[OpenGL Tutorial] Using the Quadrics

사용자 삽입 이미지Quadrics가 무엇인지 부터 알아야 하겠다. Quadrics은 공간상에 기하학적인 모양을 생성하는 것이다. 여기서 말하는 기하학적 모양이란 원뿔, 원통, 원판, 구 등을 말한다. 즉 Quadrics를 사용하여 쉽고 간단하게 위에서 언급한 물체를 생성할 수 있다. 그렇다면 이제 Quadrics를 사용하여 물체를 만들고 시연해보자 !!

먼저 Quadrics를 이용하여 물체를 만들기 전에 Quadrics를 생성하여야 한다. Quadrics는 속성을 가지고 있는데, 그 속성이란 그리고자 하는 것, 그리고자 하는 것의 위치(원점)과 값(반지름 등등), 광원 모드, 텍스쳐 모드, 그리고 그리는 도중에 에러가 발생할 경우 호출할 CallBack 함수들을 말한다. Quadrics를 생성하는 방법은 쉽다. 제공되는 Factory(생성) 함수가 있으니 말이다.

GLUquadricObj *obj;
obj = gluNewQuadric();

생성은 위의 코드가 전부이다. 간단하다. 나중에 생성된 Quadric객체의 인스턴스 변수인 obj를 이용하여 물체를 그리는데 사용되는 함수는 gluCylinder, gluDisk, gluSphere가 있고 미래에 더 추가될 것이다. 이 함수들은 첫번째 인자로 Quadric 객체를 요구하고 각 함수에 따라 실린더 모양을 그릴것인지 디스크 모양을 그릴것인지 구 모양을 그릴 것인지를 지정하는 것이다. 그렇다면 정작 그릴 물체에 대한 속성은 어떻게 설정하는 것인가? 예를 들어서 물체를 Wire Frame 형태로 그릴것인지 Solid 형태로 그릴것인지의 결정은 어떻게 하는가? 또한 Solid 형태로 그린다면 물체의 면을 Flat형태로 그릴것인지 Smooth하게 그릴것인지의 결정은 어떻게 하는가? 법선벡터의 방향을 바깓쪽으로 할것인지 안쪽으로 할것인지의 결정은 어떻게 하는가? 그리고 나중에 Quadric로 생성한 객체에 대해 텍스쳐 맵핑을 할경우 텍스쳐 맵 좌표를 자동으로 생성시키게 할것인가 아니면 않할것인가의 지정은 어떻게 하는가? 이 많은 질문에 대한 답은 아래와 같다.

일단 Quadric 객체가 생성되면 다음의 함수를 통해서 그 속성을 설정할수있다.

1. void gluQuadricDrawStyle(GLUquadricObj *obj, GLenum drawStyle)

이 함수의 첫번째인자는 속성을 설정할 Quadric에 대한 인스턴스 변수에 대한 포인터가 오며 두번째 변수에 올수있는 값은 GLU_FILL, GLU_LINE, GLU_SILHOUETTE, GLU_POINT가 온다. Wire Frame 형태를 원한다면 GLU_LINE가 필요하고 Soild 형태를 원한다면 GUL_FILL이 그리고 단지 점만으로 그리기를 원한다면 GLU_POINT가 온다. GLU_SILHOUETTE는 선으로 외부 모서리만을 그리게 된다.

2. void gluQuadricNormals(GLUquadricObj *obj, GLenum normals)

위의 함수는 법선벡터를 제어하는데 사용되는데 법선 벡터에의해서 빛에 대한 영향이 결정된다는 것은 지난 “빛”에 대한 장에서 충분히 설명했다. 이 함수의 첫번째 인자는 역시 Quadric의 인스턴스 변수에 대한 포인터를 갖고 두번째 인자에 올수있는 인자의 값에는 GLU_NONE, GLU_FLAT, GLU_SMOOTH가 온다. GLU_NONE는 법선벡터를 생성하지 않는데 이렇게 되면 빛에 대해서 아무런 효과를 얻을 수 없다. GLU_FLAT는 면이 깍인것처럼 보이도록 법선벡터를 생성하고 GL_SMOOTH는 면이 부드럽게 보이도록 즉, 물체의 모서리를 부드럽게 보이게 법선 벡터를 생성한다.

3. void gluQuadricOrientation(GLUquadricObj *obj, GLenum orientation)

이 함수는 법선벡터의 방향을 지정하기 위해 사용된다. 첫번째 인자는 Quadric의 인스턴스 변수에 대한 포인터를 갖고 두번째 인자가 갖을 수 있는 값에는 GLU_OUTSIDE와 GLU_INSIDE가 온다. GLU_OUTSIDE는 법선벡터를 물체에 대해서 바깓쪽으로 법선벡터의 방향을 지정하고 GLU_INSIDE는 법선벡터를 물체에 대해서 안쪽으로 방향을 지정하도록 생성한다.

4. void gluQuadricTexture(GLUquadricObj *obj, GLboolean textureCoords)

이 함수는 텍스쳐 맵핑 좌표를 생성할 것인지 않할 것인지를 지정하는 것이다. 첫번째 인자는 Quadric의 인스턴스 변수에 대한 포인터를 갖고 두번째 인자가 갖을 수 있는 값에는 GL_TRUE와 GL_FALSE이다. GL_TRUE로 할경우 텍스쳐 맵핑 좌표를 생성하며 GL_FALSE는 텍스쳐 맵핑 좌표를 생성하지 않는다.

자 이렇게 해서 Quadric에 대한 속성을 설정하는 함수에 대한 소개를 마치고 이제 본격적으로 우리가 필요로하는 물체를 그려보는 것에 대해서 알아보자!!

사용할 기본 소스는 1장의 소스에서 시작한다.

먼저 Quadric 객체를 생성하기 위한 변수를 하나 선언하자. 코드 전체에서 이 변수를 참조하므로 전역 변수를 선언하는 곳에 선언한다.

GLUquadricObj *obj;

이제 Quadric를 생성해야 한다. OpenGL을 초기화 시키는 부분인 InitGL 함수부에서 끝부분쯤에 다음의 코드를 추가한다.

obj = gluNewQuadric(); // <1>
gluQuadricDrawStyle(obj, GLU_FILL); // <2>
gluQuadricNormals(obj, GLU_SMOOTH); // <3>
gluQuadricOrientation(obj, GLU_OUTSIDE); // <4>
gluQuadricTexture(obj, GL_FALSE); // <5>
   
glEnable(GL_LIGHTING); // <6>
glEnable(GL_LIGHT0); // <7>
glEnable(GL_COLOR_MATERIAL); // <8>

<1>번 코드는 실제적으로 Quadric 객체를 생성시키는 코드이다.

<2>번 코드는 Solid 형태로 물체를 그린다는 것이고 <3>번은 면에 대해서 부드럽게 그린다는 것이고 <4>번은 법선벡터의 방향을 물체에 대해서 바깓쪽으로 향하도록 법선벡터를 생성하라는 의미이다. <5>번은 텍스쳐 맵을 적용하지 않을 것으므로 텍스쳐 맵핑 좌표를 생성하지 말라는 의미이다.

<5>~<8>번은 빛을 활성화시키고 칼라 추적 기능을 이용해서 물체의 재질을 설정하라고 지시한다. 참고로 LIGHT0는 별도로 설정하지 않아도 기본적으로 그래픽 카드에서 값이 설정되어 있는 빛이다. 필자의 그래픽 카드(G400)에서는 휼룡하게 작동했다.

자! 이렇게 해서 Quadric 객체를 생성했고 그 속성을 설정했으며 나머지 빛과 재질에 대한 설정 또한 끝냈다.

그렇다면 무언가를 생성했으니 나중에 필요치 않으면 메모리에서 제거해야 하는 것은 프로그래머에 대한 불문율이다. Quadric 객체를 제거하는 방법은 무언인가? 실제적으로 제거하는 코드의 위치는 WinMain 함수의 끝부분쯤에 위치한다. 아래와 같다.

            .
            .
            .
   
    gluDeleteQuadric(obj); // 추가 코드
   
    // Shutdown
    KillGLWindow(); // Kill The Window
     return (msg.wParam); // Exit The Program
}

이제 실제적으로 Quadirc객체를 이용하여 물체를 그리는 작업만 남았다. 그리는 작업은 DrawGLScene 함수에 위치한다. 다음은 그 함수에 대한 코드 전체이다.

int DrawGLScene(GLvoid)
{
    static GLfloat rot = 0.0f;
   
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -15.0f);
   
    glPushMatrix();
    glTranslatef(-5.0f, 0.0f, 0.0f);
    glRotatef(rot, 1.0f, 1.0f, 1.0f);
    glTranslatef(0.0f, 0.0f, -2.0f);
    glColor3f(0.6f, 0.6f, 1.0f);
    gluCylinder(obj, 1.0f, 1.0f, 4.0f, 16, 4); //<1>
    glPopMatrix();
   
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.0f);
    glRotatef(rot, 1.0f, 1.0f, 1.0f);
    glColor3f(0.6f, 0.6f, 1.0f);
    glColor3f(1.0f, 0.6f, 0.6f);
    gluDisk(obj, 0.2f, 1.6f, 16, 4); //<2>
    glPopMatrix();
   
    glPushMatrix();
    glTranslatef(5.0f, 0.0f, 0.0f);
    glRotatef(rot, 1.0f, 1.0f, 1.0f);
    glColor3f(0.6f, 0.6f, 1.0f);
    glColor3f(0.6f, 1.0f, 0.6f);
    gluSphere(obj, 1.5f, 24, 24); //<3>
    glPopMatrix();
   
    rot += 1.0f;
    if(rot > 359.0f) rot = 1.0f;
   
    return TRUE;
}

새롭게 추가된 코드는 노란색으로 나타냈다. 실제 중요한 Quadric 객체를 그리는 코드에 대해서만 설명하도록 한다. 나머지 부분은 지난장에서 이미 다루었던 내용이므로 해당 장들을 참고하기 바란다.

<1>번 코드에서는 gluCylinder 함수를 사용했는데 첫번째 인자는 Quadric의 인스턴스 변수에 대한 포인터가 온다. 두번째 인자는 실린더의 밑부분의 반지름 크기이고 세번째는 실린더의 윗부분의 반지름 크기이다. 네번째는 실린더의 길이를 지정하는 것이고 다섯번째는 Slice의 수를 여섯번째는 Stack의 수를 나타낸다. Slice를 높일수록 실린더의 모양이 보다 부드러워진다. WireFrame 모드로 설정해서 그려본다면 분명하게 그 내용을 파악할수있다. 실린더의 윗부분과 아랫부분은 뚫려있다.

<2>번 코드는 gluDisk를 사용하는데 첫번째 인자는 Quadric의 인스턴스 변수에 대한 포인터가 온다. 두번째는 디스크의 안쪽 뚤린 원에 대한 반지름이고 세번째는 디스크의 바깓쪽에 대한 반지름이다. 네번째는 Slice의 갯수이고 다섯번째는 loop의 갯수이다.

<3>번 코드는 gluSphere인데 첫번째 인자는 Quadric의 인스턴스 변수에 대한 포인터가 온다. 두번째는 구의 반지름값이고 세번째는 slice의 갯수이고 네번째는 stacks의 갯수가 온다.

자, 이제 실행하는 것만 남았다. 아래는 그 실행 결과이다

사용자 삽입 이미지

[OpenGL Tutorial] Output String on the Screen(Outline)

사용자 삽입 이미지지난장에서는 비트맵으로 문자를 출력했었다. 이번에는 문자를 객체로 처리하는 방법인 Outline Font에 대해서 알아보도록 한다. 이 장의 시작은 7장의 소스 코드에서 시작한다.

전역 변수를 2개 추가하자. Outline Font로써 문자를 처리하면 일반 객체처럼 회전이 가능하다. 이를 확인해 보기 위해 문자를 회전시키는데 사용하는 변수 하나와 Outline Font 문자들에 대한 정보를 저장하는 변수 변수인 gmf을 선언한다. 배열이 96개인 이유는 ASCII의 코드중에서 숫자, 영문자와 특수문자에 대해 사용할 수 있도록 하기 위함이다.

GLuint base;
GLfloat rot = 0.0f; // 
GLYPHMETRICSFLOAT gmf[96]; // 

이제 해야 할 일은 모든 문자들을 Outline Font로써 리스트에 등록 저장하는 것이다. 즉, OpenGL에서 사용할수 있도록 폰트의 리스트를 만들어야 한다. 다음의 코드가 폰트의 리스트를 생성하는 코드이다.

GLvoid BuildFont(GLvoid)
{
    HFONT font;
    base = glGenLists(96);
    font = CreateFont(-12,
                0,
                0,
                0,
                FW_BOLD,
                FALSE,
                FALSE,
                FALSE,
                HANGUL_CHARSET,  // <1-1>
                OUT_TT_PRECIS,
                CLIP_DEFAULT_PRECIS,
                ANTIALIASED_QUALITY,
                FF_DONTCARE|DEFAULT_PITCH,
                "Comic Sans MS"); // <1-2>
   
    SelectObject(hDC, font);
   
    wglUseFontOutlines(hDC,  // <2-1>
                32, // <2-2>
                96, // <2-3>
                base, // <2-4>
                0.1f, // <2-5>
                0.5f, // <2-6>
                WGL_FONT_POLYGONS, // <2-7>
                gmf); // <2-8>
}

지난장에서 설명했던 것은 제외하고 새로운 것만을 설명하도록 하겠다.

<1-1>의 코드를 살펴보자. 기억력이 좋은 독자는 지난장에서의 <1-1>의 코드가 무엇이었는지 기억하는가? ANSI_CHARSET이였다. 하지만 한글 윈도우즈에서는 Outline Font를 사용할때 ANSI_CHARSET로 해주면 Outline Font를 얻을수없다. 원하는 것을 얻기위해서는 HANGUL_CHARSET으로 지정해 주어야 한다.

<1-2>에서 폰트를 바꾸었다. 지난장과 같이 폰트를 바꾸지 않아도 상관없다.

이제 가장 핵심이 되는 실제 Outline Font의 리스트를 얻어오는 함수에 대해서 알아보도록 하겠는데 바로 <2-1>에서 보이는 wglUseFontOutlines가 바로 그것이다. 총 8개의 인자가 필요한데 하나 하나 알아보자.

<2-1> 코드는 OpenGL과 연결되어 있는 DC에서 폰트 정보를 얻기 위한 DC의 핸들이다.

<2-2> 코드는 ASCII에서 시작할 코드의 번호이고 <2-3> 코드는 <2-2>코드에서 지정된 코드에서 몇개의 문자를 얻을 것인지를 지정하는 갯수값이다.

<2-4> 코드는 실제 리스트를 만들때 기준이 되는 값을 지정하는 것이다.

<2-5> 코드는 폰트로부터 얼마나 정밀하게 객체를 생성할 것인지를 나타낸다. 0.0값이 가장 정말하게 만들수있다.

<2-6> 코드는 Z축으로 문자 객체의 두깨를 설정한다.

<2-7> 코드가 가질수있는 값은 2가지인데 첫째는 WGL_FONT_POLYGONS와 WGL_FONT_LINES이다. 첫째는 면으로 구성된 폰트 객체를 생성하고 두번째는 라인만으로 구성된 폰트 객체를 생성한다.

<2-8> 코드는 실제 생성된 각각의 문자에 대한 Outline 정보가 저장되는 배열 변수이다.

리스트를 생성했다면 생성된 것들을 반환하는 함수도 필요하다. 다음의 코드가 그와 같은 것이다. 이미 지난장에서 만들었고 그대로 사용하면 된다.

GLvoid KillFont(GLvoid)
{
    glDeleteLists(base, 96);
}

glDeleteLists 함수로써 첫번재 인자는 메모리 상에서 제거할 리스트의 기준값이 오고 두번째는 그 기준에서부터 몇개의 리스트를 제거할 것인지를 나타낸다.

이제 사용할 폰트 리스트가 완벽하게 준비가 되었다. 이제 이 준비된 리스트를 화면상에 찍을 수 있는 함수를 만들어보자. 출력한 물자열을 인자로 받아 출력해 주는 함수이다. 이미 지난장에서 만들었고 그대로 사용하면 된다.

GLvoid glPrint(const char *text)
{
    glPushAttrib(GL_LIST_BIT); //<1>
    glListBase(base - 32); //<2>
    glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); //<3>
    glPopAttrib(); //<4>
}

자! 이제 화면상에 글자를 그려주는 함수까지 준비가 되었다. 이제 위에서 만든 것들을 사용만 하면 되겠다. 먼저 initGL(GLvoid) 함수에 위에서 만든 BuildFont 함수를 추가함으로써 폰트 리스트를 생성하도록 한다.

int InitGL(GLvoid)
{
    glShadeModel(GL_SMOOTH);
    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
   
    ///////////////////////// NEW //////////////////////////
    BuildFont();
    glEnable(GL_LIGHTING); // <1>
    glEnable(GL_LIGHT0); // <2>
    glEnable(GL_COLOR_MATERIAL); // <3>
    ///////////////////////// NEW //////////////////////////
   
    return TRUE;
}

위의 코드를 보면 새롭게 추가된 코드가 3개이다. <1>과 <2>는 빛을 켜는 코드이고 <3>은 색상을 추적하여 물체의 재질을 설정하는 코드이다. 이 코드가 새로운 독자는 빛과 재질에 대한 장을 보기 바란다.

그리고 WinProc 함수의 WM_CLOSE를 처리하는 부분(이 부분은 프로그램이 종료될때 실행된다)에서 KillFont 함수를 추가하여야 하는데 이미 지난장에서 추가하였다.

case WM_CLOSE:
{
    ///////////////////////// NEW //////////////////////////
    KillFont();
    //////////////////////// NEW //////////////////////////
    PostQuitMessage(0);

    return 0;
}

자 이제 문자열을 화면상에 그려주는 것만 남았다. 무언가를 그려주는 코드는 항상 DrawGLScene(GLvoid) 부에 위치했고 이번에도 역시 마찬가지이다. 다음의 코드를 살펴보자.

int DrawGLScene(GLvoid)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -6.0f);
   
    glColor3f(0.90f, 0.9f, 1.0f);
    glScalef(1.0f, 2.0f, 1.0f);
    glRotatef(rot, 0.0f, 1.0f, 0.0f);
    glTranslatef(-1.0f, -0.3f, 0.0f);
    glPrint("Dip2K");
    rot += 1.0f;
   
    return TRUE;
}

DrawGLScene 함수의 구현은 모두 새롭게 작성되어졌다.

기본 흐름은 옅은 파랑색으로 재질을 설정하며 Y축으로 물체(문자)를 늘렸다. 그리고 매 순간마다 Y축으로 1도씩 회전시키는 에니메이션으로써 분명하게 문자의 3차원임일 확인한다. 비트맵의 경우 특별하게 문자의 위치를 지정하는 함수가 따로 있었던데 반해서 Outline Font는 단지 객체이므로 따로 그럴 필요가 없다.

다음은 최종적인 이 프로그램의 실행 결과이다.


사용자 삽입 이미지
어떤가? 드디어 우리가 원하는 결과를 얻었다.

[OpenGL Tutorial] Output String on the Screen(Bitmap)

사용자 삽입 이미지OpenGL에서 문자를 출력해야 할 경우가 있다. 그렇다면 OpenGL에서는 문자를 출력하기 위한 루틴이 준비되어져 있는가? 대답은 “전혀, 아니다” 이다. 그 이유는 각 플랫폼 OS에 따라 문자를 출력하는 방식이 너무나도 다르기 때문이라고 하는 이도 있다. 그래서인지 각 플랫폼마다 각각 그에 맞는 OpenGL API를 확장하여 제공하는데 문자 출력 부분의 함수도 같이 제공된다. 윈도우즈에서는 위글(WGL)이라 불리우며 Applet은 아글(AGL), 유닉스 계열의 OS은 XGL의 이름으로 재공된다. 본장은 여러가지 플랫폼들중에 우리가 가장 많이 사용하는 윈도우즈에서 문자를 출력해 보는 것으로 구성하려고 한다. 즉, 이 장은 다른 OS에서는 이용될수 없다.

우리의 컴퓨터에는 많은 글꼴이 하드 디스크에 저장되어져 있고 또 사용되어진다. 이 많은 글꼴들을 OpenGL에서 사용하는 방법에는 2가지가 있는데 첫째는 문자 하나 하나를 Bitmap 방식으로 사용하는 경우와 문자 하나 하나를 객체로 처리하여 사용하는 경우가 있다. Bitmap 방식으로 사용할 경우 이것은 객체가 아니기 때문에 회전이라든지 확대/축소라든지 텍스쳐 맵핑등 OpenGL에서 객체에 적용할 수 있는 것들이 크게 제약된다. 하지만 객체 단위로 처리할 경우 말 그대로 문자 하나 하나가 객체이므로 모든 특수효과를 적용할수 있다. 그러나 Bitmap에 비하여 객체단위로 문자를 처리하는 것은 많은 어버헤드와 연산 시간이 소요된다. 이장에서는 Bitmap으로 문자를 처리하는 것에 대해 다루고 다음에 장에서 객체를 이용한 문자 출력을 설명하기로 한다. 참고로 객체 단위로 문자를 처리하는 경우 그 문자를 Outline 형태의 문자라 한다.

이곳에서 사용할 소스 코드는 1장에서 만들어진 것에서 부터 시작된다.

전역 변수를 하나 설정하자. 이 변수는 폰트 리스트의 기준으로 사용된다.

GLuint base;

이제 해야 할 일은 모든 문자들을 비트맵 형식으로 저장하는 것이다. 즉, OpenGL에서 사용할수 있도록 폰트의 리스트를 만들어야 한다. 다음의 코드가 폰트의 리스트를 생성하는 코드이다.

GLvoid BuildFont(GLvoid)
{
    HFONT font; // <1>
    base = glGenLists(96); // <2>
    font = CreateFont(-24, // <3-1>
                0,
                0,
                0,
                FW_BOLD, // <3-2>
                FALSE, // <3-3>
                FALSE, // <3-4>
                FALSE, // <3-5>
                ANSI_CHARSET, // <3-6>
                OUT_TT_PRECIS,
                CLIP_DEFAULT_PRECIS,
                ANTIALIASED_QUALITY,
                FF_DONTCARE|DEFAULT_PITCH,
                "Courier New"); // <3-6>
   
    SelectObject(hDC, font); // <4>
    wglUseFontBitmaps(hDC, 32, 96, base); // <5>
}

<1>번 코드는 윈도우즈에 설치되어 있는 폰트를 사용하기 위해 폰트를 생성하기 위해 사용하는 변수이다.

<2>번 코드는 총 96개의 리스트를 만든다. 숫자와 영문자(대, 소문자) 그리고 특수 기호를 모두 합한 갯수이다. 잠깐 리스트에 대해서 소개하자면 리스트란 우리가 어떤 물체를 만든다고 할때 그 물체를 하나의 리스트에 지정해 두면 이후에 또 그 물체가 필요할 경우 지정된 리스트만을 호출해서 필요한 물체를 사용할 수 있도록 하는 기능이다. 장점이라면 리스트로 미리 물체를 생성해 놓으면 그렇지 않을때보다 속도가 많이 개선된다. 단점이라면 메모리를 차지 하고 있다는 것이다. 리스트를 생성하는 함수가 glGenLusts인데 몇개의 리스트를 생성하는지를 인자로 갖는다. 반환값은 생성된 리스트의 첫번째를 참조하는 기준(Base)값을 리턴한다.

<3-1>번 코드에서 보이는 CreateFont는 Font를 생성하는하여 반환하는 것으로 아주 많은 인자를 갖는다. 필자도 이 모든 인자에 대해서 자세히 알지 못하지만 중요하다고 생각되는 인자에 대해서만 언급하도록 하겠다. 첫번재 인자는 폰트의 크기이다. 이 경우 -24인 음수를 주었는데 이는 만약 크기 24인 폰트를 생성하는데 24인 폰트를 만들수없다면 그와 가장 가까운 크기로 만들어라는 의미에서 음수 형태로 지정한 것이다. 그리고 <3-2>의 인자는 폰트를 어느 정도로 두껍게 할지에 대해 지정하는 것이다. 주로 갖는 값은 FW_SHIN, FW_BOLD, FW_NORMAL 등이 있다. <3-3>은 Italic 모양인지를 지정하는 것이고 <3-4>는 언더라인 형태인지를, <3-5>는 Strike Out 형태인지를 Boolean 형태로 지정한다. <3-6>은 생성할 폰트의 Char Set를 지정하는 것으로 대부분의 영문자에 대해서는 ANSI_CHARSET이면 충분하고 한국 윈도우즈의 경우 HANGUL_CHARSET으로 지정할 수도 있는데 다음장에서 설명할 Outline 형태의 문자 출력에서는 HANGUL_CHARSET으로 지정해야만 된다. 그리고 벳딩과 같은 그림문자 기호는 SYMBOL_CHARSET으로 지정해야 원하는 바를 얻을수 있다. 그리고 <3-6>은 사용하기를 원하는 폰트의 이름을 지정한다. 이 함수에 대한 나머지 자세한 것들은 관련 자료를 찾아보길 바란다.

<4>번 코드는 생성한 폰트를 해당 DC에서 사용하도록 지정하는 코드이다.

<5>번 코드는 OpenGL이 사용하는 DC에서 사용하는 폰트를 통해서 폰트 리스트를 생성하는 위글 함수이다. 위글 함수는 윈도우즈에서만 제공되는 함수이다. 첫번째 인자는 DC의 헨들, 두번째는 코드값과 밀접한데 우리가 ASCII 코드는 0에서 255까지의 값을 갖는다. 즉 두번째는 ASCII 코드값중에서 몇번부터 사용할 것인지를 지정한다. 세번째는 두번째에서 지정한 코드에서부터 몇개의 코드를 취할 것인지를 지정한다. 위의 코드는 32번 코드에서부터 총 96개의 문자를 취해 리스트를 생성하고자 한다는 의미이다. 네번째 인자는 생성될 리스트의 기준이 될 변수이다. 이 코드가 가장 핵심적인 코드가 되겠다.

리스트를 생성했다면 생성된 것들을 반환하는 함수도 필요하다. 다음의 코드가 그와 같은 것이다.

GLvoid KillFont(GLvoid)
{
    glDeleteLists(base, 96);
}

glDeleteLists 함수로써 첫번재 인자는 메모리 상에서 제거할 리스트의 기준값이 오고 두번째는 그 기준에서부터 몇개의 리스트를 제거할 것인지를 나타낸다.

이제 사용할 폰트 리스트가 완벽하게 준비가 되었다. 이제 이 준비된 리스트를 화면상에 찍을 수 있는 함수를 만들어보자. 출력한 물자열을 인자로 받아 출력해 주는 함수이다.

GLvoid glPrint(const char *text)
{
    glPushAttrib(GL_LIST_BIT); //<1>
    glListBase(base - 32); //<2>
    glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); //<3>
    glPopAttrib(); //<4>
}

<1>번 코드는 리스트에 대한 상태를 저장하는 것인데 이는 우리가 리스트를 하나만 사용하는 경우에는 별로 중요치 않으나 또 다른 다른 리스트 사용할 수도 있다. 또 다른 리스트를 위해서 리스트 상태를 저장해 두는 것이다.

<2>번 코드는 사용하고자 하는 리스트의 기준을 OpenGL에게 알려주는 것이다. 기준에서 32를 뺐는데(base-32) 우리가 위에서 폰트 리스트를 생성할때 ASCII 코드중에서 32번부터 시작을 했기 때문이다.

<3>번 코드는 실제적으로 리스트에서 필요한 것들을 가져와 그려주는 핵심이 된다. text 변수는 문자열 배열이다. 우리가 ASCII에서 ‘A’는 65번이다. ‘B’는 66번이다. text 변수에 “ABC”라는 문자가 있다고 해보자. text는 문자열 배열이라고 볼수있고 각 셀의 값은 부호없는 Byte형이다. 모두 3개의 문자로 이루어져 있다. 이것은 곧 첫번재 셀에는 65가 두번째 셀에는 66이 세번째 셀에는 67의 Unsigned Byte Type의 값이 들어있는 것과 동일하다. 이부분을 이해했다면 glCallLists를 살펴보자. 첫번재 인자는 해석해야될 셀의 겟수를 나타내고 두번째는 셀의 데이타 타입을 세번째는 그 셀의 배열을 나타내게 된다. 결국 하나 하나의 셀을 순서대로 처리해서 화면상에 그려주는 것이다. 일단 하나의 셀이 처리되면 자동으로 다음에 처리될 셀을 위해 좌표가 오른쪽으로 이동된다.

자! 이제 화면상에 글자를 그려주는 함수까지 준비가 되었다. 이제 위에서 만든 것들을 사용만 하면 되겠다. 먼저 initGL(GLvoid) 함수에 위에서 만든 BuildFont 함수를 추가함으로써 폰트 리스트를 생성하도록 한다.

int InitGL(GLvoid)
{
    glShadeModel(GL_SMOOTH);
    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
   
    ///////////////////////// NEW //////////////////////////
    BuildFont();
    ///////////////////////// NEW //////////////////////////
   
    return TRUE;
}

그리고 WinProc 함수의 WM_CLOSE를 처리하는 부분(이 부분은 프로그램이 종료될때 실행된다)에서 KillFont 함수를 추가한다.

case WM_CLOSE:
{
    ///////////////////////// NEW //////////////////////////
    KillFont();
    ///////////////////////// NEW //////////////////////////
    PostQuitMessage(0);
    return 0;
}

자 이제 문자열을 화면상에 그려주는 것만 남았다. 무언가를 그려주는 코드는 항상 DrawGLScene(GLvoid) 부에 위치했고 이번에도 역시 마찬가지이다. 다음의 코드를 살펴보자.

int DrawGLScene(GLvoid)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -4.0f);
    glBegin(GL_QUADS);
    glColor3f(0.0f, 0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
    glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(1.0f, -1.0f);
    glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(1.0f, 1.0f);
    glColor3f(0.0f, 0.0f, 1.0f); glVertex2f(-1.0f, 1.0f);
    glEnd();
   
    glColor3f(1.0f, 1.0f, 1.0f);      //<1>
    glRasterPos2f(-1.4f, 0.0f);       //<2>
    glPrint("Dip2K's OpenGL Forum");  //<3>
   
    return TRUE;
}

노란색의 코드가 새롭게 추가된 것들인데 중요한 것은 <1>번과 <2>번 코드이다. 나머지 것들은 모두 지난장에서 살펴보았으므로 설명은 생략하기로 하고 중요한 것들만 살펴보자.

<1>번 코드는 그려줄 비트맵의 색을 지정하는 코드이다. 비트맵 역시 glColor로써 색을 지정한다.

<2>번 코드는 우리가 어디에 문자를 그려줄 것인가를 지정하는 것이다. Bitmap의 문자는 특별이 위치를 지정해 주는 함수가 따로 준비되어 있는데 바로 glRasterPos2f가 그 함수이다. 첫번째는 X좌표이고 두번째는 Y좌표를 나타낸다. Bitmap은 Perspective가 적용되지 않으며 항상 Ortho 모드로만 적용된다.

<3>번 코드는 우리가 이미 만들어 놓은 함수이다. 출력하고자 하는 문자열을 넣어주기만 하면 그만이다.

다음은 최종적인 이 프로그램의 실행 결과이다.

사용자 삽입 이미지

어떤가? 드디어 우리가 원하는 결과를 얻었다.

[OpenGL Tutorial] Texture Mapping

사용자 삽입 이미지

이번 장에서는 컴퓨터 그래픽의 꽃이라고 할수있는 텍스쳐 맵핑에 대해서 알아보도록하자. 컴퓨터 그래픽에 있어서 가장 발전한 기술이 바로 이 텍스쳐 맵핑이라고 한다. 텍스쳐 맵핑이 무엇인지 잠깐 설명하도록 하겠다. 둠이라는 게임을 해 보았는가? 벽으로 막힌 건물 안에서 사악한 주인공이 조용이 살고 싶어하는 착한 괴물을 죽이고 다니는 아주 불건전한 겜이다. 여기서 둠에 나오는 벽을 생각해 보자. 그 벽은 원래 그냥 폴리곤(면)에 불과 했다. 그런데 그 면위에 그림을 입혀 마치 진짜 벽처럼 보이게 한 것이다. 바로 그림을 폴리곤에 입히는 것을 텍스쳐 맵핑이라고 한다. 그 둠이라는 게임에서 사용한 텍스쳐 맵핑 기술은 아주 원시적인 기술이다. 둠의 텍스쳐 맵핑은 단지 평평한 면에만 그림을 입힐수있다. 하지만 OpenGL에서는 곡면에도 그림을 입힐수있다.

대강 텍스쳐 맵핑에 대한 소개는 이쯤에서 접고 OpenGL에서 텍스쳐 맵핑 가운데 2차원 텍스쳐 맵핑에 대해서 알아보도록 하자. 2차원 텍스쳐 맵핑을 설명하기 위해 필자가 준비한 실습 예제는 우리가 지난장에서 만든 정육면체의 각면들에 세가지 그림을 입히는 것, 즉 그림(텍스쳐)를 맵핑하는 것으로 하겠다. 시작에 앞서 그 결과를 먼저 보여주겠다.

사용자 삽입 이미지

그 결과를 살며 보았으면 이제 어떻게 이런 결과를 얻었는지의 그 과정을 설명하기 위해 5장에서 사용한 소스를 기본으로 해서 제작해도록 하겠다. 자! 5장의 소스를 비주얼씨++로 열어 보기 바란다.

텍스쳐 맵핑을 하기 위해 준비해야될 것들은 무엇인가? 바로 텍스쳐, 즉 그림이다. 이 장에서는 3개의 그림이 필요하겠다. OpenGL에서는 간단하게 그림 파일(BMP)을 바로 텍스쳐 맵핑 소스로 사용할 수 없다. 이 그림 파일을 텍스쳐 맵핑 소스로 변환해 주는 루틴이 필요한다. 다음이 바로 그 루틴이다.

AUX_RGBImageRec *LoadBMPFile(char *filename)
{
    FILE *hFile = NULL;
    if(!filename) return NULL;
   
    hFile = fopen(filename, "r");
    if(hFile) {
        fclose(hFile);
        return auxDIBImageLoad(filename);
    }
   
    return NULL;
}

AUX_RGBImageRec 구조체는 AUX 라이브러리의 함수로 BMP 파일의 크기와 그림 데이타 포인터를 가지고 있다. 위의 함수는 파일 이름 인자를 가지는데 그 인자에 해당하는 것이 BMP 파일이다. 중요한 함수는 auxDIBImageLoad 함수이고 나머지 모든 루틴은 파일이 존재하는지을 참조하기 위함이다. 모든 오류에 있어서 NULL 값을 반환한다.

이제 그림 파일에서 맵핑 소스를 읽어 들이는 루틴이 완성되었다. 그렇다면 텍스쳐 맵핑을 OpenGL에서 사용할수있도록 Setting을 해줘야 하는데 그에 해당되는 코드들을 살펴보자.

AUX_RGBImageRec *texRec[3]; //<1>
memset(texRec, 0, sizeof(void *)*3); //<2>

if((texRec[0]=LoadBMPFile("img.bmp")) && //<3>
    (texRec[1]=LoadBMPFile("img2.bmp")) &&
    (texRec[2]=LoadBMPFile("img3.bmp"))) {
    glGenTextures(3, &tex[0]); //<4>
    for(int i=0; i<3; i++) { //<5>
        glBindTexture(GL_TEXTURE_2D, tex[i]); //<6>
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //<7>
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //<8>
        glTexImage2D(GL_TEXTURE_2D, 0, 3, texRec[i]->sizeX, texRec[i]->sizeY, 0, 
                 GL_RGB, GL_UNSIGNED_BYTE,texRec[i]->data); //<9>
    }
} else return FALSE;

for(int i=0; i<3; i++) { //<10>
    if(texRec[i]) {
        if(texRec[i]->data) free(texRec[i]->data);
        free(texRec[i]);
    } else return FALSE;
}

glEnable(GL_TEXTURE_2D); //<11>
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); //<12>

자, 하나 하나 살펴 보도록하자.

<1> 코드는 우리가 3개의 텍스쳐 맵핑 소스를 만들어야 하기 때문에 3개의 Cell을 갖는 배열을 선언한 것이다. AUX_RGBImageRec 구조체 타입은 이미 앞에서 살펴보았는데 바로 그림 파일에서 맵핑 소스를 얻기 위해 사용할 함수의 반환값을 저장할 목적으로 쓰인다.

<2> 코드는 메모리 상의 변수를 0으로 만드는 코드인데 굳이 필요치 않는 코드이나 깔끔을 떠는 프로그래머들이 즐겨 사용하는 스타일로 어떤 변수를 사용하기에 앞서 0으로 초기화를 시켜본 경험이 있는 독자도 있을 것이다. 바로 그것이다.

<3> 코드는 IF 문인데 앞에서 살펴본 그림파일에서 텍스쳐 맵핑 소스를 생성하는 함수를 사용해서 각각의 3가지 그림 파일을 실제 읽어 들이는 루틴이다. 오류(파일이 없다)가 발생하지 않는 다면 실행점이 IF문의 TRUE 블럭으로 진입한다.

<4> 코드에서 새로운 함수가 등장했다. 앞으로 OpenGL의 새로운 함수가 많이 등장할 것이다. glGenTextures 함수는 2개의 인자를 갖는데 첫째는 우리가 몇개의 텍스쳐 맵핑 소스를 생성할 것인지를 지정하는 것이고 두번째는 그중 가장 첫번째 텍스쳐 맵핑 소스의 식별자의 주소값이다. 여기서 텍스쳐 맵핑 소스의 식별자라 함은 일단 텍스쳐 맵핑 소스가 생성되었으면 나중에 사용하기 위해서 그 맵핑 소스에 이름을 붙이게 되는데 그 이름으로써 정수값을 사용하며 그 정수값을 식별자라 부른다. 그런데 뜸금없이 tex라는 변수가 튀어 나왔는데 이 변수는 전역 변수 선언부에 다음과 같이 얌전하게 선언되어 있다.

GLuint tex[3];

3개의 텍스쳐를 사용할 것이므로 역시 3개의 Cell을 갖는 배열을 선언하였다.

<5>번 코드는 FOR 문인데 3번 반복하게 되어 있는데 한번의 반복당 하나의 텍스쳐 맵핑 소스에 대한 특성을 지정하게 된다.

<6>코드에 나오는 함수인 glBindTexture는 앞으로 설정할 텍스쳐의 식별자를 지정하는 것으로 첫번째 인자는 텍스쳐가 1차원(GL_TEXTURE_1D)인지, 2차원(GL_TEXTURE_2D)인지를 지정한다. 두번째 인자는 다음에 설정할 텍스쳐 맵핑의 식별자가 온다. 이 함수 이후로 이루어지는 텍스쳐 맵핑의 특성에 대한 설정은 모두 앞서 지정된 식별자에 해당하는 텍스쳐 맵핑에 대한 것이다.

<7>, <8>번 코드를 설명하기 전에 먼저 알아야 할 것이 있다. 실제 텍스쳐 맵핑의 크기와 맵핑되어질 물체의 크기가 똑같다면 간단하게 맵핑을 시키면 되겠으니 작거나 크다면 어떤 식으로 텍스쳐 맵핑 소스를 물체의 크기에 맞게 줄이거나 키울 것인가? 바로 그 어떻게 줄이거나 키울 것에 대한 방법으로 대표적으로 2가지가 있는데 하나는 보간법(GL_LINEAR)과 최근점법(GL_NEAREST)가 있다. 이해가 되었다면 glTexParameteri에 대해서 살펴보자. 세개의 인자를 취하는데 첫번째는 1차원인지, 2차원인지를 지정하는 것이고 두번째 인자는 만약 텍스쳐 맵핑 소스가 맵핑되어질 물체보다 클 경우에 어떤 식으로 축소시켜야 하는지를 지정하는 GL_TEXTURE_MIN_FILTER와 텍스쳐 맵핑 소스가 맵핑되어질 물체보다 작을 경우 어떤 식으로 확대시켜야 하는지를 지정하는 GL_TEXTURE_MAG_FILTER가 온다. 세번째 인자는 실제 그 축소, 확대시키는 방법을 기술하는데 대표적으로 GL_LINEAR와 GL_NEAREST가 온다. GL_LENEAR이 GL_NEAREST보다 나은 장면을 얻을 수 있으나 속도가 느리다. 위의 코드에서는 나은 장면을 얻기위해 모든 텍스쳐 맵핑 소스에 대해서 보간법을 사용하였다.


<9>번 코드는 꽤 많은 인자를 요구하는 glTexImage2D라고 하는 놈이다. 모두 9개의 인자를 갖는다. 첫번째는 텍스쳐 이미지가 1차원인지 2차원인지를 지정하는 것이고 두번째 인자는 항상 0으로 지정하게 된다. 사실 이 인자는 Detail Level을 나타내는 놈으로 보다 나은 Midmap 텍스쳐 맵핑을 구현할때 사용하는 것이다. 이장에서는 사용법에 대해 언급하지 않겠지만 간략하게 소개하자면 앞에서 우리는 텍스쳐 맵핑 소스가 물체보다 크거나 작을때 맵핑 소스를 줄이거나 키운다고 했다. 하지만 Midmap 텍스쳐 맵핑은 처음부터 미리 큰 맵핑 소스와 그리고 중간 맵핑 소스, 작은 맵핑 소스등 많은 맵핑 소스를 준비해서 보다 나은 장면을 얻을 수 있는데 이런 Midmap 맵핑 소스 이미지들은 프로그래머가 처음부터 그림 파일로 만들어 놓고 지정하는 경우와 컴퓨터가 자동으로 생성하는 경우가 있다. 이제 계속 인자에 대해 알아보자. 세번째 인자는 생상 구성 요소의 갯수인데 BMP 파일은 RGB의 세가지 색상요소가 있으므로 3이 온다. 네번재와 다섯번째는 이미지의 가로 길이와 세로 길이를 나타내게 되고 여섯번째는 이미지의 경계에 대한 픽셀두깨를 지정하게 된다. 이 예제에서 사용하는 그림들은 모두 불필요한 경계가 없으므로 0이 된다. 일곱번째는 텍스쳐 맵핑 소스의 구성 요소를 분명하게 지정하는 것으로 GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_RGB 등 여러 값이 올수있으나 여기서는 GL_RGB로 이미 우리는 그림파일에서 텍스쳐 맵핑을 준비하는 것이고 그 그림파일은 RGB값을 갖는 구조이기 때문이다. 여덜번째는 색상 구성 요소들이 갖는 값의 타입을 나타내는데 모든 BMP파일에 있어서 RGB의 세가지 구성요소들은 부호 없는 Byte형이므로 GL_UNSIGNED_BYTE가 온다. 마지막으로 아홉번째는 텍스쳐 맵핑 소스의 실제 데이타값(그림 데이타)에 대한 포인터가 온다.

여기까지가 텍스쳐 맵핑 소스를 생성하고 그 맵핑 소스에 대한 특성을 설정하는 것들이다. 이후로 이제 불필요한 할당된 메모리를 해제하고 텍스쳐 맵핑을 사용한다고 지정하는 것들이 남았다.

<10>번 코드가 바로 이제는 더이상 필요치 않는 할당된 메모리를 해제하는 코드이다.

<11>은 2차원 텍스쳐 맵핑을 사용하겠노라고 OpenGL에게 알린다.

<12>에 나오는 함수인 glTexEnvi는 세개의 인자를 갖는데 중요한 것은 세번째 인자로써 올수있는 값은 GL_MODULATE와 GL_BLEND와 GL_DECAL이 올수있다. GL_MODULATE는 화면상의 픽셀 색과 텍스춰의 픽셀 색을 서로 곱하게 된다. <12>번 코드를 생략하면 자동으로 GL_MODULATE로 지정된다. GL_DECAL은 화면상의 픽셀 색을 텍스춰의 픽셀 색으로 대체한다. 이 경우 빛에 대해서 전혀 텍스쳐가 영향을 받지 않는다. GL_BLEND는 화면상의 픽셀 색을 텍스쳐의 픽색 색과 섞고 특정한 색과 결합시키게 된다.

자!! 이렇게 해서 텍스쳐 맵핑 소스를 만드는 것에 대한 것들을 알아 보았다. 그렇다면 이 코드들은 어디에 위치해야 하는가? 간단하게 OpenGL을 초기화는 곳에 위치하도록 하자. 즉 void InitGL(GLvoid) 함수에 위치 시키자.

이제 우리는 이 텍스쳐 맵핑 소스를 물체에 적용하는 방법에 대해 알아볼 차례이다. 적용은 실제 물체를 그리는 코드에서 이루어진다. 다음의 DrawGLScene 함수를들어다 보자.

int DrawGLScene(GLvoid)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
   
    glTranslatef(0.0f, 0.0f, -7.0f);
   
    glColor3f(0.8f, 0.8f, 0.8f);
   
    glRotatef(rot, 1.0f, 1.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, tex[0]); //<1>
    glBegin(GL_QUADS);
    glNormal3f(0.0f, 0.0f, 1.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, -1.0f, 1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 1.0f); 
    glEnd();
   
    glBindTexture(GL_TEXTURE_2D, tex[1]); //<1>
    glBegin(GL_QUADS);
    glNormal3f(1.0f, 0.0f, 0.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, 1.0f, 1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, -1.0f, 1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, -1.0f, -1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, -1.0f);
    glEnd();
   
            .
            .
            .
   
    glBindTexture(GL_TEXTURE_2D, tex[0]); //<1>
    glBegin(GL_QUADS);
    glNormal3f(0.0f, 1.0f, 0.0f);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, -1.0f);
    glEnd();
   
    rot+=1.0f;
    if(rot>359.0f) rot=0.0f;
   
    return TRUE;
}

5장에서의 정육면체를 그릴때의 방법을 약간 변형했는데 5장에서는 한번의 glBegin과 glEnd를 사용하여 모든 면을 그려주었다. 하지만 이 장에서는 각각의 면에 대해서 glBegin와 glEnd를 사용하여 그려주었다. 그 이유는 각 면에 대해서 서로 다른 텍스쳐 맵핑을 시켜야 하기 때문이다. 살펴 볼것은 면에 대해서 어떤 텍스쳐 맵핑을 사용할 것인지는 앞서 언급한 텍스쳐 맵핑 식별자를 사용하는데 <1>번 코드가 바로 그것이다. 그리고 실제 텍스쳐 맵핑을 지정하는 것에 대한 것인데 위의 코드를 주의 깊게 살펴보면 면에 대한 각 점들을 지정해 줄때 glTexCoord2f라는 함수를 통해서 텍스쳐 맵핑 좌표를 같이 지정해 주었다는 점이다. 이것은 무엇을 의미하는가? 텍스쳐 맵핑의 소스는 크기에 상관없는 S-T 자표계를 사용하는데 S-T좌표계라는 시작점은 0으로 하고 끝점은 1로 한다는 점이다. 아래의 그림과 같이 말이다.

사용자 삽입 이미지

즉 glTexCoord2f를 이용하여 glVertex3f로 지정한 점에 대해 텍스쳐 맵핑 좌표를 설정해 줄때 glVertex3f로 지정한 위치에 대해 glTexCoord2f 좌표가 서로 일치시켜 그림을 맵핑하게 되는 것이다.

각각의 면들에 대해서 동일한 방법으로 텍스쳐 맵핑 좌표를 설정하였다.

이로써 텍스쳐 맵핑에 대한 것들을 마칠까 한다.