tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/part_buf.cpp

3446 lines
No EOL
113 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(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:: /VSS_Sync/ww3d2/part_buf.cpp $*
* *
* $Author:: Vss_sync $*
* *
* $Modtime:: 10/26/01 2:56p $*
* *
* $Revision:: 21 $*
* *
*-------------------------------------------------------------------------*
* 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,
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),
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),
PingPongPosition(pingpong),
Velocity(NULL),
TimeStamp(NULL),
Emitter(emitter),
DecimationThreshold(0U),
ProjectedArea(0.0f),
DefaultTailDiffuse(0,0,0,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 = new 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 = new 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 = new 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 = new 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=new 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) );
// 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=new 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) );
// 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) );
if (PingPongPosition) {
Position[1] = NEW_REF( ShareBufferClass<Vector3> , (MaxNum) );
}
APT = NEW_REF( ShareBufferClass<unsigned int> , (MaxNum) );
Velocity = new Vector3[MaxNum];
TimeStamp = new 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(const ParticleBufferClass & src) :
RenderObjClass(src),
NewParticleQueue(NULL),
NewParticleQueueStart(0U),
NewParticleQueueEnd(0U),
NewParticleQueueCount(0U),
RenderMode(src.RenderMode),
FrameMode(src.FrameMode),
MaxAge(src.MaxAge),
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),
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) );
// Copy color keyframes
ColorKeyFrameTimes = new unsigned int [NumColorKeyFrames];
ColorKeyFrameValues = new Vector3 [NumColorKeyFrames];
ColorKeyFrameDeltas = new 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 = new Vector3 [NumRandomColorEntriesMinus1 + 1];
for (unsigned int j = 0; j <= NumRandomColorEntriesMinus1; j++) {
RandomColorEntries[j] = src.RandomColorEntries[j];
}
}
} else {
ColorKeyFrameValues = new Vector3 [1];
ColorKeyFrameValues[0] = src.ColorKeyFrameValues[0];
}
NumRandomAlphaEntriesMinus1 = src.NumRandomAlphaEntriesMinus1;
if (src.Alpha) {
// Create alpha array
Alpha = NEW_REF( ShareBufferClass<float> , (MaxNum) );
// Copy alpha keyframes
AlphaKeyFrameTimes = new unsigned int [NumAlphaKeyFrames];
AlphaKeyFrameValues = new float [NumAlphaKeyFrames];
AlphaKeyFrameDeltas = new 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 = new float [NumRandomAlphaEntriesMinus1 + 1];
for (unsigned int j = 0; j <= NumRandomAlphaEntriesMinus1; j++) {
RandomAlphaEntries[j] = src.RandomAlphaEntries[j];
}
}
} else {
AlphaKeyFrameValues = new float [1];
AlphaKeyFrameValues[0] = src.AlphaKeyFrameValues[0];
}
NumRandomSizeEntriesMinus1 = src.NumRandomSizeEntriesMinus1;
if (src.Size) {
// Create size array
Size = NEW_REF( ShareBufferClass<float> , (MaxNum) );
// Copy size keyframes
SizeKeyFrameTimes = new unsigned int [NumSizeKeyFrames];
SizeKeyFrameValues = new float [NumSizeKeyFrames];
SizeKeyFrameDeltas = new 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 = new float [NumRandomSizeEntriesMinus1 + 1];
for (unsigned int j = 0; j <= NumRandomSizeEntriesMinus1; j++) {
RandomSizeEntries[j] = src.RandomSizeEntries[j];
}
}
} else {
SizeKeyFrameValues = new 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) );
// Copy rotation / orientation keyframes
RotationKeyFrameTimes = new unsigned int [NumRotationKeyFrames];
RotationKeyFrameValues = new float [NumRotationKeyFrames];
HalfRotationKeyFrameDeltas = new float [NumRotationKeyFrames];
OrientationKeyFrameValues = new 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 = new 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 = new 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) );
} else {
UCoord = NEW_REF( ShareBufferClass<float>, (MaxNum) );
}
// Copy frame keyframes
FrameKeyFrameTimes = new unsigned int [NumFrameKeyFrames];
FrameKeyFrameValues = new float [NumFrameKeyFrames];
FrameKeyFrameDeltas = new 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 = new float [NumRandomFrameEntriesMinus1 + 1];
for (unsigned int j = 0; j <= NumRandomFrameEntriesMinus1; j++) {
RandomFrameEntries[j] = src.RandomFrameEntries[j];
}
}
} else {
FrameKeyFrameValues = new 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 = new 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 = new 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 = new 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 = new SegLineRendererClass(*src.LineRenderer);
}
break;
case W3D_EMITTER_RENDER_MODE_LINEGRP_TETRA:
{
WWASSERT(src.LineGroup);
LineGroup=new 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) );
// 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=new 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) );
// 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) );
if (PingPongPosition) {
Position[1] = NEW_REF( ShareBufferClass<Vector3> , (MaxNum) );
}
APT = NEW_REF( ShareBufferClass<unsigned int> , (MaxNum) );
Velocity = new Vector3[MaxNum];
TimeStamp = new 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);
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 new 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) );
}
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)
{
// 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;
Vector3 * positions = Position[pingpong]->Get_Array();
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);
for (i = Start; i < sub1_end; i++) {
if (PermutationArray[i & 0xF] >= DecimationThreshold) {
tmp_points.Add(positions[i]);
}
}
for (i = sub2_start; i < End; i++) {
if (PermutationArray[i & 0xF] >= DecimationThreshold) {
tmp_points.Add(positions[i]);
}
}
// If we got any points, render them
if (tmp_points.Count() > 0) {
SphereClass bounding_sphere;
Get_Obj_Space_Bounding_Sphere(bounding_sphere);
LineRenderer->Render(rinfo,
Transform,
tmp_points.Count(),
&(tmp_points[0]),
bounding_sphere);
}
}
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));
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));
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;
for (i = 0; i < NumSizeKeyFrames; i++) {
SizeKeyFrameValues[i] *= scale;
SizeKeyFrameDeltas[i] *= scale;
}
if (RandomSizeEntries) {
for (i = 0; i <= NumRandomSizeEntriesMinus1; i++) {
RandomSizeEntries[i] *= scale;
}
}
MaxSize *= scale;
SizeRandom *= 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)
{
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 = new Vector3 [1];
}
} else {
ColorKeyFrameValues = new 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) );
}
// 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 = new unsigned int [NumColorKeyFrames];
ColorKeyFrameValues = new Vector3 [NumColorKeyFrames];
ColorKeyFrameDeltas = new 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 = new Vector3 [1];
}
} else {
RandomColorEntries = new 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 = new Vector3 [default_randomizer_entries];
}
} else {
RandomColorEntries = new 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 = new float [1];
}
} else {
AlphaKeyFrameValues = new 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) );
}
// 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 = new unsigned int [NumAlphaKeyFrames];
AlphaKeyFrameValues = new float [NumAlphaKeyFrames];
AlphaKeyFrameDeltas = new 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 = new float [1];
}
} else {
RandomAlphaEntries = new 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 = new float [default_randomizer_entries];
}
} else {
RandomAlphaEntries = new 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 = new float [1];
}
} else {
SizeKeyFrameValues = new 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) );
}
// 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 = new unsigned int [NumSizeKeyFrames];
SizeKeyFrameValues = new float [NumSizeKeyFrames];
SizeKeyFrameDeltas = new 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 = new float [1];
}
} else {
RandomSizeEntries = new 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 = new float [default_randomizer_entries];
}
} else {
RandomSizeEntries = new 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) );
}
// 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 = new unsigned int [NumRotationKeyFrames];
RotationKeyFrameValues = new float [NumRotationKeyFrames];
HalfRotationKeyFrameDeltas = new float [NumRotationKeyFrames];
OrientationKeyFrameValues = new 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 = new float [1];
}
} else {
RandomRotationEntries = new 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 = new float [default_randomizer_entries];
}
} else {
RandomRotationEntries = new 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 = new float [1];
}
} else {
RandomOrientationEntries = new 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 = new float [default_randomizer_entries];
}
} else {
RandomOrientationEntries = new 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 = new float [1];
}
} else {
FrameKeyFrameValues = new 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) );
}
} else {
if (!Frame) {
Frame = NEW_REF( ShareBufferClass<uint8> , (MaxNum) );
}
}
// 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 = new unsigned int [NumFrameKeyFrames];
FrameKeyFrameValues = new float [NumFrameKeyFrames];
FrameKeyFrameDeltas = new 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 = new float [1];
}
} else {
RandomFrameEntries = new 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 = new float [default_randomizer_entries];
}
} else {
RandomFrameEntries = new 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;
}
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;
}
// 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 = new float[real_keyframe_count];
colors.Values = new 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 = new float[real_keyframe_count];
opacities.Values = new 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 = new float[real_keyframe_count];
sizes.Values = new 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 = new float[real_keyframe_count];
rotations.Values = new 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 = new float[real_keyframe_count];
frames.Values = new 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;
}
Reference in a new issue View git blame Copy permalink