int init_render(int x_res, int y_res)
{
GzDisplay* display;
GzNewDisplay(&display, 0, x_res, y_res);
GzNewRender(&renderer, GZ_Z_BUFFER_RENDER, display);
//init camera
default_camera.position[X] =0.0;
default_camera.position[Y] = 10.0;
default_camera.position[Z] = 10.0;
default_camera.lookat[X] = 0.0;
default_camera.lookat[Y] = 0.0;
default_camera.lookat[Z] = 0.0;
default_camera.worldup[X] = 0.0;
default_camera.worldup[Y] = 1.0;
default_camera.worldup[Z] = 0.0;
default_camera.FOV = 53.7; // degrees
GzPutCamera(renderer, &default_camera);
//setup light
GzToken nameListLights[10];
GzPointer valueListLights[10];
GzLight ambient_light = {{0.0f, 0.0f, 0.0f}, {0.9f, 0.9f, 0.9f}};
GzLight direction_light = { {0.0f, -0.707f, -0.707f} , {0.9f, 0.9f, 0.9f}};
nameListLights[0] = GZ_AMBIENT_LIGHT;
valueListLights[0] = (GzPointer)&ambient_light;
nameListLights[1] = GZ_DIRECTIONAL_LIGHT;
valueListLights[1] = (GzPointer)&direction_light;
GzPutAttribute(renderer, 2, nameListLights, valueListLights);
//read in model
teapot_model.ReadMesh("POT4.ASC");
teapot_scale[0] = 0.3f;
teapot_scale[1] = 0.3f;
teapot_scale[2] = 0.3f;
teapot_position[0] = 0.0f;
teapot_position[1] = -3.0f;
teapot_position[2] = -1.0f;
teapot_rotation[0] = 0.0f;
teapot_rotation[1] = 0.0f;
teapot_rotation[2] = 0.0f;
water_plane_model.ReadMesh("water_plane.asc");
//setup texture display
GzNewDisplay(&refraction_display, GZ_Z_BUFFER_RENDER, x_res, y_res);
return 0;
}
int Application3::Initialize()
{
/* to be filled in by the app if it sets camera params */
GzCamera camera;
int i, j;
int xRes, yRes, dispClass; /* display parameters */
int status;
status = 0;
/*
* Allocate memory for user input
*/
m_pUserInput = new GzInput;
/*
* initialize the display and the renderer
*/
m_nWidth = 256; // frame buffer and display width
m_nHeight = 256; // frame buffer and display height
/* Translation matrix */
GzMatrix scale =
{
3.25, 0.0, 0.0, 0.0,
0.0, 3.25, 0.0, -3.25,
0.0, 0.0, 3.25, 3.5,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateX =
{
1.0, 0.0, 0.0, 0.0,
0.0, .7071, .7071, 0.0,
0.0, -.7071, .7071, 0.0,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateY =
{
.866, 0.0, -0.5, 0.0,
0.0, 1.0, 0.0, 0.0,
0.5, 0.0, .866, 0.0,
0.0, 0.0, 0.0, 1.0
};
status |= GzNewFrameBuffer(&m_pFrameBuffer, m_nWidth, m_nHeight);
status |= GzNewDisplay(&m_pDisplay, GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pDisplay, &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pDisplay);
status |= GzNewRender(&m_pRender, GZ_Z_BUFFER_RENDER, m_pDisplay);
#if 1 /* set up app-defined camera if desired, else use camera defaults */
camera.position[X] = 13.2;
camera.position[Y] = -8.7;
camera.position[Z] = -14.8;
camera.lookat[X] = 0.8;
camera.lookat[Y] = 0.7;
camera.lookat[Z] = 4.5;
camera.worldup[X] = -0.2;
camera.worldup[Y] = 1.0;
camera.worldup[Z] = 0.0;
camera.FOV = 53.7; /* degrees */
status |= GzPutCamera(m_pRender, &camera);
#endif
/* Start Renderer */
status |= GzBeginRender(m_pRender);
status |= GzPushMatrix(m_pRender, scale);
status |= GzPushMatrix(m_pRender, rotateY);
status |= GzPushMatrix(m_pRender, rotateX);
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application5::Initialize()
{
GzCamera camera;
int xRes, yRes, dispClass; /* display parameters */
GzToken nameListShader[9]; /* shader attribute names */
GzPointer valueListShader[9]; /* shader attribute pointers */
GzToken nameListLights[10]; /* light info */
GzPointer valueListLights[10];
int shaderType, interpStyle;
float specpower;
int status;
status = 0;
/*
* Allocate memory for user input
*/
m_pUserInput = new GzInput;
/*
* initialize the display and the renderer
*/
m_nWidth = 256; // frame buffer and display width
m_nHeight = 256; // frame buffer and display height
//initialize the final display
status |= GzNewFrameBuffer(&m_pFrameBuffer, m_nWidth, m_nHeight);
status |= GzNewDisplay(&m_finalDisplay, GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_finalDisplay, &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_finalDisplay);
/* Translation matrix */
GzMatrix scale =
{
3.25, 0.0, 0.0, 0.0,
0.0, 3.25, 0.0, -3.25,
0.0, 0.0, 3.25, 3.5,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateX =
{
1.0, 0.0, 0.0, 0.0,
0.0, .7071, .7071, 0.0,
0.0, -.7071, .7071, 0.0,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateY =
{
.866, 0.0, -0.5, 0.0,
0.0, 1.0, 0.0, 0.0,
0.5, 0.0, .866, 0.0,
0.0, 0.0, 0.0, 1.0
};
m_pRender = new GzRender* [AAKERNEL_SIZE * sizeof(GzRender*)];
m_pDisplay = new GzDisplay* [AAKERNEL_SIZE * sizeof(GzDisplay*)];
//initialize the seperated display and renderer for different offsets
for (int i = 0; i < AAKERNEL_SIZE; i++)
{
status |= GzNewDisplay(&m_pDisplay[i], GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pDisplay[i], &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pDisplay[i]);
status |= GzNewRender(&m_pRender[i], GZ_Z_BUFFER_RENDER, m_pDisplay[i]);
#if 1 /* set up app-defined camera if desired, else use camera defaults */
camera.position[X] = -3;
camera.position[Y] = -25;
camera.position[Z] = -4;
camera.lookat[X] = 7.8;
camera.lookat[Y] = 0.7;
camera.lookat[Z] = 6.5;
camera.worldup[X] = -0.2;
camera.worldup[Y] = 1.0;
camera.worldup[Z] = 0.0;
camera.FOV = 63.7; /* degrees * /* degrees */
status |= GzPutCamera(m_pRender[i], &camera);
#endif
/* Start Renderer */
status |= GzBeginRender(m_pRender[i]);
/* Light */
GzLight light1 = { {-0.7071, 0.7071, 0}, {0.5, 0.5, 0.9} };
GzLight light2 = { {0, -0.7071, -0.7071}, {0.9, 0.2, 0.3} };
GzLight light3 = { {0.7071, 0.0, -0.7071}, {0.2, 0.7, 0.3} };
GzLight ambientlight = { {0, 0, 0}, {0.3, 0.3, 0.3} };
/* Material property */
GzColor specularCoefficient = { 0.3, 0.3, 0.3 };
GzColor ambientCoefficient = { 0.1, 0.1, 0.1 };
GzColor diffuseCoefficient = {0.7, 0.7, 0.7};
/*
renderer is ready for frame --- define lights and shader at start of frame
*/
/*
* Tokens associated with light parameters
*/
nameListLights[0] = GZ_DIRECTIONAL_LIGHT;
valueListLights[0] = (GzPointer)&light1;
nameListLights[1] = GZ_DIRECTIONAL_LIGHT;
valueListLights[1] = (GzPointer)&light2;
nameListLights[2] = GZ_DIRECTIONAL_LIGHT;
valueListLights[2] = (GzPointer)&light3;
status |= GzPutAttribute(m_pRender[i], 3, nameListLights, valueListLights);
nameListLights[0] = GZ_AMBIENT_LIGHT;
valueListLights[0] = (GzPointer)&ambientlight;
status |= GzPutAttribute(m_pRender[i], 1, nameListLights, valueListLights);
/*
* Tokens associated with shading
*/
nameListShader[0] = GZ_DIFFUSE_COEFFICIENT;
valueListShader[0] = (GzPointer)diffuseCoefficient;
/*
* Select either GZ_COLOR or GZ_NORMALS as interpolation mode
*/
nameListShader[1] = GZ_INTERPOLATE;
interpStyle = GZ_NORMALS; /* Phong shading */
//interpStyle = GZ_COLOR; //gourand shading
valueListShader[1] = (GzPointer)&interpStyle;
nameListShader[2] = GZ_AMBIENT_COEFFICIENT;
valueListShader[2] = (GzPointer)ambientCoefficient;
nameListShader[3] = GZ_SPECULAR_COEFFICIENT;
valueListShader[3] = (GzPointer)specularCoefficient;
nameListShader[4] = GZ_DISTRIBUTION_COEFFICIENT;
specpower = 32;
valueListShader[4] = (GzPointer)&specpower;
nameListShader[5] = GZ_TEXTURE_MAP;
#if 0 /* set up null texture function or valid pointer */
valueListShader[5] = (GzPointer)0;
#else
valueListShader[5] = (GzPointer)(tex_fun); /* use tex_fun */
//valueListShader[5] = (GzPointer)(ptex_fun); // use ptex_fun
#endif
nameListShader[6] = GZ_AASHIFTX;
valueListShader[6] = (GzPointer)&(AAFilter[i][X]);
nameListShader[7] = GZ_AASHIFTY;
valueListShader[7] = (GzPointer)&(AAFilter[i][Y]);
status |= GzPutAttribute(m_pRender[i], 8, nameListShader, valueListShader);
status |= GzPushMatrix(m_pRender[i], scale);
status |= GzPushMatrix(m_pRender[i], rotateY);
status |= GzPushMatrix(m_pRender[i], rotateX);
}
if (status) exit(GZ_FAILURE);
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application4::Initialize()
{
/* to be filled in by the app if it sets camera params */
GzCamera camera;
int xRes, yRes, dispClass; /* display parameters */
GzToken nameListShader[9]; /* shader attribute names */
GzPointer valueListShader[9]; /* shader attribute pointers */
GzToken nameListLights[10]; /* light info */
GzPointer valueListLights[10];
int shaderType, interpStyle;
float specpower;
int status;
status = 0;
/*
* Allocate memory for user input
*/
m_pUserInput = new GzInput;
/*
* initialize the display and the renderer
*/
m_nWidth = 512; // frame buffer and display width
m_nHeight = 512; // frame buffer and display height
status |= GzNewFrameBuffer(&m_pFrameBuffer, m_nWidth, m_nHeight);
status |= GzNewDisplay(&m_pDisplay, GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pDisplay, &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pDisplay);
status |= GzNewRender(&m_pRender, GZ_Z_BUFFER_RENDER, m_pDisplay);
/* Translation matrix */
GzMatrix scale =
{
3.25, 0.0, 0.0, 0.0,
0.0, 3.25, 0.0, -3.25,
0.0, 0.0, 3.25, 3.5,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateX =
{
1.0, 0.0, 0.0, 0.0,
0.0, .7071, .7071, 0.0,
0.0, -.7071, .7071, 0.0,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateY =
{
.866, 0.0, -0.5, 0.0,
0.0, 1.0, 0.0, 0.0,
0.5, 0.0, .866, 0.0,
0.0, 0.0, 0.0, 1.0
};
#if 1 /* set up app-defined camera if desired, else use camera defaults */
camera.position[X] = 13.2;
camera.position[Y] = -8.7;
camera.position[Z] = -14.8;
camera.lookat[X] = 0.8;
camera.lookat[Y] = 0.7;
camera.lookat[Z] = 4.5;
camera.worldup[X] = -0.2;
camera.worldup[Y] = 1.0;
camera.worldup[Z] = 0.0;
camera.FOV = 53.7; /* degrees */
status |= GzPutCamera(m_pRender, &camera);
#endif
/* Start Renderer */
status |= GzBeginRender(m_pRender);
/* Light */
GzLight light1 = { {-0.7071, 0.7071, 0}, {0.5, 0.5, 0.9} };
GzLight light2 = { {0, -0.7071, -0.7071}, {0.9, 0.2, 0.3} };
GzLight light3 = { {0.7071, 0.0, -0.7071}, {0.2, 0.7, 0.3} };
GzLight ambientlight = { {0, 0, 0}, {0.3, 0.3, 0.3} };
/* Material property */
GzColor specularCoefficient = { 0.3, 0.3, 0.3 };
GzColor ambientCoefficient = { 0.1, 0.1, 0.1 };
GzColor diffuseCoefficient = {0.7, 0.7, 0.7};
/*
renderer is ready for frame --- define lights and shader at start of frame
*/
/*
* Tokens associated with light parameters
*/
nameListLights[0] = GZ_DIRECTIONAL_LIGHT;
valueListLights[0] = (GzPointer)&light1;
nameListLights[1] = GZ_DIRECTIONAL_LIGHT;
valueListLights[1] = (GzPointer)&light2;
nameListLights[2] = GZ_DIRECTIONAL_LIGHT;
valueListLights[2] = (GzPointer)&light3;
status |= GzPutAttribute(m_pRender, 3, nameListLights, valueListLights);
nameListLights[0] = GZ_AMBIENT_LIGHT;
valueListLights[0] = (GzPointer)&ambientlight;
status |= GzPutAttribute(m_pRender, 1, nameListLights, valueListLights);
/*
* Tokens associated with shading
*/
nameListShader[0] = GZ_DIFFUSE_COEFFICIENT;
valueListShader[0] = (GzPointer)diffuseCoefficient;
/*
* Select either GZ_COLOR or GZ_NORMALS as interpolation mode
*/
nameListShader[1] = GZ_INTERPOLATE;
#if 0
interpStyle = GZ_COLOR; /* Gouraud shading */
#else
interpStyle = GZ_NORMALS; /* Phong shading */
#endif
valueListShader[1] = (GzPointer)&interpStyle;
nameListShader[2] = GZ_AMBIENT_COEFFICIENT;
valueListShader[2] = (GzPointer)ambientCoefficient;
nameListShader[3] = GZ_SPECULAR_COEFFICIENT;
valueListShader[3] = (GzPointer)specularCoefficient;
nameListShader[4] = GZ_DISTRIBUTION_COEFFICIENT;
specpower = 32;
valueListShader[4] = (GzPointer)&specpower;
status |= GzPutAttribute(m_pRender, 5, nameListShader, valueListShader);
status |= GzPushMatrix(m_pRender, scale);
status |= GzPushMatrix(m_pRender, rotateY);
status |= GzPushMatrix(m_pRender, rotateX);
if (status) exit(GZ_FAILURE);
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application1::Render()
{
int i, j;
int xRes, yRes, dispClass; /* display parameters */
int status;
status = 0;
/*
* initialize the display and the renderer
*/
m_nWidth = 512; // frame buffer and display width
m_nHeight = 512; // frame buffer and display height
status |= GzNewFrameBuffer(&m_pFrameBuffer, m_nWidth, m_nHeight);
status |= GzNewDisplay(&m_pDisplay, GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pDisplay, &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pDisplay); /* init for new frame */
if (status) exit(GZ_FAILURE);
// I/O File open
FILE *infile;
if( (infile = fopen( INFILE1 , "r" )) == NULL )
{
AfxMessageBox( "The input file was not opened\n" );
return GZ_FAILURE;
}
FILE *outfile;
if( (outfile = fopen( OUTFILE1 , "wb" )) == NULL )
{
AfxMessageBox( "The output file was not opened\n" );
return GZ_FAILURE;
}
int ulx, uly, lrx, lry, r, g, b;
while( fscanf(infile, "%d %d %d %d %d %d %d",
&ulx, &uly, &lrx, &lry, &r, &g, &b) == 7) {
for (j = uly; j <= lry; j++) {
for (i = ulx; i <= lrx; i++) {
GzPutDisplay(m_pDisplay, i, j, r, g, b, 1, 0);
}
}
}
GzFlushDisplay2File(outfile, m_pDisplay); /* write out or update display to file*/
GzFlushDisplay2FrameBuffer(m_pFrameBuffer, m_pDisplay); // write out or update display to frame buffer
/*
* Clean up and exit
*/
if( fclose( infile ) )
AfxMessageBox( "The input file was not closed\n" );
if( fclose( outfile ) )
AfxMessageBox( "The output file was not closed\n" );
status |= GzFreeDisplay(m_pDisplay);
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application2::Render()
{
GzToken nameListTriangle[3]; /* vertex attribute names */
GzPointer valueListTriangle[3]; /* vertex attribute pointers */
GzToken nameListColor[3]; /* color type names */
GzPointer valueListColor[3]; /* color type rgb pointers */
GzColor color;
GzCoord vertexList[3]; /* vertex position coordinates */
GzCoord normalList[3]; /* vertex normals */
GzTextureIndex uvList[3]; /* vertex texture map indices */
char dummy[256];
int i;
int xRes, yRes, dispClass; /* display parameters */
int status;
status = 0;
/*
* initialize the display and the renderer
*/
m_nWidth = 256; // frame buffer and display width
m_nHeight = 256; // frame buffer and display height
status |= GzNewFrameBuffer(&m_pFrameBuffer, m_nWidth, m_nHeight);
status |= GzNewDisplay(&m_pDisplay, GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pDisplay, &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pDisplay);
status |= GzNewRender(&m_pRender, GZ_Z_BUFFER_RENDER, m_pDisplay);
status |= GzBeginRender(m_pRender);
if (status) exit(GZ_FAILURE);
/*
* Tokens associated with triangle vertex values
*/
nameListTriangle[0] = GZ_POSITION; /* define vert coordinates only */
// I/O File open
FILE *infile;
if( (infile = fopen( INFILE2 , "r" )) == NULL )
{
AfxMessageBox( "The input file was not opened\n" );
return GZ_FAILURE;
}
FILE *outfile;
if( (outfile = fopen( OUTFILE2 , "wb" )) == NULL )
{
AfxMessageBox( "The output file was not opened\n" );
return GZ_FAILURE;
}
/*
* Walk through the list of triangles, set color
* and pass vert info to render/scan convert each triangle
*/
i = 0;
while( fscanf(infile, "%s", dummy) == 1) { /* read in tri word */
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[0][0]), &(vertexList[0][1]),
&(vertexList[0][2]),
&(normalList[0][0]), &(normalList[0][1]),
&(normalList[0][2]),
&(uvList[0][0]), &(uvList[0][1]) );
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[1][0]), &(vertexList[1][1]),
&(vertexList[1][2]),
&(normalList[1][0]), &(normalList[1][1]),
&(normalList[1][2]),
&(uvList[1][0]), &(uvList[1][1]) );
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[2][0]), &(vertexList[2][1]),
&(vertexList[2][2]),
&(normalList[2][0]), &(normalList[2][1]),
&(normalList[2][2]),
&(uvList[2][0]), &(uvList[2][1]) );
/*
* Set up shading attributes for each triangle
*/
shade2(normalList[0], color);/* shade based on the norm of vert0 */
valueListColor[0] = (GzPointer)color;
nameListColor[0] = GZ_RGB_COLOR;
GzPutAttribute(m_pRender, 1, nameListColor, valueListColor);
/*
* Set the value pointers to the first vertex of the
* triangle, then feed it to the renderer
*/
valueListTriangle[0] = (GzPointer)vertexList;
GzPutTriangle(m_pRender, 1, nameListTriangle, valueListTriangle);
}
GzFlushDisplay2File(outfile, m_pDisplay); /* write out or update display to file*/
GzFlushDisplay2FrameBuffer(m_pFrameBuffer, m_pDisplay); // write out or update display to frame buffer
/*
* Clean up and exit
*/
if( fclose( infile ) )
AfxMessageBox( "The input file was not closed\n" );
if( fclose( outfile ) )
AfxMessageBox( "The output file was not closed\n" );
status |= GzFreeRender(m_pRender);
status |= GzFreeDisplay(m_pDisplay);
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application4::Initialize()
{
GzCamera camera;
int xRes = 0, yRes = 0, dispClass; /* display parameters */
GzToken nameListShader[9]; /* shader attribute names */
GzPointer valueListShader[9]; /* shader attribute pointers */
GzToken nameListLights[10]; /* light info */
GzPointer valueListLights[10];
GzToken nameListShifts[10]; /* Shift info */
GzPointer valueListShifts[10];
int shaderType, interpStyle;
float specpower;
int status;
int index = 0;
status = 0;
/*
* Allocate memory for user input
*/
m_pUserInput = new GzInput;
/*
* initialize the display and the renderer
*/
m_nWidth = 256; // frame buffer and display width
m_nHeight = 256; // frame buffer and display height
/* Translation matrix */
GzMatrix scale =
{
3.25, 0.0, 0.0, 0.0,
0.0, 3.25, 0.0, -3.25,
0.0, 0.0, 3.25, 3.5,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateX =
{
1.0, 0.0, 0.0, 0.0,
0.0, .7071, .7071, 0.0,
0.0, -.7071, .7071, 0.0,
0.0, 0.0, 0.0, 1.0
};
GzMatrix rotateY =
{
.866, 0.0, -0.5, 0.0,
0.0, 1.0, 0.0, 0.0,
0.5, 0.0, .866, 0.0,
0.0, 0.0, 0.0, 1.0
};
/* Light */
GzLight light1 = { {-0.7071, 0.7071, 0}, {0.5, 0.5, 0.9} };
GzLight light2 = { {0, -0.7071, -0.7071}, {0.9, 0.2, 0.3} };
GzLight light3 = { {0.7071, 0.0, -0.7071}, {0.2, 0.7, 0.3} };
GzLight ambientlight = { {0, 0, 0}, {0.3, 0.3, 0.3} };
/* Material property */
GzColor specularCoefficient = { 0.3, 0.3, 0.3 };
GzColor ambientCoefficient = { 0.1, 0.1, 0.1 };
GzColor diffuseCoefficient = {0.7, 0.7, 0.7};
#if 0 /* set up app-defined camera if desired, else use camera defaults */
camera.position[X] = -3;
camera.position[Y] = -25;
camera.position[Z] = -4;
camera.lookat[X] = 7.8;
camera.lookat[Y] = 0.7;
camera.lookat[Z] = 6.5;
camera.worldup[X] = -0.2;
camera.worldup[Y] = 1.0;
camera.worldup[Z] = 0.0;
camera.FOV = 63.7; /* degrees * /* degrees */
status |= GzPutCamera(m_pRender, &camera);
#endif
status |= GzNewFrameBuffer(&m_pFrameBuffer, m_nWidth, m_nHeight);
// ****************************************************************************************
// START HW6 CHANGE
// ****************************************************************************************
// Create multiple displays and framebuffers(display framebuffers)
for(index = 0; index < AAKERNEL_SIZE; index++){
status |= GzNewDisplay(&m_pDisplay[index], GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pDisplay[index], &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pDisplay[index]);
status |= GzNewRender(&m_pRender[index], GZ_Z_BUFFER_RENDER, m_pDisplay[index]);
/* Start Renderer */
status |= GzBeginRender(m_pRender[index]);
/*
* Tokens associated with light parameters
*/
nameListLights[0] = GZ_DIRECTIONAL_LIGHT;
valueListLights[0] = (GzPointer)&light1;
nameListLights[1] = GZ_DIRECTIONAL_LIGHT;
valueListLights[1] = (GzPointer)&light2;
nameListLights[2] = GZ_DIRECTIONAL_LIGHT;
valueListLights[2] = (GzPointer)&light3;
// store the Directional Light values in the render structures
status |= GzPutAttribute(m_pRender[index], 3, nameListLights, valueListLights);
nameListLights[0] = GZ_AMBIENT_LIGHT;
valueListLights[0] = (GzPointer)&ambientlight;
// store the Ambient Light values in the render structures
status |= GzPutAttribute(m_pRender[index], 1, nameListLights, valueListLights);
/*
* Tokens associated with shading
*/
nameListShader[0] = GZ_DIFFUSE_COEFFICIENT;
valueListShader[0] = (GzPointer)diffuseCoefficient;
/*
* Select either GZ_COLOR or GZ_NORMALS as interpolation mode
*/
nameListShader[1] = GZ_INTERPOLATE;
#if 0
interpStyle = GZ_COLOR; /* Gourand shading */
#else
interpStyle = GZ_NORMALS; /* Phong shading */
#endif
valueListShader[1] = (GzPointer)&interpStyle;
nameListShader[2] = GZ_AMBIENT_COEFFICIENT;
valueListShader[2] = (GzPointer)ambientCoefficient;
nameListShader[3] = GZ_SPECULAR_COEFFICIENT;
valueListShader[3] = (GzPointer)specularCoefficient;
nameListShader[4] = GZ_DISTRIBUTION_COEFFICIENT;
specpower = 32;
valueListShader[4] = (GzPointer)&specpower;
nameListShader[5] = GZ_TEXTURE_MAP;
#if 1 /* set up null texture function or valid pointer */
valueListShader[5] = (GzPointer)0;
#else
valueListShader[5] = (GzPointer)(tex_fun); /* or use ptex_fun */
#endif
// store the Ambient shading values in the render structures
status |= GzPutAttribute(m_pRender[index], 6, nameListShader, valueListShader);
// Pass the Sample offset X for the renderer defined for handling that jittered sample
nameListShifts[0] = GZ_AASHIFTX;
valueListShifts[0] = (GzPointer)&AAFilter[index][X];
status |= GzPutAttribute(m_pRender[index], 1, nameListShifts, valueListShifts);
// Pass the Sample offset Y for the renderer defined for handling that jittered sample
nameListShifts[0] = GZ_AASHIFTY;
valueListShifts[0] = (GzPointer)&AAFilter[index][Y];
status |= GzPutAttribute(m_pRender[index], 1, nameListShifts, valueListShifts);
// Push the transformation matrices into all the renderer stacks
status |= GzPushMatrix(m_pRender[index], scale);
status |= GzPushMatrix(m_pRender[index], rotateY);
status |= GzPushMatrix(m_pRender[index], rotateX);
}
// ****************************************************************************************
// END HW6 CHANGE
// ****************************************************************************************
if (status) exit(GZ_FAILURE);
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application4::Render()
{
GzToken nameListTriangle[3]; /* vertex attribute names */
GzPointer valueListTriangle[3]; /* vertex attribute pointers */
GzCoord vertexList[3], tempVertexList[3]; /* vertex position coordinates */
GzCoord normalList[3], tempNormalList[3]; /* vertex normals */
GzTextureIndex uvList[3], tempUVList[3]; /* vertex texture map indices */
char dummy[256];
int status;
int index = 0, x = 0, y = 0, disp_i = 0;
int xRes, yRes, dispClass;
int i = 0, j = 0;
// ****************************************************************************************
// START HW6 CHANGE
// ****************************************************************************************
/* Initialize Display */
for(index = 0; index < AAKERNEL_SIZE; index++){
status |= GzInitDisplay(m_pDisplay[index]);
}
// ****************************************************************************************
// END HW6 CHANGE
// ****************************************************************************************
/*
* Tokens associated with triangle vertex values
*/
nameListTriangle[0] = GZ_POSITION;
nameListTriangle[1] = GZ_NORMAL;
nameListTriangle[2] = GZ_TEXTURE_INDEX;
// I/O File open
FILE *infile;
if( (infile = fopen( INFILE , "r" )) == NULL )
{
AfxMessageBox( "The input file was not opened\n" );
return GZ_FAILURE;
}
FILE *outfile;
if( (outfile = fopen( OUTFILE , "wb" )) == NULL )
{
AfxMessageBox( "The output file was not opened\n" );
return GZ_FAILURE;
}
/*
* Walk through the list of triangles, set color
* and render each triangle
*/
while( fscanf(infile, "%s", dummy) == 1) { /* read in tri word */
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[0][0]), &(vertexList[0][1]),
&(vertexList[0][2]),
&(normalList[0][0]), &(normalList[0][1]),
&(normalList[0][2]),
&(uvList[0][0]), &(uvList[0][1]) );
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[1][0]), &(vertexList[1][1]),
&(vertexList[1][2]),
&(normalList[1][0]), &(normalList[1][1]),
&(normalList[1][2]),
&(uvList[1][0]), &(uvList[1][1]) );
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[2][0]), &(vertexList[2][1]),
&(vertexList[2][2]),
&(normalList[2][0]), &(normalList[2][1]),
&(normalList[2][2]),
&(uvList[2][0]), &(uvList[2][1]) );
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
tempVertexList[i][j] = vertexList[i][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
tempNormalList[i][j] = normalList[i][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 2; j++)
tempUVList[i][j] = uvList[i][j];
/*
* Set the value pointers to the first vertex of the
* triangle, then feed it to the renderer
* NOTE: this sequence matches the nameList token sequence
*/
// ****************************************************************************************
// START HW6 CHANGE
// ****************************************************************************************
for(index = 0; index < AAKERNEL_SIZE; index++)
{
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
vertexList[i][j] = tempVertexList[i][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
normalList[i][j] = tempNormalList[i][j];
for(i = 0; i < 3; i++)
for(j = 0; j < 2; j++)
uvList[i][j] = tempUVList[i][j];
valueListTriangle[0] = (GzPointer)vertexList;
valueListTriangle[1] = (GzPointer)normalList;
valueListTriangle[2] = (GzPointer)uvList;
GzPutTriangle(m_pRender[index], 3, nameListTriangle, valueListTriangle);
}
// ****************************************************************************************
// END HW6 CHANGE
// ****************************************************************************************
}
// ****************************************************************************************
// START HW6 CHANGE
// ****************************************************************************************
// Create The final display for rendering it into the framebuffer
status |= GzNewDisplay(&m_pFinalDisplay, GZ_RGBAZ_DISPLAY, m_nWidth, m_nHeight);
status |= GzGetDisplayParams(m_pFinalDisplay, &xRes, &yRes, &dispClass);
status |= GzInitDisplay(m_pFinalDisplay);
GzColor finalColor;
for(y = 0; y <= RESOLUTIONY; y++){
for(x = 0; x <= RESOLUTIONX; x++){
disp_i = (x+(y*256));
finalColor[RED]=0;
finalColor[GREEN]=0;
finalColor[BLUE]=0;
for(index = 0; index < AAKERNEL_SIZE; index++){
finalColor[RED] += ((float)m_pRender[index]->display->fbuf[disp_i].red * AAFilter[index][2]);
finalColor[GREEN] += ((float)m_pRender[index]->display->fbuf[disp_i].green * AAFilter[index][2]);
finalColor[BLUE] += ((float)m_pRender[index]->display->fbuf[disp_i].blue * AAFilter[index][2]);
}
m_pFinalDisplay->fbuf[disp_i].red = (short)finalColor[RED];
m_pFinalDisplay->fbuf[disp_i].green = (short)finalColor[GREEN];
m_pFinalDisplay->fbuf[disp_i].blue = (short)finalColor[BLUE];
}
}
/*
// update the renderers with the sample weights
for(index = 0; index < 1; index++){
for(y = 0; y <= RESOLUTIONY; y++){
for(x = 0; x <= RESOLUTIONX; x++){
disp_i = (x+(y*256));
m_pRender[index]->display->fbuf[disp_i].red *= AAFilter[index][2];
m_pRender[index]->display->fbuf[disp_i].green *= AAFilter[index][2];
m_pRender[index]->display->fbuf[disp_i].blue *= AAFilter[index][2];
}
}
}
// Compute the final pixel colors to render in the framebuffer
for(index = 0; index < 1; index++){
for(y = 0; y <= RESOLUTIONY; y++){
for(x = 0; x <= RESOLUTIONX; x++){
disp_i = (x+(y*256));
m_pFinalDisplay->fbuf[disp_i].red += m_pRender[index]->display->fbuf[disp_i].red;
m_pFinalDisplay->fbuf[disp_i].green += m_pRender[index]->display->fbuf[disp_i].green;
m_pFinalDisplay->fbuf[disp_i].blue += m_pRender[index]->display->fbuf[disp_i].blue;
}
}
}
*/
// ****************************************************************************************
// END HW6 CHANGE
// ****************************************************************************************
GzFlushDisplay2File(outfile, m_pFinalDisplay); /* write out or update display to file*/
GzFlushDisplay2FrameBuffer(m_pFrameBuffer, m_pFinalDisplay); // write out or update display to frame buffer
/*
* Close file
*/
if( fclose( infile ) )
AfxMessageBox( "The input file was not closed\n" );
if( fclose( outfile ) )
AfxMessageBox( "The output file was not closed\n" );
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
int Application5::Render()
{
GzToken nameListTriangle[3]; /* vertex attribute names */
GzPointer valueListTriangle[3]; /* vertex attribute pointers */
GzCoord vertexList[3]; /* vertex position coordinates */
GzCoord normalList[3]; /* vertex normals */
GzTextureIndex uvList[3]; /* vertex texture map indices */
char dummy[256];
int status;
/* Initialize Display */
/////for (int i = 0; i < AAKERNEL_SIZE; i++)
////status |= GzInitDisplay(m_pDisplay);
/////for (int i = 0; i < AAKERNEL_SIZE; i++) {
/////GzNewDisplay(&AArender->display, GZ_RGBAZ_DISPLAY, m_pRender->display->xres, m_pRender->display->yres);
/////}
/*
* Tokens associated with triangle vertex values
*/
nameListTriangle[0] = GZ_POSITION;
nameListTriangle[1] = GZ_NORMAL;
nameListTriangle[2] = GZ_TEXTURE_INDEX;
// I/O File open
FILE *infile;
if( (infile = fopen( INFILE , "r" )) == NULL )
{
AfxMessageBox(_T( "The input file was not opened\n" ));
return GZ_FAILURE;
}
FILE *outfile;
if( (outfile = fopen( OUTFILE , "wb" )) == NULL )
{
AfxMessageBox(_T("The output file was not opened\n"));
return GZ_FAILURE;
}
/*
* Walk through the list of triangles, set color
* and render each triangle
*/
////m_pAADisplays = (GzDisplay **)malloc(6 * sizeof(GzDisplay*));
////m_pAADisplays = new GzDisplay*[6];
////m_pAARenders = (GzRender **)malloc(6 * sizeof(GzRender*));
////m_pAARenders = new GzRender*[6];
for (int i = 0; i < AAKERNEL_SIZE; i++) {
/////status |= GzNewRender(&m_pAARenders[i], m_pAADisplays[i]);
m_pAARenders[i] = new GzRender();
memcpy(m_pAARenders[i], m_pRender, sizeof(GzRender));
status |= GzNewDisplay(&m_pAADisplays[i], m_nWidth, m_nHeight);
status |= GzInitDisplay(m_pAADisplays[i]);
m_pAARenders[i]->display = m_pAADisplays[i];
m_pAARenders[i]->Xshift = AAFilter[i][0];
m_pAARenders[i]->Yshift = AAFilter[i][1];
m_pAARenders[i]->Weight = AAFilter[i][2];
}
while (fscanf(infile, "%s", dummy) == 1) { /* read in tri word */
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[0][0]), &(vertexList[0][1]),
&(vertexList[0][2]),
&(normalList[0][0]), &(normalList[0][1]),
&(normalList[0][2]),
&(uvList[0][0]), &(uvList[0][1]));
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[1][0]), &(vertexList[1][1]),
&(vertexList[1][2]),
&(normalList[1][0]), &(normalList[1][1]),
&(normalList[1][2]),
&(uvList[1][0]), &(uvList[1][1]));
fscanf(infile, "%f %f %f %f %f %f %f %f",
&(vertexList[2][0]), &(vertexList[2][1]),
&(vertexList[2][2]),
&(normalList[2][0]), &(normalList[2][1]),
&(normalList[2][2]),
&(uvList[2][0]), &(uvList[2][1]));
/*
* Set the value pointers to the first vertex of the
* triangle, then feed it to the renderer
* NOTE: this sequence matches the nameList token sequence
*/
valueListTriangle[0] = (GzPointer)vertexList;
valueListTriangle[1] = (GzPointer)normalList;
valueListTriangle[2] = (GzPointer)uvList;
GzPutTriangle(m_pRender, 3, nameListTriangle, valueListTriangle);
//#if ANTIALIASING
for (int i = 0; i < AAKERNEL_SIZE; i++)
GzPutTriangle(m_pAARenders[i], 3, nameListTriangle, valueListTriangle);
//#endif
}
GzInitDisplay(m_pRender->display);
for (int y = 0; y < m_pRender->display->yres; y++) {
for (int x = 0; x < m_pRender->display->xres; x++) {
GzDisplay* display = m_pRender->display;
int index = ARRAY(x, y);
for (int i = 0; i < AAKERNEL_SIZE; i++) {
m_pRender->display->fbuf[index].red += m_pAARenders[i]->display->fbuf[index].red * m_pAARenders[i]->Weight;
m_pRender->display->fbuf[index].green += m_pAARenders[i]->display->fbuf[index].green * m_pAARenders[i]->Weight;
m_pRender->display->fbuf[index].blue += m_pAARenders[i]->display->fbuf[index].blue * m_pAARenders[i]->Weight;
}
}
}
GzFlushDisplay2File(outfile, m_pDisplay); /* write out or update display to file*/
GzFlushDisplay2FrameBuffer(m_pFrameBuffer, m_pDisplay); // write out or update display to frame buffer
/*
* Close file
*/
if( fclose( infile ) )
AfxMessageBox(_T("The input file was not closed\n"));
if( fclose( outfile ) )
AfxMessageBox(_T("The output file was not closed\n"));
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
void copyRender(GzRender* &AArender, GzRender* m_pRender) {
AArender = new GzRender();
memcpy(AArender, m_pRender, sizeof(GzRender));
GzNewDisplay(&AArender->display, GZ_RGBAZ_DISPLAY, m_pRender->display->xres, m_pRender->display->yres);
}
