void RenderMethod_PhongPoint_CG::setShaderData(const GeometryChunk &gc) {
const Renderer::Light &light0 = renderer->getLight();
ASSERT(light0.type == Renderer::Light::POINT, "point lights only pls");
mat4 MI = (gc.transformation).inverse(); // world -> object projection
// Set the position of the light (in object-space)
vec3 LightPosObj = MI.transformVector(light0.position);
cgGLSetParameter3fv(cgLightPos, LightPosObj);
// Set the position of the camera (in object-space)
vec3 CameraPosWld = renderer->getCamera().getPosition();
vec3 CameraPosObj = MI.transformVector(CameraPosWld);
cgGLSetParameter3fv(cgCameraPos, CameraPosObj);
// Set the light properties
cgGLSetParameter1fv(cgkC, &light0.kC);
cgGLSetParameter1fv(cgkL, &light0.kL);
cgGLSetParameter1fv(cgkQ, &light0.kQ);
// Set the material properties
cgGLSetParameter4fv(cgKa, gc.material.Ka);
cgGLSetParameter4fv(cgKd, gc.material.Kd);
cgGLSetParameter4fv(cgKs, gc.material.Ks);
cgGLSetParameter1fv(cgShininess, &gc.material.shininess);
// Everything else
cgGLSetStateMatrixParameter(cgMVP, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(cgView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
}
void RenderMethod_TerrainPhong_CG::setShaderData(const GeometryChunk &gc) {
ASSERT(renderer, "Null pointer");
const Renderer::Light &light0 = renderer->getLight();
ASSERT(light0.type == Renderer::Light::DIRECTIONAL, "dir lights only pls");
mat4 MI = (gc.transformation).inverse(); // world -> object projection
// Set the direction of the light (in object-space)
vec3 LightDirObj = MI.transformVector(light0.direction.getNormal());
cgGLSetParameter3fv(cgLightDir, LightDirObj);
// Set the position of the camera (in object-space)
vec3 CameraPosWld = renderer->getCamera().getPosition();
vec3 CameraPosObj = MI.transformVector(CameraPosWld);
cgGLSetParameter3fv(cgCameraPos, CameraPosObj);
// Set the material properties
cgGLSetParameter4fv(cgKa, gc.material.Ka);
cgGLSetParameter4fv(cgKd, gc.material.Kd);
// Everything else
cgGLSetStateMatrixParameter(cgMVP, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(cgView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
}
void ShaderCG::preRender(Renderer* renderer)
{
#ifdef HAS_CG
if (!use_cg) return;
cgGLEnableProfile(profile_vertex);
cgGLEnableProfile(profile_fragment);
cgGLBindProgram(program_vertex);
cgGLBindProgram(program_fragment);
if(g_modelViewProjMatrix != NULL)
cgGLSetStateMatrixParameter(g_modelViewProjMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
if(g_modelViewMatrix != NULL)
cgGLSetStateMatrixParameter(g_modelViewMatrix, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
if(g_modelViewMatrixI != NULL)
cgGLSetStateMatrixParameter(g_modelViewMatrixI, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE);
if(g_modelViewMatrixIT != NULL)
cgGLSetStateMatrixParameter(g_modelViewMatrixIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
Light light;
renderer->getLight(&light, 0);
if(g_lightDiffuse != NULL)
cgGLSetParameter4fv(g_lightDiffuse, light.getDiffuse());
if(g_lightPosition != NULL)
cgGLSetParameter4fv(g_lightPosition, light.getPos());
/*
if(g_lightAmbiente != NULL)
cgGLSetParameter4fv(g_lightAmbiente, light.getAmbiente());
if(g_lightSpecular != NULL)
cgGLSetParameter4fv(g_lightSpecular, light.getSpecular());
*/
ErrorCheck();
glDisable(GL_LIGHTING);
#endif // HAS_CG
}
void RenderMethod_Grass_CG::setShaderData(const GeometryChunk &gc) {
const Renderer::Light &light0 = renderer->getLight();
ASSERT(light0.type == Renderer::Light::POINT, "point lights only pls");
mat4 MI = (gc.transformation).inverse(); // world -> object projection
// Set the position of the light (in object-space)
vec3 LightPosObj = MI.transformVector(light0.position);
cgGLSetParameter3fv(cgLightPos, LightPosObj);
// Set the position of the camera (in object-space)
vec3 CameraPosWld = renderer->getCamera().getPosition();
vec3 CameraPosObj = MI.transformVector(CameraPosWld);
cgGLSetParameter3fv(cgCameraPos, CameraPosObj);
// Send the inverse view matrix
mat4 ViewI = getViewI();
cgGLSetMatrixParameterfr(cgViewI, ViewI);
// Send the camera right vector (in object-space)
vec3 CameraRightEye = vec3(1.0, 0.0, 0.0);
vec3 CameraRightObj = ViewI.transformVector(CameraRightEye);
cgGLSetParameter3fv(cgCameraRight, CameraRightObj);
// Send the camera right vector (in object-space)
vec3 CameraUpEye = vec3(0.0, 1.0, 0.0);
vec3 CameraUpObj = ViewI.transformVector(CameraUpEye);
cgGLSetParameter3fv(cgCameraUp, CameraUpObj);
// Set the light properties
cgGLSetParameter1fv(cgkC, &light0.kC);
cgGLSetParameter1fv(cgkL, &light0.kL);
cgGLSetParameter1fv(cgkQ, &light0.kQ);
// Set the material properties
cgGLSetParameter4fv(cgKa, gc.material.Ka);
cgGLSetParameter4fv(cgKd, gc.material.Kd);
// Set animation time
cgGLSetParameter1fv(cgTime, &angle);
// Everything else
cgGLSetStateMatrixParameter(cgMVP, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(cgView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
}
void ParticleShaderDiskDevelop::drawParticle(int i)
{
cgGLEnableProfile(vProfile);
cgGLEnableProfile(fProfile);
cgGLBindProgram(vProgram);
bindCGParametersVertex();
bindCGParametersFragment();
cgGLBindProgram(fProgram);
GLfloat lightpos[4];
glGetLightfv(GL_LIGHT0, GL_POSITION, lightpos);
cgGLSetParameter4fv(lightPositionEC, lightpos);
// Pull the diffuse color
GLfloat diff[4];
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
// Set the disk center
GLfloat dC[3] = {0.0, 0.0, 0.0};
// Get the radius
if (radius_data)
radius = (*radius_data)[i];
else
radius = 1.0;
// Set the per-particle Cg parameters
cgGLSetParameter3fv(diskCenterWC, dC);
cgGLSetParameter4fv(diffuseColor, diff);
cgGLSetParameter1f(diskRadius, GLfloat(radius * scale));
cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
gluDisk(quad,0,radius*scale*1.51,4,4);
cgGLDisableProfile(vProfile);
cgGLDisableProfile(fProfile);
}
void Cg::SetParameter(CGparameter param,float* f,int elenum){
if (param != NULL)
{
if(elenum == 4)
cgGLSetParameter4fv(param, f);
}
else
{
cout<<"CGparameter is null"<<endl;
abort();
}
CheckCgError();
}
void ParticleShaderVoronoi::drawSecondPass(int i)
{
// push the shader name down
glPushName(0xffffffff);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gmVector3 p = position->getPosition(i);
glTranslatef(p[0],p[1],p[2]);
gmMatrix4 rotMat = orientation->getMatrix(i);
GLdouble mat[16];
rotMat.copyTo(mat);
glMultMatrixd(mat);
//setColor(i);
// Pull the diffuse color
GLfloat diff[4];
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
// Set the disk center
GLfloat dC[3] = {0.0, 0.0, 0.0};
// Get the radius
if (radius_data)
radius = (*radius_data)[i];
else
radius = 1.0;
// Set the per-particle Cg parameters
cgGLSetParameter3fv(diskCenterWC, dC);
cgGLSetParameter4fv(diffuseColor, diff);
cgGLSetParameter1f(diskRadius, GLfloat(radius * scale));
cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
// Now, actually draw the shape
drawShape(i);
glPopMatrix();
glPopName();
}
void SetupVertexProgramParameters(ZZshProgram prog, int context)
{
ZZshParameter p;
p = cgGetNamedParameter(prog, "g_fPosXY");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgConnectParameter(g_vparamPosXY[context], p);
// Set Z-test, log or no log;
if (conf.settings().no_logz) {
g_vdepth = float4( 255.0 /256.0f, 255.0/65536.0f, 255.0f/(65535.0f*256.0f), 1.0f/(65536.0f*65536.0f));
vlogz = float4( 1.0f, 0.0f, 0.0f, 0.0f);
}
else {
g_vdepth = float4( 256.0f*65536.0f, 65536.0f, 256.0f, 65536.0f*65536.0f);
vlogz = float4( 0.0f, 1.0f, 0.0f, 0.0f);
}
p = cgGetNamedParameter(prog, "g_fZ");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE ) {
cgGLSetParameter4fv(p, g_vdepth);
p = cgGetNamedParameter(prog, "g_fZMin"); // Switch to flat-z when needed
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE ) {
//ZZLog::Error_Log("Use flat-z\n");
cgGLSetParameter4fv(p, vlogz);
}
else
ZZLog::Error_Log("Shader file version is outdated! Only log-Z is possible.");
}
float4 vnorm = float4(g_filog32, 0, 0,0);
p = cgGetNamedParameter(prog, "g_fZNorm");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, vnorm);
p = cgGetNamedParameter(prog, "g_fBilinear");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f ));
p = cgGetNamedParameter(prog, "g_fZBias");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(1.0f/256.0f, 1.0004f, 1, 0.5f));
p = cgGetNamedParameter(prog, "g_fc0");
if( p != NULL && cgIsParameterUsed(p, prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(0,1, 0.001f, 0.5f));
}
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 SetupFragmentProgramParameters(FRAGMENTSHADER* pf, int context, int type)
{
// uniform parameters
ZZshParameter p;
p = cgGetNamedParameter(pf->prog, "g_fFogColor");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
cgConnectParameter(g_fparamFogColor, p);
}
SET_UNIFORMPARAM(sOneColor, "g_fOneColor");
SET_UNIFORMPARAM(sBitBltZ, "g_fBitBltZ");
SET_UNIFORMPARAM(sInvTexDims, "g_fInvTexDims");
SET_UNIFORMPARAM(fTexAlpha2, "fTexAlpha2");
SET_UNIFORMPARAM(fTexOffset, "g_fTexOffset");
SET_UNIFORMPARAM(fTexDims, "g_fTexDims");
SET_UNIFORMPARAM(fTexBlock, "g_fTexBlock");
SET_UNIFORMPARAM(fClampExts, "g_fClampExts");
SET_UNIFORMPARAM(fTexWrapMode, "TexWrapMode");
SET_UNIFORMPARAM(fRealTexDims, "g_fRealTexDims");
SET_UNIFORMPARAM(fTestBlack, "g_fTestBlack");
SET_UNIFORMPARAM(fPageOffset, "g_fPageOffset");
SET_UNIFORMPARAM(fTexAlpha, "fTexAlpha");
// textures
p = cgGetNamedParameter(pf->prog, "g_sBlocks");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
cgGLSetTextureParameter(p, ptexBlocks);
cgGLEnableTextureParameter(p);
}
// cg parameter usage is wrong, so do it manually
if( type == 3 ) {
p = cgGetNamedParameter(pf->prog, "g_sConv16to32");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
cgGLSetTextureParameter(p, ptexConv16to32);
cgGLEnableTextureParameter(p);
}
}
else if( type == 4 ) {
p = cgGetNamedParameter(pf->prog, "g_sConv32to16");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
cgGLSetTextureParameter(p, ptexConv32to16);
cgGLEnableTextureParameter(p);
}
}
else {
p = cgGetNamedParameter(pf->prog, "g_sBilinearBlocks");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
cgGLSetTextureParameter(p, ptexBilinearBlocks);
cgGLEnableTextureParameter(p);
}
}
p = cgGetNamedParameter(pf->prog, "g_sMemory");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
//cgGLEnableTextureParameter(p);
pf->sMemory = p;
}
p = cgGetNamedParameter(pf->prog, "g_sSrcFinal");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
//cgGLEnableTextureParameter(p);
pf->sFinal = p;
}
p = cgGetNamedParameter(pf->prog, "g_sBitwiseANDX");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
//cgGLEnableTextureParameter(p);
pf->sBitwiseANDX = p;
}
p = cgGetNamedParameter(pf->prog, "g_sBitwiseANDY");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
//cgGLEnableTextureParameter(p);
pf->sBitwiseANDY = p;
}
p = cgGetNamedParameter(pf->prog, "g_sCLUT");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
//cgGLEnableTextureParameter(p);
pf->sCLUT = p;
}
p = cgGetNamedParameter(pf->prog, "g_sInterlace");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
//cgGLEnableTextureParameter(p);
pf->sInterlace = p;
}
// set global shader constants
p = cgGetNamedParameter(pf->prog, "g_fExactColor");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) {
cgGLSetParameter4fv(p, float4(0.5f, (conf.settings().exact_color)?0.9f/256.0f:0.5f/256.0f, 0,1/255.0f));
}
p = cgGetNamedParameter(pf->prog, "g_fBilinear");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f ));
p = cgGetNamedParameter(pf->prog, "g_fZBias");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(1.0f/256.0f, 1.0004f, 1, 0.5f));
p = cgGetNamedParameter(pf->prog, "g_fc0");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(0,1, 0.001f, 0.5f));
p = cgGetNamedParameter(pf->prog, "g_fMult");
if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE )
cgGLSetParameter4fv(p, float4(1/1024.0f, 0.2f/1024.0f, 1/128.0f, 1/512.0f));
}
void ZZshSetParameter4fv(ZZshProgram& prog, ZZshParameter param, const float* v, const char* name) {
ShaderHandleName = name;
cgGLSetParameter4fv(param, v);
}
// display function
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat translation[3];
cgGLBindProgram(cg_vertex_program);
checkForCgError("binding vertex program");
cgGLEnableProfile(cg_vertex_profile);
checkForCgError("enabling vertex profile");
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gluLookAt(camera_position[0], camera_position[1], camera_position[2], // camera Position
0.0, 0.0, 0.0, // view Center
0.0, 1.0, 0.0); // up vector
cgGLSetParameter3fv(cg_vertex_param_ambient_light, ambient_light);
cgGLSetParameter3fv(cg_vertex_param_light_color, light_color);
cgGLSetParameter4fv(cg_vertex_param_light_position, light_position);
cgGLSetParameter4fv(cg_vertex_param_camera_position, camera_position);
glPushMatrix();
translation[0] = 2.0; translation[1] = 0.0; translation[2] = 0.0;
glTranslatef(translation[0], translation[1], translation[2]);
cgGLSetParameter3fv(cg_vertex_param_translation, translation);
cgGLSetStateMatrixParameter(cg_vertex_param_modelview_proj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
checkForCgError("set parameter modelview_proj");
set_brass_material();
glutSolidSphere(2.0, 30, 30);
glPopMatrix();
glPushMatrix();
translation[0] = -2.0; translation[1] = 0.0; translation[2] = -1.0;
glTranslatef(translation[0], translation[1], translation[2]);
cgGLSetParameter3fv(cg_vertex_param_translation, translation);
cgGLSetStateMatrixParameter(cg_vertex_param_modelview_proj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
checkForCgError("set parameter modelview_proj");
set_plastic_material();
glutSolidCube(3.0);
glPopMatrix();
glPushMatrix();
translation[0] = 0.0; translation[1] = -1.5; translation[2] = 0.0;
glTranslatef(translation[0], translation[1], translation[2]);
cgGLSetParameter3fv(cg_vertex_param_translation, translation);
cgGLSetStateMatrixParameter(cg_vertex_param_modelview_proj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
checkForCgError("set parameter modelview_proj");
set_plane_material();
glBegin(GL_QUADS);
glNormal3f(0.0, 1.0, 0.0);
glVertex3f(-10.0, 0.0, -10.0);
glVertex3f(10.0, 0.0, -10.0);
glVertex3f(10.0, 0.0, 10.0);
glVertex3f(-10.0, 0.0, 10.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(light_position[0], light_position[1], light_position[2]);
cgGLSetParameter3fv(cg_vertex_param_translation, light_position);
cgGLSetStateMatrixParameter(cg_vertex_param_modelview_proj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
checkForCgError("set parameter modelview_proj");
set_light_source_material();
glutSolidSphere(0.2, 10, 10);
glPopMatrix();
glPopMatrix();
cgGLDisableProfile(cg_vertex_profile);
checkForCgError("disabling vertex profile");
glutSwapBuffers();
}
void ParticleShaderVoronoi::drawPost()
{
// Get the viewport dimensions
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
if ((pbufferOne->height != viewport[3]) || (pbufferOne->width != viewport[2]))
{
delete pbufferOne;
setupBuffers(viewport[2], viewport[3]);
}
// Get the light position
GLfloat lightpos[4];
glGetLightfv(GL_LIGHT0, GL_POSITION, lightpos);
// Create storage for matrices
GLfloat mm[16];
GLfloat pm[16];
// If we're not sharing contexts, need to copy state
glGetFloatv(GL_MODELVIEW_MATRIX, mm);
glGetFloatv(GL_PROJECTION_MATRIX, pm);
// Switch to pbufferOne rendering context
if (wglMakeCurrent(pbufferOne->hdc, pbufferOne->hglrc) == FALSE)
pbufferOne->wglGetLastError();
// If we're not sharing contexts, need to update state
if (pbufferOne->onecontext == false) {
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(pm);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(mm);
glEnable(GL_DEPTH_TEST);
}
else {
// Turn off color writes, for better performance
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
}
// Clear the depth texture
glClear(GL_DEPTH_BUFFER_BIT);
cgGLEnableProfile(vProfile);
cgGLEnableProfile(fProfile);
cgGLBindProgram(vProgram);
bindCGParametersVertex();
cgGLBindProgram(fProgramZero);
bindCGParametersFragmentZero();
// Draw into the buffer for the depth texture
for (unsigned int i = 0; i < ps->size(); i++)
drawParticle(i);
// Turn back on color for eventual rendering
if (pbufferOne->onecontext) {
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
cgGLDisableProfile(vProfile);
cgGLDisableProfile(fProfile);
// Switch to normal rendering context
if (wglMakeCurrent(hdc, hglrc) == FALSE)
pbufferOne->wglGetLastError();
// Setup CG
cgGLEnableProfile(vProfile);
cgGLEnableProfile(fProfile);
cgGLBindProgram(vProgram);
bindCGParametersVertex();
bindCGParametersFragmentOne();
cgGLBindProgram(fProgramOne);
// Make the depth texture active
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
glActiveTextureARB(GL_TEXTURE0_ARB);
// Bind the depth texture
glEnable(GL_TEXTURE_RECTANGLE_NV);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, depth_texture);
// Bind pbufferOne as a depth texture
wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)wglGetProcAddress("wglBindTexImageARB");
if (wglBindTexImageARB(pbufferOne->hpbuffer, WGL_DEPTH_COMPONENT_NV) == FALSE)
pbufferOne->wglGetLastError();
cgGLEnableTextureParameter(firstPassDepth);
glActiveTextureARB(GL_TEXTURE1_ARB);
// Set parameters
cgGLSetParameter1f(depthRange, GLfloat(abs(10.0 - 0.5)));
cgGLSetParameter4fv(lightPositionEC, lightpos);
cgGLSetParameter1f(toleranceScaleFactor, GLfloat(toleranceScale));
cgGLSetStateMatrixParameter(viewMatrix, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
// Draw the particles to the screen
for (unsigned int i = 0; i < ps->size(); i++) {
drawSecondPass(i);
}
cgGLDisableTextureParameter(firstPassDepth);
glDisable(GL_TEXTURE_RECTANGLE_NV);
// Release the depth texture
wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)wglGetProcAddress("wglReleaseTexImageARB");
if (wglReleaseTexImageARB(pbufferOne->hpbuffer, WGL_DEPTH_COMPONENT_NV) == false)
pbufferOne->wglGetLastError();
cgGLDisableProfile(vProfile);
cgGLDisableProfile(fProfile);
}
void ObjMeshGPUDeformer::RenderMaster(int masterMode, void * data)
{
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
cgGLEnableProfile(VertexProfile);
if (masterMode == 0)
{
cgGLBindProgram(VertexPass2Program);
if (renderingMode & OBJMESHRENDER_TEXTURE)
{
cgGLEnableProfile(FragmentProfile);
cgGLBindProgram(FragmentPass2Program);
}
cgGLSetStateMatrixParameter(ModelViewProjParam,
CG_GL_MODELVIEW_PROJECTION_MATRIX,
CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(ModelViewITParam,
CG_GL_MODELVIEW_MATRIX,
CG_GL_MATRIX_INVERSE_TRANSPOSE);
cgGLSetParameter4f(LightPos1Param, lightPos[0], lightPos[1], lightPos[2], 1);
cgGLSetParameter4f(LightPos2Param, lightPos[4], lightPos[5], lightPos[6], 1);
cgGLSetParameter4f(LightPos3Param, lightPos[8], lightPos[9], lightPos[10], 1);
cgGLSetParameter4f(LightPos4Param, lightPos[12], lightPos[13], lightPos[14], 1);
cgGLSetParameter1f(Light1IntensityParam, lightIntensity[0]);
cgGLSetParameter1f(Light2IntensityParam, lightIntensity[1]);
cgGLSetParameter1f(Light3IntensityParam, lightIntensity[2]);
cgGLSetParameter1f(Light4IntensityParam, lightIntensity[3]);
cgGLSetParameter1f(AmbientIntensityParam, ambientIntensity);
}
if (masterMode == 1)
{
cgGLBindProgram(VertexPass2ProgramShadow);
cgGLSetStateMatrixParameter(ModelViewProjShadowParam,
CG_GL_MODELVIEW_PROJECTION_MATRIX,
CG_GL_MATRIX_IDENTITY);
double intensity = *(double*)data;
cgGLSetParameter1f(ShadowIntensityParam, intensity);
}
if (renderingMode & OBJMESHRENDER_TEXTURE)
{
cgGLEnableProfile(FragmentProfile);
cgGLBindProgram(FragmentPass2Program);
}
cgGLSetStateMatrixParameter(ModelViewProjParam,
CG_GL_MODELVIEW_PROJECTION_MATRIX,
CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(ModelViewITParam,
CG_GL_MODELVIEW_MATRIX,
CG_GL_MATRIX_INVERSE_TRANSPOSE);
cgGLSetParameter4f(LightPos1Param, lightPos[0], lightPos[1], lightPos[2], 1);
cgGLSetParameter4f(LightPos2Param, lightPos[4], lightPos[5], lightPos[6], 1);
cgGLSetParameter4f(LightPos3Param, lightPos[8], lightPos[9], lightPos[10], 1);
cgGLSetParameter4f(LightPos4Param, lightPos[12], lightPos[13], lightPos[14], 1);
cgGLSetParameter1f(Light1IntensityParam, lightIntensity[0]);
cgGLSetParameter1f(Light2IntensityParam, lightIntensity[1]);
cgGLSetParameter1f(Light3IntensityParam, lightIntensity[2]);
cgGLSetParameter1f(Light4IntensityParam, lightIntensity[3]);
cgGLSetParameter1f(AmbientIntensityParam, ambientIntensity);
glBindTexture(GL_TEXTURE_2D, vertexDeformationTextureID);
BindRT();
for(int groupNo=0; groupNo<numGroups; groupNo++)
{
const ObjMesh::Group * groupHandle = mesh->getGroupHandle(groupNo);
int materialIndex = groupHandle->getMaterialIndex();
const ObjMesh::Material * materialHandle = mesh->getMaterialHandle(materialIndex);
float alpha = (float)(materialHandle->getAlpha());
Vec3d Ka = materialHandle->getKa();
float Kav[4] = { (float)Ka[0], (float)Ka[1], (float)Ka[2], alpha };
Vec3d Kd = materialHandle->getKd();
float Kdv[4] = { (float)Kd[0], (float)Kd[1], (float)Kd[2], alpha };
Vec3d Ks = materialHandle->getKs();
float Ksv[4] = { (float)Ks[0], (float)Ks[1], (float)Ks[2], alpha };
float shininess = materialHandle->getShininess();
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Kav);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Kdv);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Ksv);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
float zero[4] = { 0, 0, 0, 0 };
cgGLSetParameter4fv(KaParam, ambientEnabled ? Kav : zero);
cgGLSetParameter4fv(KdParam, diffuseEnabled ? Kdv : zero);
cgGLSetParameter4fv(KsParam, specularEnabled ? Ksv : zero);
cgGLSetParameter1f(shininessParam, shininess);
if ((renderingMode & OBJMESHRENDER_TEXTURE) && (materialHandle->hasTextureFilename()))
{
ObjMeshRender::Texture * textureHandle = meshRender->getTextureHandle(materialIndex);
GLuint tname = textureHandle->getTexture();
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, tname);
glEnable(GL_TEXTURE_2D);
}
#ifdef OBJMESHGPUDEFORMER_USING_VBOS
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+0]);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, 0);
if (vboNormalEnabled[groupNo])
{
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+1]);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, 0);
}
glClientActiveTextureARB(GL_TEXTURE0_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+2]);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, 0);
if (vboTex1Enabled[groupNo])
{
glClientActiveTextureARB(GL_TEXTURE1_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+3]);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, 0);
}
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vboID[5*groupNo+4]);
glDrawElements(GL_TRIANGLES, 3 * numGroupTriangles[groupNo], GL_UNSIGNED_INT, 0);
// turn off VBOs
glDisableClientState(GL_VERTEX_ARRAY);
if (vboNormalEnabled[groupNo])
glDisableClientState(GL_NORMAL_ARRAY);
glClientActiveTextureARB(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if (vboTex1Enabled[groupNo])
{
glClientActiveTextureARB(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
#else
glCallList(displayListStart + groupNo);
#endif
if ((masterMode == 0) && (renderingMode & OBJMESHRENDER_TEXTURE) && (materialHandle->hasTextureFilename()))
{
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
}
UnbindRT();
if ((masterMode == 0) && (renderingMode & OBJMESHRENDER_TEXTURE))
cgGLDisableProfile(FragmentProfile);
cgGLDisableProfile(VertexProfile);
}
void OGLShader::setParameter(const std::string name, const float* value){
cgGLSetParameter4fv(getParameter(name), value);
}
