void DX9LineTrailRenderer::render(const Group& group,const DataSet* dataSet,RenderBuffer* renderBuffer) const
{
// RenderBuffer is not used as dataset already contains organized data for rendering
const Vector3D* vertexBuffer = SPK_GET_DATA(const Vector3DArrayData,dataSet,VERTEX_BUFFER_INDEX).getData();
const Color* colorBuffer = SPK_GET_DATA(const ColorArrayData,dataSet,COLOR_BUFFER_INDEX).getData();
DX9Buffer& buffer = static_cast<DX9Buffer&>(*renderBuffer);
buffer.positionAtStart(); // Repositions all the buffers at the start
initBlending();
initRenderingOptions();
// Inits lines' parameters
DX9Info::getDevice()->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
buffer.lock(VERTEX_AND_COLOR_LOCK);
for( unsigned int i = 0; i < group.getNbParticles() * (nbSamples + 2); ++i )
{
buffer.setNextVertex(vertexBuffer[i]);
buffer.setNextColor(colorBuffer[i]);
}
// WARNING : D3DXVECTOR3 and Vector3D are the same in memory now
//buffer.copy(VERTEX_LOCK, (void *)vertexBuffer, group.getNbParticles() * (nbSamples + 2) * sizeof(D3DXVECTOR3));
//buffer.copy(COLOR_LOCK, (void *)colorBuffer, group.getNbParticles() * (nbSamples + 2) * sizeof(DWORD));
buffer.unlock();
buffer.render(D3DPT_LINESTRIP, group.getNbParticles() * (nbSamples + 2) - 1);
}
void DX9LineRenderer::render(const Group& group)
{
HRESULT hr;
if( !DX9PrepareBuffers(group) )
return;
if (!prepareBuffers(group))
return;
initBlending();
if( group.getNbParticles() != 0 )
{
for (size_t i = 0; i < group.getNbParticles(); ++i)
{
const Particle& particle = group.getParticle(i);
D3DCOLOR c = D3DCOLOR_COLORVALUE(particle.getR(), particle.getG(), particle.getB(), particle.getParamCurrentValue(PARAM_ALPHA));
Assign((gpuIterator)->position, particle.position());
(gpuIterator++)->color = c;
Assign((gpuIterator)->position, (particle.position() + particle.velocity() * length));
(gpuIterator++)->color = c;
}
void *ptr;
if( DX9VertexBuffer->Lock(0, 0, &ptr, 0) == D3D_OK )
{
std::memcpy(ptr, gpuBuffer, group.getNbParticles() * 2 * sizeof(LineVertex));
if( DX9VertexBuffer->Unlock() == D3D_OK )
{
LPDIRECT3DDEVICE9 device = DX9Info::getDevice();
device->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE);
device->SetStreamSource(0, DX9VertexBuffer, 0, sizeof(LineVertex));
device->DrawPrimitive(D3DPT_LINELIST, 0, group.getNbParticles());
}
}
}
}
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 DX9LineRenderer::render(const Group& group,const DataSet* dataSet,RenderBuffer* renderBuffer) const
{
SPK_ASSERT(renderBuffer != NULL,"DX9LinesRenderer::render(const Group&,const DataSet*,RenderBuffer*) - renderBuffer must not be NULL");
DX9Buffer& buffer = static_cast<DX9Buffer&>(*renderBuffer);
buffer.positionAtStart();
initBlending();
initRenderingOptions();
DX9Info::getDevice()->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);
for (ConstGroupIterator particleIt(group); !particleIt.end(); ++particleIt)
{
const Particle& particle = *particleIt;
buffer.setNextVertex(particle.position());
buffer.setNextVertex(particle.position() + particle.velocity() * length);
buffer.setNextColor(particle.getColor());
buffer.setNextColor(particle.getColor());
}
buffer.render(D3DPT_LINELIST, group.getNbParticles());
}
void DX9LineRenderer::render(const Group& group)
{
HRESULT hr;
if (!prepareBuffers(group))
return;
initBlending();
D3DXMATRIX view;
DX9Info::getDevice()->GetTransform(D3DTS_VIEW, &view);
D3DXVECTOR3 r(-view._11, view._12, view._13);
D3DXVECTOR3 d(-view._31, view._32, view._33);
// position de la caméra
D3DXVECTOR3 p(view._41, view._42, view._43);
D3DXVECTOR3 right;
//D3DXVECTOR3 direction;
D3DXVECTOR3 vel;
D3DCOLOR c;
float w2 = this->getWidth() / 2.0f;
if( group.getNbParticles() != 0 )
{
hr = gpuBuffer->Lock(0, group.getNbParticles()*4*sizeof(LineVertex), (void**)&gpuIterator, 0);
for (size_t i = 0; i < group.getNbParticles(); ++i)
{
const Particle& particle = group.getParticle(i);
c = D3DCOLOR_COLORVALUE(particle.getR(), particle.getG(), particle.getB(), particle.getParamCurrentValue(PARAM_ALPHA));
Assign(vel, particle.velocity());
//D3DXVec3ProjectNormal(&right, &r, &vel);
D3DXVec3Cross(&right, &vel, &d);
D3DXVec3Normalize(&right, &right);
Assign((gpuIterator)->position, particle.position());
(gpuIterator)->position += right * w2;
(gpuIterator++)->color = c;
Assign((gpuIterator)->position, particle.position());
(gpuIterator)->position -= right * w2;
(gpuIterator++)->color = c;
Assign((gpuIterator)->position, (particle.position() + particle.velocity() * length));
(gpuIterator)->position -= right * w2;
(gpuIterator++)->color = c;
Assign((gpuIterator)->position, (particle.position() + particle.velocity() * length));
(gpuIterator)->position += right * w2;
(gpuIterator++)->color = c;
}
gpuBuffer->Unlock();
DX9Info::getDevice()->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE);
DX9Info::getDevice()->SetStreamSource(0, gpuBuffer, 0, sizeof(LineVertex));
DX9Info::getDevice()->SetIndices(indexBuffer);
DX9Info::getDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, group.getNbParticles()*4, 0, group.getNbParticles()*2);
}
}
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);
}
void GLQuadRenderer::render(const Group& group,const DataSet* dataSet,RenderBuffer* renderBuffer) const
{
SPK_ASSERT(renderBuffer != NULL,"GLQuadRenderer::render(const Group&,const DataSet*,RenderBuffer*) - renderBuffer must not be NULL");
GLBuffer& buffer = static_cast<GLBuffer&>(*renderBuffer);
buffer.positionAtStart(); // Repositions all the buffers at the start
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();
initRenderingOptions();
glShadeModel(GL_FLAT);
switch(texturingMode)
{
case TEXTURE_MODE_2D :
// Creates and inits the 2D TexCoord buffer if necessary
if (buffer.getNbTexCoords() != 2)
{
buffer.setNbTexCoords(2);
if (!group.isEnabled(PARAM_TEXTURE_INDEX))
{
float t[8] = {1.0f,0.0f,0.0f,0.0f,0.0f,1.0f,1.0f,1.0f};
for (size_t i = 0; i < group.getCapacity() << 3; ++i)
buffer.setNextTexCoord(t[i & 7]);
}
}
// Binds the texture
#ifndef SPK_GL_NO_EXT
if (SPK_GL_CHECK_EXTENSION(SPK_GL_TEXTURE_3D_EXT))
glDisable(GL_TEXTURE_3D_EXT);
#endif
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,textureIndex);
// Selects the correct function
if (!group.isEnabled(PARAM_TEXTURE_INDEX))
{
if (!group.isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render2D;
else
renderParticle = &GLQuadRenderer::render2DRot;
}
else
{
if (!group.isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render2DAtlas;
else
renderParticle = &GLQuadRenderer::render2DAtlasRot;
}
break;
case TEXTURE_MODE_3D :
// Creates and inits the 3D TexCoord buffer if necessery
if (buffer.getNbTexCoords() != 3)
{
buffer.setNbTexCoords(3);
float t[12] = {1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,1.0f,0.0f,1.0f,1.0f,0.0f};
for (size_t i = 0; i < group.getCapacity() * 12; ++i)
buffer.setNextTexCoord(t[i % 12]);
}
// Binds the texture
glDisable(GL_TEXTURE_2D);
#ifndef SPK_GL_NO_EXT
glEnable(GL_TEXTURE_3D_EXT);
glBindTexture(GL_TEXTURE_3D_EXT,textureIndex);
#endif
// Selects the correct function
if (!group.isEnabled(PARAM_ANGLE))
renderParticle = &GLQuadRenderer::render3D;
else
renderParticle = &GLQuadRenderer::render3DRot;
break;
case TEXTURE_MODE_NONE :
if (buffer.getNbTexCoords() != 0)
buffer.setNbTexCoords(0);
glDisable(GL_TEXTURE_2D);
// Selects the correct function
#ifndef SPK_GL_NO_EXT
if (SPK_GL_CHECK_EXTENSION(SPK_GL_TEXTURE_3D_EXT))
glDisable(GL_TEXTURE_3D_EXT);
#endif
if (!group.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]));
// Fills the buffers
if (globalOrientation)
{
computeGlobalOrientation3D(group);
for (ConstGroupIterator particleIt(group); !particleIt.end(); ++particleIt)
(this->*renderParticle)(*particleIt,buffer);
}
else
{
for (ConstGroupIterator particleIt(group); !particleIt.end(); ++particleIt)
{
computeSingleOrientation3D(*particleIt);
(this->*renderParticle)(*particleIt,buffer);
}
}
buffer.render(GL_QUADS,group.getNbParticles() << 2);
}
