Blender Git Commits

Generalization of the dynamic socket list feature, currently used by mesh-combine.

Use default node input value for constants.

BVM node for combining dupli lists.

Extended notifiers from node value editing to include instancing trees.

The use of notifiers from node trees is very unsatisfactory atm.
Notifiers should be integrated into the depsgraph, so that changes
to data automatically trigger appropriate UI redrawing.

Implementation of the "make dupli" node to generate a single dupli object.

Use a std::vector for storing Dupli instances in bvm for efficiency.

Return duplis from a bvm node evaluation, just like DerivedMesh.

Fix for default values of array types.

Now an array can be passed directly to the add_input functions to
construct an ArrayValue.

New opaque type 'DUPLIS' for storing a dupli list.

This works just like the MESH type, but wraps a ListBase instead of
a DerivedMesh. Using this type the duplis can be generated internally
and returned as a result.

All such data types should be handled in a generalized way eventually.

Correct types for array 'pass' nodes.

Reordered data types a bit, so mesh and other complex types are at the end.

Array types for node sockets.

These are an extension of the type description to support contiguous
arrays of base values. They effectively form a second set of types,
mirroring the 'single' base types. Socket connections will have to
strictly match between these types as well, i.e. any dereferencing and
array access will have to be explicit.

PASS nodes for array types.

Sqrt math node mode, patch by lichtwerk.

Removed unused function declaration.

New dupli mode for use of BVM node trees to generate duplis.

Not yet functional, as it doesn't have opcodes yet.

Object pointer should not be needed for constructing modifier node functions.

Merge branch 'master' into object_nodes

Use the bvm function cache for modifier nodes, to avoid recompiling all the time.

Separation of dependencies of node trees and their users for compiling vs. evaluation.

So far any change in a node tree would cause both a recompile of bvm functions
as well as a re-evaluation of any users of that function. This is quite inefficient
and should be separated to allow caching of the bvm functions independent from
their users.

To this end the nodes now have 2 callbacks: one for getting compile deps, the other
for getting eval deps.
* Compile dependencies are typically other node trees (node groups). In the future
this could also be Text datablocks, similar to how OSL script nodes work.
* Eval dependencies are all the blend_data blocks that a function might access.
For modifier nodes these could typically be meshes, curves; for shaders could
be images, textures; and so forth.

Separating these dependencies means the bvm functions will have to be recompiled
only when the actual bNodes change (add/remove, linking, socket values).
Conversely when some modifier input data changes (editing, cfra) the modifier
function will be re-evaluated.