Blender Git Commits

Don't simulate the hair root.

This enforces the basic root constraint of hair curves. In principle we
could allow free, unconstrained hairs as well ...

Keep the solver over time steps during a single modifier eval.

Added time stepping in the modifier, like all the other simulations do.

This is pretty crappy in general, but there is no good alternative so
far. Eventually we'd like to separate simulation stepping from the
keyframe animation system, so that simulations can be advanced
independently. This would be very useful for tweaking (in a otherwise
constant environment), doing pre-roll, setting start frame in the cache
etc.

For now this modifier update approach is just a quick hack to get
visual feedback for the integrator.

Very basic Semi-implicit Euler integrator for hair particles.

The semi-implicit (aka symplectic) Euler integrator is almost as simple
as the basic Euler integration, but conserves Energy much better.
http://en.wikipedia.org/wiki/Semi-implicit_Euler_method

It is the integrator suggested originally in this paper:
http://graphics.pixar.com/library/CurlyHairA/paper.pdf

Time stepping operator for the hair system.

Basic solver class, to perform iterative simulation of hair (eventually).

Data from DNA can be copied into a SolverData struct for optimized
solver access. This should happen any time the data layout is changed in
the DNA (points/hairs added or removed), since the solver works on fixed
datasets only. After each time step the solver result can be applied
back to the DNA data for display, tools etc.

It may be beneficial to keep the solver and its data around between time
steps, so the data does not get deleted automatically after applying.
Initializing the data, applying and freeing are separate functions.

Macro utility for using MEM_guardedalloc in C++ hair classes.

Fixed the smoothing algorithm.

The smoothing factor used for display is now exposed in RNA/modifier UI
too. This is just a debugging feature though, it doesn't really serve
any higher purpose.

Particle-to-Hair copy: Use the pathcache of particle systems rather than
the base particle data.

Particles store all hair deformation and dynamics in the path cache, so
using the base data is not very interesting ...

Smoothing function as a first feature in dedicated hair code.

This function is used in a number of places in the targeted algorithms.
It is a useful utility for parallel-transport of various properties
along a hair curve. With curled hair in particular the control curve
itself is otherwise too irregular to give usable results, for which the
smoothing offers an elegant solution.

The algorithm is described in detail in the paper "Artistic simulation
of curly hair":
http://graphics.pixar.com/library/CurlyHairA/paper.pdf

Read/Write code for hair data.

Fix for particle-to-hair copy operator.

Old particle system hair has its own local space and must be multiplied
by a per-hair matrix to get into
object space.

Simple draw method for hair systems.

This is totally unoptimized and has only the bare minimum of key hair
display as lines. More sophisticated drawing will follow once the
requirements are clear.

Operator for copying hair data from old particle systems to the new
hair data structure.

This will allow a quick initialization of the hair data with real world
examples, so we can test the hair simulation etc. without having to
write setup code or fully fledged tools first.

Possibly could also allow porting of old blend file data, but that is
of secondary importance for now.

Change of the hair DNA data to use an array of arrays, instead of
flattening all the points into a single array.

The latter would be better for some algorithms and memory conherence,
but for frequent access we would copy to acceleration structures anyway.
Using double arrays is much nicer for access and modification by tools.

Deleted unused cmake file.

This was committed accidentally, but does not contain usable code yet.

Stub hair simulation modifier to attach a hair system to an object.

The modifier should never get anything more than a hair system and
some basic access features, all the logic should be in the hair system
only.

Skeleton structs for Hair system, based on curves and points.

Squashed commit of current WIP custom split normals work.

Obviously incomplete, just to test new 'testbuild' feature of buildbot. ;)