windows10, visual studio 2017 환경입니다.

1. 첨부된 파일을 받습니다.

2. 압축을 해제 합니다.

3. *.lib 파일은 C:\Program Files (x86)\Windows Kits\10\Lib\10.0.15063.0\um\x86 에 모두 paste 합니다.

4. *.h 파일은 C:\Program Files (x86)\Windows Kits\10\Include\10.0.15063.0\um\gl 에 모두 paste 합니다.

(gl 폴더가 없다면 생성 후 paste 하면 된다.)

5. *dll 파일은 모두 C:\Windows\System32 에 paste 합니다.

6. VS에서 OpenGL 프로젝트를 생성할 때 소스코드 상단에 아래와 같이 작성한다.

#include <Windows.h>
#include <gl/GL.h>
#include <gl/GLU.h>
#include <gl/glut.h>
#include <gl/glaux.h>

순서가 다르면 안되는 경우도 있다고 한다. 

혹시 순서가 다르다면 순서를 같게 해본다.

opengl_lib.zip

설명

3차원 큐브를 X축, Y축, Z축 회전을 하며 (x, y, z키를 눌렀을 경우),

X, Y, Z를 눌렀을 때 우측 하단에 문자열을 출력한다.

소스코드

(앞의 예제와 마찬가지로 생략된 부분은 아래의 링크를  참조한다.)

2017/09/12 - [SW/OpenGL] - OpenGL - 사각형 회전, 색바꾸기

변수

static bool R = true;
static bool G = true;
static bool B = true;
static float theta;
bool rot = true;
int r, x_axis = 0, y_axis = 1, z_axis = 0;
int t_x, t_y, t_z;
 
/// <summary>
/// The vertices {x, y, z}
/// </summary>
GLfloat vertices[8][3] = { { -1, -1, 1 },{ -1, 1, 1 },
{ 1, 1, 1 },{ 1, -1, 1 },{ -1, -1, -1 },
{ -1, 1, -1 },{ 1, 1, -1 },{ 1, -1, -1 } };
 
/// <summary>
/// The colors {R, G, B}
/// </summary>
GLfloat colors[8][3] =
{ { 0, 0, 1 },{ 0, 1, 1 },
{ 1, 1, 1 },{ 1, 0, 1 },
{ 0, 0, 0 },{ 0, 1, 0 },
{ 1, 1, 0 },{ 1, 0, 0 } };

키보드 이벤트

void menu(int item)
{
	keyboard((unsigned char)item, 0, 0);
}
 
void keyupfunc(unsigned char key, int x, int y)
{
	t_x = 0;
	t_y = 0;
	t_z = 0;
}
 
void keyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
	case 'q' | 'Q':
		exit(0); break;
	case VK_ESCAPE:
		exit(0); break;
	case 'x' | 'X': //rotate with x axis
	{
		x_axis = 1;
		y_axis = 0;
		z_axis = 0;
		t_x = 1;
		t_y = 0;
		t_z = 0;
		break;
	}
	case 'y' | 'Y': //rotate with y axis
	{
		x_axis = 0;
		y_axis = 1;
		z_axis = 0;
		t_x = 0;
		t_y = 1;
		t_z = 0;
		break;
	}
	case 'z' | 'Z': //rotate with z axis
	{
		x_axis = 0;
		y_axis = 0;
		z_axis = 1;
		t_x = 0;
		t_y = 0;
		t_z = 1;
		break;
	}
	default:
		break;
	}
}

렌더링함수

void RenderScene(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(0.5, 0.5, 0.5, 0, 0, 0, 0, 1, 0);
 
	glPushMatrix(); {//push
		glRotatef(theta, x_axis, y_axis, z_axis);
		//draw cube
		quad(0, 3, 2, 1);
		quad(2, 3, 7, 6);
		quad(3, 0, 4, 7);
		quad(1, 2, 6, 5);
		quad(4, 5, 6, 7);
		quad(5, 4, 0, 1);
		glEnd();
	}glPopMatrix();//pop
 
	glPushMatrix(); {//push
		glColor3f(1, 0, 0);//red
		glRasterPos2f(1.4, -1.4);//string position
		if (t_x == 1)//print X_axis
			glPrint("X_axis", theta);
		else if (t_y == 1)//print Y_axis
			glPrint("Y_axis", theta);
		else if (t_z == 1)//print Z_axis
			glPrint("Z_axis", theta);
	}glPopMatrix();//pop
 
	glutPostRedisplay();
	glutSwapBuffers();
}

//swap rotate direction
void mouseButton(int button, int state, int x, int y)
{
	if (button == GLUT_LEFT_BUTTON)
	{
		if (state == GLUT_DOWN)
		{
			if (!mouseLeftDown)
			{
				if (rot)
					rot = false;
				else
					rot = true;
			}
		}
		else if (state == GLUT_UP)
		{
			if (mouseLeftDown)
				mouseLeftDown = false;
		}
	}
	else if (button == GLUT_RIGHT_BUTTON)
	{
		if (state == GLUT_DOWN)
		{
		}
		else if (state = GLUT_UP)
		{
		}
	}
	glutPostRedisplay();
}
 
void mouseMotion(int x, int y)
{
	if (mouseLeftDown)
	{
		double viewport[4];
		glGetDoublev(GL_VIEWPORT, viewport);
 
		point[1][0] = x / (float)viewport[2] * 500;
		point[1][1] = (viewport[3] - y) / (float)viewport[3] * 500;
	}
	glutPostRedisplay();
}

폰트 설정

//setting font
void init(void)
{
	theta = 0.0f;
	hWnd = GetActiveWindow();
	hDC = GetDC(hWnd);
 
	listID = glGenLists(1);
	glNewList(listID, GL_COMPILE);
 
	glEndList();
	BuildFont();
 
	glutTimerFunc(10, timer, 1);
}

void BuildFont(void)
{
	HFONT font;
	HFONT oldfont;
 
	base = glGenLists(96);
	font = CreateFontA(-24,
		0,
		0,
		0,
		FW_BOLD,
		FALSE,
		FALSE,
		FALSE,
		ANSI_CHARSET,
		OUT_TT_PRECIS,
		CLIP_DEFAULT_PRECIS,
		ANTIALIASED_QUALITY,
		FF_DONTCARE | DEFAULT_PITCH,
		"Courier New");
 
	oldfont = (HFONT)SelectObject(hDC, font);
	wglUseFontBitmaps(hDC, 32, 96, base);
	SelectObject(hDC, oldfont);
	DeleteObject(font);
}

void KillFont(GLvoid)
{
	glDeleteLists(base, 96);
}
 
//print function
void glPrint(const char *fmt, ...)
{
	char text[256];
	va_list ap;
	if (fmt == NULL)
		return;
 
	va_start(ap, fmt);
	vsprintf(text, fmt, ap);
	va_end(ap);
 
	glPushAttrib(GL_LIST_BIT); {//push
		glListBase(base - 32);
		glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);
	}glPopAttrib();//pop
}

cube를 구성할 사각형

/// <summary>
/// draw square
/// </summary>
/// <param name="a">a.</param>
/// <param name="b">The b.</param>
/// <param name="c">The c.</param>
/// <param name="d">The d.</param>
void quad(int a, int b, int c, int d)
{
	glBegin(GL_QUADS);
	glColor3fv(colors[a]); glVertex3fv(vertices[a]);
	glColor3fv(colors[b]); glVertex3fv(vertices[b]);
	glColor3fv(colors[c]); glVertex3fv(vertices[c]);
	glColor3fv(colors[d]); glVertex3fv(vertices[d]);
}

메인함수

void main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutInitWindowSize(500, 500);
	glutCreateWindow("xyz rotate");
	glutDisplayFunc(RenderScene);
	glutReshapeFunc(ChangeSize);
 
	glutMouseFunc(mouseButton);
	glutMotionFunc(mouseMotion);
	glutTimerFunc(1000 / 30, timer, 1); //timer 실행
	glutKeyboardFunc(keyboard);
	glutKeyboardUpFunc(keyupfunc);
 
	//bind menu with keyboard event
	glutCreateMenu(menu);
	glutAddMenuEntry("1", 1);
	glutAddMenuEntry("2", 2);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
 
	init();
	SetupRc();
	glutMainLoop();
}

실행영상

OrthoGraphic (직교투영), Perspective (투시투영) projection

둘의 차이를 간단히 설명하자면 직교투영은 무한한 거리에서 바라보는 것이라고 생각하면 된다.

가까운 거리에 있는 물체는 크게, 멀리 있는 물체는 작게 보이는 실생활과는 달리, 같은 크기의 물체는 모두 같게 보이는 것이다.

즉 그 반대인 투시투영은 실생활에서 우리 보는 원근감을 그대로 표현하는 projection이라고 생각하면 된다.

예제를 통해서 그 둘을 비교해 본다. 이번 예제는 같은 큐브를 두개의 관점에서 본다.

(앞의 예제와 마찬가지로, 생략된 코드는 아래의 링크를 참조한다)

2017/09/12 - [SW/OpenGL] - OpenGL - 사각형 회전, 색바꾸기

소스코드

선언부

static int vi = 2;
static float viewer[3];
 
/// <summary>
/// The vertices {x, y, z}
/// </summary>
GLfloat vertices[8][3] = { { -1, -1, 1 },{ -1, 1, 1 },
{ 1, 1, 1 },{ 1, -1, 1 },{ -1, -1, -1 },
{ -1, 1, -1 },{ 1, 1, -1 },{ 1, -1, -1 } };
 
/// <summary>
/// The colors {R, G ,B]
/// </summary>
GLfloat colors[8][3] =
{ { 0, 0, 1 },{ 0, 1, 1 },
{ 1, 1, 1 },{ 1, 0, 1 },
{ 0, 0, 0 },{ 0, 1, 0 },
{ 1, 1, 0 },{ 1, 0, 0 } };
 
int W = 600, H = 600;//width, height

키보드 이벤트

void menu(int item)
{
	keyboard((unsigned char)item, 0, 0);
}
 
void keyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
	case 'q' | 'Q':
		exit(0); break;
	case VK_ESCAPE:
		exit(0); break;
	case 1://perspective
	{
		W += 1;
		vi = 1;
		glutReshapeWindow(W, H);
	}	break;
	case 2://orthographic
	{
		vi = 2;
		W -= 1;
		glutReshapeWindow(W, H);
	}break;
	}
}

초기화

void init(void)
{
	for (int i = 0; i < 3; i++) {
		viewer[i] = 2.5;
	}
}

사각형 draw

/// <summary>
/// draw square
/// </summary>
/// <param name="a">a.</param>
/// <param name="b">The b.</param>
/// <param name="c">The c.</param>
/// <param name="d">The d.</param>
void quad(int a, int b, int c, int d)
{
	glBegin(GL_QUADS);
	glColor3fv(colors[a]); glVertex3fv(vertices[a]);
	glColor3fv(colors[b]); glVertex3fv(vertices[b]);
	glColor3fv(colors[c]); glVertex3fv(vertices[c]);
	glColor3fv(colors[d]); glVertex3fv(vertices[d]);
	glEnd();
}

렌더링함수

void RenderScene(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	if (vi == 1)//perspective
	{
		vi = 1;
		gluLookAt(viewer[0], viewer[1], viewer[2], 0, 0, 0, 0, 1, 0);
		glutReshapeFunc(ChangeSize);
	}
	else//orthographic
	{
		vi = 2;
		glutReshapeFunc(ChangeSize);
		gluLookAt(viewer[0], viewer[1], viewer[2], 0, 0, 0, 0, 1, 0);
	}
	//draw cube
	quad(0, 3, 2, 1);
	quad(2, 3, 7, 6);
	quad(3, 0, 4, 7);
	quad(1, 2, 6, 5);
	quad(4, 5, 6, 7);
	quad(5, 4, 0, 1);
	glutSwapBuffers();
}

결과영상

설명 : 16개의 teapot이 랜던한 색과 방향으로 회전한다.

이번에는 빛을 줘서 그림자 효과도 준다.

생략된 부분은 링크된 부분을 참고하세요(소스동일)

2017/09/12 - [SW/OpenGL] - OpenGL - 사각형 회전, 색바꾸기

선언부

GLUquadricObj *p;
void getaxis(int index);
double getcolor();
int axi[16];
double colR[16];
double colG[16];
double colB[16];
static float theta[3];
GLdouble angle;

렌더링 함수

void RenderScene(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(0, 2.0, 2.0, 0, 0, 0, 0, 1.0, 0); //view point
 
	glEnable(GL_LIGHTING); //light on
	glEnable(GL_LIGHT0); //0th light
 
	GLfloat position0[4] = { 100, 100, 100, 1 };
	GLfloat ambient0[4] = { 0, 0, 0.6,0 };
	GLfloat diffuse0[4] = { 1.0, 1.0, 0, 1 };
	GLfloat specular0[4] = { 1, 1, 1, 1 };
 
	glLightfv(GL_LIGHT0, GL_POSITION, position0);
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambient0);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse0);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specular0);
 
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);//light attributes is ambient, diffuse
	glEnable(GL_COLOR_MATERIAL);
 
	//set teapots attributes
	GLfloat mat_specular[4] = { 1,1,1,1 };
	GLfloat mat_shininess = 25.0f;
	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
	glMaterialf(GL_FRONT, GL_SHININESS, mat_shininess);
	double xp = -1.6;
	double yp = 2.4;
	int a = 0;
	int b = 0;
 
	for (int i = 0; i < 4; i++)
	{
		xp = -1.6; // teapot move 1.6 with x-axis
		for (int k = 0; k < 4; k++)
		{
			glPushMatrix();//push
			glTranslatef(xp, yp, 0.0);
 
			if (axi[a] == 0)
				glRotatef(angle, 1, 0, 0);
			else if (axi[a] == 1)
				glRotatef(angle, 0, 1, 0);
			else
				glRotatef(angle, 0, 0, 1);
			glColor3f(colR[b], colG[b], colB[b]);
			glutSolidTeapot(0.2);
			glPopMatrix();//pop
			a++;
			b++;
			xp = xp + 0.8;
		}
		yp = yp - 0.8;
	}
	glutSwapBuffers();
}

랜덤한 방향으로 회전하도록 x,y,z 방향을 제시해주는 함수

/// <summary>
/// set rotate direction random
/// </summary>
/// <param name="index">The index.</param>
void getaxis(int index)
{
	if (index == 0)
		glRotatef(angle, 1, 0, 0);
	else if (index == 1)
		glRotatef(angle, 0, 1, 0);
	else
		glRotatef(angle, 0, 0, 1);
}

주전자가 2도씩 회전함

/// <summary>
/// rotate teapot 2 degree
/// </summary>
/// <param name="value">The value.</param>
void rtimer(int value)
{
	angle += 2;
	glutTimerFunc(30, rtimer, 0);
	glutPostRedisplay();
}

티팟에 줄 랜덤한 색을 제시

/// <summary>
/// Get random colors this instance.
/// </summary>
/// <returns></returns>
double getcolor(void)
{
	double c;
	c = (double)rand() / RAND_MAX;
	return c;
}

색과 방향 초기화

void init(void)
{
	srand(time(NULL));
	theta[0] = 0;
	theta[1] = 0;
	theta[2] = 0;
	for (int t = 0; t < 16; t++)
	{
		axi[t] = rand() % 3;
		colR[t] = (double)rand() / RAND_MAX;
		colG[t] = (double)rand() / RAND_MAX;
		colB[t] = (double)rand() / RAND_MAX;
	}
}

메인함수

void main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutInitWindowSize(800, 800);
	glutCreateWindow("Ex4");
	glutDisplayFunc(RenderScene);
	glutReshapeFunc(ChangeSize);
	glutTimerFunc(30, rtimer, 1);
	init();
	SetupRc();
	glutMainLoop();
}

결과

설명

로봇의 팔을 만들어서 회전하고 꺽을수 있다.

이번에도 마찬가지로 소스에 대한 설명은 주석을 참조하세요

또한 생략된 소스는 맨 앞의 글을 참조하세요

2017/09/12 - [SW/OpenGL] - OpenGL - 사각형 회전, 색바꾸기

로봇의 base

void base(void)
{
	glPushMatrix();//push
	{
		glColor3f(1, 0, 0);//red
		glTranslatef(0, -0.8, 0);//y axis
		glRotatef(-90, 1, 0, 0);//x axis
		glRotatef(Base_Angle, 0, 0, 1);//z axis
		gluCylinder(p, 0.5, 0.5, 0.3, 20, 1);//draw cylinder
	}
	glPopMatrix();//pop
}

로봇의 lower

/// <summary>
/// arm's lower
/// </summary>
void lower_arm(void)
{
	glPushMatrix();//push
	{
		glColor3f(0, 1, 0);//green
		glRotatef(Base_Angle, 0, 1, 0);//rotate with y axis
		glTranslatef(0, -0.7, 0);//translate with axis
		glRotatef(Lower_Arm_Angle, 0, 0, 1);//rotate with z axis
		glTranslatef(0, 0.5, 0);//translate with y axis
		glScalef(0.2, 1, 0.2);//scaling
		glutWireCube(1);//draw cube
	}
	glPopMatrix();//pop
}

로봇의 upper

/// <summary>
/// arm's upper
/// </summary>
void upper_arm(void)
{
	glPushMatrix(); //push
	{
		glColor3f(0, 0, 1); // blue
		glRotatef(Base_Angle, 0, 1, 0); //rotate y axis
		glTranslatef(0, -0.7, 0);//translate y axis
		glRotatef(Lower_Arm_Angle, 0, 0, 1);//rotate z axis
		glTranslatef(0, 1.0, 0);//translate y axis
		glRotatef(Upper_Arm_Angle, 0, 0, 1);//rotate z axis
		glTranslatef(0, 0.4, 0);//translate y axis
		glScalef(0.2, 0.8, 0.2);//scaling
		glutWireCube(1);//draw cube
	}
	glPopMatrix();//pop
}

렌더링 함수

void RenderScene(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(0.5, 0.5, 0.5, 0, 0, 0, 0, 1, 0);//setting camera viewpoint
	base(); //draw base
	lower_arm(); //draw lower part
	upper_arm(); //draw upper part
	glutSwapBuffers();
}

스페셜 키 이벤트 (화살표4개, home, end)

/// <summary>
/// Special key event
/// </summary>
/// <param name="key">Special key.</param>
/// <param name="x">The x</param>
/// <param name="y">The y</param>
void specialkeys(int key, int x, int y)
{
	switch (key)
	{
	case GLUT_KEY_UP: //up arrow
		Lower_Arm_Angle += 2;
		break;
	case GLUT_KEY_DOWN: //down arrow
		Lower_Arm_Angle -= 2;
		break;
	case GLUT_KEY_LEFT: //left arrow
		Base_Angle -= 2;
		break;
	case GLUT_KEY_RIGHT: //right arrow
		Base_Angle += 2;
		break;
	case GLUT_KEY_HOME: //home key
		Upper_Arm_Angle += 2;
		break;
	case GLUT_KEY_END: //end key
		Upper_Arm_Angle -= 2;
		break;
	default:
		break;
	}
}

메인함수

void main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutInitWindowSize(500, 500);
	glutCreateWindow("Simple");
	glutDisplayFunc(RenderScene);
	glutReshapeFunc(ChangeSize);
	glutSpecialFunc(specialkeys); //Special key event
	glutMouseFunc(mouseButton);
	glutMotionFunc(mouseMotion);
	glutTimerFunc(1000 / 30, timer, 1);
	glutKeyboardFunc(keyboard);
	init();
	SetupRc();
	glutMainLoop();
}

타이머 함수

void timer(int value)
{
	if (rot)
	{
		theta += 2.0;
		if (theta >= 360.0)
			theta -= 360.0;
	}
	else
	{
		theta -= 2.0;
		if (theta <= 360.0)
			theta += 360.0;
	}
	glutTimerFunc(1000 / 30, timer, 1);
	glutPostRedisplay();
}

결과

설명

정육면체를 'X'를 눌렀을때는 X축 회전, 'Y'를 눌렀을땐 Y축회전, 'Z'를 눌렀을때는 Z축 회전시킨다.

소스설명

앞의 소스와 중복되는 부분은 변경이 있기전까진 생략한다.

궁금하신분은 맨 앞의 게시물을 확인바랍니다.

2017/09/12 - [SW/OpenGL] - OpenGL - 사각형 회전, 색바꾸기

선언

static bool mouseLeftDown;//checking mouse click
static float point[2][2];
void mouseButton(int button, int state, int x, int y);
void mouseMotion(int x, int y);
void keyboard(unsigned char key, int x, int y);
void timer(int value);
void quad(int a, int b, int c, int d);
static bool R = true;
static bool G = true;
static bool B = true;
static float theta;
bool rot = true;
int r, x_axis = 0, y_axis = 1, z_axis = 0;

점8개와 색8개

/// <summary>
/// eight point to draw a cube
/// </summary>
GLfloat vertices[8][3] = { { -1, -1, 1 },{ -1, 1, 1 },
{ 1, 1, 1 },{ 1, -1, 1 },{ -1, -1, -1 },
{ -1, 1, -1 },{ 1, 1, -1 },{ 1, -1, -1 } };
 
 
 
/// <summary>
/// eight color each points
/// </summary>
GLfloat colors[8][3] =
{ { 0, 0, 1 },{ 0, 1, 1 },
{ 1, 1, 1 },{ 1, 0, 1 },
{ 0, 0, 0 },{ 0, 1, 0 },
{ 1, 1, 0 },{ 1, 0, 0 } };

colors는 r,g,b 값으로 색을 조합한다.

x,y,z 키에 대한 이벤트(x축, y축, z축)

void keyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
	case 'q' | 'Q':
		exit(0); break;
	case VK_ESCAPE:
		exit(0); break;
	case 1:
		exit(0); break;
	case 2:
		exit(0); break;
	case 'x' | 'X':
	{
		x_axis = 1;
		y_axis = 0;
		z_axis = 0;
		break;
	}
	case 'y' | 'Y':
	{
		x_axis = 0;
		y_axis = 1;
		z_axis = 0;
		break;
	}
	case 'z' | 'Z':
	{
		x_axis = 0;
		y_axis = 0;
		z_axis = 1;
		break;
	}
	default:
		break;
	}
}

렌더링함수

void RenderScene(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(0.5, 0.5, 0.5, 0, 0, 0, 0, 1, 0); //view point
	glRotatef(theta, x_axis, y_axis, z_axis);//rotate cube
 
	//draw a cube with 6 quadrature
	quad(0, 3, 2, 1);
	quad(2, 3, 7, 6);
	quad(3, 0, 4, 7);
	quad(1, 2, 6, 5);
	quad(4, 5, 6, 7);
	quad(5, 4, 0, 1);
	glEnd();
	glutSwapBuffers();
}

사각형을 그린다 위의 함수에서 6개의 사각형을 그리는데 사용하는 함수 quad

void quad(int a, int b, int c, int d)
{
	glBegin(GL_QUADS);
	glColor3fv(colors[a]); glVertex3fv(vertices[a]);
	glColor3fv(colors[b]); glVertex3fv(vertices[b]);
	glColor3fv(colors[c]); glVertex3fv(vertices[c]);
	glColor3fv(colors[d]); glVertex3fv(vertices[d]);
}

마우스 클릭, 모션 함수 (마우스 왼쪽 클릭하면 회전방향이 바뀐다.)

void mouseButton(int button, int state, int x, int y)
{
	//mouse left button click
	if (button == GLUT_LEFT_BUTTON)
	{
		if (state == GLUT_DOWN)
		{
			if (!mouseLeftDown)
			{
				if (rot)
					rot = false;
				else
					rot = true;
			}
		}
		else if (state == GLUT_UP)
		{
			if (mouseLeftDown)
				mouseLeftDown = false;
		}
	}
	//mouse right button click
	else if (button == GLUT_RIGHT_BUTTON)
	{
		if (state == GLUT_DOWN)
		{
 
		}
		else if (state = GLUT_UP)
		{
 
		}
	}
	glutPostRedisplay();
}
 
void mouseMotion(int x, int y)
{
	if (mouseLeftDown)
	{
		double viewport[4];
		glGetDoublev(GL_VIEWPORT, viewport);
 
		point[1][0] = x / (float)viewport[2] * 500;
		point[1][1] = (viewport[3] - y) / (float)viewport[3] * 500;
	}
	glutPostRedisplay();
}

정육면체를 회전하기 위한 타이머

void timer(int value)
{
	if (rot)
	{
		theta += 2.0;
		if (theta >= 360.0)
			theta -= 360.0;
	}
	else
	{
		theta -= 2.0;
		if (theta <= 360.0)
			theta += 360.0;
	}
	glutTimerFunc(1000 / 30, timer, 1);
	glutPostRedisplay();
}

초기화

void init(void)
{
	theta = 0.0f;
	glutTimerFunc(10, timer, 1);
}
 
void SetupRc(void)
{
	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
	glEnable(GL_DEPTH_TEST);
}

결과

설명

마우스로 폼위의 3점을 찍으면 그 점을 꼭지점으로 삼각형을 그린다.

소스설명

설명은 주석으로 대체하였다.

parameter

#define POINTS 100
 
GLfloat pos[POINTS][2];//point array
GLfloat Width = 600.0; //form width
GLfloat Height = 600.0; //form height
GLint n = 0; //number of points

렌더링함수

/// <summary>
/// Renders the scene.
/// </summary>
void RenderScene(void)
{
	int i;
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1, 0, 0);//red color
	glPointSize(10.0f);//size 10
	glEnableClientState(GL_VERTEX_ARRAY);// enable array
 
	
	for (i = 0; i < 3; i++)
	{
		glBegin(GL_POINTS);//dot
		glVertex2f(pos[i][0], pos[i][1]);//dot position
	}
	if (i>2 && (pos[2][0] != 0))//draw triangle when the number of points are greater than two
	{
		glBegin(GL_TRIANGLES);
		glVertex2f(pos[0][0], pos[0][1]);
		glVertex2f(pos[1][0], pos[1][1]);
		glVertex2f(pos[2][0], pos[2][1]);
	}
	glEnd();
	glFlush();//flush
}

마우스 클릭 이벤트

/// <summary>
/// Mouse button event.
/// </summary>
/// <param name="button">The button.</param>
/// <param name="state">The state.</param>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
void mousebutton(int button, int state, int x, int y)
{
	if (button == GLUT_LEFT_BUTTON)
	{
		if (state == GLUT_DOWN)
		{
			pos[n][0] = x / Width;
			pos[n][1] = (Height - y) / Height;
			if (n > 2)//when then number of points greater than two
			{
				pos[n % 3][0] = pos[n][0];//x
				pos[n % 3][1] = pos[n][1];//y
			}
			n++;
			RenderScene();//rendering
		}
	}
}

윈폼 크기 변경 함수

/// <summary>
/// winform size changed
/// </summary>
/// <param name="w">width</param>
/// <param name="h">height</param>
void ChangeSize(int w, int h)
{
	GLfloat asepectRatio;
 
	Width = w;
	Height = h;
 
	if (Height == 0)
		Height = 1;
	glViewport(0, 0, w, h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	
	gluOrtho2D(0.0, 1.0, 0.0, 1.0);
}
void main(int argc, char *argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowSize(Width, Height);
	glutInitWindowPosition(0, 0);
	glutCreateWindow("ex2");
	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
	glMatrixMode(GL_PROJECTION);
 
	glutDisplayFunc(RenderScene);
	glutReshapeFunc(ChangeSize);
	glutMouseFunc(mousebutton);
 
	glutMainLoop();
}

결과물

Ch3

시스템 소프트웨어는 컴퓨터 시스템의 효율적인 운영과 제어를 담당한다.

PC = Program Counter 다음에 수행할 명령어의 주소를 저장

MAR = Memory Address Register 로 input/output 수행할 주기억장치의 주소를 저장

SP = Stack Pointer 스택의 최상의 주소를 저장

IX = Index Register 인덱스 주소지정 방식에서 인덱스를 저장

IR = Instruction Register 현재 실행중인 명령어를 저장

MBR = Memory Buffer Register 주기억장치의 데이터를 임시저장

AC = Accumulator 연산결과데이터를 임시저장

PSR = Program Status Register CPU 의 현재 상태 정보를 저장

터치스크린 = 접촉점의 좌표값을 컴퓨터에 전달

스캐너 = 화상 정보를 광학적으로 인식하여 컴퓨터에 입력

햅틱인터페이스 = 사물의 촉감을 감지하고 재현함

CISC 보단 RISC가 더 범용적임

명령어와 주소가 간단하며 형식도 고정되있으며, 레지스터는 많다. ROM을 사용하지 않고 하드와이어드 방식을 사용, 빠름

주소명령어

0-    주소명령어 스택구조컴퓨터에서 사용

1-    주소명령어 누산기레지스터를 이용

2-    대부분컴퓨터 주소필드에 레지스터 번호나 주기억장치의 주소를 지정한다.

3-    2와 같지만, 프로그램의 길이가 짧아지는 장점이 있는 반면 명령어 하나의 길이가 김

ROM

마스크ROM 제조과정에서 데이터를 저장하지 않고, 미리 정보를 기록하여 생산하고 저장된 정보를 변경할순 없지만 대량생산

PROM 제조과정에선 데이터를 저장할수 없지만 라이터로 정보를 입력하여 한번만 쓸 수 있음

EPROM 자외선을 이용하여 새로운 정보를 기록 여러 번쓸수있찌만 비싸

EEPROM 전기적 펄스를 이용하여 데이터를 삭제함 중간에 데이터를 넣을수 있음

중앙처리장치가 필요로 하는 데이터가 캐시 메모리에 존재하는 상황을 캐시 적중이라 하고 반대를 캐시 미스라고 함.

자기디스크 순차접근과 직접접근이 모두 가능하며, 지정된 액세스 암이 지정된 트랙까지 이동하는 데 걸리는 시간을 탐색시간이라고 한다. 원하는 데이터의 저장위치가 헤드까지 오는 데 걸리는 시간을 회전 지연 시간이라고 한다.

CRT 전자총의 전자가 유리의 형광물질 자극

LCD 2장의 유리판 사이의 액정에 전압을 가함

PDP 2장의 얇은 ㅇ리판 사이에 가스를 넣고 양전음전 사이에서 방전현상을 이용

OLED 유기발광다이오드 전류가 흐르면 빛을 내는 현상을 이용하는 자체 발광형 유기물질

Ch 4

프로그램은 데이터와 데이터를 처리하는 기능을 뜻함

구조적 프로그램은 단일 입출구를 가진다.

절차지향프로그램은 데이터와 기능을 분리한다.

프로그램제어구조에는 크게 순차 선택 반복으로 구성

인터프리터 방식에서는 번역과 실행이 동시에 이뤄진다.

구조적프로그래밍으로 goto를 지움

객체를 정의 한다는 것은 속성과 기능을 정의하고 다른 객체와의 관계를 정의

절차지향으프로그램은 goto문을 줄이고 명령문의 처리를 블록으로 모듈화하기 위해 구조적프로그래밍이 필요

객체지향언어는 캡슐화 시킨후 메시지를 전달하여 일을 처리

CH5

프로그램은 수동적 개체이고, 프로세스는 능동적 개체이다.

색인 순차파일은 순차접근과 직접접근 모두 가능하다.

CPU 스케쥴링은 CPU를 언제 어느곳에 사용할것인지를 결정

운영체제란 자원의 관리를 하는것임, 하드웨어와 사용자 사이의 인터페이스를 제공

작업처리방식

일괄처리시스템 모아뒀다가 한꺼번에 처리함 시스템을 효율적으로 사용하지만 반환시간 ㅠ

다중 프로그래밍시스템 CPU의 유휴시간에도 다른 프로그램을 처리하기 때문에 효율 갑

다중처리 시스템 컴퓨터에 2개이상의 CPU

시분할시스템 일정한 CPU시간을 할당 대화형식으 프로그램실행

실시간시스템  입력된 데이터를 즉시 처리한 후 바로 결과를 보낸다.

분산 처리 시스템 네트워크를 통해 PC에 작업과 자원을 분할

PCB는 주기억장치에 저장되며 운영체제에게 프로세의 대한 정보를 제공하는 자료구조, 프로세스와 같이 살고 죽음 CPU를 다른 프로세스에 넘겨줄 때 실행중인 모든 프로세스정보가 저장됨

CPU 스케쥴링

FCFS (First Com First Server) 준비큐에 도착한 순서대로 CPU할당

라운드 로빈 동일한 CPU시간 할당 (선점)

SJF(Shortest Job First) 실행시간이 짧은 것을 우선처리 (비선점)

SRT(Shortset Remainin Time) 프로세스 중 잔여 실행시간이 짧은 것 선택 (선점)

HRN (Highest Response ratio Next) 가장 높은 응답률먼저 (비선점)

우선순위 프로세스마다 우선순위 부여(비선점)

MLQ(Multi Level Que) 다수의 그룹으로 분류하여 그룹마다 별도의 큐 제공 (선점)

MFQ(Multi-level Feedback Queue) 입출력 프로세스와 CPU위주 프로세스이 특성에 따라 CPU의 할당량을 다르게 부여 (선점)

보조기억장치의 작업을 주기억장치의 어디에 배치할건가?

최초적합 첫번째 공간에 배치

최적적합 가장 작은곳에 배치

최악적압 가장 큰 곳에 배치

페이징기법

페이지와 페이지 프레임의 크기는 동일하며 프로세스가 참조하는 가상주소는 실행 중에 실제 주소로 변환 프로세스마다 별도의 페이지 테이블을 부여

파일구조

순차파일 테이프에 사용 빈공간없이 효율적사용 삽입삭제 어려움

색인순차파일 키값에 따라 정렬된 레코드를 순차적으로 접근 직접파일구조 ,순차파일구조 모두사용 삽입과 수정용이 색인을이용하므로 처리 속도가 늦고 색인 저장공간도 필요

직접파일 레코드에 직접 접근 물리주소를 키 값으로 계산하여 접근 키 값에 의한 순차 검색이 어려움

분할파일 서브파일로 구성되어 라이브러리 저장에 용이 시작주소는 디렉터리레코드에 저장

파일의 공간할당기법

연속할당 연속적으로 빈공간에 저장 저장곤간없으면 안됨 빈공간이 조각나면 단편화 현상이 발생하므로 집약이 필요

불연속할당 파일의 크기변화에 유연하게 대응
섹터단위 섹터들이 연결리스트로 구성 다른 섹터와 연결을 위한 포인터를 가짐 (링크드리스트)
블록단위 섹터를 묶은 블록단위로 ㅎ할당 연속할당과 불연속하당의 절충 디스크전체에 분산되므로 검색에 시간이 많이 걸림

접근제어행렬 개별파일이나 디렉터리에 대한 접근이 가능한 사용자와 허용되는 동장한 기록한 것

Ch6

데이터베이스 관리 시스템은 db관리 프로그램의 집합 많은 사람이 사용할수록 효율

파일 구성의 기본요소는 레코드  레코드는 연관 필드의 집합으로 구성되며 자료 저장,표현의 기본단위 필드는 속성을 나타내는 기본

다수의 데이터파일에서 데이터 불일치 현상을 막기위해 db등장

DB는 데이터를 공유할 수 있도록 데이터를 통합,관리함

DB

통합된 데이터 : 연관된 데이터의 모임

저장된 데이터 : 보조기억장치에 저장되어있는 데이터의 모임

운영 데이터 : 특정 조직체의 존재 목적이나 역할 측면에서 필요한 데이터가 구조적으로 통합

특징

실시간접근, 계속적인 변화, 동시공유, 내용참조

DBMS

효율적인 데이터베이스 사용환경을 제공
구조 명시, 생성, 검색, 수정 보호, 접근

파일처리 시스템과 비교할때의 DBMS의 장점

데이터의 중복,불일치 감소, 융통성 향상, 개발 유지비용 감소, 복구 가능, 무결성 향상,표준화

DB언어

데이터 정의어 : 저장구조, 접근방법, 형식 -> 데이터 구축이나 수정

데이터 조작어 : 데이터 검색 수정 삽입 삭제

데이터 제어어 : 데이터 보호 관리

데이터베이스 구조와 근간을 이루는 데이터 모델은 논리구조 표현함

계층적 데이터모델은 레코드와 링크로 구성된 트리

네트워크형 데이터모델 레코드를 노드로, 레코드간의 관계는 간선(edge)로 나타냄

                                간선으로 되어있어 확장성이 떨어짐

관계형 데이터 모델 개념이 단순하여 널리 사용 2차원 테이블에 데이터를 저장, 테이블은 엔티티에 관한 정보를 저장, 고유이름을 가짐

객체지향형 데이터모델 데이터와 메소드를 하나의 객체에서 다룸

릴레이션은 2차원 테이블로 하나의 릴레이션은 하나의 엔티티에 관한 데이터를 저장

속성이 가질수 있는 값의 집합을 도메인 이라함 비워져있을떈 NULL

키 는 하나 이상의 속성 모임 후보키는 최소한의 속성으로 구성

후보 키가 두개 이상이면 하나를 기본키 하나를 대체키로 정해야함

무결성 제약조건 : DB상태가 만족해야 하는 조건으로서 사용자에 의한 DB갱신이 DB의 일관성을 손상하지 않도록 보장하는 수단

도메인 제약조건 : 각 속성값은 반드시 도메인에 속한 하나의 값을 가져야함

개체 무결성 제약조건 기본키를 구성하는 어떤요소도 NULL값이면 안된다.

참조 무결성 제약조건 외래키의 값은 참조된 릴레이션의 기본 키의 값과 같아야함

관계형 대수란 DB데이터를 삽입, 저장 데이터를 검색 수정 삭제 하는 언어이며 데이터가 무엇인지 검색방법은 어떻게 되는지 기술하므로 절차적 언어이다.

선택연산 주어진 릴레이션에서 특정조건을 만족하는 튜플을 구함

추출연산 주어진 릴레이션에서 원하는 속성만 구함

합집합연산 합집합 튜플 튜플을 구함

교집합연산 교집합 튜플

차집합연산 차집합 튜플

카티전 곱 연산 두 개의 릴레이션에 존재하는 모든 튜플의 조합

조인연산 선택연산하여 튜플을 결합하여 하나의 튜플로만듬

나누기 연산 나머지가 나오는 연산

SQL

데이터 정의, 조작, 제어 기능

CREAT TABLE

DROP TABLE

ALTER TABLE (ADD, MODIFY, DROP)

SELECT FROM

WHERE (조건문)

ORDERED BY 정렬 조건

INSERT 한번에 하나의 튜플을 삽입

DELETE WHERE조건을 만족하는 튜플을 삭제

UPDATE 튜플의 속성 값을 변경

CH7

네트워크의 시초는 모스가 발명한 전신 기술 모스부호는 원거리에 있는 상대방에게 전기신호의 길이와 끊김으로 정보를 전송

프로토콜 : 네트워크에서 데이터를 주고받을 때 수행되는 절차

기능

주소지정 : 보낼 데이터에 송신측과 수신측의 주소를 추가

동기화 : 송신 컴퓨터가 수신컴퓨터에 데이터를 전송할 때 상호 데이터 전송속도와 타이밍 일치

캡슐화 : 데이터 보호

오류제어 : 오류를 송신컴에 보냄

흐름제어 : 데이터 전송을 위한 데이터 전송과 응답방식

데이터 분할 및 조합 : 여러 개로 나눠서 보냄

연결 제어 : 연결 설정 -> 데이터 전송 -> 연결 해제 단계

프로토콜의 절차

연결 설정 -> 데이터 전송 -> 연결 해제

OSI 참조 모델

7계층 -> 물리, 데이터링크, 네트워크, 전송, 세션, 표현, 응용

네트워크까지는 하위로 네트워크 특성에 영향을 받지만 상위계층으 영향 x

물리계층 : 시스템 연결에서 기계적, 전기적 특성과 물리적 신호 제어 절차

데이터 링크 계층 : 데이터 물지적 전송 오류를 감지 복구 오류제어기능과 전송 데이터 흐름 제어

네트워크 계층 : 네트워크에서 최적의 경로로 전송될 수 있도록 경로 배정과 혼합제어기능

전송계층 : 특성에 영향없이 오류제어, 흐름제어 기능 수행 신뢰데이터전송

세션계층 : 송수신 컴간 네트워크 대화 제어 동기화 유지

표현 계층 : 구문과 의미에 관련된 기능으로 변환, 암호화, 압축수행

응용계층 : 최상위 계층으로 사용자의 데이터처릴 도와줌

네트워크는 허브와 라우터 같은 교환기들이 통신회선으로 서로 연결

네트워크 구성형태

메쉬형 점과 점으로 연결되어 회선이 고장나더라도 전체 네트워크에 영향을 주진 않지만 회선수가 너무 많아 공간확보가 필요함

스타형 허브라는 네트워크에 점과 점으로 연결되어 재구성이 간편하지만 허브가 고장나면 전체 네트워크 문제

트리형 스타형끼리 연결되어 있어 허브만 준비되면 많은컴을 쉽게연결하지만 허브가 고장나면 전체문제임

버스형 하나의 통신회선에 여러대의 컴ㅍ터가 멀티포인트로 연결되어 컴터 추가, 삭제가 편하지만 무분별하게 추가하면 성능 저하 통신회선일부가 고장나면 전체 네트워크 문제

링형 : 컴퓨터가 점대 점으로 연결 컴퓨터를 통신회선에 연결할 때 리피터를 사용하여 재구성이 쉽지만 링 부분이 문제면 전체 문제

하이브리드형 다씀

Computer architecture

Compute : datapath + control + memory + input + output

Spatial locality(공간 구역성) : 하나의 기억 장소가 참조되면 그 근처의 기억 장소가 계속 참조되는 경향이 있는 성질

Temporal locality(잠정 구역성) : 최초 참조된 기억 장소가 가까운 미래에도 계속 참조될 가능성이 높음

메모리의 레벨이 높아질수록 프로세서와의 거리는 증가하고 속도는 감소한다.

FLASH : 비휘발성 반도체 저장소, 디스크 보다 빠르다, 작고 저전력, 튼튼하다 비싸다.

Disk Latency = seek time + rotation time + transfer time + controller overhead

Access time = hit time + miss rate x miss penalty

Processor는 miss가 나면 파이프라인은 중단시킨다.

Replacement policy = 캐쉬는 사이즈 작기 때문에 miss가 많이 발생하기에 사용빈도가 높은 것을 우선순위에 둠

Write policy = cash와 memory를 조절

Capacity misses : 용량이 작아서 생기는 miss (용량을 키우면 됨)

Associative cashes : miss rate를 줄이는 효과(장점), 오버헤드, 지연(단점)

Block : direct mapped, set associative, fully associative

Block finding : indexing, limited search, full search, separate lookup table

RAID : 하드에 장애 발생시 실시간으로 데이터를 복구0~7레벨