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());
}
//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;
}
//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;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexProgram_nglTrackMatrixNV(JNIEnv *env, jclass clazz, jint target, jint address, jint matrix, jint transform, jlong function_pointer) {
glTrackMatrixNVPROC glTrackMatrixNV = (glTrackMatrixNVPROC)((intptr_t)function_pointer);
glTrackMatrixNV(target, address, matrix, transform);
}
//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 )
{
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");
}
//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;
}
