Blender Git Commits

Merge branch 'master' into object_nodes

Remove the unordered_map cmake monstrosity from subdirectory build files.

Doing this in the top-level cmake file for blenvm is enough.

Extended debug printing modes to the LLVM code.

The LLVM IR code can be dumped either in raw form or optimized.
It is stored as a raw text file.

Minor fixes for compiling without LLVM.

Fix expression result use as function arguments and add RGBA color mix node.

Inlining of base node functions in LLVM IR code.

This requires a somewhat hackish stub function to force linking of inlined
functions in the modules, so that clang doesn't just omit them when
producing IR code. Not very nice, but also not directly related to the
actual Blender code.

Optimization passes for the generated LLVM code.

Completed basic expression tree code generation.

The code uses a pointer-based signature convention for node functions,
which helps to avoid issues with type coercion through clang.
In the future we could either find a more reliable way to produce llvm IR
for the nodes, or use node functions as external functions without inlining.

Use annotation attributes on module functions to avoid name mangling issues.

Names in C++ code tend to get mangled by the clang compiler according to the
respective target ABI. This is unfortunate because it makes it difficult to
map functions to nodes by name. For now we use a function attribute in the module
C++ code to pass on the "true" name of the function and map them internally.

Make LLVM module compilation depend on header files to force recompile when headers change.

Generate function calls for every node, using code defined in precompiled modules.

Note that this is currently not quite working: The clang compiler call used
tentatively for generating the LLVM IR code for modules uses a lowering pass to
coerce struct data types (such as float3) according to the target ABI. This should
be avoided and is unnecessary for our purposes, since we stitch together and optimize
these code fragments ourselves. In principle we could avoid using a C compiler altogether
and write this stuff by hand, but the point of using the compiler is to avoid this tedious
work. More info:
http://stackoverflow.com/questions/22776391/why-does-clang-coerce-struct-parameters-to-ints

Ported over code from previous llvm branch for loading IR modules and linking runtime code.

Initial code for mapping node sockets to llvm values.

Cleanup: Fixed deprecated docstrings for file location.

Cleanup: Renamed Value class to NodeValue, to distinguish from llvm::Value easier.

With the proper formal function parameters for node functions they can now actually be called.

Use getFunctionAddress instead of deprecated getFunctionPointer.

Retain functions both for storage in the cache as well as keeping the pointer during eval.

Otherwise the function is freed immediately after each use, making the cache pointless.

Only insert functions into the function cache when use_cache argument is true.

Type generation for LLVM based on node socket types.

Currently every socket stores a complete and unique type definition.
This should be changed to module-level type declarations and referencing by name.