1. KRAKOWSKA AKADEMIA
im. Andrzeja Frycza Modrzewskiego
Wydział Ekonomii i Zarządzania
Kierunek: Informatyka i ekonometria
Specjalność: Informatyka Zarządcza
Jerzy Paszcz
PODSTAWOWE ALGORYTMY WYKORZYSTYWANE W GRAFICE 3D CZASU
RZECZYWISTEGO
Praca dyplomowa licencjacka
napisana pod kierunkiem
Prof. dr hab. Tadeusza Grabińskiego
1

2. Spis treści
Wstęp.....................................................................................................................................................4
TEORETYCZNE PODSTAWY GRAFIKI 3D CZASU RZECZYWISTEGO....................................5
1.1WPROWADZENIE DO GRAFIKI 3D CZASU RZECZYWISTEGO.......................................5
1.1.1 Generowanie grafiki 3d czasu rzeczywistego.......................................................................5
1.1.2 Matematyczne podstawy grafiki trójwymiarowej................................................................5
1.1.3 Zdefiniowanie informacji o obiektach sceny -modele 3d.....................................................5
1.1.4 Potok renderowania..............................................................................................................6
1.1.5 Potok geometrii.....................................................................................................................6
1.1.6 Oświetlenie...........................................................................................................................7
1.1.7 Wykreślanie wielokątów (Renderowanie)............................................................................7
1.2 MATEMATYCZNE PODSTAWY GRAFIKI TRÓJWYMIAROWEJ.....................................7
1.2.1 Kartezjański układ współrzędnych.......................................................................................7
1.2.2 Funkcje trygonometryczne...................................................................................................8
1.2.3 Wektory..............................................................................................................................10
1.2.4 Działania na wektorach.......................................................................................................11
1.2.5 Podstawowe przekształcenia geometryczne.......................................................................13
1.2.6 Macierze.............................................................................................................................14
1.2.7 Przekształcenia geometryczne przy użyciu macierzy.........................................................15
1.3 STRUKTURY DANYCH OPISUJĄCE TRÓJWYMIAROWE MODELE.............................16
1.3.1 Podział struktur danych......................................................................................................16
1.3.2 Model 3d.............................................................................................................................16
1.3.3 Lista renderowania..............................................................................................................18
1.4 POTOK GEOMETRII...............................................................................................................18
1.4.1 Potok geometrii...................................................................................................................18
1.4.2 Lokalny układ współrzędnych modelu 3d..........................................................................19
1.4.3 Transformacja obiektu do współrzędnych globalnych sceny.............................................20
1.4.4 Kamera................................................................................................................................20
1.4.5 Przekształcenie obiektów sceny do współrzędnych kamery..............................................21
1.4.6 Usunięcie obiektów poza kamerą.......................................................................................21
1.4.7 Usunięcie ścian zwróconych tyłem....................................................................................22
1.4.8 Układ współrzędnych płaszczyzny rzutowania..................................................................22
1.4.9 Przekształcenie współrzędnych widoku na współrzędne ekranu.......................................23
1.4.10 Przycinanie.......................................................................................................................24
1.5 OŚWIETLENIE.........................................................................................................................25
1.5.1 Światło w świecie rzeczywistym........................................................................................25
1.5.2 Charakterystyka światła ze względu na sposób odbicia.....................................................25
1.5.3 Charakterystyka światła ze względu na rodzaj źródła........................................................26
1.5.4 Cieniowanie........................................................................................................................28
1.5.5 Ustalanie barw....................................................................................................................29
1.5.6 Globalny model oświetlenia...............................................................................................30
1.6 RENDEROWANIE...................................................................................................................31
1.6.1 Renderowanie.....................................................................................................................31
1.6.2 Rasteryzacja trójkątów........................................................................................................31
1.6.5 Przycinanie w przestrzeni ekranu.......................................................................................33
1.6.5 Algorytm cieniowania Gourand.........................................................................................34
2

3. 1.6.6 Teksturowanie.....................................................................................................................36
1.6.7 Algorytm Bufor Z..............................................................................................................39
IMPLEMENTACJA ALGORYTMÓW GRAFIKI 3D CZASU RZECZYWISTEGO......................42
2.1 APLIKACJA KREŚLĄCA GRAFIKĘ 3D W CZASIE RZECZYWISTYM...........................42
2.1.1 Charakterystyka aplikacji...................................................................................................42
2.1.2 Budowa aplikacji................................................................................................................43
2.2 PROGRAMOWANIE W WINDOWS Z UŻYCIEM BIBLIOTEKI DIRECT X....................44
2.2.1 System Windows................................................................................................................44
2.2.2 Programowanie w modelu Win32......................................................................................44
2.2.3 Biblioteka Direct X.............................................................................................................45
2.2.4 Programowanie przy wykorzystaniu Direct X...................................................................45
2.3 Spis funkcji................................................................................................................................47
2.3.1 Szkielet aplikacji.................................................................................................................47
2.3.2 Użycie Direct X do obsługi ekranu i klawiatury................................................................47
2.3.3 Funkcje matematyczne.......................................................................................................48
2.3.4 Zdefiniowanie modeli.........................................................................................................50
2.3.5 Potok geometrii ..................................................................................................................51
2.3.6 Oświetlenie.........................................................................................................................52
2.3.7 Renderowanie.....................................................................................................................52
Spis ilustracji.......................................................................................................................................54
Bibliografia..........................................................................................................................................55
3

4. Wstęp
Grafika komputerowa 3d jest ta forma przekazu treści wizualnych, która umożliwia
połączenie sposobu, w jaki postrzegamy rzeczywistość z możliwością dowolnego jej formowania i
przetwarzania. Dlatego znalazła zastosowanie wszędzie tam, gdzie ludzka pomysłowość,
kreatywność i wyobraźnia styka się z rzeczywistością. Znalazła zastosowanie w takich branżach i
dziedzinach jak przemysł filmowy, media i reklama, systemy wspomagające projektowanie,
przemysł gier komputerowych, rożnego rodzaju symulatory, medycyna. Jednym z miejsc, w których
grafika 3d jest bardzo mocno związana to branża gier komputerowych. To właśnie rozwiązania
pochodzące z branży gier video stały się inspiracja do napisania niniejszej pracy.
Praca ta przedstawia podstawowe algorytmy i definicje struktur danych składające się na kompletny
programowy potok renderowania wielokątów w czasie rzeczywistym.
Uniwersalny charakter prezentowanych schematów sprawia ze stanowią doskonały wstęp do świata
bardziej zaawansowanych rozwiązań wykorzystywanych w nowoczesnym oprogramowaniu
związanym z grafika 3d .
W pracy przedstawiłem następujące algorytmy i schematy:
• Sposób definicja struktur opisujących modele 3d przy pomocy wielokątów
• Przekształcenie struktur 3d do ich reprezentacji na ekranie poprzez rzutowanie prostokątne w
procesie zwanym potokiem geometrii.
• Imitacja oświetlenia
• Wykreślanie rzutowanych wielokątów zwane procesem renderowania.
• Zastosowałem takie algorytmy jak cieniowanie płaskie i Gourand, teksturowanie liniowe,
bufor Z
Przedstawione działania są następnie implementowane w postaci interaktywnej aplikacji kreślącej
grafikę 3d w czasie rzeczywistym.
Aplikacja działa w środowisku Windows i posługuje się bibliotekom Direct X do przyspieszenia
obsługi ekranu i klawiatury. W ramach części poświeconej implementacji teoretycznych podstaw
zaprezentowałem ogólny schemat potoku renderowania, programowania w środowisku Windows
przy użyciu C i omówiłem bibliotekę Direct X oraz przedstawiłem ogólną budowę aplikacji.
4

5. Rozdział 1
TEORETYCZNE PODSTAWY GRAFIKI 3D CZASU RZECZYWISTEGO
1.1 WPROWADZENIE DO GRAFIKI 3D CZASU RZECZYWISTEGO
1.1.1 Generowanie grafiki 3d czasu rzeczywistego
Grafika 3d czasu rzeczywistego, to dziedzina grafiki komputerowej, której najważniejszą
cechą, jest zdolność połączenia swobodnego definiowania widoku oraz interakcji z elementami
sceny, z płynnym wyświetlaniem obrazu. Efektem działania tego typu rozwiązań, powinno być
wywołanie u użytkownika, wrażenia realności w poruszaniu się i współdziałaniu ze sztucznie
wykreowaną sceną. Oko ludzkie daje się łatwo oszukać i zapewnienie wykreślania pewnej
określonej liczby klatek na sekundę (ang. fps -frame per second), powoduje u widza złudzenie
płynności ruchu.
Powyższe kryteria powodują, że najważniejszym zagadnieniem związanym z wyświetlaniem grafiki
czasu rzeczywistego, jest wydajność zastosowanych metod i algorytmów w przeprowadzaniu
obliczeń.
W niniejszej pracy zawarto opis schematu wyświetlania grafiki 3d w oparciu o tzw. kreślenie
wielokątów. Metoda ta polega na rzutowaniu perspektywicznym obiektów opisanych przy pomocy
siatek wielokątów i jest bardzo wydajna, gdyż obliczenia sprowadzają się głównie do przekształceń
punktów definiujących te figury tzn. wierzchołków. Dzięki swojej prostocie i szybkości działania,
algorytmy oparte o wielokąty, są najpopularniejszymi rozwiązaniami wykorzystywanymi do
kreślenia grafiki 3d czasu rzeczywistego.
W rozdziale tym zaprezentowano wszystkie niezbędne działania i elementy potrzebne do
wyświetlenia trójwymiarowej sceny na ekranie komputera.
1.1.2 Matematyczne podstawy grafiki trójwymiarowej
Proces generowania grafiki 3d opiera się na matematycznym opisie przekształceń figur
geometrycznych w przestrzeni i na płaszczyźnie. Podstawowe operacje związane z przemieszeniem,
wzajemnym położeniem i rzutowaniem punktów i prostych definiujących przestrzenne figury,
zostały opisane przy pomocy wektorów i macierzy.
1.1.3 Zdefiniowanie informacji o obiektach sceny -modele 3d
Jednym z najważniejszych pojęć grafiki komputerowej 3d jest pojecie tzw. modelu 3d.
Model 3d to zbiór danych, którego zadaniem jest imitowanie i odtwarzanie wyglądu obiektów ze
świata rzeczywistego w wirtualnej scenie. W przypadku algorytmów opartych o wielokąty, model
3d jest definiowany przy pomocy tzw. siatki
wielokątów, będącej zbiorem danych opisujących położenie wierzchołków i opartych o nie
wielokątów. Dodatkowe informacje, które modele mogą zawierać, to sposoby przetwarzania
5

6. powierzchni w postaci definicji materiałów, przypisanych bitmapach tzw. teksturach, sposobie
zachowania jak np. ruch w scenie (animacje) itp.
1.1.4 Potok renderowania
Jak wspomniałem, wyświetlanie grafiki 3d czasu rzeczywistego, polega na ciągłym
kreśleniu nakładających się na siebie obrazów. Główny zespól metod, odpowiedzialnych za
przetwarzanie obrazu, nosi nazwę potoku renderowania. Jego wynikiem jest pojedyncza klatka
(kadr) obrazu i jest on wykonywany bez przerwy, w odstępach odpowiadających wymaganej ilości
klatek na sekundę.
Potok renderowania składa się z szeregu działań. To właśnie te działania stanowią istotę
tej pracy, i ich przebieg, i nazewnictwo, choć może się różnic w szczegółach, jest uniwersalne dla
stosowanych obecnie rozwiązań związanych z grafika 3d czasu rzeczywistego.
W tej pracy przyjąłem podział potoku renderowania na trzy podstawowe działy:
 potok geometrii, będący szeregiem działań wykonywanych na modelach 3d, a mający na
celu przekształcenie trójwymiarowych definicji wielokątów tworzących obiekty w scenie, na
ich dwuwymiarowa reprezentację na płaszczyźnie ekranu, gotową do poddania procesowi
wykreślania.
 oświetlenie, mające na celu symulację oddziaływania światła, na zdefiniowane przez
przekształcane wielokąty powierzchnie.
 wykreślanie przetworzonych wielokątów na ekranie, zwane procesem renderowania
1.1.5 Potok geometrii
Potok geometrii to ważna cześć całego procesu kreślenia. Jego wynikiem jest rzutowanie
informacji o rozmieszczeniu punktów definiujących modele 3d na płaszczyznę widoku i dalej na
płaszczyznę ekranu. Na potok geometrii składają się przekształcenia pomiędzy kolejnymi układami
współrzędnych, do których odnosimy siatki wielokątów budujące modele. Są to:
 lokalny układ współrzędnych, będący podstawą początkowej definicji modelu 3d
 globalny układ współrzędnych, wspólny dla wszystkich elementów sceny
 układ współrzędny kamery, według którego definiujemy widok
 układ współrzędnych perspektywy to układ płaszczyzny widoku, na który rzutujemy
wszystkie punkty definiujące obiekty wirtualnego świata
 układ współrzędnych ekranu to ostateczny sposób definicji, w którym wierzchołki
składające się na wielokąty definiujące obiekty sceny, przyjmują położenie gotowe do
poddania procesowi wykreślania (rasteryzacji)
6

7. Do potoku geometrii zalicza się również wszelkie zabiegi optymalizujące ilość koniecznych
działań, a polegające na unikaniu nadmiaru informacji o geometrii, poprzez usuwanie z potoku
przekształceń wielokątów znajdujących się poza widokiem kamery.
1.1.6 Oświetlenie
Informacje o oświetleniu, pozwala symulować sposób, w jaki w rzeczywistym świecie,
światło generuje obraz, który jest odbierany przez widza. Dzięki temu scena nabiera kolorów, a
sposób wyświetlania obiektów, zależy od rodzaju i natężenia światła jakie im przypada, nadając
scenie złudzenie realizmu. Informacje te są następnie wykorzystane w ostatecznym procesie
wykreślania wielokątów na ekranie.
1.1.7 Wykreślanie wielokątów (Renderowanie)
Renderowanie, to ostateczny proces kreślenia obrazu, który integruje w sobie informacje
pochodzące z rożnych algorytmów, mających wpływ na końcowy sposób, w jaki wyświetlane są
wielokąty. Renderowanie zawiera więc w sobie takie procesy jak:
 rasteryzacja - podstawowy algorytm kreślenia figur geometrycznych na ekranie
 cieniowanie - to proces obliczania koloru kreślonych powierzchni na podstawie przyjętych
algorytmów oraz informacji o zastosowanych materiałach i wpływie procesu oświetlenia
 teksturowanie - imitowanie bardziej skomplikowanych materiałów poprzez użycie bitmap
 algorytmy określania widoczności kreślonych wielokątów(przysłaniania) – W pracy
wykorzystano tzw. bufor Z, algorytm określania widoczności wielokątów na podstawie
głębokości pikseli wyświetlanego i rzutowanego trójkąta na ekranie, dzięki czemu można
zachować właściwą kolejność przesłaniania trójkątów w procesie renderowania sceny.
1.2 MATEMATYCZNE PODSTAWY GRAFIKI TRÓJWYMIAROWEJ
1.2.1 Kartezjański układ współrzędnych
W grafice komputerowej 3d, podstawowe dane które przetwarzamy, związane są z
położeniem obiektów w przestrzeni. Do opisania położenia punktów w przestrzeni posługujemy się
tzw. kartezjańskim układem współrzędnych.
Kartezjański układ współrzędnych, to układ współrzędnych, w którym do opisu położenia punktu w
przestrzeni, używamy jego rzutu prostokątnego na wzajemnie prostopadle proste, zwane osiami,
przechodzące przez wspólny punkt, zwany początkiem układu współrzędnych. Inna nazwa to układ
współrzędnych prostokątnych.
W przestrzeni trójwymiarowej, współrzędne punktu, definiujemy przy pomocy trzech zmiennych,
odpowiadających jego położeniu, określonemu według osi oznaczonych literami x, y, z.
7

8. Początek układu współrzędnych to punkt, którego współrzędne przyjmują wartości (0,0,0).
Rysunek 1.Kartezjański układ współrzędnych.
Kartezjański układ współrzędnych dzieli się na lewo i prawostronny, zależnie od wzajemnego
skierowania osi x i z. Układ lewostronny wyznacza się przy pomocy lewej dłoni, w której palce
wskazują dodatni zwrot osi x, a wnętrze dłoni dodatnią os y. Kciuk wskazuje dodatni zwrot osi z.
Analogicznie wyznacza się prawostronny układ przy pomocy prawej dłoni. Aplikacja, będąca
implementacją omawianych zagadnień i przedstawiona w rozdziale drugim, posługuje się
lewostronnym układem współrzędnych kartezjańskich.
1.2.2 Funkcje trygonometryczne
Funkcje trygonometryczne, to funkcje związane z miarą wzajemnych stosunków pomiędzy
bokami i kątami trójkąta. Podstawowe definicje są oparte o trójkąt prostokątny. Funkcje
trygonometryczne mają fundamentalne znaczenie w geometrii, a co z tym związane, stanowią
również podstawę większości algorytmów grafiki 3d.
Trójkąt prostokątny to trójkąt, który posiada trzy kąty wewnętrzne, z których jeden posiada wartość
90º. W trójkącie tym, obieramy jeden z kątów ostrych (kąt bazowy) i według niego, definiujemy
nazwy boków trójkąta. Bok przylegający do kąta bazowego, to przyprostokątna przylegająca, bok
8
x+
y+
z+
p (x, y, z)
0

9. .
α
przyprostokątna przylegająca a
przeciwprostokątna c
przyprostokątna
przeciwległa b
leżący naprzeciw kata, to przyprostokątna przeciwległa, a najdłuższy bok, leżący naprzeciw kąta
prostego, to przeciwprostokątna.
Rysunek 2. Trójkąt prostokątny.
W zastosowaniach informatycznych, jako miar kątów, używa się pojęcia radianów.
Kąt pełny posiada wartość 2 · pi radianów, gdzie pi odpowiada informatycznej skończonej definicji
liczby π.
Suma kątów trójkąta wynosi 180 stopni, czyli pi radianów.
Twierdzenie Pitagorasa - suma kwadratów boków przylegających do kąta prostego, jest równa
kwadratowi długości jego przeciwprostokątnej. Co można zapisać wzorem:
222
bac +=
W oparciu o trójkąt prostokątny definiujemy funkcje trygonometryczne.
Kąt bazowy będzie oznaczony symbolem α.
sin α = stokatnaprzeciwpro
laprzeciwlegkatnaprzyprosto
=
c
b
Dziedziną funkcji sinus jest zakres kątowy pi2,0 , zbiór wartości 1,1− .
cos α = stokatnaprzeciwpro
przyleglakatnaprzyprosto
=
c
a
Dziedziną funkcji cosinus jest zakres kątowy pi2,0 , zbiór wartości 1,1− .
tg α = stokatnaprzeciwpro
laprzeciwlegkatnaprzyprosto
stokatnaprzeciwpro
przyleglakatnaprzyprosto
=
a
b
Dziedziną funkcji tangens jest zakres kątowy 2/,2/ pipi− , zbiór wartości ∞∞− , .
Podstawowe zależności pomiędzy funkcjami trygonometrycznymi:
9

10. (x B ,y B )(x A ,y A )
B=(x B ,y B )
A=(x A ,y A )
x
y
0
cscα =
αsin
1
sec α =
αcos
1
ctg α = αtg
1
sin 2
α + cos 2
α =1
sin α = cos(α -π/2)
sin(-α) = -sin α
cos(-α) = cos α
sin(α +β) = sin α · cos β + cos α · sin β
cos(α +β) = cos α · cos β - sin α · sin β
1.2.3 Wektory
Wektory to uporządkowana para punktów, z których jeden jest jego początkiem, a drugi
końcem W interpretacji geometrycznej, na płaszczyźnie, wektor jest odcinkiem, o początku w
punkcie A= i końcu w punkcie B= . Inaczej można określić wektor jako wielkość,
którą charakteryzuje wartość i kierunek. Wektor oznaczamy najczęściej małą literą i definiujemy
przy pomocy składowych, które przyjmują wartość równą różnicy punktów początkowego i
końcowego.
Rysunek 3. Wektor.
u= YX uu , =(x B -x A ,y B -y A )
Długość wektora jest równa pierwiastkowi kwadratowemu z sumy jego składowych.
|u| = )(
222
ZYX uuu ++
Wektor jednostkowy to wektor, którego długość wynosi 1.
10

11. Wektory jednostkowe są przydatne wszędzie, tam gdzie interesuje nas tylko kierunek wektora. W
celu doprowadzenia wektora do postaci wektora jednostkowego, posługujemy się normalizacją
wektora.
Normalizacja wektora to działanie, które polega na wyliczeniu ilorazu wartości składowych i
długości.
u´ = u
u
u
u uX
,
1.2.4 Działania na wektorach
Dodawanie wektorów to operacja, polegająca na zsumowaniu wartości składowych
wektorów.
u + v = yyXX vuvu ++ ,
Odejmowanie wektorów to operacja odjęcia wartości wektorów składowych.
u – v = YYXX vuvu −− ,
Iloczyn wektora i wartości skalarnej polega na przemnożeniu składowych przez skalar.
u · k = kuku YX ·,·
Iloczyn skalarny
Iloczyn skalarny wektorów, jest równy iloczynowi składowych tych wektorów, a jego wynikiem jest
skalar.
Operacje mnożenia skalarnego wektorów oznaczamy kropką u . v .
u . v = YYXX vuvu ·,·
Wyrażenie to, jest równoważne iloczynowi długości tych wektorów i cosinusa kąta zawartego
między nimi.
U . v= |u| · |v| · cos α
Na tej podstawie możemy wyliczyć kąt pomiędzy wektorami
α = cos 1−
||·||
.
vu
vu
11

12. u= YX uu ,
v= YX vv ,
α
u
v
w
α
Rysunek 4. Iloczyn skalarny wektorów u i v.
Iloczyn skalarny przyjmuje następujące wartości:
Dla kąta α = 90º u . v = 0
Dla kąta α < 90º u . v > 0
Dla kąta α > 90º u . v < 0
Jeżeli wektory u i v są identyczne to u . v = |u| 2
=|v| 2
Iloczyn skalarny jest wykorzystywany przy oświetleniu, do wyznaczenia wartości natężenia w
zależności od kąta padania światła, a także do ustalania widoczności powierzchni (czy dana
powierzchnia jest zwrócona w kierunku kamery).
Iloczyn wektorowy
Ma sens dla wektorów zdefiniowanych w przestrzeni trójwymiarowej.
Jest on równy iloczynowi długości wektorów, sinusowi kąta między nimi i wektora normalnego
skierowanego prostopadle do wektorów.
w = u × v · sin α
Rysunek 5. Iloczyn wektorowy dwóch wektorów u v× .
Wzór na wektor normalny do wektorów u i v.
N= YYZZZZ u·v·,·uv·,u·v· XXXxYY vuvuvu −+−−
gdzie u = ZYX uuu ,, , v = zyx vvv ,,
12

13. Wektory normalne są wykorzystywane do wyznaczenia kierunku, w którym skierowane są
powierzchnie, tj. przy algorytmach usuwania powierzchni zwróconych tyłem i oświetleniu, i często
mają postać wektora jednostkowego.
1.2.5 Podstawowe przekształcenia geometryczne
Podstawowe przekształcenia geometryczne wykorzystywane w grafice 3d, to przesunięcie o
wektor, zwane translacją, skalowanie i obrót.
Przesunięcie o wektor, to przemieszczenie współrzędnych punktu, o wartość wektora przesunięcia.
Wzór na przesunięcie jest następujący:
x = x + u X
y = y + u Y
z = z + u Z
,gdzie wektor przesunięcia u = <u X ,u Y ,u Z >
Skalowanie, to operacja polegająca na przemnożeniu współrzędnych punktu przez wartość skalarną.
x = x · s X
y = y · s Y
z = z · s Z
gdzie s X , s Y , s Z to czynniki skalowania dla kierunków x ,y, z.
Obrót
W przypadku obrotu punktu dookoła jednej z trzech osi o kąt α, musimy obliczyć współrzędne
punktu dla pozostałych dwóch osi. Położenie punktu na osi, według której dokonuje się obrotu nie
zmienia się.
Wartość punktu x po wykonaniu obrotu obliczamy przy pomocy wzorów:
y = y · cos α - z · sin α
z = y · sin α + z · cos α
dla osi y i z, wzory na wartość punktu po dokonaniu obrotu, przedstawiają się następująco:
oś y:
x = x · cos α + z · sin α
z = -x · sin α + z · cos α
oś z:
x = x · cos α - y · sin α
y = x · sin α + y · cos α
13

14. 1.2.6 Macierze
Macierzą określamy prostokątną tablice liczb. Tablica ta posiada m wierszy i n kolumn, co
określamy mianem rozmiaru m x n.
M dc
ba
Macierz M to macierz czteroelementowa, o rozmiarze 2x2.
Macierze mają bardzo szerokie zastosowanie, gdyż można za ich pomocą, wyrazić skomplikowane
równania i działania w czytelnej postaci. W przypadku grafiki 3d, macierze wykorzystywane są do
podstawowych przekształceń, takich jak przesunięcie, skalowanie, obrót oraz do rzutowania na
płaszczyznę widoku i płaszczyznę ekranu (o czym szerzej w podrozdziale „Potok geometrii”).
Macierze mają wiele właściwości, z których omówię tylko te najbardziej podstawowe.
Na macierzach można wykonywać operacje matematyczne.
Dodawanie i odejmowanie macierzy, polega na wykonaniu tych działań, na odpowiadających sobie
elementach dwóch macierzy o identycznym rozmiarze.
hdgc
fbea
hg
fe
dc
ba
++
++
=+
Mnożenie macierzy przez skalar, polega na pomnożeniu każdego elementu macierzy przez wartość
skalarną.
·dk·ck
·bk·a
·
k
dc
ba
k =
Mnożenie macierzy polega na przemnożeniu wierszy pierwszej macierzy, przez kolumny drugiej i
jest możliwe wtedy i tylko wtedy, gdy liczbie kolumn pierwszej macierzy, odpowiada liczba wierszy
drugiej macierzy.
hdcc
babea
hg
fe
dc
ba
··fg·de·
·h·fg··
++
++
=+
Mnożenie macierzy nie jest przemienne(wyjątek stanowi mnożenie macierzy jednostkowej).
A · B ≠ B · A
Macierz jednostkowa, to macierz kwadratowa, której elementy znajdujące się na przekątnej,
przyjmują wartość 1, a pozostałe są równe 0.Oznaczamy ją przez I.
I 10
01
Iloczyn dowolnej macierzy przez macierz jednostkową, daje w rezultacie tę samą macierz.
14

15. M · I = M
Iloczyn macierzy przez swoją odwrotność, jest równy macierzy jednostkowej.
M · M 1−
= I
1.2.7 Przekształcenia geometryczne przy użyciu macierzy
Głównym powodem, dla którego stosuje się macierz, jest możliwość dokonania złożonych
transformacji punktu przy pomocy iloczynu macierzy, redukując tym samym, konieczność
przeliczania danych punktu dla kolejnych przekształceń, co można wyrazić:
P´=P · M 1 · M 2 · M 3 · ... · M n
Współrzędne jednorodne
Ważnym pojęciem związanym z przekształceniami geometrycznymi przy użyciu macierzy, są
współrzędne jednorodne, ponieważ umożliwiają zapis dowolnego przekształcenia przestrzeni przy
pomocy zapisu macierzowego.
Współrzędne jednorodne uzyskuje się, poprzez uzupełnienie współrzędnych punktu o dodatkową
współrzędną w, zwaną współrzędną jednorodną. W przestrzeni trójwymiarowej współrzędne
jednorodne punktu zapisuje się jako wzyx . Związek współrzędnych jednorodnych do
kartezjańskich, jest równy ilorazowi współrzędnych jednorodnych przez współrzędną dodatkową w:
zyx =
w
z
w
y
w
x
Zwykle w przekształceniach przyjmuje się w=1.
W zgodzie z powyższymi założeniami, współrzędne przekształconego punktu, są równe iloczynowi
punktu początkowego, zdefiniowanego w macierzy czteroelementowej 1zyx i
czterowymiarowej macierzy przekształceń.
Podstawowe macierze przekształceń:
Macierz przesunięcia
1
0100
0010
0001
zyx
Macierz skalowania
1000
000
000
000
z
y
x
15

16. Macierz obrotu wokół osi x
1000
0cossin0
0sincos0
0001
xx
xx
−−
Macierz obrotu wokół osi y
1000
0cos0sin
0010
0sin0cos
yy
yy −
Macierz obrotu wokół osi z
1000
0100
00cossin
00sincos
zz
zz
−
1.3 STRUKTURY DANYCH OPISUJĄCE TRÓJWYMIAROWE MODELE
1.3.1 Podział struktur danych
W grafice 3d czasu rzeczywistego, opartej o wykreślanie wielokątów, struktury definiujące
modele 3d pełnią centralną role, gdyż to na nich wykonywane są obliczenia. Generalnie można
opisać obiekty sceny na dwa sposoby. Pierwszy, związany jest z podziałem na poszczególne
elementy sceny i role im przypisane. Są to właśnie modele 3d. Ich rolą jest naśladowanie obiektów
istniejących w świecie rzeczywistym. Są one zdefiniowane przy pomocy siatki wielokątów
uformowanej w odpowiedni sposób i mają przypisane materiały symulujące ich wygląd w świecie
rzeczywistym.
Drugi sposób definicji, związany jest ze sposobem definiowania geometrii przy pomocy algorytmów
komputerowych. Na pewnym etapie operowanie na pojedynczych siatkach jest skomplikowane tak
od strony operacji komputerowych, jak i budowanych algorytmów. W tym celu całą geometrię
umieszcza się w jednej głównej strukturze ,będącej listą elementów, do której dostęp jest bardzo
prosty i odbywa się przy pomocy iteracji. Jest to lista renderowania.
1.3.2 Model 3d
W swojej najprostszej postaci, model 3d, jest zbiorem wielokątów budujących tzw. siatkę
wielokątów, rozmieszczonych w przestrzeni w taki sposób, ażeby naśladowały określony przedmiot.
Siatka ta, zdefiniowana jest przy użyciu trzech struktur:
16

17. • lista wierzchołków zawierająca położenie wszystkich wierzchołków składających się
na obiekt, zdefiniowanych według wspólnego (lokalnego) układu współrzędnych
• lista wierzchołków służąca do przechowywania informacji o przekształceniach
wierzchołków i wykorzystywana w potoku renderowania.
• lista wielokątów, zawierająca informacje o wszystkich wielokątach składających się
na obiekt. Wielokąty te są zdefiniowane przy pomocy indeksu wierzchołków,
opartego na liście wierzchołków. Dzięki temu nie ma konieczności odświeżania
informacji po przekształceniu, gdyż definicje wielokątów nie zmieniają się.
Dodatkowe informacje, które są zdefiniowane przy pomocy listy wielokątów to
współrzędne tekstury.
Każdy wielokąt definiuje pewną powierzchnię Do wyświetlania powierzchni potrzebne są
informacje o kolorze powierzchni i sposobie reagowania na oświetlenie, zwane cieniowaniem.
Informacje te, zdefiniowane są na poziomie modelu, jednakowo dla każdego wielokąta Sposób
przetwarzania informacji rożni się w zależności od trybu cieniowania i jest związany z pojęciem
wektora normalnego. W trybie cieniowania płaskiego, do właściwego oświetlenia potrzebny jest
wektor normalny zdefiniowany dla powierzchni. W trybie cieniowania Gourand, wektor normalny
jest określony dla każdego wierzchołka i przyjmuje średnią wartość, pochodząca z zsumowania
wszystkich wektorów powierzchni zawierających dany wierzchołek. W modelu została umieszczona
struktura przechowująca wartość wektorów normalnych dla wierzchołków (lista wektorów
normalnych).
Podstawowym wielokątem, używanym do budowania siatek przestrzennych w mojej pracy, jest
trójkąt. Jest to najbardziej naturalny i najprostszy sposób radzenia sobie z opisywaniem przestrzeni
trójwymiarowej. W geometrii trzy punkty jednoznacznie definiują powierzchnie, jednocześnie
posługiwanie się tego typu obiektami znacznie upraszcza obliczenia. Wektor normalny obliczany
jest na podstawie kolejności w jakiej wierzchołki są zdefiniowane. Mogą być one zdefiniowane
zgodnie z ruchem wskazówek zegara(układ lewostronny) lub odwrotnie.
Model zawiera również informacje takie jak położenie czy promień, które są wykorzystywane w
przekształceniach potoku geometrii.
Modele wykorzystywane są na początkowym etapie przekształceń, gdyż jak wspomniałem, jest to
efektywny i łatwy sposób zarządzania zachowaniem elementów sceny.
Rysunek 6. Model 3d wyświetlany w postaci szkieletu(siatka wielokątów).
17

18. 1.3.3 Lista renderowania
Lista renderowania stanowi zbiór wszystkich wielokątów w scenie .Musi więc, zawierać w
sobie dane obiektów już przekształconych do współrzędnych sceny, wspólne dla każdego elementu
składającego się na wirtualny świat. Ten sposób definiowania danych bardzo ułatwia zarządzanie
strukturami danych w scenie i umożliwia zredukowanie działań, do kilku wywołań funkcji,
operujących na jednej wspólnej liście renderowania. Jest to bardzo wygodne w dalszych etapach
potoku geometrycznego i przy wykreślaniu trójkątów.
Lista renderownia, wykorzystywana przeze mnie, zawiera listę trójkątów, która jest
podstawową strukturą wykorzystywaną do przechowywania informacji o wielokątach. Każdy
trójkąt, to osobna struktura zawierająca takie informacje jak:
• Kolor
• Kolor oświetlony
• Wektor normalny
• Długość wektora normalnego
Do definiowania informacji o wierzchołkach służy struktura, która podobnie jak w definicji trójkąta
zawiera dane dotyczące:
• Kolor oświetlonego wierzcholka
• Wektora normalnego
• Długości wektora normalnego
• Mapowanie tekstur
1.4 POTOK GEOMETRII
1.4.1 Potok geometrii
Potok geometrii, stanowi zasadniczą część całego potoku wyświetlania, a jego zadaniem, jest
przetwarzanie danych opisujących obiekty przestrzenne sceny na ich dwuwymiarową reprezentację
na ekranie. Wynikiem działania potoku geometrii jest lista wielokątów, gotowa do poddania się
procesowi wykreślania.
Działania składające się na potok geometrii można przedstawić, jako przekształcenia wierzchołków
definiujących obiekty pomiędzy kolejnymi układami współrzędnych:
• lokalny układ współrzędnych, według którego definiujemy trójwymiarowe modele
18

19. • globalny układ współrzędnych, według którego opisujemy kompletną scenę
• układ współrzędnych zdefiniowanych według kamery, do której przekształcamy wirtualną
scenę
• układ współrzędnych płaszczyzny rzutowania, na który rzutujemy obiekty
• układ współrzędnych ekranowych, według którego adresujemy rzutowane wielokąty,
umożliwiając proces wykreślania
Oprócz tego, do potoku geometrii, zaliczamy również działania mające na celu usunięcie zbędnych
danych opisujących obiekty lub wielokąty, które nie znalazły się w polu widzenia kamery. Są to:
• usunięcie obiektów znajdujących się poza polem kamery(tzw. test sfer otaczających)
• usunięcie ścian zwróconych tyłem (test mający sprawdzić, czy powierzchnia wielokąta jest
skierowana w stronę kamery)
• przycinanie wielokątów, które przecinają przednią płaszczyznę obcinającą.
Istotnym zagadnieniem, związanym z procesem przekształceń geometrii, jest sposób opisu danych
definiujących obiekty przestrzenne, opisany w poprzednim podrozdziale. W potoku geometrii,
przechodzimy od definicji obiektów w formie opisu modeli, do luźnego połączenia całej geometrii
budującej scenę w formie listy wielokątów, zwanej listą renderowania.
Duże znaczenie ma również kolejność wykonywanych działań, ze względu na minimalizacje ilości
koniecznych obliczeń. Np. usuniecie obiektów znajdujących się poza kamerą, przed
przekształceniem sceny do współrzędnych kamery, pozwala pominąć wiele zbędnych iterowan.
Należy również pamiętać, że na pewnym etapie, dochodzi do procesu oświetlenia, opisanego
osobno. W efekcie wielokąty budujące scenę, zostają wzbogacone o informacje o kolorze, jaki
posiadają po oświetleniu. Ma to znaczenie w przypadku operacji przycinania wielokątów, które
wychodzą poza przednią płaszczyznę obcinająca.
Wreszcie kwestia zapisu działań przy pomocy macierzy. Dużą cześć przekształceń, można wyrazić
przy pomocy stosu macierzy, opisanego w podrozdziale nt. matematycznych podstaw grafiki 3d.
Należy również mieć na uwadze, że prezentowane tutaj rozwiązania, stanowią jedynie pewien
model. Pomijając fakt, że w rzeczywistych zastosowaniach, potok geometrii może przybierać
dowolną formę i dowolną kolejność, ze względu na optymalizację działań.
1.4.2 Lokalny układ współrzędnych modelu 3d
Operacje składające się na potok geometrii, rozpoczynają się, od przekształceń
wykonywanych w lokalnym układzie współrzędnych. Układ ten związany jest z pierwotną definicją
siatki wielokątów, a za jego punkt początkowy, bardzo często obieramy środek geometryczny
modelu. Ten sposób operowania obiektem, jest wygodny do dokonywania na nim takich operacji jak
obrót i skalowanie. Przykładem takich działań mogą być animacje ruchów typu
zawiasowego(oczywiście po zdefiniowaniu modelu według odpowiednio obranego początku układu
współrzędnych, będącego osią obrotu) jak np. symulacja stawów przy animacji poruszającej się
postaci, symulacja pracującej koparki, otwieranie drzwi itp.
19

20. 1.4.3 Transformacja obiektu do współrzędnych globalnych sceny
Współrzędne globalne sceny, to współrzędne wspólne dla wszystkich elementów sceny
takich jak modele, kamery i światła. Ten sposób zdefiniowania obiektów wirtualnego świata,
umożliwia rozmieszczenie elementów, w zgodzie z przyjętymi założeniami, odpowiadającymi
charakterowi elementów, przemieszczeniu (animacja ruchu jako zmianie położenia) itp.
Transformacja obiektu do współrzędnych globalnych wirtualnego świata, polega na transformacji
współrzędnych każdego z wierzchołków obiektu o wektor położenia obiektu w globalnej scenie.
1.4.4 Kamera
Kolejne przekształcenie związane jest z pojęciem kamery. Kamera to obiekt, poprzez który
definiujemy sposób oglądania świata. Dlatego też, w potoku geometrii, pełni ona rolę obiektu, do
którego odnosimy inne obiekty i według którego definiujemy współrzędne przekształconego świata.
Kamera jest obiektem, który możemy swobodnie definiować w trakcie oglądania sceny. Możemy
zmieniać takie właściwości jak położenie w scenie, kąty definiujące kierunek patrzenia. Definiuje
również pewne pole widzenia, które ogranicza ilość wyświetlanej geometrii.
Kamera posiada następujące cechy:
• położenie -punkt, który jest środkiem osi rzutowania
• Kąt obrotu - zdefiniowany według osi x
• Kąt nachylenia -zdefiniowany według osi y
• Kąt odchylenia- zdefiniowany według osi z
• Płaszczyzna rzutowania- płaszczyzna, na którą rzutowane są obiekty.
• Płaszczyzna znajduje się w odległości, zwanej odległością widzenia od punktu
początkowego kamery.
• Przednia i tylnia płaszczyzna obcinająca -płaszczyzny, które ograniczają widok świata
• Kąt widzenia-definiuje pole widzenia
Kamerę można przedstawić w postaci ostrosłupa, ściętego przy wierzchołku przez płaszczyznę
rzutowania. Kamera wyznacza układ współrzędnych, w którym kierunek patrzenia jest zgodny z
osią dodatnia z. W pracy przyjmuje uproszczony model kamery o kącie widzenia 90º i odległości
widzenia 1.
20
y+ ostrosłup widzenia

21. Rysunek 7.Pole widzenia kamery definiuje ostrosłup widzenia
1.4.5 Przekształcenie obiektów sceny do współrzędnych kamery
W celu przekształcenia obiektów sceny do współrzędnych kamery, przyjmuję, że wyznacza
ona układ współrzędnych (układ współrzędnych kamery), o początku w punkcie zbiegu osi
rzutowania (położenia kamery), z kierunkiem patrzenia zbieżnym z osią z+, z kątami przechyleń i
nachyleń równymi 0. Kąt widzenia dla płaszczyzn pionowych i poziomych jest równy 90º.
Następnie wykonuję obrót obiektów zgodnie z ujemną wartością kątów, jakie przyjmuje kamera w
układzie współrzędnych sceny (kąty obrotu, nachylenia, przechylenia). Obrót ten, obliczam na
podstawie wzorów przekształceń z użyciem macierzy, przedstawionych w podrozdziale
„Matematyczne podstawy grafiki 3d”.
1.4.6 Usunięcie obiektów poza kamerą
Usunięcie obiektów znajdujących się poza kamerą, polega na wykonaniu tzw. testu sfer
otaczających. Jego pierwszy etap to wyznaczenie promienia sfery w której obiekt zawiera się
całkowicie, a następnie przekształceniu informacji o sferze (środka położenia) na współrzędne
kamery. Działanie to, nieskomplikowane pod względem obliczeniowym, pozwala w łatwy sposób
sprawdzić czy kula(sfera) znajduje się w polu widzenia kamery. Algorytm dokonujący sprawdzenia,
polega na sprawdzeniu, czy obiekt znajduje się poza płaszczyznami ostrosłupa widzenia i bierze pod
uwagę, że dla kąta widzenia 90º ,współrzędne x i y znajdujące się na płaszczyźnie definiującej pole
widzenia kamery, są równe współrzędnej z. Oczywiście fakt, że obiekt przeszedł negatywnie
test(tzn. nie wyszedł całkowicie poza obręb pola widzenia), nie oznacza jeszcze, że jest on widoczny
w całości (może to zależeć od sposobu opisania sfery na obiekcie i kształtu obiektu). Jednak na tym
etapie obiekt jest rozbijany na mniejsze elementy(wielokąty) i kolejna (analogiczna)operacja jest
przeprowadzona na wielokątach na dalszych etapach potoku przekształceń.
21
x+
z+
przednia płaszczyzna
obcinającą
tylnia płaszczyzna
obcinającą
płaszczyzna
rzutowania
z+sfery
otaczające

22. Rysunek 8. Test sfer otaczających.
1.4.7 Usunięcie ścian zwróconych tyłem
To działanie polegające na sprawdzeniu i odrzuceniu wielokątów, których powierzchnia nie
jest zwrócona w stronę kamery. Działanie takie ma sens, kiedy założymy ze wielokąt wyznacza
tylko jedną powierzchnię. Np. przy definiowaniu sześcianu zakładamy, że wszystkie powierzchnie
wielokątów są zwrócone na zewnątrz. Algorytm weryfikacji czy dany wielokąt jest widoczny,
polega na wyznaczaniu wektora normalnego powierzchni i wektora widzenia skierowanego od
powierzchni do oka kamery, a następnie wyliczeniu iloczynu skalarnego pomiędzy nimi.
Jeżeli iloczyn skalarny jest większy od 0, wtedy kąt pomiędzy powierzchnią i kamerą jest mniejszy
od 90º, co oznacza, że powierzchnia jest widoczna i może uczestniczyć w dalszym działaniach
związanych z potokiem renderowania. Na tym etapie umieszczam wielokąty na liście renderowania.
1.4.8 Układ współrzędnych płaszczyzny rzutowania
Posiadając współrzędne obiektów sceny zdefiniowane według współrzędnych kamery,
można przystąpić do rzutowania perspektywicznego wielokątów na płaszczyznę rzutowania, która to
operacja jest sednem przekształceń geometrii w potoku geometrii i umożliwia uzyskanie obrazu z
perspektywą. Rzutowanie to, poprowadzone jest po prostej przechodzącej przez środek
współrzędnych kamery, będącej punktem widzenia (położenia kamery) i przez rzutowane
wierzchołki. Jeżeli wierzchołek znajduje się w polu widzenia kamery, to proste przebiją płaszczyznę
rzutowania. Miejsce, w którym dochodzi do przebicia, wyznacza współrzędne wierzchołków na
płaszczyźnie rzutowania.
Współrzędne rzutowanego punktu, można wyznaczyć z twierdzenia o podobieństwie trójkątów:
x´ = d ·
0
0
z
x
, y´ = d ·
0
0
z
y
22
x+
ostrosłup widzenia
kamery
y+ (x 0 , y 0 , z 0 )
przednia płaszczyzna
obcinająca
dla kąta widzenia=90º
wartość współrzędnych x, y na
krawędzi jest równa z

23. Rysunek 9. Rzutowanie na płaszczyznę perspektywy.
Dane odnośnie położenia wierzchołka, należy uzupełnić o stosunek wysokości i szerokości obrazu,
ponieważ po rzutowaniu otrzymujemy współrzędne, opisane według kwadratowej płaszczyzny
rzutowania. W tym celu możemy zmodyfikować współrzędne szerokości o współczynnik „aspect
ratio” = szerokość/wysokość. Dla zachowania prawidłowego odwzorowania trzeba przeskalować
jedną z osi. Robimy to skalując oś y.
Macierz potrzebna do wykonania tego przekształcenia ma postać:
0000
1100
000
000
ard
d
⋅
Przy obraniu odległości widzenia równiej d=1, otrzymuje znormalizowane współrzędne
wierzchołków na płaszczyźnie rzutowania:
x ∈ 1,1− , y ∈ arar /1,/1−
1.4.9 Przekształcenie współrzędnych widoku na współrzędne ekranu
Przekształcenie wierzchołków do współrzędnych ekranowych, jest ostatnim z działań w
potoku geometrii. Jego wynikiem jest lista obiektów zaadresowanych według współrzędnych
ekranu, gotowa do poddania procesowi rasteryzacji.
Układ współrzędnych ekranowych ma swój początek w lewym górnym rogu. Jest to
dwuwymiarowy układ współrzędnych w osi x przyjmującej wartość z przedziału 1-szerokosc,0
i odwróconej osi y o wartościach należących do przedziału -wysokoœædo0 1.
23
z+
(x´, y´, z´)
(0,0,0)
d
x+
(0,0) (szerokość ekranu-1,0)
(-1,0) (1,0)
(0,1/ar)
płaszczyzna
rzutowania

24. Rysunek 10. Współrzędne ekranu i współrzędne perspektywy.
Wartości współrzędnych ekranowych:
x ∈ 1,1− , y ∈ arar /1,/1−
Wartości współrzędnych perspektywy:
x ∈ 1,0 −kranuszerokosce , y ∈ 1,0 −ranuwysokoscek
Wzór na przekształcenie współrzędnych ekranowych na współrzędne perspektywy:
x ekran =( x yperspektyw + 1 ) · ( 0.5 · szerokość ekranu - 0.5 )
y ekran =( wysokość ekranu – 1 ) - ( y yperspektyw + 1 ) · ( 0.5 · wysokość ekranu - 0.5 )
Podstawiając:
α = (0.5 · szerokość ekranu - 0.5 )
β = ( 0.5 · wysokość ekranu - 0.5 )
otrzymuję ostateczną postać wzoru:
x ekran = α + x yperspektyw · α
y ekran = β - y yperspektyw · β
Macierz przekształceń współrzędnych ekranowych na współrzędne perspektywy ma następująca
postać:
10
0100
000
000
βα
β
α
1.4.10 Przycinanie
Operacja przycinania związana jest z położeniem wielokątów po przekształceniu do układu
współrzędnych kamery. Po przekształceniu, wiele wielokątów wystaje całkowicie lub częściowo
poza ostrosłup widzenia . Skutkiem tego po dokonaniu przekształcenia do współrzędnych ekranu,
wystają one poza obszar odrysowanego ekranu. Rozwiązaniem problemu może być przycinanie na
płaszczyźnie ekranu, które wykonywane jest w trakcie rasteryzacji. Polega na adresowaniu tylko
tych pikseli, które znajdą się w polu odrysowanego ekranu. Ten typ przycinania omawiany jest w
podrozdziale o renderowaniu. Problemem są jednak wielokąty, znajdujące się w ostrosłupie
widzenia, których krawędzie przekraczają środek układu współrzędnych (punkt widzenia).
Rzutowanie takich wielokątów na płaszczyznę perspektywy spowoduje błędy(odwrócenie
wartości).Ażeby im przeciwdziałać, stosuje się przycinanie do przedniej płaszczyzny obcinania.
24
y+
0,(wysokość ekranu-1)
(0,-1/ar)

25. Polega ono na obliczeniu współrzędnych, w których krawędzie wielokąta przebijają przednią
płaszczyznę obcinania.
Algorytm przycinania trójkąta polega na zastosowaniu równania parametrycznego do wyznaczenia
współrzędnych przebicia przedniej płaszczyzny obcinającej.
p(x,y,z)= w 0 +(w 1 -w 0 ) · t , gdzie w 0 -początek krawędzi, w 1 - koniec krawędzi
x = x 0 +(x 1 -x 0 ) · t
y = y 0 +(y 1 -y 0 ) · t
z = z 0 +(z 1 -z 0 ) · t
Po podstawieniu za z wartości położenia przedniej płaszczyzny obcinającej z´, możemy
obliczyć wartość parametru t:
t=(z´- z 0 )/(z 1 - z 0 )
i na tej podstawie wyliczyć współrzędne x i y punktu przecięcia płaszczyzny.
Po przycięciu powstaje nowy trójkąt (w przypadku gdy 2 wierzchołki przekraczają przednia
płaszczyznę obcinająca) lub czworokąt(w przypadku gdy 1 wierzchołek trójkąta przekracza
przednia płaszczyznę obcinająca), który trzeba podzielić na 2 trójkąty i dodać do listy renderowania.
1.5 OŚWIETLENIE
1.5.1 Światło w świecie rzeczywistym
Algorytmy symulujące oświetlenie w grafice komputerowej 3d starają się naśladować
rzeczywistość. Dlatego tą cześć pracy, zacznę od opisu, w jaki światło kreuje obraz, który widzimy.
Światło, to ta cześć pasma promieniowania elektromagnetycznego, którą jest w stanie zarejestrować
ludzkie oko. Długość fali, którą przyjmuje, zawiera się w przedziale od 380 nm do 700nm, a jej
zróżnicowanie związane jest z widzeniem barw. Naturalne światło przyjmuje barwę białą i zawiera
w sobie cale spektrum widzialne. Generowanie kolorów polega na absorpcji określonej długości fali
(np. zielonej) i odbiciu innej(czerwonej),która następnie jest odbierana przez obserwatora i
powoduje u niego rozróżnianie barw. Istotne znaczenie, w procesie odbioru wrażeń wzrokowych,
ma również natężenie światła, które jest zależne od ilości energii świetlnej, jaka dociera do
ludzkiego oka.
1.5.2 Charakterystyka światła ze względu na sposób odbicia
25

26. Przy opisie modelu światła, trzeba wziąć pod uwagę , że rola światła w kreowaniu efektów
optycznych, jest zależna od źródła światła i sposobu jego reakcji z otoczeniem. Ze względu na
sposób, w jaki światło zostaje odbite od powierzchni i odebrane przez obserwatora, można
wyróżnić kilka rodzajów świateł. Są to światła:
otoczenia, rozproszone , zwierciadlane, emisyjne
Światło otoczenia
W otoczeniu zawsze istnieje pewna ilość światła, które nie zostało zaabsorbowane i nosi ono nazwę
światła otaczającego, bądź światła atmosferycznego. W praktyce światło to ma określoną barwę i
natężenie, a ostateczna wartość oddziaływania na obiekty sceny jest równa ich iloczynowi.
Światło rozproszone
Światło rozproszone to światło, które pada na obiekt, odbija się i ulega rozproszeniu, docierając do
obserwatora. Światło to rozprasza się w każdym kierunku równomiernie i wartość natężenia, nie
zależy od pozycji obserwatora w stosunku do oświetlonej powierzchni, a jedynie od kąta padania
światła na tę powierzchnię. Stąd wartość natężenia światła rozproszonego, zależy od iloczynu
skalarnego wektorów normalnego powierzchni i wektora kąta padania światła. Symulacja z użyciem
światła rozproszonego, to podstawowy sposób w jaki symuluje się oświetlenie sceny w grafice 3d.
Odbicia zwierciadlane
Odbicie zwierciadlane, wyraża zmianę wartości natężenia światła, zależną od kąta padania światła i
pozycji obserwatora, w stosunku do powierzchni i światła. Odbicie zwierciadlane związane jest ze
strukturą materiału, który podlega oświetleniu i która składa się z niewielkich ścianek pełniących
role luster i odbijających światło pod tym samym kątem, pod którym padało.
Światło Emisyjne
Model światła emisyjnego służy do nadania barwy tym elementom, których zadaniem jest
odzwierciedlanie powierzchni emitujących światło jak np.: powierzchnie lamp, neonów itp. Model
ten za wartość natężenia uznaje sam kolor powierzchni.
1.5.3 Charakterystyka światła ze względu na rodzaj źródła
W procesie modelowania oświetlenia, duże znaczenie ma również, podział światła ze
względu na źródło pochodzenia. Źródłem może być światło naturalne w postaci Słońca bądź gwiazd
lub światło sztuczne. Aby zamodelować te typy oświetlenia, posługuję się modelami światła, w
których może ono przyjąć rożne charakterystyki, w zależności od odległości, natężenia i kierunku.
W niniejszej pracy zaprezentujemy dwa modele:
model światła kierunkowego i model światła punktowego
Światło Kierunkowe
Światło kierunkowe, służy do symulowania światła, którego promienie są do siebie równolegle, a
które znajduje się nieskończenie daleko od sceny (np. słonce).Inne określenie to światło
nieskończenie odlegle. Jego natężenie nie maleje wraz z odległością od swojego źródła i nie posiada
pozycji, a do opisu służą trzy parametry kierunek, natężenie i barwa.
26

27. Rysunek 11. Promienie światła kierunkowego są do siebie równolegle .
Światło punktowe
Światło punktowe, to światło zdefiniowane w przestrzeni, którego natężenie zanika wraz ze
zwiększaniem się odległości. Wartość natężenia zależy od odległości, którą obliczamy, jako różnicę
pozycji oświetlenia i oświetlonej powierzchni. Do symulacji tego typu oświetlenia używa się wzoru,
który uzależnia wartość natężenia od trzech współczynników:
stały współczynnik tłumienia - K
liniowy współczynnik tłumienia - K · d
współczynnik tłumienia drugiego stopnia – K · d 2
gdzie d - odległość źródła światła do powierzchni
Wartość natężenia wyraża się wzorem 2
dKdKK
Natezenie
⋅+⋅+
27
x+
x+
y+
y+
0
0

28. Rysunek 12. Światło punktowe.
1.5.4 Cieniowanie
Istotnym zagadnieniem w grafice 3d jest algorytm, który decyduje o tym, w jaki sposób
uwzględnić oddziaływanie oświetlenia na ostateczny wygląd wykreślanej powierzchni, zwany
cieniowaniem. W niniejszej pracy przedstawiam trzy podstawowe algorytmy cieniowania przydatne
w grafice czasu rzeczywistego. Są to:
cieniowanie proste, cieniowanie płaskie, cieniowanie Gourand.
Cieniowanie proste
W cieniowaniu prostym, kolor wykreślanej powierzchni ustalany jest na podstawie
przyporządkowanej zmiennej i nie zależy od oświetlenia. Ten typ cieniowania jest przydatny do
przeprowadzania testów geometrii, bądź do symulowania obiektów emitujących światło.
Cieniowanie płaskie
Przy zastosowaniu algorytmu cieniowanie płaskiego, kolor powierzchni wielokąta przyjmuje
jednolitą barwę, zależną od przypisanego koloru wyjściowego i sumy natężeń kolorów nań
padających. Cieniowanie to nadaje się do symulowania oddziaływania światła rozproszonego. Jest
to najprostszy algorytm, dzięki któremu możemy odróżnić od siebie elementy geometrii, w
zależności od ich budowy i położenia(scena nabiera głębi),jednak nadaje się on tylko do wykreślania
płaskich powierzchni, gdyż przejścia pomiędzy oświetlonymi powierzchniami następują stopniowo,
przez co wyświetlane obiekty wyglądają jak złożone z płaszczyzn.
Rysunek 13. Modele wyświetlane z zastosowaniem cieniowania płaskiego.
Cieniowanie Gourand
W cieniowaniu Gourand, do ustalania koloru oświetlonej powierzchni, bierzemy pod uwagę
wierzchołki wielokątów z przypisanymi im wektorami normalnymi, mającymi wartość uśrednionej
sumy wektorów normalnych powierzchni do których należy wierzchołek. Następnie, przy
wykreślaniu wielokąta, kolor jego powierzchni ustalany jest na podstawie interpolacji wartości
28

29. kolorów pomiędzy poszczególnymi wierzchołkami Efektem tak przeprowadzonej operacji, jest
płynne przejście kolorów pomiędzy sąsiadującymi wielokątami ,co umożliwia symulowanie
zaokrągleń.
Rysunek 14. Modele wyświetlane z zastosowaniem cieniowania Gourand.
1.5.5 Ustalanie barw
Proces oświetlenia to działanie, polegające na imitowaniu zjawisk optycznych związanych z
tworzeniem i mieszaniem się ze sobą rożnych barw. W technice związanej z wyświetlaniem i
przetwarzaniem obrazu do opisywanie barw używa się tzw. modelu RGB, który polega na dodaniu
ze sobą barw Czerwonej Zielonej i Niebieskiej .Termin RGB jest nazwany od angielskich nazw
kolorów(Red Green Blue). W informatyce do odwzorowania kolorów zapisanych w tym modelu
używa się tak zwanej palety 24 bitowej. Każdy bajt(8bitow) zawiera 256 możliwych odcieni jednego
ze składników(zwanych kanałem), co daje w sumie możliwość uzyskania 16,7mln (256 3
) rożnych
odcieni, ze zmieszania ze sobą tych trzech kolorów. W procesie oświetlenia zachodzi do mieszania i
oddziaływania ze sobą barw, które to zjawiska są opisywane przy pomocy działań takich jak:
addycja i modulacja.
Addycja
Dodawanie kolorów wykorzystywane jest przy sumowaniu wartości oświetlenia padającego na dany
obiekt i polega na zsumowaniu ze sobą wartości każdego z kanałów RGB danych kolorów:
Kolor 1 + Kolor 2 = ( R 1 + R 2 , G 1 + G 2 , B 1 + B 2 )
Należy pamiętać ze wynik dodawania dla każdego kanału musi być z zakresu 0-255 w trybie 24
bitowym.
Modulacja
Modulacja jest wykorzystywana przy obliczaniu koloru wynikowego, przy oświetleniu obiektu.
Mnoży się kolor światła padającego i koloru zdefiniowanego dla obiektu. Modulacja kolorów polega
na pomnożeniu ze sobą wartości skalarnej i koloru bądź dwóch kolorów.
Kolor1 · Kolor2 = ( R 1 · R 2 , G 1 · G 2 , B 1 · B 2 )
W tym przypadku rezultat również musie być z zakresu 0-255.
29

30. 1.5.6 Globalny model oświetlenia
Globalny model oświetlenia to model, który służy do symulowania oświetlenia w scenie.
Liczy całkowitą wartość natężenia padającego światła na powierzchnię i na jego podstawie, oblicza
kolor powierzchni oświetlonej, zależnie od rodzaju powierzchni i sposobu interakcji z oświetleniem.
W pracy ograniczam się tylko do światła kierunkowego i punktowego, będącymi źródłem światła
rozproszonego. Wartość ich oddziaływania uzupełniam o światło otaczające. Podstawowe rodzaje
cieniowania to cieniowanie płaskie, gdzie obliczenia są wspólne dla całej oświetlanej powierzchni i
cieniowanie Gourand, w którym trzeba wyliczyć wartość oświetlenia dla każdego wierzchołka.
Algorytm oświetlenia wygląda następująco:
Dla każdej powierzchni, którą oświetlamy sprawdzamy oddziaływanie każdego światła ze sceny.
Światło punktowe
• obliczam wektor kierunku pomiędzy powierzchnią i źródłem światła w
• obliczam wartość iloczynu skalarnego w.n, pomiędzy wektorem normalnym powierzchni n i
wektorem kierunku w.
• jeżeli iloczyn skalarny jest większy od 0 ,wtedy liczę odległość światła od powierzchni d
• podstawiam do wzoru na natężenie I:
I= ( )2
.
dKdKKdn
nw
⋅+⋅+⋅⋅
Światło kierunkowe
• obliczam wektor kierunku pomiędzy powierzchnią i źródłem światła w
• obliczam wartość iloczynu skalarnego w.n, pomiędzy wektorem normalnym powierzchni n i
wektorem kierunku w.
• jeżeli iloczyn skalarny jest większy od 0 ,wtedy liczę odległość światła od powierzchni d
• wzór na natężenie I:
I=
d
nw.
Wartość natężenia jest mnożona przez kolor, jaki przyjmuje światło, a następnie po zsumowaniu
oddziaływania wszystkich świateł, dodaję oddziaływanie światła otaczającego i mnożę przez kolor
oświetlanej powierzchni, co w efekcie daje nowy kolor, będący kolorem jaki przyjmie powierzchnia
pod wpływem oddziaływujących świateł.
30

31. W przypadku cieniowania Gourand, powyższe wzory wykonuję dla każdego wierzchołka.
1.6 RENDEROWANIE
1.6.1 Renderowanie
Pojęcie renderowania w grafice 3d, oznacza całościowy proces tworzenia obrazu na ekranie, na
podstawie przetworzonych danych. W tej pracy, pojęcia renderowania, używam do określania
procesu ostatecznego wykreślania przekształconych wielokątów. Jego przebieg polega na
wyliczaniu współrzędnych i barwy pikseli składających się na wielokąty budujące scenę, na
podstawie odpowiednich algorytmów. Jako dane wejściowe, służą współrzędne wierzchołków
wyświetlanych wielokątów i dane pochodzące z procesu oświetlenia i współrzędne tekstur.
Następnie dane te są przetwarzane przy użyciu następujących algorytmów:
• rasteryzowania jako procesu właściwego odwzorowania wyświetlanych figur
• cieniowania jako procesu ustalania odpowiedniej barwy wyświetlanych wielokątów
• teksturowania jako procesu modyfikacji pikseli wyświetlanych wielokątów na podstawie
przypisanej mapy bitowej
• Bufor Z jako proces określania, które wielokąty zostaną wyświetlone, a które przysłonięte
przez wielokąty znajdujące się na bliższym planie.
1.6.2 Rasteryzacja trójkątów
Rasteryzacja polega na przybliżeniu wyglądu wykreślanych figur geometrycznych na ekranie
komputera, w skończonej rozdzielczości. Algorytmy rasteryzacji mają za cel określenie, które
piksele należy wyświetlić, ażeby osiągnięty efekt był jak najbardziej zbliżony do wykreślanej figury.
Istotną cechą tych algorytmów jest ich szybkość. W pracy prezentuję podstawowy algorytm
wypełniania trójkątów, stanowiący podstawę dla prezentowanych algorytmów cieniowania,
teksturowania, buforowania .
Algorytm wypełniania trójkątów w niniejszej pracy, polega na wykreślaniu trójkąta o płaskiej
podstawie. Każdy trójkąt o dowolnej formie (różne wysokości wierzchołków), może by podzielony
na dwa trójkąty o płaskiej podstawie(jeden odwrócony).Jego przebieg nie jest skomplikowany i
polega, na wyznaczeniu pikseli leżących na dwóch krawędziach, poprowadzonych od wierzchołka
do podstawy, a następnie na wykreśleniu pikseli leżących pomiędzy tymi krawędziami, linia po linii.
Posiadając trójkąt o płaskiej podstawie, wykonuję następujące kroki:
• Obliczam różnice wysokości wierzchołków:
dy =y 1 -y 0
31

32. • Obliczam różnice położenia wierzchołków na osi x, dla lewej i prawej krawędzi:
dx LEWA =x 1 -x 0
dx PRAWA =x 2 -x 0
• Wartość nachylenie
1
dla lewej i prawej krawędzi jest równa:
dy
dxLEWA
dy
dxPRAWA
• na podstawie wartości nachylenie
1
, mogę wyznaczyć położenie współrzędnej x dla obu
krawędzi, według wartości całkowitych współrzędnej y, odpowiadającym kolejnym
liniom obrazu:
x LEWA =x 0 +y
dy
dxLEWA
x PRAWA =x 0 +y
dy
dxPRAWA
• wyświetlam wszystkie punkty znajdujące się pomiędzy krawędziami lewą i prawą
32
(x 0 ,y 0 )
(x 1 ,y 1 ) (x 2 ,y 2 )
x LEWA =x 0
+y
dy
dxLEWA
x
PRAWA =x 0 +y
dy
dxPRAWA
x+
y+
0

33. Rysunek 15. Algorytm wypełniania trójkątów.
Podział trójkąta na dwa trójkąty o płaskich podstawach, następuje wzdłuż długiej krawędzi.
Rysunek 16. Podział trójkąta w algorytmie wypełniania trójkątów.
1.6.5 Przycinanie w przestrzeni ekranu
Przycinanie w przestrzeni ekranu, związane jest bezpośrednio z procesem rasteryzowania i
należy uwzględnić je, przy implementacji algorytmów rasteryzacji. Ekran posiada cztery krawędzie,
które definiują krawędzie przycinania:
y GORNAKRAWEDZ _ =0
y DOLNAKRAWEDZ _ = wysokość ekranu-1
x LEWAKRAWEDZ _ = 0
x PRAWAKRAWEDZ _ = szerokość ekranu-1
W przypadku gdy rasteryzowany trójkąt wykracza poza krawędź górną (y<0),
należy przeliczyć nowe współrzędne początku położenia krawędzi dla y=0:
x LEWA = x 0 + (0 - y 0 ) ·
01
01
yy
xx
−
−
, x PRAWA = x 0 + (0 - y 0 ) ·
02
02
yy
xx
−
−
33
x+
y+
0
x=x 1 +(y 1 -y 0 ) · (x 2 -x 0 )/(y 2 -y 0 )
(x 1 ,y 1 )
(x 2 ,y 2 )
(x 0 ,y 0 )

34. Dolna krawędź wyznacza ostatnią linię rasteryzowanego obrazu, podobnie krawędzie boczne,
wyznaczają pierwszy i ostatni piksel, który ma zostać zaadresowany. Współrzędne x
rasteryzowanych pikseli muszą zawierać się w przedziale (0,szerokosc ekranu-1)
1.6.5 Algorytm cieniowania Gourand
Cieniowanie jest jednym z najważniejszych algorytmów stosowanych w procesie
renderowania i czasem z nim utożsamiany. Polega na nadaniu odpowiedniego koloru pikselom, na
podstawie danych pochodzących z procesu oświetlenia (został opisany w podrozdziale
”Oświetlenie”). W pracy prezentuję trzy algorytmy cieniowania: proste, płaskie i Gourand.
Wykreślanie wielokątów cieniowanych płasko i prosto, nie rożni się od podstawowego algorytmu
wypełniania trójkątów i związane jest z przypisaniem jednolitego koloru dla wielokąta (w
cieniowaniu płaskim kolor ten jest wyznaczany w procesie oświetlenia).
W przypadku cieniowania Gourand, kolor jest obliczany dla każdego wierzchołka trójkąta, a
algorytm wyświetlania polega na interpolacji wartości koloru pomiędzy wierzchołkami i na tej
podstawie wyliczane są kolory na przeciwległych krawędziach. Następnie kolory te są
interpolowane pomiędzy krawędziami.
Przebieg działania algorytmu jest podobny do przebiegu rasteryzacji, z tą różnicą, źe wyznaczamy
nie położenie punktów krawędzi, a kolory składowe:
• Obliczam różnicę wysokości wierzchołków:
dy =y 1 -y 0
• Obliczam różnicę składowych kolorów (R,G,B) przypisanych do wierzchołków dla lewej
i prawej krawędzi:
dr LEWA =r 1 -r 0 , dg LEWA =g 1 -g 0 , db LEWA =b 1 -b 0 ,
dr PRAWA =r 2 -r 0 , dg PRAWA =g 2 -g 0 , db PRAWA =b 2 -b 0
• Wartość zmiany składowej kolorów dla lewej i prawej krawędzi jest równa:
dy
drLEWA
,
dy
dgLEWA
,
dy
dbLEWA
dy
drPRAWA
,
dy
dgPRAWA
,
dy
dbPRAWA
• na podstawie wartości zmiany składowej, mogę wyznaczyć wartość składowej dla obu
krawędzi, odpowiadającej określonej współrzędnej y:
r LEWA =r 0 +y
dy
drLEWA
, g LEWA =g 0 +y
dy
dgLEWA
, b LEWA =b 0 +y
dy
dbLEWA
34

35. r PRAWA =r 0 +y
dy
drPRAWA
, g PRAWA =g 0 +y
dy
dgPRAWA
, b PRAWA =b 0 +y
dy
dbPRAWA
• wyliczam odległość dx, pomiędzy pikselami znajdującymi się na przeciwległych
krawędziach, według wzoru wykorzystanego w algorytmie rasteryzowania
dx = x LEWA - x PRAWA = 





+
dy
dx
y LEWA
0x - 





+
dy
dx
yx PRAWA
0
• wyliczam zmianę wartości składowej koloru przypadająca na każdy piksel znajdujący
się miedzy krawędzi, dzieląc miedzy sobą różnice między składową kolorów dla
przeciwległych krawędzi i odległość w pikselach.
dr =
dx
rLEWA
, dg =
dx
gLEWA
, db =
dx
bLEWA
• dla każdego piksela znajdującego się pomiędzy krawędziami, wyliczam składową koloru
według wzoru:
r = r LEWA +i ·
dx
rLEWA
, rg = g LEWA +i ·
dx
gLEWA
, br = b LEWA +i ·
dx
bLEWA
gdzie i przyjmuje wartości całkowite od 0 do dx
35
x+
y+
(r 0 ,g 0 ,b 0 )
(r 1 ,g 1 ,b 1 ) (r 2 ,g 2 ,b 2 )
0
r LEWA =r 0 +y
dy
drLEWA
g LEWA =g 0 +y
dy
dgLEWA
b LEWA =b 0 +y
dy
dbLEWA
r PRAWA =r 0 +y
dy
drPRAWA
g
PRAWA =g 0 +y
dy
dgPRAWA
b
PRAWA =b 0 +y
dy
dbPRAWA

36. Rysunek17. Algorytm cieniowania Gourand.
1.6.6 Teksturowanie
Teksturowanie to proces opisywania materiału obiektu przy pomocy bitmapy.
Bitmapa może być użyta do symulowania skomplikowanych barw lub wzorów, którymi ma być
pokryty model lub tez do opisania sposobu interakcji ze światłem, bądź nieregularności powierzchni
jak np. wypukłości itp. W pracy opisuję najprostszy algorytm, polegający na modyfikacji koloru
wyświetlanego obiektu według tekstury:
Rysunek 18. Sześcian pokryty teksturą.
Podstawowym zagadnieniem związanym z przeprowadzaniem procesu teksturowania jest
mapowanie. Polega ono na przypisaniu do trójkąta odpowiednich współrzędnych bitmapy, która ma
go pokrywać. Każdy wielokąt ma przypisane współrzędne bitmapy, poziomą i pionową, zwane u i v,
co określamy mianem mapowania tekstury.
36
(0,0) (1,0)

37. Rysunek 19. Mapowanie tekstur.
Najprostszy rodzaj mapowania, to liniowe mapowanie tekstur. Liniowość związana jest tutaj z tzw.
procesem próbkowania, który dotyczy sposobu w jaki ma zostać przetworzona bitmapa w
momencie, kiedy rozmiar mapowanej powierzchni na ekranie, nie odpowiada rozmiarowi jaki na
nim przyjmie. Najprostszą metodą próbkowania jest próbkowanie liniowe, w którym kolor
poszczególnych pikseli jest dostosowywany do wyświetlanego obrazu przy pomocy wzoru
współczynnik próbkowania =
docelowawysokosc
zrodlowawysokosc
_
_
Algorytm teksturowania liniowego przyjmuje następujący przebieg:
• Obliczam różnicę wysokości wierzchołków:
dy =y 1 -y 0
• Obliczam różnicę koordynatów mapowania przypisanych do wierzchołków ,dla lewej i
prawej krawędzi:
du LEWA =u 1 - u 0 , dv LEWA =v 1 - v 0
du PRAWA =u 2 - u 0 , dv PRAWA =v 2 - v 0
• Wartość zmiany koordynatów mapowania dla lewej i prawej krawędzi jest równa:
dy
duLEWA
,
dy
dvLEWA
dy
duPRAWA
,
dy
dvPRAWA
37
u
v (0,1) (1,1)

38. • na podstawie zmiany wartości koordynatów, mogę wyznaczyć wartość koordynatów
mapowania dla obu krawędzi, odpowiadającej określonej współrzędnej y:
u LEWA =u 0 +y
dy
duLEWA
, v LEWA =v 0 +y
dy
dvLEWA
u PRAWA =u 0 +y
dy
duPRAWA
, v PRAWA =v 0 +y
dy
dvPRAWA
• wyliczam odległość dx, pomiędzy pikselami znajdującymi się na przeciwległych
krawędziach, według wzoru wykorzystanego w algorytmie rasteryzowania
dx = x LEWA - x PRAWA = 





+
dy
dx
y LEWA
0x - 





+
dy
dx
yx PRAWA
0
• wyliczam zmianę koordynatów mapowania przypadająca na każdy piksel, znajdujący się
miedzy krawędziami, dzieląc miedzy sobą różnice między wartościami koordynatów na
przeciwległych krawędziach i odległość w pikselach.
du =
dx
uu PRAWALEWA −
, dv =
dx
vv PRAWALEWA −
• dla każdego piksela znajdującego się pomiędzy krawędziami, wyliczam koordynaty
mapowania według wzoru:
u =u LEWA +i ·
dx
uu PRAWALEWA −
, v =v LEWA +i ·
dx
vv PRAWALEWA −
gdzie i przyjmuje wartości całkowite od 0 do dx
38
x+
y+
0
u LEWA =u 0 +y
dy
duLEWA
v LEWA
=v 0 +y
dy
dvLEWA
u PRAWA =u 0 +y
dy
duPRAWA
v
PRAWA =v 0 +y
dy
dvPRAWA
u =u LEWA +i ·
dx
uu PRAWALEWA −
v =v LEWA +i ·
dx
vv PRAWALEWA −
(u 0 ,v 0 )
(u 1 ,v 1 ) (u 2 ,v 2 )

39. Rysunek 20. Algorytm teksturowania.
1.6.7 Algorytm Bufor Z
Bufor Z to technika określania widoczności rasteryzowanych trójkątów. W trakcie
renderowania niektóre trójkąty mogą się przecinać, nachodzić na siebie itp. Określenie tego, która
część wielokąta jest widoczna, a która zasłonięta przez inny wielokąt, służy właśnie bufor Z
.Technika ta, polega na określeniu w jakiej odległości od płaszczyzny rzutowania leży
rasteryzowany piksel. Następnie wartość ta, jest sprawdzana w tablicy (bufor) i jeżeli jest mniejsza
niż odpowiadająca jej wartość, to jest zapisywana a piksel wyświetlany.
Ogólny schemat algorytmu:
• zdefiniowanie tablicy zawierającej współrzędne z, zwanej buforem Z, o wymiarach
szerokość x wysokość ekranu, zainicjowane wartościami maksymalnymi jakie może
przyjąć zmienna z.
• rasteryzujac trójkąt, dokonuj ę obliczenia współrzędnej z dla każdego piksela trójkąta
• sprawdzam, czy współrzędna z dla określonego adresu piksela, jest mniejsza niż
głębokość zapisana w tablicy. Jeżeli tak, to adresuję piksel określonym kolorem i
modyfikuję tablicę wartością obliczonej współrzędnej z przetwarzanego piksela.
Sam schemat obliczania współrzędnej z pikseli, jest analogiczny do obliczania współrzędnych
wyświetlanych pikseli w procesie rasteryzacji. Wyznaczam krawędzie trójkąta według
współrzędnych z (interpolując) i następnie na tej podstawie, dokonuję interpolacji liniowej
wszystkich pikseli znajdujących się między tymi krawędziami.
Jego przebieg zaprezentowałem poniżej:
• Obliczam różnicę wysokości wierzchołków:
dy =y 1 -y 0
• Obliczam różnice głębokości wierzchołków dla lewej i prawej krawędzi:
dz LEWA =z 1 -z 0 , dr PRAWA =z 2 -z 0
• Wartość zmiany głębokości dla lewej i prawej krawędzi jest równa:
dy
dzLEWA
,
dy
dzPRAWA
• na podstawie wartości zmiany głębokości, mogę wyznaczyć wartość współrzędnej z dla
obu krawędzi, odpowiadającej określonej współrzędnej y:
39

40. z LEWA =z 0 +y
dy
dzLEWA
, z PRAWA =z 0 +y
dy
dzPRAWA
• wyliczam odległość dx pomiędzy pikselami znajdującymi się na przeciwległych
krawędziach, według wzoru wykorzystanego w algorytmie rasteryzowania
dx = x LEWA - x PRAWA = 





+
dy
dx
y LEWA
0x - 





+
dy
dx
yx PRAWA
0
• wyliczam zmianę wartości współrzędnej z, przypadająca na każdy piksel znajdujący się
miedzy krawędzi, dzieląc miedzy sobą różnicę miedzy wartościami współrzędnej z dla
przeciwległych krawędzi i odległość w pikselach.
dz =
dx
zz PRAWALEWA −
• dla każdego piksela znajdującego się pomiędzy krawędziami, wyliczam wartość
głębokości według wzoru:
z = z LEWA +i ·
dx
zz PRAWALEWA −
gdzie i przyjmuje wartości całkowite od 0 do dx
40
x+
y+
0
z LEWA =z 0 +y
dy
dzLEWA
z PRAWA =z 0 +y
dy
dzPRAWA
z = z LEWA +i ·
dx
zz PRAWALEWA −
(x 0 ,y 0 ,z 0 )
(x 1 ,y 1 ,z 1 ) (x 2 ,y 2 ,z 2 )

41. Rysunek 21. Algorytm bufor Z.
41

42. Rozdział 2
IMPLEMENTACJAALGORYTMÓW GRAFIKI 3D CZASU
RZECZYWISTEGO
2.1 APLIKACJA KREŚLĄCA GRAFIKĘ 3D W CZASIE RZECZYWISTYM
2.1.1 Charakterystyka aplikacji
W drugiej części pracy prezentuję charakterystykę i schemat działania aplikacji kreślącej
grafikę 3d w czasie rzeczywistym. Aplikacja ta, stanowi praktyczną implementację zagadnień i
algorytmów przedstawionych w części pierwszej. Składa się na nią zbiór definicji, struktur i
wywołań funkcji, realizujących w sposób programowy obliczenia i przekształcenia, kreśląc za ich
pomocą obraz. Wspomaganie, poprzez biblioteki umożliwiające dostęp sprzętowy, jest realizowane
tylko do obsługi ekranu i klawiatury. Aplikacja ma na celu prezentację poruszanych problemów i
dlatego, zawiera jedynie proste i schematyczne implementacje przedstawionych algorytmów.
Aplikacja ta, została napisana na podstawie rozwiązań, zawartych w książce „Triki
najlepszych programistów gier 3D. Vademecum profesjonalisty” autorstwa Andre LaMothe.
Napisana i skompilowana w środowisku Microsoft Visual Studio 2005 EDU z użyciem bibliotek
Direct X SDK 7 i 9.Kod źródłowy został zamieszczony w załączniku.
Jej podstawowe możliwości:
• możliwość definiowania modeli 3d (ale nie wczytywania)
• swobodna kamera -możliwość poruszania się po scenie
• możliwość animowania obiektów sceny przy pomocy takich przekształceń jak: obrót,
skalowanie, przemieszczenie.
• implementacja prostego oświetlenia w postaci światła punktowego i kierunkowego
• wykreślanie siatki wielokątów
• wykreślanie trójkątów z użyciem algorytmów cieniowania prostego, płaskiego i Gourand
• prosta implementacja tekstur (ograniczone możliwości wczytywania)
• bufor Z (prosta implementacja przez interpolację)
42

43. Rysunek 22. Screen z działającej aplikacji
2.1.2 Budowa aplikacji
Aplikacja została napisana w oparciu o środowisko Windows, z użyciem biblioteki Direct X
do obsługi ekranu i klawiatury. Działa w trybie okienkowym.
Zawiera zdefiniowaną listę modeli 3d. Został zaimplementowany kompletny opisany potok
geometrii, umożliwiający przeprowadzanie animacji w lokalnym układzie współrzędnych
(skalowanie, obrót), przemieszczenia, swobodne, interaktywne definiowanie pozycji kamery przez
użytkownika(symulacja poruszania się po scenie).Po przekształceniu do współrzędnych kamery,
następuje usuwanie zbędnej geometrii w postaci usuwania modeli poza kamerą i usuwanie ścian
zwróconych tyłem. Następnie trójkąty są wstawianie na listę renderowania, która zapewnia sprawne
posługiwanie się geometrią zawartą w scenie. Symulacja oświetlenia, jest przeprowadzona przy
użyciu światła punktowego i kierunkowego. W celu bezproblemowego wyświetlania geometrii,
zawarto przycinanie w przestrzeni obiektu trójkątów, wykraczających poza przednią płaszczyznę
obcinająca. Po wykonaniu rzutowania na płaszczyznę perspektywy i ekranu , wykonuje
renderowanie, w postaci wykreślania siatki wielokątów, bądź z użyciem cieniowania płaskiego lub
Gourand, i z użyciem tekstur i bufora Z.
W następnym podrozdziale, poruszam zagadnienia związane z obsługa okna i ekranu w środowisku
Windows, ze wspomaganiem dostępu do klawiatury i ekranu przy pomocy biblioteki Direct X.
Ostatni podrozdział zawiera spis wywołań funkcji zawartych w zaimplementowanej aplikacji .
43

44. 2.2 PROGRAMOWANIE W WINDOWS Z UŻYCIEM BIBLIOTEKI DIRECT X
2.2.1 System Windows
Windows to rodzina systemów operacyjnych firmy Microsoft, która postawiła sobie za cel
dostarczenie klientom tzw. przyjaznego oprogramowania. Dzięki temu, że są łatwe w obsłudze i
efektywne, systemy te zdominowały rynek komputerów dostępnych dla przeciętnego użytkownika.
Posiadają następujące cechy:
• wykorzystują graficzny interfejs do komunikacji z użytkownikiem ,wyświetlając aplikacje w
przydzielonych fragmentach ekranu zwanych oknami (stad nazwa systemu Windows ang.
okna)
• obsługują pracujące aplikacje w trybie wielozadaniowym z wywłaszczeniem, umożliwiając
prace wielowątkową, co oznacza że to system jest odpowiedzialny za obsługę i przydział
zasobów dla aplikacji i umożliwia on, realizację przez użytkownika wielu zadań naraz
• stosuje koncepcje Plug and Play co oznacza, że system sam szuka i konfiguruje sterowniki
potrzebne do zainstalowania i uruchomienia nowego sprzętu, odciążając tym samym
użytkownika
2.2.2 Programowanie w modelu Win32
Do dnia dzisiejszego, na rynek trafiło kilka generacji systemu Windows ,ja jednak skupię się
na opisie modelu programowania dla wersji 32 bitowej, opartym na wykorzystaniu tzw. API (skrót
ang. Application Programming Interface) czyli interfejsie programowania aplikacji. Windows API,
to zbiór wywołań funkcji, służących do obsługi praktycznie każdego aspektu związanego z obsługą
systemu jak i sprzętu. Dzięki niemu możemy napisać i uruchomić program, obsłużyć urządzania
wejścia – wyjścia takie jak klawiatura, ekran, drukarka, wczytać pliki itp.
Działanie programu w systemie Windows, oparte jest o tzw. model obsługi zdarzeń, w którym
komunikaty umieszczane są w kolejce komunikatów przez system, a następnie wysyłane do
odpowiedniej aplikacji i tam obsłużone.
Funkcja WinMain
Punktem startowym każdej aplikacji Windows jest funkcja główna WinMain. To do niej
trafiają komunikaty z systemu i są dalej rozsyłane do odpowiednich procedur. Przy jej uruchamianiu
jest tworzona i rejestrowana klasa okna. Okno to obiekt i oznacza każdy element, który ma
właściwości sterujące tzn. takie, przez które użytkownik może się komunikować z programem, i
który przybiera postać widoczną na ekranie. Okno otrzymuje identyfikator i można mu nadać
parametry związane ze stylem i zasobami, dzięki czemu można mu przypisać rożne rodzaje
kursorów, pędzli, menu i funkcje obsługi zdarzeń. Następnie okno zostaje zainicjowane z użyciem
funkcji CreateWindowEx, której parametry zawierają miedzy innymi klasę , nazwę oraz pozycje i
rozmiar okna.
W funkcji WinMain znajduje się pętla obsługi komunikatów, poprzez którą są one rozsyłane do
procedur je obsługujących. W prezentowanej przeze mnie aplikacji, standardowa funkcja obsługi
komunikatów GetMessage, została zastąpiona przez funkcję PeekMessage, co umożliwia ciągłe
wykonywanie pętli kreślenia obrazu (funkcja GetMessage uruchamia wykonywanie kodu dopiero po
otrzymaniu komunikatu).
44

45. 2.2.3 Biblioteka Direct X
Direct X, to warstwa oprogramowania działająca w systemie Windows ,która umożliwia
niskopoziomowy dostęp do urządzeń multimedialnych takich jak karta graficzna, karta dźwiękową,
urządzenia wejścia (klawiatura, mysz, joystick),urządzania sieciowe, dzięki czemu, możliwe jest
znaczne przyspieszenie działania aplikacji wykorzystujących te urządzenia.
Jej istotną cechą, jest oddzielenie warstwy oprogramowania od obsługi sprzętu. Dzięki temu
,programiści mogą skupić się na pisaniu programów, bez konieczności pisania obsługi dla urządzeń
pochodzących od rożnych producentów, ponieważ do obsługi urządzeń wystarczy znajomość
wywołań funkcji .Resztę dostarczają producenci urządzeń ,i lub Microsoft (uniwersalne sterowniki) .
Biblioteka ta, została napisania w celu umożliwienia programistom pisania gier dla systemu
Windows i okazała się bardzo efektywna, dzięki czemu, platforma Windows plus Direct X
zdominowała rynek gier dla komputerów klasy PC.
Opis budowy
W tej pracy używam Direct X w wersji 7.0, dobrze zintegrowanej z modelem programowania
Win32 i umożliwiającej bezpośredni dostęp do karty graficznej. Najciekawsze komponenty
wchodzące w skład biblioteki:
• DirectDraw - moduł obsługi wyświetlania grafiki , odpowiedzialny za wyświetlanie obrazu i
obsługę map bitowych
• DirectSound - moduł odpowiedzialny za obsługę dźwięku w postaci cyfrowej
• DirectSound3D – moduł służy do imitowania dźwięku przestrzennego
• DirectMusic - obsługa odtwarzania plików MIDI
• DirectShow - umożliwia przetwarzanie strumieni audio i video
• DirectInput - obsługa urządzeń wejścia takich jak: myszka ,klawiatura, joystick
• DirectPlay - moduł umożliwiający tworzenie połączeń sieciowych
• Direct3DRM - wysokopoziomowy interfejs 3d
• Direct3DIM - niskopoziomowe wsparcie dla funkcji wyświetlających grafikę 3d
2.2.4 Programowanie przy wykorzystaniu Direct X
Technologia COM
Direct X jest biblioteką programistyczną, która udostępnia dostęp do swoich obiektów
poprzez tzw. technologię Com. Technologia Com (ang. Component Object Model -model
komponentów obiektowych), to model programistyczny, który ma umożliwić komunikację
międzyprocesową pomiędzy komponentami oprogramowania, przy pomocy interfejsów binarnych.
W modelu tym, nie jest ważny zastosowany język. Wewnętrzna implementacja funkcji, jest
oddzielona od wywołujących ją interfejsów, a cała komunikacja odbywa się przy wykorzystaniu
tychże interfejsów. Każdy obiekt COM dziedziczy po interfejsie IUnknown, który jest bazowym dla
tego
standardu i składa się z trzech nadpisywalnych wywołań funkcji:
45

46. • AddRef
• Release
• QueryInterface
Programowanie odbywa się przy pomocy interfejsów. Inicjujemy obiekt COM i dzięki funkcji
QueryInterface otrzymujemy dostęp do wirtualnych wywołań odpowiednich funkcji. Funkcje
AddRef i Realase, służą odpowiednio zliczaniu instancji obiektu i zwalnianiu obiektu, dzięki czemu,
obiekty COM są automatycznie usuwane, kiedy są już nieużywane.
Użycie DirectDraw do rasteryzowania grafiki
Aplikacja wykorzystuje komponent DirectDraw do adresowania pamięci ekranu, dzięki
czemu, możliwe jest obsłużenie każdego piksela ekranu w bardzo szybki sposób, co umożliwia
napisanie własnego kodu rasteryzującego. Aplikacja jest napisana w wersji okienkowej, co oznacza
że rozdzielczość i głębia koloru jest narzucona przez system Windows. Trzeba również wziąć pod
uwagę, że okno nie zajmuje całej powierzchni ekranu i dlatego potrzebne będzie przycinanie widoku
do wielkości okna.
Do rasteryzowania obrazu wykorzystuję cztery interfejsy pochodzące z DirectDraw:
• IUnknown - interfejs bazowy wspólny dla technologii COM. Składa się z trzech
nadpisywalnych wywołań funkcji AddRef, Release, QueryInterface.
• Główny interfejs DirectDraw, to IDirectDraw, który jest konieczny do wywołania innych
interfejsów i obsługi karty graficznej.
• IdirectDrawSurface, to interfejs obsługi widoku ekranu(powierzchni wyświetlania). Są dwa
rodzaje wyświetlanych powierzchni: Primary i Secondary - przednia i tylnia. Przednia
reprezentuje aktualny wyświetlany obraz, tylnia służy do tymczasowego kreowania obrazu
(jako wyniku działania programu) i może być zamieniana z przednia, co umożliwia
animację.
• IdirectDrawClipper, to interfejs służący przycinaniu powierzchni rasteryzowanych lub
bitmap do określonych w programie. Zastosowanie interfejsu powoduje uproszczenie i
przyspieszenie operacji przycinania.
Użycie modułu DirectInput do obsługi klawiatury
• Inicjacja interfejsu IDirectInput odpowiedzialny za obsługę urządzeń wejścia
• IDirectInputDevice - interfejs obsługi konkretnego urządzenia, udostępnia funkcje
zwracające informacje od urządzenia
46

47. 2.3 Spis funkcji
Działanie aplikacji kreśląca grafikę 3d czasu rzeczywistego polega na ciągłym
wykonywaniu potoku renderowania i wykreślaniu obrazu trójwymiarowej sceny. Główna pętla
działania jest oparta o pętle komunikatów funkcji WinMain. Działanie programu składa się z trzech
etapów. Wczytania zasobów, ciągłego wykonywania pętli przetwarzania obrazu, zakończenia
działania i zwolnienia zasobów. Najważniejsze elementy aplikacji to:
• funkcje związane z obsługą biblioteki Direct X
• funkcje matematyczne będące podstawa przetwarzania danych
• struktury i funkcje odpowiedzialne za definiowanie i przechowywanie informacji związanej
z trójwymiarowymi modelami
• funkcje przekształceń geometrii składające się na potok geometrii
• funkcje i struktury związane z procesem oświetlenia
• funkcje związane z implementacja algorytmów renderowania
2.3.1 Szkielet aplikacji
Główne funkcje, o które oparta została aplikacja:
• Zasoby_Inicjuj - inicjacja zasobów Direct X, inicjacja modeli, swiateł, kamery, wczytanie
tekstur, inicjacja tablicy bufora Z
• Glowna_Petla - zawarty cały potok renderowania
• Zasoby_Zwolnij - zwalnia zasoby Direct X
Glowna petla dzialania zostala zsynchronizowna w celu utrzymania stalej szybkosc wyswietlania
obrazu przy pomocy funkcji:
• czas_pobierz - pobiera czas –wykorzystywana przez pozostałe dwie funkcje
• czas_poczatek - rozpoczyna liczenie czasu
• czas_czekaj - czeka 30 milisekund, syschronizacja do 30 klatek na sekunde
2.3.2 Użycie Direct X do obsługi ekranu i klawiatury
Adresowanie pamięci ekranu z zastosowaniem DirectDraw
Schemat wywołań funkcji do obsługi DirectDraw wygląda następująco:
• Wywołanie funkcji ddraw_inicjuj na etapie inicjacji zasobow
47

48. • utworzenie obiektu DirectDraw i dostęp do interfejsu DirectDraw7. Służy do tego funkcja
DirectDrawCreateEx, która zwraca wskaźnik LPDIRECTDRAW7 lpdd.
• ustawiam opcje trybu okienkowego poprzez wywołanie funkcji SetCooperativeLevel
interfejsu DDraw7
• zainicjalizowanie głównej powierzchni wyświetlania przy pomocy funkcji, wywołanej ze
wskaźnika lpdd – CreateSurface, zwracającej wskaźnik LPDIRECTDRAWSURFACE7
lpddsprimary
• utworzenie drugiej powierzchni tzw. zmiennej backbuffer, służącej adresowaniu kreślonego
obrazu, poprzez wywołanie funkcji ddraw_utworz_powierzchnie, zwracajacej wskaznik
LPDIRECTDRAWSURFACE7 lpddsback
• utworzenie powierzchni przycinania dla głównej i tylniej powierzchni. Wskaźniki
LPDIRECTDRAWCLIPPER odpowiednio lpddclipperwin i lpddclipper .
Rasteryzacja z uzyciem DirectDraw
Sposób dokonania rasteryzacji z użyciem DDraw.
W celu dokonania rasteryzacji należy zablokować powierzchnie wykreślania przy pomocy funkcji.
• draw_blokuj_powierzchnie_robocza
Następnie dokonuję zapisu danych do tylniej powierzchni i zamiany informacji znajdującej się w
pamięci z użyciem funkcji:
• ddraw_zamien()
Odblokowuje powierzchnię
• ddraw_odblokuj_powierzchnie_robocza()
Zasoby DirectDraw są zwalniane przy pomocy funkcji:
• ddraw_zwolnij.
Klawiatura DirectInput
2.3.3 Funkcje matematyczne
Do przechowywania informacji o położeniu wierzchołków, posługuję się strukturą typu
WEKTOR , umożliwiającą przechowywanie trzy lub czterowymiarowych współrzędnych.
48

49. Funkcje, które służą do definiowania wektorów:
• mat_wektor_buduj - oblicza wektor na podstawie podanych punktów
• mat_dodaj_wektory – sumuje ze sobą wektory
• mat_wektor_kopiuj - kopiuje wektor pomiędzy zmiennymi
Do przeprowadzania obliczeń z wykorzystaniem wektorów, służą funkcje:
• mat_wektor_iloczyn_skalarny - zwraca wartość iloczynu skalarnego wektorów
• mat_wektor_iloczyn_wektorowy - zwraca wektor normalny prostopadły do pary wektorów.
Funkcje te, wykorzystane są do określenia kierunku, w którym zwrócone są powierzchnie w takich
działaniach jak usuwanie ścian zwróconych tyłem i do obliczania natężenia oświetlenia.
Dodatkowo wykorzystuje funkcje:
• mat_wektor_dlugosc - do obliczania długości wektora
• mat_wektor_normalizuj - normalizacja wektora
W potoku geometrii, do przeprowadzenia przekształceń takich jak obrót, skalowanie i przesuniecie
używam struktury MACIERZ.
Funkcje służące do działań na macierzach:
• macierz_jednostkowa - służy do inicjowania zawartości macierzy wartościami macierzy
jednostkowej
• mat_macierz_inicjuj -wypełnia macierz argumentami
• mat_mnozenie_wektor_macierz –funkcja używana przy przekształceniach wierzchołków
• mat_mnozenie_macierzy - służy do składania macierzy przekształceń
Do szybkiego wyznaczania wartości funkcji trygonometrycznych sinus i cosinus, przy obliczaniu
przekształceń związanych z obrotem, wykorzystuję funkcje:
• mat_oblicz_tablice_sin_cos - tworzy tablicę sinusów i cosinusów
• mat_przyb_sin- zwraca wartość sinusa dla danego kąta
• mat_przyb_cos- zwraca wartość cosinusa dla danego kąta
49

50. 2.3.4 Zdefiniowanie modeli
W aplikacji do posługiwania się trójwymiarowymi modelami, zdefiniowałem struktury typu
MODEL3D.Glowne elementy struktury to:
• lista wierzchołków, służąca do przechowywania struktury wierzchołków bazowych
• lista wierzchołków roboczych która służy do przechowywania danych pochodzących z
przekształceń wierzchołków
• lista trojkątów zdefiniowanych przy pomocy struktury TROJKAT
• lista wektorów normalnych, opartych o wierzchołki, potrzebna do przeprowadzenia
cieniowania typu Gourand
W aplikacji wykorzystuję cztery modele : model płaszczyzny, szescianu, walca i kuli.
Informacje definiujące te modele są zapisane w funkcjach:
• inicjujSzescian
• inicjujWalec
• inicjujKula
• inicjujPodloga
Do grupowania obiektów budujących scenę, używam struktury LISTA_OBIEKTOW, dzięki
czemu, uzyskuje łatwy dostęp do wykorzystanych elementów. Do skopiowania zmiennych,
przechowujących dane modeli, do listy obiektów służy funkcja:
• dodaj_obiekt_listy_obiektow
Lista renderowania, to zbiór wielokątcw, z których każdy jest osobnym elementem niezależnym od
pozostałych, zdefiniowana przy pomocy struktury LISTA_RENDEROWANIA .
Strukura ta zawiera elementy:
• Trójkąty znajdujące się na liście zdefiniowano przy pomocy struktury
TROJKAT_POWIERZCHNIA .
Każdy trójkąt zawiera takie informacje jak:
• kolor
• wektor normalny
• dlugość wektora normalnego
• lista wierzchołków
Każdy wierzchołek na liscie wierzchołków jest opisany przez strukturę typu WIERZCHOLEK i
może zawierać takie informacje jak:
• kolor
50

51. • wektor normalny
• dlugość wektora normalnego
• mapowanie tekstur zapisane w strukturze UV
Funkcja wykorzystywana do zerowania listy renderowania w kolejnych przebiegach pętli:
• lista_renderowania_zeruj
2.3.5 Potok geometrii
Pierwsze działanie w potoku geometrii, związane jest z prostymi przekształceniami :
skalowaniem, obrotem, przemieszczaniem. Przy pomocy zmodyfikowanych zmiennych tworzę
macierz przekształcenia
• obrot_skalowanie_przesuniecie_buduj_macierz – buduję macierz na podstawie wektorów
obrotu i przemieszczenia oraz zmiennej skalowania
• przeksztalc_model_lokalnie_globalnie - przekształcam wierzchołki danego modelu, dzięki
czemu, tworzona jest dynamicznie się zmieniająca scena.
Kolejne przekształcenie na liście związane jest z obiektem kamery.
Obiekt kamery został bardzo uproszczony i charakteryzuje się polem widzenia 90º i odległością
rzutowania 1.Kamera zostala zdefiniowana przy pomocy struktury KAMERA.
Podstawowe dane definiujące kamerę, zostały zapisane w funkcji:
• kamera_inicjuj
Zaimplementowana obsługa klawiatury, umożliwia wpływanie na zmienne definiujące położenie i
kąty kamery, przy pomocy zmiennych pozycja i kąty, które są modyfikowane przez użytkownika w
czasie działania programu przy pomocy klawiszy:
A,S,D,W,( kąty), oraz klawiszy kursora i klawiszy PageUp i PageDown (pozycja).
Funkcje związane z usuwaniem zbędnej geometrii:
• usun_obiekty_poza_kamera - usuwanie obiektów poza widokiem kamery
• usun_trojkaty_zwrocone_tylem_wstaw_na_liste- usuwa ściany zwrócone tyłem i wstawia
wielokąty na listę renderowania
Funkcje przekształceń wielokątów według kolejnych układów współrzędnych, związanych z
obiektem kamery:
• wsp_kamery - przekształcenie do współrzędnych kamery
• wsp_perspektywy - przekształcenie do współrzędnych perspektywy
• wsp_ekranu- przekształcenie do współrzędnych ekranu
Operacja przycinania trójkątów:
• przycinanie_trojkatow-przycina trójkąty, które wystają poza przednią plaszczyznę
obcinającą
51

52. 2.3.6 Oświetlenie
Oświetlenie, to operacja polegająca na zdefiniowaniu źródeł światła w scenie, obliczeniu ich
globalnego wpływu na obiekt, a następnie, na zmodyfikowaniu informacji o sposobie wyświetlania
obiektu i jego barwie. Struktura którą wykorzystuje to SWIATLO. Zawiera informacje o rodzaju
swiatła, kolorze itp.Do definicji i wczytania oświetlenia służy funkcja:
• swiatlo_inicjuj
Funkcja odpowiedzialna za liczenie światła:
• oswietlenie
2.3.7 Renderowanie
Ostateczny efekt działania aplikacji związany jest z funkcja renderowania. Jest to proces
który integruje w sobie działania związane z buforowaniem, teksturowaniem i cieniowaniem przy
wykreślaniu wielokątów.
Buforowanie
Każda funkcja renderowania zawiera w sobie algorytm buforowania.
Struktura służąca do przechowywanie informacji o głębokości wykreślanych pikseli BUFORZ.
Funkcje:
• buforZ_inicjuj - inicjacja tablicy zawierającej informacje nt. współrzędnej z pikseli
• buforZ_zwolnij - zwalnia zasoby
• buforZ_wyczysc - czyszczenie tablicy
Do procesu teksturowania potrzebne jest wczytanie bitmapy:
• wczytaj_teksture
Zastosowane algorytmy renderowania, umożliwiają wykreślanie szkieletów, renderowanie płaskie i
z zastosowaniem cieniowania Gourand, z zastosowaniem tekstur. Przełączanie trybu, pomiędzy
wyświetlaniem szkieletów a rysowaniem wypełnionych trójkątów, odbywa się przy użyciu klawisza
R. Funkcje stosowane w procesie renderowania:
• rysuj_szkielet – wykreśla szkielet siatki wielokątow
• przytnij_linie – funkcja przycinania lini przy wykreślaniu siatki wielokątow
52

53. • rysuj_linie – wykreśla przycięte linie
• renderuj- główna funkcja renderowania
• void rysuj_trojkat_gora-renderowanie trójkątów o odwróconej podstawie, cieniowanych
plasko
• void rysuj_trojkat_dol- renderowanie trójkątów o poziomej podstawie, cieniowanych plasko
• void rysuj_trojkat_gora_g-renderowanie cieniowanie Gourand , trojkąt odwrocony
• void rysuj_trojkat_dol_g-renderowanie cieniowanie Gourand, trojkąt o podstawie poziomej
Funkcje renderujące z zastosowaniem teksturowania:
• rysuj_trojkat_gora_t-renderowanie trójkątów o odwróconej podstawie, cieniowanych plasko
z użyciem tekstury
• rysuj_trojkat_dol_t- renderowanie trójkątów o poziomej podstawie, cieniowanych plasko z
użyciem tekstury
• void rysuj_trojkat_gora_gt- renderowanie trójkątów o odwróconej podstawie, cieniowanych
metodą Gourand z użyciem tekstur
• void rysuj_trojkat_dol_gt - renderowanie trójkątów o poziomej podstawie, cieniowanych
metodą Gourand z użyciem tekstury
53

54. Spis ilustracji
Rysunek 1.Kartezjański układ współrzędnych......................................................................................8
Rysunek 2. Trójkąt prostokątny.............................................................................................................9
Rysunek 3. Wektor..............................................................................................................................10
Rysunek 4. Iloczyn skalarny wektorów u i v.......................................................................................12
Rysunek 5. Iloczyn wektorowy dwóch wektorów u ...........................................................................12
Rysunek 6. Model 3d wyświetlany w postaci szkieletu(siatka wielokątów).......................................17
Rysunek 7.Pole widzenia kamery definiuje ostrosłup widzenia.........................................................21
Rysunek 8. Test sfer otaczających.......................................................................................................22
Rysunek 9. Rzutowanie na płaszczyznę perspektywy.........................................................................23
Rysunek 10. Współrzędne ekranu i współrzędne perspektywy. .........................................................24
Rysunek 11. Promienie światła kierunkowego są do siebie równolegle ............................................27
Rysunek 12. Światło punktowe...........................................................................................................28
Rysunek 13. Modele wyświetlane z zastosowaniem cieniowania płaskiego......................................28
Rysunek 14. Modele wyświetlane z zastosowaniem cieniowania Gourand........................................29
Rysunek 15. Algorytm wypełniania trójkątów....................................................................................33
Rysunek 16. Podział trójkąta w algorytmie wypełniania trójkątów....................................................33
Rysunek17. Algorytm cieniowania Gourand......................................................................................36
Rysunek 18. Sześcian pokryty teksturą...............................................................................................36
Rysunek 19. Mapowanie tekstur.......................................................................................................37
Rysunek 20. Algorytm teksturowania.................................................................................................39
Rysunek 21. Algorytm bufor Z............................................................................................................41
Rysunek 22. Screen z działającej aplikacji..........................................................................................43
54

55. Bibliografia
1. Andre LaMothe, Triki najlepszych programistów gier 3D. Vademecum profesjonalisty,
Helion 2004/04
2. Andre LaMothe, Tricks of the Windows Game Programming Gurus (2nd Edition), SAMS
2002
3. Mccuskey Mason, Programowanie Gier w DirectX ,Wydawnictwo MIKOM 2003
4. Stephen Prata, Język C. Szkoła programowania. WydanieV , Helion 2006
5. Charles Petzold, Programowanie Windows Petzold Wydanie 2 , WydawnictwoRM 1999
6. Fletcher Dunn, Ian Parberry, 3D Math Primer for Graphics and Game Development,
Wordware Publishing, Inc. 2002
7. Eric Lengyel, Mathematics for 3D Game Programming & Computer Graphics , 2nd edition,
Charles River Media 2004
8. Steven Eliott, Philip Miller , 3D Studio MAX. Doskonałość i precyzja,
9. Wikipedia, http://pl.wikipedia.org
Ą ę źżśćł ą ńó
55