void GLLineRenderer::render(const Group& group)
{
if (!prepareBuffers(group))
return;
initBlending();
initRenderingHints();
glLineWidth(width);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
for (size_t i = 0; i < group.getNbParticles(); ++i)
{
const Particle& particle = group.getParticle(i);
*(gpuIterator++) = particle.position().x;
*(gpuIterator++) = particle.position().y;
*(gpuIterator++) = particle.position().z;
gpuIterator += 4; // skips the first vertex color data as GL_FLAT was forced
*(gpuIterator++) = particle.position().x + particle.velocity().x * length;
*(gpuIterator++) = particle.position().y + particle.velocity().y * length;
*(gpuIterator++) = particle.position().z + particle.velocity().z * length;
*(gpuIterator++) = particle.getR();
*(gpuIterator++) = particle.getG();
*(gpuIterator++) = particle.getB();
*(gpuIterator++) = particle.getParamCurrentValue(PARAM_ALPHA);
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// interleaves vertex and color data
glVertexPointer(3,GL_FLOAT,7 * sizeof(float),gpuBuffer);
glColorPointer(4,GL_FLOAT,7 * sizeof(float),gpuBuffer + 3);
glDrawArrays(GL_LINES,0,group.getNbParticles() << 1);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
void GLQuadRenderer::render(const Group& group)
{
if (!prepareBuffers(group))
return;
float oldModelView[16];
for (int i = 0; i < 16; ++i)
oldModelView[i] = modelView[i];
glGetFloatv(GL_MODELVIEW_MATRIX,modelView);
for (int i = 0; i < 16; ++i)
if (oldModelView[i] != modelView[i])
{
invertModelView();
break;
}
initBlending();
initRenderingHints();
glShadeModel(GL_FLAT);
switch(texturingMode)
{
case TEXTURE_2D :
if (getTexture3DGLExt() == SUPPORTED)
glDisable(GL_TEXTURE_3D);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,textureIndex);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,getTextureBlending());
if (!group.getModel()->isEnabled(PARAM_TEXTURE_INDEX))
{
if (!group.getModel()->isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render2D;
else
renderParticle = &GLQuadRenderer::render2DRot;
}
else
{
if (!group.getModel()->isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render2DAtlas;
else
renderParticle = &GLQuadRenderer::render2DAtlasRot;
}
break;
case TEXTURE_3D :
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_3D);
glBindTexture(GL_TEXTURE_3D,textureIndex);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,getTextureBlending());
if (!group.getModel()->isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render3D;
else
renderParticle = &GLQuadRenderer::render3DRot;
break;
case TEXTURE_NONE :
glDisable(GL_TEXTURE_2D);
if (getTexture3DGLExt() == SUPPORTED)
glDisable(GL_TEXTURE_3D);
if (!group.getModel()->isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render2D;
else
renderParticle = &GLQuadRenderer::render2DRot;
break;
}
bool globalOrientation = precomputeOrientation3D(
group,
Vector3D(-invModelView[8],-invModelView[9],-invModelView[10]),
Vector3D(invModelView[4],invModelView[5],invModelView[6]),
Vector3D(invModelView[12],invModelView[13],invModelView[14]));
if (globalOrientation)
{
computeGlobalOrientation3D();
for (size_t i = 0; i < group.getNbParticles(); ++i)
(this->*renderParticle)(group.getParticle(i));
}
else
{
for (size_t i = 0; i < group.getNbParticles(); ++i)
{
const Particle& particle = group.getParticle(i);
computeSingleOrientation3D(particle);
(this->*renderParticle)(particle);
}
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
if (texturingMode == TEXTURE_2D)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2,GL_FLOAT,0,textureBuffer);
}
else if (texturingMode == TEXTURE_3D)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3,GL_FLOAT,0,textureBuffer);
}
// interleaves vertex and color data
glVertexPointer(3,GL_FLOAT,7 * sizeof(float),gpuBuffer);
glColorPointer(4,GL_FLOAT,7 * sizeof(float),gpuBuffer + 3);
glDrawArrays(GL_QUADS,0,group.getNbParticles() << 2);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
if (texturingMode != TEXTURE_NONE)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
void GLLineTrailRenderer::render(const Group& group)
{
if (!prepareBuffers(group))
return;
initBlending();
initRenderingHints();
// Inits lines' parameters
glLineWidth(width);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
for (size_t i = 0; i < group.getNbParticles(); ++i)
{
const Particle& particle = group.getParticle(i);
float age = particle.getAge();
float oldAge = *valueIterator;
if ((age == 0.0f)||(age < *valueIterator)) // If the particle is new, buffers for it are reinitialized
init(particle,0.0f);
else
{
if (age - *(valueIterator + 1) >= duration / (nbSamples - 1)) // shifts the data by one
{
std::memmove(vertexIterator + 6,vertexIterator + 3,(nbSamples - 1) * 3 * sizeof(float));
std::memmove(colorIterator + 8,colorIterator + 4,((nbSamples - 1) << 2) * sizeof(float));
std::memmove(valueIterator + 1,valueIterator,(nbSamples - 1) * sizeof(float));
// post degenerated vertex copy
std::memcpy(vertexIterator + (nbSamples + 1) * 3,vertexIterator + nbSamples * 3,3 * sizeof(float));
}
// Updates the current sample
const Vector3D& pos = particle.position();
*(vertexIterator++) = pos.x;
*(vertexIterator++) = pos.y;
*(vertexIterator++) = pos.z;
std::memcpy(vertexIterator,vertexIterator - 3,3 * sizeof(float));
vertexIterator += (nbSamples + 1) * 3;
colorIterator += 4; // skips post degenerated vertex color
*(colorIterator++) = particle.getR();
*(colorIterator++) = particle.getG();
*(colorIterator++) = particle.getB();
*(colorIterator++) = particle.getParamCurrentValue(PARAM_ALPHA);
colorIterator += 3;
*(valueIterator++) = age;
//valueIterator += nbSamples;
// Updates alpha
for (size_t i = 0; i < nbSamples - 1; ++i)
{
float ratio = (age - oldAge) / (duration - age + *valueIterator);
if (ratio > 0.0f)
*colorIterator *= ratio < 1.0f ? 1.0f - ratio : 0.0f;
colorIterator += 4;
++valueIterator;
}
++colorIterator;
}
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4,GL_FLOAT,0,colorBuffer);
glVertexPointer(3,GL_FLOAT,0,vertexBuffer);
glDrawArrays(GL_LINE_STRIP,0,group.getNbParticles() * (nbSamples + 2));
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
