void Project::FindForceField(float* ffx_1, float* ffy_1, unsigned char* gradient, float* ffx, float* ffy)
{
unsigned char* blurredGradient;
GzNewFrameBuffer(&blurredGradient, m_nWidth, m_nHeight);
BlurDepthMap(gradient, blurredGradient);
GzMatrix3 filterX = {
-1, -2, -1,
0, 0, 0,
1, 2, 1,
};
GzMatrix3 filterY = {
1, 0, -1,
2, 0, -2,
1, 0, -1,
};
for (int y = 0; y < m_nHeight; ++y)
{
for (int x = 0; x < m_nWidth; ++x)
{
int framebufferIndex = 3 * x + (y * m_nWidth * 3);
if (x == 0 || x == m_nWidth - 1 ||
y == 0 || y == m_nHeight - 1)
{
ffx[framebufferIndex] = 0;
ffy[framebufferIndex] = 0;
continue;
}
float gradX = 0;
float gradY = 0;
for (int j = -1; j < 2; ++j)
{
for (int i = -1; i < 2; ++i)
{
int fIndex = 3 * (x + i) + ((y + j) * m_nWidth * 3);
gradX += (blurredGradient[fIndex] * filterX[i + 1][j + 1]);
gradY += (blurredGradient[fIndex] * filterY[i + 1][j + 1]);
}
}
ffx[framebufferIndex] = ffx_1[framebufferIndex] + gradY;
ffy[framebufferIndex] = ffy_1[framebufferIndex] - gradX;
}
}
}
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 Project::Render()
{
GzToken nameListTriangle[2]; /* vertex attribute names */
GzPointer valueListTriangle[2]; /* vertex attribute pointers */
GzCoord vertexList[3]; /* vertex position coordinates */
GzCoord normalList[3]; /* vertex normals */
int status;
objParser.getNumOfVertices();
/* Initialize Display */
status |= GzInitDisplay(m_pDisplay);
/*
* Tokens associated with triangle vertex values
*/
nameListTriangle[0] = GZ_POSITION;
nameListTriangle[1] = GZ_NORMAL;
// I/O File open
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
*/
for (int i = 0; i < objParser.getNumOfFaces(); ++i)
{
Face face = objParser.getFace(i + 1);
vector<Face::FaceVertex> faceVertices = face.faceVertices;
for (int j = 0; j < faceVertices.size(); ++j)
{
Face::FaceVertex faceVertex = faceVertices[j];
Vertex vertex = objParser.getVertex(faceVertex.v);
VertexNormal vertexNormal = objParser.getVertexNormal(faceVertex.vn);
vertexList[j][0] = vertex.x;
vertexList[j][1] = vertex.y;
vertexList[j][2] = vertex.z;
normalList[j][0] = vertexNormal.x;
normalList[j][1] = vertexNormal.y;
normalList[j][2] = vertexNormal.z;
}
valueListTriangle[0] = (GzPointer)vertexList;
valueListTriangle[1] = (GzPointer)normalList;
GzPutTriangle(m_pRender, 2, 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
switch(currRenderFunc)
{
case 1:
{
CreateDepthMap(m_pDisplay, m_pDepthMap);
BlurDepthMap(m_pDepthMap, m_pDepthMapBlurred);
CopyToFrameBuffer(m_pFrameBuffer, m_pDepthMapBlurred);
break;
}
case 2:
{
CreateDepthMap(m_pDisplay, m_pDepthMap);
BlurDepthMap(m_pDepthMap, m_pDepthMapBlurred);
GetEdgeMap(m_pDepthMapBlurred, m_pEdgeMap, m_pFF1_x, m_pFF1_y, m_pGradient);
CopyToFrameBuffer(m_pFrameBuffer, m_pEdgeMap);
break;
}
case 3:
{
ApplyGaussianBlur(m_pFrameBuffer, m_p3DImageBlurred, m_ifilterLength);
CopyToFrameBuffer(m_pFrameBuffer, m_p3DImageBlurred);
break;
}
case 4:
{
ApplyGaussianBlur(m_pFrameBuffer, m_p3DImageBlurred, m_ifilterLength);
MultiplyImageWithTexture(m_p3DImageBlurred, m_pProceduralTexture, m_pTextureImageMult);
CopyToFrameBuffer(m_pFrameBuffer, m_pTextureImageMult);
break;
}
case 5:
{
ApplyGaussianBlur(m_pFrameBuffer, m_p3DImageBlurred, m_ifilterLength);
MultiplyImageWithTexture(m_p3DImageBlurred, m_pImageTexture, m_pTextureImageMult);
CopyToFrameBuffer(m_pFrameBuffer, m_pTextureImageMult);
break;
}
case 6:
{
CreateDepthMap(m_pDisplay, m_pDepthMap);
BlurDepthMap(m_pDepthMap, m_pDepthMapBlurred);
GetEdgeMap(m_pDepthMapBlurred, m_pEdgeMap, m_pFF1_x, m_pFF1_y, m_pGradient);
FindForceField(m_pFF1_x, m_pFF1_y, m_pGradient, m_pFF_x, m_pFF_y);
unsigned char* output;
GzNewFrameBuffer(&output, m_nWidth, m_nHeight);
DrawLooseStrokes(m_pEdgeMap, m_pFF_x, m_pFF_y, output);
CopyToFrameBuffer(m_pFrameBuffer, output);
break;
}
case 7:
{
CreateDepthMap(m_pDisplay, m_pDepthMap);
BlurDepthMap(m_pDepthMap, m_pDepthMapBlurred);
GetEdgeMap(m_pDepthMapBlurred, m_pEdgeMap, m_pFF1_x, m_pFF1_y, m_pGradient);
ApplyGaussianBlur(m_pFrameBuffer, m_p3DImageBlurred, m_ifilterLength);
if (lastTexture == 1)
CopyToFrameBuffer(m_pTexture, m_pImageTexture);
else
CopyToFrameBuffer(m_pTexture, m_pProceduralTexture);
MultiplyImageWithTexture(m_p3DImageBlurred, m_pTexture, m_pTextureImageMult);
FindForceField(m_pFF1_x, m_pFF1_y, m_pGradient, m_pFF_x, m_pFF_y);
DrawLooseStrokes(m_pEdgeMap, m_pFF_x, m_pFF_y, m_pTextureImageMult);
CopyToFrameBuffer(m_pFrameBuffer, m_pTextureImageMult);
break;
}
default:
break;
}
//CreateDepthMap(m_pDisplay, m_pDepthMap);
//BlurDepthMap(m_pDepthMap, m_pDepthMapBlurred);
//GetEdgeMap(m_pDepthMapBlurred, m_pEdgeMap, m_pFF1_x, m_pFF1_y, m_pGradient);
//ApplyGaussianBlur(m_pFrameBuffer, m_p3DImageBlurred, 9);
//MultiplyImageWithTexture(m_p3DImageBlurred, m_pPaperTexture, m_pTextureImageMult);
//
//FindForceField(m_pFF1_x, m_pFF1_y, m_pGradient, m_pFF_x, m_pFF_y);
//unsigned char* output;
//GzNewFrameBuffer(&output, m_nWidth, m_nHeight);
////DrawLine(line, 1, 230, 200, 210, 0, 0, 0);
////DrawForceField(m_pDepthMap, m_pFF_x, m_pFF_y);
//DrawLooseStrokes(m_pEdgeMap, m_pFF_x, m_pFF_y, m_pTextureImageMult);
//CopyToFrameBuffer(m_pFrameBuffer, m_pTextureImageMult);
/*
* Close file
*/
if( fclose( outfile ) )
AfxMessageBox( "The output file was not closed\n" );
if (status)
return(GZ_FAILURE);
else
return(GZ_SUCCESS);
}
void Project::BlurGradientMap9(unsigned char *gradmap, unsigned char *gradmapBlurred)
{
float filter[9][9] = {
1, 2, 4, 8, 16, 8, 4, 2, 1,
2, 4, 8, 16, 32, 16, 8, 4, 2,
4, 8, 16, 32, 64, 32, 16, 8, 4,
8, 16, 32, 64, 128, 64, 32, 16, 8,
16, 32, 64, 128, 256, 128, 64, 32, 16,
8, 16, 32, 64, 128, 64, 32, 16, 8,
4, 8, 16, 32, 64, 32, 16, 8, 4,
2, 4, 8, 16, 32, 16, 8, 4, 2,
1, 2, 4, 8, 16, 8, 4, 2, 1,
};
float mag = 256.0 * 256.0;
unsigned char* extendedGradmap;
GzNewFrameBuffer(&extendedGradmap, m_nWidth + 8, m_nHeight + 8);
for (int y = 0; y < m_nHeight + 4; ++y)
{
for (int x = 0; x < m_nWidth + 4; ++x)
{
int framebufferIndex = 3 * x + (y * (m_nWidth + 4) * 3);
extendedGradmap[framebufferIndex] = 0;
}
}
for (int y = 0; y < m_nHeight; ++y)
{
for (int x = 0; x < m_nWidth; ++x)
{
int framebufferIndex1 = 3 * (x + 4) + ((y + 4) * (m_nWidth + 4) * 3);
int framebufferIndex = 3 * x + (y * m_nWidth * 3);
extendedGradmap[framebufferIndex1] = gradmap[framebufferIndex];
}
}
for (int y = 0; y < m_nHeight; ++y)
{
for (int x = 0; x < m_nWidth; ++x)
{
int framebufferIndex1 = 3 * (x + 4) + ((y + 4) * (m_nWidth + 4) * 3);
int framebufferIndex = 3 * x + (y * m_nWidth * 3);
if (x == 0 || x == m_nWidth - 1 ||
y == 0 || y == m_nHeight - 1)
{
gradmapBlurred[framebufferIndex] = 255;
gradmapBlurred[framebufferIndex + 1] = 255;
gradmapBlurred[framebufferIndex + 2] = 255;
continue;
}
float sum = 0;
for (int j = -4; j < 5; ++j)
{
for (int i = -4; i < 5; ++i)
{
int fIndex = 3 * (x + 4 + i) + ((y + 4 + j) * (m_nWidth + 4) * 3);
sum += (extendedGradmap[fIndex] * filter[i + 4][j + 4]);
}
}
float val = ((int) (sum / mag));
gradmapBlurred[framebufferIndex] = val;
gradmapBlurred[framebufferIndex + 1] = val;
gradmapBlurred[framebufferIndex + 2] = val;
}
}
}
void Project::BlurGradientMap(unsigned char *gradmap, unsigned char *gradmapBlurred)
{
float filter[5][5] = {
1, 2, 4, 2, 1,
2, 4, 8, 4, 2,
4, 8, 16, 8, 4,
2, 4, 8, 4, 2,
1, 2, 4, 2, 1,
};
float mag = 256.0;
unsigned char* extendedGradmap;
GzNewFrameBuffer(&extendedGradmap, m_nWidth + 5, m_nHeight + 5);
for (int y = 0; y < m_nHeight + 10; ++y)
{
for (int x = 0; x < m_nWidth + 10; ++x)
{
int framebufferIndex = 3 * x + (y * m_nWidth * 3);
extendedGradmap[framebufferIndex] = 0;
}
}
for (int y = 0; y < m_nHeight; ++y)
{
for (int x = 0; x < m_nWidth; ++x)
{
int framebufferIndex1 = 3 * (x + 5) + ((y + 5) * m_nWidth * 3);
int framebufferIndex = 3 * x + (y * m_nWidth * 3);
extendedGradmap[framebufferIndex1] = gradmap[framebufferIndex];
}
}
for (int y = 0; y < m_nHeight; ++y)
{
for (int x = 0; x < m_nWidth; ++x)
{
int framebufferIndex1 = 3 * (x + 5) + ((y + 5) * m_nWidth * 3);
int framebufferIndex = 3 * x + (y * m_nWidth * 3);
if (x == 0 || x == m_nWidth - 1 ||
y == 0 || y == m_nHeight - 1)
{
gradmapBlurred[framebufferIndex] = 255;
gradmapBlurred[framebufferIndex + 1] = 255;
gradmapBlurred[framebufferIndex + 2] = 255;
continue;
}
float sum = 0;
for (int j = -2; j < 3; ++j)
{
for (int i = -2; i < 3; ++i)
{
int fIndex = 3 * (x + 5 + i) + ((y + 5 + j) * m_nWidth * 3);
sum += (extendedGradmap[fIndex] * filter[i + 2][j + 2]);
}
}
float val = ((int) (sum / mag));
gradmapBlurred[framebufferIndex] = val;
gradmapBlurred[framebufferIndex + 1] = val;
gradmapBlurred[framebufferIndex + 2] = val;
}
}
}