/***************************************************************************** The Dark Mod GPL Source Code This file is part of the The Dark Mod Source Code, originally based on the Doom 3 GPL Source Code as published in 2011. The Dark Mod Source Code 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. For details, see LICENSE.TXT. Project: The Dark Mod (http://www.thedarkmod.com/) ******************************************************************************/ #include "precompiled.h" #pragma hdrstop struct ParticleParmDesc { const char *name; int count; const char *desc; }; const ParticleParmDesc ParticleDistributionDesc[] = { { "rect", 3, "" }, { "cylinder", 4, "" }, { "sphere", 3, "" } }; const ParticleParmDesc ParticleDirectionDesc[] = { { "cone", 1, "" }, { "outward", 1, "" }, }; const ParticleParmDesc ParticleOrientationDesc[] = { { "view", 0, "" }, { "aimed", 2, "" }, { "x", 0, "" }, { "y", 0, "" }, { "z", 0, "" } }; const ParticleParmDesc ParticleCustomDesc[] = { { "standard", 0, "Standard" }, { "helix", 5, "sizeX Y Z radialSpeed axialSpeed" }, { "flies", 3, "radialSpeed axialSpeed size" }, { "orbit", 2, "radius speed"}, { "drip", 2, "something something" } }; const int CustomParticleCount = sizeof( ParticleCustomDesc ) / sizeof( const ParticleParmDesc ); /* ================= idDeclParticle::Size ================= */ size_t idDeclParticle::Size( void ) const { return sizeof( idDeclParticle ); } /* ===================== idDeclParticle::GetStageBounds ===================== */ void idDeclParticle::GetStageBounds( idParticleStage *stage ) { stage->bounds.Clear(); // this isn't absolutely guaranteed, but it should be close particleGen_t g; renderEntity_t renderEntity; memset( &renderEntity, 0, sizeof( renderEntity ) ); renderEntity.axis = mat3_identity; renderView_t renderView; memset( &renderView, 0, sizeof( renderView ) ); renderView.viewaxis = mat3_identity; g.renderEnt = &renderEntity; g.renderView = &renderView; g.origin.Zero(); g.axis = mat3_identity; idRandom steppingRandom; steppingRandom.SetSeed( 0 ); // just step through a lot of possible particles as a representative sampling for ( int i = 0 ; i < 1000 ; i++ ) { g.random = g.originalRandom = steppingRandom; int maxMsec = stage->particleLife * 1000; // SteveL #4218: Speed up load time for long-lived particles. // Limit the sampling to 250 spread across the particle's lifetime. const int step_milliseconds = idMath::Imax(maxMsec / 250, 16); // 16 was the original value, meaning test every frame for ( int inCycleTime = 0 ; inCycleTime < maxMsec ; inCycleTime += step_milliseconds ) { // make sure we get the very last tic, which may make up an extreme edge if ( inCycleTime + step_milliseconds > maxMsec ) { inCycleTime = maxMsec - 1; } g.frac = (float)inCycleTime / ( stage->particleLife * 1000 ); g.age = inCycleTime * 0.001f; // if the particle doesn't get drawn because it is faded out or beyond a kill region, // don't increment the verts idVec3 origin; stage->ParticleOrigin( &g, origin ); stage->bounds.AddPoint( origin ); } } // find the max size float maxSize = 0; for ( float f = 0; f <= 1.0f; f += 1.0f / 64 ) { float size = stage->size.Eval( f, steppingRandom ); float aspect = stage->aspect.Eval( f, steppingRandom ); if ( aspect > 1 ) { size *= aspect; } if ( size > maxSize ) { maxSize = size; } } maxSize += 8; // just for good measure // users can specify a per-stage bounds expansion to handle odd cases stage->bounds.ExpandSelf( maxSize + stage->boundsExpansion ); } /* ================ idDeclParticle::ParseParms Parses a variable length list of parms on one line ================ */ void idDeclParticle::ParseParms( idLexer &src, float *parms, int maxParms ) { idToken token; memset( parms, 0, maxParms * sizeof( *parms ) ); int count = 0; while( 1 ) { if ( !src.ReadTokenOnLine( &token ) ) { return; } if ( count == maxParms ) { src.Error( "too many parms on line" ); return; } token.StripQuotes(); parms[count] = atof( token ); count++; } } /* ================ idDeclParticle::ParseParametric ================ */ void idDeclParticle::ParseParametric( idLexer &src, idParticleParm *parm ) { idToken token; parm->table = NULL; parm->from = parm->to = 0.0f; if ( !src.ReadToken( &token ) ) { src.Error( "not enough parameters" ); return; } if ( token.IsNumeric() ) { // can have a to + 2nd parm parm->from = parm->to = atof( token ); if ( src.ReadToken( &token ) ) { if ( !token.Icmp( "to" ) ) { if ( !src.ReadToken( &token ) ) { src.Error( "missing second parameter" ); return; } parm->to = atof( token ); } else { src.UnreadToken( &token ); } } } else { // table parm->table = static_cast( declManager->FindType( DECL_TABLE, token, false ) ); } } /* ================ idDeclParticle::ParseParticleStage ================ */ idParticleStage *idDeclParticle::ParseParticleStage( idLexer &src ) { idToken token; idParticleStage *stage = new idParticleStage; stage->Default(); while (1) { if ( src.HadError() ) { break; } if ( !src.ReadToken( &token ) ) { break; } if ( !token.Icmp( "}" ) ) { break; } if ( !token.Icmp( "material" ) ) { src.ReadToken( &token ); stage->material = declManager->FindMaterial( token.c_str() ); continue; } if ( !token.Icmp( "count" ) ) { stage->totalParticles = src.ParseInt(); continue; } if ( !token.Icmp( "time" ) ) { stage->particleLife = src.ParseFloat(); continue; } if ( !token.Icmp( "cycles" ) ) { stage->cycles = src.ParseFloat(); continue; } if ( !token.Icmp( "timeOffset" ) ) { stage->timeOffset = src.ParseFloat(); continue; } if ( !token.Icmp( "deadTime" ) ) { stage->deadTime = src.ParseFloat(); continue; } if ( !token.Icmp( "randomDistribution" ) ) { stage->randomDistribution = src.ParseBool(); continue; } if ( !token.Icmp( "bunching" ) ) { stage->spawnBunching = src.ParseFloat(); continue; } if ( !token.Icmp( "distribution" ) ) { src.ReadToken( &token ); if ( !token.Icmp( "rect" ) ) { stage->distributionType = PDIST_RECT; } else if ( !token.Icmp( "cylinder" ) ) { stage->distributionType = PDIST_CYLINDER; } else if ( !token.Icmp( "sphere" ) ) { stage->distributionType = PDIST_SPHERE; } else { src.Error( "bad distribution type: %s\n", token.c_str() ); } ParseParms( src, stage->distributionParms, sizeof( stage->distributionParms ) / sizeof( stage->distributionParms[0] ) ); continue; } if ( !token.Icmp( "direction" ) ) { src.ReadToken( &token ); if ( !token.Icmp( "cone" ) ) { stage->directionType = PDIR_CONE; } else if ( !token.Icmp( "outward" ) ) { stage->directionType = PDIR_OUTWARD; } else { src.Error( "bad direction type: %s\n", token.c_str() ); } ParseParms( src, stage->directionParms, sizeof( stage->directionParms ) / sizeof( stage->directionParms[0] ) ); continue; } if ( !token.Icmp( "orientation" ) ) { src.ReadToken( &token ); if ( !token.Icmp( "view" ) ) { stage->orientation = POR_VIEW; } else if ( !token.Icmp( "aimed" ) ) { stage->orientation = POR_AIMED; } else if ( !token.Icmp( "x" ) ) { stage->orientation = POR_X; } else if ( !token.Icmp( "y" ) ) { stage->orientation = POR_Y; } else if ( !token.Icmp( "z" ) ) { stage->orientation = POR_Z; } else { src.Error( "bad orientation type: %s\n", token.c_str() ); } ParseParms( src, stage->orientationParms, sizeof( stage->orientationParms ) / sizeof( stage->orientationParms[0] ) ); continue; } if ( !token.Icmp( "customPath" ) ) { src.ReadToken( &token ); if ( !token.Icmp( "standard" ) ) { stage->customPathType = PPATH_STANDARD; } else if ( !token.Icmp( "helix" ) ) { stage->customPathType = PPATH_HELIX; } else if ( !token.Icmp( "flies" ) ) { stage->customPathType = PPATH_FLIES; } else if ( !token.Icmp( "spherical" ) ) { stage->customPathType = PPATH_ORBIT; } else { src.Error( "bad path type: %s\n", token.c_str() ); } ParseParms( src, stage->customPathParms, sizeof( stage->customPathParms ) / sizeof( stage->customPathParms[0] ) ); continue; } if ( !token.Icmp( "speed" ) ) { ParseParametric( src, &stage->speed ); continue; } if ( !token.Icmp( "rotation" ) ) { ParseParametric( src, &stage->rotationSpeed ); continue; } if ( !token.Icmp( "angle" ) ) { stage->initialAngle = src.ParseFloat(); continue; } if ( !token.Icmp( "entityColor" ) ) { stage->entityColor = src.ParseBool(); continue; } if ( !token.Icmp( "size" ) ) { ParseParametric( src, &stage->size ); continue; } if ( !token.Icmp( "aspect" ) ) { ParseParametric( src, &stage->aspect ); continue; } if ( !token.Icmp( "fadeIn" ) ) { stage->fadeInFraction = src.ParseFloat(); continue; } if ( !token.Icmp( "fadeOut" ) ) { stage->fadeOutFraction = src.ParseFloat(); continue; } if ( !token.Icmp( "fadeIndex" ) ) { stage->fadeIndexFraction = src.ParseFloat(); continue; } if ( !token.Icmp( "color" ) ) { stage->color[0] = src.ParseFloat(); stage->color[1] = src.ParseFloat(); stage->color[2] = src.ParseFloat(); stage->color[3] = src.ParseFloat(); continue; } if ( !token.Icmp( "fadeColor" ) ) { stage->fadeColor[0] = src.ParseFloat(); stage->fadeColor[1] = src.ParseFloat(); stage->fadeColor[2] = src.ParseFloat(); stage->fadeColor[3] = src.ParseFloat(); continue; } if ( !token.Icmp("offset" ) ) { stage->offset[0] = src.ParseFloat(); stage->offset[1] = src.ParseFloat(); stage->offset[2] = src.ParseFloat(); continue; } if ( !token.Icmp( "animationFrames" ) ) { stage->animationFrames = src.ParseInt(); continue; } if ( !token.Icmp( "animationRate" ) ) { stage->animationRate = src.ParseFloat(); continue; } if ( !token.Icmp( "boundsExpansion" ) ) { stage->boundsExpansion = src.ParseFloat(); continue; } if ( !token.Icmp( "gravity" ) ) { src.ReadToken( &token ); if ( !token.Icmp( "world" ) ) { stage->worldGravity = true; } else { src.UnreadToken( &token ); } stage->gravity = src.ParseFloat(); continue; } if ( !token.Icmp( "WorldAxis" ) ) { // #3950 stage->worldAxis = true; continue; } if ( !token.Icmp( "softeningRadius" ) ) { stage->softeningRadius = src.ParseFloat(); continue; } src.Error( "unknown token %s\n", token.c_str() ); } // derive values stage->cycleMsec = ( stage->particleLife + stage->deadTime ) * 1000; return stage; } /* ================ idDeclParticle::Parse ================ */ bool idDeclParticle::Parse( const char *text, const int textLength ) { idLexer src; idToken token; src.LoadMemory( text, textLength, GetFileName(), GetLineNum() ); src.SetFlags( DECL_LEXER_FLAGS ); src.SkipUntilString( "{" ); depthHack = 0.0f; while (1) { if ( !src.ReadToken( &token ) ) { break; } if ( !token.Icmp( "}" ) ) { break; } if ( !token.Icmp( "{" ) ) { idParticleStage *stage = ParseParticleStage( src ); if ( !stage ) { src.Warning( "Particle stage parse failed" ); MakeDefault(); return false; } stages.Append( stage ); continue; } if ( !token.Icmp( "depthHack" ) ) { depthHack = src.ParseFloat(); continue; } src.Warning( "bad token %s", token.c_str() ); MakeDefault(); return false; } // // calculate the bounds // bounds.Clear(); for( int i = 0; i < stages.Num(); i++ ) { GetStageBounds( stages[i] ); bounds.AddBounds( stages[i]->bounds ); } if ( bounds.GetVolume() <= 0.1f ) { bounds = idBounds( vec3_origin ).Expand( 8.0f ); } return true; } /* ================ idDeclParticle::FreeData ================ */ void idDeclParticle::FreeData( void ) { stages.DeleteContents( true ); } /* ================ idDeclParticle::DefaultDefinition ================ */ const char *idDeclParticle::DefaultDefinition( void ) const { return "{\n" "\t" "{\n" "\t\t" "material\t_default\n" "\t\t" "count\t20\n" "\t\t" "time\t\t1.0\n" "\t" "}\n" "}"; } /* ================ idDeclParticle::WriteParticleParm ================ */ void idDeclParticle::WriteParticleParm( idFile *f, idParticleParm *parm, const char *name ) { f->WriteFloatString( "\t\t%s\t\t\t\t ", name ); if ( parm->table ) { f->WriteFloatString( "%s\n", parm->table->GetName() ); } else { f->WriteFloatString( "\"%.3f\" ", parm->from ); if ( parm->from == parm->to ) { f->WriteFloatString( "\n" ); } else { f->WriteFloatString( " to \"%.3f\"\n", parm->to ); } } } /* ================ idDeclParticle::WriteStage ================ */ void idDeclParticle::WriteStage( idFile *f, idParticleStage *stage ) { int i; f->WriteFloatString( "\t{\n" ); f->WriteFloatString( "\t\tcount\t\t\t\t%i\n", stage->totalParticles ); f->WriteFloatString( "\t\tmaterial\t\t\t%s\n", stage->material->GetName() ); if ( stage->animationFrames ) { f->WriteFloatString( "\t\tanimationFrames \t%i\n", stage->animationFrames ); } if ( stage->animationRate ) { f->WriteFloatString( "\t\tanimationRate \t\t%.3f\n", stage->animationRate ); } f->WriteFloatString( "\t\ttime\t\t\t\t%.3f\n", stage->particleLife ); f->WriteFloatString( "\t\tcycles\t\t\t\t%.3f\n", stage->cycles ); if ( stage->timeOffset ) { f->WriteFloatString( "\t\ttimeOffset\t\t\t%.3f\n", stage->timeOffset ); } if ( stage->deadTime ) { f->WriteFloatString( "\t\tdeadTime\t\t\t%.3f\n", stage->deadTime ); } f->WriteFloatString( "\t\tbunching\t\t\t%.3f\n", stage->spawnBunching ); f->WriteFloatString( "\t\tdistribution\t\t%s ", ParticleDistributionDesc[stage->distributionType].name ); for ( i = 0; i < ParticleDistributionDesc[stage->distributionType].count; i++ ) { f->WriteFloatString( "%.3f ", stage->distributionParms[i] ); } f->WriteFloatString( "\n" ); f->WriteFloatString( "\t\tdirection\t\t\t%s ", ParticleDirectionDesc[stage->directionType].name ); for ( i = 0; i < ParticleDirectionDesc[stage->directionType].count; i++ ) { f->WriteFloatString( "\"%.3f\" ", stage->directionParms[i] ); } f->WriteFloatString( "\n" ); f->WriteFloatString( "\t\torientation\t\t\t%s ", ParticleOrientationDesc[stage->orientation].name ); for ( i = 0; i < ParticleOrientationDesc[stage->orientation].count; i++ ) { f->WriteFloatString( "%.3f ", stage->orientationParms[i] ); } f->WriteFloatString( "\n" ); if ( stage->customPathType != PPATH_STANDARD ) { f->WriteFloatString( "\t\tcustomPath %s ", ParticleCustomDesc[stage->customPathType].name ); for ( i = 0; i < ParticleCustomDesc[stage->customPathType].count; i++ ) { f->WriteFloatString( "%.3f ", stage->customPathParms[i] ); } f->WriteFloatString( "\n" ); } if ( stage->entityColor ) { f->WriteFloatString( "\t\tentityColor\t\t\t1\n" ); } WriteParticleParm( f, &stage->speed, "speed" ); WriteParticleParm( f, &stage->size, "size" ); WriteParticleParm( f, &stage->aspect, "aspect" ); if ( stage->rotationSpeed.from ) { WriteParticleParm( f, &stage->rotationSpeed, "rotation" ); } if ( stage->initialAngle ) { f->WriteFloatString( "\t\tangle\t\t\t\t%.3f\n", stage->initialAngle ); } f->WriteFloatString( "\t\trandomDistribution\t\t\t\t%i\n", static_cast( stage->randomDistribution ) ); f->WriteFloatString( "\t\tboundsExpansion\t\t\t\t%.3f\n", stage->boundsExpansion ); f->WriteFloatString( "\t\tfadeIn\t\t\t\t%.3f\n", stage->fadeInFraction ); f->WriteFloatString( "\t\tfadeOut\t\t\t\t%.3f\n", stage->fadeOutFraction ); f->WriteFloatString( "\t\tfadeIndex\t\t\t\t%.3f\n", stage->fadeIndexFraction ); f->WriteFloatString( "\t\tcolor \t\t\t\t%.3f %.3f %.3f %.3f\n", stage->color.x, stage->color.y, stage->color.z, stage->color.w ); f->WriteFloatString( "\t\tfadeColor \t\t\t%.3f %.3f %.3f %.3f\n", stage->fadeColor.x, stage->fadeColor.y, stage->fadeColor.z, stage->fadeColor.w ); f->WriteFloatString( "\t\toffset \t\t\t\t%.3f %.3f %.3f\n", stage->offset.x, stage->offset.y, stage->offset.z ); f->WriteFloatString( "\t\tgravity \t\t\t" ); if ( stage->worldGravity ) { f->WriteFloatString( "world " ); } f->WriteFloatString( "%.3f\n", stage->gravity ); f->WriteFloatString( "\t}\n" ); } /* ================ idDeclParticle::RebuildTextSource ================ */ bool idDeclParticle::RebuildTextSource( void ) { idFile_Memory f; f.WriteFloatString("\n\n/*\n" "\tGenerated by the Particle Editor.\n" "\tTo use the particle editor, launch the game and type 'editParticles' on the console.\n" "*/\n" ); f.WriteFloatString( "particle %s {\n", GetName() ); if ( depthHack ) { f.WriteFloatString( "\tdepthHack\t%f\n", depthHack ); } for ( int i = 0; i < stages.Num(); i++ ) { WriteStage( &f, stages[i] ); } f.WriteFloatString( "}" ); SetText( f.GetDataPtr() ); return true; } /* ================ idDeclParticle::Save ================ */ bool idDeclParticle::Save( const char *fileName ) { RebuildTextSource(); if ( fileName ) { declManager->CreateNewDecl( DECL_PARTICLE, GetName(), fileName ); } ReplaceSourceFileText(); return true; } /* ==================================================================================== idParticleParm ==================================================================================== */ float idParticleParm::Eval( float frac, idRandom &rand ) const { if ( table ) { return table->TableLookup( frac ); } return from + frac * ( to - from ); } float idParticleParm::Integrate( float frac, idRandom &rand ) const { if ( table ) { common->Printf( "idParticleParm::Integrate: can't integrate tables\n" ); return 0; } return ( from + frac * ( to - from ) * 0.5f ) * frac; } /* ==================================================================================== idParticleStage ==================================================================================== */ /* ================ idParticleStage::idParticleStage ================ */ idParticleStage::idParticleStage( void ) { material = NULL; totalParticles = 0; cycles = 0.0f; cycleMsec = 0; spawnBunching = 0.0f; particleLife = 0.0f; timeOffset = 0.0f; deadTime = 0.0f; distributionType = PDIST_RECT; distributionParms[0] = distributionParms[1] = distributionParms[2] = distributionParms[3] = 0.0f; directionType = PDIR_CONE; directionParms[0] = directionParms[1] = directionParms[2] = directionParms[3] = 0.0f; // idParticleParm speed; gravity = 0.0f; worldGravity = false; worldAxis = false; customPathType = PPATH_STANDARD; customPathParms[0] = customPathParms[1] = customPathParms[2] = customPathParms[3] = 0.0f; customPathParms[4] = customPathParms[5] = customPathParms[6] = customPathParms[7] = 0.0f; offset.Zero(); animationFrames = 0; animationRate = 0.0f; randomDistribution = true; entityColor = false; initialAngle = 0.0f; // idParticleParm rotationSpeed; orientation = POR_VIEW; orientationParms[0] = orientationParms[1] = orientationParms[2] = orientationParms[3] = 0.0f; // idParticleParm size // idParticleParm aspect color.Zero(); fadeColor.Zero(); fadeInFraction = 0.0f; fadeOutFraction = 0.0f; fadeIndexFraction = 0.0f; hidden = false; boundsExpansion = 0.0f; bounds.Clear(); softeningRadius = -2.0f; // -2 means "auto" } /* ================ idParticleStage::Default Sets the stage to a default state ================ */ void idParticleStage::Default() { material = declManager->FindMaterial( "_default" ); totalParticles = 100; spawnBunching = 1.0f; particleLife = 1.5f; timeOffset = 0.0f; deadTime = 0.0f; distributionType = PDIST_RECT; distributionParms[0] = 8.0f; distributionParms[1] = 8.0f; distributionParms[2] = 8.0f; distributionParms[3] = 0.0f; directionType = PDIR_CONE; directionParms[0] = 90.0f; directionParms[1] = 0.0f; directionParms[2] = 0.0f; directionParms[3] = 0.0f; orientation = POR_VIEW; orientationParms[0] = 0.0f; orientationParms[1] = 0.0f; orientationParms[2] = 0.0f; orientationParms[3] = 0.0f; speed.from = 150.0f; speed.to = 150.0f; speed.table = NULL; gravity = 1.0f; worldGravity = false; worldAxis = false; customPathType = PPATH_STANDARD; customPathParms[0] = 0.0f; customPathParms[1] = 0.0f; customPathParms[2] = 0.0f; customPathParms[3] = 0.0f; customPathParms[4] = 0.0f; customPathParms[5] = 0.0f; customPathParms[6] = 0.0f; customPathParms[7] = 0.0f; offset.Zero(); animationFrames = 0; animationRate = 0.0f; initialAngle = 0.0f; rotationSpeed.from = 0.0f; rotationSpeed.to = 0.0f; rotationSpeed.table = NULL; size.from = 4.0f; size.to = 4.0f; size.table = NULL; aspect.from = 1.0f; aspect.to = 1.0f; aspect.table = NULL; color.x = 1.0f; color.y = 1.0f; color.z = 1.0f; color.w = 1.0f; fadeColor.x = 0.0f; fadeColor.y = 0.0f; fadeColor.z = 0.0f; fadeColor.w = 0.0f; fadeInFraction = 0.1f; fadeOutFraction = 0.25f; fadeIndexFraction = 0.0f; boundsExpansion = 0.0f; randomDistribution = true; entityColor = false; cycleMsec = ( particleLife + deadTime ) * 1000; softeningRadius = -2.0f; // -2 means "auto" } /* ================ idParticleStage::NumQuadsPerParticle includes trails and cross faded animations ================ */ int idParticleStage::NumQuadsPerParticle() const { int count = 1; if ( orientation == POR_AIMED ) { int trails = idMath::Ftoi( orientationParms[0] ); // each trail stage will add an extra quad count *= ( 1 + trails ); } // if we are doing strip-animation, we need to double the number and cross fade them if ( animationFrames > 1 ) { count *= 2; } return count; } /* =============== idParticleStage::ParticleOrigin =============== */ void idParticleStage::ParticleOrigin( particleGen_t *g, idVec3 &origin ) const { if ( customPathType == PPATH_STANDARD ) { // // find intial origin distribution // float radiusSqr, angle1, angle2; switch( distributionType ) { case PDIST_RECT: { // ( sizeX sizeY sizeZ ) origin[0] = ( ( randomDistribution ) ? g->random.CRandomFloat() : 1.0f ) * distributionParms[0]; origin[1] = ( ( randomDistribution ) ? g->random.CRandomFloat() : 1.0f ) * distributionParms[1]; origin[2] = ( ( randomDistribution ) ? g->random.CRandomFloat() : 1.0f ) * distributionParms[2]; break; } case PDIST_CYLINDER: { // ( sizeX sizeY sizeZ ringFraction ) angle1 = ( ( randomDistribution ) ? g->random.CRandomFloat() : 1.0f ) * idMath::TWO_PI; idMath::SinCos16( angle1, origin[0], origin[1] ); origin[2] = ( ( randomDistribution ) ? g->random.CRandomFloat() : 1.0f ); // reproject points that are inside the ringFraction to the outer band if ( distributionParms[3] > 0.0f ) { radiusSqr = origin[0] * origin[0] + origin[1] * origin[1]; if ( radiusSqr < distributionParms[3] * distributionParms[3] ) { // if we are inside the inner reject zone, rescale to put it out into the good zone float f = sqrt( radiusSqr ) / distributionParms[3]; float invf = 1.0f / f; float newRadius = distributionParms[3] + f * ( 1.0f - distributionParms[3] ); float rescale = invf * newRadius; origin[0] *= rescale; origin[1] *= rescale; } } origin[0] *= distributionParms[0]; origin[1] *= distributionParms[1]; origin[2] *= distributionParms[2]; break; } case PDIST_SPHERE: { // ( sizeX sizeY sizeZ ringFraction ) // iterating with rejection is the only way to get an even distribution over a sphere if ( randomDistribution ) { do { origin[0] = g->random.CRandomFloat(); origin[1] = g->random.CRandomFloat(); origin[2] = g->random.CRandomFloat(); radiusSqr = origin[0] * origin[0] + origin[1] * origin[1] + origin[2] * origin[2]; } while( radiusSqr > 1.0f ); } else { origin.Set( 1.0f, 1.0f, 1.0f ); radiusSqr = 3.0f; } if ( distributionParms[3] > 0.0f ) { // we could iterate until we got something that also satisfied ringFraction, // but for narrow rings that could be a lot of work, so reproject inside points instead if ( radiusSqr < distributionParms[3] * distributionParms[3] ) { // if we are inside the inner reject zone, rescale to put it out into the good zone float f = sqrt( radiusSqr ) / distributionParms[3]; float invf = 1.0f / f; float newRadius = distributionParms[3] + f * ( 1.0f - distributionParms[3] ); float rescale = invf * newRadius; origin[0] *= rescale; origin[1] *= rescale; origin[2] *= rescale; } } origin[0] *= distributionParms[0]; origin[1] *= distributionParms[1]; origin[2] *= distributionParms[2]; break; } } // offset will effect all particle origin types // add this before the velocity and gravity additions origin += offset; // // add the velocity over time // idVec3 dir; switch( directionType ) { case PDIR_CONE: { // angle is the full angle, so 360 degrees is any spherical direction angle1 = g->random.CRandomFloat() * directionParms[0] * idMath::M_DEG2RAD; angle2 = g->random.CRandomFloat() * idMath::PI; float s1, c1, s2, c2; idMath::SinCos16( angle1, s1, c1 ); idMath::SinCos16( angle2, s2, c2 ); dir[0] = s1 * c2; dir[1] = s1 * s2; dir[2] = c1; break; } case PDIR_OUTWARD: { dir = origin; dir.Normalize(); dir[2] += directionParms[0]; break; } default: common->Error("idParticleStage::ParticleOrigin: bad direction"); return; } // add speed float iSpeed = speed.Integrate( g->frac, g->random ); origin += dir * iSpeed * particleLife; } else { // // custom paths completely override both the origin and velocity calculations, but still // use the standard gravity // float angle1, angle2, speed1, speed2; switch( customPathType ) { case PPATH_HELIX: { // ( sizeX sizeY sizeZ radialSpeed axialSpeed ) speed1 = g->random.CRandomFloat(); speed2 = g->random.CRandomFloat(); angle1 = g->random.RandomFloat() * idMath::TWO_PI + customPathParms[3] * speed1 * g->age; float s1, c1; idMath::SinCos16( angle1, s1, c1 ); origin[0] = c1 * customPathParms[0]; origin[1] = s1 * customPathParms[1]; origin[2] = g->random.RandomFloat() * customPathParms[2] + customPathParms[4] * speed2 * g->age; break; } case PPATH_FLIES: { // ( radialSpeed axialSpeed size ) speed1 = idMath::ClampFloat( 0.4f, 1.0f, g->random.CRandomFloat() ); speed2 = idMath::ClampFloat( 0.4f, 1.0f, g->random.CRandomFloat() ); angle1 = g->random.RandomFloat() * idMath::PI * 2 + customPathParms[0] * speed1 * g->age; angle2 = g->random.RandomFloat() * idMath::PI * 2 + customPathParms[1] * speed1 * g->age; float s1, c1, s2, c2; idMath::SinCos16( angle1, s1, c1 ); idMath::SinCos16( angle2, s2, c2 ); origin[0] = c1 * c2; origin[1] = s1 * c2; origin[2] = -s2; origin *= customPathParms[2]; break; } case PPATH_ORBIT: { // ( radius speed axis ) angle1 = g->random.RandomFloat() * idMath::TWO_PI + customPathParms[1] * g->age; float s1, c1; idMath::SinCos16( angle1, s1, c1 ); origin[0] = c1 * customPathParms[0]; origin[1] = s1 * customPathParms[0]; origin.ProjectSelfOntoSphere( customPathParms[0] ); break; } case PPATH_DRIP: { // ( speed ) origin[0] = 0.0f; origin[1] = 0.0f; origin[2] = -( g->age * customPathParms[0] ); break; } default: { common->Error( "idParticleStage::ParticleOrigin: bad customPathType" ); } } origin += offset; } if ( worldAxis ) // SteveL #3950 -- allow particles to use world axis for their offset and travel direction { origin *= g->renderEnt->axis.Transpose(); } else { origin *= g->axis; // adjust for any per-particle offset } origin += g->origin; // adjust for any per-particle offset // add gravity after adjusting for axis if ( worldGravity ) { idVec3 gra( 0, 0, -gravity ); gra *= g->renderEnt->axis.Transpose(); origin += gra * g->age * g->age; } else { origin[2] -= gravity * g->age * g->age; } } /* ================== idParticleStage::ParticleVerts ================== */ int idParticleStage::ParticleVerts( particleGen_t *g, idVec3 origin, idDrawVert *verts ) const { float psize = size.Eval( g->frac, g->random ); float paspect = aspect.Eval( g->frac, g->random ); float width = psize; float height = psize * paspect; idVec3 left, up; if ( orientation == POR_AIMED ) { // reset the values to an earlier time to get a previous origin idRandom currentRandom = g->random; float currentAge = g->age; float currentFrac = g->frac; idDrawVert *verts_p = verts; idVec3 stepOrigin = origin; idVec3 stepLeft; int numTrails = idMath::Ftoi( orientationParms[0] ); float trailTime = orientationParms[1]; stepLeft.Zero(); if ( trailTime == 0 ) { trailTime = 0.5f; } float height = 1.0f / ( 1 + numTrails ); float t = 0; for ( int i = 0 ; i <= numTrails ; i++ ) { g->random = g->originalRandom; g->age = currentAge - ( i + 1 ) * trailTime / ( numTrails + 1 ); // time to back up g->frac = g->age / particleLife; idVec3 oldOrigin; ParticleOrigin( g, oldOrigin ); up = stepOrigin - oldOrigin; // along the direction of travel idVec3 forwardDir; g->renderEnt->axis.ProjectVector( g->renderView->viewaxis[0], forwardDir ); up -= ( up * forwardDir ) * forwardDir; up.Normalize(); left = up.Cross( forwardDir ); left *= psize; verts_p[0] = verts[0]; verts_p[1] = verts[1]; verts_p[2] = verts[2]; verts_p[3] = verts[3]; if ( i == 0 ) { verts_p[0].xyz = stepOrigin - left; verts_p[1].xyz = stepOrigin + left; } else { verts_p[0].xyz = stepOrigin - stepLeft; verts_p[1].xyz = stepOrigin + stepLeft; } verts_p[2].xyz = oldOrigin - left; verts_p[3].xyz = oldOrigin + left; // modify texcoords verts_p[0].st[0] = verts[0].st[0]; verts_p[0].st[1] = t; verts_p[1].st[0] = verts[1].st[0]; verts_p[1].st[1] = t; verts_p[2].st[0] = verts[2].st[0]; verts_p[2].st[1] = t+height; verts_p[3].st[0] = verts[3].st[0]; verts_p[3].st[1] = t+height; t += height; verts_p += 4; stepOrigin = oldOrigin; stepLeft = left; } g->random = currentRandom; g->age = currentAge; g->frac = currentFrac; return 4 * (numTrails+1); } // // constant rotation // float angle; angle = ( initialAngle ) ? initialAngle : 360 * g->random.RandomFloat(); float angleMove = rotationSpeed.Integrate( g->frac, g->random ) * particleLife; // have hald the particles rotate each way if ( g->index & 1 ) { angle += angleMove; } else { angle -= angleMove; } angle = angle / 180 * idMath::PI; float c = idMath::Cos16( angle ); float s = idMath::Sin16( angle ); if ( orientation == POR_Z ) { // oriented in entity space left[0] = s; left[1] = c; left[2] = 0; up[0] = c; up[1] = -s; up[2] = 0; } else if ( orientation == POR_X ) { // oriented in entity space left[0] = 0; left[1] = c; left[2] = s; up[0] = 0; up[1] = -s; up[2] = c; } else if ( orientation == POR_Y ) { // oriented in entity space left[0] = c; left[1] = 0; left[2] = s; up[0] = -s; up[1] = 0; up[2] = c; } else { // oriented in viewer space idVec3 entityLeft, entityUp; g->renderEnt->axis.ProjectVector( g->renderView->viewaxis[1], entityLeft ); g->renderEnt->axis.ProjectVector( g->renderView->viewaxis[2], entityUp ); left = entityLeft * c + entityUp * s; up = entityUp * c - entityLeft * s; } left *= width; up *= height; verts[0].xyz = origin - left + up; verts[1].xyz = origin + left + up; verts[2].xyz = origin - left - up; verts[3].xyz = origin + left - up; return 4; } /* ================== idParticleStage::ParticleTexCoords ================== */ void idParticleStage::ParticleTexCoords( particleGen_t *g, idDrawVert *verts ) const { float s, width; float t, height; if ( animationFrames > 1 ) { width = 1.0f / animationFrames; float floatFrame; if ( animationRate ) { // explicit, cycling animation floatFrame = g->age * animationRate; } else { // single animation cycle over the life of the particle floatFrame = g->frac * animationFrames; } int intFrame = (int)floatFrame; g->animationFrameFrac = floatFrame - intFrame; s = width * intFrame; } else { s = 0.0f; width = 1.0f; } t = 0.0f; height = 1.0f; verts[0].st[0] = s; verts[0].st[1] = t; verts[1].st[0] = s+width; verts[1].st[1] = t; verts[2].st[0] = s; verts[2].st[1] = t+height; verts[3].st[0] = s+width; verts[3].st[1] = t+height; } /* ================== idParticleStage::ParticleColors ================== */ void idParticleStage::ParticleColors( particleGen_t *g, idDrawVert *verts ) const { float fadeFraction = 1.0f; // most particles fade in at the beginning and fade out at the end if ( g->frac < fadeInFraction ) { fadeFraction *= ( g->frac / fadeInFraction ); } if ( 1.0f - g->frac < fadeOutFraction ) { fadeFraction *= ( ( 1.0f - g->frac ) / fadeOutFraction ); } // individual gun smoke particles get more and more faded as the // cycle goes on (note that totalParticles won't be correct for a surface-particle deform) if ( fadeIndexFraction ) { float indexFrac = ( totalParticles - g->index ) / (float)totalParticles; if ( indexFrac < fadeIndexFraction ) { fadeFraction *= indexFrac / fadeIndexFraction; } } for ( int i = 0 ; i < 4 ; i++ ) { float fcolor = ( ( entityColor ) ? g->renderEnt->shaderParms[i] : color[i] ) * fadeFraction + fadeColor[i] * ( 1.0f - fadeFraction ); int icolor = idMath::FtoiFast( fcolor * 255.0f ); if ( icolor < 0 ) { icolor = 0; } else if ( icolor > 255 ) { icolor = 255; } verts[0].color[i] = verts[1].color[i] = verts[2].color[i] = verts[3].color[i] = icolor; } } /* ================ idParticleStage::CreateParticle Returns 0 if no particle is created because it is completely faded out Returns 4 if a normal quad is created Returns 8 if two cross faded quads are created Vertex order is: 0 1 2 3 ================ */ int idParticleStage::CreateParticle( particleGen_t *g, idDrawVert *verts ) const { idVec3 origin; verts[0].Clear(); verts[1].Clear(); verts[2].Clear(); verts[3].Clear(); ParticleColors( g, verts ); // if we are completely faded out, kill the particle if ( verts[0].color[0] == 0 && verts[0].color[1] == 0 && verts[0].color[2] == 0 && verts[0].color[3] == 0 ) { return 0; } ParticleOrigin( g, origin ); ParticleTexCoords( g, verts ); int numVerts = ParticleVerts( g, origin, verts ); if ( animationFrames <= 1 ) { return numVerts; } // if we are doing strip-animation, we need to double the quad and cross fade it float width = 1.0f / animationFrames; float frac = g->animationFrameFrac; float iFrac = 1.0f - frac; for ( int i = 0 ; i < numVerts ; i++ ) { verts[numVerts + i] = verts[i]; verts[numVerts + i].st[0] += width; verts[numVerts + i].color[0] *= frac; verts[numVerts + i].color[1] *= frac; verts[numVerts + i].color[2] *= frac; verts[numVerts + i].color[3] *= frac; verts[i].color[0] *= iFrac; verts[i].color[1] *= iFrac; verts[i].color[2] *= iFrac; verts[i].color[3] *= iFrac; } return numVerts * 2; } /* ================== idParticleStage::GetCustomPathName ================== */ const char* idParticleStage::GetCustomPathName() { int index = ( customPathType < CustomParticleCount ) ? customPathType : 0; return ParticleCustomDesc[index].name; } /* ================== idParticleStage::GetCustomPathDesc ================== */ const char* idParticleStage::GetCustomPathDesc() { int index = ( customPathType < CustomParticleCount ) ? customPathType : 0; return ParticleCustomDesc[index].desc; } /* ================== idParticleStage::NumCustomPathParms ================== */ int idParticleStage::NumCustomPathParms() { int index = ( customPathType < CustomParticleCount ) ? customPathType : 0; return ParticleCustomDesc[index].count; } /* ================== idParticleStage::SetCustomPathType ================== */ void idParticleStage::SetCustomPathType( const char *p ) { customPathType = PPATH_STANDARD; for ( int i = 0; i < CustomParticleCount; i ++ ) { if ( idStr::Icmp( p, ParticleCustomDesc[i].name ) == 0 ) { customPathType = static_cast( i ); break; } } } /* ================== idParticleStage::operator= ================== */ void idParticleStage::operator=( const idParticleStage &src ) { material = src.material; totalParticles = src.totalParticles; cycles = src.cycles; cycleMsec = src.cycleMsec; spawnBunching = src.spawnBunching; particleLife = src.particleLife; timeOffset = src.timeOffset; deadTime = src.deadTime; distributionType = src.distributionType; distributionParms[0] = src.distributionParms[0]; distributionParms[1] = src.distributionParms[1]; distributionParms[2] = src.distributionParms[2]; distributionParms[3] = src.distributionParms[3]; directionType = src.directionType; directionParms[0] = src.directionParms[0]; directionParms[1] = src.directionParms[1]; directionParms[2] = src.directionParms[2]; directionParms[3] = src.directionParms[3]; speed = src.speed; gravity = src.gravity; worldGravity = src.worldGravity; randomDistribution = src.randomDistribution; entityColor = src.entityColor; customPathType = src.customPathType; customPathParms[0] = src.customPathParms[0]; customPathParms[1] = src.customPathParms[1]; customPathParms[2] = src.customPathParms[2]; customPathParms[3] = src.customPathParms[3]; customPathParms[4] = src.customPathParms[4]; customPathParms[5] = src.customPathParms[5]; customPathParms[6] = src.customPathParms[6]; customPathParms[7] = src.customPathParms[7]; offset = src.offset; animationFrames = src.animationFrames; animationRate = src.animationRate; initialAngle = src.initialAngle; rotationSpeed = src.rotationSpeed; orientation = src.orientation; orientationParms[0] = src.orientationParms[0]; orientationParms[1] = src.orientationParms[1]; orientationParms[2] = src.orientationParms[2]; orientationParms[3] = src.orientationParms[3]; size = src.size; aspect = src.aspect; color = src.color; fadeColor = src.fadeColor; fadeInFraction = src.fadeInFraction; fadeOutFraction = src.fadeOutFraction; fadeIndexFraction = src.fadeIndexFraction; hidden = src.hidden; boundsExpansion = src.boundsExpansion; bounds = src.bounds; }