구차니의 잡동사니 모음

대충 한달 정도? 글을 쓰고 정리 안해서 공개도 못하고 있다.

일이 바쁜건지

체력이 후달리는건지

혹은 둘다인지.. 쩝..

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

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

#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;
}

indicator 혹은 active buzzer는 내부에 회로가 내장되어

전기만 공급되면 resonant frequency 로 소리를 발생시키는 부품이다.

transducer 라던가 passive buzzer가 pwm에 의해 주파수로 입력하면 원하는 소리가 나는 부품인듯.

[링크 : https://puiaudio.com/file/specs-AI-1223-TWT-3V-2-R.pdf]

개인 권한으로 하려니 안되서 어쩔수 없이 root 권한으로 설치 --

[링크 : https://github.com/google-gemini/gemini-cli]

이후에 계정 연동해서 하려는데 회사 계정으로는 안된다.

나중에 개인 계정으로 시도해 봐야겠다.

[링크 : https://www.youtube.com/watch?v=fb60_3iSF44]

[링크 : https://gamhongshi.tistory.com/22]

[링크 : https://ics.uci.edu/~fielding/pubs/dissertation/top.htm]

HATEOAS - Hypermedia As The Engine of Application State

요즘 SaaS 쓰니까 굳이 요즘 스타일로 바꾸면 HaTEoAS 라고 해야하나? ㅋㅋ

[링크 : https://wonit.tistory.com/454]

[링크 : https://dev-coco.tistory.com/187]

대성리 근처의 호빵 맛집

아내가 야채 맛있다고 극찬

갓바위찐빵만두

[링크 : https://blog.naver.com/godbawe_cp]

어우 왜 3층이야 -_ㅠ

자다가 수영장 이용 시간이 끝나버렸고

애들 데리고 키즈카페에서 죽칠 예정 ㅋㅋ

내 속옷 넣는 서랍장이랑

애들 속옷 넣는 서랍장이 무너져서

어찌 맞겠지 생각에 좀더 폭이 넓은걸로 해서 구매하고

오늘 배송받아 드라이버로 한땀한땀 교체!

아내도 나도 만족!

만원에 레일 3개에 배송비 들인거 치고는 꽤 만족스럽다.

[링크 : http://itempage3.auction.co.kr/DetailView.aspx?ItemNo=C337662970&frm3=V2]

awk로 쇼할 바에는 이게 최고구만

[링크  https://packages.debian.org/search?keywords=csvtool]

+

2025.07.31

csv 파일에서 특정 셀을 뽑아내서 합계를 구하려는데

mlr과 csvtool을 gpt가 추천해줘서 찾아보게 됨

30도인데 의외로 덥지 않은 느낌

한국의 여름인데.. 왜 습하지 않지?