OpenGL 스피어 렌더링하기

Study/OpenGL 2011. 10. 27. 11:14

#include <windows.h>           
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gl/glut.h>   
#include <math.h>

#define	PI	3.1415926
#define	No_T	50
#define No_P	50

float	theta, phi;
float	delta_theta, delta_phi;
float	start_theta, start_phi;

float	lightPositionR[] = { 0.0f, 0.0f, 5.0f, 1.0f};
float	lightPositionG[] = { 0.0f, 0.0f, 5.0f, 1.0f};
float	lightPositionB[] = { 0.0f, 0.0f, 5.0f, 1.0f};

float	diffuseLightR[] = { 1.0f, 0.0f, 0.0f, 1.0f};
float	diffuseLightG[] = { 0.0f, 1.0f, 0.0f, 1.0f};
float	diffuseLightB[] = { 0.0f, 0.0f, 1.0f, 1.0f};

float	specularLightR[] = { 1.0f, 0.0f, 0.0f, 1.0f};
float	specularLightG[] = { 0.0f, 1.0f, 0.0f, 1.0f};
float	specularLightB[] = { 0.0f, 0.0f, 1.0f, 1.0f};

float	spotRirection[] = {0.0f, 0.0f, -1.0f};

float	diffuseLight[] =  { 0.5f, 0.5f, 0.5f, 1.0f };
float	specularLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };
float	lightPosition[] = { 0.0f, 0.0f, 10.0f, 1.0f };

GLfloat light0_position[] = {0.0f, 0.0f, 10.0f, 0.0f};

GLfloat light1_ambient[] =  {0.0f, 0.0f, 1.0f, 1.0f};
GLfloat light1_diffuse[] =  {0.0f, 0.0f, 1.0f, 1.0f};
GLfloat light1_specular[] =  {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat light1_position[] = {0.0f, 0.0f, 100.0f, 0.0f};

struct  vector3d{
	float		x;
	float		y;
	float		z;
};

struct point3d{
	float		x;
	float		y;
	float		z;
	vector3d	normal;
};
point3d		*ver;
//point3d		PP[No_T][No_P];

struct face3{
	int			v1;
	int			v2;
	int			v3;
	vector3d	normal;
};
face3		*face;

float	Radius;
float	rotationX, rotationY;
int		No_V, No_F;

float	moveX, moveY;
int		lastX, lastY;

//********************* Material Data ****************//
typedef struct materialStruct{
	GLfloat	ambient[4];
	GLfloat	diffuse[4];
	GLfloat	specular[4];
	GLfloat	shininess;
}materialStruct;

materialStruct brassMaterials = {
	{0.33, 0.22, 0.03, 0.5},
	{0.78, 0.57, 0.11, 0.5},
	{0.99, 0.91, 0.81, 0.5},
	1.0
};

materialStruct redPlasticMaterials = {
	{0.3, 0.0, 0.0, 0.0},
	{0.6, 0.0, 0.0, 0.0},
	{0.8, 0.6, 0.6, 0.0},
	5.0
};

materialStruct whiteShineyMaterials = {
	{1.0, 1.0, 1.0, 1.0},
	{1.0, 1.0, 1.0, 1.0},
	{1.0, 1.0, 1.0, 1.0},
	10.0
};

//********************* Light Data ****************//
typedef struct lightingStruct{
	GLfloat	ambient[4];
	GLfloat	diffuse[4];
	GLfloat	specular[4];
}lightingStruct;

lightingStruct whiteLighting = {
	{0.0, 0.0, 0.0, 1.0},
	{1.0, 1.0, 1.0, 1.0},
	{1.0, 1.0, 1.0, 1.0}
};

lightingStruct coloredLighting = {
	{0.2, 0.0, 0.0, 1.0},
	{0.0, 1.0, 0.0, 1.0},
	{0.0, 0.0, 1.0, 1.0}
};

GLfloat	light0_pos[4] = {0.9, 0.9, 2.25, 0.0};

materialStruct	*currentMaterials;
lightingStruct	*currentLighting;

float	angle[3];
int		axis;

void	Sphere_Vertex(void) {

int		i, j;
	int		count=0;

No_V = No_T * (No_P-2) + 2;
	ver = new point3d[No_V];
	
	start_theta = 0.0;
	delta_theta = 2* PI/ No_T;

start_phi = -PI/2.0;
	delta_phi = PI / (No_P-1);
	
	ver[count].x = Radius *  cos(-PI/2.0) * cos(0.0);
	ver[count].y = Radius *  cos(-PI/2.0) * sin(0.0);
	ver[count].z = Radius *  sin(-PI/2.0);
	count++;
	
	for (  j = 1; j < No_P-1; j++ ) {
		for ( i = 0; i < No_T; i++) {
			theta = start_theta + i * delta_theta;
			phi = start_phi + j * delta_phi;
			
			ver[count].x = Radius *  cos(phi) * cos(theta);
			ver[count].y = Radius *  cos(phi) * sin(theta);
			ver[count].z = Radius *  sin(phi);
			count++;
		}
	}

ver[count].x = Radius *  cos(PI/2.0) * cos(0.0);
	ver[count].y = Radius *  cos(PI/2.0) * sin(0.0);
	ver[count].z = Radius *  sin(PI/2.0);
	count++;
	
}

void	Modify_Vertex(void) {

int		i ;
	float	length;

for ( i = 0 ; i < No_V; i++ ) {
		if ( fabs(ver[i].z) < 0.5 ) {
			length = (4.0 * sqrt(3) - 1.0)/2.0 * fabs(ver[i].z) * fabs(ver[i].z) + 1/8.0;
			ver[i].x *= length;
			ver[i].y *= length;
		}
	}

}

void Sphere_Face(void) {
	int		count = 0;

No_F = 2 * No_T * (No_P - 2) ;
	face = new face3[No_F];

for (int i = 1; i < No_T; i++) {
		face[count].v1 = i;
		face[count].v2 = 0;
		face[count].v3 = i+1;
		count++;
	}
	face[count].v1 = No_T;
	face[count].v2 = 0;
	face[count].v3 = 1;
	count++;
	
	for ( int j = 1; j <= No_P - 3; j++ ) {
		for (int i = 1; i < No_T; i++) {
			face[count].v1 = (j-1)*No_T + i;
			face[count].v2 = (j-1)*No_T + i+1;
			face[count].v3 = j*No_T     + i;
			count++;

face[count].v1 = (j-1)*No_T + i+1;
			face[count].v2 = j*No_T     + i+1;
			face[count].v3 = j*No_T     + i;
			count++;
		}
		face[count].v1 = j*No_T;
		face[count].v2 = (j-1)*No_T + 1;
		face[count].v3 = (j+1)*No_T;
		count++;

face[count].v1 = (j-1)*No_T + 1;
		face[count].v2 =  j   *No_T + 1;
		face[count].v3 = (j+1)*No_T;
		count++;
	}
	for ( i = 1; i < No_T; i++) {
		face[count].v1 = (No_P-3)*No_T + i;
		face[count].v2 = (No_P-3)*No_T + i+1;
		face[count].v3 = (No_P-2)*No_T + 1;
		count++;
	}
	face[count].v1 = (No_P-2)*No_T ;
	face[count].v2 = (No_P-3)*No_T + 1;
	face[count].v3 = (No_P-2)*No_T + 1;
	count++;
}

vector3d	Normalization (vector3d p) {
	float	mag;

mag = sqrt(p.x*p.x + p.y*p.y + p.z*p.z);
	p.x /= mag;
	p.y /= mag;
	p.z /= mag;

return	p;
}

vector3d Cross_Product(vector3d U, vector3d V)
{
	vector3d cross;

cross.x =         U.y * V.z - U.z * V.y ;
	cross.y = -1.0 * (U.x * V.z - U.z * V.x) ;
	cross.z =         U.x * V.y - U.y * V.x ;

return	Normalization(cross);
}

void face_normal_computation(void) {

vector3d	U, V;
	int			first, second, third;

for ( int j = 0; j < No_F; j++ ) {
		first  = face[j].v1;
		second = face[j].v2; 
		third  = face[j].v3;

U.x = ver[third].x - ver[second].x;
		U.y = ver[third].y - ver[second].y;
		U.z = ver[third].z - ver[second].z;

V.x = ver[first].x - ver[second].x;
		V.y = ver[first].y - ver[second].y;
		V.z = ver[first].z - ver[second].z;

face[j].normal = Cross_Product(U, V);
	}
}

float	Vector_Magnitude(vector3d U) {
	 return(sqrt(U.x*U.x + U.y*U.y + U.z*U.z));
}

void vertex_normal_computation(void) {
	vector3d	temp_normal;
	int			*index;
	int			count;

for ( int i = 0 ; i < No_V; i++ ) {
		index = new int[100];
		count = 0;
		for ( int j = 0; j < No_F; j++ ) {
			if ( i == face[j].v1 || i == face[j].v2 || i == face[j].v3 ) {
				index[count] = j;
				count++;
			}
		}
		temp_normal.x = 0.0;
		temp_normal.y = 0.0;
		temp_normal.z = 0.0;
		for ( int k = 0; k < count ; k++ ) {
			temp_normal.x += face[index[k]].normal.x;
			temp_normal.y += face[index[k]].normal.y;
			temp_normal.z += face[index[k]].normal.z;
		}
		temp_normal.x /= count;
		temp_normal.y /= count;
		temp_normal.z /= count;

ver[i].normal = Normalization(temp_normal);
	
		delete(index);
	}
}

void draw_object(void) {
	for ( int i = 0; i < No_F; i++ ) {
		glBegin(GL_POLYGON);	
			glNormal3f(ver[face[i].v1].normal.x, ver[face[i].v1].normal.y, ver[face[i].v1].normal.z );
			glVertex3f(ver[face[i].v1].x, ver[face[i].v1].y, ver[face[i].v1].z );
			glNormal3f(ver[face[i].v2].normal.x, ver[face[i].v2].normal.y, ver[face[i].v2].normal.z );
			glVertex3f(ver[face[i].v2].x, ver[face[i].v2].y, ver[face[i].v2].z );
			glNormal3f(ver[face[i].v3].normal.x, ver[face[i].v3].normal.y, ver[face[i].v3].normal.z );
			glVertex3f(ver[face[i].v3].x, ver[face[i].v3].y, ver[face[i].v3].z );
		glEnd();
	}
}

void init (void)
{
	glClearColor (0.0, 0.0, 0.0, 0.0) ;

glShadeModel(GL_SMOOTH);
//	glShadeModel(GL_FLAT);

glEnable(GL_DEPTH_TEST);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
	glLightf (GL_LIGHT0, GL_SPOT_CUTOFF, 40.0f);
	glLightf (GL_LIGHT0, GL_SPOT_EXPONENT, 80.0f);

glEnable(GL_LIGHT1);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLightR);
	glLightfv(GL_LIGHT1, GL_SPECULAR, specularLightR);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPositionR);

glEnable(GL_COLOR_MATERIAL);
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
	glMaterialfv(GL_FRONT, GL_SPECULAR, specularLight);
	glMateriali(GL_FRONT, GL_SHININESS, 128);
/*
	currentMaterials = &redPlasticMaterials;
	glMaterialfv(GL_FRONT, GL_AMBIENT, currentMaterials->ambient);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, currentMaterials->diffuse);
	glMaterialfv(GL_FRONT, GL_SPECULAR, currentMaterials->specular);
	glMaterialf(GL_FRONT, GL_SHININESS, currentMaterials->shininess);

currentLighting = &whiteLighting;
	glLightfv(GL_LIGHT0, GL_AMBIENT, currentLighting->ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, currentLighting->diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, currentLighting->specular);
	glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
*/

Radius = 1.0;
	moveX = 0.0;
	moveY = 0.0;
	lastX = 0;
	lastY = 0;

Sphere_Vertex();
	Modify_Vertex();
	Sphere_Face();
	face_normal_computation();
	vertex_normal_computation();
}

void reshape (int w, int h)
{
	glViewport(0, 0, w, h);
	glMatrixMode (GL_PROJECTION);  
	glLoadIdentity();
	gluPerspective(45.0, 1.0, 1.0, 1000);

}

void display (void)
{
	float	x, y, z;
	float	angle1, angle2;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	x = 3.0 * Radius * cos(moveY) * cos(moveX);
	y = 3.0 * Radius * cos(moveY) * sin(moveX);
	z = 3.0 * Radius * sin(moveY);
	
	glMatrixMode (GL_MODELVIEW);    
	glLoadIdentity();

gluLookAt(x, y, z, 0, 0, 0, 0.0, 0.0, 1.0);
	draw_object();

glFlush (); 
	glutSwapBuffers();
}

void SpecialKey( int key, int x, int y) {
	switch (key) {
	case GLUT_KEY_LEFT :	moveX -= 0.1;
							break;
	case GLUT_KEY_RIGHT :	moveX += 0.1;
							break;
	case GLUT_KEY_UP :		moveY += 0.1;
							break;
	case GLUT_KEY_DOWN :	moveY -= 0.1;
							break;
	default :				break;
	}
	if ( moveX > 2.0 * PI ) 
		moveX -= (2.0 * PI);
	else if ( theta < 0.0 )
		moveX += (2.0 * PI);
	glutPostRedisplay();
}

void main (int argc, char** argv)
{
    glutInit (&argc, argv);    
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);  
	glutInitWindowPosition (100, 100);    
	glutInitWindowSize (500, 500);   
	glutCreateWindow ("Bunny Lighting");  
	glutDisplayFunc (display); 
	glutSpecialFunc(SpecialKey);
	glutReshapeFunc (reshape);  
	glutIdleFunc(display);

init();    
	 
	glutMainLoop();    
}

'Study > OpenGL' 카테고리의 다른 글

파노라마 VR에 대해 (0)	2011.10.27
파노라마 제작하기 (0)	2011.10.27
OpenGL 구에 조명주기 (0)	2011.10.24
OpenGL bunny코드 분석 (0)	2011.10.16
OpenGL 중간고사 (0)	2011.10.13

Posted by 코딩하는 야구쟁이

야구를 좋아하는 프로그래머

OpenGL 스피어 렌더링하기

'Study > OpenGL' 카테고리의 다른 글

카테고리

태그목록

최근에 올라온 글

최근에 달린 댓글

최근에 받은 트랙백

글 보관함

링크

티스토리툴바