Darmowe kursy Online » Biblioteki C++ » Kurs OpenGL, C++

Biblioteki C++

Światła i materiały

[lekcja] Rozdział 13. Model oświetlenia w bibliotece OpenGL; parametry źródeł światła; parametry modelu oświetlenia; właściwości materiałów; śledzenie kolorów; wektory normalne; kwadryki; pięć przykładowych programów.

Model oświetlenia zastosowany w bibliotece OpenGL opiera się na trzech rodzajach światła. Pierwszy rodzaj to światło otaczające (ang. ambient light), które nie pochodzi z żadnego konkretnego kierunku i równomiernie oświetla wszystkie elementy sceny 3D. Drugim rodzajem światła jest światło rozproszone (ang. diffuse light), które pada na obiekt z określonego kierunku, ale jest na nim rozpraszane we wszystkich kierunkach. Ostatnim rodzajem światła obsługiwanego przez OpenGL jest światło odbite (ang. specular light), zwane także światłem kierunkowym, które pada na obiekt w określonym kierunku i odbijane jest także w ściśle określonym kierunku.
W bibliotece OpenGL ze światłem ściśle związane jest pojęcia materiałów określające właściwości oświetlanych obiektów. Właściwości materiału, poza reakcją na opisane wyżej trzy rodzaje światła, uwzględniają także możliwość emitowania światła.

Włączanie oświetlenia

Domyślnie biblioteka OpenGL nie wykonuje obliczeń związanych z oświetleniem. Uruchomienie oświetlenia wymaga wywołania funkcji glEnable z parametrem GL_LIGHTING. Ponadto należy włączyć bufor głębokości. Nie jest to wprawdzie konieczne ale znacząco wpływa na realizm generowanej sceny 3D. Oczywiście wyłączenie oświetlenia sprowadza się do wywołania funkcji glDisable z parametrem GL_LIGHTING.

Włączanie źródła światła

Specyfikacja OpenGL określa, że minimalną ilość źródeł światła, którą musi obsługiwać każda implementacja biblioteki wynosi 8. Każde źródło światła ma swój unikatowy numer oznaczony stałą GL_LIGHTi, gdzie i zawiera się w przedziale [0, 7]. Ilość źródeł światła obsługiwanych przez daną implementację biblioteki OpenGL zwraca wywołanie funkcji glGetIntegerv z parametrem GL_MAX_LIGHTS. Alternatywnie numery źródeł światła można określić przy pomocy wyrażenia: GL_LIGHTi = GL_LIGHT0 + i. Jest to szczególnie przydatne przy źródłach światła o numerach wyższych niż 7, bowiem pliki nagłówkowe biblioteki OpenGL standardowo nie zawierają stosownych stałych. Zasada ta odnosi się do każdej funkcji korzystającej z numeru źródła światła.
Poszczególne źródła światła włączamy i wyłączamy przy użyciu funkcji glEnable/glDisable z parametrem określającym numer źródła światła.

Parametry źródła światła

Parametry każdego ze źródła światła można modyfikować niezależnie od pozostałych źródeł światła. Służą do tego funkcje z grupy glLight, które można podzielić na dwie podgrupy. Pierwsza pozwala na modyfikację parametrów źródła światła określanych pojedynczą wartością; druga grupa funkcji przyjmuje wskaźniki na tablice z wartościami parametrów, przy czym można ich także używać do modyfikacji parametrów źródła światła określanych pojedynczą wartością.
Zmianę parametru źródła światła określanego pojedynczą wartością umożliwiają funkcje:

void glLightf( GLenum light, GLenum pname, GLfloat param )
void glLighti( GLenum light, GLenum pname, GLint param )

Natomiast zmianę parametru źródła światła określanego tablicą wartości umożliwiają funkcje:

void glLightfv( GLenum light, GLenum pname, const GLfloat * params )
void glLightiv( GLenum light, GLenum pname, const GLint * params )

Parametr light określa numer źródła światła, którego parametry chcemy zmienić. Numer źródła światła określają omówione już stałe GL_LIGHTi. Parametr pname określa parametr źródła światła, który chcemy zmodyfikować. Dopuszczalne są następujące wartości tego parametru:

GL_AMBIENT - wartości składowych RGBA światła otaczającego,
GL_DIFFUSE - wartości składowych RGBA światła rozproszonego,
GL_SPECULAR - wartości składowych RGBA światła odbitego,
GL_POSITION – czteroelementowy wektor (x, y, z, w), którego interpretacja zależy od wartości w; jeżeli w ma wartość 1, oznacza to, że trzy pierwsze współrzędne wektora określają położenie źródła światła; jeżeli natomiast w ma wartość 0, to źródło światła jest światłem kierunkowym, a jego promienie padają w kierunku zdefiniowanym przez trzy pierwsze współrzędne wektora,
GL_SPOT_DIRECTION - znormalizowany (długości 1) trójwspółrzędny wektor określający kierunek reflektora,
GL_SPOT_EXPONENT - wykładnik tłumienia kątowego reflektora; dopuszczalne są wartości z przedziału [0, 128],
GL_SPOT_CUTOFF - kąt odcięcia reflektora; dopuszczalne są wartości z przedziału [0, 90] oraz 180,
GL_CONSTANT_ATTENUATION - stały współczynnik tłumienia światła,
GL_LINEAR_ATTENUATION - liniowy współczynnik tłumienia światła,
GL_QUADRATIC_ATTENUATION - kwadratowy współczynnik tłumienia światła.

Wspomniane wyżej reflektory to po prostu światło kierunkowe, którego promienie rozchodzą się w przestrzeni ograniczonej stożkiem o wierzchołku znajdującym się w źródle światła. Połowę kąta rozwarcia stożka światła określa parametr GL_SPOT_CUTOFF (patrz rysunek 1). Wszystkie obiekty sceny znajdujące się poza stożkiem światła reflektora pozostają nieoświetlone jego światłem.

Rysunek 1. Parametr GL_SPOT_CUTOFF

Parametr GL_SPOT_EXPONENT umożliwia regulację stopnia skupienia światła reflektora. Jest to wykładnik potęgi wyrażenia stanowiącego kosinus kąta pomiędzy kierunkiem padania światła, a kierunkiem od źródła światła do wierzchołka oświetlanego elementu sceny. Domyślna wartość 0 oznacza brak tłumienia kątowego, czyli równomierne rozchodzenie się światła we wszystkich kierunkach.
Trzy ostatnie parametry źródła światła określają współczynnik tłumienia światła dany wzorem:

Wzór

gdzie d oznacza odległość wierzchołka od źródła światła, a stałe ac, al i aq odpowiednio stały (GL_CONSTANT_ATTENUATION), liniowy (GL_LINEAR_ATTENUATION) i kwadratowy (GL_QUADRATIC_ATTENUATION) współczynnik tłumienia. Przy domyślnych ustawieniach parametrów źródeł światła wartość współczynnika tłumienia wynosi 1, co oznacza, że intensywność strumienie światła nie zależy od odległości pomiędzy jego źródłem a wierzchołkiem oświetlanego obiektu.
Zestawienie domyślnych wartości parametrów źródła światła GL_LIGHT0 zawiera tabela 1. Te same dane dla pozostałych źródeł światła przedstawia tabela 2.

Tabela 1: Domyślne parametry źródła światła GL_LIGHT0

parametr źródła światła	wartość
`GL_AMBIENT`	(0, 0, 0, 1)
`GL_DIFFUSE`	(1, 1, 1, 1)
`GL_SPECULAR`	(1, 1, 1, 1)
`GL_POSITION`	(0, 0, 1, 0)
`GL_SPOT_DIRECTION`	(0, 0, −1)
`GL_SPOT_EXPONENT`	0
`GL_SPOT_CUTOFF`	180
`GL_CONSTANT_ATTENUATION`	1
`GL_LINEAR_ATTENUATION`	0
`GL_QUADRATIC_ATTENUATION`	0

Tabela 2: Domyślne parametry źródeł światła GL_LIGHT1 - GL_LIGHT7

parametr źródła światła	wartość
`GL_AMBIENT`	(0, 0, 0, 1)
`GL_DIFFUSE`	(0, 0, 0, 1)
`GL_SPECULAR`	(0, 0, 0, 1)
`GL_POSITION`	(0, 0, 1, 0)
`GL_SPOT_DIRECTION`	(0, 0, −1)
`GL_SPOT_EXPONENT`	0
`GL_SPOT_CUTOFF`	180
`GL_CONSTANT_ATTENUATION`	1
`GL_LINEAR_ATTENUATION`	0
`GL_QUADRATIC_ATTENUATION`	0

Jak widzimy na powyższych tabelach światło GL_LIGHT0 jest światłem białym kierunkowym położonym w punkcie o współrzędnych (0, 0, 1). Światło skierowane jest zgodnie z kierunkiem wyznaczonym przez wektor o współrzędnych [0, 0, −1]. Pomimo kierunkowego charakteru stożek światła GL - LIGHT0 nie jest w żaden sposób ograniczony (parametr GL_SPOT_CUTOFF ma wartość 180◦ ) i światło rozchodzi się każdym kierunku. Przy domyślnych początkowych ustawieniach układu współrzędnych oraz bryły odcinania źródło światła GL_LIGHT0 znajduje się na środku płaszczyzny monitora (okna) i jest skierowane prostopadle w głąb monitora.
Źródła światła GL_LIGHT1 - GL_LIGHT7 różną się do światła GL_LIGHT0 tylko barwą światła rozproszonego i odbitego.

Parametry modelu oświetlenia

Poza zdefiniowaniem właściwości poszczególnych źródeł światła do oświetlenia sceny w bibliotece OpenGL trzeba jeszcze określić parametry stosowanego modelu oświetlenia. Służą do tego funkcje z grupy glLightModel:

void glLightModelf( GLenum pname, GLfloat param )
void glLightModeli( GLenum pname, GLint param )
void glLightModelfv( GLenum pname, const GLfloat * params )
void glLightModeliv( GLenum pname, const GLint * params )

Funkcje te, podobnie jak funkcje z grupy glLight, występują w dwóch wersjach różniących się sposobem przekazywania parametrów.
Parametr pname określa właściwość modelu oświetlenia, który chcemy zmienić. Dopuszczalne są następujące wartości tego parametru:

GL_LIGHT_MODEL_LOCAL_VIEWER - określenie sposobu obliczania kąta odbicia światła; wartość 0 oznacza, że kąt obliczany jest na podstawie kierunku od początku układu współrzędnych do oświetlanego wierzchołka obiektu; wartość różna od 0 oznacza, że kąt odbicia światła obliczany jest na podstawie kierunku ujemnej osi OZ,
GL_LIGHT_MODEL_TWO_SIDE - określenie czy będą oświetlane obie strony wielokątów (wartość różna od 0) czy też tylko przednie strony wielokątów (wartość 0),
GL_LIGHT_MODEL_AMBIENT - określenie składowych RGBA globalnego światła otaczającego,
GL_LIGHT_MODEL_COLOR_CONTROL - określenie czy efekt oświetlenia światłem odbitym będzie nakładany dopiero po nałożeniu tekstury (wartość GL_SEPARATE_SPECULAR_COLOR) lub też razem z teksturą (wartość GL_SINGLE_COLOR).

Ustawienie wartości składowych RGBA globalnego światła otaczającego wymaga oczywiście użycia funkcji glLightModelfv lub glLightModeliv. Parametr GL_LIGHT_MODEL_COLOR_CONTROL, będący jednym z elementów techniki nazywanej drugorzędnym kolorem odbicia (ang. secondary specular color), wprowadzono w wersji 1.2 biblioteki OpenGL. Wcześniej technika ta opisana była w rozszerzeniu EXT separate specular color. Zostanie to bliżej zaprezentowane w jednym z kolejnych odcinków kursu OpenGL.
Tabela 3 przedstawia wartości domyślne parametrów modelu oświetlenia w bibliotece OpenGL.

Tabela 3: Domyślne parametry modelu oświetlenia

parametr modelu oświetlenia	wartość
`GL_LIGHT_MODEL_LOCAL_VIEWER`	0
`GL_LIGHT_MODEL_TWO_SIDE`	0
`GL_LIGHT_MODEL_AMBIENT`	(2/10, 2/10, 2/10, 1)
`GL_LIGHT_MODEL_COLOR_CONTROL`	`GL_SINGLE_COLOR`

Materiały

Integralnym elementem modelu oświetlenia przyjętego w bibliotece OpenGL jest opis sposobu zachowania się powierzchni obiektów na poszczególne rodzaje światła, czyli opis właściwości materiałów. Modyfikowanie właściwości materiałów umożliwiają funkcje z grupy glMaterial:

void glMaterialf( GLenum face, GLenum pname, GLfloat para )
void glMateriali( GLenum face, GLenum pname, GLint para )
void glMaterialfv( GLenum face, GLenum pname, const GLfloat * params )
void glMaterialiv( GLenum face, GLenum pname, const GLint * params )

Jak Czytelnik zauważył także i te funkcje występują w dwóch wersjach różniących się sposobem przekazywania parametrów.
Parametr face ustala, którą stronę wielokąta dotyczy modyfikowany parametr. Dopuszczalne są poznane już wcześniej wartości: GL_FRONT - przednia strona wielokąta, GL_BACK - tylna strona wielokąta i GL_FRONT_AND_BACK - obie strony wielokąta.
Parametr pname określa zmienianą wartość parametru materiału. Dopuszczalne są poniższe wartości:

GL_AMBIENT - składowe RGBA określające stopień odbicia światła otaczającego,
GL_DIFFUSE - składowe RGBA określające stopień rozproszenia światła rozproszonego,
GL_AMBIENT_AND_DIFFUSE - składowe RGBA określające jednocześnie stopień odbicia światła otaczającego i stopień rozproszenia światła rozproszonego; jest to wartość domyślna,
GL_SPECULAR - składowe RGBA określające stopień odbicia światła odbitego,
GL_SHININESS - stała z przedziału [0, 128] określająca wykładnik odbłysku światła (ang. specular exponent) czyli regulację stopnia występowania efektu rozbłysku obiektu; im większa wartość parametru, tym większe skupienie rozbłysku światła na obiekcie,
GL_EMISSION - składowe RGBA światła emitowanego przez obiekt; taki obiekt nie staje się źródłem światła i nie oświetla innych obiektów sceny, wymaga to także utworzenia źródła światła,
GL_COLOR_INDEXES - w indeksowym trybie kolorów trzy indeksy do tablicy kolorów określające kolejno składowe RGBA określające reakcję na światło otaczające, rozproszone i odbite.

Zestawienie domyślnych własności materiałów zawiera tabela 4. Zwróćmy uwagę, że parametr GL_AMBIENT_AND_DIFFUSE nie posiada domyślnych wartości.

Tabela 4: Domyślne parametry materiałów

parametr materiału	wartość
`GL_AMBIENT`	(2/10, 2/10, 2/10, 1)
`GL_DIFFUSE`	(8/10, 8/10, 8/10, 1)
`GL_AMBIENT_AND_DIFFUSE`	-
`GL_SPECULAR`	(0,0,0,1)
`GL_SHININESS`	0
`GL_EMISSION`	(0,0,0,1)
`GL_COLOR_INDEXES`	(0,1,1)

Największy wpływ na kolor obiektu mają składowe GL_DIFFUSE.
Dobranie materiału o odpowiednich właściwościach nie jest zadaniem łatwym, choćby z uwagi na dużą ilość niezależnych od siebie parametrów. Podamy jednak kilka praktycznych rad przy dobieraniu materiałów. Przy materiałach matowych duże wartości powinny mieć składowe GL_DIFFUSE przy małych wartościach składowych GL_SPECULAR. Materiały imitujące tworzywa sztuczne także mają wysokie wartości składowych GL_DIFFUSE przy neutralnych (białych) składowych GL_SPECULAR. Powierzchnie metaliczne to małe wartości składowych GL_DIFFUSE i jednocześnie duże wartości składowych GL_SPECULAR. Stosownie do rodzaju powierzchni trzeba także dobrać odpowiednią wartość współczynnika GL_SHININESS.
Przykładowe definicje materiałów Czytelnik znajdzie w jednym z programów testowych.

Śledzenie kolorów

Biblioteka OpenGL umożliwia także definiowanie parametrów materiałów na podstawie kolorów wierzchołków określanych, przypomnijmy, przy pomocy funkcji z grupy glColor. Technika ta nazywana jest śledzeniem kolorów (ang. color tracking). Wybór parametrów materiału, które będą określane poprzez kolory wierzchołków, określa funkcja:

void glColorMaterial( GLenum face, GLenum mode )

Parametr face ustala, którą stronę wielokąta dotyczy modyfikowany parametr. Dopuszczalne są wszystkie opisane wcześniej wartości: GL_FRONT, GL_BACK i GL_FRONT_AND_BACK. Wartością domyślną jest GL_FRONT_AND_BACK.
Parametr mode wskazuje, która z właściwości materiału ma być definiowana zgodnie z bieżącym kolorem wierzchołka. Dopuszczalne są niemal wszystkie opisane wcześniej własności materiałów: GL_EMISSION, GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR i GL_AMBIENT_AND_DIFFUSE. Wartością domyślną jest GL_AMBIENT_AND_DIFFUSE.
Śledzenie kolorów jest domyślne wyłączone, stąd przed użyciem funkcji glColorMaterial trzeba wywołać funkcję glEnable z parametrem GL_COLOR_MATERIAL. Oczywiście wyłączenie śledzenia kolorów wymaga wywołania funkcji glDisable z parametrem GL_COLOR_MATERIAL.
Używanie techniki śledzenie kolorów jest szczególnie użyteczne, gdy na każdy wierzchołek obiektu zmieniamy tylko jedną właściwość materiału.

Wektory normalne

Do prawidłowego generowania efektów oświetlenia, a w szczególności określenia orientacji wierzchołków obiektów względem źródeł światła, biblioteka OpenGL wymaga definiowania wektorów normalnych (prostopadłych). Ponieważ obliczenia związane z oświetleniem OpenGL wykonuje dla każdego wierzchołka, stąd każdy wierzchołek ma przypisany swój wektor normalny.
Wektor normalny definiują funkcje z grupy glNormal3, które dzielą się na dwie grupy. Pierwsza grupa posiada trzy parametry określające składowe wektora normalnego:

void glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
void glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
void glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
void glNormal3i( GLint nx, GLint ny, GLint nz )
void glNormal3s( GLshort nx, GLshort ny, GLshort nz )

Druga grupa funkcji posiada jeden parametr będący wskaźnikiem na tablicę ze składowymi wektora normalnego:

void glNormal3bv( const GLbyte * v )
void glNormal3dv( const GLdouble * v )
void glNormal3fv( const GLfloat * v )
void glNormal3iv( const GLint * v )
void glNormal3sv( const GLshort * v )

Podobnie jak w przypadku kolorów czy własności materiału dany wektor normalny obowiązuje do czasu zdefiniowania kolejnego. W szczególności można użyć jednego wektora normalnego do grupy wierzchołków opisujących płaski obiekt. Początkowa wartość wektora normalnego wynosi [0, 0, 1].
Do wyznaczania wektora normalnego można użyć iloczynu wektorowego. Przy obliczeniach wykorzystujemy wektory utworzone z krawędzi ściany obiektu, pamiętając o zachowaniu odpowiedniej orientacji. Jeżeli ściany mają sprawiać wrażenie płaskich, wówczas obliczamy wektor normalny tylko dla pierwszego wierzchołka. Pozostałe wierzchołki będą korzystały z tego samego wektora.
Jeżeli natomiast zależy nam na uzyskaniu wrażenia gładkości oświetlanego obiektu wykorzystujemy technikę uśredniania wektorów normalnych. Polega ona na obliczaniu wektora normalnego dla każdego wierzchołka obiektu 3D. Tym razem wektor ten obliczamy nie na podstawie krawędzi jednej ściany ale wszystkich krawędzi wychodzących z wierzchołka. Można do tego celu wykorzystać złożenie (sumę) wektorów normalnych wszystkich ścian zawierających dany wierzchołek. Technika ta pozwala na zwiększenie realizmu sceny bez radykalnego zwiększania złożoności renderowanych obiektów.
Aby obliczenia oświetlenia były wykonywane poprawne wektor normalny musi mieć długość jednostkową, inaczej mówiąc musi być znormalizowany (jednostkowy). Normalizację wektorów można wykonać programowo, przy czym należy uwzględniać przekształcenia macierzy modelowania, które modyfikują także wektory normalne i mogą przy okazji zmienić ich długość. W szczególności dotyczy to operacji skalowania macierzy modelowania.
Drugim sposobem normalizacji wektorów normalnych jest skorzystanie z mechanizmu udostępnianego przez OpenGL, który automatycznie normalizuje wektory normalne. W tym celu trzeba wywołać funkcję glEnable z parametrem GL_NORMALIZE. Domyślnie mechanizm ten jest nieaktywny. Wyłączenie automatycznej normalizacji wektorów normalnych wymaga wywołania funkcji glDisable z parametrem GL_NORMALIZE.
Bardzo pomocnym przy stosowaniu wektorów normalnych jest wprowadzony w wersji 1.2 biblioteki OpenGL mechanizm automatycznego skalowania jednostkowych wektorów normalnych. Przy jego zastosowaniu normalizacja wektora normalnego jest wykonywana tylko raz, a późniejsze jego modyfikacje wykonywane są wyłącznie przy skalowaniu macierzy modelowania, które, przypomnijmy, zmienia długość wektora normalnego.
Technikę automatycznego skalowania jednostkowych wektorów normalnych wprowadzono wcześniej w rozszerzeniu EXT rescale normal, a jej wykorzystanie sprowadza się do wywołania funkcji glEnable z parametrem GL_RESCALE_NORMAL (lub GL_RESCALE_NORMAL_EXT). Wyłączenie automatycznego skalowania jednostkowych wektorów normalnych wymaga wywołania funkcji glDisable z parametrem GL_RESCALE_NORMAL lub GL_RESCALE_NORMAL_EXT.

Odczyt parametrów źródła światła i materiałów

Odczyt ustawień wybranego źródła światła umożliwiają funkcje z grupy glGetLight:

void glGetLightfv( GLenum light, GLenum pname, GLfloat * params )
void glGetLightiv( GLenum light, GLenum pname, GLint * params )

Znaczenie parametrów light i pname jest takie same jak analogicznych parametrów funkcji z grupy glLight. Wartości pobieranych ustawień źródła światła umieszczane są w tablicy, do której wskaźnik należy podać w parametrze params.
Analogicznie wygląda pobieranie ustawień bieżącego materiału, do czego służą funkcje z grupy glGetMaterial:

void glGetMaterialfv( GLenum face, GLenum pname, GLfloat * params )
void glGetMaterialiv( GLenum face, GLenum pname, GLint * params )

Parametry face i pname są odpowiednikami parametrów funkcji z grupy glMaterial, a wartości pobieranych ustawień bieżącego materiału umieszczane są w tablicy wskazywanej przez parametr params.
Oczywiście przy korzystaniu z powyższych funkcji program musi zapewnić wystarczającą ilość miejsca w tablicy, która będzie zawierała pobierane parametry źródła światła lub materiału.

Programy przykładowe

Pierwszy przykładowy program (patrz plik globalne swiatlo otaczajace.cpp) oświetla scenę wyłącznie przy pomocy globalnego światła otaczającego i pozwala na modyfikację wartości poszczególnych składowych RGB tego światła. Jak już powiedzieliśmy na wstępie światło otaczające nie pochodzi z żadnego konkretnego kierunku i równomiernie oświetla wszystkie elementy sceny 3D. Przedstawione wcześniej funkcje z grupy glLightModel umożliwiają modyfikację globalnego światła otaczającego dla całej sceny 3D.
Pozwala to, przy braku innych źródeł światła, na równomierne oświetlenie całej sceny.
Wartości początkowe składowych tego światła przyjęte w programie odpowiadają wartościom domyślnym przyjmowanym przez bibliotekę OpenGL. Początkowy wygląd ścian: czerwonej, niebieskiej i zielonej sześcianu RGB przedstawia rysunek 2. Jak widać domyślne światło otaczające jest stosunkowo ciemne. Dla porównania rysunek 3 przedstawia te same ściany sześcianu ale przy maksymalnych wartościach składowych RGB globalnego światła otaczającego. Natomiast efekty oświetlenia obiektu sceny globalnych światłem otaczającym z wybranymi składowymi RGB o wartościach ujemnych przedstawiają rysunki 4 i 5.

Rysunek 2. Program Globalne światło otaczające - ściany RGB przy początkowych (domyślnych) wartościach składowych RGB globalnego światła otaczającego

Warto także zwrócić uwagę, że przy definiowaniu sześcianu nie były wykorzystywane wektory normalne. Nie ma takiej potrzeby, bowiem jak wcześniej napisaliśmy, globalne światło otaczające nie pochodzi z żadnego konkretnego kierunku.
W ramach ćwiczeń Czytelnik może łatwo sprawdzić, że wygląd sześcianu RGB przedstawiony na rysunku 3, odpowiada wyglądowi tego samego sześcianu ale przy wyłączonych efektach oświetlenia. Oznacza to, że domyślnie biblioteka OpenGL faktycznie nie wykonuje żadnych obliczeń związanych z oświetleniem, a obiekty są bezpośrednio rasteryzowane zgodnie z wartościami składowych RGB.

Rysunek 3. Program Globalne światło otaczające - ściany RGB przy maksymalnych wartościach składowych RGB globalnego światła otaczającego

Rysunek 4. Program Globalne światło otaczające - ściany RGB przy minimalnej wartości składowej czerwonej globalnego światła otaczającego

Plik globalne_swiatlo_otaczajace.cpp

Rysunek 5. Program Globalne światło otaczające - ściany RGB przy minimalnej wartości składowych czerwonej i niebieskiej globalnego światła otaczającego

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glut.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "colors.h"

// stałe do obsługi menu podręcznego

enum
{
FULL_WINDOW, // aspekt obrazu - całe okno
ASPECT_1_1, // aspekt obrazu 1:1
EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// rozmiary bryły obcinania

const GLdouble left = - 2.0;
const GLdouble right = 2.0;
const GLdouble bottom = - 2.0;
const GLdouble top = 2.0;
const GLdouble near = 3.0;
const GLdouble far = 7.0;

// kąty obrotu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;

// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;

// położenie kursora myszki

int button_x, button_y;

// składowe globalnego światła otaczającego
// wartość początkowa odpowiada wartości domyślnej
// składowych tego światła

GLfloat ambient_light[ 4 ] =
{
0.2, 0.2, 0.2, 1.0
};

// funkcja rysująca napis w wybranym miejscu

void DrawString( GLfloat x, GLfloat y, char * string )
{
// położenie napisu
glRasterPos2f( x, y );

// wyświetlenie napisu
int len = strlen( string );
for( int i = 0; i < len; i++ )
   glutBitmapCharacter( GLUT_BITMAP_9_BY_15, string[ i ] );

}

// funkcja generująca scenę 3D

void Display()
{
// kolor tła - zawartość bufora koloru
glClearColor( 1.0, 1.0, 1.0, 1.0 );

// czyszczenie bufora koloru i bufora głębokości
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

// wybór macierzy modelowania
glMatrixMode( GL_MODELVIEW );

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// przesunięcie układu współrzędnych sześcianu do środka bryły odcinania
glTranslatef( 0, 0, -( near + far ) / 2 );

// obroty sześcianu
glRotatef( rotatex, 1.0, 0, 0 );
glRotatef( rotatey, 0, 1.0, 0 );

// niewielkie powiększenie sześcianu
glScalef( 1.15, 1.15, 1.15 );

// włączenie oświetlenia
glEnable( GL_LIGHTING );

// parametry globalnego światła otaczającego
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, ambient_light );

// włączenie obsługi właściwości materiałów
glEnable( GL_COLOR_MATERIAL );

// właściwości materiału określone przez kolor wierzchołków
glColorMaterial( GL_FRONT, GL_AMBIENT );

// włączenie testu bufora głębokości
glEnable( GL_DEPTH_TEST );

// rysowanie sześcianu - 12 trójkątów
glBegin( GL_TRIANGLES );
glColor3fv( Red );
glVertex3f( - 1.0, - 1.0, 1.0 );
glVertex3f( 1.0, - 1.0, 1.0 );
glVertex3f( 1.0, 1.0, 1.0 );
glVertex3f( - 1.0, - 1.0, 1.0 );
glVertex3f( 1.0, 1.0, 1.0 );
glVertex3f( - 1.0, 1.0, 1.0 );

glColor3fv( Magenta );
glVertex3f( - 1.0, 1.0, 1.0 );
glVertex3f( 1.0, 1.0, 1.0 );
glVertex3f( - 1.0, 1.0, - 1.0 );
glVertex3f( - 1.0, 1.0, - 1.0 );
glVertex3f( 1.0, 1.0, 1.0 );
glVertex3f( 1.0, 1.0, - 1.0 );

glColor3fv( Cyan );
glVertex3f( 1.0, 1.0, - 1.0 );
glVertex3f( 1.0, 1.0, 1.0 );
glVertex3f( 1.0, - 1.0, 1.0 );
glVertex3f( 1.0, 1.0, - 1.0 );
glVertex3f( 1.0, - 1.0, 1.0 );
glVertex3f( 1.0, - 1.0, - 1.0 );

glColor3fv( Lime );
glVertex3f( 1.0, - 1.0, - 1.0 );
glVertex3f( 1.0, - 1.0, 1.0 );
glVertex3f( - 1.0, - 1.0, - 1.0 );
glVertex3f( - 1.0, - 1.0, - 1.0 );
glVertex3f( 1.0, - 1.0, 1.0 );
glVertex3f( - 1.0, - 1.0, 1.0 );

glColor3fv( Blue );
glVertex3f( - 1.0, - 1.0, - 1.0 );
glVertex3f( - 1.0, - 1.0, 1.0 );
glVertex3f( - 1.0, 1.0, - 1.0 );
glVertex3f( - 1.0, 1.0, - 1.0 );
glVertex3f( - 1.0, - 1.0, 1.0 );
glVertex3f( - 1.0, 1.0, 1.0 );

glColor3fv( Yellow );
glVertex3f( - 1.0, - 1.0, - 1.0 );
glVertex3f( - 1.0, 1.0, - 1.0 );
glVertex3f( 1.0, 1.0, - 1.0 );
glVertex3f( 1.0, - 1.0, - 1.0 );
glVertex3f( - 1.0, - 1.0, - 1.0 );
glVertex3f( 1.0, 1.0, - 1.0 );

// koniec definicji sześcianu
glEnd();

// wyłączenie oświetlenia
glDisable( GL_LIGHTING );

// wyłączenie obsługi właściwości materiałów
glDisable( GL_COLOR_MATERIAL );

// wyświetlenie składowych globalnego światła otaczającego
char string[ 100 ];
GLfloat rgba[ 4 ];
glColor3fv( Black );

// pobranie wartości składowych światła otaczającego
// (oczywiście wartości te odpowiadają tablicy ambient_light)
glGetFloatv( GL_LIGHT_MODEL_AMBIENT, rgba );
sprintf( string, "AMBIENT: R=%f G=%f B=%f A=%f", rgba[ 0 ], rgba[ 1 ], rgba[ 2 ], rgba[ 3 ] );

// trzeba odpowiednio przekształcić układ współrzędnych
// aby napis znajdował się na samej "górze" bryły obcinania
glLoadIdentity();
glTranslatef( 0, 0, - near );

// narysowanie napisu
DrawString( left, bottom, string );

// skierowanie poleceń do wykonania
glFlush();

// zamiana buforów koloru
glutSwapBuffers();
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
// obszar renderingu - całe okno
glViewport( 0, 0, width, height );

// wybór macierzy rzutowania
glMatrixMode( GL_PROJECTION );

// macierz rzutowania = macierz jednostkowa
glLoadIdentity();

// parametry bryły obcinania
if( aspect == ASPECT_1_1 )
{
// wysokość okna większa od wysokości okna
if( width < height && width > 0 )
   glFrustum( left, right, bottom * height / width, top * height / width, near, far );
else

// szerokość okna większa lub równa wysokości okna
if( width >= height && height > 0 )
   glFrustum( left * width / height, right * width / height, bottom, top, near, far );

}
else
   glFrustum( left, right, bottom, top, near, far );

// generowanie sceny 3D
Display();
}

// obsługa klawiatury

void Keyboard( unsigned char key, int x, int y )
{
// zmiana wartości składowej R
if( key == 'R' && ambient_light[ 0 ] < 1.0 )
   ambient_light[ 0 ] += 0.05;
else
if( key == 'r' && ambient_light[ 0 ] > - 1.0 )
   ambient_light[ 0 ] -= 0.05;

// zmiana wartości składowej G
if( key == 'G' && ambient_light[ 1 ] < 1.0 )
   ambient_light[ 1 ] += 0.05;
else
if( key == 'g' && ambient_light[ 1 ] > - 1.0 )
   ambient_light[ 1 ] -= 0.05;

// zmiana wartości składowej B
if( key == 'B' && ambient_light[ 2 ] < 1.0 )
   ambient_light[ 2 ] += 0.05;
else
if( key == 'b' && ambient_light[ 2 ] > - 1.0 )
   ambient_light[ 2 ] -= 0.05;

// narysowanie sceny
Display();
}

// obsługa klawiszy funkcyjnych i klawiszy kursora

void SpecialKeys( int key, int x, int y )
{
switch( key )
{
// kursor w lewo
case GLUT_KEY_LEFT:
rotatey -= 1;
break;

// kursor w górę
case GLUT_KEY_UP:
rotatex -= 1;
break;

// kursor w prawo
case GLUT_KEY_RIGHT:
rotatey += 1;
break;

// kursor w dół
case GLUT_KEY_DOWN:
rotatex += 1;
break;
}

// odrysowanie okna
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}

// obsługa przycisków myszki

void MouseButton( int button, int state, int x, int y )
{
if( button == GLUT_LEFT_BUTTON )
{
// zapamiętanie stanu lewego przycisku myszki
button_state = state;

// zapamiętanie położenia kursora myszki
if( state == GLUT_DOWN )
{
button_x = x;
button_y = y;
}
}
}

// obsługa ruchu kursora myszki

void MouseMotion( int x, int y )
{
if( button_state == GLUT_DOWN )
{
rotatey += 30 *( right - left ) / glutGet( GLUT_WINDOW_WIDTH ) *( x - button_x );
button_x = x;
rotatex -= 30 *( top - bottom ) / glutGet( GLUT_WINDOW_HEIGHT ) *( button_y - y );
button_y = y;
glutPostRedisplay();
}
}

// obsługa menu podręcznego

void Menu( int value )
{
switch( value )
{
// obszar renderingu - całe okno
case FULL_WINDOW:
aspect = FULL_WINDOW;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// obszar renderingu - aspekt 1:1
case ASPECT_1_1:
aspect = ASPECT_1_1;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// wyjście
case EXIT:
exit( 0 );
}
}

int main( int argc, char * argv[] )
{
// inicjalizacja biblioteki GLUT
glutInit( & argc, argv );

// inicjalizacja bufora ramki
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );

// rozmiary głównego okna programu
glutInitWindowSize( 500, 500 );

// utworzenie głównego okna programu
#ifdef WIN32

glutCreateWindow( "Globalne światło otaczające" );
#else

glutCreateWindow( "Globalne swiatlo otaczajace" );
#endif

// dołączenie funkcji generującej scenę 3D
glutDisplayFunc( Display );

// dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
glutReshapeFunc( Reshape );

// dołączenie funkcji obsługi klawiatury
glutKeyboardFunc( Keyboard );

// dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
glutSpecialFunc( SpecialKeys );

// obsługa przycisków myszki
glutMouseFunc( MouseButton );

// obsługa ruchu kursora myszki
glutMotionFunc( MouseMotion );

// utworzenie menu podręcznego
glutCreateMenu( Menu );

// utworzenie podmenu - aspekt obrazu
int MenuAspect = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Aspekt obrazu - całe okno", FULL_WINDOW );
#else

glutAddMenuEntry( "Aspekt obrazu - cale okno", FULL_WINDOW );
#endif

glutAddMenuEntry( "Aspekt obrazu 1:1", ASPECT_1_1 );

// menu główne
glutCreateMenu( Menu );
glutAddSubMenu( "Aspekt obrazu", MenuAspect );
#ifdef WIN32

glutAddMenuEntry( "Wyjście", EXIT );
#else

glutAddMenuEntry( "Wyjscie", EXIT );
#endif

// określenie przycisku myszki obsługującej menu podręczne
glutAttachMenu( GLUT_RIGHT_BUTTON );

// wprowadzenie programu do obsługi pętli komunikatów
glutMainLoop();
return 0;
}

Drugi przykładowy program (plik materialy.cpp) prezentuje sposób wykorzystania materiałów. Definicje materiałów, umieszczone w pliku materials.h, pochodzą pochodzą z pracy „Advanced Graphics Programming Techniques Using OpenGL” (SIGGRAPH 1998), która dostępna jest pod adresem: http://www.opengl.org.
Do prezentacji materiałów wykorzystamy kwadryki, czyli powierzchnie stopnia drugiego, udostępniane przez bibliotekę pomocniczą GLU. Nową kwadrykę tworzymy wywołując funkcję:

GLUquadric * gluNewQuadric()

Funkcja zwraca wskaźnik do struktury, lub klasy w przypadku użycia języka C++, typu GLUquadric, który jest później używany przy wszelkich operacjach na kwadrykach. Warto zauważyć, że specyfikacja biblioteki GLU używa przy opisie kwadryk równorzędnego typu GLUquadricObj. Po zakończeniu używania kwadryki trzeba zwolnić przydzieloną jej pamięć wywołując funkcję:

void gluDeleteQuadric( GLUquadric * state )

Biblioteka GLU udostępnia cztery rodzaje kwadryk. Są to: kula (sfera), cylinder, dysk i niepełny dysk, przy czym dwie ostatnie są figurami płaskimi. Kulę tworzy wywołanie funkcji:

void gluSphere( GLUquadric * quadobj,
GLdouble radius, GLint slices, GLint stacks )

której parametry radius, slices i stacks maję te same znaczenie jak parametry opisywanych wcześniej funkcji glutWireSphere i glutSolidSphere. Parametr quadobj to oczywiście wskaźnik na strukturę (klasę) GLUquadric, zwrócony przez funkcję gluNewQuadric przy tworzeniu kwadryki.
Cylinder tworzony jest poprzez wywołanie funkcji:

void gluCylinder( GLUquadric * quadobj,
GLdouble baseRadius, GLdouble topRadius, GLdouble height, GLint slices, GLint stacks )

Parametry baseRadius i topRadius określają odpowiednio promień dolnej i górnej podstawy cylindra. Promienie mogą oczywiście mieć różną wielkość, co spowoduje utworzenie stożka ściętego. W szczególnym przypadku jeden z promieni może mieć wartość 0. Jak się Czytelnik domyśla, otrzymamy wówczas stożek. W każdym przypadku obiekt rysowany jest bez górnej i dolnej podstawy. Można je utworzyć korzystając z opisanego dalej dysku.
Parametry slices i stacks mają takie same znaczenie jak w przypadku tworzenia kuli. Są to odpowiedniki południków i równoleżników na kuli. W przypadku cylindra można je określić jako wzdłużne i poprzeczne segmenty.
Kolejną kwadryką dostępną w bibliotece GLU jest dysk (koło) tworzony wywołaniem funkcji:

void gluDisk( GLUquadric * quadobj,
GLdouble innerRadius, GLdouble outerRadius, GLint slices, GLint loops )

Parametry innerRadius i outerRadius określają promień wewnętrzny i zewnętrzny dysku. Jeżeli promień wewnętrzny jest większy od 0, to dysk zawiera w środku okrągły otwór. Taką figurę nazywamy pierścieniem kołowym. Parametry slices i loops określają ilość sektorów w kierunku obwodowym i promieniowym, z których składa się dysk.
Ostatnią kwadryką dostępną w bibliotece GLU jest częściowy dysk (wycinek kołowy). Tworzy go wywołanie funkcji:

void gluPartialDisk( GLUquadric * quadobj, GLdouble innerRadius, GLdouble outerRadius, GLint slices, GLint loops, GLdouble startAngle, GLdouble sweepAngle )

Parametry innerRadius, outerRadius, slices i loops mają takie same znaczenie jak przy tworzeniu dysku za pomocą funkcji gluDisk. Natomiast parametry startAngle i sweepAngle określają kąt początkowy i kąt środkowy dysku. Jeżeli promień wewnętrzny, określony parametrem outerRadius, jest większy od 0, otrzymamy figurę nazywaną wycinkiem pierścienia kołowego.
Biblioteka GLU zawiera cztery funkcje umożliwiające modyfikację sposobu rysowania kwadryk. Trzy z nich zostały wykorzystane w przykładowym programie, a czwartą obsługującą teksturowanie, wykorzystamy w jednym z następnych odcinków kursu.
Sposób prezentacji kwadryki określa funkcja:

void gluQuadricDrawStyle( GLUquadric * quadobj, GLenum drawStyle )

której parametr drawStyle przyjmuje jedną z poniższych wartości:

GLU_POINT - punkty,
GLU_LINE - odcinki,
GLU_FILL - pełna figura (wartość domyślna),
GLU_SILHOUETTE - odcinki, przy czym rysowane są tylko odcinki zewnętrzne (brzegowe) figury.

Druga funkcja określa sposób generowania wektorów normalnych kwadryk:

void gluQuadricNormals( GLUquadric * quadobj, GLenum normals )

Parametr normals przyjmuje jedną z wartości:

GLU_SMOOTH - wektor normalny określany jest dla każdego wierzchołka, czyli z zastosowaniem opisywanej wcześniej techniki uśredniania wektorów normalnych (wartość domyślna),
GLU_FLAT - wektor normalny określany jest dla każdej ściany,
GLU_NONE - wektory normalne nie są generowane.

Kolejna prezentowana funkcja określa orientację generowanych wektorów
normalnych:

void gluQuadricOrientation( GLUquadric * quadobj, GLenum orientation )

Parametr orientation przyjmuje jedną z dwóch wartości:

GLU_OUTSIDE - wektory normalne skierowane na zewnątrz (wartość domyślna),
GLU_INSIDE - wektory normalne skierowane do wewnątrz.

Oczywiście pojęcia „na zewnątrz” i „do wewnątrz” nabierają różnego znaczenia w zależności od rodzaju rysowanej kwadryki. W przypadku figur płaskich będzie to po prostu jedna ze stron figury.
Zadaniem ostatniej z opisywanych funkcji jest nałożenie dwuwymiarowej tekstury na kwadrykę:

void gluQuadricTexture( GLUquadric * quadobj, GLboolean texture )

Parametr quadobj to oczywiście wskaźnik do struktury (klasy) GLUquadric. Drugi parametr określa czy kwadryka ma być teksturowana bieżącą teksturą (GL_TRUE) czy też nie (GL_FALSE).
Ostatnim elementem obługi kwadryk w bibliotece GLU jest możliwość zdefiniowania funkcji zwrotnej wywoływanej w momencie wystąpienia błędu. Dołączenie funkcji zwrotnej realizuje funkcja:

void gluQuadricCallback( GLUquadric * quadobj, GLenum which, void( * fn )() )

której parametr which określa rodzaj błędu obsługiwanego przez funkcję zwrotną wskazywaną w parametrze fn. Ponieważ jednak w przypadku kwadryk biblioteka GLU nie posiada specjalnego zestawu kodów błędów, jedyną dopuszczalną wartością parametru which jest stała GLU_ERROR.
Wróćmy teraz do możliwości naszego programu. Kwadryki oświetlane są światłem GL_LIGHT0 z parametrami domyślnymi. Program z założenia nie modyfikuje żadnych ustawień tego źródła światła, umożliwia natomiast wybór z poziomu menu podręcznego wszystkich opisanych wcześniej opcji rysowania kwadryk. Z poziomu menu użytkownik może także wybrać rodzaj materiału użytego do narysowania kwadryki. Dodatkowo przy pomocy przycisków PageUp i PageDown można zmieniać ilość elementów, z których będzie złożona kwadryka. Wyświetlany cały czas na ekranie wskaźnik FPS (ang. frames per second) ilości ramek obrazu rysowanych w ciągu jednej sekundy pozwala na jednoczesną weryfikację stosunku jakości generowanego obrazu do szybkości jego generowania. Wartość FPS jest obliczana po narysowaniu co tysięcznej ramki obrazu.
Przykładowe efekty działania programu przedstawiono na rysunkach 6 - 10. W celu ujednolicenia opisu pod każdym rysunkiem po nazwie rysowanej kwadryki umieszczono parametry z jaką została narysowana. Są to kolejno: wektory normalne, orientacja, styl oraz ilość elementów użytych do rysowania kwadryki (odpowiednio ilość sektorów lub południków i równoleżników figury). Nie należy tego mylić z ilością trójkątów lub innych prymitywów graficznych użytych do narysowania figury.

Rysunek 6. Program Materiały - kula: mosiądz, GLU_SMOOTH, GLU_OUTSIDE, GLU_FILL, 10

Plik materials.h

Rysunek 7. Program Materiały - cylinder: brąz, GLU_SMOOTH, GLU_OUTSIDE, GLU_FILL, 30

Rysunek 8. Program Materiały - dysk: grafit, GLU_SMOOTH, GLU_OUTSIDE, GLU_LINE, 20

Rysunek 9. Program Materiały - kula: perła, GLU_FLAT, GLU_OUTSIDE, GLU_FILL, 40

Rysunek 10. Program Materiały - częściowy dysk: rubin, GLU_FLAT, GLU_OUTSIDE, GLU_POINT, 200

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#ifndef __MATERIALS__H__
#define __MATERIALS__H__

#include <GL/gl.h>

// mosiądz

const GLfloat BrassAmbient[ 4 ] =
{
0.329412, 0.223529, 0.027451, 1.000000
};

const GLfloat BrassDiffuse[ 4 ] =
{
0.780392, 0.568627, 0.113725, 1.000000
};

const GLfloat BrassSpecular[ 4 ] =
{
0.992157, 0.941176, 0.807843, 1.000000
};

const GLfloat BrassShininess = 27.8974;

// brąz

const GLfloat BronzeAmbient[ 4 ] =
{
0.212500, 0.127500, 0.054000, 1.000000
};

const GLfloat BronzeDiffuse[ 4 ] =
{
0.714000, 0.428400, 0.181440, 1.000000
};

const GLfloat BronzeSpecular[ 4 ] =
{
0.393548, 0.271906, 0.166721, 1.000000
};

const GLfloat BronzeShininess = 25.6;

// polerowany brąz

const GLfloat PolishedBronzeAmbient[ 4 ] =
{
0.250000, 0.148000, 0.064750, 1.000000
};

const GLfloat PolishedBronzeDiffuse[ 4 ] =
{
0.400000, 0.236800, 0.103600, 1.000000
};

const GLfloat PolishedBronzeSpecular[ 4 ] =
{
0.774597, 0.458561, 0.200621, 1.000000
};

const GLfloat PolishedBronzeShininess = 76.8;

// chrom

const GLfloat ChromeAmbient[ 4 ] =
{
0.250000, 0.250000, 0.250000, 1.000000
};

const GLfloat ChromeDiffuse[ 4 ] =
{
0.400000, 0.400000, 0.400000, 1.000000
};

const GLfloat ChromeSpecular[ 4 ] =
{
0.774597, 0.774597, 0.774597, 1.000000
};

const GLfloat ChromeShininess = 76.8;

// miedź

const GLfloat CopperAmbient[ 4 ] =
{
0.191250, 0.073500, 0.022500, 1.000000
};

const GLfloat CopperDiffuse[ 4 ] =
{
0.703800, 0.270480, 0.082800, 1.000000
};

const GLfloat CopperSpecular[ 4 ] =
{
0.256777, 0.137622, 0.086014, 1.000000
};

const GLfloat CopperShininess = 12.8;

// polerowana miedź

const GLfloat PolishedCopperAmbient[ 4 ] =
{
0.229500, 0.088250, 0.027500, 1.000000
};

const GLfloat PolishedCopperDiffuse[ 4 ] =
{
0.550800, 0.211800, 0.066000, 1.000000
};

const GLfloat PolishedCopperSpecular[ 4 ] =
{
0.580594, 0.223257, 0.069570, 1.000000
};

const GLfloat PolishedCopperShininess = 51.2;

// złoto

const GLfloat GoldAmbient[ 4 ] =
{
0.247250, 0.199500, 0.074500, 1.000000
};

const GLfloat GoldDiffuse[ 4 ] =
{
0.751640, 0.606480, 0.226480, 1.000000
};

const GLfloat GoldSpecular[ 4 ] =
{
0.628281, 0.555802, 0.366065, 1.000000
};

const GLfloat GoldShininess = 52.2;

// polerowane złoto

const GLfloat PolishedGoldAmbient[ 4 ] =
{
0.247250, 0.224500, 0.064500, 1.000000
};

const GLfloat PolishedGoldDiffuse[ 4 ] =
{
0.346150, 0.314300, 0.090300, 1.000000
};

const GLfloat PolishedGoldSpecular[ 4 ] =
{
0.797357, 0.723991, 0.208006, 1.000000
};

const GLfloat PolishedGoldShininess = 83.2;

// cyna z ołowiem (grafit)

const GLfloat PewterAmbient[ 4 ] =
{
0.105882, 0.058824, 0.113725, 1.000000
};

const GLfloat PewterDiffuse[ 4 ] =
{
0.427451, 0.470588, 0.541176, 1.000000
};

const GLfloat PewterSpecular[ 4 ] =
{
0.333333, 0.333333, 0.521569, 1.000000
};

const GLfloat PewterShininess = 9.84615;

// srebro

const GLfloat SilverAmbient[ 4 ] =
{
0.192250, 0.192250, 0.192250, 1.000000
};

const GLfloat SilverDiffuse[ 4 ] =
{
0.507540, 0.507540, 0.507540, 1.000000
};

const GLfloat SilverSpecular[ 4 ] =
{
0.508273, 0.508273, 0.508273, 1.000000
};

const GLfloat SilverShininess = 51.2;

// polerowane srebro

const GLfloat PolishedSilverAmbient[ 4 ] =
{
0.231250, 0.231250, 0.231250, 1.000000
};

const GLfloat PolishedSilverDiffuse[ 4 ] =
{
0.277500, 0.277500, 0.277500, 1.000000
};

const GLfloat PolishedSilverSpecular[ 4 ] =
{
0.773911, 0.773911, 0.773911, 1.000000
};

const GLfloat PolishedSilverShininess = 89.6;

// szmaragd

const GLfloat EmeraldAmbient[ 4 ] =
{
0.021500, 0.174500, 0.021500, 0.550000
};

const GLfloat EmeraldDiffuse[ 4 ] =
{
0.075680, 0.614240, 0.075680, 0.550000
};

const GLfloat EmeraldSpecular[ 4 ] =
{
0.633000, 0.727811, 0.633000, 0.550000
};

const GLfloat EmeraldShininess = 76.8;

// jadeit

const GLfloat JadeAmbient[ 4 ] =
{
0.135000, 0.222500, 0.157500, 0.950000
};

const GLfloat JadeDiffuse[ 4 ] =
{
0.540000, 0.890000, 0.630000, 0.950000
};

const GLfloat JadeSpecular[ 4 ] =
{
0.316228, 0.316228, 0.316228, 0.950000
};

const GLfloat JadeShininess = 12.8;

// obsydian (szkło wulkaniczne)

const GLfloat ObsidianAmbient[ 4 ] =
{
0.053750, 0.050000, 0.066250, 0.820000
};

const GLfloat ObsidianDiffuse[ 4 ] =
{
0.182750, 0.170000, 0.225250, 0.820000
};

const GLfloat ObsidianSpecular[ 4 ] =
{
0.332741, 0.328634, 0.346435, 0.820000
};

const GLfloat ObsidianShininess = 38.4;

// perła

const GLfloat PearlAmbient[ 4 ] =
{
0.250000, 0.207250, 0.207250, 0.922000
};

const GLfloat PearlDiffuse[ 4 ] =
{
1.000000, 0.829000, 0.829000, 0.922000
};

const GLfloat PearlSpecular[ 4 ] =
{
0.296648, 0.296648, 0.296648, 0.922000
};

const GLfloat PearlShininess = 11.264;

// rubin

const GLfloat RubyAmbient[ 4 ] =
{
0.174500, 0.011750, 0.011750, 0.550000
};

const GLfloat RubyDiffuse[ 4 ] =
{
0.614240, 0.041360, 0.041360, 0.550000
};

const GLfloat RubySpecular[ 4 ] =
{
0.727811, 0.626959, 0.626959, 0.550000
};

const GLfloat RubyShininess = 76.8;

// turkus

const GLfloat TurquoiseAmbient[ 4 ] =
{
0.100000, 0.187250, 0.174500, 0.800000
};

const GLfloat TurquoiseDiffuse[ 4 ] =
{
0.396000, 0.741510, 0.691020, 0.800000
};

const GLfloat TurquoiseSpecular[ 4 ] =
{
0.297254, 0.308290, 0.306678, 0.800000
};

const GLfloat TurquoiseShininess = 12.8;

// czarny plastik

const GLfloat BlackPlasticAmbient[ 4 ] =
{
0.000000, 0.000000, 0.000000, 1.000000
};

const GLfloat BlackPlasticDiffuse[ 4 ] =
{
0.010000, 0.010000, 0.010000, 1.000000
};

const GLfloat BlackPlasticSpecular[ 4 ] =
{
0.500000, 0.500000, 0.500000, 1.000000
};

const GLfloat BlackPlasticShininess = 32;

// czarna guma

const GLfloat BlackRubberAmbient[ 4 ] =
{
0.020000, 0.020000, 0.020000, 1.000000
};

const GLfloat BlackRubberDiffuse[ 4 ] =
{
0.010000, 0.010000, 0.010000, 1.000000
};

const GLfloat BlackRubberSpecular[ 4 ] =
{
0.040000, 0.040000, 0.040000, 1.000000
};

const GLfloat BlackRubberShininess = 10;

#endif // __MATERIALS_H__

Plik materlaly.cpp

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include "colors.h"
#include "materials.h"

// stałe do obsługi menu podręcznego

enum
{
// obiekty
SPHERE, // kula
CYLINDER, // cylinder
DISK, // dysk
PARTIAL_DISK, // częściowy dysk

// materiały
BRASS, // mosiądz
BRONZE, // brąz
POLISHED_BRONZE, // polerowany brąz
CHROME, // chrom
COPPER, // miedź
POLISHED_COPPER, // polerowana miedź
GOLD, // złoto
POLISHED_GOLD, // polerowane złoto
PEWTER, // grafit (cyna z ołowiem)
SILVER, // srebro
POLISHED_SILVER, // polerowane srebro
EMERALD, // szmaragd
JADE, // jadeit
OBSIDIAN, // obsydian
PEARL, // perła
RUBY, // rubin
TURQUOISE, // turkus
BLACK_PLASTIC, // czarny plastik
BLACK_RUBBER, // czarna guma

// wektory normalne
NORMALS_SMOOTH, // GLU_SMOOTH
NORMALS_FLAT, // GLU_FLAT
NORMALS_NONE, // GLU_NONE

// orientacja
ORIENTATION_OUTSIDE, // GLU_OUTSIDE
ORIENTATION_INSIDE, // GLU_INSIDE

// styl
STYLE_POINT, // GLU_POINT
STYLE_LINE, // GLU_LINE
STYLE_FILL, // GLU_FILL
STYLE_SILHOUETTE, // GLU_SILHOUETTE

// obszar renderingu
FULL_WINDOW, // aspekt obrazu - całe okno
ASPECT_1_1, // aspekt obrazu 1:1
EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// rozmiary bryły obcinania

const GLdouble left = - 1.0;
const GLdouble right = 1.0;
const GLdouble bottom = - 1.0;
const GLdouble top = 1.0;
const GLdouble near = 3.0;
const GLdouble far = 7.0;

// kąty obrotu obiektu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;

// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;

// położenie kursora myszki

int button_x, button_y;

// współczynnik skalowania

GLfloat scale = 1.05;

// właściwości materiału - domyślnie mosiądz

const GLfloat * ambient = BrassAmbient;
const GLfloat * diffuse = BrassDiffuse;
const GLfloat * specular = BrassSpecular;
GLfloat shininess = BrassShininess;

// wyświetlany obiekt 3D

int object = SPHERE;

// wektory normalne

int normals = NORMALS_SMOOTH;

// orientacja

int orientation = GLU_OUTSIDE;

// styl

int style = GLU_FILL;

// ilość segmantów obiektu

int segments = 10;

// licznik ramek (FPS)

int frames = 0;

// licznik czasu

long start_time = 0;

// tablica znaków ze wartością FPS

char time_string[ 100 ] = "FPS:";

// funkcja rysująca napis w wybranym miejscu

void DrawString( GLfloat x, GLfloat y, char * string )
{
// położenie napisu
glRasterPos2f( x, y );

// wyświetlenie napisu
int len = strlen( string );
for( int i = 0; i < len; i++ )
   glutBitmapCharacter( GLUT_BITMAP_9_BY_15, string[ i ] );

}

// funkcja generująca scenę 3D

void Display()
{
// licznik czasu
if( !frames++ )
   start_time = clock();

// kolor tła - zawartość bufora koloru
glClearColor( 1.0, 1.0, 1.0, 1.0 );

// czyszczenie bufora koloru i bufora głębokości
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

// wybór macierzy modelowania
glMatrixMode( GL_MODELVIEW );

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// włączenie testu bufora głębokości
glEnable( GL_DEPTH_TEST );

// włączenie oświetlenia
glEnable( GL_LIGHTING );

// włączenie światła GL_LIGHT0 z parametrami domyślnymi
glEnable( GL_LIGHT0 );

// włączenie automatycznej normalizacji wektorów normalnych
glEnable( GL_NORMALIZE );

// przesunięcie układu współrzędnych obiektu do środka bryły odcinania
glTranslatef( 0, 0, -( near + far ) / 2 );

// obroty obiektu
glRotatef( rotatex, 1.0, 0, 0 );
glRotatef( rotatey, 0, 1.0, 0 );

// skalowanie obiektu - klawisze "+" i "-"
glScalef( scale, scale, scale );

// właściwości materiału
glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, ambient );
glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, specular );
glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, shininess );

// utworzenie kwadryki
GLUquadricObj * quadobj = gluNewQuadric();

// sposób generacji wektorów normalnych
gluQuadricNormals( quadobj, normals );

// styl ((wygląd) generowanej kwadryki
gluQuadricDrawStyle( quadobj, style );

// określenie orientacji wektorów normalnych kwadryki
gluQuadricOrientation( quadobj, orientation );

// wybór rysowanego obiektu 3D
switch( object )
{
case SPHERE:
gluSphere( quadobj, 1, segments, segments );
break;
case CYLINDER:
gluCylinder( quadobj, 0.5, 0.5, 1, segments, segments );
break;
case DISK:
gluDisk( quadobj, 0.5, 1.0, segments, segments );
break;
case PARTIAL_DISK:
gluPartialDisk( quadobj, 0.5, 1.0, segments, segments, 90, 180 );
break;
}

// usunięcie kwadryki
gluDeleteQuadric( quadobj );

// wyłączenie oświetlenia
glDisable( GL_LIGHTING );

// wyłączenie testu bufora głębokości
glDisable( GL_DEPTH_TEST );

// trzeba odpowiednio przekształcić układ współrzędnych
// aby napis znajdował się na samej "górze" bryły obcinania
glLoadIdentity();
glTranslatef( 0, 0, - near );

// komunikat o ilości ramek rysowanych na sekundę (FPS)
glColor3fv( Black );
if( frames == 1000 )
{
frames = 0;
sprintf( time_string, "FPS: %i",( int )( 1000 * CLOCKS_PER_SEC /( float )( clock() - start_time ) ) );
}

// narysowanie napisu
DrawString( left, bottom, time_string );

// skierowanie poleceń do wykonania
glFlush();

// zamiana buforów koloru
glutSwapBuffers();
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
// obszar renderingu - całe okno
glViewport( 0, 0, width, height );

// wybór macierzy rzutowania
glMatrixMode( GL_PROJECTION );

// macierz rzutowania = macierz jednostkowa
glLoadIdentity();

// parametry bryły obcinania
if( aspect == ASPECT_1_1 )
{
// wysokość okna większa od wysokości okna
if( width < height && width > 0 )
   glFrustum( left, right, bottom * height / width, top * height / width, near, far );
else

// szerokość okna większa lub równa wysokości okna
if( width >= height && height > 0 )
   glFrustum( left * width / height, right * width / height, bottom, top, near, far );

}
else
   glFrustum( left, right, bottom, top, near, far );

// generowanie sceny 3D
Display();
}

// obsługa klawiatury

void Keyboard( unsigned char key, int x, int y )
{
// klawisz +
if( key == '+' )
   scale += 0.05;
else

// klawisz -
if( key == '-' && scale > 0.05 )
   scale -= 0.05;

// narysowanie sceny
Display();
}

// obsługa przycisków myszki

void MouseButton( int button, int state, int x, int y )
{
if( button == GLUT_LEFT_BUTTON )
{
// zapamiętanie stanu lewego przycisku myszki
button_state = state;

// zapamiętanie położenia kursora myszki
if( state == GLUT_DOWN )
{
button_x = x;
button_y = y;
}
}
}

// obsługa ruchu kursora myszki

void MouseMotion( int x, int y )
{
if( button_state == GLUT_DOWN )
{
rotatey += 30 *( right - left ) / glutGet( GLUT_WINDOW_WIDTH ) *( x - button_x );
button_x = x;
rotatex -= 30 *( top - bottom ) / glutGet( GLUT_WINDOW_HEIGHT ) *( button_y - y );
button_y = y;
glutPostRedisplay();
}
}

// obsługa klawiszy funkcyjnych i klawiszy kursora

void SpecialKeys( int key, int x, int y )
{
switch( key )
{
// PageUp
case GLUT_KEY_PAGE_UP:
segments += 10;
break;

// PageDown
case GLUT_KEY_PAGE_DOWN:
if( segments > 10 )
   segments -= 10;

break;
}

// odrysowanie okna
Display();
}

// obsługa menu podręcznego

void Menu( int value )
{
switch( value )
{
// rysowany obiekt - kula
case SPHERE:
object = SPHERE;
Display();
break;

// rysowany obiekt - cylinder
case CYLINDER:
object = CYLINDER;
Display();
break;

// rysowany obiekt - dysk
case DISK:
object = DISK;
Display();
break;

// rysowany obiekt - częściowy dysk
case PARTIAL_DISK:
object = PARTIAL_DISK;
Display();
break;

// materiał - mosiądz
case BRASS:
ambient = BrassAmbient;
diffuse = BrassDiffuse;
specular = BrassSpecular;
shininess = BrassShininess;
Display();
break;

// materiał - brąz
case BRONZE:
ambient = BronzeAmbient;
diffuse = BronzeDiffuse;
specular = BronzeSpecular;
shininess = BronzeShininess;
Display();
break;

// materiał - polerowany brąz
case POLISHED_BRONZE:
ambient = PolishedBronzeAmbient;
diffuse = PolishedBronzeDiffuse;
specular = PolishedBronzeSpecular;
shininess = PolishedBronzeShininess;
Display();
break;

// materiał - chrom
case CHROME:
ambient = ChromeAmbient;
diffuse = ChromeDiffuse;
specular = ChromeSpecular;
shininess = ChromeShininess;
Display();
break;

// materiał - miedź
case COPPER:
ambient = CopperAmbient;
diffuse = CopperDiffuse;
specular = CopperSpecular;
shininess = CopperShininess;
Display();
break;

// materiał - polerowana miedź
case POLISHED_COPPER:
ambient = PolishedCopperAmbient;
diffuse = PolishedCopperDiffuse;
specular = PolishedCopperSpecular;
shininess = PolishedCopperShininess;
Display();
break;

// materiał - złoto
case GOLD:
ambient = GoldAmbient;
diffuse = GoldDiffuse;
specular = GoldSpecular;
shininess = GoldShininess;
Display();
break;

// materiał - polerowane złoto
case POLISHED_GOLD:
ambient = PolishedGoldAmbient;
diffuse = PolishedGoldDiffuse;
specular = PolishedGoldSpecular;
shininess = PolishedGoldShininess;
Display();
break;

// materiał - grafit (cyna z ołowiem)
case PEWTER:
ambient = PewterAmbient;
diffuse = PewterDiffuse;
specular = PewterSpecular;
shininess = PewterShininess;
Display();
break;

// materiał - srebro
case SILVER:
ambient = SilverAmbient;
diffuse = SilverDiffuse;
specular = SilverSpecular;
shininess = SilverShininess;
Display();
break;

// materiał - polerowane srebro
case POLISHED_SILVER:
ambient = PolishedSilverAmbient;
diffuse = PolishedSilverDiffuse;
specular = PolishedSilverSpecular;
shininess = PolishedSilverShininess;
Display();
break;

// materiał - szmaragd
case EMERALD:
ambient = EmeraldAmbient;
diffuse = EmeraldDiffuse;
specular = EmeraldSpecular;
shininess = EmeraldShininess;
Display();
break;

// materiał - jadeit
case JADE:
ambient = JadeAmbient;
diffuse = JadeDiffuse;
specular = JadeSpecular;
shininess = JadeShininess;
Display();
break;

// materiał - obsydian
case OBSIDIAN:
ambient = ObsidianAmbient;
diffuse = ObsidianDiffuse;
specular = ObsidianSpecular;
shininess = ObsidianShininess;
Display();
break;

// materiał - perła
case PEARL:
ambient = PearlAmbient;
diffuse = PearlDiffuse;
specular = PearlSpecular;
shininess = PearlShininess;
Display();
break;

// metariał - rubin
case RUBY:
ambient = RubyAmbient;
diffuse = RubyDiffuse;
specular = RubySpecular;
shininess = RubyShininess;
Display();
break;

// materiał - turkus
case TURQUOISE:
ambient = TurquoiseAmbient;
diffuse = TurquoiseDiffuse;
specular = TurquoiseSpecular;
shininess = TurquoiseShininess;
Display();
break;

// materiał - czarny plastik
case BLACK_PLASTIC:
ambient = BlackPlasticAmbient;
diffuse = BlackPlasticDiffuse;
specular = BlackPlasticSpecular;
shininess = BlackPlasticShininess;
Display();
break;

// materiał - czarna guma
case BLACK_RUBBER:
ambient = BlackRubberAmbient;
diffuse = BlackRubberDiffuse;
specular = BlackRubberSpecular;
shininess = BlackRubberShininess;
Display();
break;

// wektory normalne - GLU_SMOOTH
case NORMALS_SMOOTH:
normals = GLU_SMOOTH;
Display();
break;

// wektory normalne - GLU_FLAT
case NORMALS_FLAT:
normals = GLU_FLAT;
Display();
break;

// wektory normalne - GLU_NONE
case NORMALS_NONE:
normals = GLU_NONE;
Display();
break;

// orientacja - GLU_OUTSIDE
case ORIENTATION_OUTSIDE:
orientation = GLU_OUTSIDE;
Display();
break;

// orientacja - GLU_INSIDE
case ORIENTATION_INSIDE:
orientation = GLU_INSIDE;
Display();
break;

// styl - GLU_POINT
case STYLE_POINT:
style = GLU_POINT;
Display();
break;

// styl - GLU_LINE
case STYLE_LINE:
style = GLU_LINE;
Display();
break;

// styl - GLU_FILL
case STYLE_FILL:
style = GLU_FILL;
Display();
break;

// styl - GLU_SILHOUETTE
case STYLE_SILHOUETTE:
style = GLU_SILHOUETTE;
Display();
break;

// obszar renderingu - całe okno
case FULL_WINDOW:
aspect = FULL_WINDOW;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// obszar renderingu - aspekt 1:1
case ASPECT_1_1:
aspect = ASPECT_1_1;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// wyjście
case EXIT:
exit( 0 );
}
}

int main( int argc, char * argv[] )
{
// inicjalizacja biblioteki GLUT
glutInit( & argc, argv );

// inicjalizacja bufora ramki
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );

// rozmiary głównego okna programu
glutInitWindowSize( 500, 500 );

// utworzenie głównego okna programu
#ifdef WIN32

glutCreateWindow( "Materiały" );
#else

glutCreateWindow( "Materialy" );
#endif

// dołączenie funkcji generującej scenę 3D
glutDisplayFunc( Display );

// dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
glutReshapeFunc( Reshape );

// dołączenie funkcji obsługi klawiatury
glutKeyboardFunc( Keyboard );

// dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
glutSpecialFunc( SpecialKeys );

// obsługa przycisków myszki
glutMouseFunc( MouseButton );

// obsługa ruchu kursora myszki
glutMotionFunc( MouseMotion );

// utworzenie menu podręcznego
glutCreateMenu( Menu );

// utworzenie podmenu - obiekt
int MenuObject = glutCreateMenu( Menu );
glutAddMenuEntry( "Kula", SPHERE );
glutAddMenuEntry( "Cylinder", CYLINDER );
glutAddMenuEntry( "Dysk", DISK );
#ifdef WIN32

glutAddMenuEntry( "Częściowy dysk", PARTIAL_DISK );
#else

glutAddMenuEntry( "Czesciowy dysk", PARTIAL_DISK );
#endif

// utworzenie podmenu - Materiał
int MenuMaterial = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Mosiądz", BRASS );
glutAddMenuEntry( "Brąz", BRONZE );
glutAddMenuEntry( "Polerowany brąz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedź", COPPER );
glutAddMenuEntry( "Polerowana miedź", POLISHED_COPPER );
glutAddMenuEntry( "Złoto", GOLD );
glutAddMenuEntry( "Polerowane złoto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perła", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#else

glutAddMenuEntry( "Mosiadz", BRASS );
glutAddMenuEntry( "Braz", BRONZE );
glutAddMenuEntry( "Polerowany braz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedz", COPPER );
glutAddMenuEntry( "Polerowana miedz", POLISHED_COPPER );
glutAddMenuEntry( "Zloto", GOLD );
glutAddMenuEntry( "Polerowane zloto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perla", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#endif

// utworzenie podmenu - Wektory normalne
int MenuNormals = glutCreateMenu( Menu );
glutAddMenuEntry( "GLU_SMOOTH", NORMALS_SMOOTH );
glutAddMenuEntry( "GLU_FLAT", NORMALS_FLAT );
glutAddMenuEntry( "GLU_NONE", NORMALS_NONE );

// utworzenie podmenu - Orientacja
int MenuOrientation = glutCreateMenu( Menu );
glutAddMenuEntry( "GLU_OUTSIDE", ORIENTATION_OUTSIDE );
glutAddMenuEntry( "GLU_INSIDE", ORIENTATION_INSIDE );

// utworzenie podmenu - Styl
int MenuStyle = glutCreateMenu( Menu );
glutAddMenuEntry( "GLU_POINT", STYLE_POINT );
glutAddMenuEntry( "GLU_LINE", STYLE_LINE );
glutAddMenuEntry( "GLU_FILL", STYLE_FILL );
glutAddMenuEntry( "GLU_SILHOUETTE", STYLE_SILHOUETTE );

// utworzenie podmenu - Aspekt obrazu
int MenuAspect = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Aspekt obrazu - całe okno", FULL_WINDOW );
#else

glutAddMenuEntry( "Aspekt obrazu - cale okno", FULL_WINDOW );
#endif

glutAddMenuEntry( "Aspekt obrazu 1:1", ASPECT_1_1 );

// menu główne
glutCreateMenu( Menu );
glutAddSubMenu( "Obiekt", MenuObject );

#ifdef WIN32

glutAddSubMenu( "Materiał", MenuMaterial );
#else

glutAddSubMenu( "Material", MenuMaterial );
#endif

glutAddSubMenu( "Wektory normalne", MenuNormals );
glutAddSubMenu( "Orientacja", MenuOrientation );
glutAddSubMenu( "Styl", MenuStyle );
glutAddSubMenu( "Aspekt obrazu", MenuAspect );
#ifdef WIN32

glutAddMenuEntry( "Wyjście", EXIT );
#else

glutAddMenuEntry( "Wyjscie", EXIT );
#endif

// określenie przycisku myszki obsługującej menu podręczne
glutAttachMenu( GLUT_RIGHT_BUTTON );

// funkcja bezczynności
glutIdleFunc( Display );

// wprowadzenie programu do obsługi pętli komunikatów
glutMainLoop();
return 0;
}

Kolejny program przykładowy (plik wektory normalne.cpp) przedstawia dwa opisane wcześniej sposoby generowania wektorów normalnych. Ale zanim przejdziemy do opisu obliczania wektorów normalnych popatrzmy na sposób opisu bryły wyświetlanej przez program - dwudziestościanu foremnego.
Dwudziestościan opisany jest przez dwie tablice. Pierwsza tablica vertex opisuje współrzędne położenia wierzchołków figury. Druga tablica triangles zawiera opis poszczególnych trójkątów, z których składa się dwudziestościan. Jedną z cech takiego rodzaju opis bryły jest łatwość obliczania wektorów normalnych. W przypadku, gdy do obliczamy wektor normalny dla ściany, wystarczy skorzystać z iloczynu wektorowego, przy czym składniki tego iloczynu stanowią wektory utworzone z dwóch boków trójkąta. W przykładowym programie realizuje to funkcja Normal. Natomiast w przypadku, gdy obliczamy wektor normalny dla każdego wierzchołka, program przegląda listę ścian (tablica triangles) wybierając te ściany, w skład których wchodzi bieżący wierzchołek i dokonuje sumowania wektorów normalnych każdej z wybranych ścian. Wykorzystany do tego celu algorytm jest wprawdzie prosty, ale także bardzo czasochłonny. Najprostszym sposobem jego optymalizacji jest jednokrotne obliczenie wektora normalnego każdej ze ścian i zapamiętanie wyników w tablicy.
Normalizacja wektorów normalnych realizowana jest w programie na dwa spsoby. Jeżeli implementacja biblioteki OpenGL obsługuje rozszerzenie EXT rescale normal, lub jest to wersja co najmniej 1.2, program korzysta z opisanego wcześniej mechanizmu automatycznego skalowania jednostkowych wektorów normalnych. W przeciwnym wypadku całość obliczeń związanych z normalizacją wykonuje biblioteka OpenGL, a funkcja Normalize, która wykonuje normalizację, nie jest wykorzystywana.
Efekty działania programu przedstawiają dwa rysunki. Pierwszy z nich (rysunek nr 11) przedstawia obiekt z wektorami normalnymi generowanymi dla każdego wierzchołka. Na rysunku łatwo można dostrzec charakterystyczne linie pokrywające się z krawędziami obiektu. Nieciągłości te, zwane pasmami Macha, są jedną z wad cieniowania Gourauda zastosowanego w bibliotece OpenGL. Na rysunku nr 12 przedstawiono bryłę w tym samym powiększeniu i położeniu, ale z wektorami normalnymi generowanymi dla każdej ściany.

Rysunek 11. Program Wektory normalne - wektory normalne generowane dla każdego wierzchołka

Plik wektory_normalne.cpp

Rysunek 12. Program Wektory normalne - wektory normalne generowane dla ściany

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glut.h>
#include <GL/glext.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "materials.h"

// wskaźnik dostępności rozszerzenia EXT_rescale_normal

bool rescale_normal = false;

// stałe do obsługi menu podręcznego

enum
{
BRASS, // mosiądz
BRONZE, // brąz
POLISHED_BRONZE, // polerowany brąz
CHROME, // chrom
COPPER, // miedź
POLISHED_COPPER, // polerowana miedź
GOLD, // złoto
POLISHED_GOLD, // polerowane złoto
PEWTER, // grafit (cyna z ołowiem)
SILVER, // srebro
POLISHED_SILVER, // polerowane srebro
EMERALD, // szmaragd
JADE, // jadeit
OBSIDIAN, // obsydian
PEARL, // perła
RUBY, // rubin
TURQUOISE, // turkus
BLACK_PLASTIC, // czarny plastik
BLACK_RUBBER, // czarna guma
NORMALS_SMOOTH, // jeden wektor normalny na wierzchołek
NORMALS_FLAT, // jeden wektor normalny na ścianę
FULL_WINDOW, // aspekt obrazu - całe okno
ASPECT_1_1, // aspekt obrazu 1:1
EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// usunięcie definicji makr near i far

#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif

// rozmiary bryły obcinania

const GLdouble left = - 1.0;
const GLdouble right = 1.0;
const GLdouble bottom = - 1.0;
const GLdouble top = 1.0;
const GLdouble near = 3.0;
const GLdouble far = 7.0;

// kąty obrotu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;

// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;

// położenie kursora myszki

int button_x, button_y;

// współczynnik skalowania

GLfloat scale = 1.0;

// właściwości materiału - domyślnie mosiądz

const GLfloat * ambient = BrassAmbient;
const GLfloat * diffuse = BrassDiffuse;
const GLfloat * specular = BrassSpecular;
GLfloat shininess = BrassShininess;

// wektory normalne

int normals = NORMALS_FLAT;

// współrzędne wierzchołków dwudziestościanu

GLfloat vertex[ 12 * 3 ] =
{
0.000, 0.667, 0.500, // v0
0.000, 0.667, - 0.500, // v1
0.000, - 0.667, - 0.500, // v2
0.000, - 0.667, 0.500, // v3
0.667, 0.500, 0.000, // v4
0.667, - 0.500, 0.000, // v5
- 0.667, - 0.500, 0.000, // v6
- 0.667, 0.500, 0.000, // v7
0.500, 0.000, 0.667, // v8
- 0.500, 0.000, 0.667, // v9
- 0.500, 0.000, - 0.667, // v10
0.500, 0.000, - 0.667 // v11
};

// opis ścian dwudziestościanu

int triangles[ 20 * 3 ] =
{
2, 10, 11,
1, 11, 10,
1, 10, 7,
1, 4, 11,
0, 1, 7,
0, 4, 1,
0, 9, 8,
3, 8, 9,
0, 7, 9,
0, 8, 4,
3, 9, 6,
3, 5, 8,
2, 3, 6,
2, 5, 3,
2, 6, 10,
2, 11, 5,
6, 7, 10,
6, 9, 7,
4, 5, 11,
4, 8, 5
};

// obliczanie wektora normalnego dla wybranej ściany

void Normal( GLfloat * n, int i )
{
GLfloat v1[ 3 ], v2[ 3 ];

// obliczenie wektorów na podstawie współrzędnych wierzchołków trójkątów
v1[ 0 ] = vertex[ 3 * triangles[ 3 * i + 1 ] + 0 ] - vertex[ 3 * triangles[ 3 * i + 0 ] + 0 ];
v1[ 1 ] = vertex[ 3 * triangles[ 3 * i + 1 ] + 1 ] - vertex[ 3 * triangles[ 3 * i + 0 ] + 1 ];
v1[ 2 ] = vertex[ 3 * triangles[ 3 * i + 1 ] + 2 ] - vertex[ 3 * triangles[ 3 * i + 0 ] + 2 ];
v2[ 0 ] = vertex[ 3 * triangles[ 3 * i + 2 ] + 0 ] - vertex[ 3 * triangles[ 3 * i + 1 ] + 0 ];
v2[ 1 ] = vertex[ 3 * triangles[ 3 * i + 2 ] + 1 ] - vertex[ 3 * triangles[ 3 * i + 1 ] + 1 ];
v2[ 2 ] = vertex[ 3 * triangles[ 3 * i + 2 ] + 2 ] - vertex[ 3 * triangles[ 3 * i + 1 ] + 2 ];

// obliczenie waktora normalnego przy pomocy iloczynu wektorowego
n[ 0 ] = v1[ 1 ] * v2[ 2 ] - v1[ 2 ] * v2[ 1 ];
n[ 1 ] = v1[ 2 ] * v2[ 0 ] - v1[ 0 ] * v2[ 2 ];
n[ 2 ] = v1[ 0 ] * v2[ 1 ] - v1[ 1 ] * v2[ 0 ];
}

// normalizacja wektora

void Normalize( GLfloat * v )
{
// obliczenie długości wektora
GLfloat d = sqrt( v[ 0 ] * v[ 0 ] + v[ 1 ] * v[ 1 ] + v[ 2 ] * v[ 2 ] );

// normalizacja wektora
if( d )
{
v[ 0 ] /= d;
v[ 1 ] /= d;
v[ 2 ] /= d;
}
}

// funkcja generująca scenę 3D

void Display()
{
// kolor tła - zawartość bufora koloru
glClearColor( 1.0, 1.0, 1.0, 1.0 );

// czyszczenie bufora koloru i bufora głębokości
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

// wybór macierzy modelowania
glMatrixMode( GL_MODELVIEW );

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// przesunięcie układu współrzędnych obiektu do środka bryły odcinania
glTranslatef( 0, 0, -( near + far ) / 2 );

// obroty obiektu
glRotatef( rotatex, 1.0, 0, 0 );
glRotatef( rotatey, 0, 1.0, 0 );

// skalowanie obiektu - klawisze "+" i "-"
glScalef( scale, scale, scale );

// włączenie testu bufora głębokości
glEnable( GL_DEPTH_TEST );

// włączenie oświetlenia
glEnable( GL_LIGHTING );

// włączenie światła GL_LIGHT0 z parametrami domyślnymi
glEnable( GL_LIGHT0 );

// właściwości materiału
glMaterialfv( GL_FRONT, GL_AMBIENT, ambient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, diffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, specular );
glMaterialf( GL_FRONT, GL_SHININESS, shininess );

// włączenie automatycznej normalizacji wektorów normalnych
// lub automatycznego skalowania jednostkowych wektorów normalnych
if( rescale_normal == true )
   glEnable( GL_RESCALE_NORMAL );
else
   glEnable( GL_NORMALIZE );

// początek definicji obiektu
glBegin( GL_TRIANGLES );

// generowanie obiektu gładkiego - jeden uśredniony
// wektor normalny na wierzchołek
if( normals == NORMALS_SMOOTH )
for( int i = 0; i < 20; i++ )
{
// obliczanie wektora normalnego dla pierwszego wierzchołka
GLfloat n[ 3 ];
n[ 0 ] = n[ 1 ] = n[ 2 ] = 0.0;

// wyszukanie wszystkich ścian posiadających bieżący wierzchołek
for( int j = 0; j < 20; j++ )
if( 3 * triangles[ 3 * i + 0 ] == 3 * triangles[ 3 * j + 0 ] ||
3 * triangles[ 3 * i + 0 ] == 3 * triangles[ 3 * j + 1 ] ||
3 * triangles[ 3 * i + 0 ] == 3 * triangles[ 3 * j + 2 ] )
{
// dodawanie wektorów normalnych poszczególnych ścian
GLfloat nv[ 3 ];
Normal( nv, j );
n[ 0 ] += nv[ 0 ];
n[ 1 ] += nv[ 1 ];
n[ 2 ] += nv[ 2 ];
}

// uśredniony wektor normalny jest normalizowany tylko, gdy biblioteka
// obsługuje automatyczne skalowania jednostkowych wektorów normalnych
if( rescale_normal == true )
   Normalize( n );

glNormal3fv( n );
glVertex3fv( & vertex[ 3 * triangles[ 3 * i + 0 ] ] );

// obliczanie wektora normalnego dla drugiego wierzchołka
n[ 0 ] = n[ 1 ] = n[ 2 ] = 0.0;

// wyszukanie wszystkich ścian posiadających bieżący wierzchołek
for( int j = 0; j < 20; j++ )
if( 3 * triangles[ 3 * i + 1 ] == 3 * triangles[ 3 * j + 0 ] ||
3 * triangles[ 3 * i + 1 ] == 3 * triangles[ 3 * j + 1 ] ||
3 * triangles[ 3 * i + 1 ] == 3 * triangles[ 3 * j + 2 ] )
{
// dodawanie wektorów normalnych poszczególnych ścian
GLfloat nv[ 3 ];
Normal( nv, j );
n[ 0 ] += nv[ 0 ];
n[ 1 ] += nv[ 1 ];
n[ 2 ] += nv[ 2 ];
}

// uśredniony wektor normalny jest normalizowany tylko, gdy biblioteka
// obsługuje automatyczne skalowania jednostkowych wektorów normalnych
if( rescale_normal == true )
   Normalize( n );

glNormal3fv( n );
glVertex3fv( & vertex[ 3 * triangles[ 3 * i + 1 ] ] );

// obliczanie wektora normalnego dla trzeciego wierzchołka
n[ 0 ] = n[ 1 ] = n[ 2 ] = 0.0;

// wyszukanie wszystkich ścian posiadających bieżący wierzchołek
for( int j = 0; j < 20; j++ )
if( 3 * triangles[ 3 * i + 2 ] == 3 * triangles[ 3 * j + 0 ] ||
3 * triangles[ 3 * i + 2 ] == 3 * triangles[ 3 * j + 1 ] ||
3 * triangles[ 3 * i + 2 ] == 3 * triangles[ 3 * j + 2 ] )
{
// dodawanie wektorów normalnych poszczególnych ścian
GLfloat nv[ 3 ];
Normal( nv, j );
n[ 0 ] += nv[ 0 ];
n[ 1 ] += nv[ 1 ];
n[ 2 ] += nv[ 2 ];
}

// uśredniony wektor normalny jest normalizowany tylko, gdy biblioteka
// obsługuje automatyczne skalowania jednostkowych wektorów normalnych
if( rescale_normal == true )
   Normalize( n );

glNormal3fv( n );
glVertex3fv( & vertex[ 3 * triangles[ 3 * i + 2 ] ] );
}
else

// generowanie obiektu "płaskiego" - jeden wektor normalny na ścianę
for( int i = 0; i < 20; i++ )
{
GLfloat n[ 3 ];
Normal( n, i );

// uśredniony wektor normalny jest normalizowany tylko, gdy biblioteka
// obsługuje automatyczne skalowania jednostkowych wektorów normalnych
if( rescale_normal == true )
   Normalize( n );

glNormal3fv( n );
glVertex3fv( & vertex[ 3 * triangles[ 3 * i + 0 ] ] );
glVertex3fv( & vertex[ 3 * triangles[ 3 * i + 1 ] ] );
glVertex3fv( & vertex[ 3 * triangles[ 3 * i + 2 ] ] );
}

// koniec definicji obiektu
glEnd();

// skierowanie poleceń do wykonania
glFlush();

// zamiana buforów koloru
glutSwapBuffers();
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
// obszar renderingu - całe okno
glViewport( 0, 0, width, height );

// wybór macierzy rzutowania
glMatrixMode( GL_PROJECTION );

// macierz rzutowania = macierz jednostkowa
glLoadIdentity();

// parametry bryły obcinania
if( aspect == ASPECT_1_1 )
{
// wysokość okna większa od wysokości okna
if( width < height && width > 0 )
   glFrustum( left, right, bottom * height / width, top * height / width, near, far );
else

// szerokość okna większa lub równa wysokości okna
if( width >= height && height > 0 )
   glFrustum( left * width / height, right * width / height, bottom, top, near, far );

}
else
   glFrustum( left, right, bottom, top, near, far );

// generowanie sceny 3D
Display();
}

// obsługa klawiatury

void Keyboard( unsigned char key, int x, int y )
{
// klawisz +
if( key == '+' )
   scale += 0.05;
else

// klawisz -
if( key == '-' && scale > 0.05 )
   scale -= 0.05;

// narysowanie sceny
Display();
}

// obsługa klawiszy funkcyjnych i klawiszy kursora

void SpecialKeys( int key, int x, int y )
{
switch( key )
{
// kursor w lewo
case GLUT_KEY_LEFT:
rotatey -= 1;
break;

// kursor w górę
case GLUT_KEY_UP:
rotatex -= 1;
break;

// kursor w prawo
case GLUT_KEY_RIGHT:
rotatey += 1;
break;

// kursor w dół
case GLUT_KEY_DOWN:
rotatex += 1;
break;
}

// odrysowanie okna
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}

// obsługa przycisków myszki

void MouseButton( int button, int state, int x, int y )
{
if( button == GLUT_LEFT_BUTTON )
{
// zapamiętanie stanu lewego przycisku myszki
button_state = state;

// zapamiętanie położenia kursora myszki
if( state == GLUT_DOWN )
{
button_x = x;
button_y = y;
}
}
}

// obsługa ruchu kursora myszki

void MouseMotion( int x, int y )
{
if( button_state == GLUT_DOWN )
{
rotatey += 30 *( right - left ) / glutGet( GLUT_WINDOW_WIDTH ) *( x - button_x );
button_x = x;
rotatex -= 30 *( top - bottom ) / glutGet( GLUT_WINDOW_HEIGHT ) *( button_y - y );
button_y = y;
glutPostRedisplay();
}
}

// obsługa menu podręcznego

void Menu( int value )
{
switch( value )
{
// materiał - mosiądz
case BRASS:
ambient = BrassAmbient;
diffuse = BrassDiffuse;
specular = BrassSpecular;
shininess = BrassShininess;
Display();
break;

// materiał - brąz
case BRONZE:
ambient = BronzeAmbient;
diffuse = BronzeDiffuse;
specular = BronzeSpecular;
shininess = BronzeShininess;
Display();
break;

// materiał - polerowany brąz
case POLISHED_BRONZE:
ambient = PolishedBronzeAmbient;
diffuse = PolishedBronzeDiffuse;
specular = PolishedBronzeSpecular;
shininess = PolishedBronzeShininess;
Display();
break;

// materiał - chrom
case CHROME:
ambient = ChromeAmbient;
diffuse = ChromeDiffuse;
specular = ChromeSpecular;
shininess = ChromeShininess;
Display();
break;

// materiał - miedź
case COPPER:
ambient = CopperAmbient;
diffuse = CopperDiffuse;
specular = CopperSpecular;
shininess = CopperShininess;
Display();
break;

// materiał - polerowana miedź
case POLISHED_COPPER:
ambient = PolishedCopperAmbient;
diffuse = PolishedCopperDiffuse;
specular = PolishedCopperSpecular;
shininess = PolishedCopperShininess;
Display();
break;

// materiał - złoto
case GOLD:
ambient = GoldAmbient;
diffuse = GoldDiffuse;
specular = GoldSpecular;
shininess = GoldShininess;
Display();
break;

// materiał - polerowane złoto
case POLISHED_GOLD:
ambient = PolishedGoldAmbient;
diffuse = PolishedGoldDiffuse;
specular = PolishedGoldSpecular;
shininess = PolishedGoldShininess;
Display();
break;

// materiał - grafit (cyna z ołowiem)
case PEWTER:
ambient = PewterAmbient;
diffuse = PewterDiffuse;
specular = PewterSpecular;
shininess = PewterShininess;
Display();
break;

// materiał - srebro
case SILVER:
ambient = SilverAmbient;
diffuse = SilverDiffuse;
specular = SilverSpecular;
shininess = SilverShininess;
Display();
break;

// materiał - polerowane srebro
case POLISHED_SILVER:
ambient = PolishedSilverAmbient;
diffuse = PolishedSilverDiffuse;
specular = PolishedSilverSpecular;
shininess = PolishedSilverShininess;
Display();
break;

// materiał - szmaragd
case EMERALD:
ambient = EmeraldAmbient;
diffuse = EmeraldDiffuse;
specular = EmeraldSpecular;
shininess = EmeraldShininess;
Display();
break;

// materiał - jadeit
case JADE:
ambient = JadeAmbient;
diffuse = JadeDiffuse;
specular = JadeSpecular;
shininess = JadeShininess;
Display();
break;

// materiał - obsydian
case OBSIDIAN:
ambient = ObsidianAmbient;
diffuse = ObsidianDiffuse;
specular = ObsidianSpecular;
shininess = ObsidianShininess;
Display();
break;

// materiał - perła
case PEARL:
ambient = PearlAmbient;
diffuse = PearlDiffuse;
specular = PearlSpecular;
shininess = PearlShininess;
Display();
break;

// metariał - rubin
case RUBY:
ambient = RubyAmbient;
diffuse = RubyDiffuse;
specular = RubySpecular;
shininess = RubyShininess;
Display();
break;

// materiał - turkus
case TURQUOISE:
ambient = TurquoiseAmbient;
diffuse = TurquoiseDiffuse;
specular = TurquoiseSpecular;
shininess = TurquoiseShininess;
Display();
break;

// materiał - czarny plastik
case BLACK_PLASTIC:
ambient = BlackPlasticAmbient;
diffuse = BlackPlasticDiffuse;
specular = BlackPlasticSpecular;
shininess = BlackPlasticShininess;
Display();
break;

// materiał - czarna guma
case BLACK_RUBBER:
ambient = BlackRubberAmbient;
diffuse = BlackRubberDiffuse;
specular = BlackRubberSpecular;
shininess = BlackRubberShininess;
Display();
break;

// wektory normalne - GLU_SMOOTH
case NORMALS_SMOOTH:
normals = NORMALS_SMOOTH;
Display();
break;

// wektory normalne - GLU_FLAT
case NORMALS_FLAT:
normals = NORMALS_FLAT;
Display();
break;

// obszar renderingu - całe okno
case FULL_WINDOW:
aspect = FULL_WINDOW;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// obszar renderingu - aspekt 1:1
case ASPECT_1_1:
aspect = ASPECT_1_1;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// wyjście
case EXIT:
exit( 0 );
}
}

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń

void ExtensionSetup()
{
// pobranie numeru wersji biblioteki OpenGL
const char * version =( char * ) glGetString( GL_VERSION );

// odczyt wersji OpenGL
int major = 0, minor = 0;
if( sscanf( version, "%d.%d", & major, & minor ) != 2 )
{
#ifndef WIN32
printf( "Błędny format wersji OpenGL\n" );
#else

printf( "Bledny format wersji OpenGL\n" );
#endif

exit( 0 );
}

// sprawdzenie czy jest co najmniej wersja 1.2
if( major > 1 || minor >= 2 )
   rescale_normal = true;
else
// sprawdzenie czy jest obsługiwane rozszerzenie EXT_rescale_normal
if( glutExtensionSupported( "GL_EXT_rescale_normal" ) )
   rescale_normal = true;

}

int main( int argc, char * argv[] )
{
// inicjalizacja biblioteki GLUT
glutInit( & argc, argv );

// inicjalizacja bufora ramki
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );

// rozmiary głównego okna programu
glutInitWindowSize( 500, 500 );

// utworzenie głównego okna programu
glutCreateWindow( "Wektory normalne" );

// dołączenie funkcji generującej scenę 3D
glutDisplayFunc( Display );

// dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
glutReshapeFunc( Reshape );

// dołączenie funkcji obsługi klawiatury
glutKeyboardFunc( Keyboard );

// dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
glutSpecialFunc( SpecialKeys );

// obsługa przycisków myszki
glutMouseFunc( MouseButton );

// obsługa ruchu kursora myszki
glutMotionFunc( MouseMotion );

// utworzenie menu podręcznego
glutCreateMenu( Menu );

// utworzenie podmenu - Materiał
int MenuMaterial = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Mosiądz", BRASS );
glutAddMenuEntry( "Brąz", BRONZE );
glutAddMenuEntry( "Polerowany brąz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedź", COPPER );
glutAddMenuEntry( "Polerowana miedź", POLISHED_COPPER );
glutAddMenuEntry( "Złoto", GOLD );
glutAddMenuEntry( "Polerowane złoto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perła", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#else

glutAddMenuEntry( "Mosiadz", BRASS );
glutAddMenuEntry( "Braz", BRONZE );
glutAddMenuEntry( "Polerowany braz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedz", COPPER );
glutAddMenuEntry( "Polerowana miedz", POLISHED_COPPER );
glutAddMenuEntry( "Zloto", GOLD );
glutAddMenuEntry( "Polerowane zloto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perla", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#endif

// utworzenie podmenu - Wektory normalne
int MenuNormals = glutCreateMenu( Menu );
#ifndef WIN32

glutAddMenuEntry( "Jeden wektor normalny na wierzcholek", NORMALS_SMOOTH );
glutAddMenuEntry( "Jeden wektor normalny na sciane", NORMALS_FLAT );
#else

glutAddMenuEntry( "Jeden wektor normalny na wierzchołek", NORMALS_SMOOTH );
glutAddMenuEntry( "Jeden wektor normalny na ścianę", NORMALS_FLAT );
#endif

// utworzenie podmenu - aspekt obrazu
int MenuAspect = glutCreateMenu( Menu );
#ifndef WIN32

glutAddMenuEntry( "Aspekt obrazu - całe okno", FULL_WINDOW );
#else

glutAddMenuEntry( "Aspekt obrazu - cale okno", FULL_WINDOW );
#endif

glutAddMenuEntry( "Aspekt obrazu 1:1", ASPECT_1_1 );

// menu główne
glutCreateMenu( Menu );

#ifdef WIN32

glutAddSubMenu( "Materiał", MenuMaterial );
#else

glutAddSubMenu( "Material", MenuMaterial );
#endif

glutAddSubMenu( "Wektory normalne", MenuNormals );
glutAddSubMenu( "Aspekt obrazu", MenuAspect );
#ifndef WIN32

glutAddMenuEntry( "Wyjście", EXIT );
#else

glutAddMenuEntry( "Wyjscie", EXIT );
#endif

// określenie przycisku myszki obsługującej menu podręczne
glutAttachMenu( GLUT_RIGHT_BUTTON );

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń
ExtensionSetup();

// wprowadzenie programu do obsługi pętli komunikatów
glutMainLoop();
return 0;
}

Czwarty program przykładowy (plik swiatlo kierunkowe.cpp) prezentuje podstawową właściwość światła kierunkowego, czyli możliwość zmiany kierunku, z którego padają promienie światła. Wektor kierunku źródła światła jest modyfikowany zgodnie z przekształceniami macierzy modelowania, stąd, aby zmiana kierunku źródła światła odbywała się w sposób niezależny od obrotu obiektu umieszczonego na scenie, macierz modelowania należy odłożyć na stos korzystając z funkcji glPushMatrix. Po wykonaniu niezbędnych przekształceń (w przypadku światła kierunkowego będą to oczywiście tylko obroty), przywracamy odłożoną na stos macierz modelowania, wywołując funkcję glPopMatrix. Aby przekształcenie kierunku światła zostały wykonane trzeba jeszcze dla wybranego źródła światła wywołać funkcję glLightfv (lub inną z tej grupy) podając przy tym tablicę zawierającą wektor z kierunkiem źródła światła.
W odróżnieniu od drugiego programu przykładowego do rysowania obiektów w omawianym programie użyto funkcji z biblioteki GLUT. Dwie z nich (rysujące kulę i sześcian) omówiliśmy już wcześniej. Pozostałe funkcje nie różną się parametrami od ich wcześniej opisywanych wersji rysujących obiekty w postaci siatek krawędzi.
Stożek (rysunek 15), składający się z równoległych do podstawy „południków” i tworzących biegnących od wierzchołka do krawędzi podstawy stożka, rysuje funkcja:

void glutSolidCone( GLdouble base, GLdouble height, GLint slices, GLint stacks )

której parametry oznaczaja:

base - promień podstawy stożka,
height - wysokość stożka,
slices - ilość tworzących,
stacks - ilość „południków”.

Torus (rysunek 16), składający się z serii walców o nierównoległych podstawach, rysuje funkcja:

void glutSolidTorus( GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings )

której parametry oznaczają odpowiednio:

innerRadius - promień koła tworzącego torus,
outerRadius - promień torusa,
sides - ilość ścian bocznych, z których składa się pojedynczy walec,
rings - ilość walców, z których składa sie torus.

Czajnik o wielkości regulowanej parametrem size rysuje funkcja:

void glutSolidTeapot( GLdouble size )

Pozostałe użyte w programie funkcje rysują bryły Platońskie. Są to kolejno: dwunastościan (rysunek 17), ośmiościan, czworościan i dwudziestościan:

void glutSolidDodecahedron()
void glutSolidOctahedron()
void glutSolidTetrahedron()
void glutSolidIcosahedron()

Ponadto w programie wykorzystano funkcję glWindowPos2i wprowadzoną w wersji 1.4 biblioteki OpenGL, a wcześniej dostępną w opisywanym już rozszerzeniu ARB window pos. Funkcja ta została zastosowana do pozycjonowania tekstów wyświetlanych w oknie programu. A są to współrzędne określające kierunek źródła światła oraz kąty obrotu kierunku źródła światła.

Rysunek 13. Program Światło kierunkowe - rubinowy czajnik

Plik swiatlo_kierunkowe.cpp

Rysunek 14. Program Światło kierunkowe - jadeitowa kula

Rysunek 15. Program Światło kierunkowe - złoty stożek

Rysunek 16. Program Światło kierunkowe - szmaragdowy torus

Rysunek 17. Program Światło kierunkowe - grafitowy dwunastościan

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glut.h>
#include <GL/glext.h>
#ifndef WIN32
#define GLX_GLXEXT_LEGACY
#include <GL/glx.h>
#define wglGetProcAddress glXGetProcAddressARB
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "colors.h"
#include "materials.h"

// wskaźnik na funkcję glWindowPos2i

PFNGLWINDOWPOS2IPROC glWindowPos2i = NULL;

// stałe do obsługi menu podręcznego

enum
{
// obiekty
SPHERE, // kula
TEAPOT, // czajnik
CONE, // stożek
TORUS, // torus
CUBE, // sześcian
DODECAHEDRON, // dwunastościan
OCTAHEDRON, // ośmiościan
TETRAHEDRON, // czworościan
ICOSAHEDRON, // dwudziestościan

// materiały
BRASS, // mosiądz
BRONZE, // brąz
POLISHED_BRONZE, // polerowany brąz
CHROME, // chrom
COPPER, // miedź
POLISHED_COPPER, // polerowana miedź
GOLD, // złoto
POLISHED_GOLD, // polerowane złoto
PEWTER, // grafit (cyna z ołowiem)
SILVER, // srebro
POLISHED_SILVER, // polerowane srebro
EMERALD, // szmaragd
JADE, // jadeit
OBSIDIAN, // obsydian
PEARL, // perła
RUBY, // rubin
TURQUOISE, // turkus
BLACK_PLASTIC, // czarny plastik
BLACK_RUBBER, // czarna guma

// obszar renderingu
FULL_WINDOW, // aspekt obrazu - całe okno
ASPECT_1_1, // aspekt obrazu 1:1
EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// usunięcie definicji makr near i far

#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif

// rozmiary bryły obcinania

const GLdouble left = - 2.0;
const GLdouble right = 2.0;
const GLdouble bottom = - 2.0;
const GLdouble top = 2.0;
const GLdouble near = 3.0;
const GLdouble far = 7.0;

// kąty obrotu obiektu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;

// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;

// położenie kursora myszki

int button_x, button_y;

// współczynnik skalowania

GLfloat scale = 1.0;

// właściwości materiału - domyślnie mosiądz

const GLfloat * ambient = BrassAmbient;
const GLfloat * diffuse = BrassDiffuse;
const GLfloat * specular = BrassSpecular;
GLfloat shininess = BrassShininess;

// wyświetlany obiekt 3D

int object = SPHERE;

// kierunek źródła światła

GLfloat light_position[ 4 ] =
{
0.0, 0.0, 2.0, 0.0
};

// kąty obrotu kierunku źródła światła

GLfloat light_rotatex = 0.0;
GLfloat light_rotatey = 0.0;

// funkcja rysująca napis w wybranym miejscu
// (wersja korzystająca z funkcji glWindowPos2i)

void DrawString( GLint x, GLint y, char * string )
{
// położenie napisu
glWindowPos2i( x, y );

// wyświetlenie napisu
int len = strlen( string );
for( int i = 0; i < len; i++ )
   glutBitmapCharacter( GLUT_BITMAP_9_BY_15, string[ i ] );

}
// funkcja generująca scenę 3D

void DisplayScene()
{
// kolor tła - zawartość bufora koloru
glClearColor( 1.0, 1.0, 1.0, 1.0 );

// czyszczenie bufora koloru i bufora głębokości
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

// wybór macierzy modelowania
glMatrixMode( GL_MODELVIEW );

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// włączenie testu bufora głębokości
glEnable( GL_DEPTH_TEST );

// włączenie oświetlenia
glEnable( GL_LIGHTING );

// włączenie światła GL_LIGHT0
glEnable( GL_LIGHT0 );

// włączenie automatycznej normalizacji wektorów normalnych
glEnable( GL_NORMALIZE );

// przesunięcie układu współrzędnych obiektu do środka bryły odcinania
glTranslatef( 0, 0, -( near + far ) / 2 );

// obroty obiektu
glRotatef( rotatex, 1.0, 0, 0 );
glRotatef( rotatey, 0, 1.0, 0 );

// skalowanie obiektu - klawisze "+" i "-"
glScalef( scale, scale, scale );

// właściwości materiału
glMaterialfv( GL_FRONT, GL_AMBIENT, ambient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, diffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, specular );
glMaterialf( GL_FRONT, GL_SHININESS, shininess );

// zmiana kierunku źródła światła jest wykonywana niezależnie
// od obrotów obiektu, stąd odłożenie na stos macierzy modelowania
glPushMatrix();

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// obroty kierunku źródła światła - klawisze kursora
glRotatef( light_rotatex, 1.0, 0, 0 );
glRotatef( light_rotatey, 0, 1.0, 0 );

// ustalenie kierunku źródła światła
glLightfv( GL_LIGHT0, GL_POSITION, light_position );

// przywrócenie pierwotnej macierzy modelowania
glPopMatrix();

// rysowanie wybranego obiektu 3D
switch( object )
{
// kula
case SPHERE:
glutSolidSphere( 1.0, 50, 40 );
break;

// czajnik
case TEAPOT:
glutSolidTeapot( 1 );
break;

// stożek
case CONE:
glutSolidCone( 1, 1, 50, 40 );
break;

// torus
case TORUS:
glutSolidTorus( 0.3, 1, 40, 50 );
break;

// sześcian
case CUBE:
glutSolidCube( 1 );
break;

// dwunastościan
case DODECAHEDRON:
glutSolidDodecahedron();
break;

// ośmiościan
case OCTAHEDRON:
glutSolidOctahedron();
break;

// czworościan
case TETRAHEDRON:
glutSolidTetrahedron();
break;

// dwudziestościan
case ICOSAHEDRON:
glutSolidIcosahedron();
break;
}

// informacje o modyfikowanych wartościach
// parametrów źródła światała GL_LIGHT0
char string[ 200 ];
GLfloat vec[ 4 ];
glColor3fv( Black );

// kierunek źródła światła
glGetLightfv( GL_LIGHT0, GL_POSITION, vec );
sprintf( string, "GL_POSITION = (%f,%f,%f,%f)", vec[ 0 ], vec[ 1 ], vec[ 2 ], vec[ 3 ] );
DrawString( 2, 2, string );

// kąty obrotu kierunku źródła światła
sprintf( string, "light_rotatex = %f", light_rotatex );
DrawString( 2, 16, string );
sprintf( string, "light_rotatey = %f", light_rotatey );
DrawString( 2, 30, string );

// skierowanie poleceń do wykonania
glFlush();

// zamiana buforów koloru
glutSwapBuffers();
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
// obszar renderingu - całe okno
glViewport( 0, 0, width, height );

// wybór macierzy rzutowania
glMatrixMode( GL_PROJECTION );

// macierz rzutowania = macierz jednostkowa
glLoadIdentity();

// parametry bryły obcinania
if( aspect == ASPECT_1_1 )
{
// wysokość okna większa od wysokości okna
if( width < height && width > 0 )
   glFrustum( left, right, bottom * height / width, top * height / width, near, far );
else

// szerokość okna większa lub równa wysokości okna
if( width >= height && height > 0 )
   glFrustum( left * width / height, right * width / height, bottom, top, near, far );

}
else
   glFrustum( left, right, bottom, top, near, far );

// generowanie sceny 3D
DisplayScene();
}

// obsługa klawiatury

void Keyboard( unsigned char key, int x, int y )
{
switch( key )
{
// klawisz "+" - powiększenie obiektu
case '+':
scale += 0.05;
break;

// klawisz "-" - zmniejszenie obiektu
case '-':
if( scale > 0.05 )
   scale -= 0.05;

break;
}

// narysowanie sceny
DisplayScene();
}

// obsługa przycisków myszki

void MouseButton( int button, int state, int x, int y )
{
if( button == GLUT_LEFT_BUTTON )
{
// zapamiętanie stanu lewego przycisku myszki
button_state = state;

// zapamiętanie położenia kursora myszki
if( state == GLUT_DOWN )
{
button_x = x;
button_y = y;
}
}
}

// obsługa ruchu kursora myszki

void MouseMotion( int x, int y )
{
if( button_state == GLUT_DOWN )
{
rotatey += 30 *( right - left ) / glutGet( GLUT_WINDOW_WIDTH ) *( x - button_x );
button_x = x;
rotatex -= 30 *( top - bottom ) / glutGet( GLUT_WINDOW_HEIGHT ) *( button_y - y );
button_y = y;
glutPostRedisplay();
}
}

// obsługa klawiszy funkcyjnych i klawiszy kursora

void SpecialKeys( int key, int x, int y )
{
switch( key )
{
// kursor w lewo
case GLUT_KEY_LEFT:
light_rotatey -= 5;
break;

// kursor w prawo
case GLUT_KEY_RIGHT:
light_rotatey += 5;
break;

// kursor w dół
case GLUT_KEY_DOWN:
light_rotatex += 5;
break;

// kursor w górę
case GLUT_KEY_UP:
light_rotatex -= 5;
break;
}

// odrysowanie okna
DisplayScene();
}

// obsługa menu podręcznego

void Menu( int value )
{
switch( value )
{
// rysowany obiekt - kula
case SPHERE:
object = SPHERE;
DisplayScene();
break;

// rysowany obiekt - czajnik
case TEAPOT:
object = TEAPOT;
DisplayScene();
break;

// rysowany obiekt - stożek
case CONE:
object = CONE;
DisplayScene();
break;

// rysowany obiekt - torus
case TORUS:
object = TORUS;
DisplayScene();
break;

// rysowany obiekt - sześcian
case CUBE:
object = CUBE;
DisplayScene();
break;

// rysowany obiekt - dwunastościan
case DODECAHEDRON:
object = DODECAHEDRON;
DisplayScene();
break;

// rysowany obiekt - ośmiościan
case OCTAHEDRON:
object = OCTAHEDRON;
DisplayScene();
break;

// rysowany obiekt - czworościan
case TETRAHEDRON:
object = TETRAHEDRON;
DisplayScene();
break;

// rysowany obiekt - dwudziestościan
case ICOSAHEDRON:
object = ICOSAHEDRON;
DisplayScene();
break;

// materiał - mosiądz
case BRASS:
ambient = BrassAmbient;
diffuse = BrassDiffuse;
specular = BrassSpecular;
shininess = BrassShininess;
DisplayScene();
break;

// materiał - brąz
case BRONZE:
ambient = BronzeAmbient;
diffuse = BronzeDiffuse;
specular = BronzeSpecular;
shininess = BronzeShininess;
DisplayScene();
break;

// materiał - polerowany brąz
case POLISHED_BRONZE:
ambient = PolishedBronzeAmbient;
diffuse = PolishedBronzeDiffuse;
specular = PolishedBronzeSpecular;
shininess = PolishedBronzeShininess;
DisplayScene();
break;

// materiał - chrom
case CHROME:
ambient = ChromeAmbient;
diffuse = ChromeDiffuse;
specular = ChromeSpecular;
shininess = ChromeShininess;
DisplayScene();
break;

// materiał - miedź
case COPPER:
ambient = CopperAmbient;
diffuse = CopperDiffuse;
specular = CopperSpecular;
shininess = CopperShininess;
DisplayScene();
break;

// materiał - polerowana miedź
case POLISHED_COPPER:
ambient = PolishedCopperAmbient;
diffuse = PolishedCopperDiffuse;
specular = PolishedCopperSpecular;
shininess = PolishedCopperShininess;
DisplayScene();
break;

// materiał - złoto
case GOLD:
ambient = GoldAmbient;
diffuse = GoldDiffuse;
specular = GoldSpecular;
shininess = GoldShininess;
DisplayScene();
break;

// materiał - polerowane złoto
case POLISHED_GOLD:
ambient = PolishedGoldAmbient;
diffuse = PolishedGoldDiffuse;
specular = PolishedGoldSpecular;
shininess = PolishedGoldShininess;
DisplayScene();
break;

// materiał - grafit (cyna z ołowiem)
case PEWTER:
ambient = PewterAmbient;
diffuse = PewterDiffuse;
specular = PewterSpecular;
shininess = PewterShininess;
DisplayScene();
break;

// materiał - srebro
case SILVER:
ambient = SilverAmbient;
diffuse = SilverDiffuse;
specular = SilverSpecular;
shininess = SilverShininess;
DisplayScene();
break;

// materiał - polerowane srebro
case POLISHED_SILVER:
ambient = PolishedSilverAmbient;
diffuse = PolishedSilverDiffuse;
specular = PolishedSilverSpecular;
shininess = PolishedSilverShininess;
DisplayScene();
break;

// materiał - szmaragd
case EMERALD:
ambient = EmeraldAmbient;
diffuse = EmeraldDiffuse;
specular = EmeraldSpecular;
shininess = EmeraldShininess;
DisplayScene();
break;

// materiał - jadeit
case JADE:
ambient = JadeAmbient;
diffuse = JadeDiffuse;
specular = JadeSpecular;
shininess = JadeShininess;
DisplayScene();
break;

// materiał - obsydian
case OBSIDIAN:
ambient = ObsidianAmbient;
diffuse = ObsidianDiffuse;
specular = ObsidianSpecular;
shininess = ObsidianShininess;
DisplayScene();
break;

// materiał - perła
case PEARL:
ambient = PearlAmbient;
diffuse = PearlDiffuse;
specular = PearlSpecular;
shininess = PearlShininess;
DisplayScene();
break;

// metariał - rubin
case RUBY:
ambient = RubyAmbient;
diffuse = RubyDiffuse;
specular = RubySpecular;
shininess = RubyShininess;
DisplayScene();
break;

// materiał - turkus
case TURQUOISE:
ambient = TurquoiseAmbient;
diffuse = TurquoiseDiffuse;
specular = TurquoiseSpecular;
shininess = TurquoiseShininess;
DisplayScene();
break;

// materiał - czarny plastik
case BLACK_PLASTIC:
ambient = BlackPlasticAmbient;
diffuse = BlackPlasticDiffuse;
specular = BlackPlasticSpecular;
shininess = BlackPlasticShininess;
DisplayScene();
break;

// materiał - czarna guma
case BLACK_RUBBER:
ambient = BlackRubberAmbient;
diffuse = BlackRubberDiffuse;
specular = BlackRubberSpecular;
shininess = BlackRubberShininess;
DisplayScene();
break;

// obszar renderingu - całe okno
case FULL_WINDOW:
aspect = FULL_WINDOW;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// obszar renderingu - aspekt 1:1
case ASPECT_1_1:
aspect = ASPECT_1_1;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// wyjście
case EXIT:
exit( 0 );
}
}

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń

void ExtensionSetup()
{
// pobranie numeru wersji biblioteki OpenGL
const char * version =( char * ) glGetString( GL_VERSION );

// odczyt wersji OpenGL
int major = 0, minor = 0;
if( sscanf( version, "%d.%d", & major, & minor ) != 2 )
{
#ifndef WIN32
printf( "Błędny format wersji OpenGL\n" );
#else

printf( "Bledny format wersji OpenGL\n" );
#endif

exit( 0 );
}

// sprawdzenie czy jest co najmniej wersja 1.4
if( major > 1 || minor >= 4 )
{
// pobranie wskaźnika wybranej funkcji OpenGL 1.4
glWindowPos2i =( PFNGLWINDOWPOS2IPROC ) wglGetProcAddress( "glWindowPos2i" );
}
else
// sprawdzenie czy jest obsługiwane rozszerzenie ARB_window_pos
if( glutExtensionSupported( "GL_ARB_window_pos" ) )
{
// pobranie wskaźnika wybranej funkcji rozszerzenia ARB_window_pos
glWindowPos2i =( PFNGLWINDOWPOS2IPROC ) wglGetProcAddress
( "glWindowPos2iARB" );
}
else
{
printf( "Brak rozszerzenia ARB_window_pos!\n" );
exit( 0 );
}
}

int main( int argc, char * argv[] )
{
// inicjalizacja biblioteki GLUT
glutInit( & argc, argv );

// inicjalizacja bufora ramki
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );

// rozmiary głównego okna programu
glutInitWindowSize( 500, 500 );

// utworzenie głównego okna programu

#ifdef WIN32

glutCreateWindow( "Światło kierunkowe" );
#else

glutCreateWindow( "Swiatlo kierunkowe" );
#endif

// dołączenie funkcji generującej scenę 3D
glutDisplayFunc( DisplayScene );

// dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
glutReshapeFunc( Reshape );

// dołączenie funkcji obsługi klawiatury
glutKeyboardFunc( Keyboard );

// dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
glutSpecialFunc( SpecialKeys );

// obsługa przycisków myszki
glutMouseFunc( MouseButton );

// obsługa ruchu kursora myszki
glutMotionFunc( MouseMotion );

// utworzenie menu podręcznego
glutCreateMenu( Menu );

// utworzenie podmenu - obiekt
int MenuObject = glutCreateMenu( Menu );
glutAddMenuEntry( "Kula", SPHERE );
glutAddMenuEntry( "Czajnik", TEAPOT );

#ifdef WIN32

glutAddMenuEntry( "Stożek", CONE );
glutAddMenuEntry( "Torus", TORUS );
glutAddMenuEntry( "Sześcian", CUBE );
glutAddMenuEntry( "Dwunastościan", DODECAHEDRON );
glutAddMenuEntry( "Ośmiościan", OCTAHEDRON );
glutAddMenuEntry( "Czworościan", TETRAHEDRON );
glutAddMenuEntry( "Dwudziestościan", ICOSAHEDRON );
#else

glutAddMenuEntry( "Stozek", CONE );
glutAddMenuEntry( "Torus", TORUS );
glutAddMenuEntry( "Szescian", CUBE );
glutAddMenuEntry( "Dwunastoscian", DODECAHEDRON );
glutAddMenuEntry( "Osmioscian", OCTAHEDRON );
glutAddMenuEntry( "Czworoscian", TETRAHEDRON );
glutAddMenuEntry( "Dwudziestoscian", ICOSAHEDRON );
#endif

// utworzenie podmenu - Materiał
int MenuMaterial = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Mosiądz", BRASS );
glutAddMenuEntry( "Brąz", BRONZE );
glutAddMenuEntry( "Polerowany brąz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedź", COPPER );
glutAddMenuEntry( "Polerowana miedź", POLISHED_COPPER );
glutAddMenuEntry( "Złoto", GOLD );
glutAddMenuEntry( "Polerowane złoto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perła", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#else

glutAddMenuEntry( "Mosiadz", BRASS );
glutAddMenuEntry( "Braz", BRONZE );
glutAddMenuEntry( "Polerowany braz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedz", COPPER );
glutAddMenuEntry( "Polerowana miedz", POLISHED_COPPER );
glutAddMenuEntry( "Zloto", GOLD );
glutAddMenuEntry( "Polerowane zloto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perla", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#endif

// utworzenie podmenu - Aspekt obrazu
int MenuAspect = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Aspekt obrazu - całe okno", FULL_WINDOW );
#else

glutAddMenuEntry( "Aspekt obrazu - cale okno", FULL_WINDOW );
#endif

glutAddMenuEntry( "Aspekt obrazu 1:1", ASPECT_1_1 );

// menu główne
glutCreateMenu( Menu );
glutAddSubMenu( "Obiekt", MenuObject );

#ifdef WIN32

glutAddSubMenu( "Materiał", MenuMaterial );
#else

glutAddSubMenu( "Material", MenuMaterial );
#endif

glutAddSubMenu( "Aspekt obrazu", MenuAspect );
#ifdef WIN32

glutAddMenuEntry( "Wyjście", EXIT );
#else

glutAddMenuEntry( "Wyjscie", EXIT );
#endif

// określenie przycisku myszki obsługującej menu podręczne
glutAttachMenu( GLUT_RIGHT_BUTTON );

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń
ExtensionSetup();

// wprowadzenie programu do obsługi pętli komunikatów
glutMainLoop();
return 0;
}

Ostatni program przykładowy (plik reflektor.cpp) prezentuje sposób wykorzystania punktowego światła kierunkowego, tzw. reflektora. Ponadto program umożliwia zmianę wybranych parametrów pracy reflektora. Wartości wszystkich modyfikowanych parametrów źródła światła wyświetlane są na dole okna programu.
W celu łatwiejszej interpretacji uzyskanego efektu oświetlenia obiektu w miejscu położenia źródła światła program rysuje niewielką czerwoną kulę (barwa kuli nie ma nic wspólnego z kolorem źródła światła). Jednym ze sposobów aby kula otrzymała tę barwę jest chwilowe wyłączenie źródła światła GL_LIGHT0. Najłatwiej jest to zrealizować odkładając na stos zmienne stanu dotyczące oświetlenia, a następnie po modyfikacji wybranych parametrów materiału i narysowaniu kuli pobrać ze stosu wcześniej odłożone zmienne.
Odłożenie na stos wybranych grup zmiennych stanu realizuje funkcja:

void glPushAttrib( GLbitfield mask )

Parametr mask to maska bitowa określająca jaka grupa lub grupy stanu mają zostać odłożone na stos. Grupy zmiennych stanu określają następujące stałe:

GL_ACCUM_BUFFER_BIT - wartość bufora akumulacyjnego,
GL_COLOR_BUFFER_BIT - ustawienia bufora koloru,
GL_CURRENT_BIT - aktualne kolory i współrzędne, w tym m.in. wektor normalny,
GL_DEPTH_BUFFER_BIT - ustawienia bufora głębokości,
GL_ENABLE_BIT - wartości znaczników,
GL_EVAL_BIT - ustawienia mechanizmu automatycznego obliczania wartości,
GL_FOG_BIT - ustawienia mgły,
GL_HINT_BIT - ustawienia wskazówek renderingu,
GL_LIGHTING_BIT - ustawienia oświetlenia (stała użyta w przykładowym programie),
GL_LINE_BIT - ustawienia renderingu linii,
GL_LIST_BIT - ustawienia list wyświetlania,
GL_MULTISAMPLE_BIT - ustawienia wielopróbkowania (multisamlingu),
GL_PIXEL_MODE_BIT - ustawienia przekształceń pikseli,
GL_POINT_BIT - ustawienia renderingu punktów,
GL_POLYGON_BIT - ustawienia renderingu wielokątów,
GL_POLYGON_STIPPLE_BIT - wzór wypełnienia wielokątów,
GL_SCISSOR_BIT - ustawienia obcinania obrazu,
GL_STENCIL_BUFFER_BIT - ustawienia bufora szablonowego,
GL_TEXTURE_BIT - ustawienia teksturowania,
GL_TRANSFORM_BIT - ustawienia przekształceń i bryły obcinania,
GL_VIEWPORT_BIT - ustawienia widoku,
GL_ALL_ATTRIB_BITS - wszystkie grupy zmiennych maszyny stanu biblioteki OpenGL.

Stałe te można w razie potrzeby łączyć przy pomocy bitowych operatorów logicznych. Zauważmy, że dwie spośród wymienionych stałych używamy już od dłuższego czasu w każdym przykładowym programie. Są to stałe: GL_COLOR_BUFFER_BIT i GL_DEPTH_BUFFER_BIT.
Przywrócenie wartości zmiennych stanu wcześniej odłożonych na stos realizuje funkcja:

void glPopAttrib()

Dodajmy jeszcze, że stała GL_MULTISAMPLE_BIT została wprowadzona w wersji 1.3 biblioteki OpenGL. Wcześniej technikę wielopróbkowania obsługiwały rozszerzenia ARB multisample i SGIS multisample, przy czym opisywana stała miała odpowiednio oznaczenia: GL_MULTISAMPLE_BIT_ARB i GL_MULTISAMPLE_BIT_EXT.
Efekty działania programu ilustrują trzy rysunki. Pierwszy rysunek (18) przedstawia oświetlenie obiektu silnie skupioną i zarazem wąską wiązką światła. Efekt jest zgodny z oczekiwaniami. Także drugi rysunek (19), przedstawiający oświetlenie obiektu wąską ale słabo skupiona wiązką światła, daje spodziewany efekt. Jednak na trzecim rysunku (20) widzimy, że próba oświetlenia światłem kierunkowym obiektu posiadającego małą ilość wierzchołków może dać w efekcie brak oświetlenia. Jest to związane z modelem oświetlenia Gourauda przyjętym w bibliotece OpenGL, który wylicza oświetlenie wyłącznie dla wierzchołków. Jeżeli zatem w wiązce światła reflektora nie znajdzie się żaden wierzchołek oświetlanego obiektu, OpenGL nie wykona dla tego obiektu obliczeń związanych z oświetleniem.
Choć opisanej wady modelu oświetlenia biblioteki OpenGL nie można usunąć, to stosunkowo łatwo można uniknąć związanych z tym objawów. Najprostszą i najabardziej skuteczną metodą jest zwiększenie ilości wierzchołków, z których składa się obiekt.

Plik reflektor.cpp

Rysunek 18. Program Reflektor - silnie skupiona i wąska wiązka światła

Rysunek 19. Program Reflektor - wąska ale słabo skupiona wiązka światła

Rysunek 20. Program Reflektor - efektu braku oświetlenia powierzchni

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glut.h>
#include <GL/glext.h>
#ifndef WIN32
#define GLX_GLXEXT_LEGACY
#include <GL/glx.h>
#define wglGetProcAddress glXGetProcAddressARB
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "colors.h"
#include "materials.h"

// wskaźnik na funkcję glWindowPos2i

PFNGLWINDOWPOS2IPROC glWindowPos2i = NULL;

// stałe do obsługi menu podręcznego

enum
{
// obiekty
SPHERE, // kula
TEAPOT, // czajnik
CONE, // stożek
TORUS, // torus
CUBE, // sześcian
DODECAHEDRON, // dwunastościan
OCTAHEDRON, // ośmiościan
TETRAHEDRON, // czworościan
ICOSAHEDRON, // dwudziestościan

// materiały
BRASS, // mosiądz
BRONZE, // brąz
POLISHED_BRONZE, // polerowany brąz
CHROME, // chrom
COPPER, // miedź
POLISHED_COPPER, // polerowana miedź
GOLD, // złoto
POLISHED_GOLD, // polerowane złoto
PEWTER, // grafit (cyna z ołowiem)
SILVER, // srebro
POLISHED_SILVER, // polerowane srebro
EMERALD, // szmaragd
JADE, // jadeit
OBSIDIAN, // obsydian
PEARL, // perła
RUBY, // rubin
TURQUOISE, // turkus
BLACK_PLASTIC, // czarny plastik
BLACK_RUBBER, // czarna guma

// obszar renderingu
FULL_WINDOW, // aspekt obrazu - całe okno
ASPECT_1_1, // aspekt obrazu 1:1
EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// usunięcie definicji makr near i far

#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif

// rozmiary bryły obcinania

const GLdouble left = - 2.0;
const GLdouble right = 2.0;
const GLdouble bottom = - 2.0;
const GLdouble top = 2.0;
const GLdouble near = 3.0;
const GLdouble far = 7.0;

// kąty obrotu obiektu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;

// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;

// położenie kursora myszki

int button_x, button_y;

// współczynnik skalowania

GLfloat scale = 1.0;

// właściwości materiału - domyślnie mosiądz

const GLfloat * ambient = BrassAmbient;
const GLfloat * diffuse = BrassDiffuse;
const GLfloat * specular = BrassSpecular;
GLfloat shininess = BrassShininess;

// wyświetlany obiekt 3D

int object = SPHERE;

// kierunek źródła światła

GLfloat light_position[ 4 ] =
{
0.0, 0.0, 2.0, 1.0
};

// kąty obrotu położenia źródła światła

GLfloat light_rotatex = 0.0;
GLfloat light_rotatey = 0.0;

// kierunek reflektora

GLfloat spot_direction[ 3 ] =
{
0.0, 0.0, - 1.0
};

// kąt odcięcia reflektora

GLfloat spot_cutoff = 180.0;

// wykładnik tłumienia kątowego reflektora

GLfloat spot_exponent = 128.0;

// stały współczynnik tłumienia światła

GLfloat constant_attenuation = 1.0;

// liniowy współczynnik tłumienia światła

GLfloat linear_attenuation = 0.0;

// kwadratowy współczynnik tłumienia światła

GLfloat quadratic_attenuation = 0.0;

// funkcja rysująca napis w wybranym miejscu
// (wersja korzystająca z funkcji glWindowPos2i)

void DrawString( GLint x, GLint y, char * string )
{
// położenie napisu
glWindowPos2i( x, y );

// wyświetlenie napisu
int len = strlen( string );
for( int i = 0; i < len; i++ )
   glutBitmapCharacter( GLUT_BITMAP_9_BY_15, string[ i ] );

}

// funkcja generująca scenę 3D

void DisplayScene()
{
// kolor tła - zawartość bufora koloru
glClearColor( 1.0, 1.0, 1.0, 1.0 );

// czyszczenie bufora koloru i bufora głębokości
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

// wybór macierzy modelowania
glMatrixMode( GL_MODELVIEW );

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// włączenie testu bufora głębokości
glEnable( GL_DEPTH_TEST );

// włączenie oświetlenia
glEnable( GL_LIGHTING );

// włączenie światła GL_LIGHT0
glEnable( GL_LIGHT0 );

// włączenie automatycznej normalizacji wektorów normalnych
glEnable( GL_NORMALIZE );

// przesunięcie układu współrzędnych obiektu do środka bryły odcinania
glTranslatef( 0, 0, -( near + far ) / 2 );

// obroty obiektu
glRotatef( rotatex, 1.0, 0, 0 );
glRotatef( rotatey, 0, 1.0, 0 );

// skalowanie obiektu - klawisze "+" i "-"
glScalef( scale, scale, scale );

// właściwości materiału
glMaterialfv( GL_FRONT, GL_AMBIENT, ambient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, diffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, specular );
glMaterialf( GL_FRONT, GL_SHININESS, shininess );

// kąt odcięcia reflektora
glLightf( GL_LIGHT0, GL_SPOT_CUTOFF, spot_cutoff );

// wykładnik tłumienia kątowego reflektora
glLightf( GL_LIGHT0, GL_SPOT_EXPONENT, spot_exponent );

// stały współczynnik tłumienia światła,
glLightf( GL_LIGHT0, GL_CONSTANT_ATTENUATION, constant_attenuation );

// liniowy współczynnik tłumienia światła
glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, linear_attenuation );

// kwadratowy współczynnik tłumienia światła
glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, quadratic_attenuation );

// zmiana położenia źródła światła jest wykonywana niezależnie
// od obrotów obiektu, stąd odłożenie na stos macierzy modelowania
glPushMatrix();

// macierz modelowania = macierz jednostkowa
glLoadIdentity();

// przesunięcie układu współrzędnych źródła światła do środka bryły odcinania
glTranslatef( 0, 0, -( near + far ) / 2 );

// obroty położenia źródła światła - klawisze kursora
glRotatef( light_rotatex, 1.0, 0, 0 );
glRotatef( light_rotatey, 0, 1.0, 0 );

// przesunięcie źródła światła
glTranslatef( light_position[ 0 ], light_position[ 1 ], light_position[ 2 ] );

// ustalenie pozycji źródła światła
glLightfv( GL_LIGHT0, GL_POSITION, light_position );

// ustalenie kierunku reflektora
glLightfv( GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction );

// odłożenie na stos zmiennych stanu związanych z oświetleniem sceny
glPushAttrib( GL_LIGHTING_BIT );

// wyłacznie źródła światła GL_LIGHT0
glDisable( GL_LIGHT0 );

// materiał imitujący świecenie kuli na czerwono
glMaterialfv( GL_FRONT, GL_EMISSION, Red );

// narysowanie kuli położonej w początku źródła światła
glutSolidSphere( 0.1, 30, 20 );

// przywrócenie zmiennych stanu związanych z oświetleniem sceny
glPopAttrib();

// przywrócenie pierwotnej macierzy modelowania
glPopMatrix();

// rysowanie wybranego obiektu 3D
switch( object )
{
// kula
case SPHERE:
glutSolidSphere( 1.0, 50, 40 );
break;

// czajnik
case TEAPOT:
glutSolidTeapot( 1 );
break;

// stożek
case CONE:
glutSolidCone( 1, 1, 50, 40 );
break;

// torus
case TORUS:
glutSolidTorus( 0.3, 1, 40, 50 );
break;

// sześcian
case CUBE:
glutSolidCube( 1 );
break;

// dwunastościan
case DODECAHEDRON:
glutSolidDodecahedron();
break;

// ośmiościan
case OCTAHEDRON:
glutSolidOctahedron();
break;

// czworościan
case TETRAHEDRON:
glutSolidTetrahedron();
break;

// dwudziestościan
case ICOSAHEDRON:
glutSolidIcosahedron();
break;
}

// informacje o wartościach modyfikowanych
// parametrów źródła światała GL_LIGHT0
char string[ 200 ];
GLfloat vec[ 4 ];
glColor3fv( Black );

// kierunek źródła światła
glGetLightfv( GL_LIGHT0, GL_POSITION, vec );
sprintf( string, "GL_POSITION = (%f,%f,%f,%f)", vec[ 0 ], vec[ 1 ], vec[ 2 ], vec[ 3 ] );
DrawString( 2, 2, string );

glGetLightfv( GL_LIGHT0, GL_SPOT_DIRECTION, vec );
sprintf( string, "GL_SPOT_DIRECTION = (%f,%f,%f)", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
DrawString( 2, 16, string );

// kąt odcięcia reflektora
glGetLightfv( GL_LIGHT0, GL_SPOT_CUTOFF, vec );
sprintf( string, "GL_SPOT_CUTOFF = %f", vec[ 0 ] );
DrawString( 2, 30, string );

// wykładnik tłumienia kątowego reflektora
glGetLightfv( GL_LIGHT0, GL_SPOT_EXPONENT, vec );
sprintf( string, "GL_SPOT_EXPONENT = %f", vec[ 0 ] );
DrawString( 2, 44, string );

// stały współczynnik tłumienia światła,
glGetLightfv( GL_LIGHT0, GL_CONSTANT_ATTENUATION, vec );
sprintf( string, "GL_CONSTANT_ATTENUATION = %f", vec[ 0 ] );
DrawString( 2, 58, string );

// liniowy współczynnik tłumienia światła
glGetLightfv( GL_LIGHT0, GL_LINEAR_ATTENUATION, vec );
sprintf( string, "GL_LINEAR_ATTENUATION = %f", vec[ 0 ] );
DrawString( 2, 72, string );

// kwadratowy współczynnik tłumienia światła
glGetLightfv( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, vec );
sprintf( string, "GL_QUADRATIC_ATTENUATION = %f", vec[ 0 ] );
DrawString( 2, 86, string );

// skierowanie poleceń do wykonania
glFlush();

// zamiana buforów koloru
glutSwapBuffers();
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
// obszar renderingu - całe okno
glViewport( 0, 0, width, height );

// wybór macierzy rzutowania
glMatrixMode( GL_PROJECTION );

// macierz rzutowania = macierz jednostkowa
glLoadIdentity();

// parametry bryły obcinania
if( aspect == ASPECT_1_1 )
{
// wysokość okna większa od wysokości okna
if( width < height && width > 0 )
   glFrustum( left, right, bottom * height / width, top * height / width, near, far );
else

// szerokość okna większa lub równa wysokości okna
if( width >= height && height > 0 )
   glFrustum( left * width / height, right * width / height, bottom, top, near, far );

}
else
   glFrustum( left, right, bottom, top, near, far );

// generowanie sceny 3D
DisplayScene();
}

// obsługa klawiatury

void Keyboard( unsigned char key, int x, int y )
{
switch( key )
{
// klawisz "+" - powiększenie obiektu
case '+':
scale += 0.05;
break;

// klawisz "-" - zmniejszenie obiektu
case '-':
if( scale > 0.05 )
   scale -= 0.05;

break;

// klawisz "S" - zwiększenie kąta obcięcia reflektora
case 'S':
if( spot_cutoff == 90 )
   spot_cutoff = 180;
else
if( spot_cutoff < 90 )
   spot_cutoff++;

break;

// klawisz "s" - zmniejszenie kąta obcięcia reflektora
case 's':
if( spot_cutoff == 180 )
   spot_cutoff = 90;
else
if( spot_cutoff > 0 )
   spot_cutoff--;

break;

// klawisz "E" - zwiększenie wykładnika tłumienia kątowego reflektora
case 'E':
if( spot_exponent < 128 )
   spot_exponent++;

break;

// klawisz "e" - zmniejszenie wykładnika tłumienia kątowego reflektora
case 'e':
if( spot_exponent > 0 )
   spot_exponent--;

break;

// klawisz "C" - zwiększenie stałego współczynnika tłumienia światła
case 'C':
constant_attenuation += 0.1;
break;

// klawisz "c" - zmniejszenie stałego współczynnika tłumienia światła
case 'c':
if( constant_attenuation > 0 )
   constant_attenuation -= 0.1;

break;

// klawisz "L" - zwiększenie liniowego współczynnika tłumienia światła
case 'L':
linear_attenuation += 0.1;
break;

// klawisz "l" - zmniejszenie liniowego współczynnika tłumienia światła
case 'l':
if( linear_attenuation > 0 )
   linear_attenuation -= 0.1;

break;

// klawisz "Q" - zwiększenie kwadratowego współczynnika tłumienia światła
case 'Q':
quadratic_attenuation += 0.1;
break;

// klawisz "q" - zmniejszenie kwadratowego współczynnika tłumienia światła
case 'q':
if( quadratic_attenuation > 0 )
   quadratic_attenuation -= 0.1;

break;
}

// narysowanie sceny
DisplayScene();
}

// obsługa przycisków myszki

void MouseButton( int button, int state, int x, int y )
{
if( button == GLUT_LEFT_BUTTON )
{
// zapamiętanie stanu lewego przycisku myszki
button_state = state;

// zapamiętanie położenia kursora myszki
if( state == GLUT_DOWN )
{
button_x = x;
button_y = y;
}
}
}

// obsługa ruchu kursora myszki

void MouseMotion( int x, int y )
{
if( button_state == GLUT_DOWN )
{
rotatey += 30 *( right - left ) / glutGet( GLUT_WINDOW_WIDTH ) *( x - button_x );
button_x = x;
rotatex -= 30 *( top - bottom ) / glutGet( GLUT_WINDOW_HEIGHT ) *( button_y - y );
button_y = y;
glutPostRedisplay();
}
}

// obsługa klawiszy funkcyjnych i klawiszy kursora

void SpecialKeys( int key, int x, int y )
{
switch( key )
{
// kursor w lewo
case GLUT_KEY_LEFT:
light_rotatey -= 5;
break;

// kursor w prawo
case GLUT_KEY_RIGHT:
light_rotatey += 5;
break;

// kursor w dół
case GLUT_KEY_DOWN:
light_rotatex += 5;
break;

// kursor w górę
case GLUT_KEY_UP:
light_rotatex -= 5;
break;
}

// odrysowanie okna
DisplayScene();
}

// obsługa menu podręcznego

void Menu( int value )
{
switch( value )
{
// rysowany obiekt - kula
case SPHERE:
object = SPHERE;
DisplayScene();
break;

// rysowany obiekt - czajnik
case TEAPOT:
object = TEAPOT;
DisplayScene();
break;

// rysowany obiekt - stożek
case CONE:
object = CONE;
DisplayScene();
break;

// rysowany obiekt - torus
case TORUS:
object = TORUS;
DisplayScene();
break;

// rysowany obiekt - sześcian
case CUBE:
object = CUBE;
DisplayScene();
break;

// rysowany obiekt - dwunastościan
case DODECAHEDRON:
object = DODECAHEDRON;
DisplayScene();
break;

// rysowany obiekt - ośmiościan
case OCTAHEDRON:
object = OCTAHEDRON;
DisplayScene();
break;

// rysowany obiekt - czworościan
case TETRAHEDRON:
object = TETRAHEDRON;
DisplayScene();
break;

// rysowany obiekt - dwudziestościan
case ICOSAHEDRON:
object = ICOSAHEDRON;
DisplayScene();
break;

// materiał - mosiądz
case BRASS:
ambient = BrassAmbient;
diffuse = BrassDiffuse;
specular = BrassSpecular;
shininess = BrassShininess;
DisplayScene();
break;

// materiał - brąz
case BRONZE:
ambient = BronzeAmbient;
diffuse = BronzeDiffuse;
specular = BronzeSpecular;
shininess = BronzeShininess;
DisplayScene();
break;

// materiał - polerowany brąz
case POLISHED_BRONZE:
ambient = PolishedBronzeAmbient;
diffuse = PolishedBronzeDiffuse;
specular = PolishedBronzeSpecular;
shininess = PolishedBronzeShininess;
DisplayScene();
break;

// materiał - chrom
case CHROME:
ambient = ChromeAmbient;
diffuse = ChromeDiffuse;
specular = ChromeSpecular;
shininess = ChromeShininess;
DisplayScene();
break;

// materiał - miedź
case COPPER:
ambient = CopperAmbient;
diffuse = CopperDiffuse;
specular = CopperSpecular;
shininess = CopperShininess;
DisplayScene();
break;

// materiał - polerowana miedź
case POLISHED_COPPER:
ambient = PolishedCopperAmbient;
diffuse = PolishedCopperDiffuse;
specular = PolishedCopperSpecular;
shininess = PolishedCopperShininess;
DisplayScene();
break;

// materiał - złoto
case GOLD:
ambient = GoldAmbient;
diffuse = GoldDiffuse;
specular = GoldSpecular;
shininess = GoldShininess;
DisplayScene();
break;

// materiał - polerowane złoto
case POLISHED_GOLD:
ambient = PolishedGoldAmbient;
diffuse = PolishedGoldDiffuse;
specular = PolishedGoldSpecular;
shininess = PolishedGoldShininess;
DisplayScene();
break;

// materiał - grafit (cyna z ołowiem)
case PEWTER:
ambient = PewterAmbient;
diffuse = PewterDiffuse;
specular = PewterSpecular;
shininess = PewterShininess;
DisplayScene();
break;

// materiał - srebro
case SILVER:
ambient = SilverAmbient;
diffuse = SilverDiffuse;
specular = SilverSpecular;
shininess = SilverShininess;
DisplayScene();
break;

// materiał - polerowane srebro
case POLISHED_SILVER:
ambient = PolishedSilverAmbient;
diffuse = PolishedSilverDiffuse;
specular = PolishedSilverSpecular;
shininess = PolishedSilverShininess;
DisplayScene();
break;

// materiał - szmaragd
case EMERALD:
ambient = EmeraldAmbient;
diffuse = EmeraldDiffuse;
specular = EmeraldSpecular;
shininess = EmeraldShininess;
DisplayScene();
break;

// materiał - jadeit
case JADE:
ambient = JadeAmbient;
diffuse = JadeDiffuse;
specular = JadeSpecular;
shininess = JadeShininess;
DisplayScene();
break;

// materiał - obsydian
case OBSIDIAN:
ambient = ObsidianAmbient;
diffuse = ObsidianDiffuse;
specular = ObsidianSpecular;
shininess = ObsidianShininess;
DisplayScene();
break;

// materiał - perła
case PEARL:
ambient = PearlAmbient;
diffuse = PearlDiffuse;
specular = PearlSpecular;
shininess = PearlShininess;
DisplayScene();
break;

// metariał - rubin
case RUBY:
ambient = RubyAmbient;
diffuse = RubyDiffuse;
specular = RubySpecular;
shininess = RubyShininess;
DisplayScene();
break;

// materiał - turkus
case TURQUOISE:
ambient = TurquoiseAmbient;
diffuse = TurquoiseDiffuse;
specular = TurquoiseSpecular;
shininess = TurquoiseShininess;
DisplayScene();
break;

// materiał - czarny plastik
case BLACK_PLASTIC:
ambient = BlackPlasticAmbient;
diffuse = BlackPlasticDiffuse;
specular = BlackPlasticSpecular;
shininess = BlackPlasticShininess;
DisplayScene();
break;

// materiał - czarna guma
case BLACK_RUBBER:
ambient = BlackRubberAmbient;
diffuse = BlackRubberDiffuse;
specular = BlackRubberSpecular;
shininess = BlackRubberShininess;
DisplayScene();
break;

// obszar renderingu - całe okno
case FULL_WINDOW:
aspect = FULL_WINDOW;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// obszar renderingu - aspekt 1:1
case ASPECT_1_1:
aspect = ASPECT_1_1;
Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
break;

// wyjście
case EXIT:
exit( 0 );
}
}

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń

void ExtensionSetup()
{
// pobranie numeru wersji biblioteki OpenGL
const char * version =( char * ) glGetString( GL_VERSION );

// odczyt wersji OpenGL
int major = 0, minor = 0;
if( sscanf( version, "%d.%d", & major, & minor ) != 2 )
{
#ifndef WIN32
printf( "Błędny format wersji OpenGL\n" );
#else

printf( "Bledny format wersji OpenGL\n" );
#endif

exit( 0 );
}

// sprawdzenie czy jest co najmniej wersja 1.4
if( major > 1 || minor >= 4 )
{
// pobranie wskaźnika wybranej funkcji OpenGL 1.4
glWindowPos2i =( PFNGLWINDOWPOS2IPROC ) wglGetProcAddress( "glWindowPos2i" );
}
else
// sprawdzenie czy jest obsługiwane rozszerzenie ARB_window_pos
if( glutExtensionSupported( "GL_ARB_window_pos" ) )
{
// pobranie wskaźnika wybranej funkcji rozszerzenia ARB_window_pos
glWindowPos2i =( PFNGLWINDOWPOS2IPROC ) wglGetProcAddress
( "glWindowPos2iARB" );
}
else
{
printf( "Brak rozszerzenia ARB_window_pos!\n" );
exit( 0 );
}
}

int main( int argc, char * argv[] )
{
// inicjalizacja biblioteki GLUT
glutInit( & argc, argv );

// inicjalizacja bufora ramki
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );

// rozmiary głównego okna programu
glutInitWindowSize( 500, 500 );

// utworzenie głównego okna programu
glutCreateWindow( "Reflektor" );

// dołączenie funkcji generującej scenę 3D
glutDisplayFunc( DisplayScene );

// dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
glutReshapeFunc( Reshape );

// dołączenie funkcji obsługi klawiatury
glutKeyboardFunc( Keyboard );

// dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
glutSpecialFunc( SpecialKeys );

// obsługa przycisków myszki
glutMouseFunc( MouseButton );

// obsługa ruchu kursora myszki
glutMotionFunc( MouseMotion );

// utworzenie menu podręcznego
glutCreateMenu( Menu );

// utworzenie podmenu - obiekt
int MenuObject = glutCreateMenu( Menu );
glutAddMenuEntry( "Kula", SPHERE );
glutAddMenuEntry( "Czajnik", TEAPOT );

#ifdef WIN32

glutAddMenuEntry( "Stożek", CONE );
glutAddMenuEntry( "Torus", TORUS );
glutAddMenuEntry( "Sześcian", CUBE );
glutAddMenuEntry( "Dwunastościan", DODECAHEDRON );
glutAddMenuEntry( "Ośmiościan", OCTAHEDRON );
glutAddMenuEntry( "Czworościan", TETRAHEDRON );
glutAddMenuEntry( "Dwudziestościan", ICOSAHEDRON );
#else

glutAddMenuEntry( "Stozek", CONE );
glutAddMenuEntry( "Torus", TORUS );
glutAddMenuEntry( "Szescian", CUBE );
glutAddMenuEntry( "Dwunastoscian", DODECAHEDRON );
glutAddMenuEntry( "Osmioscian", OCTAHEDRON );
glutAddMenuEntry( "Czworoscian", TETRAHEDRON );
glutAddMenuEntry( "Dwudziestoscian", ICOSAHEDRON );
#endif

// utworzenie podmenu - Materiał
int MenuMaterial = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Mosiądz", BRASS );
glutAddMenuEntry( "Brąz", BRONZE );
glutAddMenuEntry( "Polerowany brąz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedź", COPPER );
glutAddMenuEntry( "Polerowana miedź", POLISHED_COPPER );
glutAddMenuEntry( "Złoto", GOLD );
glutAddMenuEntry( "Polerowane złoto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perła", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#else

glutAddMenuEntry( "Mosiadz", BRASS );
glutAddMenuEntry( "Braz", BRONZE );
glutAddMenuEntry( "Polerowany braz", POLISHED_BRONZE );
glutAddMenuEntry( "Chrom", CHROME );
glutAddMenuEntry( "Miedz", COPPER );
glutAddMenuEntry( "Polerowana miedz", POLISHED_COPPER );
glutAddMenuEntry( "Zloto", GOLD );
glutAddMenuEntry( "Polerowane zloto", POLISHED_GOLD );
glutAddMenuEntry( "Grafit (cyna z ołowiem)", PEWTER );
glutAddMenuEntry( "Srebro", SILVER );
glutAddMenuEntry( "Polerowane srebro", POLISHED_SILVER );
glutAddMenuEntry( "Szmaragd", EMERALD );
glutAddMenuEntry( "Jadeit", JADE );
glutAddMenuEntry( "Obsydian", OBSIDIAN );
glutAddMenuEntry( "Perla", PEARL );
glutAddMenuEntry( "Rubin", RUBY );
glutAddMenuEntry( "Turkus", TURQUOISE );
glutAddMenuEntry( "Czarny plastik", BLACK_PLASTIC );
glutAddMenuEntry( "Czarna guma", BLACK_RUBBER );
#endif

// utworzenie podmenu - Aspekt obrazu
int MenuAspect = glutCreateMenu( Menu );
#ifdef WIN32

glutAddMenuEntry( "Aspekt obrazu - całe okno", FULL_WINDOW );
#else

glutAddMenuEntry( "Aspekt obrazu - cale okno", FULL_WINDOW );
#endif

glutAddMenuEntry( "Aspekt obrazu 1:1", ASPECT_1_1 );

// menu główne
glutCreateMenu( Menu );
glutAddSubMenu( "Obiekt", MenuObject );

#ifdef WIN32

glutAddSubMenu( "Materiał", MenuMaterial );
#else

glutAddSubMenu( "Material", MenuMaterial );
#endif

glutAddSubMenu( "Aspekt obrazu", MenuAspect );
#ifdef WIN32

glutAddMenuEntry( "Wyjście", EXIT );
#else

glutAddMenuEntry( "Wyjscie", EXIT );
#endif

// określenie przycisku myszki obsługującej menu podręczne
glutAttachMenu( GLUT_RIGHT_BUTTON );

// sprawdzenie i przygotowanie obsługi wybranych rozszerzeń
ExtensionSetup();

// wprowadzenie programu do obsługi pętli komunikatów
glutMainLoop();
return 0;
}

Poprzedni dokument	Następny dokument
Bufor głębokości	Listy wyświetlania

Wszystkie teksty są chronione prawami autorskimi. Kopiowanie lub rozpowszechnianie treści poza niniejszym serwisem jest zabronione.

Powyższe ograniczenie nie dotyczy autora opracowania, któremu przysługuje prawo do rozpowszechniania własnego tekstu wedle własnego uznania.