void OpenMDLmodel::EnableMaterial( OpenMDL::Material* material )
{
OpenMDL::String fullname;
if( material->HasDiffuseMap() )
{
glActiveTextureARB( GL_TEXTURE0_ARB );
glEnable( GL_TEXTURE_2D );
char tmps[256];
sprintf( tmps, "Textures/%s", material->GetDiffuseMap().GetBuffer() );
BindTextureByName( tmps );
}
glActiveTextureARB( GL_TEXTURE1_ARB );
if( material->HasSpecularMap() )
{
glEnable( GL_TEXTURE_2D );
fullname = OpenMDL::String("Textures/") + material->GetSpecularMap();
BindTextureByName( fullname.GetBuffer() );
cgSetParameter1i( m_UberShader_bSpecularMapping, 1 );
}
else
{
glDisable( GL_TEXTURE_2D );
cgSetParameter1i( m_UberShader_bSpecularMapping, 0 );
}
/*
glActiveTextureARB( GL_TEXTURE2_ARB );
if( material->HasNormalMap() )
{
glEnable( GL_TEXTURE_2D );
fullname = OpenMDL::String("Textures/") + material->GetNormalMap();
BindTextureByName( fullname.GetBuffer() );
cgSetParameter1i( m_UberShader_bNormalMapping, 1 );
}
else
{
glDisable( GL_TEXTURE_2D );
cgSetParameter1i( m_UberShader_bNormalMapping, 0 );
}
*/
glActiveTextureARB( GL_TEXTURE0_ARB );
cgGLSetStateMatrixParameter( m_UberShader_ModelCamProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY );
cgGLSetStateMatrixParameter( m_UberShader_ModelCam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY );
cgGLSetParameter3f( m_UberShader_Lightpos_Pixel, m_LightInWorldSpace.x, m_LightInWorldSpace.y, m_LightInWorldSpace.z );
cgGLSetParameter1f( m_UberShader_Ambient, m_Ambient );
cgGLSetParameter3f( m_UberShader_CamPos, m_CamPos.x, m_CamPos.y, m_CamPos.z );
cgGLSetParameter3f( m_UberShader_LightColor, m_LightColor.x, m_LightColor.y, m_LightColor.z );
cgGLSetMatrixParameterfc( m_UberShader_WorldCam, m_WorldCam );
cgGLSetParameter1f( m_UberShader_SpecularPower, material->GetSpecularCoeff() );
cgGLSetParameter3f( m_UberShader_ClipPlane_Point, m_ClipPlane_Point.x, m_ClipPlane_Point.y, m_ClipPlane_Point.z );
cgGLSetParameter3f( m_UberShader_ClipPlane_Normal, m_ClipPlane_Normal.x, m_ClipPlane_Normal.y, m_ClipPlane_Normal.z );
m_UberShader.EnablePrograms();
}
static bool gl_cg_set_mvp(const math_matrix *mat)
{
if (cg_active && prg[active_index].mvp)
{
cgGLSetMatrixParameterfc(prg[active_index].mvp, mat->data);
return true;
}
else
return false;
}
static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
{
cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
if (cg_data && cg_data->prg[cg_data->active_idx].mvp)
{
cgGLSetMatrixParameterfc(cg_data->prg[cg_data->active_idx].mvp, mat->data);
return true;
}
gl_ff_matrix(mat);
return false;
}
static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
{
cg_shader_data_t *cg = (cg_shader_data_t*)shader_data;
if (!cg || !cg->prg[cg->active_idx].mvp)
goto fallback;
cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
return true;
fallback:
gl_ff_matrix(mat);
return false;
}
static bool gl_cg_set_mvp(void *data, void *shader_data,
const void *mat_data)
{
cg_shader_data_t *cg = (cg_shader_data_t*)shader_data;
if (cg && cg->prg[cg->active_idx].mvp)
{
const math_matrix_4x4 *mat = (const math_matrix_4x4*)mat_data;
cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
return true;
}
return false;
}
static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
{
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
(void)data;
if (cg && cg->prg[cg->active_idx].mvp)
{
cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
return true;
}
gl_ff_matrix(mat);
return false;
}
void CapsuleGraphicsObject::render()
{
glShadeModel(GL_SMOOTH);
if(g_shaderSys)
g_shaderSys->enableProfiles();
if(g_defaultVertexShader) {
g_defaultVertexShader->bind();
}
if(g_defaultFragmentShader)
g_defaultFragmentShader->bind();
glPushMatrix();
glEnable(GL_NORMALIZE);
glScalef(radius,length,radius);
if(g_defaultVertexShader) {
cgGLSetParameter4f(g_defaultVertexShader->getParameter("lightPos"), g_lightPos.x,g_lightPos.y,g_lightPos.z,1); //move to bind place
cgGLSetMatrixParameterfc(g_defaultVertexShader->getParameter("view"),g_viewMat);
cgGLSetStateMatrixParameter( g_defaultVertexShader->getParameter("worldViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY );
cgGLSetStateMatrixParameter( g_defaultVertexShader->getParameter("worldView"), CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY );
cgUpdateProgramParameters(g_defaultVertexShader->getProgram());
}
glColor3f(1,1,1);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,0,verts);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT,0,normals);
glDrawArrays(GL_TRIANGLES,0,nVerts);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisable(GL_NORMALIZE);
glPopMatrix();
//sphere caps
glPushMatrix();
glTranslatef(0,length/2,0);
sphere->render();
glPopMatrix();
glPushMatrix();
glTranslatef(0,-length/2,0);
sphere->render();
glPopMatrix();
if(g_shaderSys)
g_shaderSys->disableProfiles();
}
static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
(void)data;
if (cg && cg->prg[cg->active_idx].mvp)
{
cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
return true;
}
#ifndef NO_GL_FF_MATRIX
gl_ff_matrix(mat);
#endif
return false;
}
void Material::bind()
{
//bytt til egen shader
if(m_shaderSys)
m_shaderSys->enableProfiles();
if(m_vertexShader) {
m_vertexShader->bind();
cgGLSetStateMatrixParameter(m_vertexShader->getParameter("worldViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(m_vertexShader->getParameter("worldView"), CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetParameter4f(m_vertexShader->getParameter("lightPos"), g_lightPos.x,g_lightPos.y,g_lightPos.z,1);
cgGLSetMatrixParameterfc(m_vertexShader->getParameter("view"),g_viewMat);
cgUpdateProgramParameters(m_vertexShader->getProgram());
}
if(m_fragmentShader) {
m_fragmentShader->bind();
cgGLSetParameter3f(m_fragmentShader->getParameter("col"),m_color.x,m_color.y,m_color.z);
cgUpdateProgramParameters(m_fragmentShader->getProgram());
}
}
void BoxGraphicsObject::render(void)
{
if(g_shaderSys)
g_shaderSys->enableProfiles();
if(g_defaultVertexShader) {
g_defaultVertexShader->bind();
}
if(g_defaultFragmentShader)
g_defaultFragmentShader->bind();
glPushMatrix();
glEnable(GL_NORMALIZE);
glScalef(width,height,depth);
if(g_defaultVertexShader) {
cgGLSetParameter4f(g_defaultVertexShader->getParameter("lightPos"), g_lightPos.x,g_lightPos.y,g_lightPos.z,1); //move to bind place
cgGLSetMatrixParameterfc(g_defaultVertexShader->getParameter("view"),g_viewMat);
cgGLSetStateMatrixParameter( g_defaultVertexShader->getParameter("worldViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY );
cgGLSetStateMatrixParameter( g_defaultVertexShader->getParameter("worldView"), CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY );
cgUpdateProgramParameters(g_defaultVertexShader->getProgram());
}
glColor3f(1,1,1);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,0,boxVerts);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT,0,boxNormals);
glDrawArrays(GL_QUADS,0,24);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisable(GL_NORMALIZE);
glPopMatrix();
if(g_shaderSys)
g_shaderSys->disableProfiles();
}
bool CgShaderProgramGL::setConstant(const io::stringc &Name, const f32* Buffer, s32 Count)
{
if (!Buffer)
return false;
/* Get top-level parameter */
CGparameter Param = cgGetNamedParameter(cgProgram_, Name.c_str());
if (!Param)
return false;
/* Get array parameter */
if (cgGetParameterType(Param) != CG_ARRAY)
return false;
s32 ArraySize = cgGetArraySize(Param, 0);
for (s32 i = 0; i < ArraySize; ++i)
{
/* Get array element parameter */
CGparameter ElementParam = cgGetArrayParameter(Param, i);
switch (cgGetParameterType(ElementParam))
{
case CG_FLOAT:
cgGLSetParameterArray1f(Param, 0, Count, Buffer);
return true;
case CG_FLOAT2:
cgGLSetParameterArray2f(Param, 0, Count/2, Buffer);
return true;
case CG_FLOAT3:
cgGLSetParameterArray3f(Param, 0, Count/3, Buffer);
return true;
case CG_FLOAT4:
cgGLSetParameterArray4f(Param, 0, Count/4, Buffer);
return true;
case CG_FLOAT4x4:
cgGLSetMatrixParameterArrayfc(Param, 0, Count/16, Buffer);
return true;
case CG_STRUCT:
{
/* Get structure field parameter */
CGparameter FieldParam = cgGetFirstStructParameter(ElementParam);
while (FieldParam)
{
switch (cgGetParameterType(FieldParam))
{
case CG_FLOAT:
cgGLSetParameter1f(FieldParam, *Buffer);
Buffer += 1;
break;
case CG_FLOAT2:
cgGLSetParameter2fv(FieldParam, Buffer);
Buffer += 2;
break;
case CG_FLOAT3:
cgGLSetParameter3fv(FieldParam, Buffer);
Buffer += 3;
break;
case CG_FLOAT4:
cgGLSetParameter4fv(FieldParam, Buffer);
Buffer += 4;
break;
case CG_FLOAT4x4:
cgGLSetMatrixParameterfc(FieldParam, Buffer);
Buffer += 16;
break;
case CG_INT:
cgSetParameter1i(FieldParam, *((s32*)Buffer));
Buffer += 1;
break;
default:
break;
}
FieldParam = cgGetNextParameter(FieldParam);
}
}
break;
default:
break;
}
}
return true;
}
void CgFXPassChunk::updateStateUniforms(DrawEnv *pEnv)
{
CgFXMaterial *pMat = _sfMaterial.getValue();
OSG_ASSERT(pMat != NULL);
CGeffect pEffect = pMat->getEffect ();
UInt32 uiStateVars = pMat->getStateVariables();
const std::string *vStateVarNames = pMat->getStateVarNames ();
UInt32 uiMask = 0x0001;
OSG_ASSERT(pEffect != NULL);
Matrix mObj2World = pEnv->getObjectToWorld();
std::string szTmp;
for(UInt32 i = 0; i < CgFXMaterial::NumStateVars; ++i)
{
if(uiStateVars == 0x0000)
break;
switch(uiStateVars & uiMask)
{
case CgFXMaterial::CgProjectionMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgProjection].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(
pMatrixParam,
pEnv->_openGLState.getProjection().getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc", NULL);
}
break;
case CgFXMaterial::CgModelViewProjectionMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModelViewProjection].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
Matrix mWorld2Scrn = pEnv->getWorldToScreen();
mWorld2Scrn.mult(mObj2World);
cgGLSetMatrixParameterfc(pMatrixParam,
mWorld2Scrn.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
// -------------
// Model | World
// -------------
case CgFXMaterial::CgModelMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModel].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(pMatrixParam,
mObj2World.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgModelIMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModelI].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
Matrix mModelI = mObj2World;
mModelI.invert();
cgGLSetMatrixParameterfc(pMatrixParam,
mModelI.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgModelITMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModelIT].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mModelIT = mObj2World;
mModelIT.invert ();
mModelIT.transpose();
cgGLSetMatrixParameterfc(pMatrixParam,
mModelIT.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
// ---------------------
// ModelView | WorldView
// ---------------------
case CgFXMaterial::CgModelViewMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[CgFXMaterial::CgModelView].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.mult(mObj2World);
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgModelViewIMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[CgFXMaterial::CgModelViewI].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.mult(mObj2World);
mCameraViewing.invert();
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgModelViewITMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[CgFXMaterial::CgModelViewIT].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.mult (mObj2World);
mCameraViewing.invert ( );
mCameraViewing.transpose( );
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
// -------------
// View
// -------------
case CgFXMaterial::CgViewMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgView].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(pMatrixParam,
pEnv->getCameraViewing().getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgViewIMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgViewI].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
OSG::Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.invert();
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgViewITMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgViewIT].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
OSG::Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.invert ();
mCameraViewing.transpose();
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgViewProjectionMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgViewProjection].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(pMatrixParam,
pEnv->getWorldToScreen().getValues());
CgFXMaterial::checkForCgError("cgGLSetMatrixParameterfc",
NULL);
}
break;
case CgFXMaterial::CgTimeMask:
{
CGparameter pTime =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgTime].c_str());
CgFXMaterial::checkForCgError("cgGetNamedEffectParameter",
NULL);
OSG_ASSERT(pTime != NULL);
static const UInt16 MaxLeftDecDigits(4);
// getSystemTime() returns a time value as a 64-bit floating
// point number. But the time value taken by Cg is a 32-bit
// float. This can cause a problem with precision when
// getSystemTime() returns large values, that truncate when cast
// to a 32-bit float.
//
// To deal with this, we are removing the most significant
// decimal digits left of the decimal points after the
// MaxLeftDecDigits one
Time tSysTime(OSG::getSystemTime());
Time tBase10Shift(osgPow<Time>(10, MaxLeftDecDigits));
Time tTruncValue(
tSysTime -
(floor(tSysTime / tBase10Shift) * tBase10Shift));
cgSetParameter1f(pTime, static_cast<Real32>(tTruncValue));
}
break;
default:
break;
};
uiStateVars &= ~uiMask;
uiMask = uiMask << 1;
}
}
void CgfxRenderPassChunk::updateGLMatricies(DrawEnv *pEnv)
{
if( getSemanticParameters() & ((UInt32)(1 << CGFX_MODELVIEWPROJECTION_PARAMETER))) //ok
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ModelViewProjection");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),world2scrn(pEnv->getWorldToScreen());
world2scrn.mult(obj2World);
cgGLSetMatrixParameterfc(theMatrix,world2scrn.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_MODELVIEW_PARAMETER))) //ok?
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ModelView");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),cameraViewing(pEnv->getCameraViewing());
cameraViewing.mult(obj2World);
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_MODELINVERSETRANSPOSE_PARAMETER))) //ok?
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ModelInverseTranspose");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),cameraViewing(pEnv->getCameraViewing());
cameraViewing.mult(obj2World);
cameraViewing.invert();
cameraViewing.transpose();
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_MODELTRANSPOSE_PARAMETER))) //ok?
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ModelTranspose");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),cameraViewing(pEnv->getCameraViewing());
cameraViewing.mult(obj2World);
cameraViewing.transpose();
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_WORLDVIEWPROJECTION_PARAMETER))) // ok
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "WorldViewProjection");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),world2scrn(pEnv->getWorldToScreen());
world2scrn.mult(obj2World);
cgGLSetMatrixParameterfc(theMatrix,world2scrn.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_WORLD_PARAMETER))) //ok?
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "World");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),cameraViewing(pEnv->getCameraViewing());
cameraViewing.mult(obj2World);
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_WORLDINVERSETRANSPOSE_PARAMETER))) //ok?
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "WorldInverseTranspose");
OSG::Matrixr obj2World(pEnv->getObjectToWorld()),cameraViewing(pEnv->getCameraViewing());
cameraViewing.mult(obj2World);
cameraViewing.invert();
cameraViewing.transpose();
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_VIEWINVERSE_PARAMETER)))
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ViewInverse");
OSG::Matrixr cameraViewing(pEnv->getCameraViewing());
cameraViewing.invert();
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_VIEW_PARAMETER)))
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "View");
cgGLSetMatrixParameterfc(theMatrix,pEnv->getCameraViewing().getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_VIEWINVERSETRANSPOSE_PARAMETER)))
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ViewInverseTranspose");
OSG::Matrixr cameraViewing(pEnv->getCameraViewing());
cameraViewing.invert();
cameraViewing.transpose();
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
if(getSemanticParameters() & ((UInt32)(1 << CGFX_VIEWTRANSPOSE_PARAMETER)))
{
CGparameter theMatrix = cgGetEffectParameterBySemantic(*_mEffect, "ViewTranspose");
OSG::Matrixr cameraViewing(pEnv->getCameraViewing());
cameraViewing.transpose();
cgGLSetMatrixParameterfc(theMatrix,cameraViewing.getValues());
}
}
void CgFXPassChunk::updateStateUniforms(DrawEnv *pEnv)
{
CgFXMaterial *pMat = _sfMaterial.getValue();
OSG_ASSERT(pMat != NULL);
CGeffect pEffect = pMat->getEffect ();
UInt32 uiStateVars = pMat->getStateVariables();
const std::string *vStateVarNames = pMat->getStateVarNames ();
UInt32 uiMask = 0x0001;
OSG_ASSERT(pEffect != NULL);
Matrix mObj2World = pEnv->getObjectToWorld();
std::string szTmp;
for(UInt32 i = 0; i < CgFXMaterial::NumStateVars; ++i)
{
if(uiStateVars == 0x0000)
break;
switch(uiStateVars & uiMask)
{
case CgFXMaterial::CgProjectionMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgProjection].c_str());
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(
pMatrixParam,
pEnv->_openGLState.getProjection().getValues());
}
break;
case CgFXMaterial::CgModelViewProjectionMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModelViewProjection].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mWorld2Scrn = pEnv->getWorldToScreen();
mWorld2Scrn.mult(mObj2World);
cgGLSetMatrixParameterfc(pMatrixParam,
mWorld2Scrn.getValues());
}
break;
// -------------
// Model | World
// -------------
case CgFXMaterial::CgModelMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModel].c_str());
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(pMatrixParam,
mObj2World.getValues());
}
break;
case CgFXMaterial::CgModelIMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModelI].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mModelI = mObj2World;
mModelI.invert();
cgGLSetMatrixParameterfc(pMatrixParam,
mModelI.getValues());
}
break;
case CgFXMaterial::CgModelITMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgModelIT].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mModelIT = mObj2World;
mModelIT.invert ();
mModelIT.transpose();
cgGLSetMatrixParameterfc(pMatrixParam,
mModelIT.getValues());
}
break;
// ---------------------
// ModelView | WorldView
// ---------------------
case CgFXMaterial::CgModelViewMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[CgFXMaterial::CgModelView].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.mult(mObj2World);
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
}
break;
case CgFXMaterial::CgModelViewIMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[CgFXMaterial::CgModelViewI].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.mult(mObj2World);
mCameraViewing.invert();
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
}
break;
case CgFXMaterial::CgModelViewITMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[CgFXMaterial::CgModelViewIT].c_str());
OSG_ASSERT(pMatrixParam != NULL);
Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.mult (mObj2World);
mCameraViewing.invert ( );
mCameraViewing.transpose( );
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
}
break;
// -------------
// View
// -------------
case CgFXMaterial::CgViewMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgView].c_str());
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(pMatrixParam,
pEnv->getCameraViewing().getValues());
}
break;
case CgFXMaterial::CgViewIMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgViewI].c_str());
OSG_ASSERT(pMatrixParam != NULL);
OSG::Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.invert();
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
}
break;
case CgFXMaterial::CgViewITMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgViewIT].c_str());
OSG_ASSERT(pMatrixParam != NULL);
OSG::Matrix mCameraViewing = pEnv->getCameraViewing();
mCameraViewing.invert ();
mCameraViewing.transpose();
cgGLSetMatrixParameterfc(pMatrixParam,
mCameraViewing.getValues());
}
break;
case CgFXMaterial::CgViewProjectionMask:
{
CGparameter pMatrixParam =
cgGetNamedEffectParameter(
pEffect,
vStateVarNames[
CgFXMaterial::CgViewProjection].c_str());
OSG_ASSERT(pMatrixParam != NULL);
cgGLSetMatrixParameterfc(pMatrixParam,
pEnv->getWorldToScreen().getValues());
}
break;
default:
break;
};
uiStateVars &= ~uiMask;
uiMask = uiMask << 1;
}
}
void OGLShader::setParameter(const std::string name, const glm::mat4 value){
cgGLSetMatrixParameterfc(getParameter(name), glm::value_ptr(value));
}
