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 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 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 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 Cg::SetParameter(CGparameter param,float* f){
if (param != NULL)
cgGLSetParameter3fv(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 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);
}
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;
}
}
// 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();
}
