SDL - Wstęp do grafiki 3D

Oś OX jest pozioma i biegnie w prawo.

Oś OY jest pionowa i biegnie do góry.

Oś OZ jest prostopadła do płaszczyzny osi OX i OY, biegnie w kierunku obserwatora.

Na osiach ustalmy miary, które nazwiemy współrzędnymi odpowiednio x, y i z. Początek układu współrzędnych znajduje się w punkcie o mierze 0 każdej z osi. Oznaczamy go za pomocą trójki liczb (0,0,0).

Umieśćmy w przestrzeni dowolny punkt P.

Dokonajmy teraz rzutów prostokątnych punktu P na płaszczyzny zawierające osie OX-OY (Π_xy), OX-OZ (Π_xz) i OY-OZ (Π_yz):

Współrzędne tych rzutów odpowiadają współrzędnym x,y,z punktu w przestrzeni trójwymiarowej. Zatem każdy punkt będziemy określać trójką liczb x,y,z. W pamięci komputera będzie to struktura zawierająca 3 liczby zmiennoprzecinkowe:

Współrzędne x, y, z tych wierzchołków są następujące:

Wierzchołki możemy umieścić w tablicy V, której elementami są struktury typu vertex3D. W języku C++ robimy to następująco:

// Definicja wierzchołków figury

const int VN = 8;  // Liczba wierzchołków

vertex3D V[] = {{-100, 100, 100},{ 100, 100, 100},{ 100,-100, 100},{-100,-100, 100},
                {-100, 100,-100},{ 100, 100,-100},{ 100,-100,-100},{-100,-100,-100}};

Krawędź jest linią, którą będziemy rysowali od wierzchołka początkowego v₁ do końcowego v₂. Jeśli znamy numery tych wierzchołków, to linię definiujemy następująco:

struct line3D
{
  int v1,v2;
};

Ponumerujmy kolejne krawędzie naszego sześcianu:

W poniższej tabelce mamy definicje poszczególnych krawędzi sześcianu. Definicja określa kolejno numer wierzchołka startowego i numer wierzchołka końcowego krawędzi:

Podobnie jak wierzchołki, krawędzie również umieszczamy w tablicy, której elementami są struktury typu line3D:

// Definicja krawędzi figury

const int LN = 12;  // Liczba krawędzi

line3D L[] = {{0,1},{1,2},{2,3},{3,0},{4,5},{5,6},{6,7},{7,4},{0,4},{1,5},{2,6},{3,7}};

Obiekt jest zdefiniowany.

• tablica współrzędnych wierzchołków V
• tablica krawędzi L

Ustalmy położenie powierzchni graficznej SDL_Surface na płaszczyźnie Π_xy - zawierającej osie OX i OY. Od razu umówmy się, że powierzchnia ta zostanie ułożona, tak aby środek układu współrzędnych pokrywał się ze środkiem powierzchni:

Jeśli przyjrzysz się dokładnie powyższemu rysunkowi, to stwierdzisz, że układ współrzędnych powierzchni SDL_Surface nie zgadza się z układem współrzędnych przestrzennych:

1. Powierzchnia SDL_Surface zbudowana jest z punktów obrazowych, czyli pikseli, które posiadają współrzędne całkowite. Współrzędne przestrzenne są współrzędnymi rzeczywistymi. Zatem położenie punktu obrazu 3D będzie musiało być zaokrąglane do położenia najbliższego piksela.
2. Początek układu współrzędnych powierzchni SDL_Surface znajduje się w lewym górnym narożniku. Początek układu współrzędnych 3D jest na środku tej powierzchni.
3. Oś y układu współrzędnych powierzchni SDL_Surface skierowana jest w dół, a w układzie przestrzennym do góry.

Wynika stąd konieczność przeliczenia współrzędnych przestrzennych na współrzędne powierzchni graficznej - nazwijmy je współrzędnymi ekranowymi. Jeśli tego nie zrobimy, otrzymamy obraz przesunięty i do góry nogami. Na szczęście transformacja jest bardzo prosta.

Niech x i y oznaczają współrzędne punktu leżącego na powierzchni SDL w układzie 3D, a x_e i y_e współrzędne tego samego punktu w układzie SDL:

 

 

x_e = w/2 + x

y_e = h/2 - y

w - szerokość powierzchni SDL_Surface
h - wysokość powierzchni SDL_Surface

 

Teraz wyznaczymy obraz punktu P na płaszczyźnie SDL (pod uwagę będziemy brali tylko punkty, których współrzędna z jest nieujemna), najpierw we współrzędnych 3D, a później we współrzędnych samej płaszczyzny SDL_Surface. Istnieje kilka sposobów wyznaczania takiego obrazu - my zajmiemy się tzw. rzutem perspektywicznym. Zasada jest następująca:

Na ujemnej połówce osi OZ określamy punkt obserwatora. Punkt ten jest w odległości d od początku układu współrzędnych 3D. Z punktu obserwatora prowadzimy prostą do punktu P, którego obraz chcemy znaleźć na powierzchni SDL_Surface. Prosta ta przecina powierzchnię SDL_Surface w punkcie P'. Punkt ten jest obrazem punktu P w rzucie perspektywicznym.

 

 

 

W celu wyznaczenia współrzędnych x i y punktu P rozważmy dwa rzuty prostokątne tej sytuacji:

na płaszczyznę Πxz

na płaszczyznę Πyz

W obu tych przypadkach sytuacja jest podobna i możemy utworzyć proste proporcje (z twierdzenia Talesa lub z podobieństwa trójkątów prostokątnych):

A stąd już prosto:

Otrzymane współrzędne przestrzenne przeliczamy na współrzędne ekranowe:

Współrzędne x_e i y_e są liczbami całkowitymi. Określone są dla x' > -d i y' > -d.

Ponieważ obserwator jest w punkcie d poza płaszczyzną graficzną SDL, to z tego punktu widzenia oś OZ biegnie w drugą stronę, czyli w głąb ekranu:

Wynika z tego, iż do definicji obiektów możemy przyjąć układ przestrzeni 3D lub układ obserwatora, który różni się zwrotem osi OZ. Wzory w obu przypadkach pozostają identyczne.

struct vertex2D
{
  Sint32 x,y;
};

Poniższy program animuje nasz sześcian, przesuwając go w przestrzeni do różnych punktów, ale tak dobranych, aby wszystkie punkty wierzchołkowe dało się zobrazować na powierzchni graficznej (z będzie zawsze nieujemne).

Program wykorzystuje bibliotekę newgfx.

// Obiekty szkieletowe 3D
// (C)2012 Koło Informatyczne
// I LO w Tarnowie
//-------------------------------

#include "newgfx.h"
#include <cmath>
#include <list>

const double PI=3.1415926535897;

// Definicja typów danych

struct vertex3D
{
    double x,y,z;
};

struct vertex2D
{
    Sint32 x,y;
};

struct line3D
{
    int v1,v2;
};

// Definicja wierzchołków figury

const int VN = 8;  // Liczba wierzchołków

vertex3D V[] = {{-100, 100, 100},{ 100, 100, 100},{ 100,-100, 100},{-100,-100, 100},
                {-100, 100,-100},{ 100, 100,-100},{ 100,-100,-100},{-100,-100,-100}};

// Definicja krawędzi figury

const int LN = 12;  // Liczba krawędzi

line3D L[] = {{0,1},{1,2},{2,3},{3,0},{4,5},{5,6},{6,7},{7,4},{0,4},{1,5},{2,6},{3,7}};

// Tablica współrzędnych ekranowych wierzchołków

vertex2D VE[VN];

int main(int argc, char *argv[])
{
    int waiting = 1;

    SDL_Surface * screen;

    SDL_Event event;

    double kx = PI, ky = 0, kz = 0;       // Kąty pozycji na elipsie

    double sx = 0, sy = 100, sz = 1000;   // Współrzędne środka elipsy

    double rx = 700, ry = 600, rz = 900;  // Promienie elipsy

    double tx,ty,tz;  // Wektor przesunięcia

    double d = 1000;  // Punkt obserwatora

    double m;         // Mnożnik

    SDL_Rect r;       // Prostokąt wymazywania

    if(!SDL_Init(SDL_INIT_VIDEO))
    {
        atexit(SDL_Quit);

        screen = SDL_SetVideoMode(1280, 1024, 32, SDL_HWSURFACE | SDL_FULLSCREEN);

        // Ustawiamy prostokąt wymazywania

        r.x = r.y = 0;
        r.w = screen->w;
        r.h = screen->h;

        do
        {
            // Obliczamy wektor przesunięcia

            tx = sx + rx * cos(kx);
            ty = sy + ry * sin(ky);
            tz = sz + rz * cos(kz);

            // modyfikujemy kąty

            kx += 0.005;   if(kx > PI+PI) kx = 0;
            ky += 0.0075;  if(ky > PI+PI) ky = 0;
            kz += 0.0125;  if(kz > PI+PI) kz = 0;

            // Obliczamy współrzędne ekranowe

            for(int i = 0; i < VN; i++)
            {
                m = d / (V[i].z + tz + d);  // obliczamy mnożnik

                VE[i].x = (screen->w >> 1) + m * (V[i].x + tx);
                VE[i].y = (screen->h >> 1) - m * (V[i].y + ty);
            }

            if(SDL_MUSTLOCK(screen)) SDL_LockSurface(screen);

            // Rysujemy szkielet figury w kolorze białym

            for(int i = 0; i < LN; i++)
            {
                gfxClipWuLine(screen,VE[L[i].v1].x,VE[L[i].v1].y,VE[L[i].v2].x,VE[L[i].v2].y,0xffffff);
                gfxClipWuLine(screen,VE[L[i].v1].x+1,VE[L[i].v1].y,VE[L[i].v2].x+1,VE[L[i].v2].y,0xffffff);
                gfxClipWuLine(screen,VE[L[i].v1].x,VE[L[i].v1].y+1,VE[L[i].v2].x,VE[L[i].v2].y+1,0xffffff);
                gfxClipWuLine(screen,VE[L[i].v1].x+1,VE[L[i].v1].y+1,VE[L[i].v2].x+1,VE[L[i].v2].y+1,0xffffff);
            }

            if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);

            SDL_UpdateRect(screen, 0, 0, 0, 0); // Uaktualniamy ekran

            if(SDL_MUSTLOCK(screen)) SDL_LockSurface(screen);

            SDL_FillRect(screen, &r, 0);  // Wymazujemy szkielet figury

            if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);

            // Czekamy na klawisz ESCAPE

            if (SDL_PollEvent(&event))
                if ((event.type == SDL_QUIT) ||
                   ((event.type == SDL_KEYDOWN) &&
                    (event.key.keysym.sym == SDLK_ESCAPE))) waiting = 0;
        } while(waiting);
    }

    return 0;
}