Blender Git Commits

Define BMEditStrands struct as an extension of BMEditMesh.

The advantage is that we can now use this struct in the (rather involved)
process of generating a display DerivedMesh and apply modifiers to it.

Disable regular mesh drawing in hair edit mode.

Proof-of-concept: Hair edit data from regular meshes.

This adds the possibility to edit a regular mesh like strand data.
It's more of a test for independence from particles than a real use case,
but could come in handy anyway.

Check mesh samples for zero weights on eval to detect invalid/unusable samples.

Corrected implementation of the strand relaxation method ported from particles.

This is still the same algorithm as in particle edit mode, but cleaned up
some unnecessary complications and use much more meaningful variable names.

Merge branch 'master' into strand_editmode

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.