Blender Git Loki

Use the correct buffer for the control points texture.

Also a bit of cleanup renaming to use "control" consistently instead
of "guide".

Modified the guide strand creation operator to allow shorter-than-max strands.

The guide strand format may change, but it should allow varying numbers of control
points.

Calculate barycentric interpolation weights using a simple kdTree method.

This method uses the 3 closest points on the scalp for defining interpolation
weights. This method has drawbacks in cases of thin geometry, but it is
simple to implement.

Vertex attributes for the strand root points.

These attributes carry information for interpolating guide strands
in the geometry shader. Each strand can have up to 4 guide strands
(identified by index) with a normalized weight for each.

Generate a buffer texture for passing the control strand locations to the shader.

This should enable the strand geometry shader to interpolate control strands
with appropriate vertex attributes for indices and weights.

Use separate buffers for control strand and root vertices.

This is important so we can put control strands into a buffer texture,
and pass it to the geometry shader for generating strands.

Start off with some very simple own code for vert/frag/geom strand shader.

Draw render strands as simple point primitives.

The geometry shader will eventually turn these points into full strand curves.

Generate a number of "roots" for render hairs on the mesh surface.

These root points will be used as input for the strand shader to generate
the interpolated render strands.

Use the show_control_strands toggle for switching control hair display on/off.

Also use the basic edge shader for control hairs, the generated GLSL shader is
only needed for drawing render strands.

Intermediate struct StrandData for storing base data for drawing.

This is equivalent to the DerivedMesh stage in the Mesh -> DM -> GPUBuffer
pipeline. The Strands struct is the base editable user data, StrandsData
is preprocessed data with evaluated root matrices and applied for object
space drawing.

GPU code for vertex and edge buffers of strands.

This is a modification of the DerivedMesh code, which relies too much
on the DerivedMesh data structure to be used directly.

Test operator for quickly initializing the strands data.

This is just a temporary test operator, to be removed later when
edit mode and other mechanisms exist to generate useful strands.

Use plain vertex and curve arrays in Strands data, so that they can be used as OpenGL buffers.

Own file for strand drawing code to avoid polluting drawobject.c even more.

Skeleton GPU code for creating a special hair shader.

This will include a geometry shader as well as vertex/fragment shaders,
for efficiently generating strand geometry based on control strands.

Flag for enabling control strand display.

Currently still unused.

Use the Strands modifier as a simple container for strand control curves.

These curves are NOT intended for final rendering! They are abstract
editable data (control strands) from which the "actual" visible strands
have to be generated in some way.

This is largely equivalent to the parent/child dichotomy in old particles,
but enforces the separation right from the start (control curves are never
rendered).

Stub modifier for testing strand geometry generation.

Modifier is not ideal, but easiest way to test code due to lack of
infrastructure in Object for node-generated data.

Merge branch 'master' into mesh_samples