GeneralsZeroHour/GeneralsMD/Code/Libraries/Source/WWVegas/WW3D2/part_buf.cpp

/*
**	Command & Conquer Generals Zero Hour(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	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 3 of the License, or
**	(at your option) any later version.
**
**	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, see <http://www.gnu.org/licenses/>.
*/

/*************************************************************************** 
 ***    C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S     *** 
 *************************************************************************** 
 *                                                                         * 
 *                 Project Name : G                                        * 
 *                                                                         * 
 *                     $Archive:: /Commando/Code/ww3d2/part_buf.cpp       $* 
 *                                                                         * 
 *                      $Author:: Jani_p                                  $* 
 *                                                                         * 
 *                     $Modtime:: 9/07/01 12:57p                          $* 
 *                                                                         * 
 *                    $Revision:: 20                                      $* 
 *                                                                         * 
 *-------------------------------------------------------------------------* 
 * Functions:                                                              * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "part_buf.h"
#include "part_emt.h"
#include "ww3d.h"
#include "rinfo.h"
#include "scene.h"
#include "camera.h"
#include "predlod.h"
#include "pot.h"
#include "bound.h"
#include "simplevec.h"
#include "sphere.h"
#include "wwprofile.h"
#include <limits.h>
#include "vp.h"
#include "texture.h"
#include "dx8wrapper.h"
#include "vector3.h"

// A random permutation of the numbers 0 to 15 - used for LOD particle decimation.
// It was generated by the amazingly high-tech method of pulling numbers out of a hat.
const unsigned int ParticleBufferClass::PermutationArray[16] = {
	11, 3, 7, 14, 0, 13, 1, 2, 5, 12, 15, 6, 9, 8, 4, 10
};

// Maximum size of randomizer tables
const static unsigned int MAX_RANDOM_ENTRIES = 32;	// MUST be power of two!

// Total Active Particle Buffer Count
unsigned int ParticleBufferClass::TotalActiveCount = 0;

// Static array of screen-size clamps for the 17 possible LOD levels a particle buffer can have.
// We can change these from being global to being per-buffer later if we wish. Default is
// NO_MAX_SCREEN_SIZE.
float ParticleBufferClass::LODMaxScreenSizes[17] = {
	NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE,
	NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE,
	NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE,
	NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE, NO_MAX_SCREEN_SIZE,
	NO_MAX_SCREEN_SIZE
};

static Random4Class rand_gen;
const float oo_intmax = 1.0f / (float)INT_MAX;

// Default Line Emitter Properties
static const W3dEmitterLinePropertiesStruct _DefaultLineEmitterProps=
{ 0,0,0.0f,1.5f,1.0f,0.0f,0.0f,0,0,0,0,0,0,0,0,0 };

ParticleBufferClass::ParticleBufferClass
(
	ParticleEmitterClass *emitter, 
	unsigned int buffer_size,
	ParticlePropertyStruct<Vector3> &color, 
	ParticlePropertyStruct<float> &opacity,
	ParticlePropertyStruct<float> &size, 
	ParticlePropertyStruct<float> &rotation,
	float orient_rnd,
	ParticlePropertyStruct<float> &frame,
	ParticlePropertyStruct<float> &blurtime,
	Vector3 accel, 
	float max_age, 
	float future_start,
	TextureClass *tex,
	ShaderClass shader, 
	bool pingpong,
	int render_mode, 
	int frame_mode,
	const W3dEmitterLinePropertiesStruct * line_props
) :
	NewParticleQueue(NULL),
	NewParticleQueueStart(0U),
	NewParticleQueueEnd(0U),
	NewParticleQueueCount(0U),
	RenderMode(render_mode),
	FrameMode(frame_mode),
	MaxAge(1000.0f * max_age),
	FutureStartTime(1000.0f * future_start),
	LastUpdateTime(WW3D::Get_Sync_Time()),
	IsEmitterDead(false),
	MaxSize(0.0f),
	MaxNum(buffer_size),
	Start(0U),
	End(0U),
	NewEnd(0U),
	NonNewNum(0),
	NewNum(0),
	BoundingBox(Vector3(0,0,0),Vector3(0,0,0)),
	BoundingBoxDirty(true),
	NumColorKeyFrames(0),
	ColorKeyFrameTimes(NULL),
	ColorKeyFrameValues(NULL),
	ColorKeyFrameDeltas(NULL),
	NumAlphaKeyFrames(0),
	AlphaKeyFrameTimes(NULL),
	AlphaKeyFrameValues(NULL),
	AlphaKeyFrameDeltas(NULL),
	NumSizeKeyFrames(0),
	SizeKeyFrameTimes(NULL),
	SizeKeyFrameValues(NULL),
	SizeKeyFrameDeltas(NULL),
	NumRotationKeyFrames(0),
	RotationKeyFrameTimes(NULL),
	RotationKeyFrameValues(NULL),
	HalfRotationKeyFrameDeltas(NULL),
	OrientationKeyFrameValues(NULL),
	NumFrameKeyFrames(0),
	FrameKeyFrameTimes(NULL),
	FrameKeyFrameValues(NULL),
	FrameKeyFrameDeltas(NULL),
	NumBlurTimeKeyFrames(0),
	BlurTimeKeyFrameTimes(NULL),
	BlurTimeKeyFrameValues(NULL),
	BlurTimeKeyFrameDeltas(NULL),
	NumRandomColorEntriesMinus1(0),
	RandomColorEntries(NULL),
	NumRandomAlphaEntriesMinus1(0),
	RandomAlphaEntries(NULL),
	NumRandomSizeEntriesMinus1(0),
	RandomSizeEntries(NULL),
	ColorRandom(0, 0, 0),
	OpacityRandom(0),
	SizeRandom(0),
	RotationRandom(0),
	FrameRandom(0),
	InitialOrientationRandom(0),
	NumRandomRotationEntriesMinus1(0),
	RandomRotationEntries(NULL),
	NumRandomOrientationEntriesMinus1(0),
	RandomOrientationEntries(NULL),
	NumRandomFrameEntriesMinus1(0),
	RandomFrameEntries(NULL),
	NumRandomBlurTimeEntriesMinus1(0),
	RandomBlurTimeEntries(NULL),
	PointGroup(NULL),
	LineRenderer(NULL),
	LineGroup(NULL),
	Diffuse(NULL),
	TailDiffuse(NULL),
	Color(NULL),
	Alpha(NULL),
	Size(NULL),
	Orientation(NULL),
	Frame(NULL),
	UCoord(NULL),
	TailPosition(NULL),
	APT(NULL),
	GroupID(NULL),
	PingPongPosition(pingpong),
	Velocity(NULL),
	TimeStamp(NULL),
	Emitter(emitter),
	DecimationThreshold(0U),
	ProjectedArea(0.0f),
	DefaultTailDiffuse(0,0,0,0),
	CurrentGroupID(0)
{
	LodCount = 17;
	LodBias = 1.0f;

	Position[0] = NULL;
	Position[1] = NULL;

	// Create color array, keyframes and randomizer table (if needed)
	Reset_Colors(color);

	// Create alpha array, keyframes and randomizer table (if needed)
	Reset_Opacity(opacity);

	// Create size array, keyframes and randomizer table (if needed)
	Reset_Size(size);

	// Create the rotation array, keyframes, and randomizer table (if needed)
	Reset_Rotations(rotation, orient_rnd);

	// Create the frame array, keyframes, and randomizer table (if needed)
	Reset_Frames(frame);

	// Create the blur time array, keyframes, and randomizer table if needed
	Reset_Blur_Times(blurtime);

	// We do not add a ref for the emitter (see DTor for detailed explanation)
	// if (Emitter) Emitter->Add_Ref();

	// Set up new particle queue:
	NewParticleQueue = W3DNEWARRAY NewParticleStruct[MaxNum];

	// These inputs don't need to be range-checked (emitter did that).
	Accel = accel;
	HasAccel = (accel.X != 0.0f) || (accel.Y != 0.0f) || (accel.Z != 0.0f);
   
	shader.Enable_Fog ("ParticleBufferClass");
	switch (RenderMode)	
	{
	case W3D_EMITTER_RENDER_MODE_TRI_PARTICLES:
		{
			// Set up worldspace point group
			PointGroup = W3DNEW PointGroupClass();
			PointGroup->Set_Flag(PointGroupClass::TRANSFORM, true);
			PointGroup->Set_Texture(tex);			
			PointGroup->Set_Shader(shader);
			PointGroup->Set_Frame_Row_Column_Count_Log2(frame_mode);
			PointGroup->Set_Point_Mode(PointGroupClass::TRIS);
		}
		break;
	case W3D_EMITTER_RENDER_MODE_QUAD_PARTICLES:
		{
			// Set up worldspace point group
			PointGroup = W3DNEW PointGroupClass();
			PointGroup->Set_Flag(PointGroupClass::TRANSFORM, true);
			PointGroup->Set_Texture(tex);			
			PointGroup->Set_Shader(shader);
			PointGroup->Set_Frame_Row_Column_Count_Log2(frame_mode);
			PointGroup->Set_Point_Mode(PointGroupClass::QUADS);
		}
		break;
	case W3D_EMITTER_RENDER_MODE_LINE:
		{			
			LineRenderer = W3DNEW SegLineRendererClass;
			LineRenderer->Init(*line_props);
			LineRenderer->Set_Texture(tex);
			LineRenderer->Set_Shader(shader);
			LineRenderer->Set_Width(Get_Particle_Size());
			if (line_props != NULL) {				
				LineRenderer->Init(*line_props);
			} else {
				// This code should not be run, but if it does,
				// set line emitters to some reasonable value so
				// it doesn't crash
				WWASSERT(0);
				LineRenderer->Init(_DefaultLineEmitterProps);
			}
		}
		break;
	case W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA:
		{
			LineGroup=W3DNEW LineGroupClass();
			LineGroup->Set_Flag(LineGroupClass::TRANSFORM, true);
			LineGroup->Set_Texture(tex);
			LineGroup->Set_Shader(shader);
			LineGroup->Set_Line_Mode(LineGroupClass::TETRAHEDRON);
			TailPosition = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::TailPosition" ) );
			// TODO: Change TailPosition to Kinematic state and add
			// tail positions to bounding box
			Set_Force_Visible(1);
		}
		break;
	case W3D_EMITTER_RENDER_MODE_LINEGRP_PRISM:
		{
			LineGroup=W3DNEW LineGroupClass();
			LineGroup->Set_Flag(LineGroupClass::TRANSFORM, true);
			LineGroup->Set_Texture(tex);
			LineGroup->Set_Shader(shader);
			LineGroup->Set_Line_Mode(LineGroupClass::PRISM);
			TailPosition = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::TailPosition" ) );
			// TODO: Change TailPosition to Kinematic state and add
			// tail positions to bounding box
			Set_Force_Visible(1);
		}
		break;
	default:
		WWASSERT(0);
		break;
	}	

	// Set up circular buffer. Contents are not initialized because the
	// start/end indices currently indicate the buffer is empty.
	Position[0] = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::Position") );
	if (PingPongPosition) {
		Position[1] = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::Position") );
	}
	APT = NEW_REF( ShareBufferClass<unsigned int> , (MaxNum, "ParticleBufferClass::APT") );
	GroupID = NEW_REF( ShareBufferClass<unsigned char> , (MaxNum, "ParticleBufferClass::GroupID") );
	Velocity = W3DNEWARRAY Vector3[MaxNum]; 
	TimeStamp = W3DNEWARRAY unsigned int[MaxNum];

	// So that the object is ready for use after construction, we will
	// complete its initialization by initializing its cost and value arrays
	// according to a screen area of 1.
	int minlod = Calculate_Cost_Value_Arrays(1.0f, Value, Cost);

	// Ensure lod is no less than minimum allowed
	if (Get_LOD_Level() < minlod) Set_LOD_Level(minlod);

	// Update Global Count
	TotalActiveCount++;

	//lorenzen
	// If the render mode is W3D_EMITTER_RENDER_MODE_LINE and we are supplied with
	// a line properties structure, set up a line renderer
	if (RenderMode == W3D_EMITTER_RENDER_MODE_LINE) {
		if (line_props != NULL) {
			LineRenderer = W3DNEW SegLineRendererClass;
			LineRenderer->Init(*line_props);
			LineRenderer->Set_Texture(tex);
			LineRenderer->Set_Shader(shader);
			LineRenderer->Set_Width(Get_Particle_Size());
		} else {
			// We were in line mode but didn't get any line properties, drop back to triangles
			RenderMode = W3D_EMITTER_RENDER_MODE_TRI_PARTICLES;
		}
	}
}


ParticleBufferClass::ParticleBufferClass(const ParticleBufferClass & src) :
	RenderObjClass(src),
	NewParticleQueue(NULL),
	NewParticleQueueStart(0U),
	NewParticleQueueEnd(0U),
	NewParticleQueueCount(0U),
	RenderMode(src.RenderMode),
	FrameMode(src.FrameMode),
	MaxAge(src.MaxAge),
	FutureStartTime(src.FutureStartTime),
	LastUpdateTime(WW3D::Get_Sync_Time()),
	IsEmitterDead(false),
	MaxSize(src.MaxSize),
	MaxNum(src.MaxNum),
	Start(0U),
	End(0U),
	NewEnd(0U),
	NonNewNum(0),
	NewNum(0),
	BoundingBox(Vector3(0,0,0),Vector3(0,0,0)),
	BoundingBoxDirty(true),
	NumColorKeyFrames(src.NumColorKeyFrames),
	ColorKeyFrameTimes(NULL),
	ColorKeyFrameValues(NULL),
	ColorKeyFrameDeltas(NULL),
	NumAlphaKeyFrames(src.NumAlphaKeyFrames),
	AlphaKeyFrameTimes(NULL),
	AlphaKeyFrameValues(NULL),
	AlphaKeyFrameDeltas(NULL),
	NumSizeKeyFrames(src.NumSizeKeyFrames),
	SizeKeyFrameTimes(NULL),
	SizeKeyFrameValues(NULL),
	SizeKeyFrameDeltas(NULL),
	NumRotationKeyFrames(src.NumRotationKeyFrames),
	RotationKeyFrameTimes(NULL),
	RotationKeyFrameValues(NULL),
	HalfRotationKeyFrameDeltas(NULL),
	OrientationKeyFrameValues(NULL),
	NumFrameKeyFrames(src.NumFrameKeyFrames),
	FrameKeyFrameTimes(NULL),
	FrameKeyFrameValues(NULL),
	FrameKeyFrameDeltas(NULL),
	NumBlurTimeKeyFrames(src.NumBlurTimeKeyFrames),
	BlurTimeKeyFrameTimes(NULL),
	BlurTimeKeyFrameValues(NULL),
	BlurTimeKeyFrameDeltas(NULL),
	RandomColorEntries(NULL),
	RandomAlphaEntries(NULL),
	RandomSizeEntries(NULL),
	ColorRandom(src.ColorRandom),
	OpacityRandom(src.OpacityRandom),
	SizeRandom(src.SizeRandom),
	RotationRandom(src.RotationRandom),
	FrameRandom(src.FrameRandom),
	InitialOrientationRandom(src.InitialOrientationRandom),
	NumRandomRotationEntriesMinus1(0),
	RandomRotationEntries(NULL),
	NumRandomOrientationEntriesMinus1(0),
	RandomOrientationEntries(NULL),
	NumRandomFrameEntriesMinus1(0),
	RandomFrameEntries(NULL),
	NumRandomBlurTimeEntriesMinus1(0),
	RandomBlurTimeEntries(NULL),
	PointGroup(NULL),
	LineRenderer(NULL),
	LineGroup(NULL),
	Diffuse(NULL),
	TailDiffuse(NULL),
	Color(NULL),
	Alpha(NULL),
	Size(NULL),
	Orientation(NULL),
	Frame(NULL),
	UCoord(NULL),
	TailPosition(NULL),
	APT(NULL),
	GroupID(NULL),
	PingPongPosition(src.PingPongPosition),
	Velocity(NULL),
	TimeStamp(NULL),
	Emitter(src.Emitter),
	DecimationThreshold(src.DecimationThreshold),
	ProjectedArea(0.0f),
	DefaultTailDiffuse(src.DefaultTailDiffuse)	
{
	Position[0] = NULL;
	Position[1] = NULL;

	unsigned int i;

	LodCount = MIN(MaxNum, 17);
	LodBias = src.LodBias;

	/*
	** Create visual state arrays, copy keyframes and randomizer tables.
	*/

	NumRandomColorEntriesMinus1 = src.NumRandomColorEntriesMinus1;
	if (src.Color) {
		// Create color array
		Color = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::Color") );

		// Copy color keyframes
		ColorKeyFrameTimes = W3DNEWARRAY unsigned int [NumColorKeyFrames];
		ColorKeyFrameValues = W3DNEWARRAY Vector3 [NumColorKeyFrames];
		ColorKeyFrameDeltas = W3DNEWARRAY Vector3 [NumColorKeyFrames];
		for (i = 0; i < NumColorKeyFrames; i++) {
			ColorKeyFrameTimes[i] = src.ColorKeyFrameTimes[i];
			ColorKeyFrameValues[i] = src.ColorKeyFrameValues[i];
			ColorKeyFrameDeltas[i] = src.ColorKeyFrameDeltas[i];
		}

		// Copy color randomizer table
		if (src.RandomColorEntries) {
			RandomColorEntries = W3DNEWARRAY Vector3 [NumRandomColorEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomColorEntriesMinus1; j++) {
				RandomColorEntries[j] = src.RandomColorEntries[j];
			}
		}
	} else {
		ColorKeyFrameValues = W3DNEWARRAY Vector3 [1];
		ColorKeyFrameValues[0] = src.ColorKeyFrameValues[0];
	}

	NumRandomAlphaEntriesMinus1 = src.NumRandomAlphaEntriesMinus1;
	if (src.Alpha) {
		// Create alpha array
		Alpha = NEW_REF( ShareBufferClass<float> , (MaxNum, "ParticleBufferClass::Alpha") );

		// Copy alpha keyframes
		AlphaKeyFrameTimes = W3DNEWARRAY unsigned int [NumAlphaKeyFrames];
		AlphaKeyFrameValues = W3DNEWARRAY float [NumAlphaKeyFrames];
		AlphaKeyFrameDeltas = W3DNEWARRAY float [NumAlphaKeyFrames];
		for (i = 0; i < NumAlphaKeyFrames; i++) {
			AlphaKeyFrameTimes[i] = src.AlphaKeyFrameTimes[i];
			AlphaKeyFrameValues[i] = src.AlphaKeyFrameValues[i];
			AlphaKeyFrameDeltas[i] = src.AlphaKeyFrameDeltas[i];
		}

		// Copy alpha randomizer table
		if (src.RandomAlphaEntries) {
			RandomAlphaEntries = W3DNEWARRAY float [NumRandomAlphaEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomAlphaEntriesMinus1; j++) {
				RandomAlphaEntries[j] = src.RandomAlphaEntries[j];
			}
		}
	} else {
		AlphaKeyFrameValues = W3DNEWARRAY float [1];
		AlphaKeyFrameValues[0] = src.AlphaKeyFrameValues[0];
	}

	NumRandomSizeEntriesMinus1 = src.NumRandomSizeEntriesMinus1;
	if (src.Size) {
		// Create size array
		Size = NEW_REF( ShareBufferClass<float> , (MaxNum, "ParticleBufferClass::Size") );

		// Copy size keyframes
		SizeKeyFrameTimes = W3DNEWARRAY unsigned int [NumSizeKeyFrames];
		SizeKeyFrameValues = W3DNEWARRAY float [NumSizeKeyFrames];
		SizeKeyFrameDeltas = W3DNEWARRAY float [NumSizeKeyFrames];
		for (i = 0; i < NumSizeKeyFrames; i++) {
			SizeKeyFrameTimes[i] = src.SizeKeyFrameTimes[i];
			SizeKeyFrameValues[i] = src.SizeKeyFrameValues[i];
			SizeKeyFrameDeltas[i] = src.SizeKeyFrameDeltas[i];
		}

		// Copy size randomizer table
		if (src.RandomSizeEntries) {
			RandomSizeEntries = W3DNEWARRAY float [NumRandomSizeEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomSizeEntriesMinus1; j++) {
				RandomSizeEntries[j] = src.RandomSizeEntries[j];
			}
		}
	} else {
		SizeKeyFrameValues = W3DNEWARRAY float [1];
		SizeKeyFrameValues[0] = src.SizeKeyFrameValues[0];
	}

	// Set up the rotation / orientation keyframes
	NumRandomRotationEntriesMinus1 = src.NumRandomRotationEntriesMinus1;
	NumRandomOrientationEntriesMinus1 = src.NumRandomOrientationEntriesMinus1;
	if (src.Orientation) {
		// Create orientation array
		Orientation = NEW_REF( ShareBufferClass<uint8> , (MaxNum, "ParticleBufferClass::Orientation") );

		// Copy rotation / orientation keyframes
		RotationKeyFrameTimes = W3DNEWARRAY unsigned int [NumRotationKeyFrames];
		RotationKeyFrameValues = W3DNEWARRAY float [NumRotationKeyFrames];
		HalfRotationKeyFrameDeltas = W3DNEWARRAY float [NumRotationKeyFrames];
		OrientationKeyFrameValues = W3DNEWARRAY float [NumRotationKeyFrames];
		for (i = 0; i < NumRotationKeyFrames; i++) {
			RotationKeyFrameTimes[i] = src.RotationKeyFrameTimes[i];
			RotationKeyFrameValues[i] = src.RotationKeyFrameValues[i];
			HalfRotationKeyFrameDeltas[i] = src.HalfRotationKeyFrameDeltas[i];
			OrientationKeyFrameValues[i] = src.OrientationKeyFrameValues[i];
		}

		// Copy rotation randomizer table
		if (src.RandomRotationEntries) {
			RandomRotationEntries = W3DNEWARRAY float [NumRandomRotationEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomRotationEntriesMinus1; j++) {
				RandomRotationEntries[j] = src.RandomRotationEntries[j];
			}
		}

		// Copy starting orientation randomizer table
		if (src.RandomOrientationEntries) {
			RandomOrientationEntries = W3DNEWARRAY float [NumRandomOrientationEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomOrientationEntriesMinus1; j++) {
				RandomOrientationEntries[j] = src.RandomOrientationEntries[j];
			}
		}

	} else {
		// Unlike other properties, if there is no Orientation array then all the arrays are NULL
		// (including the Values array) - there is an implicit starting value of 0.
	}


	// Set up the frame keyframes
	// Frame and UCoord both use Frame Key Frames for the source data
	NumRandomFrameEntriesMinus1 = src.NumRandomFrameEntriesMinus1;
	if (src.Frame || src.UCoord) {
		// Create frame array
		if (src.Frame) {
			Frame = NEW_REF( ShareBufferClass<uint8> , (MaxNum, "ParticleBufferClass::Frame") );
		} else {
			UCoord = NEW_REF( ShareBufferClass<float>, (MaxNum, "ParticleBufferClass::UCoord") );
		}

		// Copy frame keyframes
		FrameKeyFrameTimes = W3DNEWARRAY unsigned int [NumFrameKeyFrames];
		FrameKeyFrameValues = W3DNEWARRAY float [NumFrameKeyFrames];
		FrameKeyFrameDeltas = W3DNEWARRAY float [NumFrameKeyFrames];
		for (i = 0; i < NumFrameKeyFrames; i++) {
			FrameKeyFrameTimes[i] = src.FrameKeyFrameTimes[i];
			FrameKeyFrameValues[i] = src.FrameKeyFrameValues[i];
			FrameKeyFrameDeltas[i] = src.FrameKeyFrameDeltas[i];
		}

		// Copy frame randomizer table
		if (src.RandomFrameEntries) {
			RandomFrameEntries = W3DNEWARRAY float [NumRandomFrameEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomFrameEntriesMinus1; j++) {
				RandomFrameEntries[j] = src.RandomFrameEntries[j];
			}
		}
	} else {
		FrameKeyFrameValues = W3DNEWARRAY float [1];
		FrameKeyFrameValues[0] = src.FrameKeyFrameValues[0];
	}

	// Set up the blur times keyframes
	NumRandomBlurTimeEntriesMinus1 = src.NumRandomBlurTimeEntriesMinus1;
	if (NumBlurTimeKeyFrames > 0) {
		// Copy blur time keyframes
		BlurTimeKeyFrameTimes = new unsigned int [NumBlurTimeKeyFrames];
		BlurTimeKeyFrameValues = new float [NumBlurTimeKeyFrames];
		BlurTimeKeyFrameDeltas = new float [NumBlurTimeKeyFrames];
		for (i = 0; i < NumBlurTimeKeyFrames; i++) {
			BlurTimeKeyFrameTimes[i] = src.BlurTimeKeyFrameTimes[i];
			BlurTimeKeyFrameValues[i] = src.BlurTimeKeyFrameValues[i];
			BlurTimeKeyFrameDeltas[i] = src.BlurTimeKeyFrameDeltas[i];
		}

		// Copy blur time randomizer table
		if (src.RandomBlurTimeEntries) {
			RandomBlurTimeEntries = new float [NumRandomBlurTimeEntriesMinus1 + 1];
			for (unsigned int j = 0; j <= NumRandomBlurTimeEntriesMinus1; j++) {
				RandomBlurTimeEntries[j] = src.RandomBlurTimeEntries[j];
			}
		}
	} else {
		BlurTimeKeyFrameValues = new float [1];
		BlurTimeKeyFrameValues[0] = src.BlurTimeKeyFrameValues[0];
	}


	// We do not add a ref for the emitter (see DTor for detailed explanation)
	// if (Emitter) Emitter->Add_Ref();

	// Set up new particle queue:
	NewParticleQueue = W3DNEWARRAY NewParticleStruct[MaxNum];

	// Inputs don't need to be range-checked (emitter did that).
	Accel = src.Accel;
	HasAccel = src.HasAccel;

	switch (RenderMode)	
	{
	case W3D_EMITTER_RENDER_MODE_TRI_PARTICLES:
		{
			// Set up worldspace point group
			WWASSERT(src.PointGroup);
			PointGroup = W3DNEW PointGroupClass();
			PointGroup->Set_Flag(PointGroupClass::TRANSFORM, true);
			PointGroup->Set_Texture(src.PointGroup->Peek_Texture());
			PointGroup->Set_Shader(src.PointGroup->Get_Shader());
			PointGroup->Set_Point_Mode(PointGroupClass::TRIS);
			PointGroup->Set_Frame_Row_Column_Count_Log2(src.PointGroup->Get_Frame_Row_Column_Count_Log2());
		}
		break;
	case W3D_EMITTER_RENDER_MODE_QUAD_PARTICLES:
		{
			// Set up worldspace point group
			WWASSERT(src.PointGroup);
			PointGroup = W3DNEW PointGroupClass();
			PointGroup->Set_Flag(PointGroupClass::TRANSFORM, true);
			PointGroup->Set_Texture(src.PointGroup->Peek_Texture());
			PointGroup->Set_Shader(src.PointGroup->Get_Shader());
			PointGroup->Set_Point_Mode(PointGroupClass::QUADS);
			PointGroup->Set_Frame_Row_Column_Count_Log2(src.PointGroup->Get_Frame_Row_Column_Count_Log2());
		}
		break;
	case W3D_EMITTER_RENDER_MODE_LINE:
		{	
			WWASSERT(src.LineRenderer);
			LineRenderer = W3DNEW SegLineRendererClass(*src.LineRenderer);
		}
		break;
	case W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA:
		{
			WWASSERT(src.LineGroup);
			LineGroup = W3DNEW LineGroupClass();
			LineGroup->Set_Flag(LineGroupClass::TRANSFORM, true);
			LineGroup->Set_Texture(src.LineGroup->Peek_Texture());
			LineGroup->Set_Shader(src.LineGroup->Get_Shader());
			LineGroup->Set_Line_Mode(LineGroupClass::TETRAHEDRON);
			TailPosition = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::TailPosition") );
			// TODO: Change TailPosition to Kinematic state and add
			// tail positions to bounding box
			Set_Force_Visible(1);
		}
		break;
	case W3D_EMITTER_RENDER_MODE_LINEGRP_PRISM:
		{
			WWASSERT(src.LineGroup);
			LineGroup = W3DNEW LineGroupClass();
			LineGroup->Set_Flag(LineGroupClass::TRANSFORM, true);
			LineGroup->Set_Texture(src.LineGroup->Peek_Texture());
			LineGroup->Set_Shader(src.LineGroup->Get_Shader());
			LineGroup->Set_Line_Mode(LineGroupClass::PRISM);
			TailPosition = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::TailPosition") );
			// TODO: Change TailPosition to Kinematic state and add
			// tail positions to bounding box
			Set_Force_Visible(1);
		}
		break;
	default:
		WWASSERT(0);
		break;
	}

	// Set up circular buffer. Contents are not initialized because the
	// start/end indices currently indicate the buffer is empty.
	Position[0] = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::Position") );
	if (PingPongPosition) {
		Position[1] = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::Position") );
	}
	APT = NEW_REF( ShareBufferClass<unsigned int> , (MaxNum, "ParticleBufferClass::APT") );
	GroupID = NEW_REF( ShareBufferClass<unsigned char> , (MaxNum, "ParticleBufferClass::GroupID") );
	Velocity = W3DNEWARRAY Vector3[MaxNum]; 
	TimeStamp = W3DNEWARRAY unsigned int[MaxNum];

	// So that the object is ready for use after construction, we will
	// complete its initialization by initializing its cost and value arrays
	// according to a screen area of 1.
	int minlod = Calculate_Cost_Value_Arrays(1.0f, Value, Cost);

	// Ensure lod is no less than minimum allowed
	if (Get_LOD_Level() < minlod) Set_LOD_Level(minlod);

	// Update Global Count
	TotalActiveCount++;
}


ParticleBufferClass & ParticleBufferClass::operator = (const ParticleBufferClass & that)
{
	RenderObjClass::operator = (that);

	if (this != &that) {
		assert(0);	// TODO: if you hit this assert, please implement me !!!;-)
	}

	return * this;
}


ParticleBufferClass::~ParticleBufferClass(void)
{
	if (NewParticleQueue)				delete [] NewParticleQueue;
	if (ColorKeyFrameTimes)				delete [] ColorKeyFrameTimes;
	if (ColorKeyFrameValues)			delete [] ColorKeyFrameValues;
	if (ColorKeyFrameDeltas)			delete [] ColorKeyFrameDeltas;
	if (AlphaKeyFrameTimes)				delete [] AlphaKeyFrameTimes;
	if (AlphaKeyFrameValues)			delete [] AlphaKeyFrameValues;
	if (AlphaKeyFrameDeltas)			delete [] AlphaKeyFrameDeltas;
	if (SizeKeyFrameTimes)				delete [] SizeKeyFrameTimes;
	if (SizeKeyFrameValues)				delete [] SizeKeyFrameValues;
	if (SizeKeyFrameDeltas)				delete [] SizeKeyFrameDeltas;
	if (RotationKeyFrameTimes)			delete [] RotationKeyFrameTimes;
	if (RotationKeyFrameValues)		delete [] RotationKeyFrameValues;
	if (HalfRotationKeyFrameDeltas)	delete [] HalfRotationKeyFrameDeltas;
	if (OrientationKeyFrameValues)	delete [] OrientationKeyFrameValues;
	if (FrameKeyFrameTimes)				delete [] FrameKeyFrameTimes;
	if (FrameKeyFrameValues)			delete [] FrameKeyFrameValues;
	if (FrameKeyFrameDeltas)			delete [] FrameKeyFrameDeltas;
	if (BlurTimeKeyFrameTimes)			delete [] BlurTimeKeyFrameTimes;
	if (BlurTimeKeyFrameValues)		delete [] BlurTimeKeyFrameValues;
	if (BlurTimeKeyFrameDeltas)		delete [] BlurTimeKeyFrameDeltas;
	if (RandomColorEntries)				delete [] RandomColorEntries;
	if (RandomAlphaEntries)				delete [] RandomAlphaEntries;
	if (RandomSizeEntries)				delete [] RandomSizeEntries;
	if (RandomRotationEntries)			delete [] RandomRotationEntries;
	if (RandomOrientationEntries)		delete [] RandomOrientationEntries;
	if (RandomFrameEntries)				delete [] RandomFrameEntries;
	if (RandomBlurTimeEntries)			delete [] RandomBlurTimeEntries;
	
	if (PointGroup)						delete PointGroup;
	if (LineRenderer)						delete LineRenderer;
	if (LineGroup)							delete LineGroup;

	REF_PTR_RELEASE(Position[0]);
	REF_PTR_RELEASE(Position[1]);
	REF_PTR_RELEASE(Diffuse);
	REF_PTR_RELEASE(TailDiffuse);
	REF_PTR_RELEASE(Color);
	REF_PTR_RELEASE(Alpha);
	REF_PTR_RELEASE(Size);
	REF_PTR_RELEASE(Orientation);
	REF_PTR_RELEASE(Frame);
	REF_PTR_RELEASE(UCoord);
	REF_PTR_RELEASE(TailPosition);
	REF_PTR_RELEASE(APT);
	REF_PTR_RELEASE(GroupID);

	if (Velocity)	delete [] Velocity;
	if (TimeStamp)	delete [] TimeStamp;
	if (Emitter) {
		// We should not have an emitter at this point, since the emitter
		// should still have a live ref to us if it still exists which would
		// prevent us from getting killed.
		assert(0);
		// We do not release-ref the emitter pointer because we did not add a
		// ref for it to begin with; the ref is not needed (if the emitter gets
		// deleted it will tell us to clear our emitter pointer) and actually
		// harmful (if emitter and buffer each have refcounted pointers to the
		// other neither would ever get deleted).
		// Emitter->Release_Ref();
		Emitter = NULL;
	}	

	// Update Global Count
	TotalActiveCount--;
}


RenderObjClass * ParticleBufferClass::Clone(void) const
{
	return W3DNEW ParticleBufferClass(*this);
}


int ParticleBufferClass::Get_Num_Polys(void) const
{
	// Currently in particle buffers, the cost happens to be equal to thwe polygon count.
	return (int)Get_Cost();
}

int ParticleBufferClass::Get_Particle_Count(void) const
{
	return NonNewNum + NewNum;
}

void ParticleBufferClass::Render(RenderInfoClass & rinfo)
{
	WWPROFILE("ParticleBuffer::Render");	

	unsigned int sort_level = SORT_LEVEL_NONE;

	if (!WW3D::Is_Sorting_Enabled())
		sort_level=Get_Shader().Guess_Sort_Level();

	if (WW3D::Are_Static_Sort_Lists_Enabled() && sort_level!=SORT_LEVEL_NONE) {		
		
		WW3D::Add_To_Static_Sort_List(this, sort_level);

	} else {
		// Ensure particles' kinematic state is updated
		Update_Kinematic_Particle_State();

		// Since we are rendering the particles, visual state needs to be updated (but not if the
		// entire particle buffer is decimated away)
		if (DecimationThreshold < LodCount - 1) {
			Update_Visual_Particle_State();
		}

		switch( RenderMode )
		{
		case W3D_EMITTER_RENDER_MODE_TRI_PARTICLES:
		case W3D_EMITTER_RENDER_MODE_QUAD_PARTICLES:
			Render_Particles(rinfo);
			break;
		case W3D_EMITTER_RENDER_MODE_LINE:
			Render_Line(rinfo);
			break;
		case W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA:
		case W3D_EMITTER_RENDER_MODE_LINEGRP_PRISM:
			Render_Line_Group(rinfo);
			break;

		}
	}
}

void ParticleBufferClass::Generate_APT(ShareBufferClass <unsigned int> **apt,unsigned int &active_point_count)
{
	if (NonNewNum < (int)MaxNum || DecimationThreshold > 0) {
		// In the general case, a range in a circular buffer can be composed of up
		// to two subranges. Find the Start - End subranges.
		// This differs from other similar code segments because we want to access
		// the subranges in memory order (rather than in queue order) this time.
		unsigned int sub1_start;	// Start of subrange 1.
		unsigned int sub1_end;		// End of subrange 1.
		unsigned int sub2_start;	// Start of subrange 2.
		unsigned int sub2_end;		// End of subrange 2.
		unsigned int i;			// Loop index.
		if ((Start < End) || ((Start == End) && NonNewNum == 0)) {
			sub1_start = Start;
			sub1_end = End;
			sub2_start = End;
			sub2_end = End;
		} else {
			sub1_start = 0;
			sub1_end = End;
			sub2_start = Start;
			sub2_end = MaxNum;
		}
		// Generate APT:
		unsigned int *apt_ptr = APT->Get_Array();
		for (i = sub1_start; i < sub1_end; i++) {
			if (PermutationArray[i & 0xF] >= DecimationThreshold) {
				apt_ptr[active_point_count++] = i;
			}
		}
		for (i = sub2_start; i < sub2_end; i++) {
			if (PermutationArray[i & 0xF] >= DecimationThreshold) {
				apt_ptr[active_point_count++] = i;
			}
		}
		*apt = APT;
	} else {
		active_point_count = NonNewNum;
	}
}

void ParticleBufferClass::Combine_Color_And_Alpha()
{
	// Temporary array copying to combine diffuse and alpha to one array.
	if (Color || Alpha) {
		unsigned cnt=MaxNum;
		if (!Diffuse) {
			Diffuse = NEW_REF( ShareBufferClass<Vector4> , (MaxNum, "ParticleBufferClass::Diffuse") );
		}
		if (Color && Alpha) {
			VectorProcessorClass::Copy(
				Diffuse->Get_Array(),
				Color->Get_Array(),
				Alpha->Get_Array(),
				cnt);
		}
		else if (Color) {
			VectorProcessorClass::Copy(
				Diffuse->Get_Array(),
				Color->Get_Array(),
				1.0f,
				cnt);
		}
		else {
			VectorProcessorClass::Copy(
				Diffuse->Get_Array(),
				Vector3(1.0f,1.0f,1.0f),
				Alpha->Get_Array(),
				cnt);
		}
		VectorProcessorClass::Clamp(
			Diffuse->Get_Array(),
			Diffuse->Get_Array(),
			0.0f,
			1.0f,
			cnt);
	}
	else if (Diffuse) {
		Diffuse->Release_Ref();
		Diffuse=NULL;
	}
}

void ParticleBufferClass::Render_Particles(RenderInfoClass & rinfo)
{
	// If the number of active points is less than the maximum or we need to decimate particles
	// (for LOD purposes), build the active point table:
	ShareBufferClass<unsigned int> *apt = NULL;

	unsigned int active_point_count = 0;

	Generate_APT(&apt,active_point_count);	

	// Set color, alpha, size defaults if array not present:
	if (!Color) {
		PointGroup->Set_Point_Color(ColorKeyFrameValues[0]);
	}
	if (!Alpha) {
		PointGroup->Set_Point_Alpha(AlphaKeyFrameValues[0]);
	}
	if (!Size) {
		PointGroup->Set_Point_Size(SizeKeyFrameValues[0]);
	}
	if (!Orientation) {
		// The rotation keyframes are used to derive the orientation indirectly, as well as the
		// starting orientation randomizer. If there is no Orientation array that means both are
		// absent so the orientation should just be set to 0.
		PointGroup->Set_Point_Orientation(0);
	}
	if (!Frame) {
		PointGroup->Set_Point_Frame(((int)(FrameKeyFrameValues[0])) & 0xFF);
	}


	// Pass the point buffer to the point group and render it.
	// If we are using pingpong position buffers pass the right one
	int pingpong = 0;
	if (PingPongPosition) {
		pingpong = WW3D::Get_Frame_Count() & 0x1;
	}

	Combine_Color_And_Alpha();

	PointGroup->Set_Arrays(Position[pingpong], Diffuse, apt, Size, Orientation, Frame, active_point_count);
	Update_Bounding_Box();	
	PointGroup->Render(rinfo);	
}


void ParticleBufferClass::Render_Line(RenderInfoClass & rinfo)
{

	LineRenderer->Set_Freeze_Random(Is_Freeze_Random());

	// Look up the array to use
	int pingpong = 0;
	if (PingPongPosition) {
		pingpong = WW3D::Get_Frame_Count() & 0x1;
	}

	// Unroll the circular buffer while skipping LOD'd particles
	static SimpleDynVecClass<Vector3> tmp_points;
	static SimpleDynVecClass<Vector4> tmp_diffuse;
	static SimpleDynVecClass<unsigned char> tmp_id;

	Vector3 * positions = Position[pingpong]->Get_Array();
	Vector4 * diffuse = 0;
	Vector4 default_diffuse(0, 0, 0, 0);
	unsigned char *ids = GroupID->Get_Array();
	Combine_Color_And_Alpha();
	if (Diffuse) {		
		diffuse = Diffuse->Get_Array();
	} else {
		default_diffuse.Set(ColorKeyFrameValues[0].X, ColorKeyFrameValues[0].Y, ColorKeyFrameValues[0].Z,
								  AlphaKeyFrameValues[0]);
	}

	unsigned int sub1_end;		// End of subrange 1.
	unsigned int sub2_start;	// Start of subrange 2.
	unsigned int i;				// Loop index.

	if ((Start < End) || ((Start == End) && NonNewNum ==0)) {
		sub1_end = End;
		sub2_start = End;
	} else {
		sub1_end = MaxNum;
		sub2_start = 0;
	}

	tmp_points.Delete_All(false);
	tmp_diffuse.Delete_All(false);
	tmp_id.Delete_All(false);

	Vector4 *last_color = &default_diffuse;
	unsigned char last_id = 0;

	for (i = Start; i < sub1_end; i++) {
		if (PermutationArray[i & 0xF] >= DecimationThreshold) {
			tmp_points.Add(positions[i]);
			last_color = diffuse ? &diffuse[i] : &default_diffuse;
			tmp_diffuse.Add(*last_color);
			last_id = ids[i];
			tmp_id.Add(last_id);
		}
	}
	
	for (i = sub2_start; i < End; i++) {
		if (PermutationArray[i & 0xF] >= DecimationThreshold) {
			tmp_points.Add(positions[i]);
			last_color = diffuse ? &diffuse[i] : &default_diffuse;
			tmp_diffuse.Add(*last_color);
			last_id = ids[i];
			tmp_id.Add(last_id);
		}
	}

	// add in the emitter's position too for the source	
	if (Emitter && !Emitter->Is_Stopped() && (last_id == CurrentGroupID)) {
		tmp_points.Add(Emitter->Get_Position());
		// it has the color of the last point
		tmp_diffuse.Add(*last_color);
		tmp_id.Add(last_id);
	}	

	// If we got any points, render them
	if (tmp_points.Count() > 0) {
		SphereClass bounding_sphere;
		Get_Obj_Space_Bounding_Sphere(bounding_sphere);

		// Draw line segments only if they are in the same group
		int count = tmp_points.Count();
		int start = 0;
		int end = 0;		

		while (end < count) {
			// detect contiguous runs of IDs
			while ( (end < count) && (tmp_id[start] == tmp_id[end])) {
				end++;
			}

			// render from start, excluding end
			if (end - start > 1) {
				LineRenderer->Render(rinfo,
											Transform,
											end - start,
											&(tmp_points[start]),
											bounding_sphere,
											&(tmp_diffuse[start]));
			}
			start = end;
		}
	}
}

void ParticleBufferClass::Render_Line_Group(RenderInfoClass & rinfo)
{
	// If the number of active points is less than the maximum or we need to decimate particles
	// (for LOD purposes), build the active point table:
	ShareBufferClass<unsigned int> *apt = NULL;

	unsigned int active_point_count = 0;	

	Generate_APT(&apt,active_point_count);	

	// Set color, alpha, size defaults if array not present:
	if (!Color) {
		LineGroup->Set_Line_Color(ColorKeyFrameValues[0]);
	}
	if (!Alpha) {
		LineGroup->Set_Line_Alpha(AlphaKeyFrameValues[0]);
	}
	if (!Size) {
		LineGroup->Set_Line_Size(SizeKeyFrameValues[0]);
	}
	if (!Frame) {
		LineGroup->Set_Line_UCoord(FrameKeyFrameValues[0]);
	}


	// Pass the point buffer to the line group and render it.
	// If we are using pingpong position buffers pass the right one
	int pingpong = 0;
	if (PingPongPosition) {
		pingpong = WW3D::Get_Frame_Count() & 0x1;
	}

	Combine_Color_And_Alpha();

	TailDiffuseTypeEnum tailtype=Determine_Tail_Diffuse();

	switch (tailtype)
	{
	case BLACK:
		REF_PTR_RELEASE(TailDiffuse);
		DefaultTailDiffuse.Set(0,0,0,0);
		break;
	case WHITE:
		REF_PTR_RELEASE(TailDiffuse);
		DefaultTailDiffuse.Set(1,1,1,1);
		break;
	case SAME_AS_HEAD_ALPHA_ZERO:
		// if head is all one color, set tail the same way
		if (!Diffuse) {
			REF_PTR_RELEASE(TailDiffuse);
			DefaultTailDiffuse.Set(ColorKeyFrameValues[0].X,ColorKeyFrameValues[0].Y,ColorKeyFrameValues[0].Z,0);
		} else {
			// otherwise allocate and copy tail diffuse
			if (!TailDiffuse) TailDiffuse=NEW_REF(ShareBufferClass<Vector4>,(MaxNum, "ParticleBufferClass::TailDiffuse"));
			for (unsigned int i=0; i<MaxNum; i++) {
				Vector4 elt=Diffuse->Get_Element(i);				
				elt.W=0;
				TailDiffuse->Set_Element(i,elt);
			}
		}
		break;
	case SAME_AS_HEAD:
		// if head is all one color, set tail the same way
		if (!Diffuse) {
			REF_PTR_RELEASE(TailDiffuse);
			DefaultTailDiffuse.Set(ColorKeyFrameValues[0].X,ColorKeyFrameValues[0].Y,ColorKeyFrameValues[0].Z,AlphaKeyFrameValues[0]);
		} else {
			// otherwise allocate and copy tail diffuse
			if (!TailDiffuse) TailDiffuse=NEW_REF(ShareBufferClass<Vector4>,(MaxNum, "ParticleBufferClass::TailDiffuse"));
			VectorProcessorClass::Copy(TailDiffuse->Get_Array(),Diffuse->Get_Array(),MaxNum);
		}
		break;
	default:
		WWASSERT(0);
		break;
	}

	if (!TailDiffuse)
		LineGroup->Set_Tail_Diffuse(DefaultTailDiffuse);
	
	LineGroup->Set_Arrays(Position[pingpong], TailPosition,Diffuse,TailDiffuse, apt, Size, UCoord, active_point_count);
	Update_Bounding_Box();	
	LineGroup->Render(rinfo);	
}

// Scales the size of the individual particles but doesn't affect their
// position (and therefore the size of the particle system as a whole)
void ParticleBufferClass::Scale(float scale)
{
	// Scale all size keyframes, keyframe deltas, random size entries,
	// MaxSize and SizeRandom.
	unsigned int i;
	if (NumSizeKeyFrames) {
		for (i = 0; i < NumSizeKeyFrames; i++) {
			SizeKeyFrameValues[i] *= scale;
			SizeKeyFrameDeltas[i] *= scale;
		}
	} else {
		SizeKeyFrameValues[0] *= scale;		
	}
	if (RandomSizeEntries) {
		for (i = 0; i <= NumRandomSizeEntriesMinus1; i++) {
			RandomSizeEntries[i] *= scale;
		}
	}
	if (LineRenderer) {
		LineRenderer->Scale(scale);
	}
	MaxSize *= scale;
	SizeRandom *= scale;
	Accel *= scale;
}





// The particle buffer never receives a Set_Transform/Position call,
// evem though its bounding volume changes. Since bounding volume
// invalidations ordinarily occur when these functions are called,
// the cached bounding volumes will not be invalidated unless we do
// it elsewhere (such as here). We also need to call the particle
// emitter's Emit() function (done here to avoid order dependence).
void ParticleBufferClass::On_Frame_Update(void)
{
	WWPROFILE("ParticleBufferClass::On_Frame_Update");
	Invalidate_Cached_Bounding_Volumes();
	if (Emitter) {
		Emitter->Emit();
	}
	
	if (Is_Complete()) {
		WWASSERT(Scene);
		Scene->Register(this,SceneClass::RELEASE);
	}
}


void ParticleBufferClass::Notify_Added(SceneClass * scene)
{
	RenderObjClass::Notify_Added(scene);
	scene->Register(this,SceneClass::ON_FRAME_UPDATE);
}


void ParticleBufferClass::Notify_Removed(SceneClass * scene)
{
	scene->Unregister(this,SceneClass::ON_FRAME_UPDATE);
	RenderObjClass::Notify_Removed(scene);
}


void ParticleBufferClass::Get_Obj_Space_Bounding_Sphere(SphereClass & sphere) const
{
	// This ugly cast is done because the alternative is to make everything
	// in the class mutable, which does not seem like a good solution
	// (Update_Bounding_Box can potentially update the particle state)
	((ParticleBufferClass *)this)->Update_Bounding_Box();

	// The particle buffer's transform is always identity, so
	// objspace == worldspace.

	// Wrap sphere outside bounding box:
	sphere.Center = BoundingBox.Center;
	sphere.Radius = BoundingBox.Extent.Length();
}


void ParticleBufferClass::Get_Obj_Space_Bounding_Box(AABoxClass & box) const
{
	// This ugly cast is done because the alternative is to make everything
	// in the class mutable, which does not seem like a good solution
	// (Update_Bounding_Box can potentially update the particle state).
	((ParticleBufferClass *)this)->Update_Bounding_Box();

	// The particle buffer's transform is always identity, so
	// objspace == worldspace.
	box = BoundingBox;
}


void ParticleBufferClass::Prepare_LOD(CameraClass &camera)
{
	if (Is_Not_Hidden_At_All() == false) {
		return;
	}

	// Estimate the screen area of the particle buffer. We shall take the lesser of two
	// metrics: the standard bounding-sphere projection (which for many particle systems may
	// grossly overestimate the actual screen area), and a measurement based on the screen area of
	// individual particles times the maximum number of particles (in the case of densely
	// overlapping particles this metric can also give numbers which are too high, which is why we
	// use the bounding sphere as backup). Note - to find the area of individual particles we
	// treat them as all being the maximum size and being in the center of the bounding sphere).

	Vector3 cam = camera.Get_Position();
	ViewportClass viewport = camera.Get_Viewport();
	Vector2 vpr_min, vpr_max;
	camera.Get_View_Plane(vpr_min, vpr_max);
	float width_factor = viewport.Width() / (vpr_max.X - vpr_min.X);
	float height_factor = viewport.Height() / (vpr_max.Y - vpr_min.Y);

	const SphereClass & sphere = Get_Bounding_Sphere();
	float dist = (sphere.Center - cam).Length();
	float bounding_sphere_projected_radius = 0.0f;
	float particle_projected_radius = 0.0f;
	if (dist) {
		float oo_dist = 1.0f / dist;
		bounding_sphere_projected_radius = sphere.Radius * oo_dist;
		particle_projected_radius = MaxSize * oo_dist;
	}

	float bs_rad_sq = bounding_sphere_projected_radius * bounding_sphere_projected_radius;
	float p_rad_sq = particle_projected_radius * particle_projected_radius * MaxNum;
	float proj_area = WWMATH_PI * MIN(bs_rad_sq, p_rad_sq) * width_factor * height_factor;

	// Filter the area over time so we don't get as many pops in the LOD algorithm
	ProjectedArea = 0.9f * ProjectedArea + 0.1f * proj_area;

	int minlod = Calculate_Cost_Value_Arrays(ProjectedArea, Value, Cost);

	// Ensure lod is no less than minimum allowed
	if (Get_LOD_Level() < minlod) Set_LOD_Level(minlod);

	PredictiveLODOptimizerClass::Add_Object(this);
}

void ParticleBufferClass::Increment_LOD(void)
{
	if (DecimationThreshold > 0) DecimationThreshold--;
}

void ParticleBufferClass::Decrement_LOD(void)
{
	if (DecimationThreshold < LodCount) DecimationThreshold++;
}

float ParticleBufferClass::Get_Cost(void) const
{
	return(Cost[(LodCount - 1) - DecimationThreshold]);
}

float ParticleBufferClass::Get_Value(void) const
{
	return(Value[(LodCount - 1) - DecimationThreshold]);
}

float ParticleBufferClass::Get_Post_Increment_Value(void) const
{
	return(Value[LodCount - DecimationThreshold]);
}

void ParticleBufferClass::Set_LOD_Level(int lod)
{
	lod = Bound(lod, 0, (int)LodCount);
	DecimationThreshold = (LodCount - 1) - lod;
}

int ParticleBufferClass::Get_LOD_Level(void) const
{
	return((LodCount - 1) - DecimationThreshold);
}

int ParticleBufferClass::Get_LOD_Count(void) const
{
	return LodCount;
}

int ParticleBufferClass::Calculate_Cost_Value_Arrays(float screen_area, float *values, float *costs) const
{
	unsigned int lod = 0;

	// Calculate Cost heuristic for each LOD (we currently ignore pixel costs for particle systems)
	// The cost factor is later multiplied by the LOD level. The LOD level is the numerator of the
	// fraction of particles rendered, where 16 is the denominator. For this reason the cost factor
	// is based on a 1/16 (0.0625) of the total.
	float cost_factor=0.0f;
	switch (RenderMode)
	{
	case W3D_EMITTER_RENDER_MODE_TRI_PARTICLES:
		cost_factor = (float)MaxNum * 0.0625f;
		break;
	case W3D_EMITTER_RENDER_MODE_QUAD_PARTICLES:
		cost_factor = (float)MaxNum * 2.0f * 0.0625f;
		break;
	case W3D_EMITTER_RENDER_MODE_LINE:
		cost_factor = (float) (2*MaxNum-1) * 0.0625f;
		break;
	case W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA:
		cost_factor = (float)MaxNum * 4.0f * 0.0625f;
		break;
	case W3D_EMITTER_RENDER_MODE_LINEGRP_PRISM:
		cost_factor = (float)MaxNum * 8.0f * 0.0625f;
		break;
	}	
	for (lod = 0; lod < LodCount; lod++) {
		costs[lod] = cost_factor * (float)lod;
		// If cost is zero set it to a small nonzero amount to avoid divisions by zero.
		costs[lod] = (costs[lod] != 0) ? costs[lod] : 0.000001f;
	}

	// Calculate Value heuristic. First, all LOD levels for which
	// MaxScreenSize is smaller than screen_area have their Value set to
	// AT_MIN_LOD, as well as the first LOD after that (unless there are no
	// other LODs):
	for (lod = 0;  lod < LodCount && LODMaxScreenSizes[lod] < screen_area; lod++) {
		values[lod] = AT_MIN_LOD;
	}

	if (lod >= LodCount) {
		lod = LodCount - 1;
	} else {
		values[lod] = AT_MIN_LOD;
	}

	// Now lod is the lowest allowed - return this value.
	int minlod = lod;

	// Calculate Value heuristic for any remaining LODs based on normalized screen area:
	lod++;
	for (; lod < LodCount; lod++) {
		// Currently the cost happens to be equal to the poly count. We use a floating-
		// point poly count since costs[] contains an approximation to the true polycount which may
		// be less than one in some cases (we want to avoid 0 polycounts except for true null LODs)
		float polycount = costs[lod];
		float benefit_factor = (polycount > WWMATH_EPSILON) ? (1 - (0.5f / (polycount * polycount))) : 0.0f;
		values[lod] = (benefit_factor * screen_area * LodBias) / costs[lod];
	}
	values[LodCount] = AT_MAX_LOD; 	// Post-inc value will flag max LOD.

	return minlod;
}

		
void ParticleBufferClass::Reset_Colors(ParticlePropertyStruct<Vector3> &new_props)
{

	unsigned int i;	// Used in loops
	unsigned int ui_previous_key_time = 0;
	unsigned int ui_current_key_time = 0;

	ColorRandom = new_props.Rand;

	// If the randomizer is effectively zero and there are no keyframes, then we just create a
	// values array with one entry and store the starting value in it (the keyframes and random
	// table will not be used in this case).
	static const float eps_byte = 0.0038f;	// Epsilon value - less than 1/255
	bool color_rand_zero	= (fabs(new_props.Rand.X) < eps_byte && fabs(new_props.Rand.Y) < eps_byte && fabs(new_props.Rand.Z) < eps_byte);
	if (color_rand_zero && new_props.NumKeyFrames == 0) {

		// Release Color, ColorKeyFrameTimes and ColorKeyFrameDeltas if present. Reuse
		// ColorKeyFrameValues if the right size, otherwise release and reallocate.
		if (Color) {
			Color->Release_Ref();
			Color = NULL;
		}
		if (ColorKeyFrameTimes) {
			delete [] ColorKeyFrameTimes;
			ColorKeyFrameTimes = NULL;
		}
		if (ColorKeyFrameDeltas) {
			delete [] ColorKeyFrameDeltas;
			ColorKeyFrameDeltas = NULL;
		}
		if (ColorKeyFrameValues) {
			if (NumColorKeyFrames > 1) {
				delete [] ColorKeyFrameValues;
				ColorKeyFrameValues = W3DNEWARRAY Vector3 [1];
			}
		} else {
			ColorKeyFrameValues = W3DNEWARRAY Vector3 [1];
		}

		NumColorKeyFrames = 0;
		NumRandomColorEntriesMinus1 = 0;
		ColorKeyFrameValues[0] = new_props.Start;

	} else {

		// Create the color array if not present
		if (!Color) {
			Color = NEW_REF( ShareBufferClass<Vector3> , (MaxNum, "ParticleBufferClass::Color") );
		}

		// Check times of color keyframes (each keytime must be larger than the
		// previous one by at least a millisecond, and we stop at the first
		// keytime of MaxAge or larger. (If all keyframes below MaxAge, color is
		// constant during the last segment between last keyframe and MaxAge).
		ui_previous_key_time = 0;
		for (unsigned int ckey = 0; ckey < new_props.NumKeyFrames; ckey++) {
			ui_current_key_time = (unsigned int)(new_props.KeyTimes[ckey] * 1000.0f);
			WWASSERT(ui_current_key_time > ui_previous_key_time);
			if (ui_current_key_time >= MaxAge) break;
			ui_previous_key_time = ui_current_key_time;
		}
		bool color_constant_at_end = (ckey == new_props.NumKeyFrames);

		// Reuse ColorKeyFrameValues, ColorKeyFrameTimes and ColorKeyFrameDeltas if the right size,
		// otherwise release and reallocate.
		unsigned int new_num_color_key_frames = ckey + 1;// Includes start keyframe (keytime == 0).
		if (new_num_color_key_frames != NumColorKeyFrames) {

			if (ColorKeyFrameTimes) {
				delete [] ColorKeyFrameTimes;
				ColorKeyFrameTimes = NULL;
			}
			if (ColorKeyFrameValues) {
				delete [] ColorKeyFrameValues;
				ColorKeyFrameValues = NULL;
			}
			if (ColorKeyFrameDeltas) {
				delete [] ColorKeyFrameDeltas;
				ColorKeyFrameDeltas = NULL;
			}

			NumColorKeyFrames = new_num_color_key_frames;	
			ColorKeyFrameTimes = W3DNEWARRAY unsigned int [NumColorKeyFrames];
			ColorKeyFrameValues = W3DNEWARRAY Vector3 [NumColorKeyFrames];
			ColorKeyFrameDeltas = W3DNEWARRAY Vector3 [NumColorKeyFrames];
		}

		// Set color keyframes (deltas will be set later)
		ColorKeyFrameTimes[0] = 0;
		ColorKeyFrameValues[0] = new_props.Start;
		for (i = 1; i < NumColorKeyFrames; i++) {
			unsigned int im1 = i - 1;
			ColorKeyFrameTimes[i] = (unsigned int)(new_props.KeyTimes[im1] * 1000.0f);
			ColorKeyFrameValues[i] = new_props.Values[im1];
		}

		// Do deltas for all color keyframes except last
		for (i = 0; i < NumColorKeyFrames - 1; i++) {
			ColorKeyFrameDeltas[i]	= (ColorKeyFrameValues[i + 1] - ColorKeyFrameValues[i]) /
				(float)(ColorKeyFrameTimes[i + 1] - ColorKeyFrameTimes[i]);
		}

		// Do delta for last color keyframe (i is NumColorKeyFrames - 1)
		if (color_constant_at_end) {
			ColorKeyFrameDeltas[i].Set(0.0, 0.0, 0.0);
		} else {
			// This is OK because if color_constant_at_end is false, NumColorKeyFrames is equal or
			// smaller than color.NumKeyFrames so color.Values[NumColorKeyFrames - 1] and
			// color.KeyTimes[NumColorKeyFrames - 1] exist.
			ColorKeyFrameDeltas[i]	= (new_props.Values[i] - ColorKeyFrameValues[i]) /
				(new_props.KeyTimes[i] * 1000.0f - (float)ColorKeyFrameTimes[i]);
		}

		// Set up color randomizer table

		if (color_rand_zero) {

			if (RandomColorEntries) {
				// Reuse RandomColorEntries if the right size, otherwise release and reallocate.
				if (NumRandomColorEntriesMinus1 != 0) {
					delete [] RandomColorEntries;
					RandomColorEntries = W3DNEWARRAY Vector3 [1];
				}
			} else {
				RandomColorEntries = W3DNEWARRAY Vector3 [1];
			}

			NumRandomColorEntriesMinus1 = 0;
			RandomColorEntries[0].X = 0.0f;
			RandomColorEntries[0].Y = 0.0f;
			RandomColorEntries[0].Z = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomColorEntries) {
				// Reuse RandomColorEntries if the right size, otherwise release and reallocate.
				if (NumRandomColorEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomColorEntries;
					RandomColorEntries = W3DNEWARRAY Vector3 [default_randomizer_entries];
				}
			} else {
				RandomColorEntries = W3DNEWARRAY Vector3 [default_randomizer_entries];
			}

			NumRandomColorEntriesMinus1 = default_randomizer_entries - 1;

			float rscale = new_props.Rand.X * oo_intmax;
			float gscale = new_props.Rand.Y * oo_intmax;
			float bscale = new_props.Rand.Z * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomColorEntriesMinus1; j++) {
				RandomColorEntries[j] = Vector3(rand_gen * rscale, rand_gen * gscale, rand_gen * bscale);
			}
		}
	}
}


void ParticleBufferClass::Reset_Opacity(ParticlePropertyStruct<float> &new_props)
{
	unsigned int i;	// Used in loops
	unsigned int ui_previous_key_time = 0;
	unsigned int ui_current_key_time = 0;

	OpacityRandom = new_props.Rand;

	// If the randomizer is effectively zero and there are no keyframes, then we just create a
	// values array with one entry and store the starting value in it (the keyframes and random
	// table will not be used in this case).
	static const float eps_byte = 0.0038f;	// Epsilon value - less than 1/255
	bool alpha_rand_zero	= (fabs(new_props.Rand) < eps_byte);
	if (alpha_rand_zero && new_props.NumKeyFrames == 0) {

		// Release Alpha, AlphaKeyFrameTimes and AlphaKeyFrameDeltas if present. Reuse
		// AlphaKeyFrameValues if the right size, otherwise release and reallocate.
		if (Alpha) {
			Alpha->Release_Ref();
			Alpha = NULL;
		}
		if (AlphaKeyFrameTimes) {
			delete [] AlphaKeyFrameTimes;
			AlphaKeyFrameTimes = NULL;
		}
		if (AlphaKeyFrameDeltas) {
			delete [] AlphaKeyFrameDeltas;
			AlphaKeyFrameDeltas = NULL;
		}
		if (AlphaKeyFrameValues) {
			if (NumAlphaKeyFrames > 1) {
				delete [] AlphaKeyFrameValues;
				AlphaKeyFrameValues = W3DNEWARRAY float [1];
			}
		} else {
			AlphaKeyFrameValues = W3DNEWARRAY float [1];
		}

		NumAlphaKeyFrames = 0;
		NumRandomAlphaEntriesMinus1 = 0;
		AlphaKeyFrameValues[0] = new_props.Start;

	} else {

		// Create the alpha array if not present
		if (!Alpha) {
			Alpha = NEW_REF( ShareBufferClass<float> , (MaxNum, "ParticleBufferClass::Alpha") );
		}

		// Check times of opacity keyframes (each keytime must be larger than the
		// previous one by at least a millisecond, and we stop at the first
		// keytime of MaxAge or larger. (If all keyframes below MaxAge, alpha is
		// constant during the last segment between last keyframe and MaxAge).
		ui_previous_key_time = 0;
		for (unsigned int akey = 0; akey < new_props.NumKeyFrames; akey++) {
			ui_current_key_time = (unsigned int)(new_props.KeyTimes[akey] * 1000.0f);
			WWASSERT(ui_current_key_time > ui_previous_key_time);
			if (ui_current_key_time >= MaxAge) break;
			ui_previous_key_time = ui_current_key_time;
		}
		bool alpha_constant_at_end = (akey == new_props.NumKeyFrames);

		// Reuse AlphaKeyFrameValues, AlphaKeyFrameTimes and AlphaKeyFrameDeltas if the right size,
		// otherwise release and reallocate.
		unsigned int new_num_alpha_key_frames = akey + 1;// Includes start keyframe (keytime == 0).
		if (new_num_alpha_key_frames != NumAlphaKeyFrames) {

			if (AlphaKeyFrameTimes) {
				delete [] AlphaKeyFrameTimes;
				AlphaKeyFrameTimes = NULL;
			}
			if (AlphaKeyFrameValues) {
				delete [] AlphaKeyFrameValues;
				AlphaKeyFrameValues = NULL;
			}
			if (AlphaKeyFrameDeltas) {
				delete [] AlphaKeyFrameDeltas;
				AlphaKeyFrameDeltas = NULL;
			}

			NumAlphaKeyFrames = new_num_alpha_key_frames;	
			AlphaKeyFrameTimes = W3DNEWARRAY unsigned int [NumAlphaKeyFrames];
			AlphaKeyFrameValues = W3DNEWARRAY float [NumAlphaKeyFrames];
			AlphaKeyFrameDeltas = W3DNEWARRAY float [NumAlphaKeyFrames];
		}

		// Set alpha keyframes (deltas will be set later)
		AlphaKeyFrameTimes[0] = 0;
		AlphaKeyFrameValues[0] = new_props.Start;
		for (i = 1; i < NumAlphaKeyFrames; i++) {
			unsigned int im1 = i - 1;
			AlphaKeyFrameTimes[i] = (unsigned int)(new_props.KeyTimes[im1] * 1000.0f);
			AlphaKeyFrameValues[i] = new_props.Values[im1];
		}

		// Do deltas for all alpha keyframes except last
		for (i = 0; i < NumAlphaKeyFrames - 1; i++) {
			AlphaKeyFrameDeltas[i]	= (AlphaKeyFrameValues[i + 1] - AlphaKeyFrameValues[i]) /
				(float)(AlphaKeyFrameTimes[i + 1] - AlphaKeyFrameTimes[i]);
		}

		// Do delta for last alpha keyframe (i is NumAlphaKeyFrames - 1)
		if (alpha_constant_at_end) {
			AlphaKeyFrameDeltas[i] = 0.0f;
		} else {
			// This is OK because if alpha_constant_at_end is false, NumAlphaKeyFrames is equal or
			// smaller than opacity.NumKeyFrames so opacity.Values[NumAlphaKeyFrames - 1] and
			// opacity.KeyTimes[NumAlphaKeyFrames - 1] exist.
			AlphaKeyFrameDeltas[i]	= (new_props.Values[i] - AlphaKeyFrameValues[i]) /
				(new_props.KeyTimes[i] * 1000.0f - (float)AlphaKeyFrameTimes[i]);
		}

		// Set up alpha randomizer table

		if (alpha_rand_zero) {

			if (RandomAlphaEntries) {
				// Reuse RandomAlphaEntries if the right size, otherwise release and reallocate.
				if (NumRandomAlphaEntriesMinus1 != 0) {
					delete [] RandomAlphaEntries;
					RandomAlphaEntries = W3DNEWARRAY float [1];
				}
			} else {
				RandomAlphaEntries = W3DNEWARRAY float [1];
			}

			NumRandomAlphaEntriesMinus1 = 0;
			RandomAlphaEntries[0] = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomAlphaEntries) {
				// Reuse RandomAlphaEntries if the right size, otherwise release and reallocate.
				if (NumRandomAlphaEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomAlphaEntries;
					RandomAlphaEntries = W3DNEWARRAY float [default_randomizer_entries];
				}
			} else {
				RandomAlphaEntries = W3DNEWARRAY float [default_randomizer_entries];
			}

			NumRandomAlphaEntriesMinus1 = default_randomizer_entries - 1;

			float ascale = new_props.Rand * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomAlphaEntriesMinus1; j++) {
				RandomAlphaEntries[j] = rand_gen * ascale;
			}
		}
	}
}


void ParticleBufferClass::Reset_Size(ParticlePropertyStruct<float> &new_props)
{

	unsigned int i;	// Used in loops
	unsigned int ui_previous_key_time = 0;
	unsigned int ui_current_key_time = 0;

	SizeRandom = new_props.Rand;

	// If the randomizer is effectively zero and there are no keyframes, then we just create a
	// values array with one entry and store the starting value in it (the keyframes and random
	// table will not be used in this case).
	static const float eps_size = 1.0e-12f;	// Size scale unknown so must use very small epsilon
	bool size_rand_zero	= (fabs(new_props.Rand) < eps_size);
	if (size_rand_zero && new_props.NumKeyFrames == 0) {

		// Release Size, SizeKeyFrameTimes and SizeaKeyFrameDeltas if present. Reuse
		// SizeKeyFrameValues if the right size, otherwise release and reallocate.
		if (Size) {
			Size->Release_Ref();
			Size = NULL;
		}
		if (SizeKeyFrameTimes) {
			delete [] SizeKeyFrameTimes;
			SizeKeyFrameTimes = NULL;
		}
		if (SizeKeyFrameDeltas) {
			delete [] SizeKeyFrameDeltas;
			SizeKeyFrameDeltas = NULL;
		}
		if (SizeKeyFrameValues) {
			if (NumSizeKeyFrames > 1) {
				delete [] SizeKeyFrameValues;
				SizeKeyFrameValues = W3DNEWARRAY float [1];
			}
		} else {
			SizeKeyFrameValues = W3DNEWARRAY float [1];
		}

		NumSizeKeyFrames = 0;
		NumRandomSizeEntriesMinus1 = 0;
		SizeKeyFrameValues[0] = new_props.Start;
		MaxSize = SizeKeyFrameValues[0];
	} else {

		// Create the size array if not present
		if (!Size) {
			Size = NEW_REF( ShareBufferClass<float> , (MaxNum, "ParticleBufferClass::Size") );
		}

		// Check times of size keyframes (each keytime must be larger than the
		// previous one by at least a millisecond, and we stop at the first
		// keytime of MaxAge or larger. (If all keyframes below MaxAge, size is
		// constant during the last segment between last keyframe and MaxAge).
		ui_previous_key_time = 0;
		for (unsigned int skey = 0; skey < new_props.NumKeyFrames; skey++) {
			ui_current_key_time = (unsigned int)(new_props.KeyTimes[skey] * 1000.0f);
			WWASSERT(ui_current_key_time > ui_previous_key_time);
			if (ui_current_key_time >= MaxAge) break;
			ui_previous_key_time = ui_current_key_time;
		}
		bool size_constant_at_end = (skey == new_props.NumKeyFrames);

		// Reuse SizeKeyFrameValues, SizeKeyFrameTimes and SizeKeyFrameDeltas if the right size,
		// otherwise release and reallocate.
		unsigned int new_num_size_key_frames = skey + 1;// Includes start keyframe (keytime == 0).
		if (new_num_size_key_frames != NumSizeKeyFrames) {

			if (SizeKeyFrameTimes) {
				delete [] SizeKeyFrameTimes;
				SizeKeyFrameTimes = NULL;
			}
			if (SizeKeyFrameValues) {
				delete [] SizeKeyFrameValues;
				SizeKeyFrameValues = NULL;
			}
			if (SizeKeyFrameDeltas) {
				delete [] SizeKeyFrameDeltas;
				SizeKeyFrameDeltas = NULL;
			}

			NumSizeKeyFrames = new_num_size_key_frames;	
			SizeKeyFrameTimes = W3DNEWARRAY unsigned int [NumSizeKeyFrames];
			SizeKeyFrameValues = W3DNEWARRAY float [NumSizeKeyFrames];
			SizeKeyFrameDeltas = W3DNEWARRAY float [NumSizeKeyFrames];
		}

		// Set size keyframes (deltas will be set later)
		SizeKeyFrameTimes[0] = 0;
		SizeKeyFrameValues[0] = new_props.Start;
		for (i = 1; i < NumSizeKeyFrames; i++) {
			unsigned int im1 = i - 1;
			SizeKeyFrameTimes[i] = (unsigned int)(new_props.KeyTimes[im1] * 1000.0f);
			SizeKeyFrameValues[i] = new_props.Values[im1];
		}

		// Do deltas for all size keyframes except last
		for (i = 0; i < NumSizeKeyFrames - 1; i++) {
			SizeKeyFrameDeltas[i]	= (SizeKeyFrameValues[i + 1] - SizeKeyFrameValues[i]) /
				(float)(SizeKeyFrameTimes[i + 1] - SizeKeyFrameTimes[i]);
		}

		// Do delta for last size keyframe (i is NumSizeKeyFrames - 1)
		if (size_constant_at_end) {
			SizeKeyFrameDeltas[i] = 0.0f;
		} else {
			// This is OK because if size_constant_at_end is false, NumSizeKeyFrames is equal or
			// smaller than new_props.NumKeyFrames so new_props.Values[NumSizeKeyFrames - 1] and
			// new_props.KeyTimes[NumSizeKeyFrames - 1] exist.
			SizeKeyFrameDeltas[i] = (new_props.Values[i] - SizeKeyFrameValues[i]) /
				(new_props.KeyTimes[i] * 1000.0f - (float)SizeKeyFrameTimes[i]);
		}

		// Find maximum size (for BBox updates)
		MaxSize = SizeKeyFrameValues[0];
		for (i = 1; i < NumSizeKeyFrames; i++) {
			MaxSize = MAX(MaxSize, SizeKeyFrameValues[i]);
		}
		// If last delta is positive, there may be a larger size keyframe:
		float last_size = SizeKeyFrameValues[NumSizeKeyFrames - 1] + SizeKeyFrameDeltas[NumSizeKeyFrames - 1] *
			(float)(MaxAge - SizeKeyFrameTimes[NumSizeKeyFrames - 1]);
		MaxSize = MAX(MaxSize, last_size);
		MaxSize += fabs(new_props.Rand);

		// Set up size randomizer table

		if (size_rand_zero) {

			if (RandomSizeEntries) {
				// Reuse RandomSizeEntries if the right size, otherwise release and reallocate.
				if (NumRandomSizeEntriesMinus1 != 0) {
					delete [] RandomSizeEntries;
					RandomSizeEntries = W3DNEWARRAY float [1];
				}
			} else {
				RandomSizeEntries = W3DNEWARRAY float [1];
			}

			NumRandomSizeEntriesMinus1 = 0;
			RandomSizeEntries[0] = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomSizeEntries) {
				// Reuse RandomSizeEntries if the right size, otherwise release and reallocate.
				if (NumRandomSizeEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomSizeEntries;
					RandomSizeEntries = W3DNEWARRAY float [default_randomizer_entries];
				}
			} else {
				RandomSizeEntries = W3DNEWARRAY float [default_randomizer_entries];
			}

			NumRandomSizeEntriesMinus1 = default_randomizer_entries - 1;

			float sscale = new_props.Rand * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomSizeEntriesMinus1; j++) {
				RandomSizeEntries[j] = rand_gen * sscale;
			}
		}
	}
}


void ParticleBufferClass::Reset_Rotations(ParticlePropertyStruct<float> &new_props, float orient_rnd)
{

	unsigned int i;	// Used in loops	
   float oo_intmax = 1.0f / (float)INT_MAX;
	unsigned int ui_previous_key_time = 0;
	unsigned int ui_current_key_time = 0;

	/*
	** NOTE: Input rotations are in rotations per second. These will be converted to rotations per millisecond.
	*/

	RotationRandom = new_props.Rand * 0.001f;
	InitialOrientationRandom = orient_rnd;

	// If both randomizers are effectively zero and rotation is constant zero, then all arrays are NULL.
	static const float eps_orientation = 2.77777778e-4f;	// Epsilon is equivalent to 0.1 degree
	static const float eps_rotation = 2.77777778e-4f;	// Epsilon is equivalent to one rotation per hour (in rotations / second)
	bool orientation_rand_zero = fabs(orient_rnd) < eps_orientation;
	bool rotation_rand_zero = fabs(new_props.Rand) < eps_rotation;
	if (orientation_rand_zero && rotation_rand_zero && new_props.NumKeyFrames == 0 && fabs(new_props.Start) < eps_rotation) {

		// Release Arrays, 
		REF_PTR_RELEASE(Orientation);
		if (RotationKeyFrameTimes) {
			delete [] RotationKeyFrameTimes;
			RotationKeyFrameTimes = NULL;
		}
		if (HalfRotationKeyFrameDeltas) {
			delete [] HalfRotationKeyFrameDeltas;
			HalfRotationKeyFrameDeltas = NULL;
		}
		if (RotationKeyFrameValues) {
			delete [] RotationKeyFrameValues;
			RotationKeyFrameValues = NULL;
		}
		if (OrientationKeyFrameValues) {
			delete [] OrientationKeyFrameValues;
			OrientationKeyFrameValues = NULL;
		}

		NumRotationKeyFrames = 0;
		NumRandomRotationEntriesMinus1 = 0;
		NumRandomOrientationEntriesMinus1 = 0;
	
	} else {

		// Create the array if not present
		if (!Orientation) {
			Orientation = NEW_REF( ShareBufferClass<uint8> , (MaxNum, "ParticleBufferClass::Orientation") );
		}

		// Check times of the keyframes (each keytime must be larger than the
		// previous one by at least a millisecond, and we stop at the first
		// keytime of MaxAge or larger. (If all keyframes below MaxAge, the value is
		// constant during the last segment between last keyframe and MaxAge).
		ui_previous_key_time = 0;
		for (unsigned int key = 0; key < new_props.NumKeyFrames; key++) {
			ui_current_key_time = (unsigned int)(new_props.KeyTimes[key] * 1000.0f);
			WWASSERT(ui_current_key_time > ui_previous_key_time);
			if (ui_current_key_time >= MaxAge) break;
			ui_previous_key_time = ui_current_key_time;
		}
		bool rotation_constant_at_end = (key == new_props.NumKeyFrames);

		// Reuse RotationKeyFrameValues, RotationKeyFrameTimes, RotationKeyFrameDeltas and
		// OrientationKeyFrameValues if the right size, otherwise release and reallocate.
		unsigned int new_num_key_frames = key + 1;// Includes start keyframe (keytime == 0).
		if (new_num_key_frames != NumRotationKeyFrames) {

			if (RotationKeyFrameTimes) {
				delete [] RotationKeyFrameTimes;
				RotationKeyFrameTimes = NULL;
			}
			if (RotationKeyFrameValues) {
				delete [] RotationKeyFrameValues;
				RotationKeyFrameValues = NULL;
			}
			if (HalfRotationKeyFrameDeltas) {
				delete [] HalfRotationKeyFrameDeltas;
				HalfRotationKeyFrameDeltas = NULL;
			}
			if (OrientationKeyFrameValues) {
				delete [] OrientationKeyFrameValues;
				OrientationKeyFrameValues = NULL;
			}

			NumRotationKeyFrames = new_num_key_frames;
			RotationKeyFrameTimes = W3DNEWARRAY unsigned int [NumRotationKeyFrames];
			RotationKeyFrameValues = W3DNEWARRAY float [NumRotationKeyFrames];
			HalfRotationKeyFrameDeltas = W3DNEWARRAY float [NumRotationKeyFrames];
			OrientationKeyFrameValues = W3DNEWARRAY float [NumRotationKeyFrames];
		}

		// Set rotation keyframes (deltas will be set later)
		RotationKeyFrameTimes[0] = 0;
		RotationKeyFrameValues[0] = new_props.Start * 0.001f;
		for (i = 1; i < NumRotationKeyFrames; i++) {
			unsigned int im1 = i - 1;
			RotationKeyFrameTimes[i] = (unsigned int)(new_props.KeyTimes[im1] * 1000.0f);
			RotationKeyFrameValues[i] = new_props.Values[im1] * 0.001f;
		}

		// Do deltas for all rotation keyframes except last
		for (i = 0; i < NumRotationKeyFrames - 1; i++) {
			HalfRotationKeyFrameDeltas[i]	= 0.5f * ( (RotationKeyFrameValues[i + 1] - RotationKeyFrameValues[i]) /
				(float)(RotationKeyFrameTimes[i + 1] - RotationKeyFrameTimes[i]) );
		}

		// Do delta for last rotation keyframe (i is NumRotationKeyFrames - 1)
		if (rotation_constant_at_end) {
			HalfRotationKeyFrameDeltas[i] = 0.0f;
		} else {
			// This is OK because if rotation_constant_at_end is false, NumRotationKeyFrames is equal or
			// smaller than new_props.NumKeyFrames so new_props.Values[NumRotationKeyFrames - 1] and
			// new_props.KeyTimes[NumRotationKeyFrames - 1] exist.
			HalfRotationKeyFrameDeltas[i] = 0.5f * (new_props.Values[i] * 0.001f - RotationKeyFrameValues[i]) /
				(new_props.KeyTimes[i] * 1000.0f - (float)RotationKeyFrameTimes[i]);
		}

		// Calculate orientation keyframes by integrating the rotation at each keyframe
		OrientationKeyFrameValues[0] = 0.0f;
		for (i = 1; i < NumRotationKeyFrames; i++) {
			float delta_t = (float)(RotationKeyFrameTimes[i] - RotationKeyFrameTimes[i - 1]);
			OrientationKeyFrameValues[i] = OrientationKeyFrameValues[i - 1] + delta_t *
				(RotationKeyFrameValues[i - 1] + HalfRotationKeyFrameDeltas[i - 1] * delta_t);
		}

		// Set up rotation randomizer table
		if (rotation_rand_zero) {

			if (RandomRotationEntries) {
				// Reuse RandomRotationEntries if the right size, otherwise release and reallocate.
				if (NumRandomRotationEntriesMinus1 != 0) {
					delete [] RandomRotationEntries;
					RandomRotationEntries = W3DNEWARRAY float [1];
				}
			} else {
				RandomRotationEntries = W3DNEWARRAY float [1];
			}

			NumRandomRotationEntriesMinus1 = 0;
			RandomRotationEntries[0] = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomRotationEntries) {
				// Reuse RandomRotationEntries if the right size, otherwise release and reallocate.
				if (NumRandomRotationEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomRotationEntries;
					RandomRotationEntries = W3DNEWARRAY float [default_randomizer_entries];
				}
			} else {
				RandomRotationEntries = W3DNEWARRAY float [default_randomizer_entries];
			}

			NumRandomRotationEntriesMinus1 = default_randomizer_entries - 1;

			float scale = new_props.Rand * 0.001f * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomRotationEntriesMinus1; j++) {
				RandomRotationEntries[j] = rand_gen * scale;
			}
		}

		// Set up orientation randomizer table
		if (orientation_rand_zero) {

			if (RandomOrientationEntries) {
				// Reuse RandomOrientationEntries if the right size, otherwise release and reallocate.
				if (NumRandomOrientationEntriesMinus1 != 0) {
					delete [] RandomOrientationEntries;
					RandomOrientationEntries = W3DNEWARRAY float [1];
				}
			} else {
				RandomOrientationEntries = W3DNEWARRAY float [1];
			}

			NumRandomOrientationEntriesMinus1 = 0;
			RandomOrientationEntries[0] = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomOrientationEntries) {
				// Reuse RandomOrientationEntries if the right size, otherwise release and reallocate.
				if (NumRandomOrientationEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomOrientationEntries;
					RandomOrientationEntries = W3DNEWARRAY float [default_randomizer_entries];
				}
			} else {
				RandomOrientationEntries = W3DNEWARRAY float [default_randomizer_entries];
			}

			NumRandomOrientationEntriesMinus1 = default_randomizer_entries - 1;

			float scale = orient_rnd * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomOrientationEntriesMinus1; j++) {
				RandomOrientationEntries[j] = rand_gen * scale;
			}
		}
	}
}



void ParticleBufferClass::Reset_Frames(ParticlePropertyStruct<float> &new_props)
{

	unsigned int i;	// Used in loops	
   float oo_intmax = 1.0f / (float)INT_MAX;
	unsigned int ui_previous_key_time = 0;
	unsigned int ui_current_key_time = 0;

	FrameRandom = new_props.Rand;

	// If the randomizer is effectively zero and there are no keyframes, then we just create a
	// values array with one entry and store the starting value in it (the keyframes and random
	// table will not be used in this case).
	static const float eps_frame = 0.1f;	// Epsilon is equivalent to 0.1 frame
	bool frame_rand_zero	= (fabs(new_props.Rand) < eps_frame);
	if (frame_rand_zero && new_props.NumKeyFrames == 0) {

		// Release Arrays, Reuse KeyFrameValues if the right size, 
		// otherwise release and reallocate.
		REF_PTR_RELEASE(Frame);
		REF_PTR_RELEASE(UCoord);
		if (FrameKeyFrameTimes) {
			delete [] FrameKeyFrameTimes;
			FrameKeyFrameTimes = NULL;
		}
		if (FrameKeyFrameDeltas) {
			delete [] FrameKeyFrameDeltas;
			FrameKeyFrameDeltas = NULL;
		}
		if (FrameKeyFrameValues) {
			if (NumFrameKeyFrames > 1) {
				delete [] FrameKeyFrameValues;
				FrameKeyFrameValues = W3DNEWARRAY float [1];
			}
		} else {
			FrameKeyFrameValues = W3DNEWARRAY float [1];
		}

		NumFrameKeyFrames = 0;
		NumRandomFrameEntriesMinus1 = 0;
		FrameKeyFrameValues[0] = new_props.Start;
	
	} else {

		// Create the array if not present
		if ((RenderMode==W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA) ||
			(RenderMode==W3D_EMITTER_RENDER_MODE_LINEGRP_PRISM)) {
			if (!UCoord) {
				UCoord = NEW_REF( ShareBufferClass<float>, (MaxNum, "ParticleBufferClass::UCoord") );
			}
		} else {
			if (!Frame) {
				Frame = NEW_REF( ShareBufferClass<uint8> , (MaxNum, "ParticleBufferClass::Frame") );
			}
		}

		// Check times of the keyframes (each keytime must be larger than the
		// previous one by at least a millisecond, and we stop at the first
		// keytime of MaxAge or larger. (If all keyframes below MaxAge, the value is
		// constant during the last segment between last keyframe and MaxAge).
		ui_previous_key_time = 0;
		for (unsigned int key = 0; key < new_props.NumKeyFrames; key++) {
			ui_current_key_time = (unsigned int)(new_props.KeyTimes[key] * 1000.0f);
			WWASSERT(ui_current_key_time > ui_previous_key_time);
			if (ui_current_key_time >= MaxAge) break;
			ui_previous_key_time = ui_current_key_time;
		}
		bool frame_constant_at_end = (key == new_props.NumKeyFrames);

		// Reuse FrameKeyFrameValues, FrameKeyFrameTimes and FrameKeyFrameDeltas if the right size,
		// otherwise release and reallocate.
		unsigned int new_num_key_frames = key + 1;// Includes start keyframe (keytime == 0).
		if (new_num_key_frames != NumFrameKeyFrames) {

			if (FrameKeyFrameTimes) {
				delete [] FrameKeyFrameTimes;
				FrameKeyFrameTimes = NULL;
			}
			if (FrameKeyFrameValues) {
				delete [] FrameKeyFrameValues;
				FrameKeyFrameValues = NULL;
			}
			if (FrameKeyFrameDeltas) {
				delete [] FrameKeyFrameDeltas;
				FrameKeyFrameDeltas = NULL;
			}

			NumFrameKeyFrames = new_num_key_frames;	
			FrameKeyFrameTimes = W3DNEWARRAY unsigned int [NumFrameKeyFrames];
			FrameKeyFrameValues = W3DNEWARRAY float [NumFrameKeyFrames];
			FrameKeyFrameDeltas = W3DNEWARRAY float [NumFrameKeyFrames];
		}

		// Set keyframes (deltas will be set later)
		FrameKeyFrameTimes[0] = 0;
		FrameKeyFrameValues[0] = new_props.Start;
		for (i = 1; i < NumFrameKeyFrames; i++) {
			unsigned int im1 = i - 1;
			FrameKeyFrameTimes[i] = (unsigned int)(new_props.KeyTimes[im1] * 1000.0f);
			FrameKeyFrameValues[i] = new_props.Values[im1];
		}

		// Do deltas for all frame keyframes except last
		for (i = 0; i < NumFrameKeyFrames - 1; i++) {
			FrameKeyFrameDeltas[i]	= (FrameKeyFrameValues[i + 1] - FrameKeyFrameValues[i]) /
				(float)(FrameKeyFrameTimes[i + 1] - FrameKeyFrameTimes[i]);
		}

		// Do delta for last frame keyframe (i is NumFrameKeyFrames - 1)
		if (frame_constant_at_end) {
			FrameKeyFrameDeltas[i] = 0.0f;
		} else {
			// This is OK because if frame_constant_at_end is false, NumFrameKeyFrames is equal or
			// smaller than new_props.NumKeyFrames so new_props.Values[NumFrameKeyFrames - 1] and
			// new_props.KeyTimes[NumFrameKeyFrames - 1] exist.
			FrameKeyFrameDeltas[i] = (new_props.Values[i] - FrameKeyFrameValues[i]) /
				(new_props.KeyTimes[i] * 1000.0f - (float)FrameKeyFrameTimes[i]);
		}

		// Set up frame randomizer table
		if (frame_rand_zero) {

			if (RandomFrameEntries) {
				// Reuse RandomFrameEntries if the right size, otherwise release and reallocate.
				if (NumRandomFrameEntriesMinus1 != 0) {
					delete [] RandomFrameEntries;
					RandomFrameEntries = W3DNEWARRAY float [1];
				}
			} else {
				RandomFrameEntries = W3DNEWARRAY float [1];
			}

			NumRandomFrameEntriesMinus1 = 0;
			RandomFrameEntries[0] = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomFrameEntries) {
				// Reuse RandomFrameEntries if the right size, otherwise release and reallocate.
				if (NumRandomFrameEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomFrameEntries;
					RandomFrameEntries = W3DNEWARRAY float [default_randomizer_entries];
				}
			} else {
				RandomFrameEntries = W3DNEWARRAY float [default_randomizer_entries];
			}

			NumRandomFrameEntriesMinus1 = default_randomizer_entries - 1;

			float scale = new_props.Rand * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomFrameEntriesMinus1; j++) {
				RandomFrameEntries[j] = rand_gen * scale;
			}
		}
	}
}


void ParticleBufferClass::Reset_Blur_Times(ParticlePropertyStruct<float> &new_blur_times)
{

	unsigned int i;	// Used in loops	
   float oo_intmax = 1.0f / (float)INT_MAX;
	unsigned int ui_previous_key_time = 0;
	unsigned int ui_current_key_time = 0;

	BlurTimeRandom = new_blur_times.Rand;

	// If the randomizer is effectively zero and there are no keyframes, then we just create a
	// values array with one entry and store the starting value in it (the keyframes and random
	// table will not be used in this case).
	static const float eps_blur = 1e-5f;	// Epsilon is equivalent to 1e-5 units per second
	bool blurtime_rand_zero	= (fabs(new_blur_times.Rand) < eps_blur);
	if (blurtime_rand_zero && new_blur_times.NumKeyFrames == 0) {

		// Release Arrays, Reuse KeyFrameValues if the right size, 
		// otherwise release and reallocate.		
		if (BlurTimeKeyFrameTimes) {
			delete [] BlurTimeKeyFrameTimes;
			BlurTimeKeyFrameTimes = NULL;
		}
		if (BlurTimeKeyFrameDeltas) {
			delete [] BlurTimeKeyFrameDeltas;
			BlurTimeKeyFrameDeltas = NULL;
		}
		if (BlurTimeKeyFrameValues) {
			if (NumBlurTimeKeyFrames > 1) {
				delete [] BlurTimeKeyFrameValues;
				BlurTimeKeyFrameValues = new float [1];
			}
		} else {
			BlurTimeKeyFrameValues = new float [1];
		}

		NumBlurTimeKeyFrames = 0;
		NumRandomBlurTimeEntriesMinus1 = 0;
		BlurTimeKeyFrameValues[0] = new_blur_times.Start;
	
	} else {

		// Check times of the keyframes (each keytime must be larger than the
		// previous one by at least a millisecond, and we stop at the first
		// keytime of MaxAge or larger. (If all keyframes below MaxAge, the value is
		// constant during the last segment between last keyframe and MaxAge).
		ui_previous_key_time = 0;
		for (unsigned int key = 0; key < new_blur_times.NumKeyFrames; key++) {
			ui_current_key_time = (unsigned int)(new_blur_times.KeyTimes[key] * 1000.0f);
			WWASSERT(ui_current_key_time > ui_previous_key_time);
			if (ui_current_key_time >= MaxAge) break;
			ui_previous_key_time = ui_current_key_time;
		}
		bool blurtime_constant_at_end = (key == new_blur_times.NumKeyFrames);

		// Reuse BlurTimeKeyFrameValues, BlurTimeKeyFrameTimes and BlurTimeKeyFrameDeltas if the right size,
		// otherwise release and reallocate.
		unsigned int new_num_key_frames = key + 1;// Includes start keyframe (keytime == 0).
		if (new_num_key_frames != NumBlurTimeKeyFrames) {

			if (BlurTimeKeyFrameTimes) {
				delete [] BlurTimeKeyFrameTimes;
				BlurTimeKeyFrameTimes = NULL;
			}
			if (BlurTimeKeyFrameValues) {
				delete [] BlurTimeKeyFrameValues;
				BlurTimeKeyFrameValues = NULL;
			}
			if (BlurTimeKeyFrameDeltas) {
				delete [] BlurTimeKeyFrameDeltas;
				BlurTimeKeyFrameDeltas = NULL;
			}

			NumBlurTimeKeyFrames = new_num_key_frames;	
			BlurTimeKeyFrameTimes = new unsigned int [NumBlurTimeKeyFrames];
			BlurTimeKeyFrameValues = new float [NumBlurTimeKeyFrames];
			BlurTimeKeyFrameDeltas = new float [NumBlurTimeKeyFrames];
		}

		// Set keyframes (deltas will be set later)
		BlurTimeKeyFrameTimes[0] = 0;
		BlurTimeKeyFrameValues[0] = new_blur_times.Start;
		for (i = 1; i < NumBlurTimeKeyFrames; i++) {
			unsigned int im1 = i - 1;
			BlurTimeKeyFrameTimes[i] = (unsigned int)(new_blur_times.KeyTimes[im1] * 1000.0f);
			BlurTimeKeyFrameValues[i] = new_blur_times.Values[im1];
		}

		// Do deltas for all frame keyframes except last
		for (i = 0; i < NumBlurTimeKeyFrames - 1; i++) {
			BlurTimeKeyFrameDeltas[i]	= (BlurTimeKeyFrameValues[i + 1] - BlurTimeKeyFrameValues[i]) /
				(float)(BlurTimeKeyFrameTimes[i + 1] - BlurTimeKeyFrameTimes[i]);
		}

		// Do delta for last frame keyframe (i is NumBlurTimeKeyFrames - 1)
		if (blurtime_constant_at_end) {
			BlurTimeKeyFrameDeltas[i] = 0.0f;
		} else {
			// This is OK because if frame_constant_at_end is false, NumBlurTimeKeyFrames is equal or
			// smaller than new_props.NumKeyFrames so new_props.Values[NumBlurTimeKeyFrames - 1] and
			// new_props.KeyTimes[NumBlurTimeKeyFrames - 1] exist.
			BlurTimeKeyFrameDeltas[i] = (new_blur_times.Values[i] - BlurTimeKeyFrameValues[i]) /
				(new_blur_times.KeyTimes[i] * 1000.0f - (float)BlurTimeKeyFrameTimes[i]);
		}

		// Set up frame randomizer table
		if (blurtime_rand_zero) {

			if (RandomBlurTimeEntries) {
				// Reuse RandomBlurTimeEntries if the right size, otherwise release and reallocate.
				if (NumRandomBlurTimeEntriesMinus1 != 0) {
					delete [] RandomBlurTimeEntries;
					RandomBlurTimeEntries = new float [1];
				}
			} else {
				RandomBlurTimeEntries = new float [1];
			}

			NumRandomBlurTimeEntriesMinus1 = 0;
			RandomBlurTimeEntries[0] = 0.0f;
		} else {

			// Default size of randomizer tables (tables for non-zero randomizers will be this size)
			unsigned int pot_num = Find_POT(MaxNum);
			unsigned int default_randomizer_entries = MIN(pot_num, MAX_RANDOM_ENTRIES);

			if (RandomBlurTimeEntries) {
				// Reuse RandomBlurTimeEntries if the right size, otherwise release and reallocate.
				if (NumRandomBlurTimeEntriesMinus1 != (default_randomizer_entries - 1)) {
					delete [] RandomBlurTimeEntries;
					RandomBlurTimeEntries = new float [default_randomizer_entries];
				}
			} else {
				RandomBlurTimeEntries = new float [default_randomizer_entries];
			}

			NumRandomBlurTimeEntriesMinus1 = default_randomizer_entries - 1;

			float scale = new_blur_times.Rand * oo_intmax;
			for (unsigned int j = 0; j <= NumRandomBlurTimeEntriesMinus1; j++) {
				RandomBlurTimeEntries[j] = rand_gen * scale;
			}
		}
	}
}


// This informs the buffer that the emitter is dead, so it can release
// its pointer to it and be removed itself after all its particles dies
// out.
void ParticleBufferClass::Emitter_Is_Dead(void)
{
	IsEmitterDead = true;
	// We do not have a ref for the emitter (see DTor for detailed explanation)
	// Emitter->Release_Ref();
	Emitter = NULL;
}


// This set's the buffer's current emitter - this should usually be
// called only by the emitter's copy constructor after it clones a
// buffer.
void ParticleBufferClass::Set_Emitter(ParticleEmitterClass *emitter)
{
	if (Emitter) {
		// We do not have a ref for the emitter (see DTor for detailed explanation)
		// Emitter->Release_Ref();
		Emitter = NULL;
	}

	Emitter = emitter;

	if (Emitter) {
		// We do not add a ref for the emitter (see DTor for detailed explanation)
		// Emitter->Add_Ref();
	}
}

		
NewParticleStruct * ParticleBufferClass::Add_Uninitialized_New_Particle(void)
{
	// Note that this function does not initialize the new particle - it
	// returns its address to a different function which performs the actual
	// initialization.

	// Push new particle on new particle queue. If it overflows, just adjust
	// queue to remove oldest member (which is the one which was overwritten).
	NewParticleStruct *ptr = &(NewParticleQueue[NewParticleQueueEnd]);
   if (++NewParticleQueueEnd == MaxNum) NewParticleQueueEnd = 0;
	if (++NewParticleQueueCount == (signed)(MaxNum + 1)) {
		// Overflow - advance queue start:
		if (++NewParticleQueueStart == MaxNum) NewParticleQueueStart = 0;
		NewParticleQueueCount--;
	}

	return ptr;
}


void ParticleBufferClass::Update_Cached_Bounding_Volumes(void) const
{
	// This ugly cast is done because the alternative is to make everything
	// in the class mutable, which does not seem like a good solution
	// (Update_Bounding_Box can potentially update the particle state).
	((ParticleBufferClass *)this)->Update_Bounding_Box();

	// Update cached bounding box and sphere according to the bounding box:
	CachedBoundingSphere.Init(BoundingBox.Center, BoundingBox.Extent.Length());
	CachedBoundingBox = BoundingBox;
	Validate_Cached_Bounding_Volumes();
}


void ParticleBufferClass::Update_Kinematic_Particle_State(void)
{
	// Note: elapsed may be very large indeed the first time the object is
	// updated, but this doesn't matter, since it is actually only used in
	// Update_Non_New_Particles(), which is never called on the first update.
	unsigned int elapsed = WW3D::Get_Sync_Time() - LastUpdateTime;
	if (elapsed == 0U) return;

	// Get new particles from the input buffer and write them into the circular
	// particle buffer, possibly overwriting older particles. Update each
	// according to its age.
	Get_New_Particles();

	// Kill all remaining particles which will pass their max age this update.
	Kill_Old_Particles();

	// Update all living, non-new particles by a uniform time interval.
	if (NonNewNum > 0) Update_Non_New_Particles(elapsed);

	// Mark all new particles as non-new.
	End = NewEnd;
	NonNewNum += NewNum;
	NewNum = 0;

	LastUpdateTime = WW3D::Get_Sync_Time();

	BoundingBoxDirty = true;
}


void ParticleBufferClass::Update_Visual_Particle_State(void)
{
	// NOTE: The visual state (color/alpha/size) is "stateless" in that each time it is calculated
	// without referring to what it was before. This is important for when we optimize the particle
	// systems/pointgroups in the future to chunk triangles into reusable small buffers.

	// If all visual state is constant do nothing.
	// Linegroup modes have a visual state that always have to be updated though
	bool is_linegroup=( (RenderMode==W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA) ||
							  (RenderMode==W3D_EMITTER_RENDER_MODE_LINEGRP_PRISM));
	if (!Color && !Alpha && !Size && !Orientation && !Frame && !UCoord && !is_linegroup) return;

	// In the general case, a range in a circular buffer can be composed of up
	// to two subranges. Find the Start - End subranges.
	unsigned int sub1_end;		// End of subrange 1.
	unsigned int sub2_start;	// Start of subrange 2.
	if ((Start < End) || ((Start == End) && NonNewNum ==0)) {
		sub1_end = End;
		sub2_start = End;
	} else {
		sub1_end = MaxNum;
		sub2_start = 0;
	}

	unsigned int current_time = WW3D::Get_Sync_Time();

	// The following back-to-back pair of "for" loops traverses the circular
	// buffer subranges in proper order.
	unsigned int ckey = NumColorKeyFrames - 1;
	unsigned int akey = NumAlphaKeyFrames - 1;
	unsigned int skey = NumSizeKeyFrames - 1;
	unsigned int rkey = NumRotationKeyFrames - 1;
	unsigned int fkey = NumFrameKeyFrames - 1;
	unsigned int bkey = NumBlurTimeKeyFrames -1;

	unsigned int part;
	Vector3 *color = Color ? Color->Get_Array(): NULL;
	float *alpha = Alpha ? Alpha->Get_Array(): NULL;
	float *size = Size ? Size->Get_Array(): NULL;
	uint8 *orientation = Orientation ? Orientation->Get_Array(): NULL;
	uint8 *frame = Frame ? Frame->Get_Array(): NULL;
	float *ucoord = UCoord ? UCoord->Get_Array() : NULL;
	Vector3 *tailposition = TailPosition ? TailPosition->Get_Array() : NULL;

	Vector3 *position=NULL;

	if (PingPongPosition) {
		int pingpong = WW3D::Get_Frame_Count() & 0x1;
		position = Position[pingpong]->Get_Array();		
	} else {
		position = Position[0]->Get_Array();
	}


	for (part = Start; part < sub1_end; part++) {

		unsigned int part_age = current_time - TimeStamp[part];

		// Ensure the current color keyframe is correct, and calculate color state
		if (color) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < ColorKeyFrameTimes[ckey]; ckey--);

			color[part] = ColorKeyFrameValues[ckey] +
							ColorKeyFrameDeltas[ckey] * (float)(part_age - ColorKeyFrameTimes[ckey]) +
							RandomColorEntries[part & NumRandomColorEntriesMinus1];
		}

		// Ensure the current alpha keyframe is correct, and calculate alpha state
		if (alpha) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < AlphaKeyFrameTimes[akey]; akey--);

			alpha[part] = AlphaKeyFrameValues[akey] +
				AlphaKeyFrameDeltas[akey] * (float)(part_age - AlphaKeyFrameTimes[akey]) +
				RandomAlphaEntries[part & NumRandomAlphaEntriesMinus1];
		}

		// Ensure the current size keyframe is correct, and calculate size state
		if (size) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < SizeKeyFrameTimes[skey]; skey--);

			size[part] = SizeKeyFrameValues[skey] +
				SizeKeyFrameDeltas[skey] * (float)(part_age - SizeKeyFrameTimes[skey]) +
				RandomSizeEntries[part & NumRandomSizeEntriesMinus1];

			// Size (unlike color and alpha) isn't clamped in the engine, so we need to clamp
			// negative values to zero here:
			size[part] = (size[part] >= 0.0f) ? size[part] : 0.0f;
		}

		// Ensure the current rotation keyframe is correct, and calculate orientation state
		if (orientation) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < RotationKeyFrameTimes[rkey]; rkey--);

			float f_delta_t = (float)(part_age - RotationKeyFrameTimes[rkey]);
			float tmp_orient = OrientationKeyFrameValues[rkey] +
				(RotationKeyFrameValues[rkey] + HalfRotationKeyFrameDeltas[rkey] * f_delta_t) * f_delta_t +
				RandomRotationEntries[part & NumRandomRotationEntriesMinus1] * (float)part_age +
				RandomOrientationEntries[part & NumRandomOrientationEntriesMinus1];
			
			orientation[part] = (uint)(((int)(tmp_orient * 256.0f)) & 0xFF);
		}

		// Ensure the current frame keyframe is correct, and calculate frame state
		if (frame) {
			// Frame and ucoord are mutually exclusive
			WWASSERT(ucoord==NULL);
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < FrameKeyFrameTimes[fkey]; fkey--);

			float tmp_frame = FrameKeyFrameValues[fkey] +
				FrameKeyFrameDeltas[fkey] * (float)(part_age - FrameKeyFrameTimes[fkey]) +
				RandomFrameEntries[part & NumRandomFrameEntriesMinus1];
			
			frame[part] = (uint)(((int)(tmp_frame)) & 0xFF);
		}

		// Ensure the current frame keyframe is correct, and calculate frame state
		// ucoord is the same as frame but in float
		if (ucoord) {
			// Frame and ucoord are mutually exclusive
			WWASSERT(frame==NULL);
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < FrameKeyFrameTimes[fkey]; fkey--);

			ucoord[part] = FrameKeyFrameValues[fkey] +
				FrameKeyFrameDeltas[fkey] * (float)(part_age - FrameKeyFrameTimes[fkey]) +
				RandomFrameEntries[part & NumRandomFrameEntriesMinus1];		
		}

		if (tailposition) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			float blur_time = BlurTimeKeyFrameValues[0];
			if (BlurTimeKeyFrameTimes) {
				for (; part_age < BlurTimeKeyFrameTimes[bkey]; bkey--);
				blur_time = BlurTimeKeyFrameValues[bkey] +
					BlurTimeKeyFrameDeltas[bkey] * (float)(part_age - BlurTimeKeyFrameTimes[bkey]) +
					RandomBlurTimeEntries[part & NumRandomBlurTimeEntriesMinus1];
			}
			tailposition[part]=position[part]-Velocity[part]*blur_time*1000;
		}		
	}

	for (part = sub2_start; part < End; part++) {

		unsigned int part_age = current_time - TimeStamp[part];

		// Ensure the current color keyframe is correct, and calculate color state
		if (color) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < ColorKeyFrameTimes[ckey]; ckey--);

			color[part] = 
					ColorKeyFrameValues[ckey] +
					ColorKeyFrameDeltas[ckey] * (float)(part_age - ColorKeyFrameTimes[ckey]) +
					RandomColorEntries[part & NumRandomColorEntriesMinus1];
		}

		// Ensure the current alpha keyframe is correct, and calculate alpha state
		if (alpha) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < AlphaKeyFrameTimes[akey]; akey--);

			alpha[part] = AlphaKeyFrameValues[akey] +
				AlphaKeyFrameDeltas[akey] * (float)(part_age - AlphaKeyFrameTimes[akey]) +
				RandomAlphaEntries[part & NumRandomAlphaEntriesMinus1];
		}

		// Ensure the current size keyframe is correct, and calculate size state
		if (size) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < SizeKeyFrameTimes[skey]; skey--);

			size[part] = SizeKeyFrameValues[skey] +
				SizeKeyFrameDeltas[skey] * (float)(part_age - SizeKeyFrameTimes[skey]) +
				RandomSizeEntries[part & NumRandomSizeEntriesMinus1];

			// Size (unlike color) isn't clamped in the engine, so we need to
			// clamp negative values to zero here:
			size[part] = (size[part] >= 0.0f) ? size[part] : 0.0f;
		}

		// Ensure the current rotation keyframe is correct, and calculate orientation state
		if (orientation) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < RotationKeyFrameTimes[rkey]; rkey--);

			float f_delta_t = (float)(part_age - RotationKeyFrameTimes[rkey]);
			float tmp_orient = OrientationKeyFrameValues[rkey] +
				(RotationKeyFrameValues[rkey] + HalfRotationKeyFrameDeltas[rkey] * f_delta_t) * f_delta_t +
				RandomRotationEntries[part & NumRandomRotationEntriesMinus1] * (float)part_age +
				RandomOrientationEntries[part & NumRandomOrientationEntriesMinus1];
			
			orientation[part] = (uint)(((int)(tmp_orient * 256.0f)) & 0xFF);
		}

		// Ensure the current frame keyframe is correct, and calculate frame state
		if (frame) {
			// Frame and ucoord are mutually exclusive
			WWASSERT(ucoord==NULL);
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < FrameKeyFrameTimes[fkey]; fkey--);

			float tmp_frame = FrameKeyFrameValues[fkey] +
				FrameKeyFrameDeltas[fkey] * (float)(part_age - FrameKeyFrameTimes[fkey]) +
				RandomFrameEntries[part & NumRandomFrameEntriesMinus1];
			
			frame[part] = (uint)(((int)(tmp_frame)) & 0xFF);
		}

		// Ensure the current frame keyframe is correct, and calculate frame state
		// ucoord is the same as frame but in float
		if (ucoord) {
			// Frame and ucoord are mutually exclusive
			WWASSERT(frame==NULL);
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			for (; part_age < FrameKeyFrameTimes[fkey]; fkey--);

			ucoord[part] = FrameKeyFrameValues[fkey] +
				FrameKeyFrameDeltas[fkey] * (float)(part_age - FrameKeyFrameTimes[fkey]) +
				RandomFrameEntries[part & NumRandomFrameEntriesMinus1];			
		}

		if (tailposition) {
			// We go from older to younger particles, so we go backwards from the last keyframe until
			// age >= keytime. This loop must terminate because the 0th keytime is 0.
			float blur_time = BlurTimeKeyFrameValues[0];
			if (BlurTimeKeyFrameTimes) {
				for (; part_age < BlurTimeKeyFrameTimes[bkey]; bkey--);
				blur_time = BlurTimeKeyFrameValues[bkey] +
					BlurTimeKeyFrameDeltas[bkey] * (float)(part_age - BlurTimeKeyFrameTimes[bkey]) +
					RandomBlurTimeEntries[part & NumRandomBlurTimeEntriesMinus1];
			}
			tailposition[part]=position[part]-Velocity[part]*blur_time*1000;
		}
	}
}


void ParticleBufferClass::Update_Bounding_Box(void)
{
	// Ensure all particle positions are updated. If bounding box still not
	// dirty, return.
	Update_Kinematic_Particle_State();
	if (!BoundingBoxDirty) return;

	// If there are no particles, generate a dummy bounding box:
	if (NonNewNum == 0U) {
		BoundingBox.Init(Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0));
		BoundingBoxDirty = false;
		return;
	}

	// Find min/max coord values for all points:
	int pingpong = 0;
	if (PingPongPosition) {
		pingpong = WW3D::Get_Frame_Count() & 0x1;
	}
	Vector3 *position = Position[pingpong]->Get_Array();
	Vector3 max_coords = position[Start];
	Vector3 min_coords = position[Start];

	// In the general case, a range in a circular buffer can be composed of up
	// to two subranges. Find the Start - End subranges.
	unsigned int sub1_end;		// End of subrange 1.
	unsigned int sub2_start;	// Start of subrange 2.
	unsigned int i;				// Loop index.
	if ((Start < End) || ((Start == End) && NonNewNum ==0)) {
		sub1_end = End;
		sub2_start = End;
	} else {
		sub1_end = MaxNum;
		sub2_start = 0;
	}
   for (i = Start; i < sub1_end; i++) {
		max_coords.X = max_coords.X >= position[i].X ? max_coords.X : position[i].X;
		max_coords.Y = max_coords.Y >= position[i].Y ? max_coords.Y : position[i].Y;
		max_coords.Z = max_coords.Z >= position[i].Z ? max_coords.Z : position[i].Z;
		min_coords.X = min_coords.X <= position[i].X ? min_coords.X : position[i].X;
		min_coords.Y = min_coords.Y <= position[i].Y ? min_coords.Y : position[i].Y;
		min_coords.Z = min_coords.Z <= position[i].Z ? min_coords.Z : position[i].Z;
	}
   for (i = sub2_start; i < End; i++) {
		max_coords.X = max_coords.X >= position[i].X ? max_coords.X : position[i].X;
		max_coords.Y = max_coords.Y >= position[i].Y ? max_coords.Y : position[i].Y;
		max_coords.Z = max_coords.Z >= position[i].Z ? max_coords.Z : position[i].Z;
		min_coords.X = min_coords.X <= position[i].X ? min_coords.X : position[i].X;
		min_coords.Y = min_coords.Y <= position[i].Y ? min_coords.Y : position[i].Y;
		min_coords.Z = min_coords.Z <= position[i].Z ? min_coords.Z : position[i].Z;
	}
	
	// Extend by maximum possible particle size:
	Vector3 size(MaxSize, MaxSize, MaxSize);
	max_coords += size;
	min_coords -= size;

	// Update bounding box:
	BoundingBox.Init(MinMaxAABoxClass(min_coords,max_coords));
	BoundingBoxDirty = false;
}


// NOTE: typically, the number of new particles created in a frame is small
// relative to the total number of particles, so this is not the most
// performance-critical particle function. New particles are copied from the
// new particle vector into the circular buffer, overwriting any older
// particles (including possibly other new particles) so that the newest
// particles are preserved. The particles are initialized to their state at
// the end of the current interval.
void ParticleBufferClass::Get_New_Particles(void)
{
	unsigned int current_time = WW3D::Get_Sync_Time();

	// position is the current frame position, prev_pos is the previous frames position (only if
	// we have enabled pingpong position buffers)
	Vector3 *position;
	Vector3 *prev_pos;
	if (PingPongPosition) {
		int pingpong = WW3D::Get_Frame_Count() & 0x1;
		position = Position[pingpong]->Get_Array();
		prev_pos = Position[pingpong ^ 0x1]->Get_Array();
	} else {
		position = Position[0]->Get_Array();
		prev_pos = NULL;
	}

	unsigned char * ids = GroupID->Get_Array();
	for (; NewParticleQueueCount;) {

		// Get particle off new particle queue:
		NewParticleStruct &new_particle = NewParticleQueue[NewParticleQueueStart];
		if (++NewParticleQueueStart == MaxNum) NewParticleQueueStart = 0U;
		NewParticleQueueCount--;

		// Get particle birth time stamp, calculate age. If not under maxage
		// skip this particle.
		TimeStamp[NewEnd] = new_particle.TimeStamp;
		unsigned int age = current_time - TimeStamp[NewEnd];
		if (age >= MaxAge) continue;
		float fp_age = (float)age;

		// Apply velocity and acceleration if present. Otherwise, just apply
		// velocity.
		if (HasAccel) {
			position[NewEnd] = new_particle.Position +
									(new_particle.Velocity + 0.5f * Accel * fp_age) * fp_age;
			
			Velocity[NewEnd] = new_particle.Velocity + (Accel * fp_age);
		} else {
			position[NewEnd] =new_particle.Position +
										(new_particle.Velocity * fp_age);
			Velocity[NewEnd] = new_particle.Velocity;
		}

		// If pingpong enabled, store starting position in prev_pos[].
		if (PingPongPosition) {
			prev_pos[NewEnd] = new_particle.Position;
		}

		// upate the group id
		ids[NewEnd] = new_particle.GroupID;

		// Advance the 'end of new particles' index.
		NewEnd++;
      if (NewEnd == MaxNum) NewEnd = 0;

      // Update the new particles count.
      NewNum++;

		// If we have just overflowed the total buffer, advance Start.
      if ((NewNum + NonNewNum) == (signed)(MaxNum + 1)) {
         Start++;
         if (Start == MaxNum) Start = 0;
         NonNewNum--;

         // If this underflows the 'non-new' buffer, advance End.
         if (NonNewNum == -1) {
            End++;
            if (End == MaxNum) End = 0;
            NonNewNum = 0;
            NewNum--;
         }
      }
	}	
}


void ParticleBufferClass::Kill_Old_Particles(void)
{
	// Scan from Start and find the first particle which has an age less than
	// MaxAge - set Start to that position.

	// In the general case, a range in a circular buffer can be composed of up
	// to two subranges. Find the Start - End subranges.
	unsigned int sub1_end;		// End of subrange 1.
	unsigned int sub2_start;	// Start of subrange 2.
	unsigned int i;				// Loop index.
	if ((Start < End) || ((Start == End) && NonNewNum ==0)) {
		sub1_end = End;
		sub2_start = End;
	} else {
		sub1_end = MaxNum;
		sub2_start = 0;
	}

   unsigned int current_time = WW3D::Get_Sync_Time();

	// Stop when the current particle is young enough to be alive.
	bool broke = false;
   for (i = Start; i < sub1_end; i++) {
      if ((current_time - TimeStamp[i]) < MaxAge) {
         broke = true;
         break;
      }
      NonNewNum--;
	}
   if (!broke) {
	   for (i = sub2_start; i < End; i++) {
		   if ((current_time - TimeStamp[i]) < MaxAge) break;
         NonNewNum--;
	   }
   }

	Start = i;

   // NOTE: we do not scan the new particles, because they have been already
   // preculled to be under MaxAge.
}


void ParticleBufferClass::Update_Non_New_Particles(unsigned int elapsed)
{
	// In the general case, a range in a circular buffer can be composed of up
	// to two subranges. Find the Start - End subranges.
	unsigned int sub1_end;		// End of subrange 1.
	unsigned int sub2_start;	// Start of subrange 2.
	unsigned int i;				// Loop index.
	if ((Start < End) || ((Start == End) && NonNewNum ==0)) {
		sub1_end = End;
		sub2_start = End;
	} else {
		sub1_end = MaxNum;
		sub2_start = 0;
	}

	float fp_elapsed_time = (float)elapsed;

	// Update position and velocity for all particles.
	if (PingPongPosition) {

		int pingpong = WW3D::Get_Frame_Count() & 0x1;
		Vector3 *position = Position[pingpong]->Get_Array();
		Vector3 *prev_pos = Position[pingpong ^ 0x1]->Get_Array();

		if (HasAccel) {
			Vector3 delta_v = Accel * fp_elapsed_time;
			Vector3 accel_p = Accel * (0.5f * fp_elapsed_time * fp_elapsed_time);
			for (i = Start; i < sub1_end; i++) {
				position[i] = prev_pos[i] + Velocity[i] * fp_elapsed_time + accel_p;
				Velocity[i] += delta_v;
			}
			for (i = sub2_start; i < End; i++) {
				position[i] = prev_pos[i] + Velocity[i] * fp_elapsed_time + accel_p;
				Velocity[i] += delta_v;
			}
		} else {
			for (i = Start; i < sub1_end; i++) {
				position[i] += Velocity[i] * fp_elapsed_time;
			}
			for (i = sub2_start; i < End; i++) {
				position[i] += Velocity[i] * fp_elapsed_time;
			}
		}
	} else {

		Vector3 *position = Position[0]->Get_Array();

		if (HasAccel) {
			Vector3 delta_v = Accel * fp_elapsed_time;
			Vector3 accel_p = Accel * (0.5f * fp_elapsed_time * fp_elapsed_time);
			for (i = Start; i < sub1_end; i++) {
				position[i] += Velocity[i] * fp_elapsed_time + accel_p;
				Velocity[i] += delta_v;
			}
			for (i = sub2_start; i < End; i++) {
				position[i] += Velocity[i] * fp_elapsed_time + accel_p;
				Velocity[i] += delta_v;
			}
		} else {
			for (i = Start; i < sub1_end; i++) {
				position[i] += Velocity[i] * fp_elapsed_time;
			}
			for (i = sub2_start; i < End; i++) {
				position[i] += Velocity[i] * fp_elapsed_time;
			}
		}
	}
}

void ParticleBufferClass::Get_Color_Key_Frames (ParticlePropertyStruct<Vector3> &colors) const
{
	int real_keyframe_count = (NumColorKeyFrames > 0) ? (NumColorKeyFrames - 1) : 0;
	bool create_last_keyframe = false;

	//
	//	Determine if there is a keyframe at the very end of the particle's lifetime
	//
	if ((ColorKeyFrameDeltas != NULL) &&
		 ((ColorKeyFrameDeltas[NumColorKeyFrames - 1].X != 0) ||
		  (ColorKeyFrameDeltas[NumColorKeyFrames - 1].Y != 0) ||
		  (ColorKeyFrameDeltas[NumColorKeyFrames - 1].Z != 0))) {
		real_keyframe_count ++;
		create_last_keyframe = true;
	}

	colors.Start = ColorKeyFrameValues[0];
	colors.Rand = ColorRandom;
	colors.NumKeyFrames = real_keyframe_count;
	colors.KeyTimes = NULL;
	colors.Values = NULL;

	//
	//	If we have more than just the start color, build
	// an array of key times and color vatues
	//
	if (real_keyframe_count > 0) {
		colors.KeyTimes	= W3DNEWARRAY float[real_keyframe_count];
		colors.Values		= W3DNEWARRAY Vector3[real_keyframe_count];

		//
		//	Copy the keytimes and color values
		//
		unsigned int index;
		for (index = 1; index < NumColorKeyFrames; index ++) {
			colors.KeyTimes[index - 1]	= ((float)ColorKeyFrameTimes[index]) / 1000;
			colors.Values[index - 1]	= ColorKeyFrameValues[index];
		}

		//
		//	Add a keyframe at the very end of the timeline if necessary
		//
		if (create_last_keyframe) {			
			colors.KeyTimes[index - 1] = ((float)MaxAge / 1000);

			//
			// Determine what the value of the last keyframe should be
			//
			Vector3 start_color = ColorKeyFrameValues[index - 1];
			Vector3 &delta = ColorKeyFrameDeltas[NumColorKeyFrames - 1];
			float time_delta = MaxAge - ColorKeyFrameTimes[index - 1];
			colors.Values[index - 1] = start_color + (delta * time_delta);
		}
	}

	return ;
}

void ParticleBufferClass::Get_Opacity_Key_Frames (ParticlePropertyStruct<float> &opacities) const
{
	int real_keyframe_count = (NumAlphaKeyFrames > 0) ? (NumAlphaKeyFrames - 1) : 0;
	bool create_last_keyframe = false;

	//
	//	Determine if there is a keyframe at the very end of the particle's lifetime
	//
	if ((AlphaKeyFrameDeltas != NULL) &&
		 (AlphaKeyFrameDeltas[NumAlphaKeyFrames - 1] != 0)) {
		real_keyframe_count ++;
		create_last_keyframe = true;
	}

	opacities.Start = AlphaKeyFrameValues[0];
	opacities.Rand = OpacityRandom;
	opacities.NumKeyFrames = real_keyframe_count;
	opacities.KeyTimes = NULL;
	opacities.Values = NULL;

	//
	//	If we have more than just the start opacity, build
	// an array of key times and opacity values
	//
	if (real_keyframe_count > 0) {
		opacities.KeyTimes	= W3DNEWARRAY float[real_keyframe_count];
		opacities.Values		= W3DNEWARRAY float[real_keyframe_count];

		//
		//	Copy the keytimes and opacity values
		//
		unsigned int index;
		for (index = 1; index < NumAlphaKeyFrames; index ++) {
			opacities.KeyTimes[index - 1]	= ((float)AlphaKeyFrameTimes[index]) / 1000;
			opacities.Values[index - 1]	= AlphaKeyFrameValues[index];
		}

		//
		//	Add a keyframe at the very end of the timeline if necessary
		//
		if (create_last_keyframe) {			
			opacities.KeyTimes[index - 1] = ((float)MaxAge / 1000);

			//
			// Determine what the value of the last keyframe should be
			//
			float start_alpha = AlphaKeyFrameValues[index - 1];
			float &delta = AlphaKeyFrameDeltas[NumAlphaKeyFrames - 1];
			float time_delta = MaxAge - AlphaKeyFrameTimes[index - 1];
			opacities.Values[index - 1] = start_alpha + (delta * time_delta);
		}
	}

	return ;
}


void ParticleBufferClass::Get_Size_Key_Frames (ParticlePropertyStruct<float> &sizes) const
{
	int real_keyframe_count = (NumSizeKeyFrames > 0) ? (NumSizeKeyFrames - 1) : 0;
	bool create_last_keyframe = false;

	//
	//	Determine if there is a keyframe at the very end of the particle's lifetime
	//
	if ((SizeKeyFrameDeltas != NULL) &&
		 (SizeKeyFrameDeltas[NumSizeKeyFrames - 1] != 0)) {
		real_keyframe_count ++;
		create_last_keyframe = true;
	}

	sizes.Start				= SizeKeyFrameValues[0];
	sizes.Rand				= SizeRandom;
	sizes.NumKeyFrames	= real_keyframe_count;
	sizes.KeyTimes			= NULL;
	sizes.Values			= NULL;

	//
	//	If we have more than just the start opacity, build
	// an array of key times and opacity values
	//
	if (real_keyframe_count > 0) {
		sizes.KeyTimes	= W3DNEWARRAY float[real_keyframe_count];
		sizes.Values	= W3DNEWARRAY float[real_keyframe_count];

		//
		//	Copy the keytimes and size values
		//
		unsigned int index;
		for (index = 1; index < NumSizeKeyFrames; index ++) {
			sizes.KeyTimes[index - 1]	= ((float)SizeKeyFrameTimes[index]) / 1000;
			sizes.Values[index - 1]	= SizeKeyFrameValues[index];
		}

		//
		//	Add a keyframe at the very end of the timeline if necessary
		//
		if (create_last_keyframe) {			
			sizes.KeyTimes[index - 1] = ((float)MaxAge / 1000);

			//
			// Determine what the value of the last keyframe should be
			//
			float start_size			= SizeKeyFrameValues[index - 1];
			float &delta				= SizeKeyFrameDeltas[NumSizeKeyFrames - 1];
			float time_delta			= MaxAge - SizeKeyFrameTimes[index - 1];
			sizes.Values[index - 1]	= start_size + (delta * time_delta);
		}
	}

	return ;
}


void ParticleBufferClass::Get_Rotation_Key_Frames (ParticlePropertyStruct<float> &rotations) const
{
	int real_keyframe_count = (NumRotationKeyFrames > 0) ? (NumRotationKeyFrames - 1) : 0;
	bool create_last_keyframe = false;

	/*
	** NOTE: Rotations are stored internally in rotations per millisecond. These will be converted to rotations per second.
	*/

	//
	//	Determine if there is a keyframe at the very end of the particle's lifetime
	//
	if ((HalfRotationKeyFrameDeltas != NULL) &&
		 (HalfRotationKeyFrameDeltas[NumRotationKeyFrames - 1] != 0)) {
		real_keyframe_count ++;
		create_last_keyframe = true;
	}

	// Convert the rotation values from rotations per millisecond to rotations per second.
	rotations.Start			= RotationKeyFrameValues ? RotationKeyFrameValues[0] * 1000.0f : 0;
	rotations.Rand				= RotationRandom * 1000.0f;
	rotations.NumKeyFrames	= real_keyframe_count;
	rotations.KeyTimes		= NULL;
	rotations.Values			= NULL;

	//
	//	If we have more than just the start rotation, build
	// an array of key times and rotation values
	//
	if (real_keyframe_count > 0) {
		rotations.KeyTimes	= W3DNEWARRAY float[real_keyframe_count];
		rotations.Values		= W3DNEWARRAY float[real_keyframe_count];

		//
		//	Copy the keytimes and rotation values
		//
		unsigned int index;
		for (index = 1; index < NumRotationKeyFrames; index ++) {
			rotations.KeyTimes[index - 1]	= ((float)RotationKeyFrameTimes[index]) / 1000;
			rotations.Values[index - 1]	= RotationKeyFrameValues[index] * 1000.0f;
		}

		//
		//	Add a keyframe at the very end of the timeline if necessary
		//
		if (create_last_keyframe) {			
			rotations.KeyTimes[index - 1] = ((float)MaxAge / 1000);

			//
			// Determine what the value of the last keyframe should be
			//
			float start_rotation				= RotationKeyFrameValues[index - 1];
			float delta							= 2.0f * HalfRotationKeyFrameDeltas[NumRotationKeyFrames - 1];
			float time_delta					= MaxAge - RotationKeyFrameTimes[index - 1];
			rotations.Values[index - 1]	= (start_rotation + (delta * time_delta)) * 1000.0f;
		}
	}

	return ;
}


void ParticleBufferClass::Get_Frame_Key_Frames (ParticlePropertyStruct<float> &frames) const
{
	int real_keyframe_count = (NumFrameKeyFrames > 0) ? (NumFrameKeyFrames - 1) : 0;
	bool create_last_keyframe = false;

	//
	//	Determine if there is a keyframe at the very end of the particle's lifetime
	//
	if ((FrameKeyFrameDeltas != NULL) &&
		 (FrameKeyFrameDeltas[NumFrameKeyFrames - 1] != 0)) {
		real_keyframe_count ++;
		create_last_keyframe = true;
	}

	frames.Start			= FrameKeyFrameValues[0];
	frames.Rand				= FrameRandom;
	frames.NumKeyFrames	= real_keyframe_count;
	frames.KeyTimes		= NULL;
	frames.Values			= NULL;

	//
	//	If we have more than just the start rotation, build
	// an array of key times and frame values
	//
	if (real_keyframe_count > 0) {
		frames.KeyTimes	= W3DNEWARRAY float[real_keyframe_count];
		frames.Values		= W3DNEWARRAY float[real_keyframe_count];

		//
		//	Copy the keytimes and frame values
		//
		unsigned int index;
		for (index = 1; index < NumFrameKeyFrames; index ++) {
			frames.KeyTimes[index - 1]	= ((float)FrameKeyFrameTimes[index]) / 1000;
			frames.Values[index - 1]	= FrameKeyFrameValues[index];
		}

		//
		//	Add a keyframe at the very end of the timeline if necessary
		//
		if (create_last_keyframe) {			
			frames.KeyTimes[index - 1] = ((float)MaxAge / 1000);

			//
			// Determine what the value of the last keyframe should be
			//
			float start_frame			= FrameKeyFrameValues[index - 1];
			float &delta				= FrameKeyFrameDeltas[NumFrameKeyFrames - 1];
			float time_delta			= MaxAge - FrameKeyFrameTimes[index - 1];
			frames.Values[index - 1]	= start_frame + (delta * time_delta);
		}
	}

	return ;
}

void ParticleBufferClass::Get_Blur_Time_Key_Frames (ParticlePropertyStruct<float> &blurtimes) const
{
	int real_keyframe_count = (NumBlurTimeKeyFrames > 0) ? (NumBlurTimeKeyFrames - 1) : 0;
	bool create_last_keyframe = false;

	//
	//	Determine if there is a keyframe at the very end of the particle's lifetime
	//
	if ((BlurTimeKeyFrameDeltas != NULL) &&
		 (BlurTimeKeyFrameDeltas[NumBlurTimeKeyFrames - 1] != 0)) {
		real_keyframe_count ++;
		create_last_keyframe = true;
	}

	blurtimes.Start			= BlurTimeKeyFrameValues[0];
	blurtimes.Rand				= BlurTimeRandom;
	blurtimes.NumKeyFrames	= real_keyframe_count;
	blurtimes.KeyTimes		= NULL;
	blurtimes.Values			= NULL;

	//
	//	If we have more than just the start rotation, build
	// an array of key times and blur time values
	//
	if (real_keyframe_count > 0) {
		blurtimes.KeyTimes	= new float[real_keyframe_count];
		blurtimes.Values		= new float[real_keyframe_count];

		//
		//	Copy the keytimes and frame values
		//
		unsigned int index;
		for (index = 1; index < NumBlurTimeKeyFrames; index ++) {
			blurtimes.KeyTimes[index - 1]	= ((float)BlurTimeKeyFrameTimes[index]) / 1000;
			blurtimes.Values[index - 1]	= BlurTimeKeyFrameValues[index];
		}

		//
		//	Add a keyframe at the very end of the timeline if necessary
		//
		if (create_last_keyframe) {			
			blurtimes.KeyTimes[index - 1] = ((float)MaxAge / 1000);

			//
			// Determine what the value of the last keyframe should be
			//
			float start_blurtime		= BlurTimeKeyFrameValues[index - 1];
			float &delta				= BlurTimeKeyFrameDeltas[NumBlurTimeKeyFrames - 1];
			float time_delta			= MaxAge - BlurTimeKeyFrameTimes[index - 1];
			blurtimes.Values[index - 1]	= start_blurtime + (delta * time_delta);
		}
	}

	return ;
}

void ParticleBufferClass::Set_LOD_Max_Screen_Size(int lod_level,float max_screen_size)
{
	if ((lod_level <0) || (lod_level > 17)) {
		return;
	}
	LODMaxScreenSizes[lod_level] = max_screen_size;
}


float ParticleBufferClass::Get_LOD_Max_Screen_Size(int lod_level)
{
	if ((lod_level <0) || (lod_level > 17)) {
		return NO_MAX_SCREEN_SIZE;
	}
	return LODMaxScreenSizes[lod_level];
}


int ParticleBufferClass::Get_Line_Texture_Mapping_Mode(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Get_Texture_Mapping_Mode();
	} 
	return SegLineRendererClass::UNIFORM_WIDTH_TEXTURE_MAP;
}

int ParticleBufferClass::Is_Merge_Intersections(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Is_Merge_Intersections();
	} 
	return false;
}

int ParticleBufferClass::Is_Freeze_Random(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Is_Freeze_Random();
	} 
	return false;
}

int ParticleBufferClass::Is_Sorting_Disabled(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Is_Sorting_Disabled();
	} 
	return false;
}

int ParticleBufferClass::Are_End_Caps_Enabled(void)	const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Are_End_Caps_Enabled();
	} 
	return false;
}

int ParticleBufferClass::Get_Subdivision_Level(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Get_Current_Subdivision_Level();
	} 
	return 0;
}

float ParticleBufferClass::Get_Noise_Amplitude(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Get_Noise_Amplitude();
	} 
	return 0.0f;
}

float ParticleBufferClass::Get_Merge_Abort_Factor(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Get_Merge_Abort_Factor();
	} 
	return 0.0f;
}

float ParticleBufferClass::Get_Texture_Tile_Factor(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Get_Texture_Tile_Factor();
	} 
	return 1.0f;
}

Vector2 ParticleBufferClass::Get_UV_Offset_Rate(void) const
{
	if (LineRenderer != NULL) {
		return LineRenderer->Get_UV_Offset_Rate();
	} 
	return Vector2(0.0f,0.0f);
}

ParticleBufferClass::TailDiffuseTypeEnum ParticleBufferClass::Determine_Tail_Diffuse()
{
	// if there is a texture, the assumption is that the artist
	// is controlling the fadeoff ramp using the texture
	// thus, the ARGB of the tail should be the same as the head
	TextureClass *tex=Get_Texture();
	if (tex)
	{
		REF_PTR_RELEASE(tex);
		return SAME_AS_HEAD;
	}

	ShaderClass shader=Get_Shader();

	
	//Multiplicative		RGB is white (A is don't care)
	//Additive				RGB is Black (A is don't care)
	//Screen					RGB is Black (A is don't care)
	//Alpha					Same RGB as head but A is 0
	//Alpha test blend	Same ARGB as head but A is 0	
	//Alpha test			Same ARGB as head
	//Opaque					Same ARGB as head	

	// Multiplicative
	if (shader.Get_Dst_Blend_Func()==ShaderClass::DSTBLEND_SRC_COLOR) return WHITE;
	// Additive
	else if ((shader.Get_Src_Blend_Func()==ShaderClass::SRCBLEND_ONE) && (shader.Get_Dst_Blend_Func()==ShaderClass::DSTBLEND_ONE)) return BLACK;
	// Screen
	else if ((shader.Get_Src_Blend_Func()==ShaderClass::SRCBLEND_ONE) && (shader.Get_Dst_Blend_Func()==ShaderClass::DSTBLEND_ONE_MINUS_SRC_COLOR)) return BLACK;
	// Alpha
	else if ((shader.Get_Src_Blend_Func()==ShaderClass::SRCBLEND_SRC_ALPHA) && (shader.Get_Dst_Blend_Func()==ShaderClass::DSTBLEND_ONE_MINUS_SRC_ALPHA)) return SAME_AS_HEAD_ALPHA_ZERO;
	// Alpha test
	else if (shader.Get_Alpha_Test()==ShaderClass::ALPHATEST_ENABLE) return SAME_AS_HEAD_ALPHA_ZERO;

	return SAME_AS_HEAD;
}

TextureClass * ParticleBufferClass::Get_Texture (void) const
{
	if (PointGroup) return PointGroup->Get_Texture();
	else if (LineGroup) return LineGroup->Get_Texture();
	else if (LineRenderer) return LineRenderer->Get_Texture();
	return NULL;
}

void ParticleBufferClass::Set_Texture (TextureClass *tex)
{
	if (PointGroup) PointGroup->Set_Texture(tex);
	else if (LineGroup) LineGroup->Set_Texture(tex);
	else if (LineRenderer) LineRenderer->Set_Texture(tex);
}

ShaderClass ParticleBufferClass::Get_Shader (void) const
{
	if (PointGroup) return PointGroup->Get_Shader();
	else if (LineGroup) return LineGroup->Get_Shader();
	else if (LineRenderer) return LineRenderer->Get_Shader();

	WWASSERT(0);
	return ShaderClass::_PresetOpaqueShader;
}