Why will my fluid domain only bake once?

This is because your setup is a bit weird.

First, make sure the fluid objects are enough large to be initialized as fluid volumes. To do so, you can Tab to edit mode and scale it Z, to have more volume at the beginning of the simulation. Beware to move the volume inside the domain, since the volume beyond the domain won't be computed. A good idea here would be to reset origin of both fluid objects to their respective centers.

Then, your obstacle object is not well configured:

Set the Volume initialization setting to Both because it contains both concave and convex surfaces.
It does not contain enough subdivisions, so the simulation is not so much accurate. You should add more edges to the height of the obstacle object (Tab to edit mode, then Ctrl + R over an edge, then mouse scroll to add more subdivs.)
You should also Recalculate the entire mesh's normals. (In Edit Mode, A to select all, then Ctrl + N)
As a side note, you added a Collision physics modifier for your obstacle object, which is useless here (even if it doesn't affect the fluid sim).

The amount of memory required for the simulation depends on the resolution you specify, for Final: (used for render) and for Preview:. The more resolution you give, the more memory the bake will take.

There is no "free bake" button, but you can specify the directory where Blender will store the simulation data (in the domain's Fluid dropdown, file browser at the bottom). By the way, if you re-click on the Bake button, it will erase the previous baked data while the simulation compute.


How do I add a sound to the start of my game?

I'm fairly new to the game engine, but I was able to work this out so I will add my solution.
 Add a sensor and set to always>once, and then add a controller. The controller will be be an and controller. Finally, an actuator, which will hold the sound file. Set it to Sound>sound and the mode should be Play stop.

This should work with a speaker or empty as well as a mesh object if you prefer, I tested on a uv sphere with the shortest sound I could find on my PC, and it works. It will play once only upon pressing P.

Your logic bricks will look something like this:


Sadly this feature will most likely never make it into the official release of blender.

As CoDEmanX said,

  It's not possible to implement it well in Python, as custom layer data propagates on actions like extrusion. So if you stored the selection state of edges or faces as a property of these elements, it would be copied over to the new elements when you extrude etc.

Also it is important to notice that there are some selection difficulties that would come into play. in spite of all that, there is a proposal for such a feature, and it may become possible in the future.


Viewport render is correct while rendering scene shows materials as white

One of the objects was hidden in the view but visible in the render  , you have to uncheck the camera icon in the outliner :

the render layer didn't include all scene layers, excluding some objects from the final render, for this you have to check these layers in the render-layers tab :


why N-Gons can subdivide some times and some times no?

Going around the cube this way:

You have a continuous face loop, regardless of its ngon status, because the connecting faces just have one edge between them.

If we "unwrapped" the shape in the direction you're cutting it would look like this (I've only shown three sides)

If we went the other direction it would look something like this, with a couple extra verts:

And this is no longer a continuous face loop.  The loop cut operation will stop when it can no longer find a definite way to travel down the next face.
Looking at all the edges this cut could decide to go to:

I would say as human onlookers it's pretty clear where it should go, but programmatically (for the general case) it's probably a hard problem to solve.  The operation just stops when it can't find the next face in the loop.


Not all scenes will use 100% of the GPU, or 100% of the CPU or 100% of available Memory. Blender will use the computer resources depending on the scene's complexity. Simple scenes will not use the same resources as complicated ones.

3D rendering can be a very complex and resource hungry task, but a wide variety of factors determine render time and computer usage: The number of polygons and subdivisions, types of shaders, modifiers, number of textures, texture size, use of volumetrics, particles or physics simulations, the number of samples, bounces, the size of the rendered tiles, amount and speed of RAM, etc, etc and blah, blah, blah... Not all operations are performed by the GPU so even when rendering on GPU you'll have to wait for the CPU to complete certain processes.

Again, depending on the scene, cutting render time by one half might just be unrealistic. To render in almost half the time, the most viable solution is using two GPUs instead of one...

Finding the optimal settings for your system is a trial and error process. What works on one scene might not work for others. Test different tile sizes (start around 256x256 and see how that goes), play with the number of samples and options in path tracing, simplify, optimize, decimate, bake, use all possible tricks to keep things to your liking, with tolerable noise and within realistic rendering times.

In short: There is no one-size-fits-all solution when it comes to cutting render time.


Move pivot to bottom or top of object/selection

If you need to move the origin to the bottom, you would need to move it down by the distance it is higher than the lowest point, so you could do:

import bpy
from mathutils import Vector

o = bpy.context.object
d = o.data
m = o.matrix_world

lowest = min((m @ v.co)[2] for v in d.vertices)
difference = Vector((0,0,o.location.z - lowest))
local_difference = difference @ m
for v in d.vertices:
    v.co += local_difference
m.translation -= difference


Filling in Grease Pencil Shapes via Python Script

bpy.data.grease_pencil["GPencil.001"].palettes["GP_Palette"].colors["Color.002"].fill_alpha = 0.6

-should do the trick.
Hover the mouse of the Fill -> Opacity slider in the properties panel(N)
and take a look at the command that shows in the popup. Change the names
of the "GPencil.001" and the "Color.002" to the ones that the command is pointing
to(the ones you are using).


Automate the rotation of camera around an object with python

Try using Python Scripting. The following script rotates the camera from initial position
X: 7m
Y: 1m
Z: 1m
Rotation_Z = 90 degrees (a.k.a cam.rotation_euler[2])

upto 90 degrees and captures num_steps frames. Change it to 360 for a complete view. R describes the distance from the target object (The Default Cube in my case). The radius_range contains all the radii to rotate in.
import bpy
import os
from math import *
from mathutils import *

#set your own target here
target = bpy.data.objects['Cube']
cam = bpy.data.objects['Camera']
t_loc_x = target.location.x
t_loc_y = target.location.y
cam_loc_x = cam.location.x
cam_loc_y = cam.location.y
# The different radii range
radius_range = range(3,9)

R = (target.location.xy-cam.location.xy).length # Radius

init_angle  = (1-2*bool((cam_loc_y-t_loc_y)<0))*acos((cam_loc_x-t_loc_x)/R)-2*pi*bool((cam_loc_y-t_loc_y)<0) # 8.13 degrees
target_angle = (pi/2 - init_angle) # Go 90-8 deg more
num_steps = 10 #how many rotation steps

for r in radius_range:
    for x in range(num_steps):
        alpha = init_angle + (x)*target_angle/num_steps
        cam.rotation_euler[2] = pi/2 + alpha #
        cam.location.x = t_loc_x+cos(alpha)*r
        cam.location.y = t_loc_y+sin(alpha)*r

        # Define SAVEPATH and output filename
        file = os.path.join('renders/', str(x)+'_'+ str(r)+'_'+str(round(alpha,2))+'_'+str(round(cam.location.x, 2))+'_'+str(round(cam.location.y, 2)))

        # Render
        bpy.context.scene.render.filepath = file
        bpy.ops.render.render(write_still=True)

In my, case, all cameras positions produced by this code look like

I hope it helps :)


How to cut these two objects where they meet?

Create an Empty (plane axes). This will be the mirror line.
Delete one of those "bars".
Select the other one and add a mirror modifier, and set the mirror object to the Empty.
Position the empty so that the bars are where you want them to be.
Go into edit mode and reshape the end of the bar by selecting verts and moving them. Get it to the look you want.
To turn both back into separate objects again apply the mirror modifier, go back into edit mode. Select everything with A, and press P and choose "Seperate By Loose Parts".


How to edit Parameters for an Object after it is created?

Blender does not have a construction history. You can only edit the parameters of the last action, nothing earlier than that.
To edit the parameters of the last action you can either use F9, you can go to Edit > Adjust Last Operation or open up the panel on the bottom left of the 3d Viewport.

If you want to modify the last tool you have to do it before using another tool.

In Blender 2.7x you can use F6 or the Operator Tab in the Tool Panel T to edit the parameters of the last action.


I added bones, how do I add their vertex groups

If you have done no weight painting for either the body or clothes and have the standard pose available simply parent again the armature.

It seems in newer versions of Blender it will replace the first armature the old armature is reused or deleted.  Make sure you do not get two armature modifiers.  You can also delete the armature modifier, and then parent again.

If you have done significant weight painting and want to keep those weights you can lock the current weights in the vertex groups panel.  Next parent again. I suggest you try this with an archived file if only to prevent some superstitious catastrophe.


My water simulation (preview) outline is not clear?

It looks like you just needed more lighting. The water was reflecting your black background, so thats what you see.

I just added an HDRI and it seems to look a little better.


Multiresolution modifier split face in half

Two checks:

Put the Mirror modifier on the top of other modifiers, a good sequence of using modifiers as example: Mirror -> Bevel -> Sub Division.
If the mirror modifier is on the top, make sure the clipping option is on, then move the vertices towards the middle, they will automatically merge.

Good luck!


If you're only using the Remesh modifier with the purposes of subdividing the model then the 'Subdivision Surface' modifier set to 'Simple' subdivision will probably be better.

This will subdivide the object in a similar manner to doing W> Subdivide in edit mode, but will not change the shape of the object like the default 'Subdivision Surface' modifier will:

At least on a simple test, it doesn't seem to distort the UVs and leaves them intact.


You need to invoke your script from an actuator otherwise the scene will not be updated see image at the bottom of this post.
I searched my old sources and found this very messy one that still works in BGE (today tested with Blender (2.68.5):

import sys
import time

import os
import random
import select

from math import *
import mathutils

import bge
import bpy
import math
from mathutils import Vector
from mathutils import Quaternion

def applyKinect(rot,name):
    scene = bge.logic.getCurrentScene()
    source = scene.objects
    main_arm = source.get('Armature')
    #q = Quaternion((rot.w,-rot.x,-rot.z,rot.y))
    q = Quaternion((rot.w,rot.x,rot.y,rot.z))
    main_arm.channels[ name ].rotation_quaternion = q.normalized()
    main_arm.update()
    v = rot.to_euler("XYZ")
    if name.startswith('head'):
        print("%s X:%r Y:%r Z:%r" % (name,math.degrees(v.x),math.degrees(v.y),math.degrees(v.z)))

def map():
    #print("map")
    for i in range(1, 11):
        user = bpy.nui.get_user(i)
        if not user:
            continue
        #print("Map Kinect Found User=" + str(i))
#        rot = user.hip_center[1]
#        applyKinect( rot, 'hip_center' )
#        print("hip_center %r" % rot )
        #rot = user.neck[2]
        #applyKinect( rot, 'neck' )
        rot = user.head[2]
        arm = applyKinect( rot, 'head' )
        rot = user.r_shoulder[2]
        applyKinect( rot, 'shoulder_R' )
        rot = user.r_elbow[2]
        applyKinect( rot, 'elbow_R' )
        rot = user.r_wrist[2]
        applyKinect( rot, 'wrist_R' )
        rot = user.r_hand[2]
        applyKinect( rot, 'hand_R' )

        rot = user.l_shoulder[1]
        applyKinect( rot, 'shoulder_L' )
        rot = user.l_elbow[1]
        applyKinect( rot, 'elbow_L' )
        rot = user.l_wrist[1]
        applyKinect( rot, 'wrist_L' )
        rot = user.l_hand[1]
        applyKinect( rot, 'hand_L' )

def dump(ctx, obj, level=0):
    for attr in dir(obj):
       print( "%s.%s = %s" % (ctx, attr, getattr(obj, attr)))

map()
#test()

I used quaternions (note that you can convert your euler angles to a quaternion using the methods from mathutils).

The data is provided by an addon (and polled by bpy.nui.get_user(i)), the script is executed with a logic block like this:


Under the Overlays popover in the 3D View header turn on Outline Selected.


Storing a python list as a scene variable

Storing a list as an ID property

# assign a list
>>> C.scene["mylist"] = [1, 1, 1, 1, 1, 1]
>>> C.scene['mylist']
<bpy id property array [6]>
# save file, reopen
>>> C.scene['mylist'].to_list()
[1, 1, 1, 1, 1, 1]

This will work for lists where all items are of the same type: strings, ints,  floats or booleans (booleans as ints).

Could try using your methods above as getters / setters  ... but I don't think get is available for bpy.props.CollectionProperty.


It is called Dupligroup. After assigning a group to an object/s, add an empty and go to the object properties. Under duplication you will find a group option, enable it and then select the group. Every object in the group (and others added later) will be duplicated around the empty.


Applying Location Moves Object Origin to World Origin

This behavior is exactly what "apply location" is supposed to do.  Maybe you need a new question that explains the behavior you want and asks what workflow will accomplish it.


How to insert a reference picture in 2d animation

You need to switch form Draw Mode to Object Mode

Then select the camera in the outliner.

In the properties window's settings for the camera you can add a "Camera Background Image".

Once the image is loaded you can use it as reference in the background.

(or you can also choose to add an Image Reference object or an Image Background object in the 3d Viewport, but those images will not be tied to the camera.)

To go back to Draw mode, select the Stroke object in the Outliner and go back to Draw mode in the 3D Viewport.

Keep in mind that Camera Background and reference images will not be rendered.


How to model a dress shirt collar such as the one found in zootopia?

I think that the following topology works, tell me if it's ok (I used a Solidify modifier at the end to give it thickness):


Exporting artefacts with high detail trimsheet w/ booleans

I appear to have solved the issue by adding a 'Triangulate' to the end of the modifier stack of any erroneous models. From what I understand every other program is free to triangulate how it wishes, which can be at odds with Blender expectations.
Doesn't seem to have affected how anything looks, I hope this helps someone!


unable to edit hair with brush in particle edit mode

The problem is solved by going to Options and setting Editing Type to Particles


Why im getting single verts when separate selected

You've applied the modifier, so now you have one object, and inside this object you have several meshes that compose your different small cabins.

If each of your cabin is made of one mesh, in Edit mode, select all and separate with P > By Loose Parts and you will have 12 different objects.

If each of your cabin is made of several meshes,  in Edit mode, select each object and P > Selection.


How to enable other passes on background layer?

In the View Layer Properties tab you can see all the render passes availables.


how do I get blender to stop rounding up my dimensions?

By default blender uses metric measurement system with Unit System set to None and rounding to 3 decimal places wich best suited for real world objects:

If you using Impereal Unit System rounding wich default to Feet rounding can be from 0 to 3 decimal places. This can be inconvenient when manipulating with a gizmo.

In this case, you can use Length in Thou wich meant "Thousandth of an inch":

For more complex cases: work with micro or macro objects - suitable overriding of Unit Scale:


prevent z-fighting between billboard particles?

If you would like to avoid Z-fighting you'll need to give your object at lest a small amount of difference in the location for every axis.

I would suggest to slightly increase the Velocity towards the Normal direction (e.g from 0 to 0.01) in order to not alter the overall look of the scene substantially, but at the same time, as each particle raise at different time, you'll have a variable distribution of particle location toward the camera.


in the render tab under geometry settings. render px is probably what you need


First change image source from Movie to Single Image or Image Sequence.

In Texture viewport shading mode, image texture for displaying must be active at Node Editor.

Just click on it and it should be appeared.


The zip contains many add-ons, in this case the Install From File feature in User Preferences won't do the right thing. The zip on github isn't intended to be used with Install from File directly. Blender will unpack the content of that zip to a folder inside your addons folder, called Blender Addons-master.

Solution

First you should extract the zip to somewhere on your local disk, then use the Install from File option to navigate to that directory and pick the add-on you wish to install.

You know an add-on was added to Blender's collection when straight away after that procedure the add-on is shown in the panel -- waiting for you to enable it (it will be unticked until you do).

edit

One might more accurately describe that collection of add-ons as a collection of add-ons and scripts. Some of the Python files in the collection can't be installed as add-ons. Blender expects scripters to add a bl_info description to their code if they want to make the script available as an add-on for installation. Without bl_info Blender won't be recognized them. Scripts that don't have a bl_info can usually be run from Blender's text-editor, and they may or may not have any UI.


Adding a texture map to a beveled curve or path

Yes, you can. Just simply toggle the Use UV for mapping option in Properties Editor > Object Data Tab > Texture space panel.

For BI render

In order to use UV coordinate, you have to convert the curve object into a mesh object to store UV (AltC > 2). Just besure to have that optio toggled, which will automatically generate a neat UV (named Orco by default). and set Texture coornidate to UV:

If you don't want to convert the curve object into a mesh, for regular use, you have a nice option, by using Generated coodinate instead for texture:

For Cycles Render:

After toggling Use UV for mapping option, you can immidiately see the automatic Orco UV in 3D View, Cycles will by default use UV coordinate for both curve and mesh:


How do I select Edit Mode after I imported an SVG into Blender 2.79b?

After importing the SVG you need to right click it in 3D view or left click it in Outliner. Then you will be able to Tab into Edit Mode without issues.


In 2.92 how do I show the 3D cursor in 2D drawing mode?

You need to go to Viewport Overlays > 3D Cursor


How can I make and animate a laser beam looking like an HOURGLASS in blender?

I may have accidentally made what you wanted (maybe). Please correct me if something isn't right:

So I emit particles from the vertices of a circular ngon (so that the particles collide immediately with the edges of the tube).
And the tube is a collider that has a little bit of stickiness, friction and dampening that luckily seems to make the particles to flow nicely outwards as well.
That's about it.

To do this in Blender 2.79:

Add particle system to the green 'emitter' object. Put Lifetime to 250 and Emit from 'Verts':

For the 'hourglass' object, put collision and Stickiness: 2 - Particle Damping: 0.2 - Particle Friction: 0.2:

You can also go to the particle settings and in Render panel set the particles to be the 'Icosphere' object:

Here are the objects as .blend:


If I press Shift + D to duplicate an object will it always be just one copy?

A duplicate will be created every time you press Shift + D and right or left click the mouse button.

If you only press Shift+D multiple times, but only click the mouse once, only one duplicate will be made.

If you're in Object Mode, then you can just right click each one as you said.

If you're in Edit Mode then right click to select one of the vertices and press Ctrl + L.  This will select all the geometry connected to that vertex.  Since none of the duplicates are connected, it will select each duplicated instance:


Monotone/ desaturated reflection material in Blender/ Cycles

You can use the Light Path node in your colored object's material.
Then, the object's reflections will be monochromatic.

Connect the Is Reflection Ray output into the FAC input of a mix shader.


Changing value of shapekeys keyblocks with a specific name for all objects inside a Blender collection

Get the collection by its name and loop over mesh objects (or others that have shape keys) in it to reach their shape keys.

import bpy

collection_name = "Collection"

collection = bpy.data.collections.get( collection_name )

if collection:
    for obj in [o for o in collection.objects if o.type == 'MESH']:
        key_block = obj.data.shape_keys.key_blocks.get( "Opened" )
        if key_block:
            key_block.value = 0


Vertices can be rotated around an axis into a "spiral" shape using the Screw modifier.

Here I start with just a plane and an empty object with plain axis:

Then, I add the Screw modifier and use the Empty object as the AxisObject (i.e. the object that the vertices will "spiral" around):

The iterations control how many revolutions the vertices will make, the screw parameter controls the distance between "rungs" of the spiral shall we say (I believe there is an engineering term for it), the steps and render steps act like a subdivision surface modifier, smoothing out the "spiral" and the angle parameter controls how many degrees in 1 iterations (i.e. with 180 degrees as the angle 2 iterations will be required to form a complete circle).

Here I have set the "spiral" to 6 iterations of angle 360 degrees with a screw measurement of 2.5 and a steps count of 256:

For this case i had to apply the modifier and then recalculate the normals so that the model now has lighter shading:

You can use this modifier with many different shapes to create various end results, I suggest experimentation to find the optimal shape for what you want to achieve.


How to build Blender as a Python module?

Here it is pulled from the archive.is (all Ideasman42 cited):

Overview

The official blender.org embeds a Python interpreter (CPython 3.x). This makes sense from the perspective of a user, who's primary needs are to have an application which can be extended with scripts.

However from the perspective of a Python developer, it can be useful to being Blender into your existing scripts and access its feature set.

The option to build Blender as a Python module is not officially supported, in the sense Blender.org isn't distributing it along with regular releases, Currently, its a build option you can enable, for your own use.

Rationale

This is a build option to be able to import blender into python and access its modules

Possible uses include:

rendering animations.
image processing using Blender's compositor.
video editing (using Blender's sequencer).
importers, exporters (convert 3D file formats).
development, accessing bpy from Python IDE's and debugging tools for example.
automation.

This is mainly limited to features which can be usable in background mode, so you cant for instance do OpenGL preview renders.

Prerequisites

OSX

get Python3.6-Framework from Python.org and install it.

Building

Assuming you have a CMake out-of-source build setup, see: http://wiki.blender.org/index.php/Dev:Doc/Building_Blender/Linux/Ubuntu/CMake

Change these CMake options from the defaults:

WITH_PYTHON_INSTALL=OFF
WITH_PLAYER=OFF
WITH_PYTHON_MODULE=ON

Everything should build as normal except in the cmake directory you will have ./bin/bpy.so instead of ./bin/blender

Installation

Linux

System Wide Install

You may want install the module to the systems Python path, eg:

/usr/lib/python3.6/site-packages

For a system wide installation:

WITH_INSTALL_PORTABLE=OFF

note, PYTHON_SITE_PACKAGES will be used as the target path, but this is auto detected, nevertheless, you may want to modify.

Once these optiosn are set, run:

make install

Local Install

Alternately you might want to use your user Python path (see https://www.python.org/dev/peps/pep-0370/)

$HOME/.local/lib/python3.6/site-packages

For a local install use the following options:

WITH_INSTALL_PORTABLE=ON
CMAKE_INSTALL_PREFIX=$HOME/.local/lib/python3.6/site-packages

Once these optiosn are set, run:

make install

Windows

copy bin\bpy.pyd C:\Python36\Lib\site-packages\
copy bin\*.dll C:\Python36\Lib\site-packages\
del C:\Python36\Lib\site-packages\python36.dll
xcopy /E bin\2.79 C:\Python36\

OSX

After compiling and "make install", copy needed files to your python framework

cp ./bin/bpy.so
/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/
cp -R ./bin/2.79
/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/

Note. Unlike on *nix C:\Python36\2.79 is not in the site packages, this is because of a difference in how Windows finds the scripts path and should eventually be fixed.

Testing

This allows 'bpy' to be imported from python or other applications/IDE's which embed python, eg:

python -c "import bpy ; bpy.ops.render.render(write_still=True)"

This runs in background mode and has similar restrictions to running a script:

blender --background --python test.py

Troubleshooting

The Python version requirements are the same with building a regular blender binary (if Blender us using Python3.6 then there is NO WAY to use another version - 2.7/3.2/3.6 will all fail).

On Windows, you probably won't want to use a debug build, since this requires a debug python installation (python36_d.dll rather then python36.dll), so while it can be made to work, its more trouble.


Texture Painting Not Appearing In Render Mode

Figured it out. Needed to save the painted texture as a new image


What happened to OpenGL render? Why has EEVEE been so slow at files?

This confused me for awhile. You can still get the viewport render, it is just not located where it used to be. Go To 3D Space > View and Select "Render Sequence Animation". It operates like the old OGL used to, and can be good for playblasts and what not.


Text Properties > Geometry > Extrude

To use Text object in boolean operation you would have to Convert to Mesh


In free version you must remove archipack parameters using python console.
Take a look at custom properties in mesh tab, you'll find the name of the property to remove. (for wall it is archipack_wall2)

Select your wall, then in python interactive console, enter

C.active_object.data.archipack_wall2.clear()


How to export a .FBX file　without any extra things ( and Import it in Unity)?

Select the meshes you want to export and make sure to tick "Selected Objects" in the export window


Camera Data "View Vector" Interpretation

The View Vector is in Camera space, but the Normal is in World space.

You need to transform one of the vectors to the other space if you need to compare them. I learned this now so I mark this question as helpful.

But this can apparently be simplified using the Incoming socket on the Geometry node. Incoming points towards the camera instead of from Camera towards geometry so the Absolute math node becomes redundant.


You can use inset for this.
Start with the outer dimensions of your plane.
Mine is 7 x 7

Press i and type in the offset you need (in my case its 1 unit, so I end up with a inner square of 6x6 units.

Make sure Offset Even is checked in the bottom left corner.


Where is the option for grease pencil convert to curve 2.78a

This function is not in the properties panel (N) but in the tools panel (T). Open it up and scroll down to the Grease Pencil tab on the left. At the bottom of the Grease Pencil panel you can find Convert to Geometry.... Click it and you can choose whether you want to convert it to a polygon curve, a path or a bezier curve.


No objects or images found to bake to... again

Baking started to work when I set Duplication to None (in Properties -> Object tab).


strech animation faster / slower in parts

If you select your path and go to the path object data tab form the properties pane, scroll down to path animation, there's the property frames which you can animate (hover and press i) to increase or decrease the amount of frames required to traverse the path at any given time.
So for example, if the value is at 100 at first, but starting from frame 50 you want the movement to be slower until frame 100, then at frame 50 you would create a keyframe (still at value 100), at frame 100 you would create another keyframe with value 150 for example.


Is there any way to insert f-curves keyframes by script?

You can find the data paths by right-clicking on the property and choosing 'Copy Data Path'. This gives you something like pose.bones["Bone.001"].rotation_euler.

With those you can call keyframe_insert directly on the armature object:

for ai in range(3):
    armature.keyframe_insert('pose.bones["Bone.001"].rotation_euler', ai)

This creates a keyframe for array indices 0, 1, and 2, for X, Y, and Z angles. If you want to use Quaternions, make sure you also use array index 4.

The keyframe_insert function will create a keyframe with the current value of the property (in this case the rotation); if you want to store another value, first change the property itself. You can also pass frame=f if you want to store the current value at a different frame.

By calling bpy.data.actions.new(name = 'Test') you always create a new action, which may not be what you want. Calling keyframe_insert directly on the armature will automatically create a new action if needed, so that's quite handy.

For more info, see the documentation for keyframe_insert.


Creating a smooth surface from huge number of vertices

A solution is to use meshlab to generate a surface then import the stl into blender. This is how the image below was generated from the .ply file.

Detailed Steps

Open Meshlab (get from http://meshlab.sourceforge.net/ )
Import the .ply file (File>Import Mesh ...)
Select all points ( Filers>Selection>Select all )
Compute normal ( Filters>Normals, Curvature, and Orientation> Compute normal for point set)
Create a surfaces ( Filters>Remeshing, Simplification, and Reconstruction>Surface Reconstruction: Poisson )
Export Mesh as an .stl file ( File>Export Mesh... )
Import the .stl into Blender.

You should be able to automate the meshlab step using scripts. See http://www.andrewhazelden.com/blog/2012/04/automate-your-meshlab-workflow-with-mlx-filter-scripts/ .
 You can automate the process from within Blender using Python to call the meshlab scripts.

A tutorial on this is at http://fabacademy.org/archives/2014/tutorials/pointcloudToSTL.html


The Clamp node is available in Blender 2.81


Realistic plane glass outdoor scene with cycles and hdri

Here, try this setup. I'm posting pictures of the same setup in both EEVEE and Cycles so you can see that the shadow is in the same place, just much more pronounced in eevee.
Here is EEVEE:

Now the same thing in Cycles:

You can see the shadow is there, just a bit muted. I could have played with the settings a bit more. I had to up the brightness of the spot light to make it stand out properly, and I have a rather bright light inside the building, which could be adjusted to make things look better. For the record, The glass in my picture is a separate object (plane), extruded to be 0.01m thick. Here is the final render (low sample - not de-noised). I think it at least shows the shadow, reflection, refraction and specular lighting. To make it look more like "clear glass", you can try increasing the fresnel value, or adjust the slider on the mix shader controlling the mix with the Transparent BSDF, or both. See what works best.
Rendered image (Cycles):


I can now answer my own question.  The mhx2 importer DOES install and enable under Blender 2.79.  What threw me off is that A: the error message I've quoted in my original question still appears when it's enabled, and B: the mhx2  file import no longer appears in the Import/Export dialogue where I expected to find it.  Instead, it is in an (apparently) new "mhx2 runtime" tool tab.  "Import MHX2" is now found in this tool tab.


Press Ctrl-Up Arrow (Cursor up) while the mouse pointer is in the viewport.

This wouldn't remove the main toolbar but is reversible by Ctrl-Down Arrow (Cursor Down).

You could get rid of the OS/Window-Manager decorations using Menu: Toggle Fullscreen Alt-F11.

What you (probably) want is this:

Select 3D View Full and drag the main menu away.

From python you can select a manually prepared screen layout (save in the .blend) by:

bpy.context.window.screen = bpy.data.screens['screen_name']


How to extend an Image from side to side softening the hard edge of image

You can blend the edges outwards by manipulating the texture coordinates to stretch out the image at each edge. To achieve this you can use an RGB Curves node to set the profile of the Red channel (X) to bend out the edges as follows :

To create the curve, disable clipping (click the round dot button and click the 'Use Clipping' button to disable it), create 4 additional control points, and set the 6 control points (by clicking each point in turn and typing the coordinates into the X and Y fields) to the following values :

-0.5, 0.0
0.08, 0.08
0.09, 0.09
0.91, 0.91
0.92, 0.92
1.5, 1.0

This will produce a curve that is straight in the middle section (resulting in no distortion in the middle of the image) and which flatterns at the ends (which will spread the extremeties outwards).

Note : Move points 2,3,4,5 closer to or further from the corners to blend less/more of each edge of the image. eg, moving point 2 to 0.04,0.04 and point 3 to 0.05,0.05 will blend less of the leftmost edge - the closer these points get to zero the less of the image edge will be blended. Similar for points 4 and 5 but the closer they are to 1.0. Moving points 1 and 6 closer in will reduce the extent of the blending.

Note the Mapping node to adjust the coordinates to add an additional 0.25 at the start and end of the Generated coordinate range.

This will spread the edges as shown :

This can be further manipulated using Maths nodes to 'curve' the edges with a Cosine operator and to fade out the edges as shown :

This can produce the following result :

This could potentially be enhanced by including noise in the blended section and/or the cosine to make it less uniform if desired.

Blend file attached


Why is this line appearing across my procedural material?

Usually, its not necessary to do UV unwrap for procedural textures. Try setting the texture coordinate node to OBJECT and see if it still shows that trace.
Edit : I downloaded your Blend file, but there is no line appearing in the viewport.
Not even in the render (Cycles) :

(The light is a bit weird btw)


Glossy materials not rendering correctly

You need something to reflect.
Currently you have white plane on the ground and grey sky. That is exactly what your material reflects.

You need to add enviroment map or sky texture.


how to create a Pop up dialog and link the property to an object

There are a few things to know, some of which are Python specific.

Firstly, text probably won't exist anymore by the time you call execute() because text is merely a local variable, not a class member. To make it a class member, simply declare it as self.text = bpy.props.StringProperty(name="Name", default=""). If you're familiar with C++ or C#, self is almost exactly the same as this.

Secondly, you probably want that declaration in a constructor for that class. The Python constructor is __init__(self) (it has two underscores before 'init' and two underscores after) which you declare the same as any other class method. Put code there that you want to run when an instance of the class is created, just like any other constructor.

Thirdly, I'm assuming that when you call bpy.props.StringProperty(name="Name", default="") it returns the text that gets typed into the dialog. If so, it should be as simple as bpy.data.objects['Cube'].name = self.text


Using Array modifier, is it possible to gradually increase the offset?

You can control the density of the sticks around the curve by using DupliFrames, and adjusting the 'speed' the stick 'travels' around the curve.

Starting with a curve and a stick, all origins at 0:
(Here, we're arranging 120 sticks)

Assign a 'Follow Path' constraint to the stick, with the curve as its path. Do not hit the 'Animate Path' button.
Set the stick's 'Duplication' method to 'Frames' with the Start at 1 and the End at 120.
Adjust the curve's 'Path Animation' > 'Frames' to 120.
Right-click, and insert keyframes on the constraint's 'Offset' field: 0 at frame 0, 120 at frame 120.
With that field active, open a graph editor window to see the F-curve of its animation.

You can now control the density of the sticks by altering the F-curve. I changed the end-keys (V) to 'Vector' type to begin with, to start with a straight line and even distribution. I then inserted 'Vector' keys at frames 30 and 90, converted them to 'Automatic', and rotated them a bit to get the distribution shown.

The illustration shows: The result from above, The F-Curve,  all the relevant panels, and the timeline.


How can I display a FloatVector without it being editable by the user?

Read only property

I passed in only a get() function to the parameter constructor to make
a read-only result, but now I can’t set the values via code.

Confused as to why you think cannot just set the value of a read only property in the get method.
Silly example, in the main thread sets the value of _booble_gooble to (1, 2, 3)  This  value is used by the float property getter.
This way you have a truly read only property, not one that is being masked in the UI, but possibly available to alter in the custom properties.
import bpy
from bpy.props import FloatVectorProperty
from random import random

_booble_gooble = (random(), random(), random())

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        layout = self.layout

        scene = context.scene

        col = layout.column()
        col.prop(scene, "read_only_float")

def random_value(self):
    # self is scene
    return _booble_gooble

def register():
    bpy.types.Scene.read_only_float = FloatVectorProperty(get=random_value)
    bpy.utils.register_class(HelloWorldPanel)

def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)

if __name__ == "__main__":
    _booble_gooble = (1, 2, 3) # set it
    register()


How to find image usage? Outliner / Data API / Images

These are possibly two different questions :).

To unpack an image, go to Image Editor and click the Unpack icon.
To remove unused images, select all and RMB > Clear Fake User.
All unused images will be removed after reopening your .blend file.
Only images that are currently in use will stay in the .blend file.

Unpacking a file

Removing images not in use


Properly export blender scene with materials format to three.js scene

As of October 2018, glTF 2.0 supports three material types: metal/rough PBR, spec/gloss PBR, and unlit/shadeless.

We are working on adding support for the Principled BSDF node to the Khronos Group Blender exporter. That work is in progress, and happening in a new repository (https://github.com/KhronosGroup/glTF-Blender-IO) which includes both an importer and an exporter. I'd recommend trying that for now. Note that some inputs to the Principled BSDF node (like anisotropy) are not currently part of glTF's metal/rough PBR definition, and will be ignored.

Other material types may be more or less difficult to convert into one of the supported glTF materials.


outliner : to cycle the find result in outliner

Not exactly a 'Find Next' .. but there's a dropdown next to the Filter checkboxes which can restrict the outliner display, to, among others, only selected objects.
I've assigned that dropdown to the Numpad / key, analagous to isolating in the 3D view. 'Selected' restricts the outliner view to (all) references to objects selected in the viewport.


Your source file may have variable frame rate. You can use MediaInfo to check: https://mediaarea.net/en/MediaInfo
If it has VFR you'll need to re-encode it with ex. Handbreake or any other GUI for ffmpeg: https://handbrake.fr/


Do I have to download a model to create a human being?

Makehuman is indeed an excellent tool.
To answer the second part of your question, and complete the precedent answer, concerning animation, you can import the model into blender by activating the mxh import plugin https://thomasmakehuman.wordpress.com/mhx2-documentation/import-into-blender/
Then, you can import .bhv mocap datas founded on the net (a lot of free ressources are availables) :

mocap.web.fh-koeln.de/webgl-search.php

(I can't put more than 2 links on this site because of my reputation wich is still too low, but a google search will do the job)

You then need to add the addon called MakeWalk, wich you can find on the makehuman site (same pb with the url, but you can find it on the thomasmakehuman site already listed). This will allow you to load and retarget your downloaded bhv files.


What's the difference between addons, plugins and builds?

Add-ons (also spelt addons) are python scripts that can be used just by "installing" them (which literally just copies it into the right folder).

As far as I know, there is no such thing as a plug-in (or plugin) for blender, but it's a common term that's sometimes used instead of add-on, but means the same thing.

Builds are needed when there are actual changes to blender's source code (not just something like an add-on you can plug in ;) ). Often blender's python API doesn't give you enough access to perform the function you need, or is too slow, and thus you need to implement the function directly in the source code and re-compile blender. Compiling blender can be a bit of a bitch, so the dev (or some smart person) will compile it for you and upload the new compiled code (the 'build') somewhere for regular humans to use (graphicall.org usually)

Some more info:

Quick overview and introduction to the python API
A bit more in-depth overview of the Python API
Where to get add-ons
Docs for building blender yourself: Windows, Linux, Mac


You are using Blender Render.

To be able to use Attribute node you will need to switch to Cycles Render.

Here are differences between them: How is Cycles different from Blender Internal?


The Bevel is not normally applied to a specific edge of the connected edge with Subdivision surface

This happens because there are two large n-gons, and the Subdivision Modifier doesn't like it.
Just cut them into quads, and everything will be fine.

Connect vertices to make quads.
Vertex > Connect Vertex Path
Shortcut: J

Compared results:


Where is the options menu for Convert mesh to Grease Pencil?

If I'm understanding you correctly, you know the first step, which is how to convert to grease pencil, but not how to access the options.

To get the options you listed, look for a little box in the bottom corner that says "Convert to" after you perform the convert operation (it may be collapsed at first - just click on it to open and access the options)


Duplicating objects for modeling buildings

You can use Block Modeling, first of all you need to be precise with the measurement, so I suggest you activate Snap and leave it on Increment, so that it uses the chosen unit for moving stuff in the next steps and to do all this in Orthographic View. Create blocks like the one in the picture that represent the basic elements you need to build your building, just make sure they have the same height and width (see picture below).

Now let's take a look at the Properties Panel: in the section shown in the picture below there are all the option that have to do with the actual geometric data of the selected object. If you click on the button on the right where there is the name of the geometric data (third picture) you can see the list of all geometric data you have in your scene and you can change the one regarding the selected object (in this case I renamed them for clarity so that the object's name matches its geometric data).

For example, if I select the Window Block in my viewport and change its geometric data to "Door Block" it actually transforms into a door block identical to the original one. Now they have the same geometric data so if you modify one the other gets modified too (which can be a downside depending of what you want to achieve).

So now with only just three different blocks you can create the base for any building you want by just copying one of the block (Shift+D), placing it where you want and changing its geometric data eventually. Keep in mind that doing this will results in a very long list of objects in the outliner so when you're done building and you are sure that they are placed correctly(see picture below) ,you can select every block and join them, but beware that this will result in overlapping faces where the blocks touch each other so you have to select everything in edit mode and click "Remove Doubles" (now called "Merge by Distance" in 2.8) on the Tool Shelf, and probably remove redundant geometry where is not needed anymore.

In no time you can already have something like this, and you can apply this method also when you create windows, doors, etc.


Just for fun, you can also get good results with Cycles.

Glass shader with IOR = 1,6 (same as Crown glass used in microscopes)
And a rather simple microscope setup.

Original image with a tiny Suzanne

Magnified using a microscope

Diagram of used setup

Notes:
Cycles, 100 samples + Intel Denoiser
I'm sure better results can be achieved by playing with the lens setup.
Bottom line, it works :).


Okay so with some help from Mr Zak, I found the solution to this problem.

So for anyone wondering, I was needing this for a 3D printing type animation.
Anyway, start with your curve and some objects.

Add the "Follow Path" constraint and in select your curve for the target.
To animate, go to your first frame and keyframe the "Offset:" to -100 (this may be different for some curves but this works for most). Then go to the last frame and keyframe the "Offset:" to 0 (if these values don't work, just drag the offset value until it looks right).

The cubish object in the picture just follows around the curve (for you 3D printers, it's the extruder).

The two cylinders just move forward and back with the cube (this just achieves the look of the cube moving left and right and the bars moving forward and back).

For the object you want moving only on one axis, do the same as before but add a "Limit Location" constraint after the "Follow Path" constraint.

If you want it on one axis, check the "Minimum" and "Maximum" boxes for the desired axis. If you follow the instructions up to this point, then it won't change it's position on that axis while it moves. Here's a gif showing what mine looks like


how to increase the size of the pivot in blender 2.8

You must be talking about the gizmo. In that case, Preferences > Viewport > Display > Gizmo Size.


Method from here: How to Straighten Curved UVs into Straight Belt is working just fine, but you have some errors in your model (Interior Faces).

In Edit Mode:

Select > All by Trait > Interior Faces.
X > Only Faces.

This is how to repair your mesh. Now you can use linked method to UV Unwrap it without problem.


The triangle on the top of an active camera is full yellow. The camera you've selected is not the active one, actually when you press 0 you switch to the current active one, and when you press CtrlAlt0 you just move the active one to the current view. To make a camera active, select it and press Ctrl0. Then, next time, you can use 0.


How Can I Select All Inner Faces of a Current Selection of Faces?

It's not one operation, but it is quick, and Blenderish, (no faffing with menus, no operations on things you can't see)..

H  hide the selected boundary faces...
Hover over the interior with L to pick them all up...
Alt H to bring the boundary back.


Yes, this is possible through linking objects.

In the master scene file simply go to file > link or hit Ctrl + Alt + O, choose the file you want to link an object from, go to object and select the object.  Then when you change the files containing the objects they will change in the master file.

Linked objects will be highlighted with light blue.

Something to keep in mind is that you can't edit the linked objects in the master file which makes it cumbersome to make small adjustments.


The concept of UV unwrapping is to project a curved model into a plain (in which you will paint the texture), so a quad in your model will always result in a different (distorted) quad in the texturing canvas. A lot of UV options are available to try to let the UV unwrapping being "readable": for instance you can set the front view and then select "project from view": the result will be "what you see is what you get", but - obiouvsly  - the faces you don't see (the lateral ones expecially) will be heavily distorted.

The tipical workflow for unvrapping a human head is:

modelling the mesh trying to have all quads nearly in a real quad shape (not rectangular) and nearly of the same dimensions
mark some edges as "seams", to divide the head into smaller parts which can allow seams in the texture and which will minimize the stretch of the various parts

If your are unfamiliar with theese concepts I suggest you to start unwrapping simpler models, to get used to the procedure


How can I align a new object to the camera view with Python?

Since you want to align the object with the current view (and not the camera), you need to extract that view through the view 3D's region_3d (rv3d in the example below), then assign its rotation to the object you want to align the view with:

import bpy
def view3d_find( return_area = False ):
    # returns first 3d view, normally we get from context
    for area in bpy.context.window.screen.areas:
        if area.type == 'VIEW_3D':
            v3d = area.spaces[0]
            rv3d = v3d.region_3d
            for region in area.regions:
                if region.type == 'WINDOW':
                    if return_area: return region, rv3d, v3d, area
                    return region, rv3d, v3d
    return None, None

r3d, rv3d, v3d = view3d_find()

# Add new plane which will become the context object
bpy.ops.mesh.primitive_plane_add()

bpy.context.object.rotation_euler = rv3d.view_rotation.to_euler()


Texture looks off in newer version of Blender

As we can see here:

The texture's color space is set to "Raw".
Since it's a simple color data texture and in png format, it should be "sRGB", which is the default color space when you create an image texture node.


How do I make an Icon look like glowing water in cycles?

So i got something kinda figured out that i wanted to share everyone. Not exactly how I imagined it but its good enough that i'm ok with it and think it looks good enough looking kind of watery and it glows a little bit with no lighting in the world which looks pretty cool, Although if someone has something that looks better please still post up an answer i would love to see some different takes on this.  Plus i'm going to be animating it so it appears to have water moving over the texture. just a short 8 second long animation which is why the mapping node is there. Have a great day guys and Happy Creating!!!


Make sure the object is selected and open a Dope Sheet window.

Each keyframe is represented by a diamond (white = Unselected, orange = Selected). You can use the usual tools to change the selection - eg, right-click to select a single keyframe, A for Select/Unselect All, Box Select (B), Shift for multiple select, etc. To Select all keyframes on a channel you can select one of the keyframes and then press L to select all linked keyframes on the same channel.

Select the keyframes you want to delete and press X to remove them.


Whenever I move an object a circle appears that also affects other objects

You are probably in "proportional editing object mode" in order to toggle this circle and get back to the standard handler press "O" on keyboard.


Apply Rotation on downloaded, appended eye model resets original rotation and it's driving me crazy

It has to do with your Texture Coordinate and Image Texture settings, choose the UV output socket instead of Generated and choose Flat instead of Sphere. Choosing Generated makes the pupil come back to front when you apply the rotation, which is not what you want:

Or you can put a Mapping node between these 2 nodes and play with the rotation values.


In the Viewport Overlays panel, make sure that the Weight Paint Opacity is somewhere above 0:


The UV map does not show up in the render preview, open a new image in the UV editor, or create one.


Set the Viewport Display from "Preview" to "Final".


Graphic card performance impact on baking light

10k sampling is a very bad idea, you will have to use a lower value and find the sweet spot for your render. A RTX graphics card could be used for denoising with OptiX, it's build into blender. But do not sample with 10k, the best RTX card won't be able to render magically in some minutes with this sampling value.
https://www.youtube.com/watch?v=8gSyEpt4-60&t=37s helped me a lot


Make sure you had the "Use mist" option on the particles material. You could post some file showing the problem. The image had some post process?


mathutils.Matrix behavior changed so that it expects a single argument, but the error message wasn't updated (now done)

This works as expected:

m = Matrix((matrix[0:4], matrix[4:8], matrix[8:12], matrix[12:16]))
qr = m.to_quaternion()

Mailing list thread as to why the changes was made


Dropping objects and groups with varying sizes and rotation to a floor with Python

I don't know much about Python scripting so I can't help with that part but this may help you with the workflow and concepts, then you maybe able to extrapolate hot to automate this.

Group Instances are generally created from Empty type of objects, but it doesn't have to be so, Dupligroups are the underlying feature that makes group instancing possible, and can in fact be used on any object type.

You can for example use a mesh as duplicator for a random group consisting of many other objects. It will override the "renderable geometry" of the object and replace it whatever group is being duplicated.

It also has the added benefite of allowing using physics on object types that would not support them otherwise like Bezier Curves, by assigning them to the duplicating mesh instead.

Just create any mesh object shaped as desired. If you care about detailed collision physics for complex geometries, make it so the mesh is shaped roughly as a simplified bounding volume of the group it will contain.

Add the desired curves to a new group (don't forget to set up group center, sanely placed relative to the object positions), then pick that group as Dupligroup for the previously created mesh.

You can now assign any physics desired to the mesh, virtualy looking like they are applied to the group instead.

Have in mind that in this case I made a randomly shaped mesh that has nothing to do with the underlying group shape, ideally they would roughly match.


After a bit of thinking I decided to try something different. I performed a Smart UV project and made the most important area of the mesh the largest, since this model will be low poly. I could have managed my space a little better but I think it looks okay.


Adding texture layer over stroke object (Grease Pencil)

There is a Masks section below layer list in 2.83 and later versions.
Adding new mask in here and clicking mask icon on the related layer solved the problem.


how can i keyframe on animation node properties?

you cannot animate the falloff because the falloff basically is just an array of numbers.
I think, what you wanna do is:

The timeinfo just outputs the frame number (i think you know that) and the fade falloff recalculates this to values between 0 and 10, where amount is just the step value. Of course you can use whatever falloff node you want here. So the falloff will be something like [0.1, 0.2, 0.3 ...] as you can see in the viewer.
The evaluate falloff node then just gives you the value at the index of that array.
you can try out itself in this easy example, which just moves a cube:


Snap and shrinkwrap won't keep above surface

The Shrinkwrap Modifier can only move vertices to match the target object. If there aren't many vertices in a particular area, that area will not match the target object as well as places where there are more vertices.

A simple surface will require less vertices as there are less details to match, whereas a more detailed surface (or areas of higher detail) will need more vertices.

Patches of the original object showing through are indicative of not having enough geometry, or not having placed geometry where it's needed.

By overlaying your images we can see that the places that are showing through are where some of the larger faces are. You need to either add more geometry into these areas (a guide of where you might add an edge loop is marked in red) or move edge loops that are near those areas, closer together so faces are smaller:


Can we copy UVediting colors of an object and paste it into our Layout object

One way to get meshes shaded in Solid view is to assign them materials and, in the material tab (on the right), scroll down until you see a property called "Display Color" (or something). This is the color you will see in Solid view and it is also the color your UV's will export with. You must "assign" the material to the faces you want to be that color.


BGE local position not respecting rotation

localPosition is actually the position relative to the objects parent (for the most part, see below).  If the cube has no parent, it will be the same as worldPosition.

To move forward along the local Y axis:

obj.applyMovement((0, 0.1, 0), True)

Irrelevant localPosition quirk

localPosition isn't truly relative to the parent.  It's more like... relative to the parent modified by its world position when initially parented (or something like that).  So if your parent isn't at the origin when hiting control+P, the result might be kind of weird.  Intended behavior?  No idea.


Using custom node group with Python script for Compositor

This is done by adding a node group:

group = C.scene.node_tree.nodes.new('CompositorNodeGroup')

... and then adding the custom group as new group's node tree:

group.node_tree = bpy.data.node_groups['somegroupname']


How can I select part of a mesh and make it seperate?

Splitting your mesh in to separate pieces is easy, just two steps.
First you have to select the part you want to separate.

There are many ways to select part of your mesh. Depending on how you modeled it, assigned materials, the way the geometry flows, and other factors will determine how you best select the part of the mesh.

Select Linked
Hover over the part and press L. Or select any part in the desired portion and press CtrlL. Both shortcuts are Select Linked, it selects all the connected geometry. Meaning if you have separate pieces (the teeth are not connected to the mouth) it will select that part.
Here in this gif I demonstrate the select linked tool. First by pressing L with mouse over the part I want to select, then withCtrlL.

Select by material
If you have more then one material on your mesh, you can select by material. Head over to the Material tab of the Properties window and with the correct material active (highlighted in blue) press the Select button.

"Normal" selection tools
Sometimes there will be no quick and easy way to select the part you need, then you are going to have to do it my hand. Good thing is blender has a bunch of great selection tools.
AltRMB  will select loops, edge, vertex, or face loops depending on what selection mode you are in.
CtrlAltRMB  will select rings, again edge, vertex, or face rings depending on what selection mode you are in.
A select, or deselect everything. (Sometimes it is faster to start at the opposite and work backwards.)
B Border select, draw a box around what you want selected (or deselected). Useful to be in wireframe or have Limit selection to visible turned off.
C Circle select "paint" what you want selected. Do note that you can not rotate the view while using this tool.
With one point selected, Ctrl on a second. Or with two points selected, go to the 3D view header click on Select > Shortest Path. Both will select the shortest line connecting the two points.

After you have your part selected simply press P > Selection. That will brake the selection out of the current mesh and put it in a new object (with its origin at the same location as the original's).


Is there any disadvantage to using smoke adaptive domain?

I think the only reason to have it off by default is compatibility, it was a feature added to the existing smoke simulator.

  Added a new "Adaptive Domain" setting for smoke domains: Domain resolution and size adapts to only cover areas where smoke is, so that as small domain as possible has to be calculated at a time.

To enable it when opening an old file would cause a zero sized domain breaking the existing smoke simulation cache, or at the least force existing smoke caches to need re-baking. Leaving it off allows the user to re-bake only when they decide to.


I downloaded your file and I found 2 modifiers on the cylinder. For this you did not really need modifiers. If you still want to use a Subdivision Surface modifier then, in this case, you would use the Simple mode instead of the Catmull-Clark one. Not really sure what you wanted to achieve with the Displace modifier.
It was easier to start with a new cylinder.

I deleted your old cylinder and did the following:

Added another cylinder
Rotated it 90 degrees on the Y axis.
Scaled it on the Y axis so looks a bit like the one on your image.
Entered into Edit Mode and selected Face select mode.

Selected one end of the cylinder and tapped the Delete keyboard and from popup menu selected Faces
Selected the other end and did the same delete sequence.
Re-positioned the open ended cylinder to roughly match your image.
Switched back to Object Mode
At the Tools menu clicked on the Smooth under the Shading, see below

End result below.


localOrientation on rotary inverted pendulum

I think this is the result of the conversion to Euler coordinates.

Your values are too close to the pole of the "coordinate sphere". Little precision errors have large influence on the calculation of the rotation between angles around X and Y. It behaves like a compass near one of the magnetic poles. The direction can't be determined exactly due to the near pole.

You might need a different way to determine the axis around Z. I'm not that familiar with Euler. I suggest to use a different order.


Unstretched Generated texture coordinates for Normal Mapping

You can use Object Coordinates to get a undistorted UV map without manually unwrapping the model.

Unlike the Generated coordinates which stretch to whatever size the mesh is (even if the object's scale is set to 1), object coordinates always stay square.

Here is a plane with generated coordinates.

Same plane now with object coordinates.


Generating jigsaw pieces from svg curves

Knife project curves

The main problem with your object is that the pieces are not defined by a boundary. The curves are not intersecting each other: they are just drawn lines, and expecially in the "crossroads", there is't a common point between them.

In order to get the intersection, I would suggest to take advantage of the Knife project tool to a plane object (Shift+A Add mesh: Plane) of the right size. It has some degree of approximation but should be good enough for the provided example. Remember to keep the whole mesh inside the 3D view and run the command in ortho top view as it is view dipendent.

You don't need to convert your objects to meshes or join them: just select them all and run the command in edit mode (it might take a but of time to complete).

Finish by:

calling  the Edges Split operator (you can find it in the Crtl+E menu) in order to disjoin the faces
and then finally run the Separate by Loose parts (P) command on the remaining faces.


I would make the heart shaped base, then make sure to Ctrl +  A to apply scale and rotation. Then select the surface and inset  I. You can type in the exact distance in the pop up on the lower left of the screen.
If you want to copy it to create a second object, press Shift +  D,  P, then Selected.
You can extrude that face to make a smaller heart.


The error is in the menu function itself here:

def menu_func(self, context):
    self.layout.operator(object.bl_idname, text="YMesh (.ymesh)");

it should be:

def menu_func(self, context):
    self.layout.operator(exportymesh.bl_idname, text="YMesh (.ymesh)");

the reason is, you need to pass on the name of the operator as a string to the self.layout.operator() function. The name you get by using the .idname property, but of course you need to call the idname of the right class! Your class is called exportymesh, not object.  :)

also, the execute() function in an operator needs to return a set. To indicate your operator worked, you append this as the last line in the execute function:

return {'FINISHED'}

By the way, Python doesn't need the semicolon at the end of a line. It accepts it, but it is not mandatory.


How to separate animation of materials in Blender Internal?

I've had this problem and found it's best to press the UPPER plus symbol, not the one indicated.  This will create a new material slot accessible to the object selected and one which is independent of those already there.

Back in the 3D window get into edit mode, switch to "Faces" and select those surfaces you wish to allot this new material to.

Go back to the UPPER panel (to the left of the upper plus sign) and make sure the new slot is still highlited.  If it's not, click on it.

The unnamed material will also appear in the slot next to the lower plus symbol.  Click in there (NOT on the plus sign) and give it a name.

Only when both the desired surfaces (in EDIT MODE) AND the material slot in the upper panel are highlited should you press the "Assign" button a little below.

The assign button will connect your highlited faces to the new slot.

You should see those surfaces/faces immediately react and change colour.

There should be no keyframes in the dopesheet for this new material either.  Any you do create later will only affect the new slot and  those surfaces you've just assigned to it.


Texture duplicated on opposite side of object

It seems like you've unwrapped the object with one of the "project from view" options. This means your UV map is just a flattened version of your mesh; the faces on the far side overlap the faces on the near side, and so end up bearing a reversed version of whatever image you position there.

A simple workaround is to select the faces you don't want to texture, then (in the UV editor) scale their UV mapping to 0 (S0) and tuck them away in the corner somewhere.


I am unable to preview any game play in blender

The engine is set to Blender internal. As of 2.73 P only starts the game engine when the render engine is set to Blender Game at the top of the screen:

Also note that that file was made in 2.4x. The 2.4x python api is not compatible with the 2.5x+ api, so the python scripts won't work. If you want to run that file, you can download 2.49b here.


You could create a cube and put it inside the mountain where you want the cuts to be made. Add a boolean modifier to the mountain geometry and set the object to the cube. If it doesn't look like its doing anything you can try hiding the cube you made or setting its view type to wireframe.


How to use vertex color if defined, or white otherwise?

One way is to define a material where it will use a node comparing value of vertex colors for a factor defining what socket of the next node will be used.

There are 2 cubes and 2 different materials on them (for demonstration purposes). Both cubes have vertex color layer called "Col" (default name).

The color is fed to the Math node set to Less Than which compares values on the input to its second socket (which is 0.001, almost black, color will be black if no vertex color data is present).

Then the output of that is used as a factor for the MixRGB node - the output is either 0 or 1. If factor is 0 bottom input of the MixRGB node is used, If it's 1 - then the top one.

The cube on the right has Attribute node with vertex color layer written wrongly - "Col1" and blue color is used instead of default black. You can setup any color in the bottom input of the MixRGB node.


I want to get the outside outline of a plane that is doubled up

When I was dealing with this problem, I extruded the mesh then used intersect knife, to get the faces to interact, before merging doubles and re-collapsing it to a single plane.


The Face dot it drawn at the geometric center of the vertices that make up the face. If you are using Ngons you may not see it actually anywhere inside of the face.

Another possibility is that you face dots are too small. To increase the size you can go to the theme setting in the preferences.

As you can see here the Ngons are not subdividing.


Can one render scenes in a flat LOG color space for outside grading work?

A few notes to set the stage for an answer:

LOG is not a color space. It is a way to encode data (designed to scale large dynamic range Scene Referred data to fit within containers for Display Referred formats (0 to 1)).
Proper compositing should be done using linear data, in a common color- space.
Data from cameras should be linearized first (sometimes called "de-loged"), or converted to scene referred linear value for compositing (as per previous statement).
Blender's data is already linear and using scene referred values.

Attempt to answer

Sure you could create log files, but know that log files have to be converted back to linear for proper compositing. Why work twice, and miss the opportunity to carry the full contents of the render layer created in blender?

As per statement 4. Blender already generates data in a format that is perfectly suited for compositing. Rendered images, with all of their passes (composite, Alpha, Z depth and any number of other passes you want) can be easily stored in OpenEXR multilayer files, and that way the information will never distorted or re-interpreted.

Statement no 3 and 2 carry the information for your compositing workflow

Bring those EXRs files from Blender into Resolve, and composite using Fusion (now part of Resolve). Fusion can deal correctly with linear scene referred data. The linearized (de-logged) footage from your cameras should be easy to integrate that way.

On the settings for the project use "Davinci color managed", set the timeline to use Rec709(scene). In the media tab in Resolve you can set the correct color transform for the footage. Use the "gamut" node, (or OCIO Colorspace nodes) to remove any curves (Log is a "curve") and make sure that the color primaries for gamut are set to sRGB/709.

Once the data from camera and blender is all linear, and in a common color space, you can go ahead and composite, and color grade the result.

To finish, just encode the final images to the delivery format and codec of your choice.

For more detail refer to this link: I have tried to import EXR files to Davinci Resolve with the LUT's


I've just found manual page https://docs.blender.org/api/blender_python_api_2_65_3/bpy.types.AddonPreferences.html
Problem solved.


Everything in 2.79 is essentially still available in 2.8 and more. Technically 2.8 is still in the open testing phase, but I would recommend learning it now. It doesn't take as long as one may think to figure out where everything is, and I think it's stable enough to replace 2.79. That being said, there's no shame in sticking to 2.79 for now.


Here’s one way to do it:

Start with a profile mesh for the strip:

Add a Screw modifier with 0° for the angle and a suitable number of iterations:

Add an Archemedian Spiral curve with the appropriate parameters to get the rough shape, and in the curve properties, set the Twist Method to Z-Up.

Add a Curve modifier to the strip object with the Deform Axis set to Z:

The trickiest parts of this seem to be getting the normals correct on the extruded mesh produced by the Screw modifier and getting the twist right on the curve. Checking the Calculate Order box in the Screw modifier options seemed to help with the normals, and using the Z-Up twist method for the curve produced the right twisting.


Blender includes a vrml exporter, you just need to enable it.

Unless you specifically need the vrml format you might be better off using the newer X3D exporter (X3D is the successor to vrml).

If you need to automate the export with a script you can use the export operator once the addon is enabled.

import bpy
bpy.ops.export_scene.vrml2(filepath='myscene.vrml')


How do you refresh Object Mode after quitting Edit Mode

Check if you have added Shape Keys to your model. This might have happened by accident. Shape keys allow you to define vertex location changes relative to the original model, and animate those location changes using a value slider. Kind of like recording a coordinate difference / offset. For character animation, this can be useful (search for corrective shape keys on this site).

When you add a new Key to a model in Blender, its influence parameter is set to 0.0 by default. That means, if you go back out to Object Mode, your model jumps back to its initial state. It's easier to show this in a short video:

As you can see, I'm adding the Basis Key (that's always the unaltered stage of the model) and a Key 1 to the model. I'm going to Edit Mode while Key 1 is still active, so I am defining a change within that key. When I tab back out to Object Mode, my changes disappear. But when I slide that Value Slider all the way to 1.0, my changes are back in place.

If this is your problem, Slide your Key 1 value to one, and then first create a new shape key from mix, and then remove all shape keys, while taking care that the new mixed key is the last one you delete:


Is there a hotkey for moving whole collections around?

You can select all objects in your collection.
Then move them around as one object.

Select > Select Grouped > Collection
Shortcut: Shift+G


Mesh with mirror modifier shaded differently on the other half

Seems that Custom Split Normals are causing the issue.

In the Data panel, under Geometry Data, click the Clear Custom Split Normals Data button to fix it.


In the performance panel (for either BI or Cycles), there's a Save Buffers option which will save the render to a layered EXR file in your temp directory quite often. I could be mistaken, but I think it's each time it starts a new tile.

On windows, this temp directory is located at C:\Users\[name]\AppData\Local\Temp\ by default, but will use the path specified in User Preferences > File > Temp if set.


How do I disable click-drag-click behavior in blender?

Go to User preferences, open Input tab, find 3D View > 3D View (Global) rollout.

Now scroll almost all the way down, until you find Translate (the one that uses tweak as a key-binding instead of keyboard).
Open that rollout and enable Confirm on release checkbox.


Removing doubles on imported 3DXML ngon mesh

EDIT

A better approach would be to look for the two "ripped" edges in a face that share the same geometry. (edges parallel with same mid point test or similar), and remove the edges verts from the remove doubles list.

Thanks for your help guys, The answer kinda came to me when I was creating pics to explain the situation and opened up the poly.

The trick was looking at faces with more than one double and removing them from the remove doubles operator, otherwise will end up trying to make a poly with holes, which ends up being a hole.

The following reduces vert count of building.014 from 4205 to 1258... and leaves the roof intact.

import bpy
import bmesh
context = bpy.context
obj = context.object
print("X" * 80)
bm = bmesh.new()
bm.from_mesh(obj.data)
bm.faces.ensure_lookup_table()
ignore_doubles = []
for f in bm.faces:
    verts = f.verts
    dubs = bmesh.ops.find_doubles(bm,
                                  verts=verts,
                                  dist=0.00001)
    double_verts = dubs['targetmap']
    if len(double_verts.keys()) > 1:
        for k, v in double_verts.items():
            ignore_doubles.append(v)

verts = list(set(bm.verts) - set(ignore_doubles))
bmesh.ops.remove_doubles(bm, verts=verts, dist=0.00001)

bm.to_mesh(context.object.data)


how to display an image in blender UI with python?

Easy Way

Have you looked at template_preview

tex = bpy.data.textures['.hidden']
col = layout.box().column()
col.template_preview(tex)

Hard Way

So this works, but it requires a lot of finesse to make it usable. Not figured out yet how to create a layout of a fixed size to append to the panel layout for rendering over the top of.  This code will render over the top of the properties panel, as opposed to the Panel UI element.

import bpy
import gpu
import bgl
from gpu_extras.batch import batch_for_shader

def draw():

    x1 = 0
    x2 = 200
    y1 = 0
    y2 = 200

    shader = gpu.shader.from_builtin('2D_IMAGE')
    batch = batch_for_shader(
        shader, 'TRI_FAN',
        {
            "pos": ((x1, y1), (x2, y1), (x2, y2), (x1, y2)),
            "texCoord": ((0, 0), (1, 0), (1, 1), (0, 1)),
        },
    )

    image = bpy.data.images['logo']

    if image.gl_load():
        return # an exception happened

    bgl.glActiveTexture(bgl.GL_TEXTURE0)
    bgl.glBindTexture(bgl.GL_TEXTURE_2D, image.bindcode)
    shader.bind()
    shader.uniform_int("image", 0)
    batch.draw(shader)

    image.gl_free()

handler = bpy.types.SpaceProperties.draw_handler_add(draw,(),'WINDOW','POST_PIXEL')

# then remove the handler with ...
bpy.type.SpaceProperties.draw_handler_remove(handler, 'WINDOW')


How to limit movement of a IK-chain (armature) to one plane?

The IK constraint generally ignores other constraints, so using limit constraints won't work.

However each bone has its own IK settings on their properties panel that allow you to limit rotations etc, for more information see https://docs.blender.org/manual/en/dev/rigging/armatures/posing/bone_constraints/inverse_kinematics/introduction.html#bone-ik-panel


How can I get the vector for the force that is applied to an object in the BGE?

Although it appears blender has not implemented access to an object's force, we can calculate the force using object's the mass and its change in velocity.

This equation for force relates force, time, and change in momentum. Because momentum is just mass times velocity, we can calculate the force. We can compute the change in time and the change in velocity between frames by recording initial time and velocity from the previous frame to calculate the difference with the current frame time and velocity.

Add the following script as a Module on a logic brick. It needs to be a module to save the previous time and velocity variables.

import bge, time
from mathutils import Vector

controller = bge.logic.getCurrentController()
obj = controller.owner

t = time.time()
v = Vector(obj.worldLinearVelocity)
m = obj.mass

def main():
    global t, v, m

    #compute change in time
    dt = time.time() - t
    t += dt

    #calculate change in velocity
    dv = Vector(obj.worldLinearVelocity) - v
    v += dv

    #force is change in momentum, which is velocity times mass, divided by time
    f = m * dv / dt
    print(f)

Before the monkey hits the ground, we can see the force on the z axis is around -9.2 which is the gravity of the scene and the force acting upon it.


Attribute ImageFormatSettings.file_path doesn't exist

It seems that the path you tried to use only exists in a context for UI elements, from properties_render.py:

def draw(self, context):
    layout = self.layout

    rd = context.scene.render
    image_settings = rd.image_settings
    file_format = image_settings.file_format

    layout.prop(rd, "filepath", text="")

In a script you could use something like:

bpy.data.scenes[0].render.image_settings.file_format="PNG";


Change default rotation and orientation of imported model?

Not sure if this will work but it’s worth a shoot. Manual rotate/move the object to how u want it and the press control + a and apply rotation and location


Is it possible to merge several vertices at once?

Make a selection including the vertices you want to merge, but not including other vertices which are close to one another that you don't want to merge, vertex menu CtrlV > 'Remove Doubles', adjust 'Merge Distance' in the toolbar.


How can I see a rescaled image in UV Editor?

EDIT
To tile/repeat an image in the material using the UV editor, you would need to scale up the UV map and place it manually on the image (the UV map will need to be larger than the bounds of the image). The tiling/repeated-image used as texture will be visible on the 3d viewport in material preview mode or in render preview mode.

To view the tiled the image in the UV editor. Press N to show the editor properties and in the view tab enable Repeat Image.

Old Answer (I'll keep it just to reference the comments)
Use a texture coordinate node to set the texture to use UV coordinates.
With a mapping node you can control the location rotation and scale of the texture used.

Changing the scale will allow you to repeat the texture within the UV coordinates.
Note that when you use Pont as the type, a scale of 5 means that the texture will be repeated 5 times on a given axis.
Also note that the image texture node has to be set to Repeat.

If you choose Texture as Type on the mapping node then you can repeat the texture by using values smaller than 1.0, for example a value of 0.2 will repeat the image texture 5 times.

The texture can be visualized in the Preview window for the material


Set Animation Nodes to work with animated baking

Using this answer, I can make it work via Script node (UV input is a name of UV layer to bake to):

Script itself: (Assign_img.py)

import bpy

image = bpy.data.images["Untitled"]

Object.data.uv_textures[UV].active = True
Object.data.uv_textures[UV].active_render = True

for uv_face in Object.data.uv_textures[UV].data:
    uv_face.image = image


Create a displacement map from high-res terrain to use on low-poly terrain

Alright it took me some time but I figured it out.

The end result will look better if we use plane instead of a low poly version of the terrain.

A. messed up version

B.Replace the low poly version with simple plane (keep it in the same place though)

So, with the plane selected, move the plane below the high poly version.

Select the plane and assign a material to it, the default material will do. Next go to the texture tab and create an image. Change the resolution to something you want. Also enable 32 bit float for precise displacement.

Next up, unwrap the plane (edit mode > top view > unwrap > project from view (bounds)). Make sure in the uv window you select the displacement

Next up, bake settings. Make sure you're using Blender Internal, not Cycles. Set the Bake mode to Displacement. Enable Selected to Active and set the distance to the distance between the plane and the highest point of the high poly mesh ( I just eyeballed it), 0.300 in my case.

Final Result


Amount of bevel before or after boolean modifier

This is because of Clamp Overlap. It prevents edges from sliding on top of each other and in bevel modifier it can be found under Geometry.
When you use boolean to cut away the cylinder it adds a lot more geometry to your cube and edges can't slide as far without intersecting. You can see this happening if you disable Clamp Overlap.


"bpy.context.scene.object_bases" not working in 2.80?

Appears no need for bases in 2.8  join operator override.

Testing this in python console. Have duped the default cube 3 times, the last dupe "Cube.003" is active and only object selected.

>>> C.object
bpy.data.objects['Cube.003']

>>> C.selected_objects
[bpy.data.objects['Cube.003']]

A list of all the mesh objects in scene to join

>>> obs = [o for o in C.scene.objects if o.type == 'MESH']
>>> obs
[bpy.data.objects['Cube'], bpy.data.objects['Cube.001'], bpy.data.objects['Cube.002'], bpy.data.objects['Cube.003']]

Make a context override dictionary, with only object, active_object, selected_objects, selected_editable_objects as members (possibly don't require "object")

>>> c = {}

>>> c["object"] = c["active_object"] = C.object
>>> c["selected_objects"] = c["selected_editable_objects"] = obs

Run the operator with this override

>>> bpy.ops.object.join(c)
{'FINISHED'}

Resulting scene after running.  All four cubes are joined as one "Cube.003"

>>> C.scene.objects[:]
[bpy.data.objects['Lamp'], bpy.data.objects['Camera'], bpy.data.objects['Cube.003']]

Risky look at obs since three of the objects no longer exist.

>>> obs
[<bpy_struct, Object invalid>, <bpy_struct, Object invalid>, <bpy_struct, Object invalid>, bpy.data.objects['Cube.003']]

Related

poll() failed, context incorrect? - Example: bpy.ops.view3d.background_image_add()

Scripting -- Can't figure out how to use correct contexts?

Reliable way to find out the required context for an operator?

How to find an operator's source code?


Extruding inwards without creating double faces

Press Alt + E and select Extrude Manifold.  Blender will move all the edges of your selection back while creating a new face under the lip, just like you want.


ctrlE > Un-Subdivide will give a rather good result with your topology as it's mainly quads, then you'll have to make some corrections manually (F to make a quad from two triangles)


Select your object and press altP (Clear Parent) > Clear And Keep Transformation


Posing Overlay Model Over Model Causes Clipping

If the two cubes deform in different ways, they surely have different weights. Remember that every deformation is leaded by more than a bone, if a vertex is weighted to one bone only, it moves exactly with that bone, regardeless the value of its weight.

Probably you have the same weights relatively to the head bone, but different weights relatively to some others bones (maybe shoulders and/or arms). To check this, select a vertex and search in the "N" properties panel for the "vertex weights" tab.


Yes, you can export your UV layout as an image.
Open up the UV editor and...


Setup material like this, Using emission node makes it fast:

You can get vertex color data here:

In bake options chose "Emit"


Weight Paint adding to wrong side of mesh, subtracting from active bone

This problem was solved by clearing all transformations made in pose mode and then returning to weight paint mode. I don't know what exactly was causing the problem or happening however.


I reckon you are clicking with the wrong button. Use the Right Mouse Button (often abbreviated as RMB).

The annoying target is called the 3D cursor if you are talking about this.

This fellow will act as a kind of landmark and can be moved by clicking Left Mouse Button (often abbreviated as LMB).

If this feels uncomfortable, you may remap it at the user preferences.
This may help.

Also, if you have an experience in other 3dcg softwares, such as MAYA, using remapping presets maybe useful. They are accessible at the Splash Screen.

However, I recommend you NOT to remap the mouse buttons. Blender has some wonderful mouse button shortcuts and if you innocently remap buttons, you will lose them. Besides, you will get use to them.

Finally, if you are intersting in why blender adopted this peculiar UI, I've heard that this system reduces stress on the index finger. Indeed, I find my index finger exhausted on some other 3DCG software.

Good Luck


(Animation Nodes) How can I make objects rotate to face the direction of the normals of a mesh?

Use an Object Mesh Data node to get the face data of the target object. Connect the Polygons output to an Object Instancer and create a loop subprogram that has a polygon and an object iterator. With the Mesh data node selected you can press W and choose polygons to create the loop and add another object list iterator to it.

For the subprogram, connect the object to an Object Transform Output and use a Polygon Info node to get the location and normal of each face. Connecting the polygon normal to the object rotation input will create a Direction to Rotation node that gives the direction you want. The center output will give you the location to place each instance.


You can animate Focal length in camera properties panel

Go to the first frame of you animation and insert a keyframe on the focal length, right click over the focal length and select Insert Keyframe value or press I)

Move to a different frame, change the focal length value and insert another keyframe.

Animation example


You can do this quite easily using two Simple Deform modifiers.

Add an Array modifier to your mesh.

Add a Simple Deform modifier, set to Taper.
Use Deform Factor to control it.

Add another Simple Deform modifier set to Twist.
Use Deform Angle to control it.


what i would like to know is if the devices's control panel can be
  interactively operated by the viewer like a simulation and have the
  animation respond accordingly to the controls

Yes, this is possible. Think about it like a menu with buttons. As the BGE uses 3D scenes for renderings the buttons can be anywhere in the scene.

  I would also like to know if the animation i have already created can be combined with the blender game engine

This depends on what the animations are doing. Not all features of the Blender animation system are supported.

The major difference is that you play one action per object. This means when you want to play actions (or one action) that involve several different objects you need to play these actions at each of that objects (and start them at the same time). There is no "global animation" as in Blender.

Remarks:

I strongly suggest to play around with the BGE and see how logic gets defined.


The problem with your question is that you are erroneously thinking that there are areas with lights and some without in a JPEG or other display referred image.

In reality, every single pixel is an emitter of light. As you may guess, with all of the crazy math involved in a ray tracing engine, all of that light ends up with a very complex interaction series in any image. This means that it is impossible to simulate real-world lighting without using some form of IBL.

Worse still, a JPEG is what is known as a display referred image. That is, the encoding of the image takes all of the data of a scene and maps it into the display referred range of 0.0 to 1.0. During this transition, you are losing a tremendous amount of the information in a scene.

The most ideal format for IBL is of course EXR[1]. This format permits storage of scene referred values from zero to infinity, which helps to encompass the complexity of most captured scenes.

[1] For those interested in the nerd stuff behind this statement, there is a great discussion of encoding quantization here.


Blender Python Custom Outliner tableview

The data shown in the outliner is filtered within blender's C code, the python code used to display it is rather minimal - view it here. Altering the display of the outliner will need to be implemented with C not python. code is here if you want to look.

The data you want displayed is available in the properties sidebar on the right of the 3dView (press N to show/hide it)

You can write an addon to show a customised version of this data, a sample to get you started --

bl_info = {
    'name': 'sample info display',
    'author': 'Shane',
    'version': (1, 0),
    "blender": (2, 6, 9),
    'location': 'View3D > Properties panel > Sample Info',
    'description': 'A simple panel for the 3D view properties panel to show stuff',
    "wiki_url": ""\
        "",
    "tracker_url": ""\
        "",
    'category': 'Properties'}

"""
This script simply places some properties into the 3D view Properies panel.
"""

import bpy

class SamplePanel(bpy.types.Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_label = "Sample data"

    def draw(self, context):
        layout = self.layout
        obj = context.object

        row = layout.row()
        row.column().prop(obj, "location")
        row = layout.row()
        if obj.rotation_mode == 'QUATERNION':
            row.column().prop(obj, "rotation_quaternion", text="Rotation")
        elif obj.rotation_mode == 'AXIS_ANGLE':
            row.column().prop(obj, "rotation_axis_angle", text="Rotation")
        else:
            row.column().prop(obj, "rotation_euler", text="Rotation")

def register():
    bpy.utils.register_class(SamplePanel)

def unregister():
    bpy.utils.unregister_class(SamplePanel)

if __name__ == "__main__":
    register()


Blender 2.8.2 Hair simulation - Pin hair to itself

You can try the free hairguide addon https://blenderartists.org/t/particle-hair-from-meshes-bezier-curves-nurbs/1154670 . It can create hair guides inside a mesh while following the exact direction.Then you can use bevel radius or a curve as bevel to create each braid shape.It's easy to adjust the thickness using  ALT + S.


How can you turn 2D faces into a 3D object?

At 4:30 in the video he selects all the interior faces, with circle select C. Then moves them along the X axis, G X, that gives the object thickness.
Having left the outer faces unselected, it creates a bevel which when combined with the mirror modifier he adds later will make the whole object.


Move an object on a different object's local axis?

This is a question of the coordinate system you are referring to (the space).

What spaces do we have?

Scene Space

There is the scene space (world in the BGE). The origin is the scene origin. It defines the (1,1,1) scale and the orientation of the whole scene.

Object Space

There is the object space (local in the BGE). It expresses the relativ transformation (= position, rotation, scaling) from the parent. If there is no explicit parent, the scene is the parent.

Without any transformation the object would be at the parents location, facing the same direction, and having the same scaling.

You have several different object spaces within a scene (one for each object). They can be equal, they do not need to be equal.

Other Spaces

There are more spaces (vertex space, texture space, view space, screen space ...). I want to focus on the scene and object spaces as this is what you need to deal with your situation.

Purpose

Why do we need different spaces? We do not need them. We just need one, which is valid for all participants. The different spaces are used to make things easier e.g. it is much easier move "forward" when you can add step to a single axis.

Operations in different spaces

To operate with different spaces you need to know how to convert from one space to another (e.g. from scene space to object space).

Scene space and object space are the most used spaces. You have a different use case right now. You want a -lets say- "look space". To work with it you need to find a way to convert the coordinates of one space to your "look space" and vice versa.

Luckily you can combine conversions.

Convert from scene space to look space:

referenceObject.worldTransform.inverted() * positionInSceneSpace

Convert from look space to scene space:

referenceObject.worldTransform * positionInLookSpace

Move in look space:

To move along an axis of the look space you convert the current position in scene space to coordinates in look space.

Now you can apply the motion e.g. along the x axis. All operations are in scene space.

After the change you convert the result back to scene space and apply it to the object.

Sample code:

import bge

scene = bge.logic.getCurrentScene()
referenceObject = scene.objects["ReferenceObject"]

controller = bge.logic.getCurrentController()

if all(sensor.positive for sensor in controller.sensors):
    owner = controller.owner

    # get position in scene space
    positionInSceneSpace = owner.worldPosition

    # convert to look space
    positionInLookSpace = referenceObject.worldTransform.inverted() * positionInSceneSpace

    # modify in look space
    positionInLookSpace.x += .01

    # convert to scene space
    positionInSceneSpace = referenceObject.worldTransform * positionInLookSpace

    # apply position in scene space (as the object expects it that way)
    owner.worldPosition = positionInSceneSpace

This solution considers motion, orientation and scaling of the reference object.

Operations in look space

positionInLookSpace.x += 1 moves the object 1 BU along the reference object's x axis
positionInLookSpace = mathutils.Vector((0,0,0)) sets the object at the origin of the reference object
positionInLookSpace = mathutils.Vector((1,0,0)) creates an vector that goes one BU along the referenced object's x axis. After converting it to scene space you can apply it to applyMovement().

Convert from object space

Just for information: When you want to use localPosition rather than worldPosition:

convert from object space to scene space
convert from scene space to look space
change position in look space
convert from look space to scene space
convert from scene space to object space

So you need two additional conversions. Luckily the BGE already does that for you when you use worldPosition.