Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								/* particle.c
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  $ Id $ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-07 19:13:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  * * * * *  BEGIN  GPL  LICENSE  BLOCK  * * * * * 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  This  program  is  free  software ;  you  can  redistribute  it  and / or 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  modify  it  under  the  terms  of  the  GNU  General  Public  License 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  as  published  by  the  Free  Software  Foundation ;  either  version  2 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-07 19:13:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  of  the  License ,  or  ( at  your  option )  any  later  version . 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  This  program  is  distributed  in  the  hope  that  it  will  be  useful , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  but  WITHOUT  ANY  WARRANTY ;  without  even  the  implied  warranty  of 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  MERCHANTABILITY  or  FITNESS  FOR  A  PARTICULAR  PURPOSE .   See  the 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  GNU  General  Public  License  for  more  details . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  You  should  have  received  a  copy  of  the  GNU  General  Public  License 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  along  with  this  program ;  if  not ,  write  to  the  Free  Software  Foundation , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  Inc . ,  59  Temple  Place  -  Suite  330 ,  Boston ,  MA   02111 - 1307 ,  USA . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  The  Original  Code  is  Copyright  ( C )  2007  by  Janne  Karhu . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  All  rights  reserved . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  The  Original  Code  is :  all  of  this  file . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  Contributor ( s ) :  none  yet . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-07 19:13:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  * * * * *  END  GPL  LICENSE  BLOCK  * * * * * 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								 */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  <stdlib.h> 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  <math.h> 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  <string.h> 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "MEM_guardedalloc.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_scene_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_particle_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_mesh_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_meshdata_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_modifier_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_object_force.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_texture_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_material_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_object_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_curve_types.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "DNA_key_types.h" 
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# include  "DNA_ipo_types.h" 	// XXX old animation system stuff to remove! 
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BLI_arithb.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BLI_blenlib.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BLI_dynstr.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BLI_kdtree.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BLI_linklist.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BLI_rand.h" 
 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# include  "BLI_threads.h" 
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_anim.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_global.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_main.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_lattice.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_utildefines.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_displist.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_particle.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_DerivedMesh.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_object.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_softbody.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_material.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_key.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_library.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_depsgraph.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "BKE_modifier.h" 
 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# include  "BKE_mesh.h" 
 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# include  "BKE_cdderivedmesh.h" 
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# include  "BKE_pointcache.h" 
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# include  "RE_render_ext.h" 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  key_from_object ( Object  * ob ,  ParticleKey  * key ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  get_cpa_texture ( DerivedMesh  * dm ,  Material  * ma ,  int  face_index , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												float  * fuv ,  float  * orco ,  ParticleTexture  * ptex , 	int  event ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* few helpers for countall etc. */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								int  count_particles ( ParticleSystem  * psys ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part = psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  tot = 0 , p ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( p = 0 , pa = psys - > particles ;  p < psys - > totpart ;  p + + , pa + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( pa - > alive  = =  PARS_KILLED ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( pa - > alive  = =  PARS_UNBORN  & &  ( part - > flag  &  PART_UNBORN ) = = 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( pa - > alive  = =  PARS_DEAD  & &  ( part - > flag  &  PART_DIED ) = = 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( pa - > flag  &  ( PARS_UNEXIST + PARS_NO_DISP ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  tot + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  tot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								int  count_particles_mod ( ParticleSystem  * psys ,  int  totgr ,  int  cur ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part = psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  tot = 0 , p ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( p = 0 , pa = psys - > particles ;  p < psys - > totpart ;  p + + , pa + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( pa - > alive  = =  PARS_KILLED ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( pa - > alive  = =  PARS_UNBORN  & &  ( part - > flag  &  PART_UNBORN ) = = 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( pa - > alive  = =  PARS_DEAD  & &  ( part - > flag  &  PART_DIED ) = = 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( pa - > flag  &  ( PARS_UNEXIST + PARS_NO_DISP ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( p % totgr = = cur )  tot + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  tot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								int  psys_count_keys ( ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ,  totpart = psys - > totpart ,  totkey = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = 0 ,  pa = psys - > particles ;  i < totpart ;  i + + ,  pa + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totkey  + =  pa - > totkey ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  totkey ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* remember to free the pointer returned from this! */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								char  * psys_menu_string ( Object  * ob ,  int  for_sb ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DynStr  * ds ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									char  * str ,  num [ 6 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ds  =  BLI_dynstr_new ( ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( for_sb ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_dynstr_append ( ds ,  " |Object%x-1 " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = 0 , psys = ob - > particlesystem . first ;  psys ;  i + + , psys = psys - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_dynstr_append ( ds ,  " | " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										sprintf ( num , " %i.  " , i + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_dynstr_append ( ds ,  num ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_dynstr_append ( ds ,  psys - > part - > id . name + 2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										sprintf ( num , " %%x%i " , i + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_dynstr_append ( ds ,  num ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									str  =  BLI_dynstr_get_cstring ( ds ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									BLI_dynstr_free ( ds ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  str ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 19:25:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* we allocate path cache memory in chunks instead of a big continguous
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  chunk ,  windows '  memory  allocater  fails  to  find  big  blocks  of  memory  often  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								# define PATH_CACHE_BUF_SIZE 1024 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  ParticleCacheKey  * * psys_alloc_path_cache_buffers ( ListBase  * bufs ,  int  tot ,  int  steps ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									LinkData  * buf ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * cache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ,  totkey ,  totbufkey ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									tot =  MAX2 ( tot ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totkey  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									cache  =  MEM_callocN ( tot * sizeof ( void * ) ,  " PathCacheArray " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									while ( totkey  <  tot )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totbufkey =  MIN2 ( tot - totkey ,  PATH_CACHE_BUF_SIZE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										buf =  MEM_callocN ( sizeof ( LinkData ) ,  " PathCacheLinkData " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										buf - > data =  MEM_callocN ( sizeof ( ParticleCacheKey ) * totbufkey * steps ,  " ParticleCacheKey " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( i = 0 ;  i < totbufkey ;  i + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cache [ totkey + i ]  =  ( ( ParticleCacheKey * ) buf - > data )  +  i * steps ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totkey  + =  totbufkey ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_addtail ( bufs ,  buf ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  cache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  psys_free_path_cache_buffers ( ParticleCacheKey  * * cache ,  ListBase  * bufs ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									LinkData  * buf ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( cache ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( cache ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( buf =  bufs - > first ;  buf ;  buf = buf - > next ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( buf - > data ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									BLI_freelistN ( bufs ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Getting stuff						*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* get object's active particle system safely */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								ParticleSystem  * psys_get_current ( Object  * ob ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ob = = 0 )  return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( psys = ob - > particlesystem . first ;  psys ;  psys = psys - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_CURRENT ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								short  psys_get_current_num ( Object  * ob ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									short  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ob = = 0 )  return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( psys = ob - > particlesystem . first ,  i = 0 ;  psys ;  psys = psys - > next ,  i + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_CURRENT ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* change object's active particle system */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_change_act ( void  * ob_v ,  void  * act_v ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * ob  =  ob_v ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * npsys ,  * psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									short  act  =  * ( ( short * ) act_v ) - 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( act > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										npsys = BLI_findlink ( & ob - > particlesystem , act ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys = psys_get_current ( ob ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > flag  & =  ~ PSYS_CURRENT ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( npsys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											npsys - > flag  | =  PSYS_CURRENT ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								Object  * psys_get_lattice ( Scene  * scene ,  Object  * ob ,  ParticleSystem  * psys ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * lattice = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys_in_edit_mode ( scene ,  psys ) = = 0 ) { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ModifierData  * md  =  ( ModifierData * ) psys_get_modifier ( ob , psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( ;  md ;  md = md - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( md - > type = = eModifierType_Lattice ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												LatticeModifierData  * lmd  =  ( LatticeModifierData  * ) md ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												lattice = lmd - > object ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( lattice ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											init_latt_deform ( lattice , 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  lattice ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_disable_all ( Object  * ob ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys = ob - > particlesystem . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( ;  psys ;  psys = psys - > next ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys - > flag  | =  PSYS_DISABLED ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_enable_all ( Object  * ob ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys = ob - > particlesystem . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( ;  psys ;  psys = psys - > next ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys - > flag  & =  ~ PSYS_DISABLED ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								int  psys_ob_has_hair ( Object  * ob ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys  =  ob - > particlesystem . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( ;  psys ;  psys = psys - > next ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > part - > type  = =  PART_HAIR ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								int  psys_in_edit_mode ( Scene  * scene ,  ParticleSystem  * psys ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  ( ( G . f  &  G_PARTICLEEDIT )  & &  psys = = psys_get_current ( ( scene - > basact ) - > object )  & &  psys - > edit ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								int  psys_check_enabled ( Object  * ob ,  ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystemModifierData  * psmd ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 16:31:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									Mesh  * me ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-16 18:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > flag  &  PSYS_DISABLED  | |  psys - > flag  &  PSYS_DELETE ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 16:31:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ob - > type  = =  OB_MESH )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										me =  ( Mesh * ) ob - > data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( me - > mr  & &  me - > mr - > current  ! =  1 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psmd =  psys_get_modifier ( ob ,  psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-21 10:57:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > renderdata )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ! ( psmd - > modifier . mode  &  eModifierMode_Render ) ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( ! ( psmd - > modifier . mode  &  eModifierMode_Realtime ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Freeing stuff						*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_free_settings ( ParticleSettings  * part ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-21 21:12:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( part - > pd )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( part - > pd ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-21 21:12:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										part - > pd  =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > pd2 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( part - > pd2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > pd2  =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-14 18:21:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  free_hair ( ParticleSystem  * psys ,  int  softbody ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ,  totpart = psys - > totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = 0 ,  pa = psys - > particles ;  i < totpart ;  i + + ,  pa + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( pa - > hair ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											MEM_freeN ( pa - > hair ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa - > hair  =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > flag  & =  ~ PSYS_HAIR_DONE ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-24 21:29:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-03-14 18:21:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( softbody  & &  psys - > soft )  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-24 21:29:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										sbFree ( psys - > soft ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > soft  =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  free_keyed_keys ( ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > particles  & &  psys - > particles - > keys )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										int  i ,  totpart = psys - > totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( psys - > particles - > keys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( i = 0 ,  pa = psys - > particles ;  i < totpart ;  i + + , pa + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa - > keys  =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa - > totkey  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  free_child_path_cache ( ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 19:25:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_free_path_cache_buffers ( psys - > childcache ,  & psys - > childcachebufs ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > childcache  =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totchildcache  =  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_free_path_cache ( ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 19:25:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_free_path_cache_buffers ( psys - > pathcache ,  & psys - > pathcachebufs ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > pathcache =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totcached =  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									free_child_path_cache ( psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-21 14:18:24 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_free_children ( ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psys - > child )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( psys - > child ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > child = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > totchild = 0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-21 14:18:24 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									free_child_path_cache ( psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* free everything */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_free ( Object  * ob ,  ParticleSystem  *  psys ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-26 01:07:18 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 	
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									if ( psys ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-26 01:07:18 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										int  nr  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ParticleSystem  *  tpsys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										if ( ob - > particlesystem . first  = =  NULL  & &  G . f  &  G_PARTICLEEDIT ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											G . f  & =  ~ G_PARTICLEEDIT ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys_free_path_cache ( psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-03-14 18:21:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										free_hair ( psys ,  1 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										free_keyed_keys ( psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-02-25 19:29:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > edit  & &  psys - > free_edit ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > free_edit ( psys ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > particles ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											MEM_freeN ( psys - > particles ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > particles  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > totpart  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > child ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											MEM_freeN ( psys - > child ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > child  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > totchild  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > effectors . first ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys_end_effectors ( psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-26 01:07:18 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// check if we are last non-visible particle system
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( tpsys = ob - > particlesystem . first ;  tpsys ;  tpsys = tpsys - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( tpsys - > part ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ELEM ( tpsys - > part - > draw_as , PART_DRAW_OB , PART_DRAW_GR ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													nr + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// clear do-not-draw-flag
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ! nr ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ob - > transflag  & =  ~ OB_DUPLIPARTS ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > part ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > part - > id . us - - ; 		
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys - > part = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-04-11 12:29:29 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > reactevents . first ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											BLI_freelistN ( & psys - > reactevents ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > pointcache ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											BKE_ptcache_free ( psys - > pointcache ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-26 01:07:18 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								/* these functions move away particle data and bring it back after
 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  rendering ,  to  make  different  render  settings  possible  without 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  removing  the  previous  data .  this  should  be  solved  properly  once  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								typedef  struct  ParticleRenderElem  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-02 15:44:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									int  curchild ,  totchild ,  reduce ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  lambda ,  t ,  scalemin ,  scalemax ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								}  ParticleRenderElem ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								typedef  struct  ParticleRenderData  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ChildParticle  * child ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * pathcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * childcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totchild ,  totcached ,  totchildcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DerivedMesh  * dm ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totdmvert ,  totdmedge ,  totdmface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  mat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  viewmat [ 4 ] [ 4 ] ,  winmat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  winx ,  winy ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  dosimplify ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									int  timeoffset ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleRenderElem  * elems ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  * origindex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								}  ParticleRenderData ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  float  psys_render_viewport_falloff ( double  rate ,  float  dist ,  float  width ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  pow ( rate ,  dist / width ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  float  psys_render_projected_area ( ParticleSystem  * psys ,  float  * center ,  float  area ,  double  vprate ,  float  * viewport ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleRenderData  * data =  psys - > renderdata ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-03 12:45:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  co [ 4 ] ,  view [ 3 ] ,  ortho1 [ 3 ] ,  ortho2 [ 3 ] ,  w ,  dx ,  dy ,  radius ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* transform to view space */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( co ,  center ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									co [ 3 ] =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulVec4fl ( data - > viewmat ,  co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* compute two vectors orthogonal to view vector */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( view ,  co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Normalize ( view ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecOrthoBasisf ( view ,  ortho1 ,  ortho2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* compute on screen minification */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									w =  co [ 2 ] * data - > winmat [ 2 ] [ 3 ]  +  data - > winmat [ 3 ] [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									dx =  data - > winx * ortho2 [ 0 ] * data - > winmat [ 0 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									dy =  data - > winy * ortho2 [ 1 ] * data - > winmat [ 1 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									w =  sqrt ( dx * dx  +  dy * dy ) / w ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* w squared because we are working with area */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									area =  area * w * w ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* viewport of the screen test */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* project point on screen */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulVec4fl ( data - > winmat ,  co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( co [ 3 ]  ! =  0.0f )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										co [ 0 ] =  0.5f * data - > winx * ( 1.0f  +  co [ 0 ] / co [ 3 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										co [ 1 ] =  0.5f * data - > winy * ( 1.0f  +  co [ 1 ] / co [ 3 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* screen space radius */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									radius =  sqrt ( area / M_PI ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* make smaller using fallof once over screen edge */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									* viewport =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( co [ 0 ] + radius  <  0.0f ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										* viewport  * =  psys_render_viewport_falloff ( vprate ,  - ( co [ 0 ] + radius ) ,  data - > winx ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( co [ 0 ] - radius  >  data - > winx ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										* viewport  * =  psys_render_viewport_falloff ( vprate ,  ( co [ 0 ] - radius )  -  data - > winx ,  data - > winx ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( co [ 1 ] + radius  <  0.0f ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										* viewport  * =  psys_render_viewport_falloff ( vprate ,  - ( co [ 1 ] + radius ) ,  data - > winy ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( co [ 1 ] - radius  >  data - > winy ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										* viewport  * =  psys_render_viewport_falloff ( vprate ,  ( co [ 1 ] - radius )  -  data - > winy ,  data - > winy ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  area ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_render_set ( Object  * ob ,  ParticleSystem  * psys ,  float  viewmat [ ] [ 4 ] ,  float  winmat [ ] [ 4 ] ,  int  winx ,  int  winy ,  int  timeoffset ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleRenderData * data ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleSystemModifierData  * psmd =  psys_get_modifier ( ob ,  psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ! G . rendering ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > renderdata ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									data =  MEM_callocN ( sizeof ( ParticleRenderData ) ,  " ParticleRenderData " ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > child =  psys - > child ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > totchild =  psys - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > pathcache =  psys - > pathcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > totcached =  psys - > totcached ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > childcache =  psys - > childcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > totchildcache =  psys - > totchildcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psmd - > dm ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										data - > dm =  CDDM_copy ( psmd - > dm ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > totdmvert =  psmd - > totdmvert ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > totdmedge =  psmd - > totdmedge ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > totdmface =  psmd - > totdmface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > child =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > pathcache =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > childcache =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totchild =  psys - > totcached =  psys - > totchildcache =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									Mat4CpyMat4 ( data - > winmat ,  winmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulMat4 ( data - > viewmat ,  ob - > obmat ,  viewmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulMat4 ( data - > mat ,  data - > viewmat ,  winmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > winx =  winx ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > winy =  winy ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									data - > timeoffset =  timeoffset ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys - > renderdata =  data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_render_restore ( Object  * ob ,  ParticleSystem  * psys ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleRenderData * data ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleSystemModifierData  * psmd =  psys_get_modifier ( ob ,  psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data =  psys - > renderdata ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ! data ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( data - > elems ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( data - > elems ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psmd - > dm )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psmd - > dm - > needsFree =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psmd - > dm - > release ( psmd - > dm ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys_free_path_cache ( psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psys - > child ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( psys - > child ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > child =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > totchild =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys - > child =  data - > child ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totchild =  data - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > pathcache =  data - > pathcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totcached =  data - > totcached ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > childcache =  data - > childcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totchildcache =  data - > totchildcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psmd - > dm =  data - > dm ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psmd - > totdmvert =  data - > totdmvert ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psmd - > totdmedge =  data - > totdmedge ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psmd - > totdmface =  data - > totdmface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psmd - > flag  & =  ~ eParticleSystemFlag_psys_updated ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-18 10:49:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psmd - > dm ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys_calc_dmcache ( ob ,  psmd - > dm ,  psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MEM_freeN ( data ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > renderdata =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								int  psys_render_simplify_distribution ( ParticleThreadContext  * ctx ,  int  tot ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DerivedMesh  * dm =  ctx - > dm ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mesh  * me =  ( Mesh * ) ( ctx - > ob - > data ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MFace  * mf ,  * mface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MVert  * mvert ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleRenderData  * data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleRenderElem  * elems ,  * elem ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part =  ctx - > psys - > part ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-03 22:43:51 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  * facearea ,  ( * facecenter ) [ 3 ] ,  size [ 3 ] ,  fac ,  powrate ,  scaleclamp ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  co1 [ 3 ] ,  co2 [ 3 ] ,  co3 [ 3 ] ,  co4 [ 3 ] ,  lambda ,  arearatio ,  t ,  area ,  viewport ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									double  vprate ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  * origindex ,  * facetotvert ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  a ,  b ,  totorigface ,  totface ,  newtot ,  skipped ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > draw_as ! = PART_DRAW_PATH  | |  ! ( part - > draw  &  PART_DRAW_REN_STRAND ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  tot ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ! ctx - > psys - > renderdata ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  tot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data =  ctx - > psys - > renderdata ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( data - > timeoffset ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ! ( part - > simplify_flag  &  PART_SIMPLIFY_ENABLE ) ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  tot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									mvert =  dm - > getVertArray ( dm ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									mface =  dm - > getFaceArray ( dm ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									origindex =  dm - > getFaceDataArray ( dm ,  CD_ORIGINDEX ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totface =  dm - > getNumFaces ( dm ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totorigface =  me - > totface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( totface  = =  0  | |  totorigface  = =  0  | |  origindex  = =  NULL ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  tot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									facearea =  MEM_callocN ( sizeof ( float ) * totorigface ,  " SimplifyFaceArea " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									facecenter =  MEM_callocN ( sizeof ( float [ 3 ] ) * totorigface ,  " SimplifyFaceCenter " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									facetotvert =  MEM_callocN ( sizeof ( int ) * totorigface ,  " SimplifyFaceArea " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									elems =  MEM_callocN ( sizeof ( ParticleRenderElem ) * totorigface ,  " SimplifyFaceElem " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-03 22:43:51 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( data - > elems ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( data - > elems ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									data - > dosimplify =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > elems =  elems ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data - > origindex =  origindex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* compute number of children per original face */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( a = 0 ;  a < tot ;  a + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										b =  origindex [ ctx - > index [ a ] ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( b  ! =  - 1 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elems [ b ] . totchild + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* compute areas and centers of original faces */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( mf = mface ,  a = 0 ;  a < totface ;  a + + ,  mf + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										b =  origindex [ a ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( b  ! =  - 1 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECCOPY ( co1 ,  mvert [ mf - > v1 ] . co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECCOPY ( co2 ,  mvert [ mf - > v2 ] . co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECCOPY ( co3 ,  mvert [ mf - > v3 ] . co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( facecenter [ b ] ,  facecenter [ b ] ,  co1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( facecenter [ b ] ,  facecenter [ b ] ,  co2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( facecenter [ b ] ,  facecenter [ b ] ,  co3 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( mf - > v4 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( co4 ,  mvert [ mf - > v4 ] . co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECADD ( facecenter [ b ] ,  facecenter [ b ] ,  co4 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												facearea [ b ]  + =  AreaQ3Dfl ( co1 ,  co2 ,  co3 ,  co4 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												facetotvert [ b ]  + =  4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												facearea [ b ]  + =  AreaT3Dfl ( co1 ,  co2 ,  co3 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												facetotvert [ b ]  + =  3 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( a = 0 ;  a < totorigface ;  a + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( facetotvert [ a ]  >  0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( facecenter [ a ] ,  1.0f / facetotvert [ a ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* for conversion from BU area / pixel area to reference screen size */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									mesh_get_texspace ( me ,  0 ,  0 ,  size ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									fac =  ( ( size [ 0 ]  +  size [ 1 ]  +  size [ 2 ] ) / 3.0f ) / part - > simplify_refsize ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									fac =  fac * fac ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									powrate =  log ( 0.5f ) / log ( part - > simplify_rate * 0.5f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > simplify_flag  &  PART_SIMPLIFY_VIEWPORT ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vprate =  pow ( 1.0  -  part - > simplify_viewport ,  5.0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vprate =  1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* set simplification parameters per original face */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( a = 0 ,  elem = elems ;  a < totorigface ;  a + + ,  elem + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										area  =  psys_render_projected_area ( ctx - > psys ,  facecenter [ a ] ,  facearea [ a ] ,  vprate ,  & viewport ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										arearatio =  fac * area / facearea [ a ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-03 22:43:51 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ( arearatio  <  1.0f  | |  viewport  <  1.0f )  & &  elem - > totchild )  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* lambda is percentage of elements to keep */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											lambda =  ( arearatio  <  1.0f ) ?  pow ( arearatio ,  powrate ) :  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											lambda  * =  viewport ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-03 22:43:51 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											lambda =  MAX2 ( lambda ,  1.0f / elem - > totchild ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* compute transition region */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											t =  part - > simplify_transition ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > t =  ( lambda - t  <  0.0f ) ?  lambda :  ( lambda + t  >  1.0f ) ?  1.0f - lambda :  t ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-02 15:44:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											elem - > reduce =  1 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* scale at end and beginning of the transition region */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemax =  ( lambda + t  <  1.0f ) ?  1.0f / lambda :  1.0f / ( 1.0f  -  elem - > t * elem - > t / t ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemin =  ( lambda + t  <  1.0f ) ?  0.0f :  elem - > scalemax * ( 1.0f - elem - > t / t ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-03 22:43:51 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											elem - > scalemin =  sqrt ( elem - > scalemin ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemax =  sqrt ( elem - > scalemax ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* clamp scaling */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											scaleclamp =  MIN2 ( elem - > totchild ,  10.0f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemin =  MIN2 ( scaleclamp ,  elem - > scalemin ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemax =  MIN2 ( scaleclamp ,  elem - > scalemax ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* extend lambda to include transition */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											lambda =  lambda  +  elem - > t ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( lambda  >  1.0f ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												lambda =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											lambda =  arearatio ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemax =  1.0f ;  //sqrt(lambda);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											elem - > scalemin =  1.0f ;  //sqrt(lambda);
 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-02 15:44:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											elem - > reduce =  0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										elem - > lambda =  lambda ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										elem - > scalemin =  sqrt ( elem - > scalemin ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										elem - > scalemax =  sqrt ( elem - > scalemax ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										elem - > curchild =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MEM_freeN ( facearea ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MEM_freeN ( facecenter ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MEM_freeN ( facetotvert ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* move indices and set random number skipping */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ctx - > skip =  MEM_callocN ( sizeof ( int ) * tot ,  " SimplificationSkip " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									skipped =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( a = 0 ,  newtot = 0 ;  a < tot ;  a + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										b =  origindex [ ctx - > index [ a ] ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( b  ! =  - 1 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( elems [ b ] . curchild + +  <  ceil ( elems [ b ] . lambda * elems [ b ] . totchild ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												ctx - > index [ newtot ] =  ctx - > index [ a ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												ctx - > skip [ newtot ] =  skipped ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												skipped =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												newtot + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  skipped + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  skipped + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( a = 0 ,  elem = elems ;  a < totorigface ;  a + + ,  elem + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										elem - > curchild =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  newtot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								int  psys_render_simplify_params ( ParticleSystem  * psys ,  ChildParticle  * cpa ,  float  * params ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleRenderData  * data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleRenderElem  * elem ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  x ,  w ,  scale ,  alpha ,  lambda ,  t ,  scalemin ,  scalemax ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  b ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ! ( psys - > renderdata  & &  ( psys - > part - > simplify_flag  &  PART_SIMPLIFY_ENABLE ) ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									data =  psys - > renderdata ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ! data - > dosimplify ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									b =  data - > origindex [ cpa - > num ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( b  = =  - 1 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									elem =  & data - > elems [ b ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									lambda =  elem - > lambda ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									t =  elem - > t ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									scalemin =  elem - > scalemin ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									scalemax =  elem - > scalemax ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-02 15:44:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ! elem - > reduce )  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										scale =  scalemin ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										alpha =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										x =  ( elem - > curchild + 0.5f ) / elem - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( x  <  lambda - t )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											scale =  scalemax ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											alpha =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( x  > =  lambda + t )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											scale =  scalemin ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											alpha =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											w =  ( lambda + t  -  x ) / ( 2.0f * t ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											scale =  scalemin  +  ( scalemax  -  scalemin ) * w ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											alpha =  w ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									params [ 0 ] =  scale ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									params [ 1 ] =  alpha ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									elem - > curchild + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Interpolated Particles				*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  float  interpolate_particle_value ( float  v1 ,  float  v2 ,  float  v3 ,  float  v4 ,  float  * w ,  int  four ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  value ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									value =  w [ 0 ] * v1  +  w [ 1 ] * v2  +  w [ 2 ] * v3 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( four ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										value  + =  w [ 3 ] * v4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  value ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  weighted_particle_vector ( float  * v1 ,  float  * v2 ,  float  * v3 ,  float  * v4 ,  float  * weights ,  float  * vec ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									vec [ 0 ] =  weights [ 0 ] * v1 [ 0 ]  +  weights [ 1 ] * v2 [ 0 ]  +  weights [ 2 ] * v3 [ 0 ]  +  weights [ 3 ] * v4 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									vec [ 1 ] =  weights [ 0 ] * v1 [ 1 ]  +  weights [ 1 ] * v2 [ 1 ]  +  weights [ 2 ] * v3 [ 1 ]  +  weights [ 3 ] * v4 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									vec [ 2 ] =  weights [ 0 ] * v1 [ 2 ]  +  weights [ 1 ] * v2 [ 2 ]  +  weights [ 2 ] * v3 [ 2 ]  +  weights [ 3 ] * v4 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 10:44:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  void  interpolate_particle ( short  type ,  ParticleKey  keys [ 4 ] ,  float  dt ,  ParticleKey  * result ,  int  velocity ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  t [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( type < 0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VecfCubicInterpol ( keys [ 1 ] . co ,  keys [ 1 ] . vel ,  keys [ 2 ] . co ,  keys [ 2 ] . vel ,  dt ,  result - > co ,  result - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										set_four_ipo ( dt ,  t ,  type ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										weighted_particle_vector ( keys [ 0 ] . co ,  keys [ 1 ] . co ,  keys [ 2 ] . co ,  keys [ 3 ] . co ,  t ,  result - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 10:44:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( velocity ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											float  temp [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( dt > 0.999f ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												set_four_ipo ( dt - 0.001f ,  t ,  type ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												weighted_particle_vector ( keys [ 0 ] . co ,  keys [ 1 ] . co ,  keys [ 2 ] . co ,  keys [ 3 ] . co ,  t ,  temp ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECSUB ( result - > vel ,  result - > co ,  temp ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												set_four_ipo ( dt + 0.001f ,  t ,  type ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												weighted_particle_vector ( keys [ 0 ] . co ,  keys [ 1 ] . co ,  keys [ 2 ] . co ,  keys [ 3 ] . co ,  t ,  temp ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECSUB ( result - > vel ,  temp ,  result - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Particles on a dm					*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* interpolate a location on a face based on face coordinates */ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_interpolate_face ( MVert  * mvert ,  MFace  * mface ,  MTFace  * tface ,  float  ( * orcodata ) [ 3 ] ,  float  * w ,  float  * vec ,  float  * nor ,  float  * utan ,  float  * vtan ,  float  * orco , float  * ornor ) { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									float  * v1 = 0 ,  * v2 = 0 ,  * v3 = 0 ,  * v4 = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  e1 [ 3 ] , e2 [ 3 ] , s1 , s2 , t1 , t2 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  * uv1 ,  * uv2 ,  * uv3 ,  * uv4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  n1 [ 3 ] ,  n2 [ 3 ] ,  n3 [ 3 ] ,  n4 [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  tuv [ 4 ] [ 2 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  * o1 ,  * o2 ,  * o3 ,  * o4 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									v1 =  ( mvert + mface - > v1 ) - > co ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									v2 =  ( mvert + mface - > v2 ) - > co ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									v3 =  ( mvert + mface - > v3 ) - > co ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( n1 , ( mvert + mface - > v1 ) - > no ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( n2 , ( mvert + mface - > v2 ) - > no ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( n3 , ( mvert + mface - > v3 ) - > no ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Normalize ( n1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Normalize ( n2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Normalize ( n3 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( mface - > v4 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										v4 =  ( mvert + mface - > v4 ) - > co ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( n4 , ( mvert + mface - > v4 ) - > no ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( n4 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vec [ 0 ] =  w [ 0 ] * v1 [ 0 ]  +  w [ 1 ] * v2 [ 0 ]  +  w [ 2 ] * v3 [ 0 ]  +  w [ 3 ] * v4 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vec [ 1 ] =  w [ 0 ] * v1 [ 1 ]  +  w [ 1 ] * v2 [ 1 ]  +  w [ 2 ] * v3 [ 1 ]  +  w [ 3 ] * v4 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vec [ 2 ] =  w [ 0 ] * v1 [ 2 ]  +  w [ 1 ] * v2 [ 2 ]  +  w [ 2 ] * v3 [ 2 ]  +  w [ 3 ] * v4 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( nor ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( mface - > flag  &  ME_SMOOTH ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 0 ] =  w [ 0 ] * n1 [ 0 ]  +  w [ 1 ] * n2 [ 0 ]  +  w [ 2 ] * n3 [ 0 ]  +  w [ 3 ] * n4 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 1 ] =  w [ 0 ] * n1 [ 1 ]  +  w [ 1 ] * n2 [ 1 ]  +  w [ 2 ] * n3 [ 1 ]  +  w [ 3 ] * n4 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 2 ] =  w [ 0 ] * n1 [ 2 ]  +  w [ 1 ] * n2 [ 2 ]  +  w [ 2 ] * n3 [ 2 ]  +  w [ 3 ] * n4 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												CalcNormFloat4 ( v1 , v2 , v3 , v4 , nor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vec [ 0 ] =  w [ 0 ] * v1 [ 0 ]  +  w [ 1 ] * v2 [ 0 ]  +  w [ 2 ] * v3 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vec [ 1 ] =  w [ 0 ] * v1 [ 1 ]  +  w [ 1 ] * v2 [ 1 ]  +  w [ 2 ] * v3 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vec [ 2 ] =  w [ 0 ] * v1 [ 2 ]  +  w [ 1 ] * v2 [ 2 ]  +  w [ 2 ] * v3 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( nor ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( mface - > flag  &  ME_SMOOTH ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 0 ] =  w [ 0 ] * n1 [ 0 ]  +  w [ 1 ] * n2 [ 0 ]  +  w [ 2 ] * n3 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 1 ] =  w [ 0 ] * n1 [ 1 ]  +  w [ 1 ] * n2 [ 1 ]  +  w [ 2 ] * n3 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 2 ] =  w [ 0 ] * n1 [ 2 ]  +  w [ 1 ] * n2 [ 2 ]  +  w [ 2 ] * n3 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												CalcNormFloat ( v1 , v2 , v3 , nor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* calculate tangent vectors */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( utan  & &  vtan ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( tface ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv1 =  tface - > uv [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv2 =  tface - > uv [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv3 =  tface - > uv [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv4 =  tface - > uv [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv1 =  tuv [ 0 ] ;  uv2 =  tuv [ 1 ] ;  uv3 =  tuv [ 2 ] ;  uv4 =  tuv [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											spheremap ( v1 [ 0 ] ,  v1 [ 1 ] ,  v1 [ 2 ] ,  uv1 ,  uv1 + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											spheremap ( v2 [ 0 ] ,  v2 [ 1 ] ,  v2 [ 2 ] ,  uv2 ,  uv2 + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											spheremap ( v3 [ 0 ] ,  v3 [ 1 ] ,  v3 [ 2 ] ,  uv3 ,  uv3 + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( v4 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												spheremap ( v4 [ 0 ] ,  v4 [ 1 ] ,  v4 [ 2 ] ,  uv4 ,  uv4 + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( v4 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											s1 =  uv3 [ 0 ]  -  uv1 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											s2 =  uv4 [ 0 ]  -  uv1 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											t1 =  uv3 [ 1 ]  -  uv1 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											t2 =  uv4 [ 1 ]  -  uv1 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecSubf ( e1 ,  v3 ,  v1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecSubf ( e2 ,  v4 ,  v1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											s1 =  uv2 [ 0 ]  -  uv1 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											s2 =  uv3 [ 0 ]  -  uv1 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											t1 =  uv2 [ 1 ]  -  uv1 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											t2 =  uv3 [ 1 ]  -  uv1 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecSubf ( e1 ,  v2 ,  v1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecSubf ( e2 ,  v3 ,  v1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vtan [ 0 ]  =  ( s1 * e2 [ 0 ]  -  s2 * e1 [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vtan [ 1 ]  =  ( s1 * e2 [ 1 ]  -  s2 * e1 [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										vtan [ 2 ]  =  ( s1 * e2 [ 2 ]  -  s2 * e1 [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										utan [ 0 ]  =  ( t1 * e2 [ 0 ]  -  t2 * e1 [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										utan [ 1 ]  =  ( t1 * e2 [ 1 ]  -  t2 * e1 [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										utan [ 2 ]  =  ( t1 * e2 [ 2 ]  -  t2 * e1 [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( orco )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( orcodata )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											o1 =  orcodata [ mface - > v1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											o2 =  orcodata [ mface - > v2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											o3 =  orcodata [ mface - > v3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( mface - > v4 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												o4 =  orcodata [ mface - > v4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												orco [ 0 ] =  w [ 0 ] * o1 [ 0 ]  +  w [ 1 ] * o2 [ 0 ]  +  w [ 2 ] * o3 [ 0 ]  +  w [ 3 ] * o4 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												orco [ 1 ] =  w [ 0 ] * o1 [ 1 ]  +  w [ 1 ] * o2 [ 1 ]  +  w [ 2 ] * o3 [ 1 ]  +  w [ 3 ] * o4 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												orco [ 2 ] =  w [ 0 ] * o1 [ 2 ]  +  w [ 1 ] * o2 [ 2 ]  +  w [ 2 ] * o3 [ 2 ]  +  w [ 3 ] * o4 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ornor ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													CalcNormFloat4 ( o1 ,  o2 ,  o3 ,  o4 ,  ornor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												orco [ 0 ] =  w [ 0 ] * o1 [ 0 ]  +  w [ 1 ] * o2 [ 0 ]  +  w [ 2 ] * o3 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												orco [ 1 ] =  w [ 0 ] * o1 [ 1 ]  +  w [ 1 ] * o2 [ 1 ]  +  w [ 2 ] * o3 [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												orco [ 2 ] =  w [ 0 ] * o1 [ 2 ]  +  w [ 1 ] * o2 [ 2 ]  +  w [ 2 ] * o3 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ornor ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													CalcNormFloat ( o1 ,  o2 ,  o3 ,  ornor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECCOPY ( orco ,  vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ornor ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( ornor ,  nor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 22:42:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_interpolate_uvs ( MTFace  * tface ,  int  quad ,  float  * w ,  float  * uvco ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									float  v10 =  tface - > uv [ 0 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v11 =  tface - > uv [ 0 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v20 =  tface - > uv [ 1 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v21 =  tface - > uv [ 1 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v30 =  tface - > uv [ 2 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v31 =  tface - > uv [ 2 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v40 , v41 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( quad )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										v40 =  tface - > uv [ 3 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										v41 =  tface - > uv [ 3 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										uvco [ 0 ] =  w [ 0 ] * v10  +  w [ 1 ] * v20  +  w [ 2 ] * v30  +  w [ 3 ] * v40 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										uvco [ 1 ] =  w [ 0 ] * v11  +  w [ 1 ] * v21  +  w [ 2 ] * v31  +  w [ 3 ] * v41 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										uvco [ 0 ] =  w [ 0 ] * v10  +  w [ 1 ] * v20  +  w [ 2 ] * v30 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										uvco [ 1 ] =  w [ 0 ] * v11  +  w [ 1 ] * v21  +  w [ 2 ] * v31 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 22:42:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_interpolate_mcol ( MCol  * mcol ,  int  quad ,  float  * w ,  MCol  * mc ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									char  * cp ,  * cp1 ,  * cp2 ,  * cp3 ,  * cp4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									cp =  ( char  * ) mc ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									cp1 =  ( char  * ) & mcol [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									cp2 =  ( char  * ) & mcol [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									cp3 =  ( char  * ) & mcol [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( quad )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp4 =  ( char  * ) & mcol [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 0 ] =  ( int ) ( w [ 0 ] * cp1 [ 0 ]  +  w [ 1 ] * cp2 [ 0 ]  +  w [ 2 ] * cp3 [ 0 ]  +  w [ 3 ] * cp4 [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 1 ] =  ( int ) ( w [ 0 ] * cp1 [ 1 ]  +  w [ 1 ] * cp2 [ 1 ]  +  w [ 2 ] * cp3 [ 1 ]  +  w [ 3 ] * cp4 [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 2 ] =  ( int ) ( w [ 0 ] * cp1 [ 2 ]  +  w [ 1 ] * cp2 [ 2 ]  +  w [ 2 ] * cp3 [ 2 ]  +  w [ 3 ] * cp4 [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 3 ] =  ( int ) ( w [ 0 ] * cp1 [ 3 ]  +  w [ 1 ] * cp2 [ 3 ]  +  w [ 2 ] * cp3 [ 3 ]  +  w [ 3 ] * cp4 [ 3 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 0 ] =  ( int ) ( w [ 0 ] * cp1 [ 0 ]  +  w [ 1 ] * cp2 [ 0 ]  +  w [ 2 ] * cp3 [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 1 ] =  ( int ) ( w [ 0 ] * cp1 [ 1 ]  +  w [ 1 ] * cp2 [ 1 ]  +  w [ 2 ] * cp3 [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 2 ] =  ( int ) ( w [ 0 ] * cp1 [ 2 ]  +  w [ 1 ] * cp2 [ 2 ]  +  w [ 2 ] * cp3 [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cp [ 3 ] =  ( int ) ( w [ 0 ] * cp1 [ 3 ]  +  w [ 1 ] * cp2 [ 3 ]  +  w [ 2 ] * cp3 [ 3 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								float  psys_interpolate_value_from_verts ( DerivedMesh  * dm ,  short  from ,  int  index ,  float  * fw ,  float  * values ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-04-12 18:15:10 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( values = = 0  | |  index = = - 1 ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										return  0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									switch ( from ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_FROM_VERT : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  values [ index ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_FROM_FACE : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_FROM_VOLUME : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											MFace  * mf = dm - > getFaceData ( dm , index , CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  interpolate_particle_value ( values [ mf - > v1 ] , values [ mf - > v2 ] , values [ mf - > v3 ] , values [ mf - > v4 ] , fw , mf - > v4 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* conversion of pa->fw to origspace layer coordinates */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  psys_w_to_origspace ( float  * w ,  float  * uv ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									uv [ 0 ] =  w [ 1 ]  +  w [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									uv [ 1 ] =  w [ 2 ]  +  w [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* conversion of pa->fw to weights in face from origspace */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  psys_origspace_to_w ( OrigSpaceFace  * osface ,  int  quad ,  float  * w ,  float  * neww ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  v [ 4 ] [ 3 ] ,  co [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									v [ 0 ] [ 0 ] =  osface - > uv [ 0 ] [ 0 ] ;  v [ 0 ] [ 1 ] =  osface - > uv [ 0 ] [ 1 ] ;  v [ 0 ] [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									v [ 1 ] [ 0 ] =  osface - > uv [ 1 ] [ 0 ] ;  v [ 1 ] [ 1 ] =  osface - > uv [ 1 ] [ 1 ] ;  v [ 1 ] [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									v [ 2 ] [ 0 ] =  osface - > uv [ 2 ] [ 0 ] ;  v [ 2 ] [ 1 ] =  osface - > uv [ 2 ] [ 1 ] ;  v [ 2 ] [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys_w_to_origspace ( w ,  co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									co [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( quad )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										v [ 3 ] [ 0 ] =  osface - > uv [ 3 ] [ 0 ] ;  v [ 3 ] [ 1 ] =  osface - > uv [ 3 ] [ 1 ] ;  v [ 3 ] [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MeanValueWeights ( v ,  4 ,  co ,  neww ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MeanValueWeights ( v ,  3 ,  co ,  neww ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										neww [ 3 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								/* find the derived mesh face for a particle, set the mf passed. this is slow
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  and  can  be  optimized  but  only  for  many  lookups .  returns  the  face  index .  */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								int  psys_particle_dm_face_lookup ( Object  * ob ,  DerivedMesh  * dm ,  int  index ,  float  * fw ,  struct  LinkNode  * node ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mesh  * me =  ( Mesh * ) ob - > data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MFace  * mface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									OrigSpaceFace  * osface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  * origindex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  quad ,  findex ,  totface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  uv [ 2 ] ,  ( * faceuv ) [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									mface  =  dm - > getFaceDataArray ( dm ,  CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									origindex  =  dm - > getFaceDataArray ( dm ,  CD_ORIGINDEX ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									osface  =  dm - > getFaceDataArray ( dm ,  CD_ORIGSPACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totface  =  dm - > getNumFaces ( dm ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( osface = = NULL  | |  origindex = = NULL )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* Assume we dont need osface data */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( index  < totface )  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-11-27 11:17:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											//printf("\tNO CD_ORIGSPACE, assuming not needed\n");
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											return  index ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										}  else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											printf ( " \t NO CD_ORIGSPACE, error out of range \n " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  DMCACHE_NOTFOUND ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( index  > =  me - > totface ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  DMCACHE_NOTFOUND ;  /* index not in the original mesh */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys_w_to_origspace ( fw ,  uv ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( node )  {  /* we have a linked list of faces that we use, faster! */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( ; node ;  node = node - > next )  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-18 10:49:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											findex =  GET_INT_FROM_POINTER ( node - > link ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											faceuv =  osface [ findex ] . uv ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											quad =  mface [ findex ] . v4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* check that this intersects - Its possible this misses :/ -
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											 *  could  also  check  its  not  between  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( quad )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( IsectPQ2Df ( uv ,  faceuv [ 0 ] ,  faceuv [ 1 ] ,  faceuv [ 2 ] ,  faceuv [ 3 ] ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													return  findex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  if ( IsectPT2Df ( uv ,  faceuv [ 0 ] ,  faceuv [ 1 ] ,  faceuv [ 2 ] ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  findex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  {  /* if we have no node, try every face */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( findex = 0 ;  findex < totface ;  findex + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( origindex [ findex ]  = =  index )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												faceuv =  osface [ findex ] . uv ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												quad =  mface [ findex ] . v4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												/* check that this intersects - Its possible this misses :/ -
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												 *  could  also  check  its  not  between  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( quad )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( IsectPQ2Df ( uv ,  faceuv [ 0 ] ,  faceuv [ 1 ] ,  faceuv [ 2 ] ,  faceuv [ 3 ] ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														return  findex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  if ( IsectPT2Df ( uv ,  faceuv [ 0 ] ,  faceuv [ 1 ] ,  faceuv [ 2 ] ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													return  findex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  DMCACHE_NOTFOUND ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  int  psys_map_index_on_dm ( DerivedMesh  * dm ,  int  from ,  int  index ,  int  index_dmcache ,  float  * fw ,  float  foffset ,  int  * mapindex ,  float  * mapfw ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( index  <  0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( dm - > deformedOnly  | |  index_dmcache  = =  DMCACHE_ISCHILD )  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* for meshes that are either only defined or for child particles, the
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										 *  index  and  fw  do  not  require  any  mapping ,  so  we  can  directly  use  it  */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										if ( from  = =  PART_FROM_VERT )  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( index  > =  dm - > getNumVerts ( dm ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											* mapindex  =  index ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else   {  /* FROM_FACE/FROM_VOLUME */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( index  > =  dm - > getNumFaces ( dm ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											* mapindex  =  index ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											QUATCOPY ( mapfw ,  fw ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									}  else  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* for other meshes that have been modified, we try to map the particle
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										 *  to  their  new  location ,  which  means  a  different  index ,  and  for  faces 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										 *  also  a  new  face  interpolation  weights  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( from  = =  PART_FROM_VERT )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if  ( index_dmcache  = =  DMCACHE_NOTFOUND  | |  index_dmcache  >  dm - > getNumVerts ( dm ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											* mapindex  =  index_dmcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else   {  /* FROM_FACE/FROM_VOLUME */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											/* find a face on the derived mesh that uses this face */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											MFace  * mface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											OrigSpaceFace  * osface ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											int  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											i  =  index_dmcache ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( i = =  DMCACHE_NOTFOUND  | |  i  > =  dm - > getNumFaces ( dm ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											* mapindex  =  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* modify the original weights to become
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											 *  weights  for  the  derived  mesh  face  */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											osface =  dm - > getFaceDataArray ( dm ,  CD_ORIGSPACE ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											mface =  dm - > getFaceData ( dm ,  i ,  CD_MFACE ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( osface  = =  NULL ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												mapfw [ 0 ] =  mapfw [ 1 ] =  mapfw [ 2 ] =  mapfw [ 3 ] =  0.0f ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												psys_origspace_to_w ( & osface [ i ] ,  mface - > v4 ,  fw ,  mapfw ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								/* interprets particle data to get a point on a mesh in object space */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_particle_on_dm ( DerivedMesh  * dm ,  int  from ,  int  index ,  int  index_dmcache ,  float  * fw ,  float  foffset ,  float  * vec ,  float  * nor ,  float  * utan ,  float  * vtan ,  float  * orco ,  float  * ornor ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  tmpnor [ 3 ] ,  mapfw [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  ( * orcodata ) [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  mapindex ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ! psys_map_index_on_dm ( dm ,  from ,  index ,  index_dmcache ,  fw ,  foffset ,  & mapindex ,  mapfw ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( vec )  {  vec [ 0 ] = vec [ 1 ] = vec [ 2 ] = 0.0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( nor )  {  nor [ 0 ] = nor [ 1 ] = 0.0 ;  nor [ 2 ] = 1.0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( orco )  {  orco [ 0 ] = orco [ 1 ] = orco [ 2 ] = 0.0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ornor )  {  ornor [ 0 ] = ornor [ 1 ] = 0.0 ;  ornor [ 2 ] = 1.0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( utan )  {  utan [ 0 ] = utan [ 1 ] = utan [ 2 ] = 0.0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( vtan )  {  vtan [ 0 ] = vtan [ 1 ] = vtan [ 2 ] = 0.0 ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									orcodata =  dm - > getVertDataArray ( dm ,  CD_ORCO ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( from  = =  PART_FROM_VERT )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										dm - > getVertCo ( dm , mapindex , vec ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( nor )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											dm - > getVertNo ( dm , mapindex , nor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( nor ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-18 10:49:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( orco ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECCOPY ( orco ,  orcodata [ mapindex ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ornor )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											dm - > getVertNo ( dm , mapindex , nor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( nor ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( utan  & &  vtan )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											utan [ 0 ] =  utan [ 1 ] =  utan [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											vtan [ 0 ] =  vtan [ 1 ] =  vtan [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									else  {  /* PART_FROM_FACE / PART_FROM_VOLUME */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MFace  * mface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MTFace  * mtface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MVert  * mvert ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										mface = dm - > getFaceData ( dm , mapindex , CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										mvert = dm - > getVertDataArray ( dm , CD_MVERT ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										mtface = CustomData_get_layer ( & dm - > faceData , CD_MTFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( mtface ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mtface  + =  mapindex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( from = = PART_FROM_VOLUME )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys_interpolate_face ( mvert , mface , mtface , orcodata , mapfw , vec , tmpnor , utan , vtan , orco , ornor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( nor ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( nor , tmpnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( tmpnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( tmpnor , - foffset ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( vec , vec , tmpnor ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys_interpolate_face ( mvert , mface , mtface , orcodata , mapfw , vec , nor , utan , vtan , orco , ornor ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								float  psys_particle_value_from_verts ( DerivedMesh  * dm ,  short  from ,  ParticleData  * pa ,  float  * values ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  mapfw [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  mapindex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ! psys_map_index_on_dm ( dm ,  from ,  pa - > num ,  pa - > num_dmcache ,  pa - > fuv ,  pa - > foffset ,  & mapindex ,  mapfw ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  psys_interpolate_value_from_verts ( dm ,  from ,  mapindex ,  mapfw ,  values ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								ParticleSystemModifierData  * psys_get_modifier ( Object  * ob ,  ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ModifierData  * md ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystemModifierData  * psmd ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( md = ob - > modifiers . first ;  md ;  md = md - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( md - > type = = eModifierType_ParticleSystem ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psmd =  ( ParticleSystemModifierData * )  md ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psmd - > psys = = psys ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  psmd ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Particles on a shape				*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* ready for future use */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 17:08:11 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  void  psys_particle_on_shape ( int  distr ,  int  index ,  float  * fuv ,  float  * vec ,  float  * nor ,  float  * utan ,  float  * vtan ,  float  * orco ,  float  * ornor ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* TODO */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  zerovec [ 3 ] = { 0.0f , 0.0f , 0.0f } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( vec ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( vec , zerovec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( nor ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( nor , zerovec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( utan ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( utan , zerovec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( vtan ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( vtan , zerovec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( orco ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( orco , zerovec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ornor ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( ornor , zerovec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Particles on emitter				*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_particle_on_emitter ( ParticleSystemModifierData  * psmd ,  int  from ,  int  index ,  int  index_dmcache ,  float  * fuv ,  float  foffset ,  float  * vec ,  float  * nor ,  float  * utan ,  float  * vtan ,  float  * orco ,  float  * ornor ) { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									if ( psmd ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-07-06 22:52:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psmd - > psys - > part - > distr = = PART_DISTR_GRID  & &  psmd - > psys - > part - > from  ! =  PART_FROM_VERT ) { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( vec ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( vec , fuv ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* we cant use the num_dmcache */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_dm ( psmd - > dm , from , index , index_dmcache , fuv , foffset , vec , nor , utan , vtan , orco , ornor ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_shape ( from , index , fuv , vec , nor , utan , vtan , orco , ornor ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Path Cache							*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  hair_to_particle ( ParticleKey  * key ,  HairKey  * hkey ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( key - > co ,  hkey - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									key - > time  =  hkey - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  bp_to_particle ( ParticleKey  * key ,  BodyPoint  * bp ,  HairKey  * hkey ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( key - > co ,  bp - > pos ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									key - > time  =  hkey - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  float  vert_weight ( MDeformVert  * dvert ,  int  group ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MDeformWeight  * dw ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( dvert )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										dw =  dvert - > dw ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( i =  dvert - > totweight ;  i > 0 ;  i - - ,  dw + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( dw - > def_nr  = =  group )  return  dw - > weight ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( i = = 1 )  break ;  /*otherwise dw will point to somewhere it shouldn't*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								static  void  do_prekink ( ParticleKey  * state ,  ParticleKey  * par ,  float  * par_rot ,  float  time ,  float  freq ,  float  shape ,  float  amplitude ,  short  type ,  short  axis ,  float  obmat [ ] [ 4 ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  vec [ 3 ] = { 0.0 , 0.0 , 0.0 } ,  q1 [ 4 ] = { 1 , 0 , 0 , 0 } , q2 [ 4 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									float  t ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									CLAMP ( time , 0.0 , 1.0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( shape ! = 0.0f  & &  type ! = PART_KINK_BRAID )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( shape < 0.0f ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											time =  ( float ) pow ( time ,  1.0 + shape ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											time =  ( float ) pow ( time ,  1.0 / ( 1.0 - shape ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									t = time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									t * = ( float ) M_PI * freq ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( par = = 0 )  return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									switch ( type ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_KINK_CURL : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											vec [ axis ] = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( par_rot ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												QUATCOPY ( q2 , par_rot ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												vectoquat ( par - > vel , axis , ( axis + 1 ) % 3 ,  q2 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											QuatMulVecf ( q2 , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( vec , amplitude ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( state - > co , state - > co , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECSUB ( vec , state - > co , par - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( t ! = 0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecRotToQuat ( par - > vel , t , q1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											QuatMulVecf ( q1 , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( state - > co , par - > co , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_KINK_RADIAL : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECSUB ( vec , state - > co , par - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( vec , amplitude * ( float ) sin ( t ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( state - > co , state - > co , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_KINK_WAVE : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											vec [ axis ] = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( obmat ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												Mat4Mul3Vecfl ( obmat , vec ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( par_rot ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												QuatMulVecf ( par_rot , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Projf ( q1 , vec , par - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECSUB ( vec , vec , q1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( vec , amplitude * ( float ) sin ( t ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( state - > co , state - > co , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										case  PART_KINK_BRAID : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( par ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												float  y_vec [ 3 ] = { 0.0 , 1.0 , 0.0 } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												float  z_vec [ 3 ] = { 0.0 , 0.0 , 1.0 } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												float  vec_from_par [ 3 ] ,  vec_one [ 3 ] ,  radius ,  state_co [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												float  inp_y , inp_z , length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( par_rot ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													QUATCOPY ( q2 , par_rot ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												else 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													vectoquat ( par - > vel , axis , ( axis + 1 ) % 3 , q2 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												QuatMulVecf ( q2 , y_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												QuatMulVecf ( q2 , z_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECSUB ( vec_from_par , state - > co , par - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( vec_one , vec_from_par ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												radius = Normalize ( vec_one ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												inp_y = Inpf ( y_vec , vec_one ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												inp_z = Inpf ( z_vec , vec_one ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( inp_y > 0.5 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( state_co , y_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( y_vec , amplitude * ( float ) cos ( t ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( z_vec , amplitude / 2.0f * ( float ) sin ( 2.0f * t ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  if ( inp_z > 0.0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( state_co , z_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( state_co , ( float ) sin ( M_PI / 3.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECADDFAC ( state_co , state_co , y_vec , - 0.5f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( y_vec , - amplitude * ( float ) cos ( t  +  M_PI / 3.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( z_vec , amplitude / 2.0f * ( float ) cos ( 2.0f * t  +  M_PI / 6.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( state_co , z_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( state_co , - ( float ) sin ( M_PI / 3.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECADDFAC ( state_co , state_co , y_vec , - 0.5f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( y_vec , amplitude * ( float ) - sin ( t + M_PI / 6.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecMulf ( z_vec , amplitude / 2.0f * ( float ) - sin ( 2.0f * t + M_PI / 3.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecMulf ( state_co , amplitude ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECADD ( state_co , state_co , par - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECSUB ( vec_from_par , state - > co , state_co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												length = Normalize ( vec_from_par ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecMulf ( vec_from_par , MIN2 ( length , amplitude / 2.0f ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECADD ( state_co , par - > co , y_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECADD ( state_co , state_co , z_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECADD ( state_co , state_co , vec_from_par ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												shape = ( 2.0f * ( float ) M_PI ) * ( 1.0f + shape ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( t < shape ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													shape = t / shape ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													shape = ( float ) sqrt ( ( double ) shape ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VecLerpf ( state - > co , state - > co , state_co , shape ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( state - > co , state_co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								static  void  do_clump ( ParticleKey  * state ,  ParticleKey  * par ,  float  time ,  float  clumpfac ,  float  clumppow ,  float  pa_clump ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( par  & &  clumpfac ! = 0.0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										float  clump ,  cpow ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( clumppow < 0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpow = 1.0f + clumppow ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpow = 1.0f + 9.0f * clumppow ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( clumpfac < 0.0 )  /* clump roots instead of tips */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											clump  =  - clumpfac * pa_clump * ( float ) pow ( 1.0 - ( double ) time , ( double ) cpow ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											clump  =  clumpfac * pa_clump * ( float ) pow ( ( double ) time , ( double ) cpow ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VecLerpf ( state - > co , state - > co , par - > co , clump ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								int  do_guide ( Scene  * scene ,  ParticleKey  * state ,  int  pa_num ,  float  time ,  ListBase  * lb ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									PartDeflect  * pd ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleEffectorCache  * ec ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * eob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Curve  * cu ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleKey  key ,  par ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  effect [ 3 ] = { 0.0 , 0.0 , 0.0 } ,  distance ,  f_force ,  mindist ,  totforce = 0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  guidevec [ 4 ] ,  guidedir [ 3 ] ,  rot2 [ 4 ] ,  temp [ 3 ] ,  angle ,  pa_loc [ 3 ] ,  pa_zero [ 3 ] = { 0.0f , 0.0f , 0.0f } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  veffect [ 3 ] = { 0.0 , 0.0 , 0.0 } ,  guidetime ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									effect [ 0 ] = effect [ 1 ] = effect [ 2 ] = 0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( lb - > first ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( ec  =  lb - > first ;  ec ;  ec =  ec - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											eob =  ec - > ob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ec - > type  &  PSYS_EC_EFFECTOR ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												pd = eob - > pd ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( pd - > forcefield = = PFIELD_GUIDE ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													cu  =  ( Curve * ) eob - > data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													distance = ec - > distances [ pa_num ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													mindist = pd - > f_strength ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( pa_loc ,  ec - > locations + 3 * pa_num ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( pa_zero , pa_loc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECADD ( pa_zero , pa_zero , ec - > firstloc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													guidetime = time / ( 1.0 - pd - > free_end ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													/* WARNING: bails out with continue here */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( ( ( pd - > flag  &  PFIELD_USEMAX )  & &  distance > pd - > maxdist )  | |  guidetime > 1.0f )  continue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( guidetime > 1.0f )  continue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													/* calculate contribution factor for this guide */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													f_force = 1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( distance < = mindist ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else  if ( pd - > flag  &  PFIELD_USEMAX )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														if ( mindist > = pd - > maxdist )  f_force =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														else  if ( pd - > f_power ! = 0.0f ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															f_force =  1.0f  -  ( distance - mindist ) / ( pd - > maxdist  -  mindist ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															f_force  =  ( float ) pow ( f_force ,  pd - > f_power ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else  if ( pd - > f_power ! = 0.0f ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														f_force =  1.0f / ( 1.0f  +  distance - mindist ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														f_force  =  ( float ) pow ( f_force ,  pd - > f_power ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( pd - > flag  &  PFIELD_GUIDE_PATH_ADD ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														where_on_path ( eob ,  f_force * guidetime ,  guidevec ,  guidedir ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														where_on_path ( eob ,  guidetime ,  guidevec ,  guidedir ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													Mat4MulVecfl ( ec - > ob - > obmat , guidevec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													Mat4Mul3Vecfl ( ec - > ob - > obmat , guidedir ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													Normalize ( guidedir ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( guidetime ! = 0.0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														/* curve direction */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														Crossf ( temp ,  ec - > firstdir ,  guidedir ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														angle = Inpf ( ec - > firstdir , guidedir ) / ( VecLength ( ec - > firstdir ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														angle = saacos ( angle ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														VecRotToQuat ( temp , angle , rot2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														QuatMulVecf ( rot2 , pa_loc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														/* curve tilt */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														VecRotToQuat ( guidedir , guidevec [ 3 ] - ec - > firstloc [ 3 ] , rot2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														QuatMulVecf ( rot2 , pa_loc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														//vectoquat(guidedir, pd->kink_axis, (pd->kink_axis+1)%3, q);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
														//QuatMul(par.rot,rot2,q);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													//else{
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													//	par.rot[0]=1.0f;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													//	par.rot[1]=par.rot[2]=par.rot[3]=0.0f;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													/* curve taper */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( cu - > taperobj ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														VecMulf ( pa_loc ,  calc_taper ( scene ,  cu - > taperobj ,  ( int ) ( f_force * guidetime * 100.0 ) ,  100 ) ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													/* TODO */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													//else{
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													///* curve size*/
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													par . co [ 0 ] = par . co [ 1 ] = par . co [ 2 ] = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( key . co , pa_loc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													do_prekink ( & key ,  & par ,  0 ,  guidetime ,  pd - > kink_freq ,  pd - > kink_shape ,  pd - > kink_amp ,  pd - > kink ,  pd - > kink_axis ,  0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													do_clump ( & key ,  & par ,  guidetime ,  pd - > clump_fac ,  pd - > clump_pow ,  1.0f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( pa_loc , key . co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECADD ( pa_loc , pa_loc , guidevec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECSUB ( pa_loc , pa_loc , pa_zero ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECADDFAC ( effect , effect , pa_loc , f_force ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECADDFAC ( veffect , veffect , guidedir , f_force ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													totforce + = f_force ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( totforce ! = 0.0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( totforce > 1.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecMulf ( effect , 1.0f / totforce ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											CLAMP ( totforce , 0.0 , 1.0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( effect , effect , pa_zero ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecLerpf ( state - > co , state - > co , effect , totforce ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( veffect ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( veffect , VecLength ( state - > vel ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECCOPY ( state - > vel , veffect ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  do_rough ( float  * loc ,  float  t ,  float  fac ,  float  size ,  float  thres ,  ParticleKey  * state ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  rough [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  rco [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( thres ! = 0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ( float ) fabs ( ( float ) ( - 1.5 + loc [ 0 ] + loc [ 1 ] + loc [ 2 ] ) ) < 1.5f * thres )  return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( rco , loc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( rco , t ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									rough [ 0 ] = - 1.0f + 2.0f * BLI_gTurbulence ( size ,  rco [ 0 ] ,  rco [ 1 ] ,  rco [ 2 ] ,  2 , 0 , 2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									rough [ 1 ] = - 1.0f + 2.0f * BLI_gTurbulence ( size ,  rco [ 1 ] ,  rco [ 2 ] ,  rco [ 0 ] ,  2 , 0 , 2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									rough [ 2 ] = - 1.0f + 2.0f * BLI_gTurbulence ( size ,  rco [ 2 ] ,  rco [ 0 ] ,  rco [ 1 ] ,  2 , 0 , 2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADDFAC ( state - > co , state - > co , rough , fac ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  do_rough_end ( float  * loc ,  float  t ,  float  fac ,  float  shape ,  ParticleKey  * state ,  ParticleKey  * par ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  rough [ 3 ] ,  rnor [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  roughfac ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									roughfac = fac * ( float ) pow ( ( double ) t , shape ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( rough , loc ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									rough [ 0 ] = - 1.0f + 2.0f * rough [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									rough [ 1 ] = - 1.0f + 2.0f * rough [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									rough [ 2 ] = - 1.0f + 2.0f * rough [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( rough , roughfac ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( par ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( rnor , par - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( rnor , state - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Normalize ( rnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Projf ( rnor , rough , rnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECSUB ( rough , rough , rnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADD ( state - > co , state - > co , rough ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  void  do_path_effectors ( Scene  * scene ,  Object  * ob ,  ParticleSystem  * psys ,  int  i ,  ParticleCacheKey  * ca ,  int  k ,  int  steps ,  float  * rootco ,  float  effector ,  float  dfra ,  float  cfra ,  float  * length ,  float  * vec ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  force [ 3 ]  =  { 0.0f , 0.0f , 0.0f } ,  vel [ 3 ]  =  { 0.0f , 0.0f , 0.0f } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleKey  eff_key ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( eff_key . co , ( ca - 1 ) - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( eff_key . vel , ( ca - 1 ) - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									QUATCOPY ( eff_key . rot , ( ca - 1 ) - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									pa =  psys - > particles + i ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									do_effectors ( i ,  pa ,  & eff_key ,  scene ,  ob ,  psys ,  rootco ,  force ,  vel ,  dfra ,  cfra ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( force ,  effector * pow ( ( float ) k  /  ( float ) steps ,  100.0f  *  psys - > part - > eff_hair )  /  ( float ) steps ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecAddf ( force ,  force ,  vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Normalize ( force ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									VECADDFAC ( ca - > co ,  ( ca - 1 ) - > co ,  force ,  * length ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( k  <  steps )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VecSubf ( vec ,  ( ca + 1 ) - > co ,  ca - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										* length  =  VecLength ( vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  int  check_path_length ( int  k ,  ParticleCacheKey  * keys ,  ParticleCacheKey  * state ,  float  max_length ,  float  * cur_length ,  float  length ,  float  * dvec ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( * cur_length  +  length  >  max_length ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VecMulf ( dvec ,  ( max_length  -  * cur_length )  /  length ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECADD ( state - > co ,  ( state  -  1 ) - > co ,  dvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										keys - > steps  =  k ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* something over the maximum step value */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  k = 100000 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										* cur_length + = length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  k ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  offset_child ( ChildParticle  * cpa ,  ParticleKey  * par ,  ParticleKey  * child ,  float  flat ,  float  radius ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( child - > co , cpa - > fuv ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( child - > co , radius ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									child - > co [ 0 ] * = flat ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( child - > vel , par - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									QuatMulVecf ( par - > rot , child - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									QUATCOPY ( child - > rot , par - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADD ( child - > co , child - > co , par - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								float  * psys_cache_vgroup ( DerivedMesh  * dm ,  ParticleSystem  * psys ,  int  vgroup ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  * vg = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psys - > vgroup [ vgroup ] ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MDeformVert  * dvert  =  dm - > getVertDataArray ( dm ,  CD_MDEFORMVERT ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( dvert ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											int  totvert = dm - > getNumVerts ( dm ) ,  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											vg = MEM_callocN ( sizeof ( float ) * totvert ,  " vg_cache " ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > vg_neg & ( 1 < < vgroup ) ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												for ( i = 0 ;  i < totvert ;  i + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													vg [ i ] = 1.0f - vert_weight ( dvert + i , psys - > vgroup [ vgroup ] - 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												for ( i = 0 ;  i < totvert ;  i + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													vg [ i ] = vert_weight ( dvert + i , psys - > vgroup [ vgroup ] - 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  vg ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_find_parents ( Object  * ob ,  ParticleSystemModifierData  * psmd ,  ParticleSystem  * psys ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part = psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									KDTree  * tree ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ChildParticle  * cpa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  p ,  totparent , totchild = psys - > totchild ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  co [ 3 ] ,  orco [ 3 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									int  from = PART_FROM_FACE ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totparent = ( int ) ( totchild * part - > parents * 0.3 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( G . rendering  & &  part - > child_nbr  & &  part - > ren_child_nbr ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totparent * = ( float ) part - > child_nbr / ( float ) part - > ren_child_nbr ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									tree = BLI_kdtree_new ( totparent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( p = 0 , cpa = psys - > child ;  p < totparent ;  p + + , cpa + + ) { 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( psmd , from , cpa - > num , DMCACHE_ISCHILD , cpa - > fuv , cpa - > foffset , co , 0 , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										BLI_kdtree_insert ( tree ,  p ,  orco ,  NULL ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									BLI_kdtree_balance ( tree ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( ;  p < totchild ;  p + + , cpa + + ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( psmd , from , cpa - > num , DMCACHE_ISCHILD , cpa - > fuv , cpa - > foffset , co , 0 , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										cpa - > parent = BLI_kdtree_find_nearest ( tree ,  orco ,  NULL ,  NULL ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									BLI_kdtree_free ( tree ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  get_strand_normal ( Material  * ma ,  float  * surfnor ,  float  surfdist ,  float  * nor ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  cross [ 3 ] ,  nstrand [ 3 ] ,  vnor [ 3 ] ,  blend ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ! ( ( ma - > mode  &  MA_STR_SURFDIFF )  | |  ( ma - > strand_surfnor  >  0.0f ) ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ma - > mode  &  MA_STR_SURFDIFF )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( cross ,  surfnor ,  nor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( nstrand ,  nor ,  cross ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										blend =  INPR ( nstrand ,  surfnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										CLAMP ( blend ,  0.0f ,  1.0f ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										VecLerpf ( vnor ,  nstrand ,  surfnor ,  blend ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( vnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										VECCOPY ( vnor ,  nor ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ma - > strand_surfnor  >  0.0f )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ma - > strand_surfnor  >  surfdist )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											blend =  ( ma - > strand_surfnor  -  surfdist ) / ma - > strand_surfnor ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecLerpf ( vnor ,  vnor ,  surfnor ,  blend ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( vnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( nor ,  vnor ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								int  psys_threads_init_path ( ParticleThread  * threads ,  Scene  * scene ,  float  cfra ,  int  editupdate ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleThreadContext  * ctx =  threads [ 0 ] . ctx ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * ob =  ctx - > ob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys =  ctx - > psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleEditSettings  * pset  =  & scene - > toolsettings - > particle ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									int  totparent = 0 ,  between = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  steps  =  ( int ) pow ( 2.0 , ( double ) part - > draw_step ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totchild  =  psys - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ,  seed ,  totthread =  threads [ 0 ] . tot ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/*---start figuring out what is actually wanted---*/ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys_in_edit_mode ( scene ,  psys ) ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > renderdata = = 0  & &  ( psys - > edit = = NULL  | |  pset - > flag  &  PE_SHOW_CHILD ) = = 0 ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											totchild = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( totchild  & &  part - > from ! = PART_FROM_PARTICLE  & &  part - > childtype = = PART_CHILD_FACES ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totparent = ( int ) ( totchild * part - > parents * 0.3 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( G . rendering  & &  part - > child_nbr  & &  part - > ren_child_nbr ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											totparent * = ( float ) part - > child_nbr / ( float ) part - > ren_child_nbr ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										/* part->parents could still be 0 so we can't test with totparent */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										between = 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-18 16:55:09 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > renderdata ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										steps = ( int ) pow ( 2.0 , ( double ) part - > ren_step ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totchild = ( int ) ( ( float ) totchild * ( float ) part - > disp / 100.0f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totparent = MIN2 ( totparent , totchild ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( totchild = = 0 )  return  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									/* init random number generator */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ctx - > psys - > part - > flag  &  PART_ANIM_BRANCHING ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										seed =  31415926  +  ctx - > psys - > seed  +  ( int ) cfra ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										seed =  31415926  +  ctx - > psys - > seed ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > flag  &  PART_BRANCHING  | |  ctx - > editupdate  | |  totchild  <  10000 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totthread =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = 0 ;  i < totthread ;  i + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										threads [ i ] . rng_path =  rng_new ( seed ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										threads [ i ] . tot =  totthread ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									/* fill context values */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ctx - > between =  between ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ctx - > steps =  steps ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ctx - > totchild =  totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ctx - > totparent =  totparent ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ctx - > parent_pass =  0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ctx - > cfra =  cfra ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys - > lattice  =  psys_get_lattice ( scene ,  ob ,  psys ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* cache all relevant vertex groups if they exist */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > from ! = PART_FROM_PARTICLE ) { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										ctx - > vg_length  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_LENGTH ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ctx - > vg_clump  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_CLUMP ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ctx - > vg_kink  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_KINK ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ctx - > vg_rough1  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_ROUGH1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ctx - > vg_rough2  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_ROUGH2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ctx - > vg_roughe  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_ROUGHE ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > part - > flag  &  PART_CHILD_EFFECT ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ctx - > vg_effector  =  psys_cache_vgroup ( ctx - > dm , psys , PSYS_VG_EFFECTOR ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* set correct ipo timing */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								#if 0  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > flag & PART_ABS_TIME  & &  part - > ipo ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										calc_ipo ( part - > ipo ,  cfra ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										execute_ipo ( ( ID  * ) part ,  part - > ipo ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# endif  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								/* note: this function must be thread safe, except for branching! */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_thread_create_path ( ParticleThread  * thread ,  struct  ChildParticle  * cpa ,  ParticleCacheKey  * keys ,  int  i ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleThreadContext  * ctx =  thread - > ctx ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * ob =  ctx - > ob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys  =  ctx - > psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * cache =  psys - > childcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * pcache =  psys - > pathcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * state ,  * par  =  NULL ,  * key [ 4 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleData  * pa = NULL ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleTexture  ptex ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  * cpa_fuv = 0 ,  * par_rot = 0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  co [ 3 ] ,  orco [ 3 ] ,  ornor [ 3 ] ,  t ,  rough_t ,  cpa_1st [ 3 ] ,  dvec [ 3 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  branch_begin ,  branch_end ,  branch_prob ,  branchfac ,  rough_rand ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  pa_rough1 ,  pa_rough2 ,  pa_roughe ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  length ,  pa_length ,  pa_clump ,  pa_kink ,  pa_effector ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  max_length  =  1.0f ,  cur_length  =  0.0f ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  eff_length ,  eff_vec [ 3 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									int  k ,  cpa_num ,  guided  =  0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									short  cpa_from ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > flag  &  PART_BRANCHING )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_begin = rng_getFloat ( thread - > rng_path ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_end = branch_begin + ( 1.0f - branch_begin ) * rng_getFloat ( thread - > rng_path ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_prob = rng_getFloat ( thread - > rng_path ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										rough_rand = rng_getFloat ( thread - > rng_path ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_begin =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_end =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_prob =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										rough_rand =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( i < psys - > totpart ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_begin = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_end = 1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										branch_prob = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ctx - > between ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										int  w ,  needupdate ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										float  foffset ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ctx - > editupdate  & &  ! ( part - > flag  &  PART_BRANCHING ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											needupdate =  0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											w =  0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											while ( w < 4  & &  cpa - > pa [ w ] > = 0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( psys - > particles [ cpa - > pa [ w ] ] . flag  &  PARS_EDIT_RECALC )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													needupdate =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												w + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ! needupdate ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												memset ( keys ,  0 ,  sizeof ( * keys ) * ( ctx - > steps + 1 ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* get parent paths */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										w =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										while ( w < 4  & &  cpa - > pa [ w ] > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											key [ w ]  =  pcache [ cpa - > pa [ w ] ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											w + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* get the original coordinates (orco) for texture usage */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cpa_num  =  cpa - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										foffset =  cpa - > foffset ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > childtype  = =  PART_CHILD_FACES ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											foffset  =  - ( 2.0f  +  part - > childspread ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cpa_fuv  =  cpa - > fuv ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cpa_from  =  PART_FROM_FACE ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( ctx - > psmd , cpa_from , cpa_num , DMCACHE_ISCHILD , cpa - > fuv , foffset , co , ornor , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* we need to save the actual root position of the child for positioning it accurately to the surface of the emitter */ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										VECCOPY ( cpa_1st , co ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Mat4MulVecfl ( ob - > obmat , cpa_1st ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ctx - > editupdate  & &  ! ( part - > flag  &  PART_BRANCHING ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ! ( psys - > particles [ cpa - > parent ] . flag  &  PARS_EDIT_RECALC ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											memset ( keys ,  0 ,  sizeof ( * keys ) * ( ctx - > steps + 1 ) ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* get the parent path */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										key [ 0 ] = pcache [ cpa - > parent ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* get the original coordinates (orco) for texture usage */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa = psys - > particles + cpa - > parent ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										cpa_from = part - > from ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cpa_num = pa - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cpa_fuv = pa - > fuv ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( ctx - > psmd , cpa_from , cpa_num , DMCACHE_ISCHILD , cpa_fuv , pa - > foffset , co , ornor , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									keys - > steps  =  ctx - > steps ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									/* correct child ipo timing */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								#if 0  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ( part - > flag & PART_ABS_TIME ) = = 0  & &  part - > ipo ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										float  dsta = part - > end - part - > sta ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										calc_ipo ( part - > ipo ,  100.0f * ( ctx - > cfra - ( part - > sta + dsta * cpa - > rand [ 1 ] ) ) / ( part - > lifetime * ( 1.0f  -  part - > randlife * cpa - > rand [ 0 ] ) ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										execute_ipo ( ( ID  * ) part ,  part - > ipo ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# endif  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									/* get different child parameters from textures & vgroups */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ptex . length = part - > length * ( 1.0f  -  part - > randlength * cpa - > rand [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ptex . clump = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ptex . kink = 1.0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ptex . rough =  1.0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ptex . exist =  1.0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									get_cpa_texture ( ctx - > dm , ctx - > ma , cpa_num , cpa_fuv , orco , & ptex , 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										MAP_PA_DENS | MAP_PA_LENGTH | MAP_PA_CLUMP | MAP_PA_KINK | MAP_PA_ROUGH ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									pa_length = ptex . length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									pa_clump = ptex . clump ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									pa_kink = ptex . kink ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									pa_rough1 = ptex . rough ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									pa_rough2 = ptex . rough ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									pa_roughe = ptex . rough ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									pa_effector =  1.0f ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ptex . exist  <  cpa - > rand [ 1 ] )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										keys - > steps  =  - 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_length ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_length * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_length ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_clump ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_clump * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_clump ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_kink ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_kink * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_kink ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_rough1 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_rough1 * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_rough1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_rough2 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_rough2 * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_rough2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_roughe ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_roughe * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_roughe ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ctx - > vg_effector ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_effector * = psys_interpolate_value_from_verts ( ctx - > dm , cpa_from , cpa_num , cpa_fuv , ctx - > vg_effector ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* create the child path */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( k = 0 , state = keys ;  k < = ctx - > steps ;  k + + , state + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ctx - > between ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											int  w = 0 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											state - > co [ 0 ]  =  state - > co [ 1 ]  =  state - > co [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											state - > vel [ 0 ]  =  state - > vel [ 1 ]  =  state - > vel [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											state - > rot [ 0 ]  =  state - > rot [ 1 ]  =  state - > rot [ 2 ]  =  state - > rot [ 3 ]  =  0.0f ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											//QUATCOPY(state->rot,key[0]->rot);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* child position is the weighted sum of parent positions */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											while ( w < 4  & &  cpa - > pa [ w ] > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > co [ 0 ]  + =  cpa - > w [ w ]  *  key [ w ] - > co [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > co [ 1 ]  + =  cpa - > w [ w ]  *  key [ w ] - > co [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > co [ 2 ]  + =  cpa - > w [ w ]  *  key [ w ] - > co [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > vel [ 0 ]  + =  cpa - > w [ w ]  *  key [ w ] - > vel [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > vel [ 1 ]  + =  cpa - > w [ w ]  *  key [ w ] - > vel [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > vel [ 2 ]  + =  cpa - > w [ w ]  *  key [ w ] - > vel [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												key [ w ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												w + + ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( k = = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												/* calculate the offset between actual child root position and first position interpolated from parents */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECSUB ( cpa_1st , cpa_1st , state - > co ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* apply offset for correct positioning */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADD ( state - > co , state - > co , cpa_1st ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* offset the child from the parent position */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											offset_child ( cpa ,  ( ParticleKey * ) key [ 0 ] ,  ( ParticleKey * ) state ,  part - > childflat ,  part - > childrad ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											key [ 0 ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* apply effectors */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > flag  &  PART_CHILD_EFFECT )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( k = 0 , state = keys ;  k < = ctx - > steps ;  k + + , state + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( k )  { 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												do_path_effectors ( ctx - > scene ,  ob ,  psys ,  cpa - > pa [ 0 ] ,  state ,  k ,  ctx - > steps ,  keys - > co ,  pa_effector ,  0.0f ,  ctx - > cfra ,  & eff_length ,  eff_vec ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecSubf ( eff_vec , ( state + 1 ) - > co , state - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												eff_length =  VecLength ( eff_vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( k = 0 , state = keys ;  k < = ctx - > steps ;  k + + , state + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										t = ( float ) k / ( float ) ctx - > steps ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ctx - > totparent ) { 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( i > = ctx - > totparent )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												/* this is now threadsafe, virtual parents are calculated before rest of children */ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												par  =  cache [ cpa - > parent ]  +  k ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												par = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( cpa - > parent > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											par = pcache [ cpa - > parent ] + k ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											par_rot  =  par - > rot ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* apply different deformations to the child path */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-07 22:39:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( part - > flag  &  PART_CHILD_EFFECT ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* state is safe to cast, since only co and vel are used */ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											guided  =  do_guide ( ctx - > scene ,  ( ParticleKey * ) state ,  cpa - > parent ,  t ,  & ( psys - > effectors ) ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( guided = = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( part - > kink ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												do_prekink ( ( ParticleKey * ) state ,  ( ParticleKey * ) par ,  par_rot ,  t , 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												part - > kink_freq  *  pa_kink ,  part - > kink_shape ,  part - > kink_amp ,  part - > kink ,  part - > kink_axis ,  ob - > obmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_clump ( ( ParticleKey * ) state ,  ( ParticleKey * ) par ,  t ,  part - > clumpfac ,  part - > clumppow ,  pa_clump ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( part - > flag  &  PART_BRANCHING  & &  ctx - > between  = =  0  & &  part - > flag  &  PART_ANIM_BRANCHING ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											rough_t  =  t  *  rough_rand ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											rough_t  =  t ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > rough1  ! =  0.0  & &  pa_rough1  ! =  0.0 ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											do_rough ( orco ,  rough_t ,  pa_rough1 * part - > rough1 ,  part - > rough1_size ,  0.0 ,  ( ParticleKey * ) state ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( part - > rough2  ! =  0.0  & &  pa_rough2  ! =  0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_rough ( cpa - > rand ,  rough_t ,  pa_rough2 * part - > rough2 ,  part - > rough2_size ,  part - > rough2_thres ,  ( ParticleKey * ) state ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( part - > rough_end  ! =  0.0  & &  pa_roughe  ! =  0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_rough_end ( cpa - > rand ,  rough_t ,  pa_roughe * part - > rough_end ,  part - > rough_end_shape ,  ( ParticleKey * ) state ,  ( ParticleKey * ) par ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( part - > flag  &  PART_BRANCHING  & &  ctx - > between = = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( branch_prob  >  part - > branch_thres ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												branchfac = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( part - > flag  &  PART_SYMM_BRANCHING ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( t  <  branch_begin  | |  t  >  branch_end ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														branchfac = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														if ( ( t - branch_begin ) / ( branch_end - branch_begin ) < 0.5 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															branchfac = 2.0f * ( t - branch_begin ) / ( branch_end - branch_begin ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															branchfac = 2.0f * ( branch_end - t ) / ( branch_end - branch_begin ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														CLAMP ( branchfac , 0.0f , 1.0f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													if ( t  <  branch_begin ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														branchfac = 0.0f ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														branchfac = ( t - branch_begin ) / ( ( 1.0f - branch_begin ) * 0.5f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														CLAMP ( branchfac , 0.0f , 1.0f ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( i < psys - > totpart ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecLerpf ( state - > co ,  ( pcache [ i ]  +  k ) - > co ,  state - > co ,  branchfac ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												/* this is not threadsafe, but should only happen for
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												 *  branching  particles  particles ,  which  are  not  threaded  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecLerpf ( state - > co ,  ( cache [ i  -  psys - > totpart ]  +  k ) - > co ,  state - > co ,  branchfac ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* we have to correct velocity because of kink & clump */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( k > 1 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECSUB ( ( state - 1 ) - > vel , state - > co , ( state - 2 ) - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( ( state - 1 ) - > vel , 0.5 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-11-27 14:12:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 15:03:45 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ctx - > ma  & &  ( part - > draw  &  PART_DRAW_MAT_COL ) ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												get_strand_normal ( ctx - > ma ,  ornor ,  cur_length ,  ( state - 1 ) - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* check if path needs to be cut before actual end of data points */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( k ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECSUB ( dvec , state - > co , ( state - 1 ) - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( part - > flag & PART_ABS_LENGTH ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												length = VecLength ( dvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												length = 1.0f / ( float ) ctx - > steps ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											k = check_path_length ( k , keys , state , max_length , & cur_length , length , dvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* initialize length calculation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( part - > flag & PART_ABS_LENGTH ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												max_length =  part - > abslength * pa_length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												max_length =  pa_length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cur_length =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 15:03:45 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ctx - > ma  & &  ( part - > draw  &  PART_DRAW_MAT_COL ) )  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											VECCOPY ( state - > col ,  & ctx - > ma - > r ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											get_strand_normal ( ctx - > ma ,  ornor ,  cur_length ,  state - > vel ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 17:08:11 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  void  * exec_child_path_cache ( void  * data ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleThread  * thread =  ( ParticleThread * ) data ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleThreadContext  * ctx =  thread - > ctx ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys =  ctx - > psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * cache =  psys - > childcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ChildParticle  * cpa ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									int  i ,  totchild =  ctx - > totchild ,  first =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( thread - > tot  >  1 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										first =  ctx - > parent_pass ?  0  :  ctx - > totparent ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										totchild =  ctx - > parent_pass ?  ctx - > totparent  :  ctx - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									cpa =  psys - > child  +  first  +  thread - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = first + thread - > num ;  i < totchild ;  i + = thread - > tot ,  cpa + = thread - > tot ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_thread_create_path ( thread ,  cpa ,  cache [ i ] ,  i ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_cache_child_paths ( Scene  * scene ,  Object  * ob ,  ParticleSystem  * psys ,  float  cfra ,  int  editupdate ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleThread  * pthreads ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleThreadContext  * ctx ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 19:25:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * * cache ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ListBase  threads ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ,  totchild ,  totparent ,  totthread ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									pthreads =  psys_threads_create ( scene ,  ob ,  psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ! psys_threads_init_path ( pthreads ,  scene ,  cfra ,  editupdate ) )  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_threads_free ( pthreads ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ctx =  pthreads [ 0 ] . ctx ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totchild =  ctx - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totparent =  ctx - > totparent ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( editupdate  & &  psys - > childcache  & &  ! ( part - > flag  &  PART_BRANCHING )  & &  totchild  = =  psys - > totchildcache )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cache  =  psys - > childcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* clear out old and create new empty path cache */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										free_child_path_cache ( psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 19:25:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys - > childcache =  psys_alloc_path_cache_buffers ( & psys - > childcachebufs ,  totchild ,  ctx - > steps + 1 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys - > totchildcache  =  totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									totthread =  pthreads [ 0 ] . tot ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( totthread  >  1 )  { 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* make virtual child parents thread safe by calculating them first */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( totparent )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											BLI_init_threads ( & threads ,  exec_child_path_cache ,  totthread ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											for ( i = 0 ;  i < totthread ;  i + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												pthreads [ i ] . ctx - > parent_pass  =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												BLI_insert_thread ( & threads ,  & pthreads [ i ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											BLI_end_threads ( & threads ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											for ( i = 0 ;  i < totthread ;  i + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												pthreads [ i ] . ctx - > parent_pass  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										BLI_init_threads ( & threads ,  exec_child_path_cache ,  totthread ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( i = 0 ;  i < totthread ;  i + + ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											BLI_insert_thread ( & threads ,  & pthreads [ i ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										BLI_end_threads ( & threads ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										exec_child_path_cache ( & pthreads [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys_threads_free ( pthreads ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								/* Calculates paths ready for drawing/rendering.									*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* -Usefull for making use of opengl vertex arrays for super fast strand drawing.	*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* -Makes child strands possible and creates them too into the cache.				*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* -Cached path data is also used to determine cut position for the editmode tool.	*/ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_cache_paths ( Scene  * scene ,  Object  * ob ,  ParticleSystem  * psys ,  float  cfra ,  int  editupdate ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleCacheKey  * ca ,  * * cache = psys - > pathcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystemModifierData  * psmd  =  psys_get_modifier ( ob ,  psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleEditSettings  * pset  =  & scene - > toolsettings - > particle ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleKey  keys [ 4 ] ,  result ,  * kkey [ 2 ]  =  { NULL ,  NULL } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									HairKey  * hkey [ 2 ]  =  { NULL ,  NULL } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleEdit  * edit  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleEditKey  * ekey  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									SoftBody  * soft  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									BodyPoint  * bp [ 2 ]  =  { NULL ,  NULL } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2007-11-27 14:12:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									Material  * ma ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									float  birthtime  =  0.0 ,  dietime  =  0.0 ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  t ,  time  =  0.0 ,  keytime  =  0.0 ,  dfra  =  1.0 ,  frs_sec  =  scene - > r . frs_sec ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									float  col [ 3 ]  =  { 0.5f ,  0.5f ,  0.5f } ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  prev_tangent [ 3 ] ,  hairmat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  k , i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  steps  =  ( int ) pow ( 2.0 ,  ( double ) psys - > part - > draw_step ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totpart  =  psys - > totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  sel_col [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  nosel_col [ 3 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  length ,  vec [ 3 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 14:16:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  * vg_effector =  NULL ,  effector = 0.0f ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  * vg_length =  NULL ,  pa_length = 1.0f ,  max_length = 1.0f ,  cur_length = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  len ,  dvec [ 3 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* we don't have anything valid to create paths from so let's quit here */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ( psys - > flag  &  PSYS_HAIR_DONE ) = = 0  & &  ( psys - > flag  &  PSYS_KEYED ) = = 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-02-25 19:29:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > renderdata )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										steps  =  ( int ) pow ( 2.0 ,  ( double ) psys - > part - > ren_step ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-02-25 19:29:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( psys_in_edit_mode ( scene ,  psys ) )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										edit = psys - > edit ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//timed = edit->draw_timed;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-02-25 19:29:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( pset - > brushtype  = =  PE_BRUSH_WEIGHT )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											sel_col [ 0 ]  =  sel_col [ 1 ]  =  sel_col [ 2 ]  =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											nosel_col [ 0 ]  =  nosel_col [ 1 ]  =  nosel_col [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
									
										
										
										
											2009-02-25 19:29:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											sel_col [ 0 ]  =  ( float ) edit - > sel_col [ 0 ]  /  255.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											sel_col [ 1 ]  =  ( float ) edit - > sel_col [ 1 ]  /  255.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											sel_col [ 2 ]  =  ( float ) edit - > sel_col [ 2 ]  /  255.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											nosel_col [ 0 ]  =  ( float ) edit - > nosel_col [ 0 ]  /  255.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											nosel_col [ 1 ]  =  ( float ) edit - > nosel_col [ 1 ]  /  255.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											nosel_col [ 2 ]  =  ( float ) edit - > nosel_col [ 2 ]  /  255.0f ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( editupdate  & &  psys - > pathcache  & &  totpart  = =  psys - > totcached )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cache  =  psys - > pathcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* clear out old and create new empty path cache */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys_free_path_cache ( psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-07 19:25:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										cache =  psys_alloc_path_cache_buffers ( & psys - > pathcachebufs ,  totpart ,  steps + 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > pathcache =  cache ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-05-22 13:58:16 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( edit = = NULL  & &  psys - > soft  & &  psys - > softflag  &  OB_SB_ENABLE )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										soft  =  psys - > soft ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-05-22 13:58:16 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ! soft - > bpoint ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											soft =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys - > lattice  =  psys_get_lattice ( scene ,  ob ,  psys ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-11-27 14:12:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ma =  give_current_material ( ob ,  psys - > part - > omat ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 15:03:45 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( ma  & &  ( psys - > part - > draw  &  PART_DRAW_MAT_COL ) ) 
							 
						 
					
						
							
								
									
										
										
										
											2007-11-27 14:12:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										VECCOPY ( col ,  & ma - > r ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 14:16:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > part - > from ! = PART_FROM_PARTICLE )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ! ( psys - > part - > flag  &  PART_CHILD_EFFECT ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											vg_effector  =  psys_cache_vgroup ( psmd - > dm ,  psys ,  PSYS_VG_EFFECTOR ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ! edit  & &  ! psys - > totchild ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											vg_length  =  psys_cache_vgroup ( psmd - > dm ,  psys ,  PSYS_VG_LENGTH ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/*---first main loop: create all actual particles' paths---*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = 0 , pa = psys - > particles ;  i < totpart ;  i + + ,  pa + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys  & &  edit = = NULL  & &  ( pa - > flag  &  PARS_NO_DISP  | |  pa - > flag  &  PARS_UNEXIST ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( soft ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												bp [ 0 ]  + =  pa - > totkey ;  /* TODO use of initialized value? */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											continue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( editupdate  & &  ! ( pa - > flag  &  PARS_EDIT_RECALC ) )  continue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  memset ( cache [ i ] ,  0 ,  sizeof ( * cache [ i ] ) * ( steps + 1 ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ! edit  & &  ! psys - > totchild )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa_length  =  part - > length  *  ( 1.0f  -  part - > randlength * pa - > r_ave [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( vg_length ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												pa_length  * =  psys_particle_value_from_verts ( psmd - > dm , part - > from , pa , vg_length ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										cache [ i ] - > steps  =  steps ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( edit ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ekey  =  edit - > keys [ i ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/*--get the first data points--*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_KEYED )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											kkey [ 0 ]  =  pa - > keys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											kkey [ 1 ]  =  kkey [ 0 ]  +  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											birthtime  =  kkey [ 0 ] - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											dietime  =  kkey [ 0 ] [ pa - > totkey - 1 ] . time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											hkey [ 0 ]  =  pa - > hair ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											hkey [ 1 ]  =  hkey [ 0 ]  +  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											birthtime  =  hkey [ 0 ] - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											dietime  =  hkey [ 0 ] [ pa - > totkey - 1 ] . time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											psys_mat_hair_to_global ( ob ,  psmd - > dm ,  psys - > part - > from ,  pa ,  hairmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( soft ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											bp [ 0 ]  =  soft - > bpoint  +  pa - > bpi ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											bp [ 1 ]  =  bp [ 0 ]  +  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/*--interpolate actual path from data points--*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( k = 0 ,  ca = cache [ i ] ;  k < = steps ;  k + + ,  ca + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											time  =  ( float ) k  /  ( float ) steps ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											t  =  birthtime  +  time  *  ( dietime  -  birthtime ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > flag  &  PSYS_KEYED )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												while ( kkey [ 1 ] - > time  <  t )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													kkey [ 1 ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												kkey [ 0 ]  =  kkey [ 1 ]  -  1 ; 				
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												while ( hkey [ 1 ] - > time  <  t )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													hkey [ 1 ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													bp [ 1 ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hkey [ 0 ]  =  hkey [ 1 ]  -  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( soft )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												bp [ 0 ]  =  bp [ 1 ]  -  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												bp_to_particle ( keys  +  1 ,  bp [ 0 ] ,  hkey [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												bp_to_particle ( keys  +  2 ,  bp [ 1 ] ,  hkey [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  if ( psys - > flag  &  PSYS_KEYED )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												memcpy ( keys  +  1 ,  kkey [ 0 ] ,  sizeof ( ParticleKey ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												memcpy ( keys  +  2 ,  kkey [ 1 ] ,  sizeof ( ParticleKey ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hair_to_particle ( keys  +  1 ,  hkey [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hair_to_particle ( keys  +  2 ,  hkey [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( psys - > flag  &  PSYS_KEYED ) = = 0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( soft )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( hkey [ 0 ]  ! =  pa - > hair ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														bp_to_particle ( keys ,  bp [ 0 ]  -  1 ,  hkey [ 0 ]  -  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														bp_to_particle ( keys ,  bp [ 0 ] ,  hkey [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( hkey [ 0 ]  ! =  pa - > hair ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														hair_to_particle ( keys ,  hkey [ 0 ]  -  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														hair_to_particle ( keys ,  hkey [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( soft )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( hkey [ 1 ]  ! =  pa - > hair  +  pa - > totkey  -  1 ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-12 13:38:07 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														bp_to_particle ( keys  +  3 ,  bp [ 1 ]  +  1 ,  hkey [ 1 ]  +  1 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														bp_to_particle ( keys  +  3 ,  bp [ 1 ] ,  hkey [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( hkey [ 1 ]  ! =  pa - > hair  +  pa - > totkey  -  1 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														hair_to_particle ( keys  +  3 ,  hkey [ 1 ]  +  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														hair_to_particle ( keys  +  3 ,  hkey [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											dfra  =  keys [ 2 ] . time  -  keys [ 1 ] . time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											keytime  =  ( t  -  keys [ 1 ] . time )  /  dfra ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* convert velocity to timestep size */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > flag  &  PSYS_KEYED ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecMulf ( keys [ 1 ] . vel ,  dfra  /  frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecMulf ( keys [ 2 ] . vel ,  dfra  /  frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* now we should have in chronologiacl order k1<=k2<=t<=k3<=k4 with keytime between [0,1]->[k2,k3] (k1 & k4 used for cardinal & bspline interpolation)*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											interpolate_particle ( ( psys - > flag  &  PSYS_KEYED )  ?  - 1  /* signal for cubic interpolation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												:  ( ( psys - > part - > flag  &  PART_HAIR_BSPLINE )  ?  KEY_BSPLINE  :  KEY_CARDINAL ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 10:44:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												, keys ,  keytime ,  & result ,  0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* the velocity needs to be converted back from cubic interpolation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > flag  &  PSYS_KEYED ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VecMulf ( result . vel ,  frs_sec  /  dfra ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  if ( soft = = NULL )  {  /* softbody and keyed are allready in global space */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												Mat4MulVecfl ( hairmat ,  result . co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											VECCOPY ( ca - > co ,  result . co ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-29 08:31:11 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* selection coloring in edit mode */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( edit ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( pset - > brushtype = = PE_BRUSH_WEIGHT ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( k = = steps ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														VecLerpf ( ca - > col ,  nosel_col ,  sel_col ,  hkey [ 0 ] - > weight ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														VecLerpf ( ca - > col ,  nosel_col ,  sel_col , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														( 1.0f  -  keytime )  *  hkey [ 0 ] - > weight  +  keytime  *  hkey [ 1 ] - > weight ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-29 08:31:11 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( ( ekey  +  ( hkey [ 0 ]  -  pa - > hair ) ) - > flag  &  PEK_SELECT ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														if ( ( ekey  +  ( hkey [ 1 ]  -  pa - > hair ) ) - > flag  &  PEK_SELECT ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VECCOPY ( ca - > col ,  sel_col ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VecLerpf ( ca - > col ,  sel_col ,  nosel_col ,  keytime ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														if ( ( ekey  +  ( hkey [ 1 ]  -  pa - > hair ) ) - > flag  &  PEK_SELECT ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VecLerpf ( ca - > col ,  nosel_col ,  sel_col ,  keytime ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VECCOPY ( ca - > col ,  nosel_col ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( ca - > col ,  col ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/*--modify paths--*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VecSubf ( vec , ( cache [ i ] + 1 ) - > co , cache [ i ] - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										length  =  VecLength ( vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 14:16:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										effector =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( vg_effector ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											effector * =  psys_particle_value_from_verts ( psmd - > dm , psys - > part - > from , pa , vg_effector ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 14:16:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										for ( k = 0 ,  ca = cache [ i ] ;  k < = steps ;  k + + ,  ca + + )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* apply effectors */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-15 12:54:43 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ! ( psys - > part - > flag  &  PART_CHILD_EFFECT )  & &  edit = = 0  & &  k ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												do_path_effectors ( scene ,  ob ,  psys ,  i ,  ca ,  k ,  steps ,  cache [ i ] - > co ,  effector ,  dfra ,  cfra ,  & length ,  vec ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* apply guide curves to path data */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-07 22:39:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( edit = = 0  & &  psys - > effectors . first  & &  ( psys - > part - > flag  &  PART_CHILD_EFFECT ) = = 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												/* ca is safe to cast, since only co and vel are used */ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												do_guide ( scene ,  ( ParticleKey * ) ca ,  i ,  ( float ) k / ( float ) steps ,  & psys - > effectors ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* apply lattice */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > lattice  & &  edit = = 0 ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-07 16:05:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												calc_latt_deform ( psys - > lattice ,  ca - > co ,  1.0f ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											/* figure out rotation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( k )  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												float  cosangle ,  angle ,  tangent [ 3 ] ,  normal [ 3 ] ,  q [ 4 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( k  = =  1 )  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													VECSUB ( tangent ,  ca - > co ,  ( ca  -  1 ) - > co ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													vectoquat ( tangent ,  OB_POSX ,  OB_POSZ ,  ( ca - 1 ) - > rot ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( prev_tangent ,  tangent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													Normalize ( prev_tangent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													VECSUB ( tangent ,  ca - > co ,  ( ca  -  1 ) - > co ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													Normalize ( tangent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													cosangle =  Inpf ( tangent ,  prev_tangent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													/* note we do the comparison on cosangle instead of
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													 *  angle ,  since  floating  point  accuracy  makes  it  give 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													 *  different  results  across  platforms  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( cosangle  >  0.999999f )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
														QUATCOPY ( ( ca  -  1 ) - > rot ,  ( ca  -  2 ) - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														angle =  saacos ( cosangle ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
														Crossf ( normal ,  prev_tangent ,  tangent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														VecRotToQuat ( normal ,  angle ,  q ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														QuatMul ( ( ca  -  1 ) - > rot ,  q ,  ( ca  -  2 ) - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( prev_tangent ,  tangent ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												if ( k  = =  steps ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													QUATCOPY ( ca - > rot ,  ( ca  -  1 ) - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											/* set velocity */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( k ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												VECSUB ( ca - > vel ,  ca - > co ,  ( ca - 1 ) - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( k = = 1 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( ( ca - 1 ) - > vel ,  ca - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ! edit  & &  ! psys - > totchild )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												/* check if path needs to be cut before actual end of data points */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( k ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													VECSUB ( dvec , ca - > co , ( ca - 1 ) - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( part - > flag & PART_ABS_LENGTH ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														len = VecLength ( dvec ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														len = 1.0f / ( float ) steps ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													k = check_path_length ( k , cache [ i ] , ca , max_length , & cur_length , len , dvec ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													/* initialize length calculation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( part - > flag & PART_ABS_LENGTH ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														max_length =  part - > abslength * pa_length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														max_length =  pa_length ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													cur_length =  0.0f ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys - > totcached  =  totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psys  & &  psys - > lattice ) { 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-07 16:05:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										end_latt_deform ( psys - > lattice ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys - > lattice =  NULL ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 14:16:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( vg_effector ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( vg_effector ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-17 19:29:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( vg_length ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										MEM_freeN ( vg_length ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Particle Key handling				*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  copy_particle_key ( ParticleKey  * to ,  ParticleKey  * from ,  int  time ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( time ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										memcpy ( to , from , sizeof ( ParticleKey ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										float  to_time = to - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										memcpy ( to , from , sizeof ( ParticleKey ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										to - > time = to_time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/*
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( to - > co , from - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( to - > vel , from - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									QUATCOPY ( to - > rot , from - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( time ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										to - > time = from - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									to - > flag = from - > flag ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									to - > sbw = from - > sbw ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_get_from_key ( ParticleKey  * key ,  float  * loc ,  float  * vel ,  float  * rot ,  float  * time ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( loc )  VECCOPY ( loc , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( vel )  VECCOPY ( vel , key - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( rot )  QUATCOPY ( rot , key - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( time )  * time = key - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*-------changing particle keys from space to another-------*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_key_to_object ( Object  * ob ,  ParticleKey  * key ,  float  imat [ ] [ 4 ] ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  q [ 4 ] ,  imat2 [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( imat = = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Mat4Invert ( imat2 , ob - > obmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										imat = imat2 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADD ( key - > vel , key - > vel , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulVecfl ( imat , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulVecfl ( imat , key - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4ToQuat ( imat , q ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECSUB ( key - > vel , key - > vel , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									QuatMul ( key - > rot , q , key - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  key_from_object ( Object  * ob ,  ParticleKey  * key ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  q [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADD ( key - > vel , key - > vel , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulVecfl ( ob - > obmat , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulVecfl ( ob - > obmat , key - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4ToQuat ( ob - > obmat , q ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECSUB ( key - > vel , key - > vel , key - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									QuatMul ( key - > rot , q , key - > rot ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  triatomat ( float  * v1 ,  float  * v2 ,  float  * v3 ,  float  ( * uv ) [ 2 ] ,  float  mat [ ] [ 4 ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  det ,  w1 ,  w2 ,  d1 [ 2 ] ,  d2 [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									memset ( mat ,  0 ,  sizeof ( float ) * 4 * 4 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									mat [ 3 ] [ 3 ] =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* first axis is the normal */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									CalcNormFloat ( v1 ,  v2 ,  v3 ,  mat [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* second axis along (1, 0) in uv space */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( uv )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										d1 [ 0 ] =  uv [ 1 ] [ 0 ]  -  uv [ 0 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										d1 [ 1 ] =  uv [ 1 ] [ 1 ]  -  uv [ 0 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										d2 [ 0 ] =  uv [ 2 ] [ 0 ]  -  uv [ 0 ] [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										d2 [ 1 ] =  uv [ 2 ] [ 1 ]  -  uv [ 0 ] [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										det  =  d2 [ 0 ] * d1 [ 1 ]  -  d2 [ 1 ] * d1 [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( det  ! =  0.0f )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											det =  1.0f / det ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											w1 =  - d2 [ 1 ] * det ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											w2 =  d1 [ 1 ] * det ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mat [ 1 ] [ 0 ] =  w1 * ( v2 [ 0 ]  -  v1 [ 0 ] )  +  w2 * ( v3 [ 0 ]  -  v1 [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mat [ 1 ] [ 1 ] =  w1 * ( v2 [ 1 ]  -  v1 [ 1 ] )  +  w2 * ( v3 [ 1 ]  -  v1 [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mat [ 1 ] [ 2 ] =  w1 * ( v2 [ 2 ]  -  v1 [ 2 ] )  +  w2 * ( v3 [ 2 ]  -  v1 [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Normalize ( mat [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mat [ 1 ] [ 0 ] =  mat [ 1 ] [ 1 ] =  mat [ 1 ] [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VecSubf ( mat [ 1 ] ,  v2 ,  v1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( mat [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* third as a cross product */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Crossf ( mat [ 0 ] ,  mat [ 1 ] ,  mat [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								static  void  psys_face_mat ( Object  * ob ,  DerivedMesh  * dm ,  ParticleData  * pa ,  float  mat [ ] [ 4 ] ,  int  orco ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  v [ 3 ] [ 3 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									MFace  * mface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									OrigSpaceFace  * osface ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  ( * orcodata ) [ 3 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i  =  pa - > num_dmcache = = DMCACHE_NOTFOUND  ?  pa - > num  :  pa - > num_dmcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( i = = - 1  | |  i  > =  dm - > getNumFaces ( dm ) )  {  Mat4One ( mat ) ;  return ;  } 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									mface = dm - > getFaceData ( dm , i , CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									osface = dm - > getFaceData ( dm , i , CD_ORIGSPACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( orco  & &  ( orcodata = dm - > getVertDataArray ( dm ,  CD_ORCO ) ) )  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										VECCOPY ( v [ 0 ] ,  orcodata [ mface - > v1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( v [ 1 ] ,  orcodata [ mface - > v2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( v [ 2 ] ,  orcodata [ mface - > v3 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* ugly hack to use non-transformed orcos, since only those
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										 *  give  symmetric  results  for  mirroring  in  particle  mode  */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										transform_mesh_orco_verts ( ob - > data ,  v ,  3 ,  1 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										dm - > getVertCo ( dm , mface - > v1 , v [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										dm - > getVertCo ( dm , mface - > v2 , v [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										dm - > getVertCo ( dm , mface - > v3 , v [ 2 ] ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									triatomat ( v [ 0 ] ,  v [ 1 ] ,  v [ 2 ] ,  ( osface ) ?  osface - > uv :  NULL ,  mat ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								void  psys_mat_hair_to_object ( Object  * ob ,  DerivedMesh  * dm ,  short  from ,  ParticleData  * pa ,  float  hairmat [ ] [ 4 ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  vec [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_face_mat ( 0 ,  dm ,  pa ,  hairmat ,  0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_particle_on_dm ( dm ,  from ,  pa - > num ,  pa - > num_dmcache ,  pa - > fuv ,  pa - > foffset ,  vec ,  0 ,  0 ,  0 ,  0 ,  0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( hairmat [ 3 ] , vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_mat_hair_to_orco ( Object  * ob ,  DerivedMesh  * dm ,  short  from ,  ParticleData  * pa ,  float  hairmat [ ] [ 4 ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  vec [ 3 ] ,  orco [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_face_mat ( ob ,  dm ,  pa ,  hairmat ,  1 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_particle_on_dm ( dm ,  from ,  pa - > num ,  pa - > num_dmcache ,  pa - > fuv ,  pa - > foffset ,  vec ,  0 ,  0 ,  0 ,  orco ,  0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* see psys_face_mat for why this function is called */ 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-12 21:49:48 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									transform_mesh_orco_verts ( ob - > data ,  & orco ,  1 ,  1 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-06 17:43:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									VECCOPY ( hairmat [ 3 ] , orco ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_vec_rot_to_face ( DerivedMesh  * dm ,  ParticleData  * pa ,  float  * vec ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  mat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2007-12-11 20:02:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									psys_face_mat ( 0 ,  dm ,  pa ,  mat ,  0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									Mat4Transp ( mat ) ;  /* cheap inverse for rotation matrix */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4Mul3Vecfl ( mat ,  vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_mat_hair_to_global ( Object  * ob ,  DerivedMesh  * dm ,  short  from ,  ParticleData  * pa ,  float  hairmat [ ] [ 4 ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  facemat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									psys_mat_hair_to_object ( ob ,  dm ,  from ,  pa ,  facemat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Mat4MulMat4 ( hairmat ,  facemat ,  ob - > obmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			ParticleSettings handling			*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  void  default_particle_settings ( ParticleSettings  * part ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > type =  PART_EMITTER ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > distr =  PART_DISTR_JIT ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > draw_as = PART_DRAW_DOT ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > bb_uv_split = 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > bb_align = PART_BB_VIEW ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > bb_split_offset = PART_BB_OFF_LINEAR ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > flag = PART_REACT_MULTIPLE | PART_HAIR_GEOMETRY ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > sta =  1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > end =  100.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > lifetime =  50.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > jitfac =  1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > totpart =  1000 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > grid_res =  10 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > timetweak =  1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > keyed_time =  0.5 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//part->userjit;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > integrator =  PART_INT_MIDPOINT ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > phystype =  PART_PHYS_NEWTON ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-01 12:47:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									part - > hair_step =  5 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									part - > keys_step =  5 ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-01 12:47:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									part - > draw_step =  2 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > ren_step =  3 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									part - > adapt_angle =  5 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > adapt_pix =  3 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > kink_axis =  2 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > reactevent =  PART_EVENT_DEATH ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > disp = 100 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > from =  PART_FROM_FACE ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > length =  1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > nbetween =  4 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > boidneighbours =  5 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > max_vel  =  10.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > average_vel  =  0.3f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > max_tan_acc  =  0.2f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > max_lat_acc  =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > reactshape = 1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > mass = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > size = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > childsize = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > child_nbr = 10 ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									part - > ren_child_nbr = 100 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									part - > childrad = 0.2f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > childflat = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > clumppow = 0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > kink_amp = 0.2f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > kink_freq = 2.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > rough1_size = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > rough2_size = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > rough_end_shape = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > draw_line [ 0 ] = 0.5 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > banking = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > max_bank = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( i = 0 ;  i < BOID_TOT_RULES ;  i + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > boidrule [ i ] = ( char ) i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > boidfac [ i ] = 0.5 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								#if 0  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									part - > ipo  =  NULL ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# endif  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-20 16:35:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > simplify_refsize =  1920 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > simplify_rate =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > simplify_transition =  0.1f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part - > simplify_viewport =  0.8 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								ParticleSettings  * psys_new_settings ( char  * name ,  Main  * main ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									part =  alloc_libblock ( & main - > particle ,  ID_PA ,  name ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									default_particle_settings ( part ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								ParticleSettings  * psys_copy_settings ( ParticleSettings  * part ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * partn ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									partn =  copy_libblock ( part ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( partn - > pd )  partn - > pd =  MEM_dupallocN ( part - > pd ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-08-21 21:12:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( partn - > pd2 )  partn - > pd2 =  MEM_dupallocN ( part - > pd2 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  partn ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-04-30 13:29:57 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  make_local_particlesettings ( ParticleSettings  * part ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * ob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * par ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  local = 0 ,  lib = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* - only lib users: do nothing
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									    *  -  only  local  users :  set  flag 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									    *  -  mixed :  make  copy 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									    */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > id . lib = = 0 )  return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > id . us = = 1 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > id . lib =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > id . flag =  LIB_LOCAL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										new_id ( 0 ,  ( ID  * ) part ,  0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* test objects */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ob =  G . main - > object . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									while ( ob )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ParticleSystem  * psys = ob - > particlesystem . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( ;  psys ;  psys = psys - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > part = = part )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ob - > id . lib )  lib =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  local =  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ob =  ob - > id . next ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( local  & &  lib = = 0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > id . lib =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										part - > id . flag =  LIB_LOCAL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										new_id ( 0 ,  ( ID  * ) part ,  0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( local  & &  lib )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										par =  psys_copy_settings ( part ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										par - > id . us =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* do objects */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ob =  G . main - > object . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										while ( ob )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ParticleSystem  * psys = ob - > particlesystem . first ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											for ( ;  psys ;  psys = psys - > next ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( psys - > part = = part  & &  ob - > id . lib = = 0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													psys - > part =  par ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													par - > id . us + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													part - > id . us - - ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ob =  ob - > id . next ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_flush_particle_settings ( Scene  * scene ,  ParticleSettings  * part ,  int  recalc ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									Base  * base  =  scene - > base . first ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  flush ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									for ( base  =  scene - > base . first ;  base ;  base  =  base - > next )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										flush  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( psys  =  base - > object - > particlesystem . first ;  psys ;  psys = psys - > next )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > part  = =  part )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												psys - > recalc  | =  recalc ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												flush + + ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2009-06-05 23:59:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( flush ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											DAG_object_flush_update ( scene ,  base - > object ,  OB_RECALC_DATA ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								LinkNode  * psys_using_settings ( struct  Scene  * scene ,  ParticleSettings  * part ,  int  flush_update ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Object  * ob ,  * tob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystem  * psys ,  * tpsys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									LinkNode  * node =  NULL ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  found ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* update all that have same particle settings */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									for ( ob = G . main - > object . first ;  ob ;  ob = ob - > id . next )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										found =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										for ( psys = ob - > particlesystem . first ;  psys ;  psys = psys - > next )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( psys - > part  = =  part )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												BLI_linklist_append ( & node ,  psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												found + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  if ( psys - > part - > type  = =  PART_REACTOR ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												tob =  ( psys - > target_ob ) ?  psys - > target_ob :  ob ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												tpsys =  BLI_findlink ( & tob - > particlesystem ,  psys - > target_psys - 1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( tpsys  & &  tpsys - > part = = part )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													BLI_linklist_append ( & node ,  tpsys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													found + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( flush_update  & &  found ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											DAG_object_flush_update ( scene ,  ob ,  OB_RECALC_DATA ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Point Cache Refactoring
=======================
Caching and Baking:
- The point cache is now cleared on DAG_object_flush_update(), and not cleared for time dependency graph updates.
- There is now a Bake button instead of Protect. Also cache start and end frames were added to softbody and particles.
- The cloth autoprotect feature was removed.
- The Ctrl+B menu now also bakes cloth and particles next to softbody and fluids. Additionally there are now frree bake and free cache menu entries.
- The point cache api has been changed. There is now a PTCacheID struct for each point cache type that can be filled and then used to call the point cache functions.
- PointCache struct was added to DNA and is automatically allocated for each physics type.
- Soft body now supports Bake Editing just like cloth.
- Tried to make the systems deal consistently with time ipo's and offsets. Still not sure it all works correct, but too complicated to solve completely now.
Library Linking:
- Added some more warnings to prevent editing settings on library linked objects.
- Linked objects now read from the cache located next to the original library file, and never write to it. This restores old behavior for softbodies. For local simulation the mesh and not the object should be linked.
- Dupligroups and proxies can't create local point caches at the moment, how to implement that I'm not sure. We probably need a proxy point cache for that to work (ugh).
Physics UI:
- Renamed deflection panel to collision for consistency and reorganized the buttons. Also removed some softbody collision buttons from the softbody panel that were duplicated in this panel for cloth.
- Tweaked field panel buttons to not jump around when changing options.
- Tabbing e.g. Soft Body Collision into the Soft Body panel, it now only shows Collision to make the panel names readable.
- I tried to make enabled/disabling physics more consistent, since all three system did things different. Now the two modifier buttons to enable the modifier for the viewport and rendering are also duplicated in the physics panels. Toggling the Soft Body and Cloth buttons now both remove their modifiers.
- Fixed modifier error drawing glitch.
Particles:
- Particles are now recalculated more often than before. Previously it did partial updates based on the changes, but that doesn't work well with DAG_object_flush_update() ..
- Fixed memory leak loading keyed particle system. Now keys are not written to file anymore but always created after loading.
- Make particle threads work with autothreads.
Continue Physics:
- The timeline play now has a Continue Physics option in the playback menu, which keeps the simulations going without writing them to the cache.
- This doesn't always work that well, some changes are not immediately updated, but this can be improved later. Still it's fun to get a feel for the physics.
Todo:
- Point cache can get out of sync with and undo and changing a file without saving it.
- Change the point cache file format to store a version (so old point cache files can be either converted or at least ignored), and to do correct endian conversion.
- Menu item and/or buttons for Ctrl+B.
- A system("rm ..") was changed to remove() since the former is very slow for clearing point caches. These system() calls were already giving trouble in a bug in the tracker, but really most use of this system("") should be changed and tested.
- The Soft Body Collision and Clot Collision panel titles don't mention there's point cache settings there too, doing that makes them unreadable with the default panel setup.. but may need to make the names longer anyway.
											 
										 
										
											2008-04-10 11:39:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  node ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Textures							*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								static  int  get_particle_uv ( DerivedMesh  * dm ,  ParticleData  * pa ,  int  face_index ,  float  * fuv ,  char  * name ,  float  * texco ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MFace  * mf ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MTFace  * tf ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  i ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									tf =  CustomData_get_layer_named ( & dm - > faceData ,  CD_MTFACE ,  name ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( tf  = =  NULL ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										tf =  CustomData_get_layer ( & dm - > faceData ,  CD_MTFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( tf  = =  NULL ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( pa )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										i =  ( pa - > num_dmcache = = DMCACHE_NOTFOUND ) ?  pa - > num :  pa - > num_dmcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( i  > =  dm - > getNumFaces ( dm ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											i  =  - 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										i =  face_index ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( i = = - 1 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										texco [ 0 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										texco [ 1 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										texco [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										mf =  dm - > getFaceData ( dm ,  i ,  CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys_interpolate_uvs ( & tf [ i ] ,  mf - > v4 ,  fuv ,  texco ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										texco [ 0 ] =  texco [ 0 ] * 2.0f  -  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										texco [ 1 ] =  texco [ 1 ] * 2.0f  -  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										texco [ 2 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								static  void  get_cpa_texture ( DerivedMesh  * dm ,  Material  * ma ,  int  face_index ,  float  * fw ,  float  * orco ,  ParticleTexture  * ptex ,  int  event ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MTex  * mtex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  m , setvars = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  value ,  rgba [ 4 ] ,  texco [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ma )  for ( m = 0 ;  m < MAX_MTEX ;  m + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										mtex = ma - > mtex [ m ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( mtex  & &  ( ma - > septex  &  ( 1 < < m ) ) = = 0 ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											float  def = mtex - > def_var ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											float  var = mtex - > varfac ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											short  blend = mtex - > blendtype ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											short  neg = mtex - > pmaptoneg ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ( mtex - > texco  &  TEXCO_UV )  & &  fw )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ! get_particle_uv ( dm ,  NULL ,  face_index ,  fw ,  mtex - > uvname ,  texco ) ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
													VECCOPY ( texco , orco ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												VECCOPY ( texco , orco ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											externtex ( mtex ,  texco ,  & value ,  rgba ,  rgba + 1 ,  rgba + 2 ,  rgba + 3 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_TIME ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ( setvars & MAP_PA_TIME ) = = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													ptex - > time = 0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													setvars | = MAP_PA_TIME ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												ptex - > time =  texture_value_blend ( mtex - > def_var , ptex - > time , value , var , blend , neg  &  MAP_PA_TIME ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_LENGTH ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > length =  texture_value_blend ( def , ptex - > length , value , var , blend , neg  &  MAP_PA_LENGTH ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_CLUMP ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > clump =  texture_value_blend ( def , ptex - > clump , value , var , blend , neg  &  MAP_PA_CLUMP ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_KINK ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > kink =  texture_value_blend ( def , ptex - > kink , value , var , blend , neg  &  MAP_PA_KINK ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_ROUGH ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > rough =  texture_value_blend ( def , ptex - > rough , value , var , blend , neg  &  MAP_PA_ROUGH ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_DENS ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												ptex - > exist =  texture_value_blend ( def , ptex - > exist , value , var , blend , neg  &  MAP_PA_DENS ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_TIME )  {  CLAMP ( ptex - > time , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_LENGTH )  {  CLAMP ( ptex - > length , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_CLUMP )  {  CLAMP ( ptex - > clump , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_KINK )  {  CLAMP ( ptex - > kink , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_ROUGH )  {  CLAMP ( ptex - > rough , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_DENS )  {  CLAMP ( ptex - > exist , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								void  psys_get_texture ( Object  * ob ,  Material  * ma ,  ParticleSystemModifierData  * psmd ,  ParticleSystem  * psys ,  ParticleData  * pa ,  ParticleTexture  * ptex ,  int  event ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MTex  * mtex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  m ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  value ,  rgba [ 4 ] ,  co [ 3 ] ,  texco [ 3 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									int  setvars = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ma )  for ( m = 0 ;  m < MAX_MTEX ;  m + + ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										mtex = ma - > mtex [ m ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( mtex  & &  ( ma - > septex  &  ( 1 < < m ) ) = = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											float  var = mtex - > varfac ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											float  def = mtex - > def_var ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											short  blend = mtex - > blendtype ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											short  neg = mtex - > pmaptoneg ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( ( mtex - > texco  &  TEXCO_UV )  & &  ELEM ( psys - > part - > from ,  PART_FROM_FACE ,  PART_FROM_VOLUME ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( ! get_particle_uv ( psmd - > dm ,  pa ,  0 ,  pa - > fuv ,  mtex - > uvname ,  texco ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													/* failed to get uv's, let's try orco's */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													psys_particle_on_emitter ( psmd , psys - > part - > from , pa - > num , pa - > num_dmcache , pa - > fuv , pa - > foffset , co , 0 , 0 , 0 , texco ,  0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												psys_particle_on_emitter ( psmd , psys - > part - > from , pa - > num , pa - > num_dmcache , pa - > fuv , pa - > foffset , co , 0 , 0 , 0 , texco ,  0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-29 23:33:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											externtex ( mtex ,  texco ,  & value ,  rgba ,  rgba + 1 ,  rgba + 2 ,  rgba + 3 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_TIME ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-12 16:36:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												/* the first time has to set the base value for time regardless of blend mode */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												if ( ( setvars & MAP_PA_TIME ) = = 0 ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-12 16:36:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													ptex - > time  * =  1.0f  -  var ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													ptex - > time  + =  var  *  ( ( neg  &  MAP_PA_TIME ) ?  1.0f  -  value  :  value ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													setvars  | =  MAP_PA_TIME ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-12 16:36:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												else 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													ptex - > time =  texture_value_blend ( def , ptex - > time , value , var , blend , neg  &  MAP_PA_TIME ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_LIFE ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > life =  texture_value_blend ( def , ptex - > life , value , var , blend , neg  &  MAP_PA_LIFE ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_DENS ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > exist =  texture_value_blend ( def , ptex - > exist , value , var , blend , neg  &  MAP_PA_DENS ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_SIZE ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > size =  texture_value_blend ( def , ptex - > size , value , var , blend , neg  &  MAP_PA_SIZE ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_IVEL ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > ivel =  texture_value_blend ( def , ptex - > ivel , value , var , blend , neg  &  MAP_PA_IVEL ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_PVEL ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												texture_rgb_blend ( ptex - > pvel , rgba , ptex - > pvel , value , var , blend ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_LENGTH ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > length =  texture_value_blend ( def , ptex - > length , value , var , blend , neg  &  MAP_PA_LENGTH ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_CLUMP ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > clump =  texture_value_blend ( def , ptex - > clump , value , var , blend , neg  &  MAP_PA_CLUMP ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if ( ( event  &  mtex - > pmapto )  &  MAP_PA_KINK ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-03-31 19:57:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												ptex - > kink =  texture_value_blend ( def , ptex - > kink , value , var , blend , neg  &  MAP_PA_CLUMP ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_TIME )  {  CLAMP ( ptex - > time , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_LIFE )  {  CLAMP ( ptex - > life , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_DENS )  {  CLAMP ( ptex - > exist , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_SIZE )  {  CLAMP ( ptex - > size , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_IVEL )  {  CLAMP ( ptex - > ivel , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_LENGTH )  {  CLAMP ( ptex - > length , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_CLUMP )  {  CLAMP ( ptex - > clump , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( event  &  MAP_PA_KINK )  {  CLAMP ( ptex - > kink , 0.0 , 1.0 ) ;  } 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/*			Particle State						*/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/************************************************/ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								float  psys_get_timestep ( ParticleSettings  * part ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  0.04f * part - > timetweak ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* part->size should be updated with possible ipo effection before this is called */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								float  psys_get_size ( Object  * ob ,  Material  * ma ,  ParticleSystemModifierData  * psmd ,  IpoCurve  * icu_size ,  ParticleSystem  * psys ,  ParticleSettings  * part ,  ParticleData  * pa ,  float  * vg_size ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleTexture  ptex ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  size = 1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( ma  & &  part - > from ! = PART_FROM_PARTICLE ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ptex . size = size ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										psys_get_texture ( ob , ma , psmd , psys , pa , & ptex , MAP_PA_SIZE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										size = ptex . size ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								#if 0  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									if ( icu_size ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										calc_icu ( icu_size , pa - > time ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										size * = icu_size - > curval ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# endif  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( vg_size ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										size * = psys_particle_value_from_verts ( psmd - > dm , part - > from , pa , vg_size ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > randsize ! = 0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										size * =  1.0f  -  part - > randsize * pa - > sizemul ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  size * part - > size ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								float  psys_get_child_time ( ParticleSystem  * psys ,  ChildParticle  * cpa ,  float  cfra ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > childtype = = PART_CHILD_FACES ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										float  time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										int  w = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										time = 0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										while ( w < 4  & &  cpa - > pa [ w ] > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											time + = cpa - > w [ w ] * ( psys - > particles + cpa - > pa [ w ] ) - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											w + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  ( cfra - time ) / ( part - > lifetime * ( 1.0f - part - > randlife * cpa - > rand [ 1 ] ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ParticleData  * pa  =  psys - > particles  +  cpa - > parent ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  ( cfra - pa - > time ) / pa - > lifetime ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								float  psys_get_child_size ( ParticleSystem  * psys ,  ChildParticle  * cpa ,  float  cfra ,  float  * pa_time ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-17 14:56:12 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  size ;  // time XXX
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > childtype = = PART_CHILD_FACES ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-15 22:08:30 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										size = part - > size ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								#if 0  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										if ( ( part - > flag & PART_ABS_TIME ) = = 0  & &  part - > ipo ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-15 22:08:30 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											IpoCurve  * icu ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( pa_time ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												time = * pa_time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												time = psys_get_child_time ( psys , cpa , cfra ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* correction for lifetime */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											calc_ipo ( part - > ipo ,  100 * time ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-15 22:08:30 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											for ( icu  =  part - > ipo - > curve . first ;  icu ;  icu = icu - > next )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( icu - > adrcode  = =  PART_SIZE ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													size  =  icu - > curval ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# endif  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										size = psys - > particles [ cpa - > parent ] . size ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									size * = part - > childsize ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( part - > childrandsize ! = 0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										size  * =  1.0f  -  part - > childrandsize * cpa - > rand [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  size ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* get's hair (or keyed) particles state at the "path time" specified in state->time */ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_get_particle_on_path ( Scene  * scene ,  Object  * ob ,  ParticleSystem  * psys ,  int  p ,  ParticleKey  * state ,  int  vel ) 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part  =  psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleSystemModifierData  * psmd  =  psys_get_modifier ( ob ,  psys ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Material  * ma  =  give_current_material ( ob ,  part - > omat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ChildParticle  * cpa ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleTexture  ptex ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 23:38:53 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									ParticleKey  * kkey [ 2 ]  =  { NULL ,  NULL } ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-18 10:49:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									HairKey  * hkey [ 2 ]  =  { NULL ,  NULL } ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									ParticleKey  * par = 0 ,  keys [ 4 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  t ,  real_t ,  dfra ,  keytime ,  frs_sec  =  scene - > r . frs_sec ; 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 12:40:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  co [ 3 ] ,  orco [ 3 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 23:38:53 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  hairmat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									float  pa_clump  =  0.0 ,  pa_kink  =  0.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totparent  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totpart  =  psys - > totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totchild  =  psys - > totchild ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									short  between  =  0 ,  edit  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  * cpa_fuv ;  int  cpa_num ;  short  cpa_from ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									//if(psys_in_edit_mode(scene, psys)){
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									//	if((psys->edit_path->flag & PSYS_EP_SHOW_CHILD)==0)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//		totchild=0;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//	edit=1;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									/* user want's cubic interpolation but only without sb it possible */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//if(interpolation==PART_INTER_CUBIC && baked && psys->softflag==OB_SB_ENABLE)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//	interpolation=PART_INTER_BSPLINE;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//else if(baked==0) /* it doesn't make sense to use other types for keyed */
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									//	interpolation=PART_INTER_CUBIC;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									t = state - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									CLAMP ( t ,  0.0 ,  1.0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( p < totpart ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa  =  psys - > particles  +  p ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( pa - > alive = = PARS_DEAD  & &  part - > flag  &  PART_STICKY  & &  pa - > flag  &  PARS_STICKY  & &  pa - > stick_ob ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											copy_particle_key ( state , & pa - > state , 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											key_from_object ( pa - > stick_ob , state ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_KEYED )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											kkey [ 0 ]  =  pa - > keys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											kkey [ 1 ]  =  kkey [ 0 ]  +  1 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											real_t  =  kkey [ 0 ] - > time  +  t  *  ( kkey [ 0 ] [ pa - > totkey - 1 ] . time  -  kkey [ 0 ] - > time ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											hkey [ 0 ]  =  pa - > hair ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											hkey [ 1 ]  =  pa - > hair  +  1 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											real_t  =  hkey [ 0 ] - > time  +  ( hkey [ 0 ] [ pa - > totkey - 1 ] . time  -  hkey [ 0 ] - > time )  *  t ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_KEYED )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											while ( kkey [ 1 ] - > time  <  real_t )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												kkey [ 1 ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											kkey [ 0 ]  =  kkey [ 1 ]  -  1 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											memcpy ( keys  +  1 ,  kkey [ 0 ] ,  sizeof ( ParticleKey ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											memcpy ( keys  +  2 ,  kkey [ 1 ] ,  sizeof ( ParticleKey ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											while ( hkey [ 1 ] - > time  <  real_t ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hkey [ 1 ] + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											hkey [ 0 ]  =  hkey [ 1 ]  -  1 ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											hair_to_particle ( keys  +  1 ,  hkey [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											hair_to_particle ( keys  +  2 ,  hkey [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( ( psys - > flag  &  PSYS_KEYED ) = = 0 )  { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										//if(soft){
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	if(key[0] != sbel.keys)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		DB_copy_key(&k1,key[0]-1);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	else
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		DB_copy_key(&k1,&k2);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//else{
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( hkey [ 0 ]  ! =  pa - > hair ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hair_to_particle ( keys ,  hkey [ 0 ]  -  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hair_to_particle ( keys ,  hkey [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//if(soft){
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	if(key[1] != sbel.keys + sbel.totkey-1)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		DB_copy_key(&k4,key[1]+1);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	else
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		DB_copy_key(&k4,&k3);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//else {
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( hkey [ 1 ]  ! =  pa - > hair  +  pa - > totkey  -  1 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hair_to_particle ( keys  +  3 ,  hkey [ 1 ]  +  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												hair_to_particle ( keys  +  3 ,  hkey [ 1 ] ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//psys_get_particle_on_path(scene, bsys,p,t,bkey,ckey[0]);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//if(part->rotfrom==PART_ROT_KEYS)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	QuatInterpol(state->rot,k2.rot,k3.rot,keytime);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//else{
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	/* TODO: different rotations */
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	float nvel[3];
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	VECCOPY(nvel,state->vel);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	VecMulf(nvel,-1.0f);
 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//	vectoquat(nvel, OB_POSX, OB_POSZ, state->rot);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										dfra  =  keys [ 2 ] . time  -  keys [ 1 ] . time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										keytime  =  ( real_t  -  keys [ 1 ] . time )  /  dfra ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* convert velocity to timestep size */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_KEYED ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( keys [ 1 ] . vel ,  dfra  /  frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( keys [ 2 ] . vel ,  dfra  /  frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											QuatInterpol ( state - > rot , keys [ 1 ] . rot , keys [ 2 ] . rot , keytime ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										interpolate_particle ( ( psys - > flag  &  PSYS_KEYED )  ?  - 1  /* signal for cubic interpolation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											:  ( ( psys - > part - > flag  &  PART_HAIR_BSPLINE )  ?  KEY_BSPLINE  :  KEY_CARDINAL ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 10:44:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											, keys ,  keytime ,  state ,  1 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* the velocity needs to be converted back from cubic interpolation */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( psys - > flag  &  PSYS_KEYED ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VecMulf ( state - > vel ,  frs_sec  /  dfra ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( pa - > flag  &  PARS_REKEY ) = = 0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												psys_mat_hair_to_global ( ob ,  psmd - > dm ,  part - > from ,  pa ,  hairmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												Mat4MulVecfl ( hairmat ,  state - > co ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 10:44:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												Mat4Mul3Vecfl ( hairmat ,  state - > vel ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												if ( psys - > effectors . first  & &  ( part - > flag  &  PART_CHILD_GUIDE ) = = 0 )  { 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-10 19:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													do_guide ( scene ,  state ,  p ,  state - > time ,  & psys - > effectors ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													/* TODO: proper velocity handling */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												if ( psys - > lattice  & &  edit = = 0 ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-07 16:05:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													calc_latt_deform ( psys - > lattice ,  state - > co , 1.0f ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( totchild ) { 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//Mat4Invert(imat,ob->obmat);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cpa = psys - > child + p - totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( totchild  & &  part - > from ! = PART_FROM_PARTICLE  & &  part - > childtype = = PART_CHILD_FACES ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											totparent = ( int ) ( totchild * part - > parents * 0.3 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( G . rendering  & &  part - > child_nbr  & &  part - > ren_child_nbr ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												totparent * = ( float ) part - > child_nbr / ( float ) part - > ren_child_nbr ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											/* part->parents could still be 0 so we can't test with totparent */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											between = 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( between ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											int  w  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											float  foffset ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* get parent states */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											while ( w < 4  & &  cpa - > pa [ w ] > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												keys [ w ] . time  =  t ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												psys_get_particle_on_path ( scene ,  ob ,  psys ,  cpa - > pa [ w ] ,  keys + w ,  1 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
												w + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* get the original coordinates (orco) for texture usage */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa_num = cpa - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											foffset =  cpa - > foffset ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( part - > childtype  = =  PART_CHILD_FACES ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												foffset  =  - ( 2.0f  +  part - > childspread ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa_fuv  =  cpa - > fuv ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa_from  =  PART_FROM_FACE ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											psys_particle_on_emitter ( psmd , cpa_from , cpa_num , DMCACHE_ISCHILD , cpa - > fuv , foffset , co , 0 , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* we need to save the actual root position of the child for positioning it accurately to the surface of the emitter */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											//VECCOPY(cpa_1st,co);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											//Mat4MulVecfl(ob->obmat,cpa_1st);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* get the parent state */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											keys - > time  =  t ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											psys_get_particle_on_path ( scene ,  ob ,  psys ,  cpa - > parent ,  keys , 1 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* get the original coordinates (orco) for texture usage */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa = psys - > particles + cpa - > parent ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa_from = part - > from ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa_num = pa - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa_fuv = pa - > fuv ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											psys_particle_on_emitter ( psmd , cpa_from , cpa_num , DMCACHE_ISCHILD , cpa_fuv , pa - > foffset , co , 0 , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* correct child ipo timing */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								#if 0  // XXX old animation system
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										if ( ( part - > flag & PART_ABS_TIME ) = = 0  & &  part - > ipo ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											calc_ipo ( part - > ipo ,  100.0f * t ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											execute_ipo ( ( ID  * ) part ,  part - > ipo ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												2.5: Blender "Animato" - New Animation System 
Finally, here is the basic (functional) prototype of the new animation system which will allow for the infamous "everything is animatable", and which also addresses several of the more serious shortcomings of the old system. Unfortunately, this will break old animation files (especially right now, as I haven't written the version patching code yet), however, this is for the future.
Highlights of the new system:
* Scrapped IPO-Curves/IPO/(Action+Constraint-Channels)/Action system, and replaced it with F-Curve/Action. 
- F-Curves (animators from other packages will feel at home with this name) replace IPO-Curves. 
- The 'new' Actions, act as the containers for F-Curves, so that they can be reused. They are therefore more akin to the old 'IPO' blocks, except they do not have the blocktype restriction, so you can store materials/texture/geometry F-Curves in the same Action as Object transforms, etc.
* F-Curves use RNA-paths for Data Access, hence allowing "every" (where sensible/editable that is) user-accessible setting from RNA to be animated.
* Drivers are no longer mixed with Animation Data, so rigs will not be that easily broken and several dependency problems can be eliminated. (NOTE: drivers haven't been hooked up yet, but the code is in place)
* F-Curve modifier system allows useful 'large-scale' manipulation of F-Curve values, including (I've only included implemented ones here): envelope deform (similar to lattices to allow broad-scale reshaping of curves), curve generator (polynomial or py-expression), cycles (replacing the old cyclic extrapolation modes, giving more control over this). (NOTE: currently this cannot be tested, as there's not access to them, but the code is all in place)
* NLA system with 'tracks' (i.e. layers), and multiple strips per track. (NOTE: NLA system is not yet functional, as it's only partially coded still) 
There are more nice things that I will be preparing some nice docs for soon, but for now, check for more details:
http://lists.blender.org/pipermail/bf-taskforce25/2009-January/000260.html
So, what currently works:
* I've implemented two basic operators for the 3D-view only to Insert and Delete Keyframes. These are tempolary ones only that will be replaced in due course with 'proper' code.
* Object Loc/Rot/Scale can be keyframed. Also, the colour of the 'active' material (Note: this should really be for nth material instead, but that doesn't work yet in RNA) can also be keyframed into the same datablock.
* Standard animation refresh (i.e. animation resulting from NLA and Action evaluation) is now done completely separate from drivers before anything else is done after a frame change. Drivers are handled after this in a separate pass, as dictated by depsgraph flags, etc.
Notes:
* Drivers haven't been hooked up yet
* Only objects and data directly linked to objects can be animated.
* Depsgraph will need further tweaks. Currently, I've only made sure that it will update some things in the most basic cases (i.e. frame change).
* Animation Editors are currently broken (in terms of editing stuff). This will be my next target (priority to get Dopesheet working first, then F-Curve editor - i.e. old IPO Editor)
* I've had to put in large chunks of XXX sandboxing for old animation system code all around the place. This will be cleaned up in due course, as some places need special review.
In particular, the particles and sequencer code have far too many manual calls to calculate + flush animation info, which is really bad (this is a 'please explain yourselves' call to Physics coders!).
											 
										 
										
											2009-01-17 03:12:50 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								# endif  // XXX old animation system
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										/* get different child parameters from textures & vgroups */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ptex . clump = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ptex . kink = 1.0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
									
										
										
										
											2007-12-05 15:48:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										get_cpa_texture ( psmd - > dm , ma , cpa_num , cpa_fuv , orco , & ptex , MAP_PA_CLUMP | MAP_PA_KINK ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_clump = ptex . clump ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa_kink = ptex . kink ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* TODO: vertex groups */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( between ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											int  w = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											state - > co [ 0 ]  =  state - > co [ 1 ]  =  state - > co [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											state - > vel [ 0 ]  =  state - > vel [ 1 ]  =  state - > vel [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* child position is the weighted sum of parent positions */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											while ( w < 4  & &  cpa - > pa [ w ] > = 0 ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > co [ 0 ]  + =  cpa - > w [ w ]  *  keys [ w ] . co [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > co [ 1 ]  + =  cpa - > w [ w ]  *  keys [ w ] . co [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > co [ 2 ]  + =  cpa - > w [ w ]  *  keys [ w ] . co [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > vel [ 0 ]  + =  cpa - > w [ w ]  *  keys [ w ] . vel [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > vel [ 1 ]  + =  cpa - > w [ w ]  *  keys [ w ] . vel [ 1 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												state - > vel [ 2 ]  + =  cpa - > w [ w ]  *  keys [ w ] . vel [ 2 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												w + + ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* apply offset for correct positioning */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											//VECADD(state->co,state->co,cpa_1st);
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* offset the child from the parent position */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											offset_child ( cpa ,  keys ,  state ,  part - > childflat ,  part - > childrad ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										par  =  keys ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//if(totparent){
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	if(p-totpart>=totparent){
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		key.time=t;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		psys_get_particle_on_path(ob,psys,totpart+cpa->parent,&key,1);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		bti->convert_dynamic_key(bsys,&key,par,cpar);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	else
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		par=0;
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//else
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	DB_get_key_on_path(bsys,cpa->parent,t,par,cpar);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										/* apply different deformations to the child path */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > kink ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_prekink ( state ,  par ,  par - > rot ,  t ,  part - > kink_freq  *  pa_kink ,  part - > kink_shape , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											part - > kink_amp ,  part - > kink ,  part - > kink_axis ,  ob - > obmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										do_clump ( state ,  par ,  t ,  part - > clumpfac ,  part - > clumppow ,  1.0f ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > rough1  ! =  0.0 ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-24 13:11:15 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											do_rough ( orco ,  t ,  part - > rough1 ,  part - > rough1_size ,  0.0 ,  state ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > rough2  ! =  0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_rough ( cpa - > rand ,  t ,  part - > rough2 ,  part - > rough2_size ,  part - > rough2_thres ,  state ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > rough_end  ! =  0.0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_rough_end ( cpa - > rand ,  t ,  part - > rough_end ,  part - > rough_end_shape ,  state ,  par ) ;  
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//if(vel){
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	if(t>=0.001f){
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		tstate.time=t-0.001f;
 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//		psys_get_particle_on_path(scene,ob,psys,p,&tstate,0);
 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//		VECSUB(state->vel,state->co,tstate.co);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	else{
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//		tstate.time=t+0.001f;
 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//		psys_get_particle_on_path(scene, ob,psys,p,&tstate,0);
 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										//		VECSUB(state->vel,tstate.co,state->co);
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//	}
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										//}
 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								/* gets particle's state at a time, returns 1 if particle exists and can be seen and 0 if not */ 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								int  psys_get_particle_state ( struct  Scene  * scene ,  Object  * ob ,  ParticleSystem  * psys ,  int  p ,  ParticleKey  * state ,  int  always ) { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									ParticleSettings  * part = psys - > part ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									ParticleData  * pa = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  cfra ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  totpart = psys - > totpart ,  between = 0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-23 12:53:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									/* negative time means "use current time" */ 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
									if ( state - > time > 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										cfra = state - > time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										cfra =  bsystem_time ( scene ,  0 ,  ( float ) scene - > r . cfra , 0.0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( psys - > totchild  & &  p > = totpart ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > from ! = PART_FROM_PARTICLE  & &  part - > childtype = = PART_CHILD_FACES ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											between = 1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa = psys - > particles + ( psys - > child + p - totpart ) - > parent ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										pa = psys - > particles + p ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( between ) { 
							 
						 
					
						
							
								
									
										
										
										
											2007-12-04 13:57:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										state - > time  =  psys_get_child_time ( psys , & psys - > child [ p - totpart ] , cfra ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( always = = 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( state - > time < 0.0  & &  ( part - > flag  &  PART_UNBORN ) = = 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												| |  ( state - > time > 1.0  & &  ( part - > flag  &  PART_DIED ) = = 0 ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( pa - > alive = = PARS_KILLED )  return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( always = = 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( ( pa - > alive = = PARS_UNBORN  & &  ( part - > flag  &  PART_UNBORN ) = = 0 ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												| |  ( pa - > alive = = PARS_DEAD  & &  ( part - > flag  &  PART_DIED ) = = 0 ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												return  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > flag  &  PSYS_KEYED ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( between ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ChildParticle  * cpa = psys - > child + p - totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											state - > time =  ( cfra - ( part - > sta + ( part - > end - part - > sta ) * cpa - > rand [ 0 ] ) ) / ( part - > lifetime * cpa - > rand [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											state - > time =  ( cfra - pa - > time ) / ( pa - > dietime - pa - > time ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_get_particle_on_path ( scene ,  ob ,  psys ,  p ,  state , 1 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  1 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else { 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 18:33:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if ( between ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  0 ;  /* currently not supported */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else  if ( psys - > totchild  & &  p > = psys - > totpart ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ChildParticle  * cpa = psys - > child + p - psys - > totpart ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											ParticleKey  * key1 ,  skey ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 22:42:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											float  t  =  ( cfra  -  pa - > time  +  pa - > loop  *  pa - > lifetime )  /  pa - > lifetime ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 18:33:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa  =  psys - > particles  +  cpa - > parent ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( pa - > alive = = PARS_DEAD  & &  part - > flag & PART_STICKY  & &  pa - > flag & PARS_STICKY  & &  pa - > stick_ob )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												key1  =  & skey ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												copy_particle_key ( key1 , & pa - > state , 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												key_from_object ( pa - > stick_ob , key1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												key1 = & pa - > state ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											offset_child ( cpa ,  key1 ,  state ,  part - > childflat ,  part - > childrad ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											CLAMP ( t , 0.0 , 1.0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( part - > kink ) 			/* TODO: part->kink_freq*pa_kink */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												do_prekink ( state , key1 , key1 - > rot , t , part - > kink_freq , part - > kink_shape , part - > kink_amp , part - > kink , part - > kink_axis , ob - > obmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											/* TODO: pa_clump vgroup */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											do_clump ( state , key1 , t , part - > clumpfac , part - > clumppow , 1.0 ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-08-04 14:17:11 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											if ( psys - > lattice ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-07 16:05:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												calc_latt_deform ( psys - > lattice ,  state - > co , 1.0f ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 18:33:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else { 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											if  ( pa )  {  /* TODO PARTICLE - should this ever be NULL? - Campbell */ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-28 19:53:37 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												if ( pa - > state . time = = state - > time  | |  ELEM ( part - > phystype , PART_PHYS_NO , PART_PHYS_KEYED ) ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-23 12:53:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													copy_particle_key ( state ,  & pa - > state ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  if ( pa - > prev_state . time = = state - > time ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													copy_particle_key ( state ,  & pa - > prev_state ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													/* let's interpolate to try to be as accurate as possible */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if ( pa - > state . time  +  1.0f  >  state - > time  & &  pa - > prev_state . time  -  1.0f  <  state - > time )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														ParticleKey  keys [ 4 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-04 14:14:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														float  dfra ,  keytime ,  frs_sec  =  scene - > r . frs_sec ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-23 12:53:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														if ( pa - > prev_state . time  > =  pa - > state . time )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															/* prev_state is wrong so let's not use it, this can happen at frame 1 or particle birth */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															copy_particle_key ( state ,  & pa - > state ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VECADDFAC ( state - > co ,  state - > co ,  state - > vel ,  ( state - > time - pa - > state . time ) / frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															copy_particle_key ( keys + 1 ,  & pa - > prev_state ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															copy_particle_key ( keys + 2 ,  & pa - > state ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															dfra  =  keys [ 2 ] . time  -  keys [ 1 ] . time ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															keytime  =  ( state - > time  -  keys [ 1 ] . time )  /  dfra ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															/* convert velocity to timestep size */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VecMulf ( keys [ 1 ] . vel ,  dfra  /  frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VecMulf ( keys [ 2 ] . vel ,  dfra  /  frs_sec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															interpolate_particle ( - 1 ,  keys ,  keytime ,  state ,  1 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															/* convert back to real velocity */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VecMulf ( state - > vel ,  frs_sec  /  dfra ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-28 19:53:37 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															VecLerpf ( state - > ave ,  keys [ 1 ] . ave ,  keys [ 2 ] . ave ,  keytime ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
															QuatInterpol ( state - > rot ,  keys [ 1 ] . rot ,  keys [ 2 ] . rot ,  keytime ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-23 12:53:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
														} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														/* extrapolating over big ranges is not accurate so let's just give something close to reasonable back */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														copy_particle_key ( state ,  & pa - > state ,  0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( pa - > alive = = PARS_DEAD  & &  part - > flag & PART_STICKY  & &  pa - > flag & PARS_STICKY  & &  pa - > stick_ob ) { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													key_from_object ( pa - > stick_ob , state ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( psys - > lattice ) 
							 
						 
					
						
							
								
									
										
										
										
											2009-01-07 16:05:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													calc_latt_deform ( psys - > lattice ,  state - > co , 1.0f ) ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-17 18:33:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
										
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  1 ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-17 00:28:14 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_get_dupli_texture ( Object  * ob ,  ParticleSettings  * part ,  ParticleSystemModifierData  * psmd ,  ParticleData  * pa ,  ChildParticle  * cpa ,  float  * uv ,  float  * orco ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MFace  * mface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									MTFace  * mtface ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  loc [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									int  num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( cpa )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > childtype  = =  PART_CHILD_FACES )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mtface =  CustomData_get_layer ( & psmd - > dm - > faceData ,  CD_MTFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( mtface )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												mface =  psmd - > dm - > getFaceData ( psmd - > dm ,  cpa - > num ,  CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												mtface  + =  cpa - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												psys_interpolate_uvs ( mtface ,  mface - > v4 ,  cpa - > fuv ,  uv ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												uv [ 0 ] =  uv [ 1 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv [ 0 ] =  uv [ 1 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( psmd , 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											( part - > childtype  = =  PART_CHILD_FACES ) ?  PART_FROM_FACE :  PART_FROM_PARTICLE , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											cpa - > num , DMCACHE_ISCHILD , cpa - > fuv , cpa - > foffset , loc , 0 , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( part - > from  = =  PART_FROM_FACE )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											mtface =  CustomData_get_layer ( & psmd - > dm - > faceData ,  CD_MTFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											num =  pa - > num_dmcache ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( num  = =  DMCACHE_NOTFOUND ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												if ( pa - > num  <  psmd - > dm - > getNumFaces ( psmd - > dm ) ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													num =  pa - > num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( mtface  & &  num  ! =  DMCACHE_NOTFOUND )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												mface =  psmd - > dm - > getFaceData ( psmd - > dm ,  num ,  CD_MFACE ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												mtface  + =  num ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												psys_interpolate_uvs ( mtface ,  mface - > v4 ,  pa - > fuv ,  uv ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												uv [ 0 ] =  uv [ 1 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											uv [ 0 ] =  uv [ 1 ] =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( psmd , part - > from , pa - > num , pa - > num_dmcache , pa - > fuv , pa - > foffset , loc , 0 , 0 , 0 , orco , 0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-26 11:48:12 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_get_dupli_path_transform ( Object  * ob ,  ParticleSystem  * psys ,  ParticleSystemModifierData  * psmd ,  ParticleData  * pa ,  ChildParticle  * cpa ,  ParticleCacheKey  * cache ,  float  mat [ ] [ 4 ] ,  float  * scale ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-16 21:16:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  loc [ 3 ] ,  nor [ 3 ] ,  vec [ 3 ] ,  side [ 3 ] ,  len ,  obrotmat [ 4 ] [ 4 ] ,  qmat [ 4 ] [ 4 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									float  xvec [ 3 ]  =  { - 1.0 ,  0.0 ,  0.0 } ,  q [ 4 ] ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecSubf ( vec ,  ( cache + cache - > steps - 1 ) - > co ,  cache - > co ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									len =  Normalize ( vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( pa ) 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( psmd , psys - > part - > from , pa - > num , pa - > num_dmcache , pa - > fuv , pa - > foffset , loc , nor , 0 , 0 , 0 , 0 ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									else 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-30 06:12:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										psys_particle_on_emitter ( psmd , 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-26 11:48:12 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											( psys - > part - > childtype  = =  PART_CHILD_FACES ) ?  PART_FROM_FACE :  PART_FROM_PARTICLE , 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											cpa - > num , DMCACHE_ISCHILD , cpa - > fuv , cpa - > foffset , loc , nor , 0 , 0 , 0 , 0 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									
							 
						 
					
						
							
								
									
										
										
										
											2008-02-26 11:48:12 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if ( psys - > part - > rotmode )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( ! pa ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											pa =  psys - > particles + cpa - > pa [ 0 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2008-02-27 14:17:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										vectoquat ( xvec ,  ob - > trackflag ,  ob - > upflag ,  q ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-26 11:48:12 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										QuatToMat4 ( q ,  obrotmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										obrotmat [ 3 ] [ 3 ] =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										QuatToMat4 ( pa - > state . rot ,  qmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Mat4MulMat4 ( mat ,  obrotmat ,  qmat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
									
										
										
										
											2008-09-16 21:16:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/* make sure that we get a proper side vector */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( fabs ( Inpf ( nor , vec ) ) > 0.999999 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if ( fabs ( Inpf ( nor , xvec ) ) > 0.999999 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 0 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 1 ]  =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 0 ]  =  1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 1 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												nor [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( side ,  nor ,  vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( side ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( nor ,  vec ,  side ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 		Mat4One ( mat ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( mat [ 0 ] ,  vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( mat [ 1 ] ,  side ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( mat [ 2 ] ,  nor ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2008-02-26 11:48:12 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2008-01-09 14:40:25 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									* scale =  len ; 
							 
						 
					
						
							
								
									
										
											 
										 
										
											
												
Particles
=========
Merge of the famous particle patch by Janne Karhu, a full rewrite
of the Blender particle system. This includes:
- Emitter, Hair and Reactor particle types.
- Newtonian, Keyed and Boids physics.
- Various particle visualisation and rendering types.
- Vertex group and texture control for various properties.
- Interpolated child particles from parents.
- Hair editing with combing, growing, cutting, .. .
- Explode modifier.
- Harmonic, Magnetic fields, and multiple falloff types.
.. and lots of other things, some more info is here:
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite
http://wiki.blender.org/index.php/BlenderDev/Particles_Rewrite_Doc
The new particle system cannot be backwards compatible. Old particle
systems are being converted to the new system, but will require
tweaking to get them looking the same as before.
Point Cache
===========
The new system to replace manual baking, based on automatic caching
on disk. This is currently used by softbodies and the particle system.
See the Cache API section on:
http://wiki.blender.org/index.php/BlenderDev/PhysicsSprint
Documentation
=============
These new features still need good docs for the release logs, help
for this is appreciated.
											 
										 
										
											2007-11-26 22:09:57 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2009-04-20 15:06:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								void  psys_make_billboard ( ParticleBillboardData  * bb ,  float  xvec [ 3 ] ,  float  yvec [ 3 ] ,  float  zvec [ 3 ] ,  float  center [ 3 ] ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									float  onevec [ 3 ]  =  { 0.0f , 0.0f , 0.0f } ,  tvec [ 3 ] ,  tvec2 [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									xvec [ 0 ]  =  1.0f ;  xvec [ 1 ]  =  0.0f ;  xvec [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									yvec [ 0 ]  =  0.0f ;  yvec [ 1 ]  =  1.0f ;  yvec [ 2 ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( bb - > align  <  PART_BB_VIEW ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										onevec [ bb - > align ] = 1.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if ( bb - > lock  & &  ( bb - > align  = =  PART_BB_VIEW ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( xvec ,  bb - > ob - > obmat [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( xvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( yvec ,  bb - > ob - > obmat [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( yvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( zvec ,  bb - > ob - > obmat [ 2 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( zvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  if ( bb - > align  = =  PART_BB_VEL )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										float  temp [ 3 ] ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECCOPY ( temp ,  bb - > vel ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( temp ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECSUB ( zvec ,  bb - > ob - > obmat [ 3 ] ,  bb - > vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( bb - > lock )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											float  fac  =  - Inpf ( zvec ,  temp ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											VECADDFAC ( zvec ,  zvec ,  temp ,  fac ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( zvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( xvec , temp , zvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( xvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( yvec , zvec , xvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										VECSUB ( zvec ,  bb - > ob - > obmat [ 3 ] ,  bb - > vec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( bb - > lock ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											zvec [ bb - > align ]  =  0.0f ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( zvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if ( bb - > align  <  PART_BB_VIEW ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Crossf ( xvec ,  onevec ,  zvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										else 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											Crossf ( xvec ,  bb - > ob - > obmat [ 1 ] ,  zvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Normalize ( xvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Crossf ( yvec , zvec , xvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( tvec ,  xvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECCOPY ( tvec2 ,  yvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( xvec ,  cos ( bb - > tilt  *  ( float ) M_PI ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( tvec2 ,  sin ( bb - > tilt  *  ( float ) M_PI ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADD ( xvec ,  xvec ,  tvec2 ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( yvec ,  cos ( bb - > tilt  *  ( float ) M_PI ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( tvec ,  - sin ( bb - > tilt  *  ( float ) M_PI ) ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADD ( yvec ,  yvec ,  tvec ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( xvec ,  bb - > size ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VecMulf ( yvec ,  bb - > size ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADDFAC ( center ,  bb - > vec ,  xvec ,  bb - > offset [ 0 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									VECADDFAC ( center ,  center ,  yvec ,  bb - > offset [ 1 ] ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								}