Blender Git Commits

Renamed bvm_typedesc to typedesc: It's not actually specific to the bvm backend.

Restructuring: Remove the 'bvm' prefix from files that are not directly concerned with the bvm backend.

The naming here is a bit confusing: BlenVM is the name used for the overall code module. BVM can be a shorthand
for BlenVM, but is also the name of the backend for SVM-like code interpreter. General purpose code (such as
node graph and util files) should avoid the bvm prefix. BlenVM as the overall name for the code module is kept
for now, but may be replaced at a later point.

Note that currently one bad-level-include from non-bvm to bvm code remains, for the Value class used in nodes.
Values should ultimately be a backend-agnostic class for storing literal values (node inputs).

Merge branch 'master' into object_nodes

Cleanup: Moved value class into own file, away from pure type declarations.

Merge branch 'master' into object_nodes

Merge branch 'master' into object_nodes

Merge branch 'master' into object_nodes

Fix for use of TypeDesc.base_type as a plain value rather than a function call.

New buffer type 'Image' for 2-dimensional arrays.

Removed the 'Iteration' node, the main index is now an implicit variable.

Updated codegen for handling variables and expressions.

Note that kernel nodes now don't have explicit 'function' inputs
any more. Any expression input can be a separate block. Eventually
this should be handled by creating true loops, branches, etc. in the
generated code, rather than reading a jump address from the instructions
and passing it to a blackbox method as a "function pointer".

For the time being the kernel nodes simply prepend a jump address before
*every* input, using BVM_JMP_INVALID in case the input node is not in a
separate block.

Adapted the node blockify procedure to the new concept of expressions and variables.

The internal bvm nodes now can contain (implicit) cyclic connections, owing to the
connection of variable inputs to local variable outputs of kernel nodes. These link
cycles are never created explicitly by the node parser (pynodes), but are a result
of the semi-functional programming nature of the nodes: each node constitutes a
function of the local variables defined inside a kernel block. When the nodes are first
constructed from the user-level nodes these inputs are left unbound, and are then
resolved backwards as the individual node functions are inlined.

Redefinition of the meaning of "value type" for sockets (intermediate commit).

The use of "expressions" for node inputs must be generalized to support array-like
data and a level of functional programming. Inputs are now expressions *by default*.

A node can also have "variables" as inputs, which are implicitly defined in the base node
graph and should not be bounded in the first compiler step (i.e. are not defined by
pynodes). Variables instead are defined as outputs of other nodes (currently still called
"kernel" nodes), which would mostly constitute loops over such variables.

The concepts being worked on here are loosely based on those found in the Halide language
http://halide-lang.org/index.html

Merge branch 'master' into object_nodes

Mockup Nodes: Dummy pynodes for smoke and rigidbody simulations.

These have no implementation yet, they are just meant to test concepts.

Basic image sampling node for reading interpolated color values from an Image datablock.

Cleanup: Simplify depsgraph API by using the same depsnode type for each ID.

This means the user might use an invalid component key for generating dependencies,
but the only consequence is that no relation is created.

Two-level use-count system for bvm pointer variables.

The rationale for this change is that copying variables on the bvm stack
will become necessary for compound variables (structs). In order to
efficiently keep pointers on the stack without making deep copies every
time such a variable is copied, the pointer must be a kind of shared_ptr
concept. In addition to this the stack variable itself must also be counted,
so that we have a way of detecting when it "goes out of scope", i.e. all
nodes using it have finished.

The node_counted_ptr is not a full C++ shared_ptr, because the user counting
is handled explicitly by the compiled bvm instructions. Using a std::shared_ptr
would be difficult due to the mixed levels of evaluation (compile-time constants,
storing shared_ptr on the opaque stack), and because of difficult interfacing
with C code (returning persistent plain pointers).

Cleanup: use size_t (i.e. size in bytes) for data types, rather than explicit stack size.

The stack size is calculated during codegen by an int-ceil division,
currently padding to int size (probably later to be changed to int4 for
better SSE support).

Cleanup: Use an real type 'EvalStack' for passing the value stack around.

This should avoid possible confusion of values (floats) with the more
abstract value stack.