// --[ Method ]---------------------------------------------------------------
//
// - Class : CMatrix
//
// - prototype : PreScale(float fX, float fY, float fZ)
//
// - Purpose : Inserts a scale transformation _before_ all other
// transformations stored in the matrix.
// So, if tranforming a vertex, it works as it is first being
// scaled then transformed by the other ones stored before.
//
// -----------------------------------------------------------------------------
void CMatrix::PreScale(float fX, float fY, float fZ)
{
CMatrix scale;
scale.BuildScaling(fX, fY, fZ);
*this = *this * scale;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CMatrix
//
// - prototype : void Scale(float fX, float fY, float fZ)
//
// - Purpose : Appends a scaling as last transformation in the matrix.
// So, if tranforming a vertex, it will first be transformed
// by the 'original' transformation and then scaled.
//
// -----------------------------------------------------------------------------
void CMatrix::Scale(float fX, float fY, float fZ)
{
CMatrix scale;
scale.BuildScaling(fX, fY, fZ);
*this = scale * *this;
}
bool CFXTransExplodingCubes::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
assert(pDemo);
CVarFloat::CValueFloat valueTime;
CVarFloat::CValueFloat valueScaleX;
CVarFloat::CValueFloat valueScaleY;
CVarCombo::CValueCombo valueFiltering;
CVarColor::CValueColor valueColor;
EvaluateVar("Time (0-1)", fEffectTime, &valueTime);
EvaluateVar("Tex Scale X", fEffectTime, &valueScaleX);
EvaluateVar("Tex Scale Y", fEffectTime, &valueScaleY);
EvaluateVar("Filtering", fEffectTime, &valueFiltering);
EvaluateVar("Flat Color", fEffectTime, &valueColor);
m_v4FlatColor = valueColor.GetValue();
// Change filter mode
GLint minFilter, magFilter;
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED);
m_textureRTT.SetActive();
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &magFilter);
if(valueFiltering.GetValue() == "Yes")
{
// If it's point filtering, change it to linear, otherwise leave it as it is
if(minFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if(magFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
// Framebuffer to texture
m_textureRTT.CopyFromFramebuffer(0, 0, 0, 0, m_textureRTT.GetWidth(), m_textureRTT.GetHeight());
// Restore demo viewport
pDemo->SetDemoViewport();
// Clear framebuffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// States
UtilGL::States::Set(UtilGL::States::LIGHTING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED);
UtilGL::States::Set (UtilGL::States::STENCILBUFFER, UtilGL::States::ENABLED);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, 1.33f, 1.0f, 100.0f);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_WORLD);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_VIEW);
CMatrix mtxTex;
mtxTex.BuildScaling(valueScaleX.GetValue(), valueScaleY.GetValue(), 1.0f);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_TEXTURE, mtxTex);
// Render:
VECCUBES::iterator it;
for(it = m_vecCubes.begin(); it != m_vecCubes.end(); ++it)
{
float fTime = valueTime.GetValue() - it->fStartTime;
if(fTime < 0.0f) fTime = 0.0f;
DrawCube(*it, fTime);
}
glStencilFunc(GL_NOTEQUAL, 1, 1);
glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
// Restore
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_TEXTURE);
return true;
}
bool CFXRings::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
assert(pDemo);
if(!m_pResHorTexture)
{
FXRuntimeError("Horizontal texture resource not found");
return false;
}
UtilGL::Texturing::CTexture2D* pHorTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResHorTexture)->GetTexture2D());
if(!pHorTexture)
{
FXRuntimeError("WARNING: Horizontal texture not available");
return false;
}
if(!m_pResVertTexture)
{
FXRuntimeError("Vertical texture resource not found");
return false;
}
UtilGL::Texturing::CTexture2D* pVertTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResVertTexture)->GetTexture2D());
if(!pVertTexture)
{
FXRuntimeError("WARNING: Texture not available");
return false;
}
// Vars
CVarFloat::CValueFloat valueAlpha;
CVarFloat::CValueFloat valueHorRingRadius;
CVarFloat::CValueFloat valueHorRingWidth;
CVarFloat::CValueFloat valueVertRingRadius;
CVarFloat::CValueFloat valueVertRingWidth;
CVarFloat::CValueFloat valueCylinderHeight;
CVarCombo::CValueCombo valueBlendMode;
CVarCombo::CValueCombo valueKeepPreviousCamera;
CVarFloat::CValueFloat valueOscillationAmplitude;
CVarFloat::CValueFloat valueOscillationFrequency;
CVarFloat::CValueFloat valueRotationSpeed;
CVarFloat::CValueFloat valueTileU;
CVarFloat::CValueFloat valueTileV;
EvaluateVar("Alpha", fEffectTime, &valueAlpha);
EvaluateVar("Horizontal Ring Radius", fEffectTime, &valueHorRingRadius);
EvaluateVar("Horizontal Ring Width", fEffectTime, &valueHorRingWidth);
EvaluateVar("Vertical Ring Radius", fEffectTime, &valueVertRingRadius);
EvaluateVar("Vertical Ring Width", fEffectTime, &valueVertRingWidth);
EvaluateVar("Cylinder Height", fEffectTime, &valueCylinderHeight);
EvaluateVar("Blend Mode", fEffectTime, &valueBlendMode);
EvaluateVar("Keep Previous Camera", fEffectTime, &valueKeepPreviousCamera);
EvaluateVar("Oscillation Amplitude", fEffectTime, &valueOscillationAmplitude);
EvaluateVar("Oscillation Frequency", fEffectTime, &valueOscillationFrequency);
EvaluateVar("Rotation Speed", fEffectTime, &valueRotationSpeed);
EvaluateVar("Tile U", fEffectTime, &valueTileU);
EvaluateVar("Tile V", fEffectTime, &valueTileV);
// States
int nSrcBlend = UtilGL::States::BLEND_SRCALPHA;
int nDstBlend = UtilGL::States::BLEND_INVSRCALPHA;
if(valueBlendMode.GetValue() == "Add")
{
nDstBlend = UtilGL::States::BLEND_ONE;
}
else if(valueBlendMode.GetValue() == "Color Mult")
{
nSrcBlend = UtilGL::States::BLEND_DSTCOLOR;
nDstBlend = UtilGL::States::BLEND_ZERO;
}
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::ENABLED);
UtilGL::States::Set(UtilGL::States::LIGHTING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::ZBUFFERWRITE, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BFCULLING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::SRCBLEND, nSrcBlend);
UtilGL::States::Set(UtilGL::States::DSTBLEND, nDstBlend);
// Transforming
CMatrix mtxCam;
CMatrix mtxAddLocal, mtxAddWorld;
CVector3 v3AddCamPos, v3AddCamAngles;
EvaluateAddTransformVars(this, fEffectTime, &mtxAddLocal, &mtxAddWorld, &v3AddCamPos, &v3AddCamAngles);
mtxCam.RotateX(v3AddCamAngles.X());
mtxCam.RotateY(v3AddCamAngles.Y());
mtxCam.RotateZ(v3AddCamAngles.Z());
mtxCam.SetPosition(v3AddCamPos);
if(valueKeepPreviousCamera.GetValue() == "No")
{
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_VIEW, mtxCam.Inverse());
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_PROJECTION);
glMatrixMode(GL_PROJECTION);
gluPerspective(60.0f, pDemo->GetAspect(), 1.0f, 1000.0f);
}
CMatrix mtxTexturing;
mtxTexturing.BuildScaling(valueTileU.GetValue(), valueTileV.GetValue(), 1.0f);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_WORLD, mtxAddWorld);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_TEXTURE, mtxTexturing);
// Render
glEnableClientState(GL_VERTEX_ARRAY);
VECRINGS::iterator it;
for(it = m_vecRings.begin(); it != m_vecRings.end(); ++it)
{
float fDistToCenter = it->fDistToCenter * valueCylinderHeight.GetValue();
float fRotSpeed = it->fRotSpeed * valueRotationSpeed.GetValue();
float fOscillationAmplitude = it->fOscillationAmplitude * valueOscillationAmplitude.GetValue();
float fOscillationFrequency = it->fOscillationFrequency * valueOscillationFrequency.GetValue();
float fHorRingWidth = it->fWidth * valueHorRingWidth.GetValue();
float fHorRingRadius = it->fRadius * valueHorRingRadius.GetValue();
float fVertRingWidth = it->fWidth * valueVertRingWidth.GetValue();
float fVertRingRadius = it->fRadius * valueVertRingRadius.GetValue();
if(!IS_ZERO(fOscillationAmplitude))
{
fDistToCenter += sinf(((it->fOscillationOffset + fEffectTime) * PI) * fOscillationFrequency) * fOscillationAmplitude;
}
CMatrix localMatrix = mtxAddLocal;
localMatrix.PreRotateY(it->fRotAngleStart + (fRotSpeed * 360.0f * fEffectTime));
localMatrix.Translate (0.0f, fDistToCenter, 0.0f);
// Compute Mesh
for(int i = 0; i < m_nSubdivisions + 1; i++)
{
float fRadius = it->eType == SRing::HORIZONTAL ? fHorRingRadius : fVertRingRadius;
float fWidth = it->eType == SRing::HORIZONTAL ? fHorRingWidth : fVertRingWidth;
m_pv3MeshVertices[i] = m_pv3Circle[i] * fRadius;
m_pv3MeshVertices[i + m_nSubdivisions + 1] = m_pv3MeshVertices[i];
if(it->eType == SRing::HORIZONTAL)
{
if(IS_ZERO(fRadius)) fRadius = 0.001f;
float fWidthRatio = fWidth / fRadius;
m_pv3MeshVertices[i + m_nSubdivisions + 1] = m_pv3MeshVertices[i + m_nSubdivisions + 1] * (1.0f - fWidthRatio);
}
if(it->eType == SRing::VERTICAL)
{
m_pv3MeshVertices[i + m_nSubdivisions + 1].SetY(m_pv3MeshVertices[i + m_nSubdivisions + 1].Y() + fWidth);
}
localMatrix.Transform(&m_pv3MeshVertices[i]);
localMatrix.Transform(&m_pv3MeshVertices[i + m_nSubdivisions + 1]);
}
// Draw
CVector4 v4Color(1.0f, 1.0f, 1.0f, it->fAlpha * valueAlpha.GetValue());
UtilGL::States::SetColor(v4Color);
glVertexPointer(3, GL_FLOAT, 0, m_pv3MeshVertices);
UtilGL::Texturing::CTexture2D* pTexture = it->eType == SRing::HORIZONTAL ? pHorTexture : pVertTexture;
if(pTexture)
{
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, m_pv2MeshMapping);
pTexture->SetActive();
pTexture->SetTiling(true);
}
else
{
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glDrawRangeElements(GL_QUADS, 0, (m_nSubdivisions * 2) + 1, m_nSubdivisions * 4, GL_UNSIGNED_INT, m_pnMeshFaceList);
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// States
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::ZBUFFERWRITE, UtilGL::States::ENABLED);
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BFCULLING, UtilGL::States::ENABLED);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_TEXTURE);
return true;
}
