Blender Git Loki

Generate wrapper functions in LLVM for converting dual types to primitives.

Currently Dual2 arguments are structs with the main value and 2 derivatives
in x and y. Node functions will generally be implemented using the base types,
so the value and derivatives have to be extracted and later combined using
the chain rule.

Generate dual values for input constants to match the declared function signatures.

Note that actual functions currently don't use Dual2<> values, but because they
only read/write the 'value' field it works anyway ...

Fix module linking: initialize the node graph module right away to avoid repeating code.

Leave the decision about passing arguments by pointer to the compiler class too.

This removes the last "global" type function, so all the details of types are now
decided in the compiler implementation subclass.

Removed unused codegen_begin/end functions.

Define a separate node function module for every compiler type.

This means we can have differing implementations for every potential use
of nodes, such as plain value functions vs. dual values with derivatives.

Node functions for each compiler type are stored in a static map and are
lazy-initialized on the first node graph compilation.

Pass texture arguments and return values as dual values.

Currently only the value part is actually accessed. Using dual values
allows the node graph to handle input/output arguments are single a
single llvm::Value instance.

Preparatory changes for differing node compiler implementations.

Uses some virtual functions of the node compiler to allow different
implementation of values. This will be used for calculating values
and partial derivatives in texture nodes.

Use a TypeSpec pointer for structure fields rather than direct storage.

Type system refactor: Use a global type definition map instead of defining each type locally.

Merge branch 'master' into object_nodes

Cleanup: removed some unused code.

Enable the new depsgraph by default.

The blenvm system depends on the new depsgraph, so it doesn't make sense
to have to enable it every time.

The legacy depsgraph can still be switched back on by the --enable-legacy-depsgraph option.

Internal definition of commonly used node functions, so that LLVM can optimize better.

This currently includes just a few 'value' nodes, but should be extended as much as feasible.
In particular many vector functions can be split component-wise.

Implemented common procedural texture patterns for LLVM.

Include all module functions in a single header for convenience.

Simple coordinate input node for texture nodes.

Handle all node type kinds appropriately.

The LLVM backend also supports PASS nodes, even though these are usually
removed from the node graph in a preprocessing step for clarity.

ARG nodes have their output values mapped in advance, so no extra code
needs to be generated for them.

Fix incorrect argument order for vector/color constructor functions.

Replaced mix of bool type flags for node types with a single enum for special kinds of nodes.