Organizing Techniques

---------------------------------------------------
MODELING:

(1) low polygon mesh

(2) LODs (level-of-detail)
a. strips

• parametric surfaces (can use offset function to make them curly)
• polygonal triangles to mark density/space in between guide hairs

b. clusters

• GCs (general cylinders) [did not seem to work very well for tightly pulled-back hair]

c. strands

• offset function to make them curly

d. wisps

(3) hierarchical hair structure (applicable to most LODs)
a. parent GC subdivided into several child GCs
b. AWT (adaptive wisp tree)
c. auto, manual, minor clumping
d. adaptive subdivision/merging based on what can be seen

(4) sparse guide hairs (curves)
a. interpolated to create hair density
b. dynamically added or removed

(5) vector fields

(6) multiple layers (main, under, fuzz, stray)

(7) 2D texture synthesis (2d feature maps)

(8) super-helices

(9) growing hairs based on scalp geometry (one at every normal)

---------------------------------------------------
ANIMATING (eulerian vs. langrangian):

(1) FFD (free form deformation) lattice

(2) mass-spring-damper (point masses vs. cylinders)

(3) mass-spring-hinge

(4) cantilever beam

(5) multi-body open chain

(6) fluid dynamics

(7) metaballs (for collisions with model)

(8) control vertices treated as particles
a. Verlet integration
b. Euler integration
c. Runge-Kutta integration

(9) spheres/pearls (for collisions with model)

---------------------------------------------------
RENDERING:

(1) polygon tessellation

(2) maps
a. texture
b. bump
c. alpha

(3) global illumination
a. self-shadowing

• using opacity-based volume rendering (i.e. voxels)

b. back lighting

• (opacity) shadow maps

(4) local illumination
a. anisotropic reflections

• reflection maps
• Marschner model
• dual scattering approximation

b. hair segments as GL lines (with anti-aliasing)
c. alpha blending to give illusion of thickness

(5) Renderman

[might be helpful to paint the scalp a dark color so bald patches are less noticeable]

---------------------------------------------------
Techniques in bold are ones that I'd love to somehow include in my project, or at least investigate in depth. Many of them have already been used in a real-time context; others have not, but could potentially be modified/merged with other techniques to do so.

What can be done to speed up the process (goal: real-time for the last 2)?
- fewer primitives
- use approximations
- use the GPU