Blender Git Commits

Merge branch 'master' into strand_editmode

Minor whitespace fix.

Added object nodes for looking up an object and transform from global data.

LLVM TypeBuilder and copy function for node_counted_ptr.

Using a DerivedMesh directly for mesh data isn't so great because
the lifetime of a DM is not necessarily known at compile time, depending
on branching. node_counted_ptr is basically a simplified shared_ptr variant.

Use a hash table to register external functions with the LLVM engine.

This will allow using BLI/BKE code for complex data types, such as DerivedMesh.

Include mesh opcode functions in modules.

Modifier functions with variable expression inputs are disabled,
until DerivedMesh handling through LLVM is implemented.

Fix graph return values: Not all value types are returned as duals.

Fix for graph function signature: use pointers also for aggregate and struct types.

Use the LLVM backend for modifier nodes.

This currently fails, because the actual mesh nodes are not yet implemented
in the LLVM backend.

Reduce repetitive code in the C API by defining static node graph signatures.

Node graph inputs/outputs are now defined statically and graph instances
can be constructed by passing these as ArrayRefs. The code for compiling
various node graph types can then be unified.

More codegen implementations for basic functions.

* float/int conversion
* float3/float4 getters and setters

Removed unused source file.

Use load/store for float3 and float4 to generate a bit nicer code.

It's unclear if the same can be done for larger aggregate types like matrix44.

Define names for most values in generated LLVM code.

These are purely for debugging the code, they help a lot in reading
LLVM dumps.

New CodeGenerator implementation for replacing the old BVM compiler.

Moved old bvm codegen and function files into bvm module.

The intern and compile modules are now truly independent from backends (llvm and bvm).

Refactor of the node graph compiler class, to have a backend-agnostic base.

The main compiler class is now itself independent of LLVM and can be used for
future backends. The implementation of specific behavior (values, statements, etc.)
happens through a CodeGenerator implementation. This also uses aggregation rather
than inheritance on the compiler class part (which is not a virtual class itself).

Merge branch 'master' into object_nodes

Use a Scope concept for avoiding codegen for existing nodes.

Rather than a single socket value map, use a "scope" to keep track of which
nodes are already generated. This reintroduces the "block" idea from earlier
versions, but at the later codegen stage rather than the node graph.

Describing scope on the level of nodes becomes quite clumsy and ambiguous,
and moves nodes further away from the UI representation. The compiler can
handle this more elegantly without requiring persistent data.

Scopes can be nested. This is not used yet, but will allow scoped variables
later on, where the variables being used for a node path depend on its scope.

Removed/Disabled some deprecated code.