void DoBlur(unsigned int uiSrcTex, unsigned int uiTargetTex, int srcTexWidth, int srcTexHeight, int destTexWidth, int destTexHeight, float xofs, float yofs)
{
cgGLBindProgram(g_cgVP_GlowBlur);
cgGLBindProgram(g_cgFP_GlowBlur);
pglActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);
pglActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);
pglActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);
pglActiveTextureARB(GL_TEXTURE3_ARB);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiSrcTex);
cgGLSetParameter1f(g_cgpVP1_XOffset, xofs);
cgGLSetParameter1f(g_cgpVP1_YOffset, yofs);
glViewport(0, 0, destTexWidth, destTexHeight);
DrawQuad(srcTexWidth, srcTexHeight);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, uiTargetTex);
glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, destTexWidth, destTexHeight, 0);
}
void ESVideo::Initialize ()
{
ESVideoPlatform::Initialize(ScreenWidth, ScreenHeight);
UIShader = new LibESGL::Program(vert, frag, false, false);
UIShader->Use();
#ifdef GLSL_IS_MY_FRIEND
glUniform1f(UIShader->ObtainToken("screenWidth"), ScreenWidth);
glUniform1f(UIShader->ObtainToken("screenHeight"), ScreenHeight);
glUniform1i(UIShader->ObtainToken("tex"), 0);
#else
cgGLSetParameter1f((CGparameter)UIShader->ObtainToken("screenWidth"), ScreenWidth);
cgGLSetParameter1f((CGparameter)UIShader->ObtainToken("screenHeight"), ScreenHeight);
#endif
//Some settings
InitializeState();
// Setup vertex buffer
VertexBuffer = (GLfloat*)malloc(VertexBufferCount * VertexSize * sizeof(GLfloat));
ApplyVertexBuffer(VertexBuffer);
//Texture for FillRectangle
FillerTexture = new Texture(2, 2);
FillerTexture->Clear(0xFFFFFFFF);
//Init framebuffer
glGenFramebuffersEXT(1, &FrameBufferID); glSplat();
}
void cgtk::raycasting_pass()
{
disable_renderbuffers();
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_RECTANGLE_ARB,final_image,0);
//glClearColor(0,0,0,0);
//glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
cgGLEnableProfile(vertexProfile);
cgGLEnableProfile(fragmentProfile);
cgGLBindProgram(vertex_main);
cgGLBindProgram(fragment_main);
cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"stepsize"),stepsize);
cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"width"),WINDOW_SIZE_W);
cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"heigth"),WINDOW_SIZE_H);
set_tex_param("tex",backface_buffer,fragment_main,param1);
set_tex_param("volume_tex",volume_texture,fragment_main,param2);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//drawQuads(1,1,1,b);
drawBd();
cgGLDisableProfile(vertexProfile);
cgGLDisableProfile(fragmentProfile);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
}
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();
}
void DepthOfField::UpdateParameters()
{
for(int i = 0; i < DOFSAMPLES; i++)
{
cgGLSetParameter2f(m_CGSamples[i], m_Samples[i].x, m_Samples[i].y);
}
cgGLSetParameter1f(m_BlurSize, m_TweakBlurSize);
cgGLSetParameter1f(m_MinRange, m_TweakMinRange);
cgGLSetParameter1f(m_MaxRange, m_TweakMaxRange);
}
void setCgParams(){
if( ModelViewProjParam != NULL )
cgGLSetStateMatrixParameter( ModelViewProjParam,
CG_GL_MODELVIEW_PROJECTION_MATRIX,
CG_GL_MATRIX_IDENTITY );
if( LightAngle != NULL )
cgGLSetParameter1f( LightAngle, degrees );
if( LightY != NULL )
cgGLSetParameter1f( LightY, ypos );
}
void Cluster::draw ()
{
glColor3fv(d->color);
cgGLEnableClientState(d->shader.v0);
cgGLSetParameter1f(d->shader.t, d->age);
cgGLSetParameter1f(d->shader.nt, d->age/d->lifetime);
cgGLSetParameterPointer(d->shader.v0, 3, GL_FLOAT, sizeof(btVector3),
d->initialVelocities[0]);
cgGLSetParameter3fv(d->shader.origin, d->origin);
cgGLSetParameter3fv(d->shader.eye, scene->camera()->position());
glDrawArrays(GL_POINTS, 0, d->starCount);
cgGLDisableClientState(d->shader.v0);
}
void Cg::SetParameter(CGparameter param,float f){
if (param != NULL)
cgGLSetParameter1f(param, f);
else
{
cout<<"CGparameter is null"<<endl;
abort();
}
CheckCgError();
}
void Bvh::setGPUParameters( CShader& l_Shader, GPUAccelerationStructureData& l_ASD )
{
#ifndef STUB
CGparameter& v0 = l_Shader.GetNamedParameter("v0t", true);
cgGLSetTextureParameter(v0, l_ASD.m_VertexTexture[0]);
CGparameter& v1 = l_Shader.GetNamedParameter("v1t", true);
cgGLSetTextureParameter(v1, l_ASD.m_VertexTexture[1]);
CGparameter& v2 = l_Shader.GetNamedParameter("v2t", true);
cgGLSetTextureParameter(v2, l_ASD.m_VertexTexture[2]);
//l_ASD.SaveTextureData( "v0t.txt", l_ASD.m_VertexTexture[0] );
//l_ASD.SaveTextureData( "v1t.txt", l_ASD.m_VertexTexture[1] );
//l_ASD.SaveTextureData( "v2t.txt", l_ASD.m_VertexTexture[2] );
CGparameter& maxindex = l_Shader.GetNamedParameter("maxIndex");
cgGLSetParameter1f( maxindex, (float)m_NodeUsed );
CGparameter& maxloop = l_Shader.GetNamedParameter("looplimit");
cgGLSetParameter1f( maxloop, 2500.0f );
#endif
}
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 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 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);
}
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;
}
static void gl_cg_set_uniform_parameter(
void *data,
struct uniform_info *param,
void *uniform_data)
{
CGparameter location;
cg_shader_data_t *cg = (cg_shader_data_t*)data;
if (!param || !param->enabled)
return;
if (param->lookup.enable)
{
char ident[64];
CGprogram prog = 0;
switch (param->lookup.type)
{
case SHADER_PROGRAM_VERTEX:
prog = cg->prg[param->lookup.idx].vprg;
break;
case SHADER_PROGRAM_FRAGMENT:
default:
prog = cg->prg[param->lookup.idx].fprg;
break;
}
if (param->lookup.add_prefix)
snprintf(ident, sizeof(ident), "IN.%s", param->lookup.ident);
location = cgGetNamedParameter(prog, param->lookup.add_prefix ? ident : param->lookup.ident);
}
else
{
struct uniform_cg *cg_param = (struct uniform_cg*)uniform_data;
location = cg_param->loc;
}
switch (param->type)
{
case UNIFORM_1F:
cgGLSetParameter1f(location, param->result.f.v0);
break;
case UNIFORM_2F:
cgGLSetParameter2f(location, param->result.f.v0, param->result.f.v1);
break;
case UNIFORM_3F:
cgGLSetParameter3f(location, param->result.f.v0, param->result.f.v1,
param->result.f.v2);
break;
case UNIFORM_4F:
cgGLSetParameter4f(location, param->result.f.v0, param->result.f.v1,
param->result.f.v2, param->result.f.v3);
break;
case UNIFORM_1FV:
cgGLSetParameter1fv(location, param->result.floatv);
break;
case UNIFORM_2FV:
cgGLSetParameter2fv(location, param->result.floatv);
break;
case UNIFORM_3FV:
cgGLSetParameter3fv(location, param->result.floatv);
break;
case UNIFORM_4FV:
cgGLSetParameter3fv(location, param->result.floatv);
break;
case UNIFORM_1I:
/* Unimplemented - Cg limitation */
break;
}
}
void Effect::setParam( const char *_name, float _x ) {
CGparameter param = cgGetNamedEffectParameter( effect, _name );
cgGLSetParameter1f( param, _x );
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
// cgGLSetParameter1f(cgGetNamedParameter(julia, "zoom"), zoom);
// cgGLSetParameter2f(cgGetNamedParameter(julia, "zc"), centerX, centerY);
// cgGLSetParameter2f(cgGetNamedParameter(julia, "c"), mouseX, mouseY);
// cgGLSetParameter2f(cgGetNamedParameter(ship, "c"), mouseX, mouseY);
// cgGLSetParameter2f(cgGetNamedParameter(ship, "zc"), centerX, centerY);
// cgGLSetParameter1f(cgGetNamedParameter(ship, "delta"), 5*delta);
// cgGLSetParameter1f(cgGetNamedParameter(ship, "zoom"), zoom);
// cgGLSetParameter1f(cgGetNamedParameter(newton, "zoom"), zoom);
// cgGLSetParameter2f(cgGetNamedParameter(newton, "f"), mouseX, mouseY);
// cgGLSetParameter2f(cgGetNamedParameter(newton, "zc"), centerX, centerY);
// cgGLSetParameter1f(cgGetNamedParameter(mandel, "zoom"), zoom);
// cgGLSetParameter2f(cgGetNamedParameter(mandel, "zc"), centerX, centerY);
// cgGLSetParameter1f(cgGetNamedParameter(gen, "zoom"), zoom);
// cgGLSetParameter2f(cgGetNamedParameter(gen, "zc"), centerX, centerY);
// cgGLSetParameter1f(cgGetNamedParameter(gen, "var1"), var1);
// cgGLSetParameter1f(cgGetNamedParameter(gen, "var2"), var2);
/*
//General shader viewer
cgGLBindProgram(newton);
glBegin(GL_QUADS);
glVertex2f(-1, -1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glVertex2f(-1, 1);
glEnd();
cgGLDisableProgramProfiles(newton);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD_EXT);
cgGLBindProgram(gen);
glBegin(GL_QUADS);
glVertex2f(-1, -1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glVertex2f(-1, 1);
glEnd();
glDisable(GL_BLEND);
*/
//DEMO
cgGLSetParameter1f(cgGetNamedParameter(gen, "zoom"), zoom);
cgGLSetParameter2f(cgGetNamedParameter(gen, "zc"), centerX, centerY);
cgGLSetParameter1f(cgGetNamedParameter(gen, "var1"), var1);
cgGLSetParameter1f(cgGetNamedParameter(gen, "var2"), var2);
glBegin(GL_QUADS);
glVertex2f(-1, -1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glVertex2f(-1, 1);
glEnd();
/*
//Mandelbrot viewer with mini Julia set
cgGLBindProgram(julia);
glBegin(GL_QUADS);
glVertex2f(-1, -1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glVertex2f(-1, 1);
glEnd();
cgGLSetParameter1f(cgGetNamedParameter(pass, "startX"), 0.25);
cgGLSetParameter1f(cgGetNamedParameter(pass, "endX"), 1);
cgGLSetParameter1f(cgGetNamedParameter(pass, "startY"), -0.25);
cgGLSetParameter1f(cgGetNamedParameter(pass, "endY"), -1);
cgGLBindProgram(julia);
glBegin(GL_QUADS);
glVertex2f(0.25, -0.25);
glVertex2f(1, -0.25);
glVertex2f(1, -1);
glVertex2f(0.25, -1);
glEnd();
*/
/*
//Julia and Newton quads
cgGLBindProgram(julia);
glBegin(GL_QUADS);
glVertex2f(-1, -1);
glVertex2f(-1, 0);
glVertex2f(0, 0);
glVertex2f(0, -1);
glVertex2f(0, 0);
glVertex2f(1, 0);
glVertex2f(1, 1);
glVertex2f(0, 1);
glEnd();
cgGLBindProgram(newton);
glBegin(GL_QUADS);
glVertex2f(-1, 0);
glVertex2f(0, 0);
glVertex2f(0, 1);
glVertex2f(-1, 1);
glVertex2f(0, 0);
glVertex2f(1, 0);
glVertex2f(1, -1);
glVertex2f(0, -1);
glEnd();
*/
/*
//Interactive Newton
cgGLBindProgram(newton);
cgGLSetParameter1f(cgGetNamedParameter(newton, "delta"), 0.0);
cgGLSetParameter1f(cgGetNamedParameter(newton, "fx"), mouseX);
cgGLSetParameter1f(cgGetNamedParameter(newton, "fy"), mouseY);
glBegin(GL_QUADS);
glVertex2f(-1, -1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glVertex2f(-1, 1);
glEnd();
*/
glutSwapBuffers();
}
int main( int argc, char **argv )
{
//Initialize Window
glutInit( &argc, argv );
glutInitWindowSize(winSze, winSze);
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("Fractal Shader");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMotionFunc(mouseMove);
glutMouseFunc(mouseAction);
glutIdleFunc(OnIdle);
glutKeyboardFunc(keyAction);
glutKeyboardUpFunc(keyUp);
glClearColor(0, 0, 0, 1);
context = cgCreateContext();
if(context == NULL){
printf("Failed to create CGcontext\n");
return 1;
}
//Profile set-up
f_prof = cgGLGetLatestProfile(CG_GL_FRAGMENT);
v_prof = cgGLGetLatestProfile(CG_GL_VERTEX);
cgGLEnableProfile(f_prof);
cgGLEnableProfile(v_prof);
/*
printf("%d, %d\n", f_prof, v_prof);
julia = cgCreateProgramFromFile(context, CG_SOURCE, "Julia.cg", f_prof, "main", NULL);
newton = cgCreateProgramFromFile(context, CG_SOURCE, "Newton.cg", f_prof, "main", NULL);
mandel = cgCreateProgramFromFile(context, CG_SOURCE, "Mandel.cg", f_prof, "main", NULL);
ship = cgCreateProgramFromFile(context, CG_SOURCE, "Ship.cg", f_prof, "main", NULL);
pass = cgCreateProgramFromFile(context, CG_SOURCE, "Pass.cg", v_prof, "main", NULL);
gen = cgCreateProgramFromFile(context, CG_SOURCE, "GenIter.cg", f_prof, "main", NULL);
printf("%s\n", cgGetErrorString(cgGetError()));
cgGLLoadProgram(julia);
cgGLLoadProgram(newton);
cgGLLoadProgram(mandel);
cgGLLoadProgram(ship);
cgGLLoadProgram(gen);
cgGLLoadProgram(pass);
//printf("%s\n", cgGetErrorString(cgGetError()));
cgGLEnableProfile(f_prof);
cgGLEnableProfile(v_prof);
printf("%s\n", cgGetErrorString(cgGetError()));
*/
//Use throughput vertex shader
chdir("/Users/peter/Desktop/CGDemo");
pass = cgCreateProgramFromFile(context, CG_SOURCE, "Pass.cg", v_prof, "main", NULL);
cgGLLoadProgram(pass);
cgGLBindProgram(pass);
cgGLSetParameter1f(cgGetNamedParameter(pass, "startX"), -1);
cgGLSetParameter1f(cgGetNamedParameter(pass, "endX"), 1);
cgGLSetParameter1f(cgGetNamedParameter(pass, "startY"), -1);
cgGLSetParameter1f(cgGetNamedParameter(pass, "endY"), 1);
//Pick scenes
curScene1 = 0;
curScene2 = 1;
numScenes = 6;
newScenes(curScene1, curScene2);
//Randomize point list
/*
srand(time(NULL));
//printf("%d\n", rand() % posLen);
int pos1, pos2;
Position p;
for(int i = 0; i < 100; i++){
pos1 = rand() % posLen;
pos2 = rand() % posLen;
p = posList[pos1];
posList[pos1] = posList[pos2];
posList[pos2] = p;
}
while(!isWellOrdered(posList)){
pos1 = rand() % posLen;
pos2 = rand() % posLen;
p = posList[pos1];
posList[pos1] = posList[pos2];
posList[pos2] = p;
}
*/
//cgGLBindProgram(gen);
if(posLen > 0){
Position pos = posList[0];
centerX = pos.px;
centerY = pos.py;
zoom = pos.z;
var1 = pos.v1;
}
glutMainLoop();
return 0;
}
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 IOGLBaseShader::SetUniform(const CString& strName, const float fValue){
cgGLSetParameter1f(this->GetParameter(strName), fValue);
}
