Fork Particle Blog

Particle jitter is a little nifty feature that comes in handy when you need to add sense of random motion to particles. Jitter motion is the jumpy but slight displacement in the particle’s position; however the original trajectory or the particle dynamics is not altered. So a good place to put in the particle jitter displacement is at rendering stage where this displacement value is not written back into the particle position. Here is (pseudo) code snippet to perform the jitter displacement:


pPos = pointer to copy of particle world position
VRight = right vector of the particle geometry quad
VUp = up vector of the particle geometry quad
fJitter = 1.0f; // Jitter distance
VECTOR3 JitterVector;
int nDirection = rand() % 4;
Vec3Set(&JitterVector, &((VECTOR3)(nDirection < 2 ? ((nDirection == 0) ? VRight : -VRight) : ((nDirection == 2) ? VUp : -VUp))));
Vec3Normalize(&JitterVector, &JitterVector);
Vec3Scale(&JitterVector, &JitterVector, fJitter);
Vec3Add((VECTOR3*)pPos, (VECTOR3*)pPos, &JitterVector);

Fork Particle’s cutting edge game development tools and video game development software is used in comprehensive multi-platform video games and big multi-player online games. Our video game development software comes with rich feature-set to streamline effects production and efficient runtime performance to enable the highest quality particle effects. Take your creativity and graphics realism to the next level with Fork Particle’s products and solutions.

Our products are easy to integrate, flexible and have cross platform support. The design and architecture of the Fork Particle’s particle engine targets both PC and video game console platforms keeping performance a top priority. Want to know more about our products and solutions or have any custom need, feel free to contact us to get an expert opinion.

Particle effects geometry quads may be rendered with Point Sprites, Triangles, Quads, and Tri-Strips render primitive types. Each primitive type can be indexed or non-indexed. There is a benefit to using indexed primitives for particle geometry quads – the vertex index buffer needs to be filled only once provided the index buffer is not destroy or recreated.

The Tri-Strips primitive method requires that each quad is disjointed after every quad. So after every four vertices, a degenerate triangle is inserted between two quads. The degenerate triangle is automatically dropped during rendering. Here is some DirectX source code snippet to setup the indices:


// Fill indices (index buffer)
WORD* pIndices = NULL;
int nNumVerts, i;
m_pIBDxQuad->Lock (0, nIBSize, (void**)&pIndices, D3DLOCK_NOOVERWRITE);
nNumVerts = 0;
for (i = 0; i < MAX_PS_PARTICLES; i++) {
*pIndices++ = nNumVerts;
*pIndices++ = nNumVerts++;
*pIndices++ = nNumVerts++;
*pIndices++ = nNumVerts++;
*pIndices++ = nNumVerts++;
*pIndices++ = nNumVerts-1;
}
m_pIBDxQuad->Unlock();

Filling particle geometry quad vertex data is reduced to 4 vertices per quad. Assuming the particle vertex is setup with position, diffuse, and texture coordinates, here is code snippet for filling the vertex data for a single particle quad:

// Fill vertex data (vertex buffer)
pVertex->Pos = (D3DXVECTOR3) V0;
pVertex->Color = DxColor;
pVertex->UV.x = pTextCoord1->x;
pVertex->UV.y = pTextCoord1->y;
pVertex++;

pVertex->Pos = (D3DXVECTOR3) V1;
pVertex->Color = DxColor;
pVertex->UV.x = pTextCoord1->x;
pVertex->UV.y = pTextCoord2->y;
pVertex++;

pVertex->Pos = (D3DXVECTOR3) V2;
pVertex->Color = DxColor;
pVertex->UV.x = pTextCoord2->x;
pVertex->UV.y = pTextCoord1->y;
pVertex++;

pVertex->Pos = (D3DXVECTOR3) V3;
pVertex->Color = DxColor;
pVertex->UV.x = pTextCoord2->x;
pVertex->UV.y = pTextCoord2->y;
pVertex++;

m_nNumIndices += 6;
m_nNumVerts += 4;

Note that index count is incremented by 6. The indices 1 through 4 make the displayed particle quad and index 4, 5, and 6 make up the degenerate triangle which is not displayed.