void InitChromaticTwin2States()
{
//Set up the register combiners
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);
//Disable per-stage constants if we have been using them
if(NV_register_combiners2_supported)
glDisable(GL_PER_STAGE_CONSTANTS_NV);
//Send (1, 0, 0, 0) as constant color 0
GLfloat constant0[]={1.0f, 0.0f, 0.0f, 0.0f};
glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, constant0);
//Combiner 0 does: red(tex0)->spare0.rgb
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_TEXTURE1_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
//Bind vertex program
glBindProgramNV(GL_VERTEX_PROGRAM_NV, chromaticTwin2VP);
//Enable blend to add to first pass
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_BLEND);
}
void SetDecalStates(void)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, decalTexture);
//Set up vertex program
glEnable(GL_VERTEX_PROGRAM_NV);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, decalVertexProgram);
}
void SetLookUpSpecularStates(void)
{
//Set Up Texture Shaders
//Unit 0 - texture 2d with signed normal map
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
if(showBumps)
glBindTexture(GL_TEXTURE_2D, signedNormalMap);
else
glBindTexture(GL_TEXTURE_2D, signedFlatNormalMap);
//Unit 1 - dot product
glActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
//Unit 2 - dot product texture 2d into specular ramp
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D, specularRamp);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_TEXTURE_2D_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
//Unit 3 - texture 2d with normal map (for gloss)
glActiveTextureARB(GL_TEXTURE3_ARB);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
if(showBumps)
glBindTexture(GL_TEXTURE_2D, normalMapTexture);
else
glBindTexture(GL_TEXTURE_2D, flatNormalMap);
glActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_SHADER_NV);
//Set up Register combiners
//1 general combiner
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);
//final combiner outputs texture2*tex3.a
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_TEXTURE2_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glEnable(GL_REGISTER_COMBINERS_NV);
//Set up vertex program
glEnable(GL_VERTEX_PROGRAM_NV);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, lookUpSpecularVertexProgram);
}
void GPUProgram::bindProgram(int unit, unsigned int glProgram) const {
switch (extension) {
case NVIDIA:
bindingTable.nvBind(unit);
glBindProgramNV(unit, glProgram);
break;
case ARB:
bindingTable.arbBind(unit);
glBindProgramARB(unit, glProgram);
break;
}
}
static void Init( void )
{
/* borrowed from an nvidia demo:
* c[0..3] = modelview matrix
* c[4..7] = inverse modelview matrix
* c[32] = light pos
* c[35] = diffuse color
*/
static const char prog[] =
"!!VP1.0\n"
"#Simple transform and diffuse lighting\n"
"\n"
"DP4 o[HPOS].x, c[0], v[OPOS] ; # object x MVP -> clip\n"
"DP4 o[HPOS].y, c[1], v[OPOS] ;\n"
"DP4 o[HPOS].z, c[2], v[OPOS] ;\n"
"DP4 o[HPOS].w, c[3], v[OPOS] ;\n"
"DP3 R1.x, c[4], v[NRML] ; # normal x MV-1T -> lighting normal\n"
"DP3 R1.y, c[5], v[NRML] ;\n"
"DP3 R1.z, c[6], v[NRML] ;\n"
"DP3 R0, c[32], R1 ; # L.N\n"
"MUL o[COL0].xyz, R0, c[35] ; # col = L.N * diffuse\n"
"MOV o[TEX0], v[TEX0];\n"
"END";
if (!glutExtensionSupported("GL_NV_vertex_program")) {
printf("Sorry, this program requires GL_NV_vertex_program");
exit(1);
}
glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1,
strlen(prog), (const GLubyte *) prog);
assert(glIsProgramNV(1));
glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1);
/* Load the program registers */
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
/* Light position */
glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 32, 2, 2, 4, 1);
/* Diffuse material color */
glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 35, 0.25, 0, 0.25, 1);
glEnable(GL_VERTEX_PROGRAM_NV);
glEnable(GL_DEPTH_TEST);
glClearColor(0.3, 0.3, 0.3, 1);
printf("glGetError = %d\n", (int) glGetError());
}
void InitChromaticSingleStates()
{
//Set up the register combiners
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 2);
//Enable per stage constants
glEnable(GL_PER_STAGE_CONSTANTS_NV);
//Send (1, 0, 0, 0) and (0, 1, 0, 0) as combiner 0 constant colors
GLfloat combiner0Constant0[]={1.0f, 0.0f, 0.0f, 0.0f};
glCombinerStageParameterfvNV(GL_COMBINER0_NV, GL_CONSTANT_COLOR0_NV, combiner0Constant0);
GLfloat combiner0Constant1[]={0.0f, 1.0f, 0.0f, 0.0f};
glCombinerStageParameterfvNV(GL_COMBINER0_NV, GL_CONSTANT_COLOR1_NV, combiner0Constant1);
//Send (0, 0, 1, 0) as combiner 1 constant color 0
GLfloat combiner1Constant0[]={0.0f, 0.0f, 1.0f, 0.0f};
glCombinerStageParameterfvNV(GL_COMBINER1_NV, GL_CONSTANT_COLOR0_NV, combiner1Constant0);
//Combiner 0 does: red(tex2)+green(tex1)->spare0.rgb
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE2_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE1_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
//Combiner 1 does: blue(tex0)+spare0.rgb->spare0.rgb
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_SPARE0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO,
GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
//Bind vertex program
glBindProgramNV(GL_VERTEX_PROGRAM_NV, chromaticSingleVP);
}
void SetDiffuseDecalStates(void)
{
//Bind textures
//Unit 0 - normal map
glEnable(GL_TEXTURE_2D);
if(showBumps)
glBindTexture(GL_TEXTURE_2D, normalMapTexture);
else
glBindTexture(GL_TEXTURE_2D, flatNormalMap);
//Unit 1 - normalisation cube map
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
//Unit 2 - decal map
glActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, decalTexture);
glActiveTextureARB(GL_TEXTURE0_ARB);
//Set up Register combiners
//1 general combiner
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);
//combiner 0 does tex0.rgb dot tex1.rgb -> spare0.rgb,
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_TEXTURE1_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE);
//final combiner outputs spare0.rgb*texture2.rgb
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_TEXTURE2_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glEnable(GL_REGISTER_COMBINERS_NV);
//Set up vertex program
glEnable(GL_VERTEX_PROGRAM_NV);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseDecalVertexProgram);
}
void Shader::bind() {
if(old_shader != this) {
if(vertex_target == GL_VERTEX_PROGRAM_ARB) glBindProgramARB(vertex_target,vertex_id);
if(fragment_target == GL_FRAGMENT_PROGRAM_ARB) glBindProgramARB(fragment_target,fragment_id);
else if(fragment_target == GL_FRAGMENT_PROGRAM_NV) glBindProgramNV(fragment_target,fragment_id);
else if(fragment_target == GL_COMBINE) glCallList(fragment_id);
old_shader = this;
}
for(int i = 0; i < num_matrixes; i++) {
glMatrixMode(GL_MATRIX0_ARB + matrixes[i].num);
if(matrixes[i].type == PROJECTION) glLoadMatrixf(Engine::projection);
else if(matrixes[i].type == MODELVIEW) glLoadMatrixf(Engine::modelview);
else if(matrixes[i].type == IMODELVIEW) glLoadMatrixf(Engine::imodelview);
else if(matrixes[i].type == TRANSFORM) glLoadMatrixf(Engine::transform);
else if(matrixes[i].type == ITRANSFORM) glLoadMatrixf(Engine::itransform);
else if(matrixes[i].type == LIGHT_TRANSFORM && Engine::current_light) glLoadMatrixf(Engine::current_light->transform);
}
if(num_matrixes) glMatrixMode(GL_MODELVIEW);
for(int i = 0; i < num_vertex_parameters; i++) {
if(vertex_parameters[i].type == TIME) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::time,Engine::time / 2.0f,Engine::time / 3.0f,Engine::time / 5.0f));
else if(vertex_parameters[i].type == SIN) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(sin(Engine::time),sin(Engine::time / 2.0f),sin(Engine::time / 3.0f),sin(Engine::time / 5.0f)));
else if(vertex_parameters[i].type == COS) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(cos(Engine::time),cos(Engine::time / 2.0f),cos(Engine::time / 3.0f),cos(Engine::time / 5.0f)));
else if(vertex_parameters[i].type == CAMERA) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::camera,1));
else if(vertex_parameters[i].type == ICAMERA) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::itransform * Engine::camera,1));
else if(vertex_parameters[i].type == LIGHT) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,Engine::light);
else if(vertex_parameters[i].type == ILIGHT) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::itransform * vec3(Engine::light),Engine::light.w));
else if(vertex_parameters[i].type == LIGHT_COLOR) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,Engine::light_color);
else if(vertex_parameters[i].type == FOG_COLOR) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,Engine::fog_color);
else if(vertex_parameters[i].type == VIEWPORT) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::viewport[0],Engine::viewport[1],Engine::viewport[2],Engine::viewport[3]));
else if(vertex_parameters[i].type == PARAMETER) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,parameters[vertex_parameters[i].parameter]);
}
for(int i = 0; i < num_fragment_parameters; i++) {
if(vertex_parameters[i].type == TIME) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::time,Engine::time / 2.0f,Engine::time / 3.0f,Engine::time / 5.0f));
else if(vertex_parameters[i].type == SIN) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(sin(Engine::time),sin(Engine::time / 2.0f),sin(Engine::time / 3.0f),sin(Engine::time / 5.0f)));
else if(vertex_parameters[i].type == COS) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(cos(Engine::time),cos(Engine::time / 2.0f),cos(Engine::time / 3.0f),cos(Engine::time / 5.0f)));
else if(fragment_parameters[i].type == CAMERA) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::camera,1));
else if(fragment_parameters[i].type == ICAMERA) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::itransform * Engine::camera,1));
else if(fragment_parameters[i].type == LIGHT) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,Engine::light);
else if(fragment_parameters[i].type == ILIGHT) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::itransform * vec3(Engine::light),Engine::light.w));
else if(fragment_parameters[i].type == LIGHT_COLOR) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,Engine::light_color);
else if(fragment_parameters[i].type == FOG_COLOR) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,Engine::fog_color);
else if(fragment_parameters[i].type == VIEWPORT) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::viewport[0],Engine::viewport[1],Engine::viewport[2],Engine::viewport[3]));
else if(fragment_parameters[i].type == PARAMETER) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,parameters[fragment_parameters[i].parameter]);
}
}
void InitSimpleSingleStates()
{
//Set up the register combiners
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 2);
//Disable per-stage constants if we have been using them
if(NV_register_combiners2_supported)
glDisable(GL_PER_STAGE_CONSTANTS_NV);
//Final combiner does col0*tex1 + (1-col0)*tex0
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_TEXTURE1_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
//Bind vertex program
glBindProgramNV(GL_VERTEX_PROGRAM_NV, simpleSingleVP);
}
void GimRasterizer::begin_frame() {
pbuffer_->Activate() ;
glViewport(0, 0, target()->width(), target()->height()) ;
glMatrixMode(GL_PROJECTION) ;
glLoadIdentity() ;
glMatrixMode(GL_MODELVIEW) ;
glLoadIdentity() ;
glClearColor(0.0, 0.0, 0.0, 1.0) ;
glClearDepth(0.0) ;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ;
glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, fragment_program);
glLoadProgramNV(
GL_FRAGMENT_PROGRAM_NV,
fragment_program,
strlen(fragment_program_source),
(const GLubyte *)fragment_program_source
) ;
glEnable(GL_FRAGMENT_PROGRAM_NV);
}
void SetSinglePassStates(void)
{
//Bind textures
//Unit 0 - normal map
glEnable(GL_TEXTURE_2D);
if(showBumps)
glBindTexture(GL_TEXTURE_2D, normalMapTexture);
else
glBindTexture(GL_TEXTURE_2D, flatNormalMap);
//Unit 1 - normalisation cube map
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
//Unit 2 - normalisation cube map
glActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
//Unit 3 - decal texture
glActiveTextureARB(GL_TEXTURE3_ARB);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, decalTexture);
glActiveTextureARB(GL_TEXTURE0_ARB);
//Set up Register combiners
//3 general combiners
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 4);
//combiner 0 does tex0.rgb dot tex1.rgb -> spare0.rgb,
// tex0.rgb dot tex2.rgb -> spare1.rgb
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_TEXTURE1_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE0_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_TEXTURE2_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_SPARE0_NV, GL_SPARE1_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_TRUE, GL_TRUE, GL_FALSE);
//combiner 1 does spare1.rgb * spare1.rgb -> spare1.rgb
// spare0.rgb * tex3.rgb -> spare0.rgb
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_SPARE1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_SPARE0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV, GL_TEXTURE3_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER1_NV, GL_RGB, GL_SPARE1_NV, GL_SPARE0_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
//combiner 2 does spare1.rgb * spare1.rgb -> spare1.rgb
glCombinerInputNV( GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_B_NV, GL_SPARE1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER2_NV, GL_RGB, GL_SPARE1_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
//combiner 3 does spare1.rgb * spare1.rgb -> spare1.rgb
glCombinerInputNV( GL_COMBINER3_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER3_NV, GL_RGB, GL_VARIABLE_B_NV, GL_SPARE1_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER3_NV, GL_RGB, GL_SPARE1_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
//final combiner outputs spare1.rgb*spare1.rgb*tex0.a+spare0.rgb
//First do spare1.rgb*spare1.rgb in EF multiplier
glFinalCombinerInputNV(GL_VARIABLE_E_NV, GL_SPARE1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_F_NV, GL_SPARE1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
//Now do rest
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_E_TIMES_F_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glEnable(GL_REGISTER_COMBINERS_NV);
//Set up vertex program
glEnable(GL_VERTEX_PROGRAM_NV);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, singlePassVertexProgram);
}
static void Init( void )
{
GLint errno;
GLuint prognum;
char buf[16 * 1024];
GLuint sz;
FILE *f;
if ((f = fopen(filename, "r")) == NULL) {
fprintf(stderr, "couldn't open %s\n", filename);
exit(1);
}
sz = (GLuint) fread(buf, 1, sizeof(buf) - 1, f);
buf[sizeof(buf) - 1] = '\0';
if (!feof(f)) {
fprintf(stderr, "file too long\n");
fclose(f);
exit(1);
}
fclose(f);
fprintf(stderr, "%.*s\n", sz, buf);
if (strncmp( buf, "!!VP", 4 ) == 0) {
glEnable( GL_VERTEX_PROGRAM_NV );
glGenProgramsNV( 1, &prognum );
glBindProgramNV( GL_VERTEX_PROGRAM_NV, prognum );
glLoadProgramNV( GL_VERTEX_PROGRAM_NV, prognum, sz, (const GLubyte *) buf );
assert( glIsProgramNV( prognum ) );
}
else {
glEnable(GL_VERTEX_PROGRAM_ARB);
glGenProgramsARB(1, &prognum);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
sz, (const GLubyte *) buf);
if (glGetError()) {
printf("Program failed to compile:\n%s\n", buf);
printf("Error: %s\n",
(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
exit(1);
}
assert(glIsProgramARB(prognum));
}
errno = glGetError();
printf("glGetError = %d\n", errno);
if (errno != GL_NO_ERROR)
{
GLint errorpos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
printf("errorpos: %d\n", errorpos);
printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
{
const float Ambient[4] = { 0.0, 1.0, 0.0, 0.0 };
const float Diffuse[4] = { 1.0, 0.0, 0.0, 0.0 };
const float Specular[4] = { 0.0, 0.0, 1.0, 0.0 };
const float Emission[4] = { 0.0, 0.0, 0.0, 1.0 };
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Emission);
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglBindProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jlong function_pointer) {
glBindProgramNVPROC glBindProgramNV = (glBindProgramNVPROC)((intptr_t)function_pointer);
glBindProgramNV(target, programID);
}
//draw a frame
void RenderFrame()
{
//Clear buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); //reset modelview matrix
camera.SetupViewMatrix();
glLoadMatrixf(camera.viewMatrix);
//Enable box texture
glEnable(GL_TEXTURE_2D);
//Enable attenuation textures
if(codePath==TEXTURE_ATTEN || codePath==GAUSSIAN_ATTEN)
{
//2D atten
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
//1D atten
glActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_1D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
else if(codePath==PASS_THROUGH_ATTEN) //set up pass through states
{
//enable texture shaders
glEnable(GL_TEXTURE_SHADER_NV);
}
else if(codePath==TEXTURE_3D_ATTEN)
{
//3D atten
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_3D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
//Enable vertex program
glEnable(GL_VERTEX_PROGRAM_NV);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, vertexProgram);
//Send the light's color to primary color
glColor4fv(lightColors[currentLightColor]);
//set the texture matrix
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glTranslatef(0.5f, 0.5f, 0.5f);
glScalef(0.5f, 0.5f, 0.5f);
glScalef(1/lightRadius, 1/lightRadius, 1/lightRadius);
glTranslatef(-lightPosition.x, -lightPosition.y, -lightPosition.z);
glMatrixMode(GL_MODELVIEW);
//Enable register combiners
glEnable(GL_REGISTER_COMBINERS_NV);
//Draw Cube
glDrawArrays(GL_QUADS, 0, 24);
//Disable box texture
glDisable(GL_TEXTURE_2D);
//Disable attenuation textures
if(codePath==TEXTURE_ATTEN || codePath==GAUSSIAN_ATTEN)
{
//2D atten
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
//1D atten
glActiveTextureARB(GL_TEXTURE2_ARB);
glDisable(GL_TEXTURE_1D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
else if(codePath==PASS_THROUGH_ATTEN) //set up pass through states
{
//disable texture shaders
glDisable(GL_TEXTURE_SHADER_NV);
}
else if(codePath==TEXTURE_3D_ATTEN)
{
//3D atten
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_3D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
//Disable vertex program
glDisable(GL_VERTEX_PROGRAM_NV);
//reset the texture matrix
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
//Disable register combiners
glDisable(GL_REGISTER_COMBINERS_NV);
//Draw light in a display list
glColor4fv(lightColors[currentLightColor]);
glTranslatef(lightPosition.x, lightPosition.y, lightPosition.z);
static GLuint sphereList=0;
if(!sphereList)
{
sphereList=glGenLists(1);
glNewList(sphereList, GL_COMPILE);
{
gluSphere(sphere, 0.1f, 24, 12);
}
glEndList();
}
glCallList(sphereList);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
fpsCounter.Update(); //update frames per second counter
glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
window.StartTextMode();
window.Print(0, 28, "FPS: %.2f", fpsCounter.GetFps()); //print the fps
glColor4f(1.0f, 1.0f, 0.0f, 0.0f);
if(codePath==TEXTURE_ATTEN)
window.Print(0, 48, "Using Texture Attenuation");
if(codePath==PASS_THROUGH_ATTEN)
window.Print(0, 48, "Using Pass Through Attenuation");
if(codePath==TEXTURE_3D_ATTEN)
window.Print(0, 48, "Using 3D Texture Attenuation");
if(codePath==GAUSSIAN_ATTEN)
window.Print(0, 48, "Using Gaussian Texture Attenuation");
window.EndTextMode();
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
if(window.isKeyPressed(VK_F1))
{
window.SaveScreenshot();
window.SetKeyReleased(VK_F1);
}
window.SwapBuffers(); //swap buffers
//check for any opengl errors
window.CheckGLError();
//quit if necessary
if(window.isKeyPressed(VK_ESCAPE))
PostQuitMessage(0);
}
//Set up openGL
bool GLInit()
{
//set viewport
int height;
if (window.height==0)
height=1;
else
height=window.height;
glViewport(0, 0, window.width, height); //reset viewport
//set up projection matrix
glMatrixMode(GL_PROJECTION); //select projection matrix
glLoadIdentity(); //reset
gluPerspective(45.0f, (GLfloat)window.width/(GLfloat)height, 1.0f, 100.0f);
//load identity modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//other states
//shading
glShadeModel(GL_SMOOTH);
glClearColor( backgroundColor.r,
backgroundColor.g,
backgroundColor.b,
backgroundColor.a);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//depth
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
//hints
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_CULL_FACE);
//set up sphere
sphere=gluNewQuadric();
//Set up vertex arrays for quad
glVertexPointer(3, GL_FLOAT, 0, vertexPositions);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glEnable(GL_VERTEX_ARRAY);
glEnable(GL_TEXTURE_COORD_ARRAY);
//load vertex program
glGenProgramsNV(1, &vertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, vertexProgram);
LoadNV_vertex_program("vertex program.txt", vertexProgram);
//Set track matrices
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_TEXTURE0_ARB, GL_IDENTITY_NV);
//Set texture atten states
SetTextureAttenStates();
return true;
}
//Render a frame
void RenderFrame(double currentTime, double timePassed)
{
//Clear buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); //reset modelview matrix
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
gluLookAt( 0.0f, 1.8f, 1.8f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0);
//Enable texture
glBindTexture(GL_TEXTURE_2D, floorTexture);
glEnable(GL_TEXTURE_2D);
//Set up vertex arrays
glVertexPointer(3, GL_FLOAT, sizeof(SIMPLE_VERTEX), &vertices[0].position);
glEnableClientState(GL_VERTEX_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(SIMPLE_VERTEX), &vertices[0].normal);
glEnableClientState(GL_NORMAL_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(SIMPLE_VERTEX), &vertices[0].texCoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//Use Fixed Function Pipeline
if(useFixedFunction)
{
//Set parameters for GL lighting
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, white*0.1f); //global ambient
glMaterialfv(GL_FRONT, GL_AMBIENT, white);
glMaterialfv(GL_FRONT, GL_DIFFUSE, white);
glEnable(GL_LIGHTING);
//8 passes, dealing with 8 lights at a time, except final pass where we do 4
for(int i=0; i<8; ++i)
{
int numLightsThisPass=8;
if(i==7)
numLightsThisPass=4;
//Set up lights
for(int j=0; j<numLightsThisPass; ++j)
{
glLightfv(GL_LIGHT0+j, GL_POSITION, VECTOR4D(lights[i*8+j].position));
glLightfv(GL_LIGHT0+j, GL_DIFFUSE, lights[i*8+j].color);
glEnable(GL_LIGHT0+j);
}
//If this is the final pass, disable lights 4-7
if(i==7)
for(int j=4; j<7; ++j)
glDisable(GL_LIGHT0+j);
//Enable additive blend for all passes except the first
if(i!=0)
{
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_BLEND);
//if this is not the first pass, no ambient
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
}
//Draw grid as triangle strips
for(int j=0; j<gridDensity-1; ++j)
glDrawElements( GL_TRIANGLE_STRIP, gridDensity*2,
GL_UNSIGNED_INT, &indices[j*gridDensity*2]);
}
//Disable lights
for(int j=0; j<7; ++j)
glDisable(GL_LIGHT0+j);
glDisable(GL_LIGHTING);
glDisable(GL_BLEND);
}
//Use vp1
if(useVP1)
{
//Bind program
glBindProgramNV(GL_VERTEX_PROGRAM_NV, vp1);
glEnable(GL_VERTEX_PROGRAM_NV);
//3 passes, dealing with 20 lights at a time
for(int i=0; i<3; ++i)
{
//Send ambient brightness as c[4]
//Only send this for the first pass
if(i==0)
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 4, white*0.1f);
else
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 4, black);
//Update program parameters 5&6 for light0, 7&8 for light1, etc
for(int j=0; j<20; ++j)
{
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 2*j+5,
VECTOR4D(lights[i*20+j].position));
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 2*j+6,
lights[i*20+j].color);
}
//Enable additive blend for passes except the first
if(i>0)
{
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_BLEND);
}
//Draw grid as triangle strips
for(int j=0; j<gridDensity-1; ++j)
glDrawElements( GL_TRIANGLE_STRIP, gridDensity*2,
GL_UNSIGNED_INT, &indices[j*gridDensity*2]);
}
glDisable(GL_VERTEX_PROGRAM_NV);
glDisable(GL_BLEND);
}
//Use vp2
if(useVP2)
{
//Bind program
glBindProgramNV(GL_VERTEX_PROGRAM_NV, vp2);
glEnable(GL_VERTEX_PROGRAM_NV);
//Send ambient brightness as c[4]
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 4, white*0.1f);
//Update program parameters 5&6 for light0, 7&8 for light1, etc
for(int j=0; j<60; ++j)
{
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 2*j+5,
VECTOR4D(lights[j].position));
glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 2*j+6,
lights[j].color);
}
//Send loop parameters to c[125]
glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 125, 60.0, //number of lights
5.0, //base offset of light data
-1.0,
2.0);//num parameters between lights
//Draw grid as triangle strips
for(int j=0; j<gridDensity-1; ++j)
glDrawElements( GL_TRIANGLE_STRIP, gridDensity*2,
GL_UNSIGNED_INT, &indices[j*gridDensity*2]);
glDisable(GL_VERTEX_PROGRAM_NV);
}
//reset states
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
fpsCounter.Update();
//Print text
font.StartTextMode();
glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
font.Print(0, 28, "FPS: %.2f", fpsCounter.GetFps());
glColor4f(1.0f, 0.0f, 0.0f, 0.0f);
if(useVP1)
font.Print(0, 48, "Using NV_vertex_program");
if(useVP2)
font.Print(0, 48, "Using NV_vertex_program2");
if(useFixedFunction)
font.Print(0, 48, "Using Fixed Function Pipeline");
font.EndTextMode();
WINDOW::Instance()->SwapBuffers();
//Save a screenshot
if(WINDOW::Instance()->IsKeyPressed(VK_F1))
{
WINDOW::Instance()->SaveScreenshot();
WINDOW::Instance()->SetKeyReleased(VK_F1);
}
//Check for an openGL error
WINDOW::Instance()->CheckGLError();
//quit if necessary
if(WINDOW::Instance()->IsKeyPressed(VK_ESCAPE))
PostQuitMessage(0);
}
//Set up openGL
bool GLInit()
{
//set viewport
int height = 480;
int width = 640;
glViewport(0, 0, width, height); //reset viewport
//set up projection matrix
glMatrixMode(GL_PROJECTION); //select projection matrix
glLoadIdentity(); //reset
gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 1.0f, 100.0f);
//load identity modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//other states
//shading
glShadeModel(GL_SMOOTH);
glClearColor( backgroundColor.r,
backgroundColor.g,
backgroundColor.b,
backgroundColor.a);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//depth
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
//hints
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//Set up vertex arrays for torus
//Fixed 17th November 2002
//Instead of passing tangents as texture coords 1 and 2, use aliased attributes 9 and 10.
//This way, these texture coordinates will reach the vertex program on a geforce 2
//which only has 2 texture units.
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].normal);
//Pass texture coords to unit 0
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s);
//Pass tangent,binormal to attributes 9, 10
glEnableClientState(GL_VERTEX_ATTRIB_ARRAY9_NV);
glVertexAttribPointerNV(9, 3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].sTangent);
glEnableClientState(GL_VERTEX_ATTRIB_ARRAY10_NV);
glVertexAttribPointerNV(10, 3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].tTangent);
//Use compiled vertex arrays
glLockArraysEXT(0, torus.numVertices);
//Load vertex programs
glGenProgramsNV(1, &singlePassVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, singlePassVertexProgram);
LoadNV_vertex_program("single pass vertex program.txt", singlePassVertexProgram);
glGenProgramsNV(1, &diffuseDecalVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseDecalVertexProgram);
LoadNV_vertex_program("diffuse decal vertex program.txt", diffuseDecalVertexProgram);
glGenProgramsNV(1, &lookUpSpecularVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, lookUpSpecularVertexProgram);
LoadNV_vertex_program("look up specular vertex program.txt", lookUpSpecularVertexProgram);
glGenProgramsNV(1, &diffuseVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, diffuseVertexProgram);
LoadNV_vertex_program("diffuse vertex program.txt", diffuseVertexProgram);
glGenProgramsNV(1, &decalVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, decalVertexProgram);
LoadNV_vertex_program("decal vertex program.txt", decalVertexProgram);
glGenProgramsNV(1, &simpleSpecularVertexProgram);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, simpleSpecularVertexProgram);
LoadNV_vertex_program("simple specular vertex program.txt", simpleSpecularVertexProgram);
//Set Tracking Matrix
//Modelview Projection in registers c[0]-c[3]
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
return true;
}
static void Init( void )
{
static const char *fragProgramText =
"!!FP1.0\n"
"DECLARE Diffuse; \n"
"DECLARE Specular; \n"
"DECLARE LightPos; \n"
"# Compute normalized LightPos, put it in R0\n"
"DP3 R0.x, LightPos, LightPos;\n"
"RSQ R0.y, R0.x;\n"
"MUL R0, LightPos, R0.y;\n"
"# Compute normalized normal, put it in R1\n"
"DP3 R1, f[TEX0], f[TEX0]; \n"
"RSQ R1.y, R1.x;\n"
"MUL R1, f[TEX0], R1.y;\n"
"# Compute dot product of light direction and normal vector\n"
"DP3_SAT R2, R0, R1;"
"MUL R3, Diffuse, R2; # diffuse attenuation\n"
"POW R4, R2.x, {20.0}.x; # specular exponent\n"
"MUL R5, Specular, R4; # specular attenuation\n"
"ADD o[COLR], R3, R5; # add diffuse and specular colors\n"
"END \n"
;
static const char *vertProgramText =
"!!VP1.0\n"
"# typical modelview/projection transform\n"
"DP4 o[HPOS].x, c[0], v[OPOS] ;\n"
"DP4 o[HPOS].y, c[1], v[OPOS] ;\n"
"DP4 o[HPOS].z, c[2], v[OPOS] ;\n"
"DP4 o[HPOS].w, c[3], v[OPOS] ;\n"
"# transform normal by inv transpose of modelview, put in tex0\n"
"DP3 o[TEX0].x, c[4], v[NRML] ;\n"
"DP3 o[TEX0].y, c[5], v[NRML] ;\n"
"DP3 o[TEX0].z, c[6], v[NRML] ;\n"
"DP3 o[TEX0].w, c[7], v[NRML] ;\n"
"END\n";
;
if (!glutExtensionSupported("GL_NV_vertex_program")) {
printf("Sorry, this demo requires GL_NV_vertex_program\n");
exit(1);
}
if (!glutExtensionSupported("GL_NV_fragment_program")) {
printf("Sorry, this demo requires GL_NV_fragment_program\n");
exit(1);
}
glGenProgramsNV(1, &FragProg);
assert(FragProg > 0);
glGenProgramsNV(1, &VertProg);
assert(VertProg > 0);
/*
* Fragment program
*/
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, FragProg,
strlen(fragProgramText),
(const GLubyte *) fragProgramText);
assert(glIsProgramNV(FragProg));
glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, FragProg);
NAMED_PARAMETER4FV(FragProg, "Diffuse", Diffuse);
NAMED_PARAMETER4FV(FragProg, "Specular", Specular);
/*
* Vertex program
*/
glLoadProgramNV(GL_VERTEX_PROGRAM_NV, VertProg,
strlen(vertProgramText),
(const GLubyte *) vertProgramText);
assert(glIsProgramNV(VertProg));
glBindProgramNV(GL_VERTEX_PROGRAM_NV, VertProg);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
/*
* Misc init
*/
glClearColor(0.3, 0.3, 0.3, 0.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0);
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
printf("Press p to toggle between per-pixel and per-vertex lighting\n");
}
void Shader::load(const char *name) {
Parser *parser = new Parser(name);
// matrixes
num_matrixes = 0;
for(int i = 0; i < NUM_MATRIXES; i++) {
char buf[1024];
sprintf(buf,"matrix%d",i);
if(parser->get(buf)) {
matrixes[num_matrixes].num = i;
getMatrix(parser->get(buf),&matrixes[num_matrixes]);
num_matrixes++;
}
}
// vertex program local parameters
num_vertex_parameters = 0;
for(int i = 0; i < NUM_LOCAL_PARAMETERS; i++) {
char buf[1024];
sprintf(buf,"vertex_local%d",i);
if(parser->get(buf)) {
vertex_parameters[num_vertex_parameters].num = i;
getLocalParameter(parser->get(buf),&vertex_parameters[num_vertex_parameters]);
num_vertex_parameters++;
}
}
// fragement program local parameters
num_fragment_parameters = 0;
for(int i = 0; i < NUM_LOCAL_PARAMETERS; i++) {
char buf[1024];
sprintf(buf,"fragment_local%d",i);
if(parser->get(buf)) {
fragment_parameters[num_fragment_parameters].num = i;
getLocalParameter(parser->get(buf),&fragment_parameters[num_fragment_parameters]);
num_fragment_parameters++;
}
}
char *data;
// vertex program
vertex_target = 0;
vertex_id = 0;
if((data = parser->get("vertex"))) {
int error = -1;
if(!strncmp(data,"!!ARBvp1.0",10)) {
vertex_target = GL_VERTEX_PROGRAM_ARB;
glGenProgramsARB(1,&vertex_id);
glBindProgramARB(vertex_target,vertex_id);
glProgramStringARB(vertex_target,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(data),data);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&error);
} else {
char *s = data;
while(*s != '\0' && *s != '\n') s++;
*s = '\0';
fprintf(stderr,"Shader::Shader(): unknown vertex program header \"%s\" in \"%s\" file\n",data,name);
}
if(error != -1) {
int line = 0;
char *s = data;
while(error-- && *s) if(*s++ == '\n') line++;
while(s >= data && *s != '\n') s--;
char *e = ++s;
while(*e != '\0' && *e != '\n') e++;
*e = '\0';
fprintf(stderr,"Shader::Shader(): vertex program error in \"%s\" file at line %d:\n\"%s\"\n",name,line,s);
}
}
// fragment program
fragment_target = 0;
fragment_id = 0;
if((data = parser->get("fragment"))) {
int error = -1;
if(!strncmp(data,"!!ARBfp1.0",10)) {
fragment_target = GL_FRAGMENT_PROGRAM_ARB;
glGenProgramsARB(1,&fragment_id);
glBindProgramARB(fragment_target,fragment_id);
glProgramStringARB(fragment_target,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(data),data);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&error);
} else if(!strncmp(data,"!!FP1.0",7)) {
fragment_target = GL_FRAGMENT_PROGRAM_NV;
glGenProgramsNV(1,&fragment_id);
glBindProgramNV(fragment_target,fragment_id);
glLoadProgramNV(fragment_target,fragment_id,strlen(data),(GLubyte*)data);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV,&error);
} else if(!strncmp(data,"!!ARBtec1.0",11)) { // arb texture env combine
fragment_target = GL_COMBINE;
fragment_id = compileARBtec(data);
} else {
char *s = data;
while(*s != '\0' && *s != '\n') s++;
*s = '\0';
fprintf(stderr,"Shader::Shader(): unknown fragment program header \"%s\" in \"%s\" file\n",data,name);
}
if(error != -1) {
int line = 0;
char *s = data;
while(error-- && *s) if(*s++ == '\n') line++;
while(s >= data && *s != '\n') s--;
char *e = ++s;
while(*e != '\0' && *e != '\n') e++;
*e = '\0';
fprintf(stderr,"Shader::Shader(): fragment program error in \"%s\" file at line %d:\n\"%s\"\n",name,line,s);
}
}
delete parser;
}
//Set up openGL
bool GLInit()
{
//set viewport
int height;
if (window.height==0)
height=1;
else
height=window.height;
glViewport(0, 0, window.width, height); //reset viewport
//set up projection matrix
glMatrixMode(GL_PROJECTION); //select projection matrix
glLoadIdentity(); //reset
gluPerspective(45.0f, (GLfloat)window.width/(GLfloat)height, 0.1f, 100.0f);
//load identity modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//other states
//shading
glShadeModel(GL_SMOOTH);
glClearColor( backgroundColor.r,
backgroundColor.g,
backgroundColor.b,
backgroundColor.a);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//depth
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
//hints
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//load vertex programs
glGenProgramsNV(1, &chromaticSingleVP);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, chromaticSingleVP);
LoadNV_vertex_program("chromatic single vp.txt", chromaticSingleVP);
glGenProgramsNV(1, &simpleSingleVP);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, simpleSingleVP);
LoadNV_vertex_program("simple single vp.txt", simpleSingleVP);
glGenProgramsNV(1, &chromaticTwin1VP);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, chromaticTwin1VP);
LoadNV_vertex_program("chromatic twin 1 vp.txt", chromaticTwin1VP);
glGenProgramsNV(1, &chromaticTwin2VP);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, chromaticTwin2VP);
LoadNV_vertex_program("chromatic twin 2 vp.txt", chromaticTwin2VP);
//Set track matrices
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_IDENTITY_NV);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 8, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 12, GL_TEXTURE, GL_IDENTITY_NV);
//Send fresnel multipication factor to c[28]
glProgramParameter4fNV( GL_VERTEX_PROGRAM_NV, 28, fresnel, fresnel, fresnel, 1.0f);
//Send refractive indices to c[32], c[33], c[34]
glProgramParameter4fNV( GL_VERTEX_PROGRAM_NV, 32, index, index*index, 0.0f, 1.0f);
glProgramParameter4fNV( GL_VERTEX_PROGRAM_NV, 33, index+indexDelta,
(index+indexDelta)*(index+indexDelta), 0.0f, 1.0f);
glProgramParameter4fNV( GL_VERTEX_PROGRAM_NV, 34, index+2*indexDelta,
(index+2*indexDelta)*(index+2*indexDelta), 0.0f, 1.0f);
//Send useful constants to c[64]
glProgramParameter4fNV( GL_VERTEX_PROGRAM_NV, 64, 0.0f, 1.0f, 2.0f, 0.5f);
//Init states to begin
if(renderPath==CHROMATIC_SINGLE)
InitChromaticSingleStates();
if(renderPath==SIMPLE_SINGLE)
InitSimpleSingleStates();
return true;
}
void
compile(const char *filename, GLenum target, int use_ARB)
{
GLenum err;
GLuint prognum[2];
char *buf;
char *ptr;
unsigned sz;
int expected_fail;
char *converted_buffers[2];
size_t buffer_sizes[2];
unsigned i;
if (!piglit_automatic) {
printf("%s:\n", filename);
}
buf = piglit_load_text_file(filename, &sz);
if (buf == NULL) {
piglit_report_result(PIGLIT_FAIL);
}
/* Scan the program source looking for two different things. First,
* look for comments of the form '# FAIL'. This signals that the
* program is expected to fail compilation. Second, look for comments
* of the form '# REQUIRE GL_XXX_xxxx_xxxx'. This signals that the
* program will only compile if some OpenGL extension is available.
*/
expected_fail = (strstr(buf, "# FAIL") != NULL);
ptr = buf;
while (ptr != NULL) {
ptr = strstr(ptr, "# REQUIRE ");
if (ptr != NULL) {
char extension[128];
unsigned i;
ptr += strlen("# REQUIRE ");
for (i = 0; !isspace((int) ptr[i]) && (ptr[i] != '\0'); i++) {
extension[i] = ptr[i];
}
extension[i] = '\0';
piglit_require_extension(extension);
}
}
converted_buffers[0] = unix_line_endings(buf, sz);
buffer_sizes[0] = strlen(converted_buffers[0]);
converted_buffers[1] = dos_line_endings(buf, sz);
buffer_sizes[1] = strlen(converted_buffers[1]);
if (use_ARB) {
glEnable(target);
glGenProgramsARB(2, prognum);
} else {
glGenProgramsNV(2, prognum);
}
for (i = 0; i < 2; i++) {
/* The use_ARB flag is used instead of the target because
* GL_VERTEX_PROGRAM_ARB and GL_VERTEX_PROGRAM_NV have the same
* value.
*/
if (use_ARB) {
glBindProgramARB(target, prognum[i]);
glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB,
buffer_sizes[i],
(const GLubyte *) converted_buffers[i]);
} else {
glBindProgramNV(target, prognum[i]);
glLoadProgramNV(target, prognum[i],
buffer_sizes[i],
(const GLubyte *) converted_buffers[i]);
}
err = glGetError();
if (err != GL_NO_ERROR) {
GLint errorpos;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
if (!piglit_automatic) {
printf("glGetError = 0x%04x\n", err);
printf("errorpos: %d\n", errorpos);
printf("%s\n",
(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
}
if ((err == GL_NO_ERROR) != (expected_fail == FALSE)) {
piglit_report_result(PIGLIT_FAIL);
}
}
free(buf);
free(converted_buffers[0]);
free(converted_buffers[1]);
}
/////////////////////////////////////////////////////////
// render
//
/////////////////////////////////////////////////////////
void vertex_program :: LoadProgram(void)
{
if(NULL==m_programString)return;
GLint err=-1;
if((GEM_PROGRAM_NV == m_programType) && (!GLEW_NV_vertex_program)) {
error("NV vertex programs not supported by this system");
return;
}
if((GEM_PROGRAM_ARB == m_programType) && (!GLEW_ARB_vertex_program)) {
error("ARB vertex programs not supported by this system");
return;
}
switch(m_programType) {
case GEM_PROGRAM_NV:
if (m_programID==0)
{
glEnable(m_programTarget);
glGenProgramsNV(1, &m_programID);
glBindProgramNV(m_programTarget, m_programID);
glLoadProgramNV(m_programTarget, m_programID, m_size, (GLubyte*)m_programString);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &err);
} else {
glEnable(m_programTarget);
glBindProgramNV(m_programTarget, m_programID);
return;
}
break;
case GEM_PROGRAM_ARB:
if (m_programID==0)
{
glEnable(m_programTarget);
glGenProgramsARB(1, &m_programID);
glBindProgramARB( m_programTarget, m_programID);
glProgramStringARB( m_programTarget, GL_PROGRAM_FORMAT_ASCII_ARB, m_size, m_programString);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err);
} else {
glEnable(m_programTarget);
glBindProgramARB(m_programTarget, m_programID);
return;
}
break;
default:
return;
}
if(err != -1) {
int line = 0;
char *s = m_programString;
while(err-- && *s) if(*s++ == '\n') line++;
while(s >= m_programString && *s != '\n') s--;
char *e = ++s;
while(*e != '\n' && *e != '\0') e++;
*e = '\0';
error("program error at line %d:\n\"%s\"\n",line,s);
post("%s\n", glGetString(GL_PROGRAM_ERROR_STRING_ARB));
}
if(GLEW_ARB_vertex_program) {
GLint isUnderNativeLimits;
glGetProgramivARB( m_programTarget, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &isUnderNativeLimits);
// If the program is over the hardware's limits, print out some information
if (isUnderNativeLimits!=1)
{
// Go through the most common limits that are exceeded
error("is beyond hardware limits");
GLint aluInstructions, maxAluInstructions;
glGetProgramivARB(m_programTarget, GL_PROGRAM_ALU_INSTRUCTIONS_ARB, &aluInstructions);
glGetProgramivARB(m_programTarget, GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, &maxAluInstructions);
if (aluInstructions>maxAluInstructions)
post("[%s]: Compiles to too many ALU instructions (%d, limit is %d)\n", m_buf.c_str(), aluInstructions, maxAluInstructions);
GLint textureInstructions, maxTextureInstructions;
glGetProgramivARB(m_programTarget, GL_PROGRAM_TEX_INSTRUCTIONS_ARB, &textureInstructions);
glGetProgramivARB(m_programTarget, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, &maxTextureInstructions);
if (textureInstructions>maxTextureInstructions)
post("[%s]: Compiles to too many texture instructions (%d, limit is %d)\n", m_buf.c_str(), textureInstructions, maxTextureInstructions);
GLint textureIndirections, maxTextureIndirections;
glGetProgramivARB(m_programTarget, GL_PROGRAM_TEX_INDIRECTIONS_ARB, &textureIndirections);
glGetProgramivARB(m_programTarget, GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, &maxTextureIndirections);
if (textureIndirections>maxTextureIndirections)
post("[%s]: Compiles to too many texture indirections (%d, limit is %d)\n", m_buf.c_str(), textureIndirections, maxTextureIndirections);
GLint nativeTextureIndirections, maxNativeTextureIndirections;
glGetProgramivARB(m_programTarget, GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, &nativeTextureIndirections);
glGetProgramivARB(m_programTarget, GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, &maxNativeTextureIndirections);
if (nativeTextureIndirections>maxNativeTextureIndirections)
post("[%s]: Compiles to too many native texture indirections (%d, limit is %d)\n", m_buf.c_str(), nativeTextureIndirections, maxNativeTextureIndirections);
GLint nativeAluInstructions, maxNativeAluInstructions;
glGetProgramivARB(m_programTarget, GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, &nativeAluInstructions);
glGetProgramivARB(m_programTarget, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, &maxNativeAluInstructions);
if (nativeAluInstructions>maxNativeAluInstructions)
post("[%s]: Compiles to too many native ALU instructions (%d, limit is %d)\n", m_buf.c_str(), nativeAluInstructions, maxNativeAluInstructions);
}
}
}
void SetSimpleSpecularStates(void)
{
//Bind textures
//Unit 0 - normal map
glEnable(GL_TEXTURE_2D);
if(showBumps)
glBindTexture(GL_TEXTURE_2D, normalMapTexture);
else
glBindTexture(GL_TEXTURE_2D, flatNormalMap);
//Unit 1 - normalisation cube map
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
glActiveTextureARB(GL_TEXTURE0_ARB);
//Set up Register combiners
//2 general combiners
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 2);
//combiner 0 does tex0.rgb dot tex1.rgb -> spare0.rgb,
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_TEXTURE1_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE);
//combiner 1 does 2*((spare0.rgb * spare0.rgb)-0.5) -> spare0.rgb
// spare0.b * tex0.a -> spare0.a
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_SPARE0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV( GL_COMBINER1_NV, GL_RGB, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV,
GL_FALSE, GL_FALSE, GL_FALSE);
glCombinerInputNV( GL_COMBINER1_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_SPARE0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_BLUE);
glCombinerInputNV( GL_COMBINER1_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_TEXTURE0_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glCombinerOutputNV( GL_COMBINER1_NV, GL_ALPHA, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV,
GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
//final combiner outputs spare0.rgb*spare0.rgb*spare0.a
//first do spare0.rgb * spare0.rgb in EF multiplier
glFinalCombinerInputNV(GL_VARIABLE_E_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_F_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_E_TIMES_F_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glEnable(GL_REGISTER_COMBINERS_NV);
//Set up vertex program
glEnable(GL_VERTEX_PROGRAM_NV);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, simpleSpecularVertexProgram);
}
//Set up variables
bool DemoInit()
{
//Seed random number generator
srand( (unsigned)time( NULL ) );
//Initialise the array of vertices
numVertices=gridDensity*gridDensity;
vertices=new SIMPLE_VERTEX[numVertices];
if(!vertices)
{
LOG::Instance()->OutputError("Unable to allocate space for %d vertices", numVertices);
return false;
}
for(int i=0; i<gridDensity; ++i)
{
for(int j=0; j<gridDensity; ++j)
{
vertices[i*gridDensity+j].position.Set( (float(i)/(gridDensity-1))*2-1,
0.0f,
(float(j)/(gridDensity-1))*2-1);
vertices[i*gridDensity+j].normal.Set( 0.0f, 1.0f, 0.0f);
vertices[i*gridDensity+j].texCoords.Set( (float(i)/(gridDensity-1)),
-(float(j)/(gridDensity-1)));
}
}
//Initialise the indices
numIndices=2*(gridDensity)*(gridDensity-1);
indices=new GLuint[numIndices];
if(!indices)
{
LOG::Instance()->OutputError("Unable to allocate space for %d indices", numIndices);
return false;
}
for(int i=0; i<gridDensity-1; ++i)
{
for(int j=0; j<gridDensity; ++j)
{
indices[(i*gridDensity+j)*2 ]=(i+1)*gridDensity+j;
indices[(i*gridDensity+j)*2+1]=i*gridDensity+j;
}
}
//Load texture
IMAGE floorImage;
floorImage.Load("OpenGL.tga");
if(floorImage.paletted)
floorImage.ExpandPalette();
glGenTextures(1, &floorTexture);
glBindTexture(GL_TEXTURE_2D, floorTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA8, floorImage.width, floorImage.height,
floorImage.format, GL_UNSIGNED_BYTE, floorImage.data);
//Initialise the lights
for(int i=0; i<numLights; ++i)
{
lights[i].position.Set( (float(rand())/RAND_MAX)*2-1,
0.02f,
(float(rand())/RAND_MAX)*2-1);
lights[i].velocity.Set( (float(rand())/RAND_MAX)*2-1,
0.0f,
(float(rand())/RAND_MAX)*2-1);
lights[i].color.Set( (float(rand())/RAND_MAX)*0.75f,
(float(rand())/RAND_MAX)*0.75f,
(float(rand())/RAND_MAX)*0.75f,
1.0f);
}
//Load vertex programs
if(GLEE_NV_vertex_program)
{
glGenProgramsNV(1, &vp1);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, vp1);
LoadARB_program(GL_VERTEX_PROGRAM_NV, "vp1.txt");
}
if(GLEE_NV_vertex_program2)
{
glGenProgramsNV(1, &vp2);
glBindProgramNV(GL_VERTEX_PROGRAM_NV, vp2);
LoadARB_program(GL_VERTEX_PROGRAM_NV, "vp2.txt");
}
if(GLEE_NV_vertex_program || GLEE_NV_vertex_program2)
{
//Track modelview-projection matrix
glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
}
//reset timer
timer.Reset();
return true;
}
static void Init( void )
{
#if 0
static const char *prog0 =
"!!FP1.0\n"
"MUL o[COLR], R0, f[WPOS]; \n"
"ADD o[COLH], H3, f[TEX0]; \n"
"ADD_SAT o[COLH], H3, f[TEX0]; \n"
"ADDX o[COLH], H3, f[TEX0]; \n"
"ADDHC o[COLH], H3, f[TEX0]; \n"
"ADDXC o[COLH], H3, f[TEX0]; \n"
"ADDXC_SAT o[COLH], H30, f[TEX0]; \n"
"MUL o[COLR].xy, R0.wzyx, f[WPOS]; \n"
"MUL o[COLR], H0, f[WPOS]; \n"
"MUL o[COLR], -H0, f[WPOS]; \n"
"MOV RC, H1; \n"
"MOV HC, H2; \n"
"END \n"
;
#endif
/* masked updates, defines, declarations */
static const char *prog1 =
"!!FP1.0\n"
"DEFINE foo = {1, 2, 3, 4}; \n"
"DEFINE foo2 = 5; \n"
"DECLARE foo3 = {5, 6, 7, 8}; \n"
"DECLARE bar = 3; \n"
"DECLARE bar2; \n"
"DECLARE bar3 = bar; \n"
"#DECLARE bar4 = { a, b, c, d }; \n"
"MOV o[COLR].xy, R0; \n"
"MOV o[COLR] (NE), R0; \n"
"MOV o[COLR] (NE.wzyx), R0; \n"
"MOV o[COLR].xy (NE.wzyx), R0; \n"
"MOV RC.x (EQ), R1.x; \n"
"KIL NE; \n"
"KIL EQ.xyxy; \n"
"END \n"
;
/* texture instructions */
static const char *prog2 =
"!!FP1.0\n"
"TEX R0, f[TEX0], TEX0, 2D; \n"
"TEX R1, f[TEX1], TEX1, CUBE; \n"
"TEX R2, f[TEX2], TEX2, 3D; \n"
"TXP R3, f[TEX3], TEX3, RECT; \n"
"TXD R3, R2, R1, f[TEX3], TEX3, RECT; \n"
"MUL o[COLR], R0, f[COL0]; \n"
"END \n"
;
/* test negation, absolute value */
static const char *prog3 =
"!!FP1.0\n"
"MOV R0, -R1; \n"
"MOV R0, +R1; \n"
"MOV R0, |-R1|; \n"
"MOV R0, |+R1|; \n"
"MOV R0, -|R1|; \n"
"MOV R0, +|R1|; \n"
"MOV R0, -|-R1|; \n"
"MOV R0, -|+R1|; \n"
"MOV o[COLR], R0; \n"
"END \n"
;
/* literal constant sources */
static const char *prog4 =
"!!FP1.0\n"
"DEFINE Pi = 3.14159; \n"
"MOV R0, {1, -2, +3, 4}; \n"
"MOV R0, 5; \n"
"MOV R0, -5; \n"
"MOV R0, +5; \n"
"MOV R0, Pi; \n"
"MOV o[COLR], R0; \n"
"END \n"
;
/* change the fragment color in a simple way */
static const char *prog10 =
"!!FP1.0\n"
"DEFINE blue = {0, 0, 1, 0};\n"
"DECLARE color; \n"
"MOV R0, f[COL0]; \n"
"#ADD o[COLR], R0, f[COL0]; \n"
"#ADD o[COLR], blue, f[COL0]; \n"
"#ADD o[COLR], {1, 0, 0, 0}, f[COL0]; \n"
"ADD o[COLR], color, f[COL0]; \n"
"END \n"
;
GLuint progs[20];
if (!glutExtensionSupported ("GL_NV_fragment_program")) {
printf("Sorry, this program requires GL_NV_fragment_program\n");
exit(1);
}
glGenProgramsNV(20, progs);
assert(progs[0]);
assert(progs[1]);
assert(progs[0] != progs[1]);
#if 0
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[0],
strlen(prog0),
(const GLubyte *) prog0);
assert(glIsProgramNV(progs[0]));
#endif
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[1],
strlen(prog1),
(const GLubyte *) prog1);
assert(glIsProgramNV(progs[1]));
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[2],
strlen(prog2),
(const GLubyte *) prog2);
assert(glIsProgramNV(progs[2]));
glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[2]);
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[3],
strlen(prog3),
(const GLubyte *) prog3);
assert(glIsProgramNV(progs[3]));
glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[3]);
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[4],
strlen(prog4),
(const GLubyte *) prog4);
assert(glIsProgramNV(progs[4]));
glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[4]);
/* a real program */
glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[10],
strlen(prog10),
(const GLubyte *) prog10);
assert(glIsProgramNV(progs[10]));
glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[10]);
glProgramNamedParameter4fNV(progs[10],
strlen("color"), (const GLubyte *) "color",
1, 0, 0, 1);
glEnable(GL_FRAGMENT_PROGRAM_NV);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_ALWAYS, 0.0);
printf("glGetError = %d\n", (int) glGetError());
}
