Attachment 115854 Details for Bug 90435 – shadow.c

shadow.c

shadow.c (text/plain), 12.54 KB, created by Ilya on 2015-05-17 14:00:02 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ilya

Created: 2015-05-17 14:00:02 UTC

Size: 12.54 KB

patch

obsolete

>#include <GL/gl.h>
>#include <GL/glu.h>
>#include <GL/glut.h>
>#include <time.h>
>#include <signal.h>
>
>#define facenum 14
>#define rebrnum 15
>#define vertnum 9
>
>/*typedef
>	struct {
>		int face1;
>		int face2;
>		int face3;
>		double normal[3];
>	} ADJ;
>*/
>GLfloat bigvalue = 5.0;
>
>short int backculled[facenum];
>int adjacency[facenum][3];
>
>GLfloat /*normals[facenum][3],*/ normalsm[facenum][3];
>
>GLfloat volume[rebrnum][4][3];
>int volumesize;
>
>GLfloat vertexm[vertnum][3], vertexes[vertnum][3] = {
>	0.5, 0.5, 0.5,
>	0.5, 0.5, -0.5,
>	0.5, -0.5, -0.5,
>	0.5, -0.5, 0.5,
>	-0.5, 0.5, 0.5,
>	-0.5, 0.5, -0.5,
>	-0.5, -0.5, -0.5,
>	-0.5, -0.5, 0.5,
>	0.0, -1.0, 0.0 };
>
>GLfloat vectors_tl[vertnum][3];
>
>int faces[facenum][3] = {
>	0, 3, 2,
>	1, 0, 2,
>	4, 7, 3,
>	0, 4, 3,
>	5, 6, 7,
>	4, 5, 7,
>	1, 2, 6,
>	5, 1, 6,
>	5, 4, 0,
>	1, 5, 0,
>
>	3, 8, 2,
>	7, 8, 3,
>	6, 8, 7,
>	2, 8, 6 };
>	
>void CalcAdjacency(int adjacency[][3], int facecount) {
>	int i, j, k, l;
>	short int s, a[2], b[2];
>	
>	for (i=0; i<facecount; i++)
>		for(j=0; j<3; j++)
>			adjacency[i][j]=-1;
>	
>	for (i=0; i<facecount; i++) {
>		s=0;
>		for (j=0; (j<3)&&(adjacency[i][j]!=-1); j++) s++;
>		if (s == 3) continue; //÷ÏÚÍÏÖÎÏ, ÞÔÏ ÍÏÖÎÏ ÉÓÐÏÌØÚÏ×ÁÔØ ÎÅ s, Á j
>		for (j=0; j<facecount; j++) {
>			if ((j == i) || (j == adjacency[i][0]) ||
>				(j == adjacency[i][1]) ||
>				(j == adjacency[i][2])) continue;
>			s=0;
>			for (k=0; k<3; k++)
>				for (l=0; l<3; l++)
>					if (faces[i][k]==faces[j][l]) {
>						a[s]=k; b[s]=l;
>						s++;
>						break;
>					};
>			if (s==2) {
>				adjacency[i][a[0]+a[1]-1]=j; //ôÏ,ÞÔÏ ÄÏÌÖÎÏ ÂÙÔØ ÎÁ 2-Í
>				adjacency[j][b[0]+b[1]-1]=i; //óÔÏÉÔ ÎÁ 3-Í É ÎÁÏÂÏÒÏÔ
>			};
>		};
>	};
>};
>
>void CalcNormals(GLfloat normals[][3], GLfloat vertexes[][3], int faces[][3], int count) {
>	int i, j;
>	GLfloat a[3], b[3];
>	
>	for (i=0; i<count; i++) {
>		for (j=0; j<3; j++) {
>			a[j]=vertexes[faces[i][0]][j]-vertexes[faces[i][1]][j];
>			b[j]=vertexes[faces[i][2]][j]-vertexes[faces[i][1]][j];
>		};
>		normals[i][0]=b[1]*a[2]-b[2]*a[1];
>		normals[i][1]=b[2]*a[0]-b[0]*a[2];
>		normals[i][2]=b[0]*a[1]-b[1]*a[0];
>	};
>};
>
>void BuildVolume(const GLfloat lightpos[], int adjacency[][3], int count, GLfloat vertexes[][3], 
>		GLfloat normals[][3]) {
>	int i, j, k;
>//	double lightvector[2][3];
>	int vs=0;
>	GLfloat s;
>	
>	for (i=0; i<vertnum; i++) {
>		vectors_tl[i][0]=lightpos[0]-vertexes[i][0];
>		vectors_tl[i][1]=lightpos[1]-vertexes[i][1];
>		vectors_tl[i][2]=lightpos[2]-vertexes[i][2];
>	};
>
>	for (i=0; i<count; i++) {
>//		if (backculled[i]) continue;
>		
>//		for (k=0; k<3; k++) lightvector[0][k]=lightpos[k]-vertexes[faces[i][0]][k];
>//		for (k=0; k<3; k++) lightvector[1][k]=lightpos[k]-vertexes[faces[i][1]][k];
>		
>		s=0;
>		for (k=0; k<3; k++)
>			s+=vectors_tl[faces[i][0]][k]*normals[i][k];
>		if (s>0) {
>			
>			for (j=0; j<3; j++) {
>			s=0;
>			
>			for (k=0; k<3; k++)
>				s+=normals[adjacency[i][j]][k]*vectors_tl[faces[adjacency[i][j]][0]][k];
>			if (s<=0) {
>				backculled[adjacency[i][j]]=1;
>				switch (j) {
>				case 0:
>					for (k=0; k<3; k++) {
>						volume[vs][0][k]=vertexes[faces[i][0]][k];
>						volume[vs][1][k]=vertexes[faces[i][1]][k];
>						volume[vs][2][k]=vertexes[faces[i][0]][k]-bigvalue*
>							vectors_tl[faces[i][0]][k];
>						volume[vs][3][k]=vertexes[faces[i][1]][k]-bigvalue*
>							vectors_tl[faces[i][1]][k];
>					};
>					break;
>				case 1:
>					for (k=0; k<3; k++) {
>						volume[vs][0][k]=vertexes[faces[i][2]][k];
>						volume[vs][1][k]=vertexes[faces[i][0]][k];
>						volume[vs][2][k]=vertexes[faces[i][2]][k]-bigvalue*
>							vectors_tl[faces[i][2]][k];
>						volume[vs][3][k]=vertexes[faces[i][0]][k]-bigvalue*
>							vectors_tl[faces[i][0]][k];
>					};
>					break;
>				case 2:
>					for (k=0; k<3; k++) {
>						volume[vs][0][k]=vertexes[faces[i][1]][k];
>						volume[vs][1][k]=vertexes[faces[i][2]][k];
>						volume[vs][2][k]=vertexes[faces[i][1]][k]-bigvalue*
>							vectors_tl[faces[i][1]][k];
>						volume[vs][3][k]=vertexes[faces[i][2]][k]-bigvalue*
>							vectors_tl[faces[i][2]][k];
>					};
>					break;
>				};
>				vs++;
>			};
>			};
>		};
>	};
>	volumesize=vs;
>};
>
>GLfloat anglecube = 0.0, angle = 0.0;
>GLfloat slag = 0.2;
>GLfloat lp[3], lightpos[4] = {0.0, 0.0, 2.0, 1.0};
>GLUquadricObj *qo;
>
>void TransformLP(GLfloat vertexes[][3], GLfloat vertexm[][3],
>		const GLfloat angle, const GLfloat x, const GLfloat y, const GLfloat z)
>{
>	GLfloat m[9], mt[16], buf[16], c, s;
>	int i;
>	
>/*	
>	c=cos(angle); s=sin(angle);
>	m[0]=x*x*(1-c)+c; m[1]=y*x*(1-c)+z*s; m[2]=x*z*(1-c)-y*s;
>	m[3]=x*y*(1-c)-z*s; m[4]=y*y*(1-c)+c; m[5]=y*z*(1-c)+x*s;
>	m[6]=x*z*(1-c)+y*s; m[7]=y*z*(1-c)-x*s; m[8]=z*z*(1-c)+c;
>	lp[0]=lightpos[0]*m[0]+lightpos[1]*m[1]+lightpos[2]*m[2];
>	lp[1]=lightpos[0]*m[3]+lightpos[1]*m[4]+lightpos[2]*m[5];
>	lp[2]=lightpos[0]*m[6]+lightpos[1]*m[7]+lightpos[2]*m[8];
>*/
>	for (i=0; i<16; buf[i++]=0.0);
>	glPushMatrix();
>	glLoadIdentity();
>	glRotatef(angle, x, y, z);
>	glGetFloatv(GL_MODELVIEW_MATRIX, mt);
>	for (i=0; i<vertnum; i++) {
>//		glLoadMatrixf(mt);
>		buf[12]=vertexes[i][0]; buf[13]=vertexes[i][1];
>		buf[14]=vertexes[i][2]; buf[15]=1.0;
>		glLoadMatrixf(mt);
>		glMultMatrixf(buf);
>		glGetFloatv(GL_MODELVIEW_MATRIX, buf);
>		vertexm[i][0]=buf[12]; vertexm[i][1]=buf[13]; vertexm[i][2]=buf[14];
>/*
>        c=cos(angle); s=sin(angle);
>        m[0]=x*x*(1-c)+c; m[1]=y*x*(1-c)+z*s; m[2]=x*z*(1-c)-y*s;
>        m[3]=x*y*(1-c)-z*s; m[4]=y*y*(1-c)+c; m[5]=y*z*(1-c)+x*s;
>        m[6]=x*z*(1-c)+y*s; m[7]=y*z*(1-c)-x*s; m[8]=z*z*(1-c)+c;
>        lp[0]=lightpos[0]*m[0]+lightpos[1]*m[1]+lightpos[2]*m[2];
>        lp[1]=lightpos[0]*m[3]+lightpos[1]*m[4]+lightpos[2]*m[5];
>        lp[2]=lightpos[0]*m[6]+lightpos[1]*m[7]+lightpos[2]*m[8];
>*/
>	};
>	glPopMatrix();
>};
>
>//òÁÚÂÉ×ÁÅÍ ÔÒÅÕÇÏÌØÎÉË ÎÁ ÎÅÓËÏÌØËÏ ÔÒÅÕÇÏÌØÎÉËÏ× É ÒÉÓÕÅÍ ÉÈ. (ÄÌÑ ÂÏÌÅÅ ÔÏÞÎÏÇÏ ÏÓ×ÅÝÅÎÉÑ ÐÏ×ÅÒÈÎÏÓÔÉ)
>void DrawTriangle(float *s1, float *s2, float *s3, int a)
>{
>//        const float size = 0.2;
>        float s12[3], s23[3], s31[3];
>
>/*      if (
>        ((sqr(s1[0]-s2[0])+sqr(s1[1]-s2[1])+sqr(s1[2]-s2[2]))<size) &&
>        ((sqr(s2[0]-s3[0])+sqr(s2[1]-s3[1])+sqr(s2[2]-s3[2]))<size) &&
>        ((sqr(s1[0]-s3[0])+sqr(s1[1]-s3[1])+sqr(s1[2]-s3[2]))<size) ) */
>        if (a > 1)
>        {
>                        glVertex3f(s1[0], s1[1], s1[2]);
>                        glVertex3f(s2[0], s2[1], s2[2]);
>                        glVertex3f(s3[0], s3[1], s3[2]);
>                return;
>        };
>        s12[0] = (s1[0]+s2[0])/2;
>        s12[1] = (s1[1]+s2[1])/2;
>        s12[2] = (s1[2]+s2[2])/2;
>
>        s23[0] = (s2[0]+s3[0])/2;
>        s23[1] = (s2[1]+s3[1])/2;
>        s23[2] = (s2[2]+s3[2])/2;
>
>        s31[0] = (s1[0]+s3[0])/2;
>        s31[1] = (s1[1]+s3[1])/2;
>        s31[2] = (s1[2]+s3[2])/2;
>
>        DrawTriangle(s1, s12, s31, a+1);
>        DrawTriangle(s12, s2, s23, a+1);
>        DrawTriangle(s31, s23, s3, a+1);
>        DrawTriangle(s12, s23, s31, a+1);
>}
>
>/*void DrawTriangle(float s[][3], int a)
>{8
>//        const float size = 0.2;
>//        float s12[3], s23[3], s31[3];
>	float sx[3][3];
>
>        if (a > 4)
>        {
>                   	glVertex3fv(s[0]);
>                        glVertex3fv(s[1]);
>                        glVertex3fv(s[2]);
>                	return;
>        };
>        sx[0][0] = (s[0][0]+s[1][0])/2;
>        sx[0][1] = (s[0][1]+s[1][1])/2;
>        sx[0][2] = (s[0][2]+s[1][2])/2;
>
>        sx[1][0] = (s[1][0]+s[2][0])/2;
>        sx[1][1] = (s[1][1]+s[2][1])/2;
>        sx[1][2] = (s[1][2]+s[2][2])/2;
>
>        sx[2][0] = (s[0][0]+s[2][0])/2;
>        sx[2][1] = (s[0][1]+s[2][1])/2;
>        sx[2][2] = (s[0][2]+s[2][2])/2;
>
>        DrawTriangle(s[0], sx[0], sx[2], a+1);
>        DrawTriangle(sx[0], s[1], sx[1], a+1);
>        DrawTriangle(sx[2], sx[1], s[2], a+1);
>        DrawTriangle(sx[0], sx[1], sx[2], a+1);
>}
>*/
>
>void Display() {
>	int i,j;
>	GLfloat lp[4], sd[3];
>	GLfloat mt[16] = {
>		0.0, 0.0, 0.0, 0.0,
>		0.0, 0.0, 0.0, 0.0,
>		0.0, 0.0, 0.0, 0.0,
>		0.0, 0.0, 0.0, 0.0 };
>	
>	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>
>	glPushMatrix();
>	glLoadIdentity();
>	glRotatef(angle, 0.0, 1.0, 0.0);
>	mt[12]=lightpos[0]; mt[13]=lightpos[1];
>	mt[14]=lightpos[2]; mt[15]=lightpos[3];
>	glMultMatrixf(mt);
>	glGetFloatv(GL_MODELVIEW_MATRIX, mt);
>	glPopMatrix();
>	
>	glPushMatrix();
>	glRotatef(angle, 0.0, 1.0, 0.0);
>	glPushMatrix();
>	glDisable(GL_LIGHTING);
>	glTranslatef(lightpos[0], lightpos[1], lightpos[2]);
>	glColor3f(0.0, 1.0, 0.0);
>	glutWireCube(0.2);
>	glPopMatrix();
>	glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
>//	sd[0]=-lightpos[0]; sd[1]=-lightpos[1]; sd[2]=-lightpos[2];
>//	glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, sd);
>	glEnable(GL_LIGHTING);
>	glPopMatrix();
>	
>	glPushMatrix();
>	
>	glColor3f(0.6, 0.3, 0.7);
>	glBegin(GL_QUADS);
>	glNormal3f(0.0, 0.0, 1.0);
>	glVertex3f(3.0, 3.0, -2.5);
>	glVertex3f(-3.0, 3.0, -2.5);
>	glVertex3f(-3.0, -3.0, -2.5);
>	glVertex3f(3.0, -3.0, -2.5);
>	glNormal3f(1.0, 0.0, 0.0);
>	glVertex3f(-3.0, 3.0, -2.5);
>	glVertex3f(-3.0, 3.0, 2.5);
>	glVertex3f(-3.0, -3.0, 2.5);
>	glVertex3f(-3.0, -3.0, -2.5);
>	glEnd();
>
>
>	TransformLP(vertexes, vertexm, anglecube, 1.0, 0.5, 0.8);
>	CalcNormals(normalsm, vertexm, faces, facenum);
>	
>//	glPushMatrix();
>//	glRotatef(anglecube, 1.0, 0.5, 0.8);
>	glColor3f(0.8, 0.2, 0.15);
>	glBegin(GL_TRIANGLES);
>	for (i=0; i<facenum; i++) {
>		glNormal3f(normalsm[i][0], normalsm[i][1], normalsm[i][2]);
>//		for (j=0; j<3; j++)
>//			glVertex3fv(vertexes[faces[i][j]]);
>		DrawTriangle(vertexm[faces[i][0]], vertexm[faces[i][1]], vertexm[faces[i][2]], 0);
>	};
>	glEnd();
>//	glPopMatrix();
>	
>	glPushMatrix();
>	glTranslatef(-3.0, 0.0, 0.0);
>	glColor3f(0.1, 0.7, 0.1);
>	gluSphere(qo, 0.7, 26, 26);
>/*	glTranslatef(3.0, 0.0, -1.5);
>	glFrontFace(GL_CW);
>	glutSolidTeapot(0.7);
>	glFrontFace(GL_CCW);*/
>	glPopMatrix();
>	
>	BuildVolume(&mt[12], adjacency, facenum, vertexm, normalsm);
>	glDisable(GL_LIGHTING);
>	glEnable(GL_STENCIL_TEST);
>	glClearStencil(1);
>	glClear(GL_STENCIL_BUFFER_BIT);
>	glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);
>	glDepthMask(GL_FALSE);
>	glEnable(GL_DEPTH_TEST);
>	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
>	glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
>	glColor3f(1.0, 0.0, 0.0);
>	glCullFace(GL_BACK);
>	glBegin(GL_TRIANGLES);
>	for (i=0; i<volumesize; i++) {
>		glVertex3fv(volume[i][0]);
>		glVertex3fv(volume[i][1]);
>		glVertex3fv(volume[i][2]);
>		glVertex3fv(volume[i][3]);
>		glVertex3fv(volume[i][2]);
>		glVertex3fv(volume[i][1]);
>	};
>	glEnd();
>	glStencilOp(GL_KEEP, GL_KEEP, GL_DECR);
>//	glFrontFace(GL_CW);
>	glCullFace(GL_FRONT);
>	
>	glBegin(GL_TRIANGLES);
>	for (i=0; i<volumesize; i++) {
>		glVertex3fv(volume[i][0]);
>		glVertex3fv(volume[i][1]);
>		glVertex3fv(volume[i][2]);
>		glVertex3fv(volume[i][3]);
>		glVertex3fv(volume[i][2]);
>		glVertex3fv(volume[i][1]);
>	};
>	glEnd();
>	
>//	glFrontFace(GL_CCW);
>	glCullFace(GL_BACK);
>
>	glStencilFunc(GL_GREATER, 1, 0xFFFFFFFF);
>	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
>	glDisable(GL_DEPTH_TEST);
>	glEnable(GL_BLEND);
>	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
>	glBegin(GL_QUADS);
>		glColor4f(0.0, 0.0, 0.0, 0.5);
>		glVertex3f(6.0, 6.0, 0.0);
>		glVertex3f(-6.0, 6.0, 0.0);
>		glVertex3f(-6.0, -6.0, 0.0);
>		glVertex3f(6.0, -6.0, 0.0);
>	glEnd();
>	glDisable(GL_BLEND);
>	glDisable(GL_STENCIL_TEST);
>	glDepthMask(GL_TRUE);
>	glEnable(GL_LIGHTING);
>	glEnable(GL_DEPTH_TEST);
>	glPopMatrix();
>	glutSwapBuffers();
>};
>
>int FPS=0;
>
>void Idle() {
>	angle+=slag;
>	anglecube+=0.2;
>	if (anglecube > 360.0) anglecube-=360.0;
>	if ((angle>=100.0)||(angle<=-10.0)) slag=-slag;
>	glutPostRedisplay();
>	FPS++;
>};
>
>
>void MyInit() {
>	glMatrixMode(GL_PROJECTION);
>	glLoadIdentity();
>	gluPerspective(60.0, 640.0/480.0, 2.0, 13.0);
>	glMatrixMode(GL_MODELVIEW);
>	glLoadIdentity();
>	glTranslatef(0.0, 0.0, -8.5);
>	glRotatef(-30.0, 1.0, 0.5, 0.0);
>	glEnable(GL_DEPTH_TEST);
>//	glEnable(GL_NORMALIZE);
>	glEnable(GL_CULL_FACE);
>	glEnable(GL_LIGHTING);
>//	glPolygonMode(GL_FRONT, GL_LINE);
>	glShadeModel(GL_SMOOTH);
>	glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
>	glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0);
>	glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.15);
>        glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 100.0);
>//        glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 20.0);
>	       
>	glEnable(GL_LIGHT0);
>	glEnable(GL_COLOR_MATERIAL);
>	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>	qo=gluNewQuadric();
>	alarm(1);
>};
>
>void printFPS(int i)
>{
>	printf("%s%d%s", "FPS: ", FPS, "\n");
>	FPS=0;
>	alarm(1);
>};
>
>int main(int argc, char **argv) {
>	int i;
>	struct sigaction act;
>
>	act.sa_handler = &printFPS;
>	act.sa_flags = 0;
>	sigaction(SIGALRM, &act, NULL);
>	for (i=0; i<facenum; i++) backculled[i]=0;
>
>	CalcAdjacency(adjacency, facenum);
>	CalcNormals(normalsm, vertexes, faces, facenum);
>	glutInit(&argc, argv);
>	glutInitWindowSize(640, 480);
>	glutInitWindowPosition(0, 0);
>	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);
>	glutCreateWindow("Shadow Test");
>	glutDisplayFunc(Display);
>	glutIdleFunc(Idle);
>	MyInit();
>	glutFullScreen();
>	glutMainLoop();
>};

Actions: View

Attachments on bug 90435: 115740 | 115854 | 117321

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.