삼각함수 사이의 관계1

단위원의 한 점을 P(x, y)라 하고, 동경 OP가 나타내는 각을 Ɵ하고 하면 아래와 같은 관계가 성립함을 알수 있다. 

sinƟ = y

cosƟ = x

tanƟ = y / x = sinƟ / cosƟ

cosecƟ = 1 / y = 1 / sinƟ

secƟ = 1 / x = 1 / cosƟ

cotƟ = x / y = cosƟ / sinƟ

삼각함수 사이의 관계2

좌표평면에서 단위원x² + y² = 1 위의 점 P(x, y)에 대하여 동경 OP가 나타내는 각을 Ɵ 라 하면 

점 P의 좌표는 P(cosƟ, sinƟ) 로 나타낼 수 있는데, x = cosƟ, y = sinƟ 를 원의 방정식에 대입하면 

sin²Ɵ + cos²Ɵ = 1

이 성립한다.  양변을 cos²Ɵ 로 나누어, 정리하면 

tan²Ɵ + 1 = sec²Ɵ 

이 성립한다.  다시 처음 식을 sin²Ɵ 나누어 정리하면 

1 + cot²Ɵ = cosec²Ɵ

이 성립한다. 

이 글은 스프링노트에서 작성되었습니다.

삼각함수의 정의

삼각비는 직각삼각형에서( 각 Ɵ가 예각인 경우) 각과 두 개의 변 사이의 비를 연관지은 개념이다. 

삼각비의 정의를 일반각의 경우로 확장하여 삼각함수를 정의할 수 있다. 

좌표평면 위에서 각 Ɵ의 동경과 원주각의 교점을 P(x, y) 라고 하면, 삼각비의 정의에 의해 

  y / r, x / r,y / x       

의 값은  반지름 r의 값에 관계없이 일정하며, Ɵ의 값에 따라서 각각 하나씩 결정된다.

Ɵ  ---> y / r, Ɵ --> x / r,Ɵ -->y / x      (x 는 0이 아님)

와 같이 대응 시키는 함수를 정의할 수 있다. 

 각 대응을 Ɵ 의 사인 함수, 코사인 함수, 탄젠트 함수라고 한다. 

sinƟ =  y / r,cosƟ = x / r,tanƟ = y / x

사인함수, 코사인함수, 탄젠트 함수의 역수로 정의되는 함수

Ɵ  ---> r / y,    Ɵ --> r / x,    Ɵ -->  x / y     (y는 0이 아님)

와 같이 대응시키는 함수를 각각 코시컨트 함수, 시컨트 함수, 코탄젠트 함수라고 한다. 

cosecƟ =  r / y,secƟ = r / x,cotƟ = x / y

이와 같이 정의된 6개의 함수를 삼각함수 라고 한다 

삼각함수를 사용한 좌표의 표현 

삼각함수의 값은 원의 반지름의 길이에 관계없이 일정하므로, r = 1로 봐도 무방하다. 

좌표평면 위해서 중심이 원점이고, 반지름의 길이가 1인 원(단위원)  x² + y² = 1 위의 점 P(x, y)에 대하여 

동경 OP 가 나타내는 각을 Ɵ라 하면, 

sinƟ = y

cosƟ = x

tanƟ = y / x

따라서 점 P(x, y) 를 P(cosƟ, sinƟ) 로 나타낼 수 있다. 

좌표평면 임의의 점 P(x, y)의 좌표는  선분 OP의 길이가 r 이면, P(r cosƟ, r sinƟ)로 나타낼 수 있다. 

이 글은 스프링노트에서 작성되었습니다.

벡터클래스  Vector3D.h

벡터클래스 테스트  Vector3DTest.cpp

#ifndef _VECTOR3D_H_

#define _VECTOR3D_H_

#define PI 3.14159265

class Vector3D {
        
public:
        float x, y, z;
public:
        Vector3D(float ex = 0, float why = 0, float zee = 0) {
                x = ex, y = why, z = zee;
        }
        
        ~Vector3D() {}
        // 벡터의 크기를 반환하는 메소드 
        float getMagnitude() {
                return sqrtf(x*x + y*y + z*z);
        }
        // 벡터의 스칼라 곱 
        Vector3D operator*(float num) const {
                return Vector3D(x*num, y*num, z*num);
        }
        // 벡터의 합 
        Vector3D operator+(const Vector3D &vec) const {
                return Vector3D(x + vec.x, y + vec.y, z + vec.z);
        }
        // 벡터의 차
        Vector3D operator-(const Vector3D &vec) const {
                return Vector3D(x - vec.x, y - vec.y, z - vec.z);
        }
        // 벡터의 정규화 
        void normalizeVector3D(void) {
                float mag = sqrtf(x*x + y*y + z*z);
                x /= mag;
                y /= mag;
                z /= mag;
        }
        // 벡터의 내적 
        float dotVector3D(const Vector3D &vec) const {
                return x*vec.x + y*vec.y + z*vec.z;
        }
        // 벡터의 외적
        Vector3D crossVector3D(const Vector3D &vec) const {
                return Vector3D(y*vec.z - z*vec.y, z*vec.x - x*vec.z, x*vec.y - y*vec.x);
        }
        // 내적을 이용해 두 벡터간의 각을 구함(단위: 도)
        float angleBetweenVector3Ds(Vector3D &vec)  {
                return (acos(dotVector3D(vec) / (getMagnitude() * vec.getMagnitude())) * (180 / PI));
        }
        
};

#endif

벡터 클래스의 사용

#include <iostream>
#include <cmath>
#include "Vector3D.h"

using namespace std;

int main()
{
        Vector3D A(5, 2, -3);
        Vector3D B(8, 1, -4);

        cout << "Vector A*B : " << A.dotVector3D(B) << endl;
        cout << "Vector A magnitude: " << A.getMagnitude() << endl;
        cout << "Vector B mgaginute: " << B.getMagnitude() << endl;
        cout << "angle between two vectors: " << A.angleBetweenVector3Ds(B) << endl;
        
        Vector3D C = A.crossVector3D(B);        
        C.normalizeVector3D();
        
        cout << "nomalized vector: " << C.x << "i " << C.y << "j " << C.z << "k" << endl;
        
        return 0;
}

이 글은 스프링노트에서 작성되었습니다.

벡터의 개념

물체의 운동을 기술하기 위한 물리량으로 정적인 위치만을 기술하는 스칼라 양으로는 부적합하다.  이런 요구 충족을 위해

벡터량이 19세기 비교적 최근에 등장하게 되었음. 벡터는 크기와 함께 방향을 갖는 물리량이다. 

프로그램 코드에서 스칼라수는 어떠한 변수에도(어떤 자료형이든) 적용가능하지만, 벡터 저장을 위한 내장 데이터 타입은

없어서 별도로 구현해야한다. 

변위와 거리

변위는 거리를, 속도는 속력을 벡터로 표현한 것이다.  변위는 마지막 위치에서 시작 위치를 뺀 값이지만, 거리는 중간에 거친 

모든 경로를 더한 값이다. 변위는 중간에 일아나는 모든 일에 대한 정보는 없어진다는 점때문에 프로그램에서는 운동을 작은

시간간격으로 쪼개어 정보손실을 보완한다.  (프레임 단위의 짧은 시간 간격으로...)

 극좌표와 데카르트 좌표

1차원 벡터는 양수, 음수만으로 벡터의 방향을 표현 가능하지만,  2차원, 3차원에서는 충분치 않다. 

2차원에서 벡터를 기술하는 2가지 형태로 극좌표와 데카르트 좌표가 있다.  극좌표는 벡터의 크기와 어떤 기준선으로 부터

벡터가 이루는 각으로 표현한 방법이며. 벡터가  어떤 모양인지 파악하기 쉬운 장점이 있다. 

벡터의 극좌표

벡터의 크기를  |A| , 벡터의 방향을 θ 라 할때, 

벡터 A = |A|@θ 로 표현함

데카르트 좌표는 벡터를 수평과 수직 변위로 표현하는 방법으로,  코딩 시 사용되는 방법이다. 벡터를 구성하는  2가지 구성요소를 수직과 수평성분이라 한다. 컴퓨터 화면은 격자형태로 설정 되어있기 때문에,  데카르트 좌표를 사용한다. 

벡터의 데카르트 좌표

벡터의 x축 단위벡터를 i, y축 단위벡터를 j라 하면, 

벡터 B = b1i + b2j

극좌표의 데카르트 좌표로의 변환 

극좌표로 표현된 벡터 A가 |A|@ θ일 때, 피타고라스의 정리를 이용하여  데카르트좌표로 다음과 같이 표현할 수 있다. 

A = a1i + a2j  (a1 = |A|cosθ, a2 = |A|sinθ)

벡터의 합과 차

두 벡터의 합을 시각적으로 표현하면, 한 벡터의 시작점을 다른 벡터의 끝점으로 수평이동 시키고, 움직이지 않은 벡터의 시작점과 움직인 벡터의 끝점을 연결하여 그려진 벡터가 두 벡터의 합이다. 

임의의 벡터 A, B에 대해서 교환법칙임 성립함 
A+B = B+A

두 벡터의 합 C+D 길이는 C , D의 길이를 각각 더한 것보다 더 짧다. 

|A+B| != |A| + |B|이기 때문에 극좌표로 표현된 벡터는 같은 방향이 아니면 더해서는 안된다는 것에 주의해야 한다. 

대신 데카르트 좌표로 변환하여 더해야한다. 

두 벡터의 합 

두 벡터 A= a1i + a2j , B = b1i + b2j 에 대하여,

A + B = (a1 + b1)i + (b1+ b2)j 

 벡터의 차는 두 번째 벡터를 반전하여 더하는 것과 같다. 

두 벡터의 차 

두 벡터 A = a1i + a2j, B = b1i + b2j 이면 

A - B = (a1 - b1)i + (a2 - b2)j

벡터의 스칼라곱, 정규화

벡터의 스칼라 곱은 벡터의 크기만을 늘리거나 줄이는 결과를 가져온다. 

극좌표 형식 벡터의 스칼라 곱

임의의 벡터 A = |A| @ θ에 대하여,

cA = c |A| @ θ

벡터의 크기가 스칼라 양을 곱한 벡터와 같다. 

데카르트 형식 벡터의 스칼라 곱

임의의 스칼라 c와 임의의 벡터 A = a1i + a2j 에 대하여,

cA = c a1i + c a2j

베터의 각 성분에 스칼라 양을 곱한 벡터와 같다. 

정규화(normalization)

벡터의 크기를 1로 맞추는 것을 의미한다. 벡터의 방향만을 사용하고 싶을 때, 크기가 1인 단위벡터로  만들어 사용하는 것이다. 

 극좌표 형식의 벡터 정규화는 벡터의 크기를 1로 바꾸고, 방향을 그대로 유지하면 된다. 데카르트 형식의 벡터는 벡터의 크기를

계산하고, 각 성분을 크기로 나누면 된다. 

2차원 벡터의 정규화 

임의의 벡터 A = [a1 a2]에 대하여,

 =  A / |A| = [ a1/ |A|  a2/ |A|  a3/ |A| ]

벡터의 내적(dot product) 

두 벡터의 내적은 그 결과가 스칼라 값이어서 스칼라적이라고도 한다. 내적은 두 벡터의 각 x성분의 곱과 각 y성분의 곱을

더한 결과이다. 두 벡터가 같은 차원이어야 가능하다는 것을 주의하자. 

2차원 벡터의 내적 

임의의 2차원 벡터 A = [a1 a2], B = [b1 b2]에 대하여,

A⋅B = a1 b1 + a2 b2

 내적이 중요한 이유는 비교적 적은 연산으로 두 벡터 사이의 각을 구할 수 있기 때문이다.

내적은 3차원 그래픽 분야에서 3차원 다각형의 보이지 않는 제거될 면을 판단하기 위해 사용된다.

(카메라와의 각이 90 이상인 다각형은 제거됨)

내적의 부호

 벡터 A 와 B 사이의 각을 θ라 할 때,

A⋅B < 0 이면(음수이면),  θ > 90˚

A⋅B = 0 이면,  A ⊥ B

A⋅B  > 0  이면(양수이면), θ< 90˚

두 벡터 사이의  각 

임의의 두 벡터 A, B 사이의 각을 θ라 하면, 

A⋅B = |A| |B| cosθ

위와 같은 공식을 이용하여, 두 벡터 가 이루는 각을 알 수 있다. 

벡터의 외적(cross product)

두 벡터를 곱하는 또 다른 방법으로, 외적의 결과는 벡터라는 점 때문에 벡터적이라고도 한다. 

외적 

임의의 두 벡터 A = [a1 a2 a3],  B = [b1 b2 b3]에 대하여,

 A x B = [(a2b3-a3b2)  (a3b1 - a1b3)  (a1b2 - a2b1)]

외적의 중요한 성질은 외적의 결과가 원래의 두 벡터와 모두 직교하는 벡터라는 점이다. 이 때문에 외적은 3차원 벡터에

대해서만 정의된다.

직교 벡터 

A x B  는 두 벡터 A, B에 모두 수직인 벡터 

벡터 A와 B를 포함하는 평면에는 수직인 2개의 방향이 있기 때문에 외적은 교환법칙이  성립하지 않는다.  

A x B != B x A

단 임의의 3차원 벡터 A,B 에 대해서 A x B = -(B x A)

외적은 표면 법선(surface normal)을 계산하는데 사용된다. 임의의 두 3차원 벡터는 하나의 면을 정의하는데, 표면 법선은

주어진 면에 수직인 길이가 1인 벡터를 말한다.

또한 두 벡터의 사이의 각을 구할시 외적을 사용할 수도 있다. (내적을 통해 구하는 것이 더 효율적이다.)

두 벡터가 이루는 각을 외적을 통해 구하기 위한 공식 

|A x B| = |A||B|sin

게임을 개발하는 과정은 일반적인 프로그래밍 과정과 크게 다르지 않다.

일반적인 프로그래밍은

와 같은 흐름을 따른다.  게임프로그래밍에서 상응하는 흐름은 다음과 같다.

이러한 과정을 거쳐 한 프레임이 화면에 출력되며, 프레임의 연속적인 애니메이션이

게임을 이루게 된다.  입력 이벤트 처리 단계에서는 입력장치(키보드, 조이스틱, 터치스크린)를 통해 받은

데이터를 게임에서 의미있는 데이터로 변환한다. 게임로직 업데이트 단계에서는 입력장치로 입력받은 데이터에

근거하여 게임의 다음상태를 계산하게 되고, 물리로직과 렌더링 로직을 업데이트 한다. 디스플레이 렌더링 단계에서는

수정된 데이터를 화면에 드로잉한다. 

Frame

프레임(frame)이란 애니메이션을 구성하는 낱낱의 한 화면을 의마한다. 조금씩 다른 사물을 포함하는 프레임을 빠르게

교환하여 마치 사물이 움직이는 듯한 애니메이션 효과를 주는 것이다. 프레임율은 fps(frame per second) 단위로 표현하며,

사람의 눈에 끈김없는  애니메이션 효과를 주기위해서는 평균 30 fps 이상이여야 한다. 

Game Architecture

입력 이벤트 처리 / 로직업데이트 / 디스플레이 렌더링 의 각 단계는 게임의 장르, 동작 플랫폼에 따라서 천차만별로 달라질 수 있다.

입력 이벤트 처리에서 입력받는 데이터는 게임이 동작하는 장치에 따라 조이스틱, 키보드, 터치 스크린 등 다양할 수 있지만, 

입력인터페이스를 통해 사용자가 입력한 데이터를 추출하여 큐에 담는 비교적 단순한 작업이다. 로직업 데이터에서는 입력데이터를

기반으로 게임 세계를 이루는 사물들의 위치와 속성 등을 변화시킨다. 이 때 물리법칙이 적용되는 게임에서는 별도의 물리엔진을 

구성하여 물리엔진을 바탕으로 속성을 변화시킨다. 

 렌더링 단계에서는 변경된 로직을 바탕으로 화면에 드로잉을 수행하는데, 요즘과 같은 화려한 그래픽을 요구하는 게임에서는

상단한 자원과 렌더링 타임을 소모하게 되기 때문에, 스마트 폰과 같은 저사양 디바이스에서는 자원과 로직데이터의 량을 최소화하여

효율적으로 사용하는 전략이 필요하다

Collision Detection

게임에서 중요한 로직 중 하나가 충돌검사이다.  게임세계에서 묘사되는 사물들은 서로 접촉하게 될 경우 다양한 반응을

보이게 된다. 이러한 것들은 충돌검사를 통해 이루어진다.  다양한 형태를 갖는 사물들이 서로 접촉했는지 검사하는 것은

굉장히 복잡하고 어려운 작업이다.  복작한 형태를 갖는 사물을 단순한 도형으로 간소화하여 대체함으로써 충돌검사를 좀더

쉽게 할수 있다. 사물을 하나의 원으로 표현한다면, 원의 중심들 간에 거리와 원의 반지름의 합을 비교하여 접촉여부를 대략적

으로 검사할 수 있다. 실제로 사물이 접촉하지도 않았는데 충돌효과가 발생하여 동작이 어색함을 유발할 수 도 있다. 이럴 경우에는

단순한 도형으로 1차 충돌 검사를 하고, 1차 충돌검사가 통과할 경우 더 작은 도형(원과 사각형 등)들로 충돌 검사를 하여 정확도를

향상시킬 수 있다. 이러한 검사전략은 게임의 문맥과 사물의 특성에 따라, 결정해야할 문제이다. 

또 하나의 충돌검사에서의 과제는 게임세계에서는 수많은 사물들이 존재하는데 어떻게 두 사물이 접촉했는지 알 수 있는가?이다.

게임 세계에 존재하는 모든 사물든 간에 접촉을 검사해야 할까? 그러면 엄청난 자원소모가 발생할 것이다. 

게임세계를 다수의 일정한 영역으로 구분한다면,  현재 사물이 속한 영역에서 일정범위에 해당하는 영역 내의 사물들로 검사의  

범위를 한정지을 수 있다. 

Texture, Sprite

사물을 이루는 정점들의 구조인 Mesh에 이미지가 덧 입혀져 게임화면을 구성한다. 게임에 사용되는 이미지를 별도로 

텍스처라고 부른다. Mesh의 각 정점들과 맵핑되는 텍스처의 점을 맵핑하여 사물에 텍스처를 입힌다. (텍스처링)

게임에서 하나의 텍스처를 로딩하는데는 상당한 자원을 소모하게 되는데, 이를 여러 텍스처를 포함하는 하나의 큰 텍스처를

구성하고 한번에 로딩하여, 원하는 텍스처를 적절한 시점에 불러와 사용하는 전략이 사용된다.

일반적으로 게임에서는 시나리오와 레벨이 있어서, 어느 시점에 어느 자원이 필요하다는 것을 알수 있기 때문에, 필요한 만큼에

자원을 예측하여 한번에 로딩하여 퍼포먼스를 향상시킬 수 있다. 

이렇게 여러 작은 텍스처로 구성된 텍스처를 Atlas(지도책) 또는 Sprite 라고 부른다. (스프라이트는 애니메이션을 위해 조금씩

모양이 다른 이미지들로 구성된 텍스처들을 나타내는 의미가 강한 것 같음)

렌더링

화면 렌더링을 위한 표준 그래픽 라이브러리로  윈도우 플랫폼을 지원하는 Direct X와 멀티플랫폼을 지원하는 OpenGL이 있다.   

게임을 이루는 사물의 메시를 모두 프로그래머가 수동으로 그릴 수는 없다.  그래서 3차원 공간상에 사물들에 메시를 그려주고,

텍스처링해주며, 플랫폼에 맞게 메시와 텍스처를 쉽게 익스포트 할 수 있게 지원하는 3D 툴을 사용하게 된다. 

대표적으로  유료툴인 Maya아, 무료툴인 Blender 가 있다. 

게임루프
다음은 C언어를 사용하여 구현한 간단한 게임루프이다.

#include <stdio.h>

// 게임상태
enumGAME_STATE {
	LOADING, 
	MAIN_MENU, 
	PLAYING, 
	PAUSE, 
	QUIT
};


// 게임종료유무를나타내는변수
int isGameOver = 0;

// 현재 게임 상태
int game_state;

// 사용자입력갑
char userInput;

void event_precess();
void logic_update();
void render();



int main (int argc, const char * argv[]) {
	
	// 게임 초기화
	game_state = LOADING;
	printf("game start\n");
	render();
	
	while (!isGameOver) {
		event_precess();
		logic_update();
		render();
	}
    return 0;
}



// 사용자 입력
void event_precess() {
	
	printf("please input!\n");
	
	// 사용자입력을받음(표준입력)
	userInput = getchar();
	
	// 개행문자(enter)가나올때까지입력버퍼를비움
	while (getchar() != '\n');
	
}

// 로직 갱신
void logic_update() {
	
	switch (game_state) {
			
		caseLOADING:
			
			if (userInput == 'm') {
				printf("move to main menu!\n");
				game_state = MAIN_MENU;
			}
			break;
			
		caseMAIN_MENU:
			
			if (userInput == 'p') {
				printf("let's play game!!\n");
				game_state = PLAYING;
			} else if (userInput == 'q') {
				game_state = QUIT;
				isGameOver = 1;
			}
			break;
			
			
			
		casePLAYING:
			
			if (userInput == 'u') {
				printf("pause game!!\n");
				game_state = PAUSE;
			} else if (userInput == 'e') {
				printf("game over! move to main menu!\n");
				game_state = MAIN_MENU;
			}
			break;
			
		case PAUSE:
			
			if (userInput == 'r') {
				printf("resume game!!\n");
				game_state = PLAYING;
			}
			break;
	}
	
}


// 화면디스플레이
void render() {
	
	switch (game_state) {
		case LOADING:
			printf("loading state...\n");
			break;
			 
		case MAIN_MENU:
			printf("main menu state...\n");
			break;
			
		case PLAYING:
			printf("playing state...\n");
			break;
			
		case PAUSE:
			printf("pause state...\n");
			break;
			
		default:
			printf("quit game! bye bye~\n");
			break;		
	}
}