OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
356 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: e616874a07
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e616874a07'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plDrawable/plParticleFiller.cpp

800 lines
34 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, 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/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "hsTypes.h"
#include "plParticleFiller.h"
// Core background
#include "hsTemplates.h"
#include "hsFastMath.h"
#include "plPipeline.h"
#include "plViewTransform.h"
// Getting at the destination data
#include "pnSceneObject/plDrawInterface.h"
#include "plDrawable/plDrawableSpans.h"
#include "plPipeline/plGBufferGroup.h"
// For shading
#include "plGLight/plLightInfo.h"
// Getting at the source data
#include "plParticleSystem/plParticleEmitter.h"
#include "plParticleSystem/plParticle.h"
static hsScalar sInvDelSecs;
//// Local Static Stuff ///////////////////////////////////////////////////////
/// Macros for getting/setting data in a D3D vertex buffer
#define STUFF_POINT( ptr, point ) { float *fPtr = (float *)ptr; \
fPtr[ 0 ] = point.fX; fPtr[ 1 ] = point.fY; fPtr[ 2 ] = point.fZ; \
ptr += sizeof( float ) * 3; }
#define STUFF_UINT32( ptr, uint ) { UInt32 *dPtr = (UInt32 *)ptr; \
dPtr[ 0 ] = uint; ptr += sizeof( UInt32 ); }
#define EXTRACT_POINT( ptr, pt ) { float *fPtr = (float *)ptr; \
pt.fX = fPtr[ 0 ]; pt.fY = fPtr[ 1 ]; pt.fZ = fPtr[ 2 ]; \
ptr += sizeof( float ) * 3; }
#define EXTRACT_FLOAT( ptr, f ) { float *fPtr = (float *)ptr; \
f = fPtr[ 0 ]; \
ptr += sizeof( float ); }
#define EXTRACT_UINT32( ptr, uint ) { UInt32 *dPtr = (UInt32 *)ptr; \
uint = dPtr[ 0 ]; ptr += sizeof( UInt32 ); }
static hsScalar sCurrMinWidth = 0;
///////////////////////////////////////////////////////////////////////////////
//// Particles ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//// Particle Processing Inlines //////////////////////////////////////////////
// Thanks to the <cough> beauty of C++, the internal loop of
// IFillParticlePolys would be horrendous without these inlines (with them,
// it's just slightly annoying). The goal is to make the code easier to
// maintain without loosing speed (hence the inlines, which will *hopefully*
// remove the function call overhead....)
void inline IInlSetParticlePathFollow( const plParticleCore &particle, const hsMatrix44& viewToWorld,
hsVector3 &xVec, hsVector3 &yVec, hsVector3 &zVec )
{
/// Follow path specified by interpreting orientation as a velocity vector.
hsVector3 viewDir(&particle.fPos, &viewToWorld.GetTranslate());
hsFastMath::NormalizeAppr(viewDir);
zVec = viewDir;
const hsVector3& orientation = (const hsVector3)(particle.fOrientation);
yVec = orientation - orientation.InnerProduct(viewDir) * viewDir;
hsFastMath::NormalizeAppr(yVec);
xVec = yVec % viewDir;
hsFastMath::NormalizeAppr(xVec);
xVec *= particle.fHSize;
yVec *= particle.fVSize;
}
void inline IInlSetParticlePathStretch( const plParticleCore &particle, const hsMatrix44& viewToWorld,
hsVector3 &xVec, hsVector3 &yVec, hsVector3 &zVec )
{
/// Follow path specified by interpreting orientation as a velocity vector.
// Well, that's one way to do it, but it has a bit of a flaw. If the length of the
// particle doesn't match the distance it's moved each frame, you get a nasty strobing
// effect, particularly as particles move faster. One of those things they don't teach
// you in the math class you slept through.
// So what we want is for the tail of the particle this frame to be where the head of
// the particle was last frame.
// First thing changed was the orientation passed in is now the change in position for
// this frame (was the last frame's velocity).
// zVec will still be the normalized vector from the eye to the particle (in world space).
// Does zVec ever get used? Hmm, only gets used for the normal facing the camera.
// This thing gets a lot faster and cleaner when we just use the view axes to compute.
// So zVec is just -viewDir.
// yVec = orientation - orientation.InnerProduct(zVec) * zVec
// xVec = yVec % zVec
// To be really correct, you can normalize xVec, because the particle doesn't get fatter
// as it goes faster, just longer. Costs a little more, but...
// And it also raises the question of what to do with the user supplied sizes. Again,
// for correctness, we want to add the size to the length of the displacement.
// We could afford that (maybe) by doing a fast normalize on yVec, then multiplying
// by orientation.InnerProduct(yVec) + fVSize.
// So the new stuff we need here are:
// The particle (to get the size out of).
// The viewToWorld transform (we can pull the eyePt and viewDir out of that.
// Note that we could probably slim away a normalize or two, but the actual number
// of normalizes we're doing hasn't gone up, I've just moved them up from IInlSetParticlePoints().
hsVector3 viewDir(&particle.fPos, &viewToWorld.GetTranslate());
hsScalar invD = hsFastMath::InvSqrtAppr(viewDir.MagnitudeSquared());
viewDir *= invD;
zVec = viewDir;
const hsVector3& orientation = (const hsVector3)(particle.fOrientation);
// We don't want the projection of orientation orthogonal to viewDir here,
// it's okay (and looks better) if yVec isn't in the image plane, we just
// want to make sure that xVec is in the image plane. Might want to make
// the same change to IInlSetParticlePathFollow(), but I haven't checked
// that yet. Artifact to look for is particles starting to look goofy
// as their orientation gets close in direction to viewDir. mf
yVec = orientation;
hsFastMath::NormalizeAppr(yVec);
xVec = yVec % viewDir; // cross product of two orthonormal vectors, no need to normalize.
hsScalar xLen = particle.fHSize;
if( xLen * invD < sCurrMinWidth )
xLen = sCurrMinWidth / invD;
xVec *= xLen;
hsScalar len = yVec.InnerProduct(orientation);
// Might want to give it a little boost to overlap itself (and compensate for the massive
// transparent border the artists love). But they can do that themselves with the VSize.
// len *= 1.5f;
len += particle.fVSize;
yVec *= len * -1.f;
}
void inline IInlSetParticlePathFlow( const plParticleCore &particle, const hsMatrix44& viewToWorld,
hsVector3 &xVec, hsVector3 &yVec, hsVector3 &zVec )
{
// Okay, all the notes for SetParticlePathStretch apply here too. The only
// difference is that we're going to keep the area of the particle constant,
// so the longer it stretches, the narrower it gets orthogonal to the velocity.
hsVector3 viewDir(&particle.fPos, &viewToWorld.GetTranslate());
hsScalar invD = hsFastMath::InvSqrtAppr(viewDir.MagnitudeSquared());
viewDir *= invD;
zVec = viewDir;
const hsVector3& orientation = (const hsVector3)(particle.fOrientation);
// We don't want the projection of orientation orthogonal to viewDir here,
// it's okay (and looks better) if yVec isn't in the image plane, we just
// want to make sure that xVec is in the image plane. Might want to make
// the same change to IInlSetParticlePathFollow(), but I haven't checked
// that yet. Artifact to look for is particles starting to look goofy
// as their orientation gets close in direction to viewDir. mf
yVec = orientation;
hsFastMath::NormalizeAppr(yVec);
xVec = yVec % viewDir; // cross product of two orthonormal vectors, no need to normalize.
hsScalar len = yVec.InnerProduct(orientation);
hsScalar xLen = particle.fHSize * hsFastMath::InvSqrtAppr(1.f + len * sInvDelSecs);
if( xLen * invD < sCurrMinWidth )
xLen = sCurrMinWidth / invD;
xVec *= xLen;
// Might want to give it a little boost to overlap itself (and compensate for the massive
// transparent border the artists love). But they can do that themselves with the VSize.
len += particle.fVSize;
yVec *= len * -2.f;
}
void inline IInlSetParticleExplicit( const hsMatrix44 &viewToWorld, const plParticleCore &particle,
hsVector3 &xVec, hsVector3 &yVec, hsVector3 &zVec )
{
const hsVector3& orientation = (const hsVector3)(particle.fOrientation);
#if 0 // See notes below - mf
zVec.Set( 0, 0, -1 );
yVec.Set( &orientation );
zVec = viewToWorld * zVec;
yVec = viewToWorld * yVec;
xVec = yVec % zVec;
#else // See notes below - mf
// The above has a bit of a problem with wide field of view. All of the
// particles are facing the same direction with respect to lighting,
// even though some are to the left and some are to the right of the camera
// (when facing the center of the system). We'll also start seeing them side on
// as they get to the edge of the screen. Fortunately, it's actually faster
// to calculate the vector from camera to particle and normalize it than
// to transform the vector (0,0,-1) (though not as fast as pulling the
// camera direction directly from the viewToWorld).
hsVector3 del(&particle.fPos, &viewToWorld.GetTranslate());
hsFastMath::NormalizeAppr(del);
zVec = del;
yVec.Set(&(viewToWorld * orientation));
xVec = yVec % zVec;
#endif // See notes below - mf
xVec = hsFastMath::NormalizeAppr( xVec ) * particle.fHSize;
yVec = hsFastMath::NormalizeAppr( yVec ) * particle.fVSize;
}
void inline IInlSetParticlePoints( const hsVector3 &xVec, const hsVector3 &yVec, const plParticleCore &particle,
hsPoint3 *partPts, UInt32 &partColor )
{
/// Do the 4 verts for this particle
partPts[ 0 ] = partPts[ 1 ] = partPts[ 2 ] = partPts[ 3 ] = particle.fPos;
partPts[ 0 ] += xVec - yVec;
partPts[ 1 ] += -xVec - yVec;
partPts[ 2 ] += -xVec + yVec;
partPts[ 3 ] += xVec + yVec;
partColor = particle.fColor;
}
void inline IInlSetParticlePointsStretch( const hsVector3 &xVec, const hsVector3 &yVec, const plParticleCore &particle,
hsPoint3 *partPts, UInt32 &partColor )
{
/// Do the 4 verts for this particle
partPts[ 0 ] = partPts[ 1 ] = partPts[ 2 ] = partPts[ 3 ] = particle.fPos;
partPts[ 0 ] += xVec + yVec;
partPts[ 1 ] += -xVec + yVec;
partPts[ 2 ] += -xVec;
partPts[ 3 ] += xVec;
partColor = particle.fColor;
}
void inline IInlStuffParticle1UV( UInt8 *&destPtr, const hsPoint3 *partPts, const hsVector3 &partNorm,
const UInt32 &partColor, const plParticleCore &particle )
{
UInt8 j;
for( j = 0; j < 4; j++ )
{
STUFF_POINT( destPtr, partPts[ j ] );
STUFF_POINT( destPtr, partNorm );
STUFF_UINT32( destPtr, partColor );
STUFF_UINT32( destPtr, 0 );
STUFF_POINT( destPtr, particle.fUVCoords[ j ] );
}
}
void inline IInlStuffParticleNoUVs( UInt8 *&destPtr, const hsPoint3 *partPts, const hsVector3 &partNorm,
const UInt32 &partColor )
{
UInt8 j;
for( j = 0; j < 4; j++ )
{
STUFF_POINT( destPtr, partPts[ j ] );
STUFF_POINT( destPtr, partNorm );
STUFF_UINT32( destPtr, partColor );
STUFF_UINT32( destPtr, 0 );
}
}
void inline IInlSetNormalViewFace( hsVector3 &partNorm, const hsVector3 &zVec )
{
partNorm = -zVec;
}
void inline IInlSetNormalStrongestLight( hsVector3 &partNorm, const plParticleCore &particle,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight, const hsVector3 &zVec )
{
if( omniLight != nil )
{
partNorm.Set( &particle.fPos, &omniLight->GetWorldPosition() );
partNorm = -partNorm;
}
else if( directionLight != nil )
{
partNorm = -directionLight->GetWorldDirection();
}
else
partNorm = -zVec;
partNorm = hsFastMath::NormalizeAppr( partNorm );
}
void inline IInlSetNormalExplicit( hsVector3 &partNorm, const plParticleCore &particle )
{
partNorm = particle.fNormal;
}
//// IIPL Functions (Internal-Inline-Particle-Loop) ///////////////////////////
// Function names go as follows:
// IIPL_u_o_n()
// where u is 1UV or 0UV (for 1 UV channel or no UV channels),
// o is OVel (for orientation-follows-velocity) or OExp (for orientation-is-explicit)
// and n is NViewFace (for normals facing view), NLite (for facing strongest light)
// or NExp (for explicit)
#define IIPL_PROLOG \
UInt32 i, partColor; \
hsVector3 xVec, yVec, zVec, partNorm; \
hsPoint3 partPts[ 4 ]; \
for( i = 0; i < numParticles; i++ )
void inline IIPL_1UV_OVel_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFollow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OVel_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticlePathFollow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OVel_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFollow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OStr_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathStretch( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OStr_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticlePathStretch( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OStr_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathStretch( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OFlo_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFlow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OFlo_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticlePathFlow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OFlo_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFlow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OExp_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticleExplicit( viewToWorld, particles[ i ], xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OExp_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticleExplicit( viewToWorld, particles[ i ], xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_1UV_OExp_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticleExplicit( viewToWorld, particles[ i ], xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticle1UV( destPtr, partPts, partNorm, partColor, particles[ i ] );
}
}
void inline IIPL_0UV_OVel_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFollow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OVel_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticlePathFollow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OVel_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFollow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OStr_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathStretch( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OStr_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticlePathStretch( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OStr_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathStretch( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OFlo_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFlow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OFlo_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticlePathFlow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OFlo_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticlePathFlow( particles[ i ], viewToWorld, xVec, yVec, zVec );
IInlSetParticlePointsStretch( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OExp_NViewFace( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticleExplicit( viewToWorld, particles[ i ], xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalViewFace( partNorm, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OExp_NLite( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr,
const plOmniLightInfo *omniLight, const plDirectionalLightInfo *directionLight )
{
IIPL_PROLOG
{
IInlSetParticleExplicit( viewToWorld, particles[ i ], xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalStrongestLight( partNorm, particles[ i ], omniLight, directionLight, zVec );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
void inline IIPL_0UV_OExp_NExp( const UInt32 &numParticles, const plParticleCore *particles, const hsMatrix44& viewToWorld, UInt8 *&destPtr )
{
IIPL_PROLOG
{
IInlSetParticleExplicit( viewToWorld, particles[ i ], xVec, yVec, zVec );
IInlSetParticlePoints( xVec, yVec, particles[ i ], partPts, partColor );
IInlSetNormalExplicit( partNorm, particles[ i ] );
IInlStuffParticleNoUVs( destPtr, partPts, partNorm, partColor );
}
}
//// IFillParticlePolys ///////////////////////////////////////////////////////
// Takes a list of particles and makes the polys for them.
#include "hsTimer.h"
#include "plProfile.h"
plProfile_CreateTimer("Fill Polys", "Particles", ParticleFillPoly);
void plParticleFiller::FillParticles(plPipeline* pipe, plDrawableSpans* drawable, plParticleSpan* span)
{
if (!span->fSource || span->fNumParticles <= 0)
return;
plProfile_BeginTiming(ParticleFillPoly);
sInvDelSecs = hsTimer::GetDelSysSeconds();
if( sInvDelSecs > 0 )
sInvDelSecs = 1.f / sInvDelSecs;
const plParticleCore* particles = span->fSource->GetParticleArray();
const UInt32 numParticles = span->fNumParticles;
plGBufferGroup* group = drawable->GetBufferGroup(span->fGroupIdx);
UInt8* destPtr = group->GetVertBufferData(span->fVBufferIdx);
destPtr += span->fVStartIdx * group->GetVertexSize();
/// Get the z vector (pointing away from the camera) in worldspace
hsMatrix44 viewToWorld = pipe->GetCameraToWorld();
plOmniLightInfo* omniLight = nil;
plDirectionalLightInfo* directionLight = nil;
/// Get strongest light, if there is one, for normal generation
if( span->GetNumLights( false ) > 0 )
{
omniLight = plOmniLightInfo::ConvertNoRef( span->GetLight( 0, false ) );
directionLight = plDirectionalLightInfo::ConvertNoRef( span->GetLight( 0, false ) );
}
/// Fill with 1 UV channel
if( group->GetNumUVs() == 1 )
{
/// Switch on orientation
if( span->fSource->fMiscFlags & plParticleEmitter::kOrientationVelocityBased )
{
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_1UV_OVel_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_1UV_OVel_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_1UV_OVel_NExp( numParticles, particles, viewToWorld, destPtr );
}
else if( span->fSource->fMiscFlags & plParticleEmitter::kOrientationVelocityStretch )
{
sCurrMinWidth = pipe->GetViewTransform().GetOrthoWidth() / pipe->GetViewTransform().GetScreenWidth() * 0.75f;
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_1UV_OStr_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_1UV_OStr_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_1UV_OStr_NExp( numParticles, particles, viewToWorld, destPtr );
}
else if( span->fSource->fMiscFlags & plParticleEmitter::kOrientationVelocityFlow )
{
sCurrMinWidth = pipe->GetViewTransform().GetOrthoWidth() / pipe->GetViewTransform().GetScreenWidth() * 0.75f;
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_1UV_OFlo_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_1UV_OFlo_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_1UV_OFlo_NExp( numParticles, particles, viewToWorld, destPtr );
}
else // Orientation explicit
{
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_1UV_OExp_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_1UV_OExp_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_1UV_OExp_NExp( numParticles, particles, viewToWorld, destPtr );
}
}
else
/// Fill with no UV channels
{
/// Switch on orientation
if( span->fSource->fMiscFlags & plParticleEmitter::kOrientationVelocityBased )
{
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_0UV_OVel_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_0UV_OVel_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_0UV_OVel_NExp( numParticles, particles, viewToWorld, destPtr );
}
else if( span->fSource->fMiscFlags & plParticleEmitter::kOrientationVelocityStretch )
{
sCurrMinWidth = pipe->GetViewTransform().GetOrthoWidth() / pipe->GetViewTransform().GetScreenWidth() * 0.75f;
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_0UV_OStr_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_0UV_OStr_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_0UV_OStr_NExp( numParticles, particles, viewToWorld, destPtr );
}
else if( span->fSource->fMiscFlags & plParticleEmitter::kOrientationVelocityFlow )
{
sCurrMinWidth = pipe->GetViewTransform().GetOrthoWidth() / pipe->GetViewTransform().GetScreenWidth() * 0.75f;
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_0UV_OFlo_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_0UV_OFlo_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_0UV_OFlo_NExp( numParticles, particles, viewToWorld, destPtr );
}
else // Orientation explicit
{
/// Switch on normal generation
if( span->fSource->fMiscFlags & plParticleEmitter::kNormalViewFacing )
IIPL_0UV_OExp_NViewFace( numParticles, particles, viewToWorld, destPtr );
else if( span->fSource->fMiscFlags & plParticleEmitter::kNormalNearestLight )
IIPL_0UV_OExp_NLite( numParticles, particles, viewToWorld, destPtr, omniLight, directionLight );
else
IIPL_0UV_OExp_NExp( numParticles, particles, viewToWorld, destPtr );
}
}
/// All done!
plProfile_EndTiming(ParticleFillPoly);
}
void plParticleFiller::FillParticlePolys(plPipeline* pipe, plDrawInterface* di)
{
if( !di )
return; // should probably be an asserted error.
plDrawableSpans* drawable = plDrawableSpans::ConvertNoRef(di->GetDrawable(0));
if( !drawable )
return;
// Currently, the di always points to exactly 1 drawable with 1 span index. If
// that changes, this would just become a loop.
UInt32 diIndex = di->GetDrawableMeshIndex(0);
hsAssert(diIndex >= 0, "Bogus input to fill particles");
const plDISpanIndex& diSpans = drawable->GetDISpans(diIndex);
int i;
for( i = 0; i < diSpans.GetCount(); i++ )
{
UInt32 spanIdx = diSpans[i];
hsAssert(drawable->GetSpan(spanIdx), "Bogus input to fill particles");
hsAssert(drawable->GetSpan(spanIdx)->fTypeMask & plSpan::kParticleSpan, "Bogus input to fill particles");
// Safe cast, since we just checked the type mask.
plParticleSpan* span = (plParticleSpan*)drawable->GetSpan(spanIdx);
if( !span->fSource )
return; // Nothing to do, it's idle.
FillParticles(pipe, drawable, span);
}
}