Blender Git Commits

Applying the inverse object transform for strand data is not necessary.

Particle pathcache data is in world space, but strands are stored in
object space already.

Basic cache overrides for strand render data in Cycles.

Still buggy, but the basic workflow is there:
When a cache library is used in conjunction with a group duplicator and
it has strands that match the particle systems, Cycles will use the
new Strands structure to construct its internal curves.

DNA file for strands types.

This is not strictly needed because the strands data is only created
at runtime at this point. However, it might be useful to later include
this in blend files.

Also the C++ RNA API has a bug that makes non-DNA collection properties
difficult (the length function is not implemented properly).

Yet another writer class for storing child strand data generated by
particles.

This is currently the same as the ParticlePathcache writer class, but
will be modified somewhat later to store additional information such as
parent weights. The purpose of this cache object is not to populate the
particle child caches, but to store renderable data associated to dupli
cache strands.

Child strands structure for storing renderable child hairs efficiently.

This is a separate struct to avoid storing unnecessary data (this means
a bit of code duplication for iterators). The child strands can be used
as the actual render data, while the parent strands usually would be
used only for simulation/deformation purposes.

Bending forces in strand hair simulation.

Store root orientation matrix in strand curves as well as caches.

This matrix is needed to create a stable and smooth coordinate system
along the strands, for things such as bending forces and child hair
deformation. The base matrix is defined on the "scalp" mesh and should
be stable wrt. deformation and animation of the mesh. For any point on
the strand a matrix is then calculated using parallel transport, i.e.
by rotating the base matrix successively along each curve corner.

Yet another iterator for looping over strands, this time for triples
of consecutive vertices ("bends").

This will be useful for calculating bending forces, without making basic
iteration a big headache.

Nicer iterator for looping over strand edges directly.

Avoids the ugly construct with vertex iterators that have to drag an
extra 'prev' iterator along.

Use the dupli object's obmat for world space simulation.

The overall world space matrix for dupli sims has to be the combined
obmat of the cached object as well as the duplicator for the dupligroup
instance. The cached strand data is generally in object space, so the
matrix has to be applied to get all the forces and interactions right.

World transform for simulation of caches.

This compensates the transformation of the dupli instance being cached,
so that forces such as gravity are in the correct reference frame.

Note that this does not yet generate fictitious forces resulting from
a moving and/or accelerated frame of reference. For this we would also
have to calculate linear/angular velocity and acceleration of the dupli
object.

Make sure the frame values for cache modifier evaluation are initialized
correctly.

Also skip empty frames in hair simulation (this includes the first
frame).

Use matching defaults and ranges in RNA/BKE for hairsim parameters.

Unused line, the strand array offset is provided by the iterator now.

Better defaults for stretch stiffness and damping.

The strong stretch forces lead to awkward lengthening of segments when
the damping factor is too high.

In fact, in a natural hair strand the stretching usually means the hair
itself is curly and stretches as a helical spring. In that case
the damping is quite small compared to the stiffness, and little energy
is lost to the stretching (the hair becomes "bouncy"). When the hair is
very stiff the damping should also be small in order to avoid extreme
forces resulting from the hair root location constraint.

Fix for stretch forces being defined wrt. the root vertex.

Was not advancing the iterator for the previous vertex correctly.

Moved root animation calculation into the solver code.

The solver can calculate the de-facto velocity of the root using the
difference of the already-updated vertex location and the state from the
previous step.

Fix for simdebug data cache reading.

Data pointers were not advanced, so only the first debug element would
show up properly.

Take strand bounds into account when calculating bounding boxes for
dupli overrides.

Apply sim debug data from caches back to the global hash table.

Note that this is quite messy atm, it will override debug data if
different caches are used, and does not discriminate when writing to
caches either.