static int render_teapot_refraction(GzRender* in_renderer)
{
	//setup shader and teapot material
	in_renderer->v_shader = GouraudVertexShader;
	in_renderer->p_shader = GouraudAlphaPixelShader;

	//use the same material for ambient, diffuse and specular
	GzColor material_color = {0.7f, 0.3f, 0.1f};
	for(int i=0; i<3; i++)
	{
		in_renderer->Ka[i] = material_color[i];
		in_renderer->Kd[i] = material_color[i];
		in_renderer->Ks[i] = material_color[i];
	}
	in_renderer->spec = 32;

	//setup transform
	GzMatrix m;
	GzScaleMat(teapot_scale, m);
	GzPushMatrix(in_renderer, m);
	GzCoord pos = {teapot_position[0], teapot_position[1]/1.33f, teapot_position[2]};
	GzTrxMat(pos, m);
	GzPushMatrix(in_renderer, m);
	GzTrxMat(teapot_rotation, m);
	GzPushMatrix(in_renderer, m);

	GzPutCamera(renderer, &default_camera);

	GzBeginRender(in_renderer);

	GzToken		nameListTriangle[4];		/* vertex attribute names */
	GzPointer	valueListTriangle[4]; 			/* vertex attribute pointers */
	nameListTriangle[0] = GZ_POSITION; 
	nameListTriangle[1] = GZ_NORMAL; 
	nameListTriangle[2] = GZ_TEXTURE_INDEX;  
	nameListTriangle[3] = GZ_RGB_COLOR;

	const Model::TriangleVector& triangles = teapot_model.GetData();
	for(Model::TriangleVector::const_iterator it = triangles.begin(); it != triangles.end(); it++) 
	{ 	
		valueListTriangle[0] = (GzPointer)(*it)->vertices; 
		valueListTriangle[1] = (GzPointer)(*it)->normals; 
		valueListTriangle[2] = (GzPointer)(*it)->uvs; 
		GzPutTriangle(in_renderer, 3, nameListTriangle, valueListTriangle); 
	}

	return GZ_SUCCESS;
}
static int render_water_plane(GzRender* in_renderer)
{
	//setup shader and teapot material
	in_renderer->v_shader = PhongVertexShader;
	in_renderer->p_shader = PhongPixelShader;

	//use the same material for ambient, diffuse and specular
	GzColor material_color = {0.04f, 0.4f, 0.6f};
	for(int i=0; i<3; i++)
	{
		in_renderer->Ka[i] = material_color[i];
		in_renderer->Kd[i] = material_color[i];
		in_renderer->Ks[i] = material_color[i];
	}
	in_renderer->spec = 32;

	GzPutCamera(renderer, &default_camera);

	//setup transform
	GzCoord scale = {3.0f, 1.0f, 1.5f};
	GzMatrix m;
	GzScaleMat(scale,m);
	GzPushMatrix(in_renderer, m);

	GzBeginRender(in_renderer);

	GzToken		nameListTriangle[4];		/* vertex attribute names */
	GzPointer	valueListTriangle[4]; 			/* vertex attribute pointers */
	nameListTriangle[0] = GZ_POSITION; 
	nameListTriangle[1] = GZ_NORMAL; 
	nameListTriangle[2] = GZ_TEXTURE_INDEX;  
	nameListTriangle[3] = GZ_RGB_COLOR;

	const Model::TriangleVector& triangles = water_plane_model.GetData();
	for(Model::TriangleVector::const_iterator it = triangles.begin(); it != triangles.end(); it++) 
	{ 	
		valueListTriangle[0] = (GzPointer)(*it)->vertices; 
		valueListTriangle[1] = (GzPointer)(*it)->normals; 
		valueListTriangle[2] = (GzPointer)(*it)->uvs; 
		GzPutTriangle(in_renderer, 3, nameListTriangle, valueListTriangle); 
	}

	return GZ_SUCCESS;
}
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); 
}
Ejemplo n.º 5
0
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 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); 
}