openGL 스터디용 gemini 생성 코드

몇년에 걸쳐서 막혔던게 이렇게 쉽게 몇번의 피드백으로 주어지다니..

공부가 의미없는 시대인가.. (현타)

 

curl -O https://raw.githubusercontent.com/nothings/stb/master/stb_image.h wget https://m.health.chosun.com/site/data/img_dir/2025/04/08/2025040803041_0.jpg mv 2025040803041_0.jpg dog.jpg

 

#include <GL/glut.h>
#include <math.h>
#include <stdio.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

// 창 크기
int width = 800;
int height = 600;

// 카메라 변수
float cam_pos_x = 5.0f, cam_pos_y = 4.0f, cam_pos_z = 5.0f;
float cam_yaw = -135.0f; // Y축 기준 회전 (좌/우)
float cam_pitch = -30.0f;  // X축 기준 회전 (상/하)
float fov = 45.0f; // 시야각 (줌인/아웃용)

// 마우스 상태 변수
int last_mouse_x, last_mouse_y;
int is_panning = 0; // 휠 드래그(패닝) 상태
int is_rotating = 0; // 좌클릭 드래그(회전) 상태

// 객체 회전 변수
float obj_rot_x = 0.0f;
float obj_rot_y = 0.0f;

// 클리핑 평면 변수
float near_plane = 1.0f;
float far_plane = 100.0f;

// 텍스처 변수
GLuint texture_id;
int texture_enabled = 1; // 텍스처 활성화 상태

// 카메라 방향 벡터 계산
void update_camera_vectors(float* front_x, float* front_z, float* up_x, float* up_y, float* up_z, float* right_x, float* right_z) {
	float yaw_rad = cam_yaw * M_PI / 180.0f;
	float pitch_rad = cam_pitch * M_PI / 180.0f;

	// 시점 방향 벡터
	*front_x = cos(yaw_rad) * cos(pitch_rad);
	*front_z = sin(yaw_rad) * cos(pitch_rad);
	
	// 오른쪽 벡터 (패닝에 사용)
	*right_x = cos(yaw_rad - M_PI / 2.0f);
	*right_z = sin(yaw_rad - M_PI / 2.0f);

	// 위쪽 벡터 (패닝에 사용)
	// 간단한 구현을 위해 Y축 고정
	*up_x = 0.0f;
	*up_y = 1.0f;
	*up_z = 0.0f;
}

void draw_scene() {
	glPushMatrix();
	glRotatef(obj_rot_x, 1.0f, 0.0f, 0.0f); // X축 회전
	glRotatef(obj_rot_y, 0.0f, 1.0f, 0.0f); // Y축 회전

	// 뚫린 상자 그리기 (6개의 면을 각각 그림)
	float thickness = 0.1f;

	// 앞면 (빨강)
	glPushMatrix();
	glColor3f(1.0, 0.0, 0.0);
	glTranslatef(0, 0, 1.5f);
	glScalef(3.0f, 3.0f, thickness);
	glutSolidCube(1.0);
	glPopMatrix();

	// 뒷면 (초록)
	glPushMatrix();
	glColor3f(0.0, 1.0, 0.0);
	glRotatef(180, 0, 1, 0);
	glTranslatef(0, 0, 1.5f);
	glScalef(3.0f, 3.0f, thickness);
	glutSolidCube(1.0);
	glPopMatrix();

	// 왼쪽 (파랑)
	glPushMatrix();
	glColor3f(0.0, 0.0, 1.0);
	glRotatef(-90, 0, 1, 0);
	glTranslatef(0, 0, 1.5f);
	glScalef(3.0f, 3.0f, thickness);
	glutSolidCube(1.0);
	glPopMatrix();

	// 오른쪽 (노랑)
	glPushMatrix();
	glColor3f(1.0, 1.0, 0.0);
	glRotatef(90, 0, 1, 0);
	glTranslatef(0, 0, 1.5f);
	glScalef(3.0f, 3.0f, thickness);
	glutSolidCube(1.0);
	glPopMatrix();

	// 윗면 (마젠타)
	glPushMatrix();
	glColor3f(1.0, 0.0, 1.0);
	glRotatef(90, 1, 0, 0);
	glTranslatef(0, 0, 1.5f);
	glScalef(3.0f, thickness, 3.0f - thickness*2);
	glutSolidCube(1.0);
	glPopMatrix();

	// 아랫면 (시안)
	glPushMatrix();
	glColor3f(0.0, 1.0, 1.0);
	glRotatef(-90, 1, 0, 0);
	glTranslatef(0, 0, 1.5f);
	glScalef(3.0f, thickness, 3.0f - thickness*2);
	glutSolidCube(1.0);
	glPopMatrix();


	// 텍스처가 입혀진 원통 그리기
	if (texture_enabled) {
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, texture_id);
	}

	glColor3f(1.0, 1.0, 1.0); // 텍스처와 곱해질 색상
	GLUquadric* quad = gluNewQuadric();
	gluQuadricTexture(quad, GL_TRUE);
	gluCylinder(quad, 0.5, 0.5, 2.0, 32, 32);
	gluDeleteQuadric(quad);

	if (texture_enabled) {
		glDisable(GL_TEXTURE_2D);
	}

	glPopMatrix();
}

// 텍스트 렌더링 함수
void render_text(int x, int y, const char* string) {
	glRasterPos2f(x, y);
	for (const char* c = string; *c != '\0'; c++) {
		glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, *c);
	}
}

// 행렬 정보 출력 함수
void draw_matrix_info() {
	GLfloat modelview[16];
	GLfloat projection[16];
	GLfloat rotation[16];
	char buffer[128];

	glGetFloatv(GL_MODELVIEW_MATRIX, modelview);
	glGetFloatv(GL_PROJECTION_MATRIX, projection);

	// 회전 행렬 계산
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();
	glRotatef(obj_rot_x, 1.0f, 0.0f, 0.0f);
	glRotatef(obj_rot_y, 0.0f, 1.0f, 0.0f);
	glGetFloatv(GL_MODELVIEW_MATRIX, rotation);
	glPopMatrix();

	glColor3f(1.0, 1.0, 1.0); // 흰색으로 설정

	// 2D 렌더링을 위해 투영 행렬 변경
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	gluOrtho2D(0, width, 0, height);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	// Model-View Matrix 정보 출력
	sprintf(buffer, "Model-View Matrix:");
	render_text(10, height - 20, buffer);
	for (int i = 0; i < 4; i++) {
		sprintf(buffer, "%.2f %.2f %.2f %.2f", modelview[i*4], modelview[i*4+1], modelview[i*4+2], modelview[i*4+3]);
		render_text(10, height - 35 - (i * 15), buffer);
	}

	// Projection Matrix 정보 출력
	sprintf(buffer, "Projection Matrix:");
	render_text(10, height - 100, buffer);
	for (int i = 0; i < 4; i++) {
		sprintf(buffer, "%.2f %.2f %.2f %.2f", projection[i*4], projection[i*4+1], projection[i*4+2], projection[i*4+3]);
		render_text(10, height - 115 - (i * 15), buffer);
	}

	// Rotation Matrix 정보 출력
	sprintf(buffer, "Rotation Matrix:");
	render_text(10, height - 180, buffer);
	for (int i = 0; i < 4; i++) {
		sprintf(buffer, "%.2f %.2f %.2f %.2f", rotation[i*4], rotation[i*4+1], rotation[i*4+2], rotation[i*4+3]);
		render_text(10, height - 195 - (i * 15), buffer);
	}

	// Near/Far 정보 출력
	sprintf(buffer, "Near: %.2f, Far: %.2f", near_plane, far_plane);
	render_text(10, height - 260, buffer);

	// 원래의 투영, 모델뷰 행렬로 복원
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
}

void display() {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	float yaw_rad = cam_yaw * M_PI / 180.0f;
	float pitch_rad = cam_pitch * M_PI / 180.0f;
	float eye_separation = 0.5f; // 눈 사이 간격

	// 오른쪽 벡터 계산
	float right_x = cos(yaw_rad - M_PI / 2.0f);
	float right_z = sin(yaw_rad - M_PI / 2.0f);

	// 왼쪽 눈 렌더링
	glViewport(0, 0, width / 2, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fov, (double)(width/2) / (double)height, near_plane, far_plane);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	float left_cam_x = cam_pos_x - right_x * eye_separation / 2.0f;
	float left_cam_z = cam_pos_z - right_z * eye_separation / 2.0f;
	float look_at_x = left_cam_x + cos(yaw_rad) * cos(pitch_rad);
	float look_at_y = cam_pos_y + sin(pitch_rad);
	float look_at_z = left_cam_z + sin(yaw_rad) * cos(pitch_rad);
	gluLookAt(left_cam_x, cam_pos_y, left_cam_z, look_at_x, look_at_y, look_at_z, 0.0, 1.0, 0.0);
	draw_scene();
	draw_matrix_info();

	// 오른쪽 눈 렌더링
	glViewport(width / 2, 0, width / 2, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fov, (double)(width/2) / (double)height, near_plane, far_plane);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	float right_cam_x = cam_pos_x + right_x * eye_separation / 2.0f;
	float right_cam_z = cam_pos_z + right_z * eye_separation / 2.0f;
	look_at_x = right_cam_x + cos(yaw_rad) * cos(pitch_rad);
	look_at_y = cam_pos_y + sin(pitch_rad);
	look_at_z = right_cam_z + sin(yaw_rad) * cos(pitch_rad);
	gluLookAt(right_cam_x, cam_pos_y, right_cam_z, look_at_x, look_at_y, look_at_z, 0.0, 1.0, 0.0);
	draw_scene();
	draw_matrix_info();

	glutSwapBuffers();
}

void reshape(int w, int h) {
	width = w;
	h = h > 0 ? h : 1;
	glViewport(0, 0, width, height);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fov, (double)width / (double)height, 1.0, 100.0);
}

void keyboard(unsigned char key, int x, int y) {
	float speed = 0.1f;
	float yaw_rad = cam_yaw * M_PI / 180.0f;

	switch (key) {
		case 'w':
			cam_pos_x += cos(yaw_rad) * speed;
			cam_pos_z += sin(yaw_rad) * speed;
			break;
		case 's':
			cam_pos_x -= cos(yaw_rad) * speed;
			cam_pos_z -= sin(yaw_rad) * speed;
			break;
		case 'a':
			cam_pos_x += cos(yaw_rad - M_PI / 2.0f) * speed;
			cam_pos_z += sin(yaw_rad - M_PI / 2.0f) * speed;
			break;
		case 'd':
			cam_pos_x -= cos(yaw_rad - M_PI / 2.0f) * speed;
			cam_pos_z -= sin(yaw_rad - M_PI / 2.0f) * speed;
			break;
		case 'r': // 리셋 기능
			cam_pos_x = 5.0f; cam_pos_y = 4.0f; cam_pos_z = 5.0f;
			cam_yaw = -135.0f;
			cam_pitch = -30.0f;
			fov = 45.0f;
			obj_rot_x = 0.0f;
			obj_rot_y = 0.0f;
			near_plane = 1.0f;
			far_plane = 100.0f;
			reshape(width, height);
			break;
		case 'i': // near 증가
			near_plane += 0.1f;
			break;
		case 'k': // near 감소
			near_plane -= 0.1f;
			if (near_plane < 0.1f) near_plane = 0.1f; // 0보다 작아지지 않도록
			break;
		case 'o': // far 증가
			far_plane += 0.1f;
			break;
		case 'l': // far 감소
			far_plane -= 0.1f;
			if (far_plane < near_plane) far_plane = near_plane + 0.1f; // near보다 작아지지 않도록
			break;
		case 't': // 텍스처 토글
			texture_enabled = !texture_enabled;
			break;
	}
	glutPostRedisplay();
}

void specialKeys(int key, int x, int y) {
	float rot_speed = 5.0f;
	switch (key) {
		case GLUT_KEY_UP:
			obj_rot_x -= rot_speed;
			break;
		case GLUT_KEY_DOWN:
			obj_rot_x += rot_speed;
			break;
		case GLUT_KEY_LEFT:
			obj_rot_y -= rot_speed;
			break;
		case GLUT_KEY_RIGHT:
			obj_rot_y += rot_speed;
			break;
	}
	glutPostRedisplay();
}

void mouse(int button, int state, int x, int y) {
	// 휠 줌 인/아웃
	if (button == 3) { // 휠 업
		fov -= 1.0f;
		if (fov < 1.0f) fov = 1.0f;
		reshape(width, height); // 투영 행렬 업데이트
	} else if (button == 4) { // 휠 다운
		fov += 1.0f;
		if (fov > 90.0f) fov = 90.0f;
		reshape(width, height); // 투영 행렬 업데이트
	}

	// 휠 클릭 (패닝)
	if (button == GLUT_MIDDLE_BUTTON) {
		if (state == GLUT_DOWN) {
			is_panning = 1;
			last_mouse_x = x;
			last_mouse_y = y;
		} else {
			is_panning = 0;
		}
	}
	
	// 좌클릭 (회전)
	if (button == GLUT_LEFT_BUTTON) {
		if (state == GLUT_DOWN) {
			is_rotating = 1;
			last_mouse_x = x;
			last_mouse_y = y;
		} else {
			is_rotating = 0;
		}
	}
	glutPostRedisplay();
}

void motion(int x, int y) {
	int dx = x - last_mouse_x;
	int dy = y - last_mouse_y;
	last_mouse_x = x;
	last_mouse_y = y;

	if (is_panning) {
		float pan_speed = 0.01f;
		float front_x, front_z, up_x, up_y, up_z, right_x, right_z;
		update_camera_vectors(&front_x, &front_z, &up_x, &up_y, &up_z, &right_x, &right_z);

		cam_pos_x -= right_x * dx * pan_speed;
		cam_pos_z -= right_z * dx * pan_speed;
		cam_pos_y += dy * pan_speed; // Y축 방향으로 이동
	} else if (is_rotating) {
		float rot_speed = 0.5f;
		obj_rot_y += dx * rot_speed;
		obj_rot_x += dy * rot_speed;
	}
	glutPostRedisplay();
}


void init() {
	glClearColor(0.1, 0.1, 0.1, 1.0);
	glEnable(GL_DEPTH_TEST);
}

// 텍스처 로드 함수
void load_texture(const char* filename) {
	int width, height, nrChannels;
	unsigned char *data = stbi_load(filename, &width, &height, &nrChannels, 0);
	if (data) {
		glGenTextures(1, &texture_id);
		glBindTexture(GL_TEXTURE_2D, texture_id);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

		GLenum format = (nrChannels == 4) ? GL_RGBA : GL_RGB;
		glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
		stbi_image_free(data);
	} else {
		printf("Failed to load texture: %s\n", filename);
		stbi_image_free(data);
	}
}

void print_help() {
	printf("====== Key Controls ======\n");
	printf(" w, a, s, d : Move Camera\n");
	printf(" Arrow Keys : Rotate Object\n");
	printf(" i, k       : Adjust Near Plane\n");
	printf(" o, l       : Adjust Far Plane\n");
	printf(" r          : Reset Camera and Object\n");
	printf(" t          : Toggle Texture\n");
	printf("--------------------------\n");
	printf("====== Mouse Controls ======\n");
	printf(" Left Drag  : Rotate Object\n");
	printf(" Wheel Drag : Pan Camera\n");
	printf(" Wheel Scroll: Zoom (Adjust FOV)\n");
	printf("==========================\n");
}

int main(int argc, char** argv) {
	print_help();
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
	glutInitWindowSize(width, height);
	glutCreateWindow("OpenGL Camera Control Demo");

	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(specialKeys);
	glutMouseFunc(mouse);
	glutMotionFunc(motion); // 마우스 버튼이 눌린 상태에서의 움직임

	init();
	load_texture("dog.jpg"); // 텍스처 로드
	glutMainLoop();

	return 0;
}