Пример #1
0
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); 
}
Пример #4
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);
}
Пример #5
0
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); 
}
Пример #8
0
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); 
}
Пример #9
0
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;
		}
	}

}
Пример #10
0
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;
		}
	}

}