P. 1
Praca

Praca

|Views: 1,253|Likes:

More info:

Published by: Tomasz Kustrzynski on Jul 11, 2011
Prawo autorskie:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

11/11/2012

pdf

text

original

Sections

  • 2. Elementy grafiki komputerowej
  • 2.1. Podstawowe pojęcia grafiki komputerowej
  • Diagram 2-1 Przebieg procesu renderingu dla oświetlenia lokalnego
  • Diagram 2-2 Przebieg procesu cieniowania
  • 2.2. Historia tekstur proceduralnych
  • 2.3. Definiowanie tekstur proceduralnych
  • 2.3.1. Definiowanie bibliotek tekstur proceduralnych
  • 2.4. Jakość tekstur proceduralnych
  • 3. Przegląd stosowanych metod symulacji zjawisk naturalnych
  • 3.1. Kategorie tekstur proceduralnych rozważane w pracy
  • Rysunek 3-1 Wzory na skórze zwierząt
  • Rysunek 3-3 Kora i drewno
  • Rysunek 3-6 Cienie kaustyczne rzucane przez wodę
  • Rysunek 3-7 Wzory abstrakcyjne
  • 3.2. Techniki zaawansowane
  • 3.2.1. Szum Perlina
  • 3.2.2. Wzory kamiennych murów
  • Rysunek 3-11 K.Miyata tekstura muru
  • 3.2.3. Wzory na skórze ssaków
  • Rysunek 3-14 G. Turk. Wzory reaction – diffusion na obiektach
  • 3.2.4. Komórkowe funkcje bazowe tekstur (cellular texture basis function)
  • Rysunek 3-16 S. Worley – Przykład wykorzystania komórkowej funkcji bazowej
  • Rysunek 3-17 Diagram Voronoi
  • Rysunek 3-19 J. Kukla - Tekstury skóry
  • 3.2.5. Podsumowanie
  • 3.3. Dostępne komercyjnie biblioteki do tworzenia wzorów proceduralnych
  • Diagram 3-1 LIBTEX – ewaluacja tekstur przestrzennych
  • Rysunek 3-20 Obraz wygenerowany przy pomocy biblioteki PixelLoom
  • Rysunek 3-21 Przykłady tekstur komórkowych wygenerowanych za pomocą CorelTEXTURE
  • 4. Metody i techniki wykorzystane w pracy
  • 4.1. Funkcja teksturująca jako złożenie funkcji bazowych
  • 4.2. Drzewa cieniowania
  • 4.3. Opis zaimplementowanych algorytmów
  • 4.3.1. Odwzorowanie nierówności powierzchni
  • Rysunek 4-2 Geometria odwzorowania nierówności powierzchni
  • 4.3.2. Szum Perlina
  • Rysunek 4-4 Obliczanie szumu Perlina 2D metodą gradientową
  • Rysunek 4-5 Wykres funkcji smoothstep(x)
  • Rysunek 4-6 Przykłady szumu fraktalnego
  • 4.3.3. Podział przestrzeni według diagramu Voronoi
  • Rysunek 4-8 Typy wyników zwracanych przez funkcję noiseV
  • Rysunek 4-9 Ilustracja fraktalnego podpodziału przestrzeni
  • 4.4. Automatyzacja poszukiwania użytecznych wzorów proceduralnych
  • 4.4.1. Losowe parametry
  • 4.4.2. Przeszukiwanie domeny parametrów
  • 5. Biblioteka do tworzenia tekstur proceduralnych TexLib
  • 5.1. Architektura
  • Diagram 5-1 Architektura biblioteki TexLib (moduły funkcjonalne)
  • 5.1.1. Interfejs
  • 5.1.2. Moduły funkcjonalne systemu renderującego
  • 5.1.3. Biblioteka
  • 5.1.4. Interfejs graficzny
  • 5.2. Implementacja - diagram klas
  • 5.2.1. Diagramy klas
  • 5.2.2. Opisy najważniejszych klas
  • 5.3. Procesu renderingu z wykorzystaniem interfejsu biblioteki TexLib
  • Diagram 5-6 Faza cieniowania z uwzględnieniem biblioteki TexLib
  • 5.3.1. Fazy procesu renderingu w bibliotece TexLib
  • 5.4. Interfejs programistyczny-rozszerzanie biblioteki o nowe wzory
  • 5.5.1. 3dsMAX release3
  • 5.5.2. LightWorks
  • 5.5.3. RenderMan
  • 5.5.4. LightWave
  • 5.5.5. Kontekst w bibliotece TexLib
  • 5.6. Wybrane szczegóły implementacyjne
  • 5.6.1. Wzory definiowane w bibliotekach DLL
  • 5.6.2. Ewaluacja drzewa cieniowania
  • Diagram 5-7 Przykład kolejności ewaluacji parametrów drzewa cieniowania
  • 5.6.3. Zapobieganie cyklom
  • 5.7. Integracja z pakietem LADS do renderingu fotorealistycznego
  • 5.7.1. System do renderingu fotorealistycznego LightWorks
  • Diagram 5-8 Architektura systemu LADS
  • Diagram 5-9 Architektura procesu renderingu w systemie LADS
  • Diagram 5-10 Przebieg procesu ewaluacji własności powierzchni w systemie LADS
  • 5.7.2. Wykorzystanie biblioteki TexLib w procesie cieniowania systemu LightWorks
  • 5.7.3. Przykładowa implementacja shadera LADS wykorzystującego TexLib
  • 6. Edytor drzew cieniowania
  • 6.1. Funkcjonalność aplikacji Edytora
  • 6.2. Interfejs użytkownika
  • Rysunek 6-1 Widok ogólny Edytora drzew cieniowania
  • 6.2.1. Dodawanie i usuwanie wzorów i wartości
  • Rysunek 6-2 Menu kontekstowe dodawania wzorów i wartości
  • Rysunek 6-3 Okienko dialogowe dodawania nowego wzoru
  • Rysunek 6-4 Okienko dialogowe dodawania nowej wartości stałej
  • 6.2.2. Tworzenie połączeń między wzorami
  • 6.2.3. Właściwości wzorów
  • 6.2.4. Rendering
  • Rysunek 6-10 Menu parametrów sceny
  • Rysunek 6-11 Okienko dialogowe z ustawieniami parametrów sceny
  • Rysunek 6-12 Menu renderingu
  • Rysunek 6-13 Okienko dialogowe z parametrami renderingu
  • Rysunek 6-14 Wizualizacja postępu procesu renderingu
  • 6.2.5. Serializacja drzew cieniowania
  • 6.3. Wybrane szczegóły implementacyjne
  • 6.3.1. Opis scen trójwymiarowych
  • 6.3.2. Rendering
  • 7. Badania eksperymentalne
  • 7.1. Cel i zakres ekperymentów
  • 7.2. Symulacje zjawisk występujących w naturze
  • 7.2.1. Skóra salamandry
  • 7.2.2. Cienie kaustyczne
  • 7.2.3. Skóra wyprawiona
  • 7.2.4. Skóra węża
  • 7.2.5. Spękana ziemia
  • 7.2.6. Twórczość H.R.Giger’a
  • 7.3. Ocena efektywności
  • 7.3.1. Warunki eksperymentu
  • 7.3.2. Czynniki wpływające na czas generowania obrazu
  • 7.3.3. Rezultaty liczbowe
  • 7.4. Ocena jakości - porównania
  • 7.5. Podsumowanie
  • 8. Podsumowanie
  • 9. Literatura
  • Dodatek A. Propozycja ćwiczenia laboratoryjnego
  • A.1. Instrukcja dla studentów
  • A.1.1. Cel ćwiczenia
  • A.1.2. Wprowadzenie - tekstury proceduralne
  • A.1.3. Biblioteka do tworzenia drzew cieniowania
  • Rysunek 9-1 Przykładowy diagram funkcji bazowych
  • A.1.4. Edytor drzew cieniowania
  • A.1.5. Zadania
  • A.1.6. Sprawozdanie
  • Rysunek 9-3 Rybia łuska
  • A.1.7. Literatura
  • A.2. Zalecenia dla prowadzącego
  • A.2.1. Ocena
  • A.2.2. Możliwe modyfikacje ćwiczenia
  • Dodatek B. Format pliku zapisu drzewa cieniowania (*.tree)
  • B.1.1. Format pliku *.tree
  • B.1.2. Definicja wzorów
  • B.1.3. Definicja wartości
  • B.1.4. Definicja powiązań

Wybrzeże Wyspiańskiego 27, 50-370 Wrocław

POLITECHNIKA WROCŁAWSKA WYDZIAŁOWY ZAKŁAD INFORMATYKI WYDZIAŁ INFORMATYKI I ZARZĄDZANIA

Zastosowanie technik teksturowania proceduralnego do modelowania zjawisk naturalnych i własności powierzchni
Tomasz Kustrzyński

Promotor: dr inż. Jerzy Sas

Ocena:

Wrocław 2002

Streszczenie
Niniejsza praca ma na celu przedstawienie niezależnej od systemów do grafiki fotorealistycznej biblioteki, zawierającej funkcje służące do symulacji zjawisk rzeczywistych przy użyciu tekstur proceduralnych. Opracowany został system do szybkiej i prostej edycji złożonych tekstur proceduralnych wykorzystujący stworzoną bibliotekę. System został zintegrowany z pakietem do grafiki fotorealistycznej LightWorks.

Abstract
The aim of this work is to present library that is independent on photorealistic graphics systems which contains functions used to simulate real-world phenomena by means of procedural texturing. The system using defined library have been designed that allows for quick and easy edition of complex procedural textures. The system have been integrated with LightWorks – photorealistic graphics package.

2

Spis treści
1. 2. WSTĘP ......................................................................................................................................................... 7 ELEMENTY GRAFIKI KOMPUTEROWEJ.......................................................................................... 9 2.1. PODSTAWOWE POJĘCIA GRAFIKI KOMPUTEROWEJ................................................................................. 9 2.2. HISTORIA TEKSTUR PROCEDURALNYCH .............................................................................................. 11 2.3. DEFINIOWANIE TEKSTUR PROCEDURALNYCH...................................................................................... 13 2.3.1. Definiowanie bibliotek tekstur proceduralnych............................................................................. 13 2.4. JAKOŚĆ TEKSTUR PROCEDURALNYCH ................................................................................................. 14 3. PRZEGLĄD STOSOWANYCH METOD SYMULACJI ZJAWISK NATURALNYCH .................. 17 3.1. KATEGORIE TEKSTUR PROCEDURALNYCH ROZWAŻANE W PRACY ....................................................... 17 3.2. TECHNIKI ZAAWANSOWANE................................................................................................................ 21 3.2.1. Szum Perlina ................................................................................................................................. 21 3.2.2. Wzory kamiennych murów............................................................................................................. 22 3.2.3. Wzory na skórze ssaków ................................................................................................................ 23 3.2.4. Komórkowe funkcje bazowe tekstur (cellular texture basis function) ........................................... 26 3.2.5. Podsumowanie .............................................................................................................................. 29 3.3. DOSTĘPNE KOMERCYJNIE BIBLIOTEKI DO TWORZENIA WZORÓW PROCEDURALNYCH ......................... 29 4. METODY I TECHNIKI WYKORZYSTANE W PRACY.................................................................... 33 4.1. FUNKCJA TEKSTURUJĄCA JAKO ZŁOŻENIE FUNKCJI BAZOWYCH ......................................................... 33 4.2. DRZEWA CIENIOWANIA ....................................................................................................................... 35 4.3. OPIS ZAIMPLEMENTOWANYCH ALGORYTMÓW .................................................................................... 35 4.3.1. Odwzorowanie nierówności powierzchni...................................................................................... 35 4.3.2. Szum Perlina ................................................................................................................................. 37 4.3.3. Podział przestrzeni według diagramu Voronoi ............................................................................. 40 4.4. AUTOMATYZACJA POSZUKIWANIA UŻYTECZNYCH WZORÓW PROCEDURALNYCH ............................... 49 4.4.1. Losowe parametry ......................................................................................................................... 49 4.4.2. Przeszukiwanie domeny parametrów ............................................................................................ 49 5. BIBLIOTEKA DO TWORZENIA TEKSTUR PROCEDURALNYCH TEXLIB.............................. 50 5.1. ARCHITEKTURA .................................................................................................................................. 50 5.1.1. Interfejs ......................................................................................................................................... 50 5.1.2. Moduły funkcjonalne systemu renderującego ............................................................................... 50 5.1.3. Biblioteka ...................................................................................................................................... 50 5.1.4. Interfejs graficzny.......................................................................................................................... 51 5.2. IMPLEMENTACJA - DIAGRAM KLAS...................................................................................................... 51 5.2.1. Diagramy klas ............................................................................................................................... 51 5.2.2. Opisy najważniejszych klas ........................................................................................................... 56 5.3. PROCESU RENDERINGU Z WYKORZYSTANIEM INTERFEJSU BIBLIOTEKI TEXLIB ................................... 58 5.3.1. Fazy procesu renderingu w bibliotece TexLib............................................................................... 59 5.4. INTERFEJS PROGRAMISTYCZNY-ROZSZERZANIE BIBLIOTEKI O NOWE WZORY...................................... 63 5.5. ZAWARTOŚĆ KONTEKSTU CIENIOWANIA W POPULARNYCH SYSTEMACH GRAFIKI FOTOREALISTYCZNEJ 64 5.5.1. 3dsMAX release3........................................................................................................................... 65 5.5.2. LightWorks .................................................................................................................................... 66 5.5.3. RenderMan .................................................................................................................................... 67 5.5.4. LightWave...................................................................................................................................... 68 5.5.5. Kontekst w bibliotece TexLib......................................................................................................... 68 5.6. WYBRANE SZCZEGÓŁY IMPLEMENTACYJNE ........................................................................................ 70 5.6.1. Wzory definiowane w bibliotekach DLL........................................................................................ 70 5.6.2. Ewaluacja drzewa cieniowania..................................................................................................... 71 5.6.3. Zapobieganie cyklom..................................................................................................................... 72 5.7. INTEGRACJA Z PAKIETEM LADS DO RENDERINGU FOTOREALISTYCZNEGO ......................................... 73 5.7.1. System do renderingu fotorealistycznego LightWorks................................................................... 73 5.7.2. Wykorzystanie biblioteki TexLib w procesie cieniowania systemu LightWorks ............................ 76 5.7.3. Przykładowa implementacja shadera LADS wykorzystującego TexLib ........................................ 77

3

.... 90 6. Rendering ........................................... 109 8........................... INSTRUKCJA DLA STUDENTÓW............................................................................................................. 124 4 ..................................................................3........................ Twórczość H............................................................................. Zadania .................4................................... Spękana ziemia.................................... 120 A....4........................2.......2.................... Dodawanie i usuwanie wzorów i wartości ..................................................................................................................3............................. 97 7...................................... 113 A.3...........................3......... Sprawozdanie .................................................................3.......... 81 6.....1..... B............... Edytor drzew cieniowania ..............................Giger’a..........................................................6............................2..........1........... 112 A................................... 89 6...........................2............................... 100 7............................3............ ZALECENIA DLA PROWADZĄCEGO .................. 9............................... WYBRANE SZCZEGÓŁY IMPLEMENTACYJNE ..................................................1.......7............3.....................4............................................ 113 A.......TREE) ...........2............................ Możliwe modyfikacje ćwiczenia ....................................... 103 7....................................................................................................... 121 A........................................... Opis scen trójwymiarowych ..2.........................tree............................................ 113 DODATEK B.............. 122 DODATEK A...........................................................1....... 110 LITERATURA..... PROPOZYCJA ĆWICZENIA LABORATORYJNEGO..............................................2........................................................... SYMULACJE ZJAWISK WYSTĘPUJĄCYCH W NATURZE .......................... Literatura .........................................1...............................................................2........................................................ 118 A......................... Tworzenie połączeń między wzorami ...............................................2................................ 104 7........................2....................................................................................................................... 121 A..........................................................................2.......................................2............................ 86 6...2................4............................ 102 7................................................................................................................3....................................................... Cienie kaustyczne ................PORÓWNANIA................................ 90 7........ 107 7.. B.....................................................................................1...........................................2.............................................2....................1.. Właściwości wzorów.......................................1.........1.......1.................. Wprowadzenie ................................................... 121 A.. 81 6........................2................................... CEL I ZAKRES EKPERYMENTÓW..............................................................3... 89 6.... Format pliku *......................................... Cel ćwiczenia.................... 91 7...................................... 123 Definicja wartości .............1............................... 113 A. Czynniki wpływające na czas generowania obrazu...... 123 Definicja wzorów...................... 99 7......... Ocena ................................................................................ 93 7......................................... Serializacja drzew cieniowania. 91 7.....................2........tekstury proceduralne..................5...........3....................................... Rendering ..........................................................5................................. Skóra węża.....................................................................................1....5....................................4. Warunki eksperymentu .............................................1........................... B........... FUNKCJONALNOŚĆ APLIKACJI EDYTORA .............................. 123 Definicja powiązań.3.....................6.. PODSUMOWANIE .................................................................. 87 6....................................... FORMAT PLIKU ZAPISU DRZEWA CIENIOWANIA (*.................6.. Rezultaty liczbowe .........................2......................................................................................1............................................. 84 6.................................2............... 80 6................ EDYTOR DRZEW CIENIOWANIA . 80 6............................................. Skóra salamandry...........................1....................1. OCENA EFEKTYWNOŚCI .........................................................................................1......... 95 7............................................... 123 B............... 113 A.................5............................2....1................... BADANIA EKSPERYMENTALNE.. INTERFEJS UŻYTKOWNIKA ..R........................................................................................................................................................................................................ 92 7...............2............ PODSUMOWANIE................................... Biblioteka do tworzenia drzew cieniowania ......................3................ 118 A.................................................................................... Skóra wyprawiona...... 91 7.....................................................1.....................................2.........1.......... 102 7..........1........ OCENA JAKOŚCI ............2.........................

.................................................................................................. 31 RYSUNEK 4-1 PRZYKŁADY POŁĄCZEŃ MIĘDZY FUNKCJAMI BAZOWYMI .................................................................... MIYATA – POŁĄCZENIA MIĘDZY KAMIENIAMI MURU ............................................ KRA .................................................................................................. 39 RYSUNEK 4-7 WYNIKI DZIAŁANIA FUNKCJI NOISEV............................................................................... MIYATA – EDO CASTLE.......................................... WORLEY ............ SZUM JAKO FUNKCJA PRZEŁĄCZAJĄCA........................................................................................ WZORY WYPRODUKOWANE ZA POMOCĄ NAKŁADANIA KILKU SYSTEMÓW REACTION – DIFFUSION.. 44 RYSUNEK 4-10 WPŁYW ZASTOSOWANIA RÓŻNYCH METRYK ODLEGŁOŚCI ........................................................PRZYKŁADY TEKSTUR UZYSKANYCH DZIĘKI ZASTOSOWANIU RÓŻNYCH KOMBINACJI LINIOWYCH FUNKCJI FN......................... OD LEWEJ: POWIERZCHNIA PLANETY...................................................... 34 RYSUNEK 4-2 GEOMETRIA ODWZOROWANIA NIERÓWNOŚCI POWIERZCHNI ...... 26 RYSUNEK 3-16 S................. 28 RYSUNEK 3-19 J........... .........................................................................Spis ilustracji RYSUNEK 2-1 SHADE TREE REALIZUJĄCE MODEL OŚWIETLENIA .......................................................................................................................................................................... PRZEKRÓJ PRZEZ PRZESTRZEŃ R3........................................................... WORLEY – PRZYKŁAD WYKORZYSTANIA KOMÓRKOWEJ FUNKCJI BAZOWEJ .............. ..................................................................................................... 84 RYSUNEK 6-7 PROCES TWORZENIA POŁĄCZENIA MIĘDZY PARAMETRAMI – WYBIERANIE PARAMETRU WEJŚCIOWEGO ...................................................... 119 RYSUNEK 9-3 RYBIA ŁUSKA ...................................... 23 RYSUNEK 3-13 G....... KUKLA ..................................................................................................................................................................... 42 RYSUNEK 4-9 ILUSTRACJA FRAKTALNEGO PODPODZIAŁU PRZESTRZENI ....................................................................................................... .......................................... WYSCHNIĘTA ZIEMIA................. 89 RYSUNEK 9-1 PRZYKŁADOWY DIAGRAM FUNKCJI BAZOWYCH ..................................... 88 RYSUNEK 6-14 WIZUALIZACJA POSTĘPU PROCESU RENDERINGU ...................................... 87 RYSUNEK 6-12 MENU RENDERINGU .......................................................................... 24 RYSUNEK 3-15 M............................. 22 RYSUNEK 3-12 K................................................................................................................................... 27 RYSUNEK 3-18 S.... 27 RYSUNEK 3-17 DIAGRAM VORONOI ...................................... 20 RYSUNEK 3-8 ZASTOSOWANIE SZUMU PERLINA DO GENERACJI TEKSTUR.............................................................................. 19 RYSUNEK 3-5 KAMIENNE MURY....... 19 RYSUNEK 3-4 PIANA I STYROPIAN.............................................................................................................................................................. SZUM UŻYTY Z TECHNIKĄ ODWZOROWANIA NIERÓWNOŚCI DO WIZUALIZACJI NIERÓWNOŚCI POWIERZCHNI..... 82 RYSUNEK 6-5 WŁAŚCIWOŚCI WARTOŚCI STAŁYCH ...................... 86 RYSUNEK 6-10 MENU PARAMETRÓW SCENY....................... 41 RYSUNEK 4-8 TYPY WYNIKÓW ZWRACANYCH PRZEZ FUNKCJĘ NOISEV................................................. 120 RYSUNEK 9-4 PIANA NA POWIERZCHNI PIWA ................ 18 RYSUNEK 3-3 KORA I DREWNO ................................................... 22 RYSUNEK 3-10 K............ WZORY REACTION – DIFFUSION NA OBIEKTACH .........................................TEKSTURY SKÓRY....................................................................................................................................... 12 RYSUNEK 3-1 WZORY NA SKÓRZE ZWIERZĄT . 29 RYSUNEK 3-20 OBRAZ WYGENEROWANY PRZY POMOCY BIBLIOTEKI PIXELLOOM ........................... 38 RYSUNEK 4-6 PRZYKŁADY SZUMU FRAKTALNEGO ... 120 5 .... 24 RYSUNEK 3-14 G......................... 88 RYSUNEK 6-13 OKIENKO DIALOGOWE Z PARAMETRAMI RENDERINGU ..................................................................................................................... 81 RYSUNEK 6-3 OKIENKO DIALOGOWE DODAWANIA NOWEGO WZORU ...................................... 18 RYSUNEK 3-2 SKÓRA I PAPIER ................. ....... ZASTOSOWANIE TECHNIKI GENEROWANIA POWIERZCHNIOWEJ TEKSTURY MURU.. 87 RYSUNEK 6-11 OKIENKO DIALOGOWE Z USTAWIENIAMI PARAMETRÓW SCENY ..................................................................... 20 RYSUNEK 3-6 CIENIE KAUSTYCZNE RZUCANE PRZEZ WODĘ............................................................................................................ 2-PARAMETRY WYJŚCIOWE ..................................................................................................................................................................................... ........................................................................................................................................ 20 RYSUNEK 3-7 WZORY ABSTRAKCYJNE ............................................................................................................... 38 RYSUNEK 4-5 WYKRES FUNKCJI SMOOTHSTEP(X)........................ 36 RYSUNEK 4-3 PSEUDO MODEL OŚWIETLENIA .................................................................................. 85 RYSUNEK 6-8 PROCES TWORZENIA POŁĄCZENIA MIĘDZY PARAMETRAMI – WYBIERANIE PARAMETRU WYJŚCIOWEGO ..... 22 RYSUNEK 3-11 K................. TEKSTURY WYGENEROWANE METODĄ CELL DIVISION I ICH NATURALNE ODPOWIEDNIKI.. 47 RYSUNEK 6-1 WIDOK OGÓLNY EDYTORA DRZEW CIENIOWANIA ........... WALTER............................................ 83 RYSUNEK 6-6 WŁAŚCIWOŚCI WARTOŚCI STAŁYCH ZWIĄZANE Z LOSOWOŚCIĄ (WŁAŚCIWOŚCI WARTOŚCI TYPU FLOATARRAY)................................. MARMUR........................................................................................... 85 RYSUNEK 6-9 WIDOK WŁAŚCIWOŚCI WZORÓW.............................................................................................................................................................. TURK..... 30 RYSUNEK 3-21 PRZYKŁADY TEKSTUR KOMÓRKOWYCH WYGENEROWANYCH ZA POMOCĄ CORELTEXTURE ................ 1-PARAMETRY WEJŚCIOWE.......................................... ...... TURK.....................MIYATA TEKSTURA MURU ......................................................................................................... 21 RYSUNEK 3-9 KEN PERLIN.............................. 82 RYSUNEK 6-4 OKIENKO DIALOGOWE DODAWANIA NOWEJ WARTOŚCI STAŁEJ ...................................................................... 37 RYSUNEK 4-4 OBLICZANIE SZUMU PERLINA 2D METODĄ GRADIENTOWĄ ............................................................................................................................................................................................................................................................................................ 81 RYSUNEK 6-2 MENU KONTEKSTOWE DODAWANIA WZORÓW I WARTOŚCI ......................... 114 RYSUNEK 9-2 PRZYKŁADOWY DIAGRAM DRZEWA CIENIOWANIA ............. DREWNO............................

............. 52 DIAGRAM 5-3 DIAGRAM KLAS ZWIĄZANYCH ZE WZORAMI ............................Spis diagramów DIAGRAM 2-1 PRZEBIEG PROCESU RENDERINGU DLA OŚWIETLENIA LOKALNEGO .............................. 73 DIAGRAM 5-9 ARCHITEKTURA PROCESU RENDERINGU W SYSTEMIE LADS.............. 58 DIAGRAM 5-7 PRZYKŁAD KOLEJNOŚCI EWALUACJI PARAMETRÓW DRZEWA CIENIOWANIA ................ 75 6 ....................................... 50 DIAGRAM 5-2 DIAGRAM KLAS TYPÓW WARTOŚCI .............. 72 DIAGRAM 5-8 ARCHITEKTURA SYSTEMU LADS..................................... 9 DIAGRAM 2-2 PRZEBIEG PROCESU CIENIOWANIA ................................................ 53 DIAGRAM 5-4 DIAGRAM KLAS FUNKCJI ZARZĄDZAJĄCYCH WZORAMI .................................................................................................................................................................................................... 10 DIAGRAM 3-1 LIBTEX – EWALUACJA TEKSTUR PRZESTRZENNYCH .... 74 DIAGRAM 5-10 PRZEBIEG PROCESU EWALUACJI WŁASNOŚCI POWIERZCHNI W SYSTEMIE LADS .......................................................................................................................................... 54 DIAGRAM 5-5 DIAGRAM KLAS PODSTAWOWYCH IMPLEMENTACJI ALGORYTMÓW SZUMÓW ............................................................................... 55 DIAGRAM 5-6 FAZA CIENIOWANIA Z UWZGLĘDNIENIEM BIBLIOTEKI TEXLIB .............................................................................................................................................................. 30 DIAGRAM 5-1 ARCHITEKTURA BIBLIOTEKI TEXLIB (MODUŁY FUNKCJONALNE)....................

(choć nie wyklucza się zastosowania podstaw fizycznych). od stosowanych w architekturze kamieni naturalnych. W Rozdziale 3 zawarty jest przegląd zaawansowanych technik symulacji zjawisk naturalnych. wzorów komórkowych. które dają najlepsze rezultaty w dziedzinie interesujących nas typów wzorów. Stosując te metody możemy zasymulować wygląd niemal każdego materiału i powierzchni. Interesuje go tylko to. Większość z tych realistycznych efektów grafiki fotorealistycznej uzyskuje się dzięki proceduralnym technikom opisu własności płaszczyzny. dzielących powierzchnię na mniej lub bardziej regularne siatki. że zawierają dokładne symulacje faktur materiałów budowlanych. Celem pracy jest opracowanie spójnej metody generowania możliwie szerokiej klasy wzorów. projektowanie wspomagane komputerowo. Szczególną rolę odgrywa grafika fotorealistyczna. można je uogólnić i zaklasyfikować do grupy tzw. Patrząc z tej perspektywy. czy szczegółów przedmiotów. W oparciu o tę aplikację opracowano metodę automatycznego generowania wzorów proceduralnych poprzez zestawianie różnych wartości parametrów procedur generujących wzór. pełnymi scen zawierających rozległe. która stara się jak najwierniej zasymulować zjawiska naturalne. 7 . po fantastyczne obrazy planet widocznych z przestrzeni kosmicznej. Na użytek badań proponowanych metod został stworzony interaktywny program pozwalający na łatwe tworzenie szerokiej klasy wzorów oraz eksperymentowanie z nimi. Coraz częściej spotykamy się z pełnometrażowymi filmami stworzonymi bez użycia standardowych kamer. zbadanie jej własności i możliwości zastosowań praktycznych oraz implementacja w postaci uniwersalnej biblioteki. Zawarte są w nim wybrane techniki. Rozdział 2 stanowi wprowadzenie do procesu renderingu. począwszy od rozrywki. można proces tworzenia tekstur proceduralnych porównać do procesu tworzenia realistycznego obrazu.1. Wspólną cechą tych zjawisk jest to. Na bazie opracowanych i zbadanych technik oraz zrealizowanego oprogramowania opracowano również ćwiczenie laboratoryjne do laboratorium Zaawansowanych Metod Grafiki Komputerowej zapoznające studentów z możliwościami zastosowania proceduralnych technik teksturowania. reklamy. że przy pewnej dozie wyobraźni. jaka część obrazów. przypomina rolę oraz historię proceduralnych technik teksturowania. aby doprowadzić do pożądanego efektu. po architekturę. gazetach. bądź bliskie ujęcia twarzy. reprodukcję ich właściwości wizualnych. wystroju wnętrz. medycynę. powstała dzięki niej. w jaki sposób dzieło zostanie odebrane przez publiczność i w jaki sposób kontrolować proces. Stała się ona w dzisiejszych czasach na tyle doskonała. Spotykamy się z nią na każdym kroku. którą będzie można zintegrować z dowolnym pakietem oprogramowania do tworzenia grafiki fotorealistycznej udostępniającym interfejs programistyczny wspomagający programowanie tekstur proceduralnych. kora drzewa. skóra ludzka. Wizualizacje architektoniczne trudno odróżnić od zdjęć. że czasem nie zdajemy sobie nawet sprawy z tego. roślinności. nieba. które widzimy w kinie. różne rodzaje skóry zwierząt. dzięki temu. scenografii ani żywych aktorów. Wstęp Grafika komputerowa ciągle zyskuje na znaczeniu w wielu dziedzinach życia. zapierające dech krajobrazy. Celem pracy nie jest symulacja poprawna fizycznie. Jest nim jedynie stworzenie wzorów jak najbardziej przypominających naturalne. Przykładami badanych zjawisk mogą być kamienie naturalne. Artysta malarz prawie nigdy nie posługuje się wiedzą na temat fizyki odtwarzanego obiektu. czy ulicznych reklamach.

Dodatek B przedstawia format opisu drzew cieniowania zapisywany i odczytywany przez bibliotekę TexLib.Opis opracowanych metod tworzenia wzorów przebadanych i zaimplementowanych w stworzonym oprogramowaniu umieszczono w Rozdziale 4. Rozdział 7 jest poświęcony badaniom eksperymentalnym oraz ocenie wyników. Ocenie podlegają zarówno wartości wizualne budowanych wzorów jak i wydajność algorytmów i procesu ich tworzenia. Podsumowanie w Rozdziale 8 zawiera ocenę wyników pracy. umożliwiający tworzenie realistycznych wzorów przy posiadaniu minimum wiedzy na temat technik grafiki komputerowej i teksturowania proceduralnego. Opisano również i przeanalizowano wprowadzone przez autora usprawnienia metod zaczerpniętych z literatury. interfejs do komunikacji z systemami do renderingu. 6 rozdział prezentuje system stworzony na bazie biblioteki TexLib. Opisane zostało środowisko jej działania. opis potencjalnych kierunków dalszego rozwoju systemu. Ćwiczenie wykorzystuje opracowany system i proponuje uczestnikom zajęć wykonanie modułów rozszerzających go. sposoby na wykorzystanie osiągniętych rezultatów. Następny. Rozdział 5 opisuje uniwersalną bibliotekę TexLib stworzoną na potrzeby tej pracy. System wykorzystuje profesjonalne narzędzie do budowy aplikacji wykorzystujących grafikę trójwymiarową LightWorks Application Development System. 8 . Znajdują się tam dokładne opisy zastosowanych algorytmów oraz ich analiza. Opis zawiera wstęp teoretyczny oraz wskazówki na temat implementacji. oraz niektóre szczegóły implementacyjne. W Dodatku A znajduje się propozycja ćwiczenia laboratoryjnego na zajęcia z zaawansowanych metod grafiki komputerowej.

druga to cieniowanie. Następująca po tym faza przekształceń rzutowania przechodzi za pomocą transformacji zależnej od zdefiniowanego wcześniej widoku na układ współrzędnych widoku.: odbicia). podlegających zniekształceniom wynikającym z animacji itd. związanych głównie z procesem teksturowania. które nie będą widoczne na wygenerowanym obrazie są usuwane z dalszego procesu (oczywiście są sytuacje wyjątkowe. Podstawowe pojęcia grafiki komputerowej Poniżej przedstawiony został schemat typowego potoku renderingu dla oświetlenia lokalnego. jak np. visibility processing – wynikają z metody renderingu i różnią się dla metod scanline.1. czyli nie biorącego pod uwagę światła odbitego i rozproszonego. płaszczyzn określonych równaniami parametrycznymi. zostały już zamienione na wielokątny) do piramidy widzenia. brył opisanych proceduralnie.).). bryły proceduralne itp. Faza rasteryzacji operuje na trójwymiarowym układzie współrzędnych ekranu. Z-buffer. Elementy grafiki komputerowej Ten rozdział zawiera definicje pojęć grafiki komputerowej. który jest jednym z elementów potoku renderingu. przekształcenia geometryczne przekształcenia modelowania przekształcenia rzutowania rasteryzacja określenie powierzchni widocznych rasteryzacja cieniowanie Diagram 2-1 Przebieg procesu renderingu dla oświetlenia lokalnego Proces tworzenia obrazu podzielony jest na 2 niezależne części. Geometria sceny może być opisana w różny sposób: za pomocą trójkątów. związane z pewnymi zagadnieniami oświetlenia globalnego.2. W tym układzie odbywa się określenie powierzchni widocznych (algorytmy określania powierzchni widocznych – ang. wszystkie płaszczyzny opisane parametrycznie. algorytm rasteryzacji określa które płaszczyzny znajdą się w kolejnych pikselach obrazu. Definiowanie obiektów sceny odbywa się zwykle w ich lokalnym układzie współrzędnych. Pierwszą jest przygotowanie geometrii. 2. wykorzystywana przez system RenderMan). Omówiono tutaj także pobieżnie proces renderingu dla metod biorących pod uwagę oświetlenie lokalne. wielokątów. Przykładami algorytmów wykorzystujących ten potok są rendering scanline. Po obcięciu wielokątów (w tej fazie geometria składa się z wielokątów. 9 . od tego czy renderer używa nadpróbkowania. W trakcie tej fazy geometria jest obcinana do piramidy widzenia zależnej od aktualnego widoku. Tutaj jest używany globalny układ współrzędnych. raytracing itd. ilości płaszczyzn ‘widocznych’ przez obliczany piksel obrazu itp. Następujące po tym cieniowanie jest odpowiedzialne za przygotowaniu kontekstu oraz obliczeniu właściwości powierzchni dla próbek (liczba próbek zależy np. Fragmenty. Faza przekształceń modelowania określa przekształcenia wszystkich elementów geometrii opisanych za pomocą hierarchii. Z-buffer. REYES (zmodyfikowana metoda scanline.

Kontekst cieniowania jest przekazywany algorytmowi odpowiedzialnemu za określenie własności cieniowanej powierzchni i wynikającego z nich koloru. przezroczystość. jako. Tekstura w grafice komputerowej to wzór opisany na obiekcie. w nowoczesnych systemach grafiki fotorealistycznej jest fazą zajmującą najwięcej zasobów systemu.t lub współrzędnych układu lokalnego obiektu P. że na jeden piksel może być pobieranych kilka próbek z kilku płaszczyzn nań się składających). określające lokalne wartości atrybutów powierzchniowych. moduł rasteryzacji i cieniowania określanie widoczności (visibility processor) tworzenie kontekstu cieniowania obliczenie koloru dla próbki Diagram 2-2 Przebieg procesu cieniowania Kontekst cieniowania jest zbiorem informacji identyfikujących i opisujących aktualnie cieniowaną próbkę (próbka nie koniecznie jest jednoznaczna z pikselem. który stosuje odpowiedni model cieniowania. ale nie tylko. który. N – wektor normalny do danej płaszczyzny (znormalizowany) L – wektor określający kierunek do źródła światła (znormalizowany) Wartość koloru jest zwracana jako wynik.1]). zostanie umieszczony bezpośrednio na obrazie lub wykorzystany jako część składowa koloru aktualnie cieniowanego piksela. gdzie: i i – indeks źródła światła.. bądź globalnego – Pw. 10 . Obliczenie koloru dla danego kontekstu cieniowania może być bardzo złożonym procesem. Zasoby te to głównie czas jednostki obliczeniowej. ka – współczynnik odbicia światła rozproszonego (z przedziału [0. zależnie od algorytmu rasteryzacji.Z naszego punktu widzenia jest to najbardziej interesujący proces. Jest on wyrażony w postaci równania oświetlenia uwzględniającego w swojej najbardziej popularnej postaci składowe oświetlenia pochodzące ze wszystkich źródeł znajdujących się na scenie w następujący sposób [Foley]: i I = I a k a + ∑ I ip * k d ( N * Li ) . Szczególnym rodzajem tekstur są tekstury proceduralne. Czynnikiem wpływającym na zwiększenie zajętości pamięci przez tę fazę jest dążenie do uzyskania jak najbardziej realistycznych obrazów poprzez wykorzystanie dobrej jakości tekstur. definiujący atrybuty powierzchni (takie jak kolor. Model cieniowania opisuje między innymi model oświetlenia. Oryginalne znaczenie tekstury to układ włókien w materiale. Ip – natężenie światła (światłość) źródła światła. Poniższy diagram pokazuje relacje modułu cieniującego z modułem określania powierzchni widocznych. połyskliwość). kd – współczynnik odbicia rozproszonego dla danego materiału. co więcej. Ia – natężenie światła otoczenia (równe dla wszystkich obiektów). które można określić jako funkcje współrzędnych układu odwzorowania tekstury s.

Objętość takiej definicji jest jednak na tyle duża. w których duża ilość płaskich obrazów. Z pomocą przychodzą tutaj przestrzenne tekstury proceduralne. czyli symulacja zniekształceń powierzchni za pomocą zmian normalnych powierzchni wprowadzony przez Blinna w 1978 oraz odwzorowanie cieni (ang. szybko w związku z tym pojawiły się ulepszenia techniki Catmulla wykorzystujące tekstury także do innych niż modyfikacja koloru powierzchni celów. Historia tekstur proceduralnych Charakterystyczną cechą obrazów powstających w początkach grafiki komputerowej był niewielki stopień ich realizmu. opisanie tekstury na kuli spowoduje wystąpienie zniekształceń w obszarach biegunowych). wykorzystano do produkcji realistycznych cieni. zawodzą. Jest ona dzisiaj określana jako „funkcja która dała początek tysiącu tekstur” („the function. Catmulla tekstur – skanowanych obrazów – nałożonych na geometrię i modyfikujących jej kolor . Ken Perlin zdefiniował najintensywniej obecnie używaną do produkcji tekstur proceduralnych funkcję. Obrazy tworzone syntetycznie – proceduralnie – były wykorzystywane od początku istnienia pojęcia tekstury. Jeśli jednak geometria jest reprezentowana za pomocą siatki trójkątów. y. Stosuje się w tych przypadkach przekształcenia z trójwymiarowej przestrzeni obiektu (x. reprezentujących kolejne przekroje obiektu. Jedyną metodą całkowitej eliminacji deformacji tekstur jest zastosowanie tekstur zdefiniowanych w przestrzeni trójwymiarowej. W ten sposób każdemu punktowi powierzchni odpowiada punkt dwuwymiarowej tekstury (s. Lata 80 przyniosły kilka innowacji. Pierwsze sceny przedstawiały modelowane za pomocą siatek trójkątów lub powierzchni parametrycznych obiekty cieniowane z wykorzystaniem mało realistycznych modeli oświetlenia. w tym samym roku. bump mapping) . także do opisu zjawisk przestrzennych.E. Wkrótce pojawiły się kolejne zastosowania tekstur w grafice komputerowej: odwzorowanie nierówności powierzchni (ang. t). Otrzymywał w ten sposób wzory przypominające naturalne chmury. wykorzystywanej do generacji naturalnie wyglądających tekstur. W 1976 Blinn i Newell przedstawili metodę odwzorowania środowiskowego (ang. Było to jedno z pierwszych podejść do tworzenia realistycznych tekstur proceduralnych. więc można z jego pomocą produkować tekstury przestrzenne – nie wymagające w 11 . Dla tego typu obiektów tradycyjne metody rzutowania dwuwymiarowych. W obydwu sposobach znajdowania współrzędnych (s. Nie sposób uczynić tego w efektywny sposób dysponując jedynie płaskimi obrazami (Choć istnieją takie podejścia. że stosowanie takiego rozwiązania na szerszą skalę jest niepraktyczne). z). tworzone przy ustawieniu obserwatora w punkcie źródła światła. skanowanych obrazów. 2. Funkcje o dużych okresach przekształcał dodając wartości funkcji o dużych częstotliwościach. za pomocą uporządkowanej pary (u. definiuje trójwymiarowe tekstury. drewna.Problem teksturowania przedstawiony został dokładniej w następnym punkcie. które umożliwiły wygodne korzystanie z tekstur. nie można łatwo przeprowadzić odwzorowania punktu na powierzchni w punkt tekstury.2. Obiekty zyskały wiele na realizmie przy niewielkim wysiłku i zwiększeniu złożoności obliczeniowej. t) jednak zawsze pojawiają się zniekształcenia (np. Znaczącym krokiem naprzód było użycie w 1974 przez E. Noise może być zdefiniowany w trzech i większej ilości wymiarów. Catmull w swoim pierwszym podejściu teksturował powierzchnie zdefiniowane parametrycznie. strona 66). chmur. takich jak drewno. that launched a thousand textures” [T&M 1998]. przy pomocy której stała się możliwa symulacja powierzchni lustrzanych. hadow mapping). gdzie tekstury głębokości. Korzystają z niej między innymi procedury generujące realistyczne obrazy marmurów. Zaraz po nim. Geoffrey Gardner produkował tekstury sumując funkcje sinus o różnych okresach. reflection mapping lub environment mapping). Minimalizacja tych zniekształceń do dziś jest problemem w przypadkach bardzo skomplikowanych modeli. v). czy marmur. Mowa o funkcji noise. fazach i amplitudach. górzystych krajobrazów itp.

atmosfery. obrazów skanowanych. skanowanych bądź tworzonych ręcznie. jednak dzięki kilku wyróżniającym je cechom ich stosowanie jest opłacalne. Shade trees dawały między innymi możliwość przypisywania powierzchniom własnych procedur opisujących kolor. Postęp w grafice komputerowej sprawił jednak. Cooka na podstawie którego powstał potem system grafiki fotorealistycznej RenderMan. Największymi zaletami teksturowania proceduralnego są: • niezależność od docelowej rozdzielczości – większość procedur potrafi wygenerować dowolną ilość detali wraz z przybliżaniem się obserwatora do powierzchni.5. tekstur są łatwość wykonania i realistyczny wygląd. point Viewer = normalize(-I). } Niewątpliwie zaletami tradycyjnych. Powstały też systemy. przy czym 4. a także animacje (4wymiarowy noise. odbicia przedmiotów znajdujących się w pobliżu). Ks=0.czasie tworzenia obrazu stosowania przekształcenia do współrzędnych (s.1. Kd=0. Chodzi tutaj nie tylko o ostrość czy czystość kolorów.Viewer. L. wpływ otoczenia na własności powierzchni (np. Poza tym obrazy skanowane rzadko mają dobrą jakość. następuje przekształcenie z trójwymiarowej 12 . Oi=Os. które je generują są oczywiście zwykle bardzo duże w porównaniu z dostarczeniem zdjęć. ale warunki oświetlenia w czasie robienia zdjęć (na powierzchniach chropowatych mogą występować cienie pochodzące od bocznych świateł). Rysunek 2-1 przedstawia przykładowe shade tree Cooka realizujące prosty model oświetlenia (plastic): Rysunek 2-1 Shade tree realizujące model oświetlenia Oto odpowiadający mu kod shadera systemu RenderMan: surface plastic (float Ka=1. • możliwość generowania tekstur wielowymiarowych – przy adresowaniu standardowych tekstur.) { point Normal=faceforward(normalize(N). wymiar opisuje czas). że nie sposób ich odróżnić od naturalnych odpowiedników. np. definicji świateł itp. tzw. Ci=Os*( Cs*(Ka*ambient()+Kd*diffuse(Normal)+ Ks*specular(Normal.I).Roughness=0. Koszty stworzenia funkcji. zaczęto tworzyć języki opisu funkcji je generujących. Odkąd tekstury proceduralne udowodniły swoją użyteczność.5. że realizm obrazów proceduralnych jest często na tyle duży. Najbardziej znanym przykładem jest system drzew cieniowania shade trees R. shading languages. model cieniowania itp. które umożliwiały definiowanie funkcji teksturujących (shaders) do opisu różnych właściwości powierzchni. przezroczystość.Rougness)) ). t).

• predefiniowane funkcje matematyczne. nie związanych z konkretnym systemem do renderingu. którego używamy dostarcza pewnego interfejsu za pomocą którego mamy możliwość umieszczenia w scenie nowych funkcji teksturujących. transformacje współrzędnych itp. pisane w języku C. bądź interfejs za pomocą którego definiowane są moduły rozszerzeń (np. W ten sposób. • stosowania rekurencji. Dla konkretnego rodzaju wzorów istnieje zwykle jeden algorytm. W Shading Language. również umożliwiający pisanie tekstur proceduralnych. Wszystkie dane związane z kontekstem aktualnie cieniowanego punktu muszą zostać przekazane za pomocą parametrów w czasie wywołania zewnętrznej funkcji wewnątrz funkcji teksturującej zdefiniowanej w Shading Language.1. 2. Definiowanie bibliotek tekstur proceduralnych Wiele tekstur proceduralnych używa podobnych metod do generacji wzorów. Definiowanie tekstur proceduralnych Definiowanie tekstur proceduralnych odbywa się zazwyczaj w konkretnym środowisku. funkcje bazowe tekstur. Są to tzw. Shading Language w RenderMan i Blue Moon Rendering Tool). 3dsMAX). 3dStudioMAX udostępnia obiektowy interfejs C++ służący do pisania modułów rozszerzeń. Najpopularniejsze funkcje bazowe są często predefiniowane w systemach do renderingu. opisujące kolor. jest zdefiniowany w C.• • przestrzeni sceny do dwuwymiarowej przestrzeni obrazu co jest przyczyną zniekształceń naniesionych na obiekty tekstur. istnieje możliwość tworzenia dowolnie skomplikowanych tekstur. Języki opisu tekstur proceduralnych to specjalizowane narzędzia. Posiadają: • predefiniowane typy (np. punkty. Także w tych przypadkach umożliwia to łatwą integrację z zewnętrzną biblioteką. co umożliwia właśnie teksturowanie proceduralne mały rozmiar definicji (w porównaniu ze skanowanymi obrazami w wysokiej rozdzielczości lub teksturami trójwymiarowymi) parametryczny interfejs umożliwiający generację wielu różniących się obrazów za pomocą jednej procedury. Istnieje też możliwość wykorzystania uniwersalnych. brak obsługi plików). wektory) oraz operacje na nich (operacje na wektorach. używanym w systemie RenderMan. które ułatwiają zadanie programisty tekstur. Interfejs taki to zwykle język opisu tekstur proceduralnych (np. wykorzystujących złożone typy danych oraz operacje wejścia/wyjścia. System. • stosowania wskaźników. istnieje możliwość rozszerzenia podstawowego zbioru funkcji (zwanych tam shadeops) o nowe. 2.3. Interfejs modułów rozszerzeń LightWave.3.). inne 13 . definiujące modele cieniowania itp. to brak możliwości • definiowania własnych typów. Biblioteki takich funkcji mogą być używane z poziomu Shading Language. • używania operacji wejścia/wyjścia (np. mimo ograniczeń języka teksturowania. • przenaszalność w przypadku języków interpretowanych Wady takich języków. problem znika jeśli tekstura jest zdefiniowana w odpowiedniej przestrzeni. który do zastosowania w wielu teksturach wymaga jedynie małych modyfikacji. Podobnymi możliwościami dysponuje wiele innych systemów. jednak same funkcje nie mogą używać shadeops ani żadnych innych dostarczanych przez renderer danych. bibliotek procedur teksturujących.

t. że zwykle wynikiem działania funkcji teksturującej jest obraz. Kolejny adapter przyjmie wyniki zwrócone przez funkcję i umieści je w odpowiednich zmiennych systemu. Efektywność działania można poprawić stosując kilka metod: 14 . których zdolności naśladowania zjawisk naturalnych są mocno ograniczone. Na przykład antialiasing tekstur powierzchniowych jest przeprowadzany w RenderManie przy pomocy wartości pochodnych powierzchni w punkcie. Po pierwsze. Dv ). Jakość tekstur proceduralnych Ocena jakości nie jest oczywista ze względu na to. gdzie dx. a ocena tego może być bardzo subiektywna. 2. aby uniknąć wielokrotnego ich definiowania i zwiększyć czytelność nowo powstających tekstur. bądź udostępniane za pośrednictwem języka teksturowania. w systemie RenderMan funkcje zdefiniowane zewnętrznie nie mają dostępu do zmiennych globalnych ani funkcji shadeops). Idąc jeszcze dalej. aby funkcja zwracała uśrednioną wartość koloru z pewnej powierzchni. • Nie możemy zakładać. Oczywistą pomocą przy ocenie jakości. która może zastąpić subiektywne estetyczne wrażenia. Danymi wejściowymi adaptera będzie kontekst cieniowania systemu renderującego. miarą. które są używane. Ocenę tekstur przeprowadza się także na podstawie kilku innych parametrów. Wchodzą tutaj w grę wrażenia estetyczne. natomiast LightWorks potrafi obliczyć wielokąt. dx.warto umieścić w bibliotece. który jest cieniowany ( Du. Wydajność to ważny w teksturach proceduralnych czynnik przesądzający o ich przydatności do użycia. który powstaje przez rzut aktualnie obliczanego piksela na cieniowaną powierzchnię. danymi wyjściowymi zaś parametry odpowiednich funkcji zdefiniowanych w bibliotece. Niniejsza praca ma na celu symulację pewnych zjawisk naturalnych. przez renderer. Wynika to z poprzednich spostrzeżeń na temat sposobu realizacji antialiasingu. będzie więc porównanie zjawisk generowanych z występującymi w naturze. aby zapewnić odpowiednią uniwersalność. Po drugie. Najczęściej dokładne modele fizyczne są zbyt skomplikowane implementacyjnie bądź zbyt złożone obliczeniowo a w zamian stosuje się uproszczone modele. Skomplikowane tekstury zwykle są kosztowne obliczeniowo. y). Aby zapewnić przenaszalność biblioteki takich funkcji między systemami do renderingu należy stosować się do kilku reguł: • Funkcje nie mogą korzystać z żadnych danych ani funkcji. y i wyrównanego do osi zdefiniowanych przez układ współrzędnych tekstury s. aby uniknąć aliasingu. y.4. tak. jakimi dokładnie możliwościami dysponuje renderer i przy budowie funkcji należy przyjąć jakieś założenia. • W celu udostępnienia informacji o kontekście cieniowania należy zbudować odpowiedni adapter. nie można stosować wartości udostępnianych przez system. można zażądać. chess(x. 3dStudioMAX dostarcza bezpośrednio zakres u i v w którym należy policzyć kolor średni. Dwa z nich to wydajność oraz jakość obrazu mierzona ilością zniekształceń spowodowanych aliasingiem (próbkowaniem wzorów o częstotliwościach większych od częstotliwości wynikającej z ograniczenia Nyquista). Są dwa tego powody. na podstawie których trudno zdefiniować przydatną miarę jakości. LightWave posługuje się pojedynczą wartością ( spotSize ). ponieważ te są zwykle podawane w inny sposób dla każdego programu. Funkcje bazowe mogą być definiowane na różnym poziomie. dy). Najprostszym przykładem takiej funkcji może być sin(x). często używana funkcja szumu Perlina – noise – jest stosunkowo wolna. np. Równie dobrze jednak można funkcją bazową nazwać dwuargumentową funkcję generującą dwuwymiarową szachownicę: chess(x. nie jest to zwykle możliwe technicznie (np. dy to rozmiary prostokąta otaczającego punkt x. W szczególności.

na niekorzyść tych pierwszych. Optymalizacje algorytmu. że tak jest w większości przypadków). Przyczyną jest to. Część wartości obliczanych wewnątrz funkcji teksturującej może być niezmienna dla kilku kolejnych wywołań jeśli odbywają się one dla punktów położonych blisko siebie (a można założyć. nie przytłaczając jednocześnie nadmiernym skomplikowaniem. Różnica stopnia skomplikowania tekstur generujących te same wzory z zastosowaniem antialiasingu analitycznego i bez niego często jest bardzo duża. jak nadpróbkowanie. Mimo tego jednak dodatkowy wysiłek włożony w implementację procedur produkujących wysokiej jakości antialiasowane obrazy w większości przypadków jest opłacalny. Możliwość wykorzystania tego spostrzeżenia istnieje w większości dostępnych systemów udostępniających interfejs teksturowania proceduralnego. • realizowane przez funkcje teksturujące: o redukcja wysokich częstotliwości w obrazie realizowana za pomocą rozmywania ostrych krawędzi z użyciem stałego filtra o adaptacyjna redukcja wysokich częstotliwości. w której wielkość filtra jest uzależniona od oszacowania wielkości projekcji piksela do przestrzeni tekstury o antialiasing analityczny. że sam algorytm produkcji tekstury bez wbudowanego mechanizmu antialiasingu będzie najczęściej działał dużo szybciej niż wersja z antialiasingiem. że 15 . Jest nim łatwość obsługi. którego znaczenie było przez długi czas niedoceniane a który ma bardzo duże znaczenie dla tekstur pisanych z myślą o udostępnianiu szerokiemu gronu użytkowników. a które pozostają niezmienne w trakcie całego procesu renderingu. ale generalną zasadą jest stosowanie cache’owania tam. Łatwość obsługi tekstur zależy od ich parametryzacji. W rzeczywistości to zagadnienie traktowane jest często jako mało istotne. Poleganie na nadpróbkowaniu prowadzi do końcowej nieefektywności mimo tego. zależy w dużej mierze od tego. Stosowanie antialiasingu analitycznego wiąże się zazwyczaj ze znacznym nakładem obliczeniowym i wymaga dostarczenia przez renderer pewnych dodatkowych informacji o wielkości obszaru dla którego mają się odbyć obliczenia. Czasem warto porównywać aktualne parametry wejściowe z poprzednimi i w miarę możliwości odzyskiwać wyniki poprzednich obliczeń. Ponadto nawet wysoki stopień nadpróbkowania może w pewnych przypadkach nie być wystarczający. Te optymalizacje są oczywiście zależne od konkretnych tekstur. a szczególnie sekwencji obrazów tworzących animację. Generalnie metody antialiasingu (czyli przeciwdziałania artefaktom) można podzielić na: • realizowane przez system renderującym niezależne od funkcji teksturującej.• • • Obliczanie wartości niezmiennych. Oprócz już wymienionych czynników wpływających na ocenę tekstury proceduralnej istnieje jeszcze jeden. gdzie jest to możliwe. jak rozwiązany został w teksturze problem aliasingu. w którym oszacowywany jest kolor średni tekstury na obszarze będącym projekcją cieniowanego piksela do przestrzeni tekstury Algorytmy renderingu potrafią do pewnego stopnia korygować artefakty powstające z powodu aliasingu za pomocą technik nadpróbkowania. Optymalizacje na poziomie języka programowania. Jakość wygenerowanego obrazu. które można obliczyć na podstawie parametrów wejściowych. Często istnieją wartości. Złożoność funkcji cieniujących rośnie jednak często do tego stopnia. Tekstury proceduralne obliczają zwykle kolor powierzchni dla danego punktu w przestrzeni. co sprzyja ignorowaniu tego zjawiska na poziomie tworzenia tekstury. że aby uzyskać obraz dobrej jakości renderer będzie najprawdopodobniej nadpróbkowywał piksele całego obrazu zamiast tylko te zajęte przez teksturę. Tekstura powinna dawać użytkownikowi dużą swobodę w kontroli efektów.

Powyższe kryteria ocena zostaną zastosowane w czasie projektowania tekstur oraz do ich końcowej oceny. że redukując liczbę parametrów tracimy elastyczność procedury. Ponieważ korzystać mają z tekstur ludzie. Aby pogodzić łatwość obsługi z zachowaniem odpowiedniej elastyczności często ukrywa się przed użytkownikiem część parametrów przyjmując jakieś ustalone wartości i dostarczając procedurę w kilku wersjach. Problem polega na tym. Posługując się za Kentonem Musgrave [T&M 1998] pojęciem wielowymiarowej przestrzeni estetycznej. można powiedzieć.spotyka się tekstury kontrolowane za pomocą kilkudziesięciu parametrów. którzy nie chcą poświęcać wiele czasu na poznawanie fizycznych czy jakichkolwiek innych podstaw działania procedury (często będą to artyści. które odpowiadają intuicji i konwertować wewnątrz procedury (zastępując na przykład kilka parametrów mających wpływ na ilość detali jednym. Jeśli nadto algorytm posługuje się mało intuicyjnymi parametrami. nie mający wielkiego pojęcia o zasadach działania technik proceduralnych). można je zastąpić takimi. opisanym jako stopień szczegółowości). że tracimy kolejne stopnie swobody. które niedoświadczonym użytkownikom (czyt. Parametry są przeważnie wyrażane liczbami. o ile nie zna się algorytmów zastosowanych w konkretnym przypadku i nie wie jak każdy z parametrów na nie wpływa. Dobranie właściwych wartości parametrów w takich przypadkach jest trudne. to parametry powinny być intuicyjne i nie powinno ich być wiele. 16 .: wszystkim poza autorem procedury) mogą sprawiać kłopoty.

Funkcje produkujące wzory tego typu to tekstury komórkowe. struktura gąbki (Rysunek 3-4). Kolejność pikseli tekstury o jakie renderer pytałby byłaby bowiem najczęściej różna od kolejności w jakiej generuje je funkcja. nie możemy więc określić stopnia szczegółowości ani rozmiarów tekstury) najlepszym rozwiązaniem są właśnie tekstury implicit. Definicja explicit wymagałaby prawdopodobnie wygenerowania całej tekstury przed rozpoczęciem renderingu i zapamiętania jej. Informacje zawarte w rozdziale stanowiły punkt wyjścia do opracowania metod symulacji dających realistyczne obrazy zjawisk podobnych do opisywanych. wzory tworzące się na wyschniętej ziemi (Rysunek 3-5). w jaki dzielą przestrzeń. Zarówno wzory na żyrafie jak kora niektórych drzew dzielą powierzchnię na komórki o mniej lub bardziej regularnych kształtach. mury kamienne. bądź to uzasadnionej fizycznie. cienie kaustyczne rzucane przez wodę(Rysunek 3-6). duże koty – gepard.3. zmięty papier (Rysunek 3-2). ogień. Kategorie tekstur proceduralnych rozważane w pracy Tekstury proceduralne mogą być tworzone dwoma sposobami: implicit i explicit. jaguar. W przypadku explicit funkcja generuje cały obraz. kamienia naturalnego (marmury. Podobnie z pozostałymi przykładami. Tutaj interesować nas będą jedynie tekstury generowane w sposób implicit. przed renderingiem nie znamy ich położenia na wynikowym obrazie. abstrakcyjne wzory (Rysunek 3-7). W tej pracy zajmę się pewnym podzbiorem tekstur proceduralnych. Tekstury proceduralne pozwalają na symulację bardzo szerokiego zakresu zjawisk naturalnych. wodę. piana. styropian. 3. leopard. wzory powstające na skórze niektórych zwierząt (żyrafy. 17 . od struktury drewna. kora drzew(Rysunek 3-3). inne.1. Cechą wspólną tych wzorów jest sposób. Przegląd stosowanych metod symulacji zjawisk naturalnych W tym rozdziale przedstawione zostały fotografie wzorów występujących w naturze oraz różne podejścia do ich symulacji. bądź opartej tylko na wrażeniach estetycznych. granity). stosując dowolną kolejność tworzenia kolejnych pikseli. Przykładami interesujących mnie wzorów są kamienne mury. kamienie naturalne. W przypadku tekstur. które są obliczane w trakcie renderingu (tzn. skóra ludzka. wężę. Funkcje implicit odpowiadają natomiast na pytanie o jakiś konkretny punkt. ocelot) (Rysunek 3-1 Wzory na skórze zwierząt). po chmury.

jaguar leopard ocelot pantera wąż Rysunek 3-1 Wzory na skórze zwierząt żyrafa skóra Rysunek 3-2 Skóra i papier zmięty papier 18 .

Rysunek 3-3 Kora i drewno piana styropian piana na powierzchni piwa Rysunek 3-4 Piana i styropian gąbka – symulacja 19 .

kamienny mur kamienny mur spękana powierzchnia wyschniętej ziemi kra lodowa Rysunek 3-5 Kamienne mury. wyschnięta ziemia. kra Rysunek 3-6 Cienie kaustyczne rzucane przez wodę Rysunek 3-7 Wzory abstrakcyjne 20 .

3.2. Techniki zaawansowane
Poniżej przytaczam wyniki badań nad zjawiskami, które mogą być symulowane za pomocą tekstur komórkowych. Szereg podejść wzorowało się na fizycznych podstawach powstawania wzorów (teorie Reaction-Diffusion oraz Cell Division powstawania wzorów na skórze ssaków), pozostałe, o ile wiadomo, nie mają nic wspólnego z rzeczywistymi procesami.

3.2.1. Szum Perlina
Największą rewolucją w symulacji naturalnych zjawisk przy pomocy teksturowania proceduralnego było wprowadzenie w 1985 przez Kena Perlina funkcji generującej szum (tzw. Perlin noise), której charakterystycznymi cechami są: • powtarzalność (dla określonych parametrów ma zawsze tę samą wartość) • ograniczenie wartości do przedziału [-1, 1] • skończona częstotliwość (maksymalna częstotliwość równa 1) W odróżnieniu od szumu Perlina, szum biały nie ma ograniczenia częstotliwości, nie jest też powtarzalny. Dla teksturowania proceduralnego jest praktycznie bezużyteczny. Pierwszym powodem jest to, że wzory wygenerowane za jego pomocą byłyby za każdym razem inne. Niemożliwe stałoby się odtworzenie wzoru, a co za tym idzie generowanie animacji ani różnych widoków tego samego obiektu. Drugim, fakt, że biały szum wprowadza nieskończoną liczbę szczegółów. Uniemożliwiłoby to przeprowadzenie antialiasingu, ponieważ próbkowanie nigdy nie mogłoby mieć wystarczającej częstotliwości. Oryginalny szum Perlina jest implementowany jako funkcja interpolująca między losowymi wartościami generowanymi w węzłach wielowymiarowej dyskretnej siatki. Perlin noise jest narzędziem wykorzystywanym przy bardziej zaawansowanych algorytmach i jako taki jest podstawą większości tekstur proceduralnych. Pozwala na symulację zjawisk, które mają charakter fraktalny, czy takich, gdzie można zaobserwować nałożone na siebie wzory o różnych wielkościach. Większość zjawisk naturalnych, czy to ruch gałęzi na wietrze czy struktura chmur bądź kamienia, ma właśnie charakter fraktalny. Rysunek 3-8 przedstawia kilka zjawisk, których podstawą jest fraktalna wersja Perlin noise. Na Rysunek 3-9 widać wykorzystanie szumu do zniekształcenia powierzchni obiektu.

Rysunek 3-8 Zastosowanie szumu Perlina do generacji tekstur. Od lewej: powierzchnia planety, szum jako funkcja przełączająca, marmur, drewno.

21

Rysunek 3-9 Ken Perlin. Szum użyty z techniką odwzorowania nierówności do wizualizacji nierówności powierzchni.

Ze pomocą tej metody nie można wygenerować większości wzorów komórkowych, jednak z powodzeniem można jej używać do produkcji np. granitu, czy powierzchni styropianu, widzianych z dostatecznie dużej odległości (tzn. takiej, z której nie można dostrzec wyraźnych szczegółów).

3.2.2. Wzory kamiennych murów
K. Miyata na konferencji SIGGRAPH 1990 zaprezentował metodę generacji tekstur przypominających kamienne mury. Jego metoda produkuje tekstury powierzchniowe (zdefiniowane w przestrzeni st obiektu). Obliczany jest kolor oraz odchylenie normalnej wizualizujące nierówności powierzchni (bump mapping). Miyata zauważył, że do stworzenia tekstury muru potrzebne są dwa modele: struktura połączeń między kamieniami oraz tekstura pojawiająca się na kamieniach. W ten sposób wyodrębnił dwa etapy produkcji tekstury. W pierwszym, na podstawie parametrów określających średnią wielkość kamieni, ich zróżnicowanie oraz sposób rozłożenia na powierzchni generuje wzór imitujący połączenia między kamieniami. W ten sposób powierzchnia zostaje podzielona na nieregularne komórki (Rysunek 3-10). Drugi etap polega na nałożeniu tekstury kamienia, wygenerowanej przy pomocy fraktalnej turbulencji. Dla każdej komórki parametry tekstury (kolor, stopień szczegółowości) nieznacznie się różnią, w ten sposób obraz nabiera większego realizmu (Rysunek 3-11).

Rysunek 3-10 K. Miyata – połączenia między kamieniami muru

Rysunek 3-11 K.Miyata tekstura muru

Rozwiązanie Miyaty posiada cztery podstawowe wady: • Tekstura jest zdefiniowana na powierzchni, więc jest narażona na zniekształcenia związane z przekształceniami do dwuwymiarowej przestrzeni parametrów tekstury st. • Nie jest możliwa poprawna wizualizacja styku oddzielnych powierzchni (dla których odwzorowanie w przestrzeń s,t jest zdefiniowane oddzielnie). Jest to widoczne na Rysunek 3-12 na rogu budynku – „kamienie” na sąsiednich ścianach są od siebie niezależne, gdy tymczasem po obu stronach powinny być widoczne części tych samych kamieni. • Dwuetapowy sposób generacji tekstury wymaga znacznego nakładu obliczeń przed rozpoczęciem renderingu.

22

Generacja struktury połączeń odbywa się w sposób explicite, więc dla ustalonej wielkości i szczegółowości muru. Miyata nie przedstawia innych zastosowań tej techniki, więc jej uniwersalność nie jest duża.

Rysunek 3-12 K. Miyata – Edo Castle. Zastosowanie techniki generowania powierzchniowej tekstury muru.

3.2.3. Wzory na skórze ssaków Reaction - Diffusion
Reaction–Diffusion to proces, opisany po raz pierwszy przez Alana Turinga (1952), w którym dwa lub więcej związków chemicznych (zwanych morfogenami, ang. morphogenes) rozpraszają się na powierzchni i reagują ze sobą produkując stabilne wzory. Dyfuzja i reakcje są opisane za pomocą układu nieliniowych równań różniczkowych cząstkowych. W systemie Reaction–Diffusion muszą zawsze występować przynajmniej dwa morfogeny, różniące się prędkościami dyfuzji. Jedna z tych substancji musi być ponadto zdolna do zwiększania szybkości produkcji. Pozostałe substancje pomagają lub usiłują zahamować ten proces. Reaction–Diffusion może generować różnorodne wzory złożone z plam lub pasów, przypominające te spotykane na skórze ssaków (koty, zebry). Biologowie są zdania, że część wzorów spotykanych w naturze może być właśnie wynikiem procesów symulowanych za pomocą Reaction–Diffusion, jednak nie zostało to dotychczas udowodnione. Jako pierwszy zaimplementował Reaction–Diffusion Greg Turk [Turk 1991]. Jego metoda umożliwia tworzenie wzoru bezpośrednio na modelu geometrycznym. Przebiega ona w kilku fazach: 1. Powierzchnia modelu dzielona jest na komórki o zbliżonych polach

23

Wzory reaction – diffusion na obiektach 24 . Rysunek 3-14 G. 3. Pewne komórki zostają „zablokowane” (tzn. Turk. Po zakończeniu symulacji i uzyskaniu stabilnych zawartości morfogenów.2. rybach) stosując szereg systemów. Turk wprowadził możliwość generacji także bardziej skomplikowanych wzorów (np. wzór rozetkowy leoparda. koncentracja jednego z nich decyduje o zabarwieniu komórki. Systemy Reaction–Diffusion produkują z reguły bardzo proste wzory (Rysunek 3-13. Przykłady wzorów powstałych w ten sposób widoczne są na Rysunek 3-13 (dolny rząd). Turk. który występuje w mniejszym stężeniu). Wzory wyprodukowane za pomocą nakładania kilku systemów reaction – diffusion. zawartość związków chemicznych w nich nie może się już zmieniać) i przeprowadzana jest kolejna symulacja. Rysunek 3-13 G. górny rząd). Teraz znowu pewne komórki mogą zostać zablokowane i proces może być powtarzany. Końcowy kolor w każdym punkcie jest kolorem średnim sąsiadujących komórek. W trakcie symulacji zawartości substancji w komórkach zmieniają się zgodnie z zasadami dyfuzji (przechodzenie związków do komórek zawierających mniejsze ich stężenia) oraz reakcji (na przykład wysoka zawartość pewnego związku chemicznego może spowodować zniszczenie związku. Każdej komórce przypisywana jest początkowa zawartość morfogenów i przeprowadzana jest symulacja Reaction–Diffusion. która wprowadza dodatkowe szczegóły. wzory na wężach. Pierwszy system tworzy wzór wyjściowy. siatka na żyrafie.

aby otrzymać wzór jakiegoś konkretnego zwierzęcia. Ich wpływ na wynikowy wzór jest trudny do przewidzenia.Problemem związanym z systemami Reaction–Diffusion ograniczającym ich szerokie zastosowanie jest duża ilość parametrów. że efekty są zaskakująco dobre dla zwierząt należących do rodziny kotów. ang. skóra naturalna wzór wygenerowany jaguar 25 . Podane przez autorów wyniki numerycznych porównań wzorów wygenerowanych z naturalnymi pokazują 7% błąd. Początkowo model pokrywany jest komórkami 2. Złożoność obliczeniowa zależy od ilości komórek na których przeprowadzana jest symulacja. którym przypisane są ciemniejsze kolory mają większą prędkość reprodukcji niż te jaśniejsze 4. Komórki mogą zmieniać swój rodzaj (kolor). zebry i żyrafy). oraz dla żyraf (Rysunek 3-15). Nie istnieje też jeden model Reaction–Diffusion pozwalający na uzyskanie wszystkich wzorów. aby każda mogła zająć taką samą powierzchnię. że w ten sposób można wygenerować dużą liczbę wzorów zwierzęcych stosując niewielką liczbę parametrów. W Reaction–Diffusion kolor jest kontrolowany za pomocą związków chemicznych. Z kolei dopiero połączenie obydwu modeli pozwala na stworzenie wzoru skóry żyrafy. Nowo podzielone komórki rozszerzają się tak. w Cell Division wzory odzwierciedlają sposób ułożenia komórek. Do produkcji cętków jaguara i leoparda (tzw. Parametry te są jednak mało intuicyjne – podobnie jak w przypadku Reaction-Diffusion trudno je dobrać tak. Jest to następny model inspirowany obserwacjami biologicznymi. w którym używa 2 parametrów do produkcji wzorów większości zwierząt z rodziny kotów. Do generacji wzorów przypominających cętki stosowany jest przez Turka inny model niż do generacji pasków zebry. rozety. Ten model został stworzony do generacji powtarzających się cętkowanych wzorów występujących w przypadku kilku gatunków ssaków (duże koty. Trzeba przyznać. Reaction–Diffusion są także bardzo wymagające obliczeniowo. jak poprzednio Atrakcyjność tego podejścia polega na tym. Oto założenia algorytmu: 1. Jest to duża zaleta w porównaniu z Reaction-Diffusion. Komórki. Uzyskanie pożądanego wzoru nie jest dzięki temu zadaniem trywialnym. Walter w swoim referacie opisuje system. Komórki różnią się liczbą pochodnych lub szybkością reprodukcji 3. Kolory włosów są rezultatem różnych typów komórek. 5. Cell Division Walter zaproponował model Cell Division [Walter 1998]. Ilość zmian może być ograniczona. a składa się na nią głównie symulacja numeryczna układu równań różniczkowych cząstkowych (w rozwiązaniu Turka dodatkowe koszty wnoszą podział powierzchni na komórki oraz obliczanie wynikowego koloru z przyległych komórek). rosette) Walter używa dodatkowych 5 parametrów. a co za tym idzie przydatność samej metody maleje.

Przykładowe tekstury autorów generowane były na wysokiej wydajności wieloprocesorowych maszynach. ale wprowadza dodatkowe koszty obliczeniowe (podział geometrii na komórki). Model mechaniczno-chemiczny wyjaśnia powstawanie wzorów siłami działającymi na komórki. Zarówno Reaction-Diffusion. Walter.2. w którym przeprowadzany jest rendering. Implementacja opisana przez Waltera i Fourniera w [Walter 1998] ogranicza się do produkcji kwadratowych tekstur powierzchniowych. To oczywiście podwyższa jakość wyników. która daje możliwości generacji dosyć szerokiego zakresu tekstur. Wynikający stąd sposób działania algorytmów praktycznie dyskwalifikuje je w naszych zastosowaniach. Zarówno Reaction-Diffusion. ewoluując wzór przed rozpoczęciem renderingu. Wprowadza także dodatkowe wymagania co do systemu. 26 . Autor wykorzystał ją do symulacji nieregularnych powierzchni przypominających płyty. Komórkowe funkcje bazowe tekstur (cellular texture basis function) Worley zaproponował realizację komórkowej funkcji bazowej.gepard (wzór rozetkowy) żyrafa Rysunek 3-15 M. Turk w swojej implementacji Reaction-Diffusion unika rzutowania płaskiego obrazu na model przeprowadzając proces ewolucji tekstury na samej geometrii.4. lodu. zmiętego papieru. jak i Cell Division są bardzo wymagające obliczeniowo. które są uważane za zgodne z naturalnymi (a przynajmniej za prawdopodobnie zgodne). Wszystkie wspomniane metody generowania wzorów na skórze ssaków używają podstaw. Renderer musi być bowiem zdolny do dostarczenia geometrii teksturowanego modelu. Tekstury wygenerowane metodą Cell Division i ich naturalne odpowiedniki. skóry. powierzchni pokrytych górami i kraterami. 3. skał. Wzory ssaków są także generowane za pomocą automatów komórkowych. Rysunek 3-16 pokazuje przykład wykorzystania komórkowej funkcji bazowej do generacji tekstury przypominającej kamienny mur. Cell Division jak i pozostałe metody działają w sposób explicite. Podsumowanie Istnieje jeszcze wiele modeli tłumaczących powstawanie wzorów na skórach zwierząt.

Rysunek 3-16 S. vo( p) = {x ∈ R d | dist ( x. p ) ≤ dist ( x. jest zdefiniowany jako zbiór punktów w R d . Worley – Przykład wykorzystania komórkowej funkcji bazowej Funkcja nie posiada wad rozwiązania Miyaty. p ∈ S . Działanie funkcji jest oparte na podziale przestrzeni według diagramu Voronoi. Podział przestrzeni na kostki służy dalej optymalizacji poszukiwań n najbliższych punktów. zwany komórką Voronoi. Jest także wydajna i stosunkowo nieskomplikowana. które są od p w odległości mniejszej niż każdy inny punkt należący do S [Fukuda 2000]. Mając dany zbiór S n punktów przestrzeni R d . q)∀q ∈ S − p} Rysunek 3-17 przedstawia przykładowy diagram Voronoi w przestrzeni R 2 . diagram Voronoi jest podziałem przestrzeni R d na n wielościennych obszarów vo( p). • W każdej kostce umieszczana jest w losowych pozycjach pewna ilość punktów (ilość punktów jest obliczana na podstawie prawdopodobieństwa o rozkładzie 27 . Każdy obszar vo( p) . Rysunek 3-17 Diagram Voronoi Sposób działania funkcji komórkowej Worleya dla R 3 : • Przestrzeń dzielona jest na kostki. to znaczy nie wymaga długiej fazy obliczeń wstępnych i nie przeprowadza obliczeń w sposób explicite.

Funkcja wynikająca z definicji diagramu Voronoi poszukuje pierwszego najbliższego punktu używając metryki Euklidesowej. Fn podającą n-ty najbliższy punkt. Metoda Worleya doczekała się wielu implementacji (np. Kukla i Edwarda J. naskórka ludzkiego. 28 . Rysunek 3-18 S.• Poissona. łatwo składane z innymi funkcjami (np.in. np. albo też wyjście funkcji komórkowych może być wykorzystywane przez inne funkcje teksturujące) oraz nakładane warstwami. oraz kombinacje liniowe różnych funkcji Fn . Wyniki niektórych ich prac znajdują się na Rysunek 3-19. j. [Legakis]). liczba losowa jest otrzymywana na podstawie współrzędnych kostki (i. podobnie jak szum Perlina. Można też wyobrazić sobie zastosowanie innych niż według diagramu Voronoi. kierunek do niego itp. Przekształcili oni oryginalne funkcje dzielące przestrzeń uzyskując bardzo dobre wyniki symulacji m. Autor podaje przykłady zastosowania innych funkcji. Sposób generacji tekstur komórkowych Worleya został zaadoptowany przez Jamesa M. Przykłady tych eksperymentów znajdują się na Rysunek 3-18. Zbiór wszystkich wylosowanych punktów to S Obliczanie wartości funkcji dla punktu X: o Obliczanych jest n punktów należących do S leżących najbliżej X o W zależności od potrzeb zwracany jest identyfikator n-tego najbliższego punktu. Bedwell ([Kukla]) do produkcji realistycznych wzorów skóry. Worley eksperymentuje z różnymi funkcjami oceniającymi odległość punktu X od punktów należących do S . k)). Worley . Mogą być. podziałów przestrzeni.Przykłady tekstur uzyskanych dzięki zastosowaniu różnych kombinacji liniowych funkcji Fn Funkcje bazowe Worleya dają możliwość łatwej rozbudowy. położenie punktów należących do S może być kontrolowane za pomocą innych funkcji teksturujących.

Sam nie jest jednak wystarczający. ale nie podają żadnych konkretnych rezultatów.2. Architektura biblioteki jest bardzo prosta – system dostarcza współrzędnych punktu. jednak większość z nich to produkty komercyjne.Rysunek 3-19 J. a na jego podstawie obliczany zostaje kolor wynikowy. Kukla . ponieważ nie jest w stanie produkować większości wzorów komórkowych. aczkolwiek biblioteka może być rozbudowywana. Przykłady podane przez autora oraz inne. Dostępne komercyjnie biblioteki do tworzenia wzorów proceduralnych Istnieje szereg bibliotek produkujących tekstury proceduralne. które używają podstaw fizycznych są w stanie tworzyć ograniczoną liczbę wzorów. Pozostałe sposoby generacji tekstur. metoda Miyaty oraz tekstury komórkowe Worleya nie tłumaczą podstaw powstawania żadnych zjawisk. LIBTEX LIBTEX [Walter 1992] to niezależny od aplikacji zbiór funkcji umożliwiających zastosowanie technik teksturowania w systemach do renderingu. Zakres obsługiwanych efektów jest bardzo mały (istnieją 3 rodzaje tekstur przestrzennych). Reaction-diffusion oraz Cell Division osiągają bardzo dobre wyniki w symulacji skóry zwierząt. itp. Autorzy mówią o innych potencjalnych zastosowaniach. 29 . Techniki mało wydajnej i również nie spełniającej oczekiwań stawianych przed tworzonym systemem.). Przede wszystkim zaś te algorytmy działają w sposób explicite i są mało wydajne. 3. który jest aktualnie cieniowany. zastosowanie cache. czyli szum Perlina. których jedynymi wspólnymi cechami są właściwości wizualne – podział przestrzeni na komórki.3. Sposób ewaluacji tekstur przestrzennych pokazuje Diagram 3-1. Szum Perlina będzie wykorzystywany na pewno jako funkcja składana z innymi.Tekstury skóry. Poniżej przedstawiam dwie wybrane implementacje: LIBTEX oraz PixelLoom. bo posiadające najszersze możliwości zastosowania i rozbudowy wydają się funkcje Worleya. Funkcje te są stosunkowo wydajne i łatwo poddają się optymalizacji (przez obliczanie pewnych wartości przed rozpoczęciem renderingu. które bazują na tym sposobie podziału przestrzeni udowadniają. Najbardziej obiecujące. że lista możliwych do uzyskania efektów jest długa. Podsumowanie Z reguły te metody generacji. 3.5. Miyata pokazuje jednak bardzo ograniczone zastosowanie swojej techniki. Nam chodzi o symulację szerokiego kręgu zjawisk fizycznych.

Nie posiada możliwości antialiasingu tekstur. Rysunek 3-20 Obraz wygenerowany przy pomocy biblioteki PixelLoom 30 . biblioteka. LIBTEX przeprowadza próbkowanie punktowe. co prawda. PixelLoom To najbardziej interesująca. jednak ta operacja oraz teksturowanie 2D nie wykorzystują technik proceduralnych. odwzorowanie nierówności powierzchni. gdzie korzysta z wartości normalnej do cieniowanej powierzchni. a jedynie tradycyjne tekstury w postaci obrazów 2D lub map nierówności.Diagram 3-1 LIBTEX – ewaluacja tekstur przestrzennych W przypadku tekstur proceduralnych LIBTEX nie korzysta z żadnych dodatkowych informacji o kontekście cieniowania. Biblioteka przeprowadza też. bo posiadająca największe możliwości. Rysunek 3-20 przedstawia obraz wygenerowany przy użyciu tekstur proceduralnych wchodzących w skład biblioteki. dlatego nie ma na temat jej architektury ani sposobu działania wielu informacji. Jest ona jednak produktem komercyjnym.

Przykładami są • IFW Procedural Textures (http://www. Miała się pod postacią TextureGenerator ukazać jako moduł rozszerzenia do 3D Studio MAX.org) .renderman. Nie wiadomo jednak jakimi możliwościami integracji z systemami do renderingu dysponuje.org)– duży zbiór tekstur dla LightWave/Inspire • Shades project (http://amber. CorelTEXTURE generuje jedynie płaskie tekstury. Jednym z nich jest CorelTEXTURE.arizona.shaders.zbiór procedur teksturujących pisanych w języku Shading Language 31 .rc. CorelTEXTURE umożliwia tworzenie tekstur za pomocą techniki nakładania kolejnych warstw. Lightwave i SoftImage. Z interesującej nas grupy zjawisk można tam znaleźć algorytm ‘Komórki’ generujący wiele rodzajów prostych tekstur komórkowych.edu/lw/shades/) – zbiór tekstur dla LightWave. Każda z warstw jest generowana przez jeden z wbudowanych algorytmów. papier chropowaty kamień kamienie wzór abstrakcyjny Rysunek 3-21 Przykłady tekstur komórkowych wygenerowanych za pomocą CorelTEXTURE Podsumowanie Większość bibliotek tekstur jest zorientowana na konkretny system do renderingu.PixelLoom jest biblioteką służącą jako baza do budowy aplikacji generujących tekstury fotorealistyczne. Rysunek 3-21 przedstawia przykłady możliwych do uzyskania efektów. głównie konwertowane z shaderów RenderMan • RenderMan Repository (http://www. PixelLoom jest wykorzystywany przez kilka programów do generacji płaskich tekstur.

Wynika to z różnic między interfejsami proceduralnymi, które występują między systemami. Użycie biblioteki z każdym nowym systemem wymaga stworzenia interfejsu pośredniczącego adaptującego bibliotekę do konkretnego systemu. Pociąga to za sobą dodatkową komplikację algorytmów i może pociągnąć spadek wydajności.

32

4. Metody i techniki wykorzystane w pracy
Rozdział ten opisuje sposób generacji tekstur proceduralnych, jakiego użyto w trakcie badań. Definiuje pojęcie funkcji bazowej, metody ich składania oraz konkretne algorytmy i implementacje funkcji używanych dalej do produkcji ciekawych wzorów proceduralnych. W szczególności omawiane są metody oparte na definicji szumu wg. Perlina, podziale przestrzeni wg. diagramu Voronoi oraz ich proponowane rozszerzenia do wersji fraktalnych i wykorzystujących różne metryki.

4.1. Funkcja teksturująca jako złożenie funkcji bazowych
Funkcja teksturująca wyznacza pewne atrybuty cieniowanej powierzchni. Jako wejście otrzymuje parametry kontekstu wejściowego, a obliczone atrybuty umieszcza w kontekście wyjściowym. W przypadku biblioteki TexLib jest ona zbiorem tzw. funkcji bazowych tworzących pewien algorytm cieniujący. Można więc powiedzieć, że system generacji tekstur opisany w tej pracy umożliwia tworzenie wzorów za pomocą składania pewnych funkcji bazowych. Funkcje bazowe mogą implementować algorytmy o różnym poziomie złożoności, od prostych funkcji często używanych w grafice komputerowej, jak sin(x), fmod(a, x), po bardziej skomplikowane funkcje szumu Perlina i inne wielowymiarowe (posiadające większą liczbę parametrów) i mające wiele wyjść (parametrów wyjściowych). Funkcja bazowa jest określona pewnymi parametrami wejściowymi oraz produktami w postaci wyjść. Każde z wejść oraz wyjść funkcji bazowej posiada swój identyfikator, typ oraz wartość domyślną. Na przykład, specyfikacja funkcji Checker jest przedstawiona w Tabela 4-1. Dalej, w opisach konkretnych algorytmów, specyfikacja służy prezentacji podstawowych właściwości danej funkcji i może być wykorzystywana jako szybkie przypomnienie efektów działania i sposobu jej wykorzystania.
Checker

Funkcja przypisująca punktowi P jeden z dwóch podanych kolorów. Tworzy wzór trójwymiarowej szachownicy.

identyfikator parametru
P scale white black color

typ Point Vector Color Color Color

wartość domyślna (0, 0, 0)

opis

WEJŚCIA punkt w przestrzeni, dla którego obliczyć kolor skala wzoru (wartości > 1 powoduję zmniejszenie wzoru, (1, 1, 1) wartości <1 jest powiększenie) (1, 1, 1) kolor pól parzystych (0, 0, 0) kolor pól nieparzystych WYJŚCIA kolor dla podanego punktu P
Tabela 4-1 Specyfikacja funkcji Checker

33

Składanie funkcji bazowych odbywa się przy zastosowaniu pewnych reguł: 1. Każdemu z wejść można przypisać wyjście innej funkcji bazowej jeśli jest ono tego samego typu. Niech będą dane funkcje bazowe F i G takie, że
(o1, o2, ..., on) = F(p1, p2, ..., pn) o = G(pg1, pg2, ..., pgn), p1, p2, ..., pn – parametry wejściowe, o, o1, o2, ..., on – wyjścia – wartości produkowane przez funkcję

gdzie:

Wtedy przypisanie wyjścia funkcji G i-temu wejściu funkcji F można zinterpretować jako złożenie funkcji w którym uzyskujemy następującą postać funkcji F:
(o1, o2, ..., on) = F(p1,...,p(i-1), G(pg1, pg2, ..., pgn), ...,pn)

Na przykład, niech Checker będzie określona jako
checker(P, scale, white, black)

Wtedy wyjście górnej funkcji Checker na Rysunek 4-1 A można zapisać
checker1( P1, scale1, checker2(P2, scale2, white2, black2), checker3(P3, scale3, white3, black3) ),

przy czym white3 i black3 mogą być produktami jakichś innych funkcji bazowych, natomiast white2 i black2 są wartościami domyślnymi. 2. Wejście bez przyporządkowanego wyjścia innej funkcji bazowej ma wartość stałą równą jego wartości domyślnej. 3. Po trzecie, jeśli przyjmiemy, że funkcje bazowe to zbiór węzłów V grafu G=(V, E), a połączenia parametrów wejściowych z wyjściowymi są zbiorem jego krawędzi E, przy czym połączenie z dowolnym wejściem lub wyjściem funkcji bazowej f jest traktowane jak połączeniem z tą funkcją to G musi być grafem zorientowanym, acyklicznym. Poprawne jest zatem połączenie na rysunku Rysunek 4-1 A, natomiast przypadek B jest niepoprawny i niemożliwy do obliczenia ze względu na cykl prosty.

A Poprawny graf połączeń między funkcjami

B Błędny graf połączeń między funkcjami (cykl zaznaczony na czerwono)

Rysunek 4-1 Przykłady połączeń między funkcjami bazowymi

Każde wejście i wyjście może być opisane jednym ze zdefiniowanych typów. Tabela 4-2 zawiera opisy wszystkich dostępnych typów.

34

Konkretne zmienne stanu kontekstu cieniowania biblioteki TexLib zostały ustalone na podstawie kilku systemów do grafiki fotorealistycznej. bump mapping) w systemach. tablica 3 wartości typu Float (r.5.3. Jest używana do odwzorowania nierówności powierzchni (ang. Uwaga: Funkcja wymusza obliczenie wartości height_func kilkukrotnie. Funkcje OutContext i InContext są nazywane abstrakcyjnymi.1. 4. Maksymalny zestaw parametrów powierzchni możliwych do modyfikacji jest określony i zaimplementowany w abstrakcyjnej funkcji bazowej o nazwie OutContext jako jej wejścia. Nie jest także możliwe ich dodawanie do drzewa cieniowania – zakłada się. Drzewo cieniowania może modyfikować jeden lub wiele z parametrów cieniowanej powierzchni. 4. Odwzorowanie nierówności powierzchni Specjalną funkcją jest funkcja CalculateNormal modyfikująca (zakłócająca) wektor normalny do płaszczyzny mając daną funkcję wysokości.. b leżą w przedziale [0. Opis zaimplementowanych algorytmów Poniżej opisane są zaimplementowane algorytmy oraz odpowiadające im w bibliotece funkcje bazowe używane dalej do produkcji wzorów proceduralnych. Potrzebne do ewaluacji drzewa parametry (kontekst cieniowania dla każdej obliczanej przez system renderujący próbki obrazu) mogą być pobierane z wyjść abstrakcyjnej funkcji InContext. g. przez to wszystkie wzory połączone w drzewie cieniowania pod wykorzystujący je parametr height_func będą ewaluowane kilka razy dla różnych wartości punktu P.nazwa typu Int Float Point Vector Color ColorArray FloatArray charakterystyka wartość całkowita wartość zmiennoprzecinkowa współrzędne punktu. przy czym r. tablica 3 wartości typu Float wektor.3.5. że w drzewie istnieją zawsze pojedyncze instancje tych funkcji (tzn. puste drzewo cieniowania zawiera konteksty). Tabela 4-3 prezentuje specyfikację tej funkcji. CalculateNormal Funkcja obliczająca zmodyfikowany wektor normalny do płaszczyny mająca daną funkcję wysokości. 35 .1] tablica wartości typu Color tablica wartości typu Float Tabela 4-2 Typy parametrów wejściowych/wyjściowych funkcji bazowych 4. tablica 3 wartości typu Float kolor RGB. To. która z kolei pobiera je z systemu do renderingu. g. Opisy zawierają także szczegóły implementacyjne oraz metody usprawnienia i antialiasingu. Drzewa cieniowania Grafy określone w poprzednim punkcie stanowią drzewa cieniowania. jakie parametry mogą być zmienianie. które nie udostępniają rzeczywistego zniekształcania powierzchni.2. jest w pewnym stopniu uzależnione od konkretnego systemu renderującego. b). ponieważ są interpretowane przez konkretny system do renderingu. Część systemów do renderingu może nie udostępniać możliwości modyfikacji wszystkich określonych tam parametrów. Dokładny ich opis można znaleźć w punkcie 5.

). Im większa tym bardziej odchylane 0. WYJŚCIA Nowy wektor normalny do płaszczyzny Tabela 4-3 Specyfikacja funkcji bazowej CalculateNormal Obliczenie normalnej opiera się na geometrii przedstawionej na Rysunek 4-2. punkt w przestrzeni.. dla którego obliczyć kolor normalna do płaszczyzny w punkcie cieniowania funkcja wysokości N Amplituda nierówności. 0. dPdv – pochodne punktu w kierunkach osi parametrów u. wektory U oraz V są obliczane jako ∂height _ func ∂P (N × ) U = ∂u ∂v ∂height _ func ∂P V = (N × ) ∂v ∂u Wektor U leży więc w tej samej płaszczyźnie co dPdu. 0. V U D N N’ DPdv DPdu Rysunek 4-2 Geometria odwzorowania nierówności powierzchni Na rysunku: N – normalna do płaszczyzny N’ – zmodyfikowana normalna dPdu. Wektor V leży w płaszczyźnie dPdv i ma długość równą zmianie height_func w kierunku v. Uwaga: System wykorzystujący bibliotekę musi poprawnie wypełnić strukturę sample. Suma tych dwóch wektorów daje odchylenie D.. 36 . v płaszczyzny Mając daną funkcję wysokości height_func.1 są normalne – tym wyraźniejsze nierówności na płaszczyźnie.identyfikator parametru typ wartość domyślna opis sample P N height_fu nc amp_scale Sample Point Vector Float Float Vector (0. Nie wszystkie systemy udostępniają potrzebne informacje. 1) 0 WEJŚCIA Parametry cieniowanego punktu (opis patrz punkt. a jego długość jest równa zmianie height_func w kierunku wektora u. Nowa wartość N’ = N+D. 0) (0.

(i.2. j )) I ( i +1. że i jest największą liczbą całkowitą mniejszą od x. Szum Perlina Algorytm W punkcie 3. g y ) . gdzie i. Aby zbadać wartości Do renderingu obrazka widocznego w metryce funkcji użyto realistycznego modelu oświetlenia. Ważne jest przy tym. Szum tak powstały nie zachowuje własności niezmienniczości i podczas obrotów widoczne są pewne artefakty. j jest największą liczbą całkowitą mniejszą od y. dobra funkcja generująca szum to taka. Dodatkowo. wybieramy takie współrzędne dyskretne w siatce (i. aby każdy kierunek był jednakowo prawdopodobny. y ) − (i + 1. y). j). y ) − (i + 1. oraz punktach P + u * ε i P + v * ε . j +1) * (( x. lecz w każdym jej węźle losowany jest wektor kierunku. która zachowuje statystyczną niezmienniczość przy obrotach i przesunięciach. dla której szukamy wartości szumu interpolujemy dostając skalarną wartość szumu. y) leży w komórce ograniczonej punktami (i+1. Wartości w węzłach najbliższym pewnej ciągłej wartości. że funkcja wygląda podobnie niezależnie od tego jak ją obrócimy i przesuniemy. j )) I ( i . gradient noise). j + 1)) 37 . ograniczenie wartości oraz ograniczenie częstotliwości (maksymalna częstotliwość jest równa 1). j+1). Metoda gradientowa także stosuje dyskretną siatkę. j). j +1) * (( x.1 zostały przedstawione główne własności szumu Perlina. Nie jest tak w przypadku najprostszej i najbardziej intuicyjnej metody. y ) − (i. j ) = G( i +1. j+1). j ) = ( g x . Oznacza to. j ) * (( x. Wpływ każdego z wektorów gradientu (wektory G na Rysunek 4-4) obliczamy jako iloczyn skalarny odpowiedniego wektora G oraz wektora od punktu (x. j). W ten sposób (x. będę się dalej posługiwał przykładem 2-wymiarowego szumu) ustalamy więc funkcję dającą w wyniku wektor 2-wymiarowy: g (i. Rysunek 4-3 Pseudo model oświetlenia 4. Rysunek 4-3 jest przykładem takiego zastosowania funkcji CalculateNormal. (i. Implementacja szumu wykorzystana w bibliotece jest oparta na technice szumu gradientowego (ang.3. j +1) = G( i .2. j ) = G(i . Dostajemy w ten sposób 4 wartości skalarne I: I ( i . (i+1. w której stosujemy dyskretną siatkę n-wymiarową (zależnie od tego w jakiej przestrzeni powstaje tekstura) z losowymi skalarnymi wartościami w każdym węźle. Dla 2-wymiarowej siatki (dla ustalenia uwagi. y ) − (i. y) do węzła siatki (wektory V na rysunku). Ciekawostką jest. czyli powtarzalność.∂height _ func ∂height _ func oraz funkcja oblicza wartości height_func ∂u ∂v w punkcie P. j +1) = G( i +1. że można osiągnąć interesujące efekty pseudo-oświetlenia traktując kierunek normalnej jako kolor. j ) * (( x. j + 1)) I ( i +1. który zachowuje wszystkie te własności. j – dyskretne współrzędne siatki Licząc wartość szumu dla punktu (x.

(i. Jak widać.j+1) (i+1. j ) ) b = I ( i . y) od poszczególnych węzłów siatki.5 1 X Rysunek 4-5 Wykres funkcji smoothstep(x) 38 . jednak w praktyce znacznie lepsze wyniki daje nieliniowa zależność wag S od odległości od węzłów siatki. j+ 1) V(i (i. oraz Sy – waga dla wymiaru y. Zastosowano tutaj funkcję smoothstep( x) = 3x 2 − 2 x3 . y) .j) +1 . smoothstep jest przedstawiona na wykresie Rysunek 4-5. j +1) ) noise( x. oznaczonych dalej jako Sx – waga dla wymiaru x. Smoothstep(x) 1 0. 1) (i+1. natomiast parametry z przedziału środkowego są „rozciągane”. Sy = y-j. j) j) . j ) + S x ( I ( i +1. j+ V(i i . j) G(i. j +1) − I (i . j +1) + S x ( I (i +1.5 0 0. j) G(i+1. j ) − I ( i . j+1) Rysunek 4-4 Obliczanie szumu Perlina 2D metodą gradientową a = I (i .j) V( V( i+1 (x. y ) = a + S y (b − a) Narzuca się tutaj obliczenie Sx = x-i. j+1) G(i+1.Wartości te interpolujemy z wagami zależnymi od odległości punktu (x. często używaną w grafice komputerowej jako funkcja wygładzająca. funkcja szybko zmierza do wartości krańcowych dla parametrów bliskich 0 i 1. j+1) G(i.

Są one wirtualne i abstrakcyjne i mają następujące deklaracje: virtual virtual virtual virtual FLOAT FLOAT Point Point Get(FLOAT x) = 0. Szum z i-tej warstwy posiada także di razy mniejszą amplitudę.fraktalny szum B . Zarówno szum Perlina jak i opisane dalej inne rodzaje szumów są zdefiniowane w klasach pochodnych CNoise (CNoisePerlin itp. Turbulencje uzyskuje się sumując wartości absolutne funkcji noise. Dodatkowo istnieje specjalna klasa pochodna CNoise o nazwie CNoiseFractal implementująca algorytm uzyskiwania szumu fraktalnego. Dodawanie szumu w celu uzyskania szumu i turbulencji fraktalnych zachodzi więc w następujący sposób: octaves noise(d i P) fractal ( P. która definiuje zachowanie szumu. octaves. Zwykle d=2. Get(Point &p) = 0. albo nawet CNoiseFractal) oraz następującymi wartościami: 39 . turbulencji. d ) = octaves ∑ i =0 abs ( noise(d i P) ) di Implementacja W bibliotece została zaimplementowana abstrakcyjna klasa CNoise. Get3D(FLOAT x) = 0. d ) = ∑ di i =0 turbulence( P. A . Przykładowe obrazy są widoczne na Rysunek 4-6. klasy CNoisePerlin. Dodając do siebie wartości noise o różnych częstotliwościach uzyskujemy ciekawe efekty fraktalnego szumu bądź tzw.fraktalna turbulencja Rysunek 4-6 Przykłady szumu fraktalnego Kolejne warstwy szumu posiadają częstotliwość d razy większą. a więc i-ta warstwa ma częstotliwość 2i. octaves. Posiada ona między innymi funkcje pobierające jednowymiarowe i trójwymiarowe wartości szumu dla punktu w przestrzeni R1 i R3. Get3D(Point &p) = 0.). Klasa ta jest sparametryzowana instancją klasy pochodnej CNoise (np.Tak obliczona funkcja noise może łatwo być wykorzystana do generacji wzorów fraktalnych.

Obrazek widoczny obok powstał przez wizualizację trójwymiarowych wartości szumu jako kolorów.Typ int Nazwa fractal Opis int float octaves persistence 0 – szum 1 – szum fraktalny 2 – turbulencja fraktalna Określa maksymalną liczbę warstw szumu Określa częstotliwość każdej następnej warstwy i jest odpowiednikiem 1/d w opisywanym algorytmie Funkcja bazowa Funkcja bazowa NoisePerlin. otrzymywane wartości końcowe nie będą się prawdopodobnie mieściły w zadanym przedziale. jakie parametry wyjściowe są wykorzystywane. bądź turbulencję fraktalną. 1 – szum fraktalny. Standardowo szum zwraca wartości z przedziału [-1.duży. 0) 0 3 Tabela 4-4 Specyfikacja funkcji bazowej NoisePerlin 4.3. dla danego punktu P zwraca wartości jedno lub trójwymiarowe. Potrafi także obliczać szum fraktalny. który stosuje ten podział przestrzeni. natomiast amplituda a 0. że jeśli liczony jest szum fraktalny. identyfikator parametru P fractal octaves typ wartość domyślna opis point int int persisten ce float min. Zależnie od tego..5 ai+1 = ai*persistence Wartości mniejsze powodują mały wpływ dalszych oktaw szumu. która wykorzystuje opisane zaimplementowane w bibliotece TexLib ma następujące własności: NoisePerlin powyżej algorytmy Produkuje wartości szumu Perlina. 1 Należy zwrócić uwagę na to. wartości większe . 2 – turbulencja fraktalna Maksymalna ilość oktaw (warstw) szumu Częstotliwość oktawy i+1 fi+1 jest równa fi+1= fi * (1/persistence). dla którego obliczyć wartość 0 – szum. Podział przestrzeni według diagramu Voronoi Algorytm Rozdział 3 podaje definicję diagramu Voronoi oraz algorytm Worleya.3. Te parametry pozwalają zmienić tę charakterystykę przez ustalenie wartości minimalnej i maksymalnej. Algorytm zaimplementowany w bibliotece TexLib działa w podobny sposób: 40 . WYJŚCIA jednowymiarowa wartość szumu trójwymiarowa wartość szumu (0. max float float color float color WEJŚCIA Punkt. 0. -1.1].

n) i przechodzących przez ich środki. 41 . j. k) dla n=2 itd. k) i przechodzącej przez punkt M. S(i-1. n)≠(i. k) służą przyspieszeniu wyszukiwania najbliższych punktów. j. algorytmu). z). k) Rysunek 4-7 Wyniki działania funkcji noiseV. (l. odległość |PC| dla n=1.Współrzędne n-tego najbliższego punktu ze zbioru S. k-1. irregularity). Wynikiem wywołania funkcji noiseV działającej w opisany powyżej sposób może być (patrz: Rysunek 4-7): A .. k). odległość |PS(i-1. Przekrój przez przestrzeń R3. Podany algorytm jest realizowany przez funkcję noiseV(P. m. który jest środkiem wektora V. gdzie parametr irregularity jest maksymalną długością wektora odchylającego pierwotne położenia punktów ze zbioru S (patrz. będąca odległością od płaszczyzny prostopadłej do wektora V=C-S(i-1. odległość do najbliższej ściany komórki wynikającej z podziału Voronoi.i+1. Na rysunku np. j+1. k) są przesuwane o pewien losowy wektor o długości z przedziału [0.1]. • dla punktu P(x. j. których współrzędne dyskretne leżą w przedziale (i-1. Na rysunku punkt C dla n=1. punkt 2. Zbiór przekształconych punktów to S.. k) S(i+1.j+1. punkt S(i-1. gdzie: C jest punktem S(i.Najmniejsza odległość do jednej z płaszczyzn prostopadłych do wektorów C-S(l.Odległość do n-tego najbliższego punktu ze zbioru S. współrzędne siatki (i. j. k) są obliczane dla każdego wymiaru jako największe liczby całkowite mniejsze od odpowiedniej współrzędnej (x. k)| dla n=2 itd. y. j. j. najbliższym punktowi P. j. k) m S(i+1. j+1.• • budowana jest 3-wymiarowa siatka współrzędne każdego z węzłów dyskretnej siatki (i. z) • szukanych jest n najbliższych P punktów ze zbioru S. Obliczone współrzędne (i. y. j+1. k) d P M S(i. j. j.k+1). j-1. Najbliższym będzie bowiem któryś z punktów. B . j. Na rysunku jest to odległość d. C .. k)=C m /2 V 37 S(i-1.. k) Innymi słowy. m.

Ilustracja B dobrze ilustruje podział przestrzeni na wg. diagramu Voronoi. Bedwell ([Kukla]) stworzone właśnie przy użyciu liniowych kombinacji funkcji Worleya. Wszystkie funkcje z powyższej tabeli zostały znalezione z użyciem automatycznych funkcji przeszukiwania dziedziny parametrów. Oznaczmy przez noiseVn funkcję zwracającą n-ty najbliższy punkt i posiadającą parametr irregularity = 0. jakie możliwości daje tak zdefiniowana funkcja. Te kilka przykładowych obrazów pokazuje duży potencjał. A – odległość od punktu ze zbioru S B – współrzędne punktu ze zbioru S C – odległość od granicy komórki Rysunek 4-8 Typy wyników zwracanych przez funkcję noiseV. Opisywane w Rozdziale 3 wzory ludzkiej skóry zostały przez Jamesa M.Kolejne ilustracje (Rysunek 4-8) pomogą wyobrazić sobie. jaką dają złożone funkcje biorące jako parametry wartości odległość od n-tego punktu ze zbioru S. Tabela 4-5 pokazuje przykładowe liniowe i nieliniowe kombinacje funkcji tego typu. mur kamienny itp. W połączeniu z wartością odległości od granicy komórki (Ilustracja C) daje to możliwości budowy wzorów typu kamień naturalny.5. 42 . o których będzie mowa później. Należy tutaj zauważyć ciekawą możliwość. który już w swojej podstawowej wersji. Ilustracja A to wynik działania funkcji zwracającej odległość od najbliższego punktu ze zbioru S. Na ilustracjach w tabeli wynik skalarny funkcji F został użyty do interpolacji liniowej między kolorami czarnym i białym. Kukla i Edwarda J. posiada funkcja noiseV. Zwracana wartość skalarna służy jako waga przy liniowej interpolacji między dwoma kolorami.

6*noiseV1 * ( 0. octaves.9*noiseV2 + 0.8*noiseV2 + 2*noiseV3 + 1.7*noiseV4 ) * 1. octaves.9*noiseV3 ) F = ( -0.9*noiseV2 + 1.3*noiseV4 0.6*noiseV1 0. Można ją zastosować wprost w przypadku funkcji noiseV zwracającej wynik typu A – odległość do najbliższego punktu ze zbioru S. Jedna z tych wersji została już przedstawiona przy okazji opisu funkcji szumu Perlina. d .8*noiseV1 – 0.2*noiseV2 0.2*noiseV2 + 0. jeśli wziąć pod uwagę jej fraktalne wersje. d .9*noiseV3 ) Tabela 4-5 Przykłady złożonych funkcji wykorzystujących noiseVn Fraktalny podział przestrzeni według diagramu Voronoi Możliwości funkcji noiseV znacznie się zwiększają.7*noiseV2 F = ( 1.6*noiseV1 0.7*noiseV1 + 1.4*noiseV1 0.6*noiseV3 F = 0. irregularity ) = octaves ∑ i =0 abs( noiseV (d i P.4*noiseV5 F = 0.6*noiseV1 F = 1.7*noiseV1 + 1.8*noiseV2 0. irregularity ) ) di 43 .7*noiseV3 ) * ( 1. irregularity ) = ∑ di i =0 turbulenceV ( P. Tak więc: octaves noiseV (d i P.F = -0.6*noiseV1 0. irregularity ) fractalV ( P.

// dodatkowe.1]. wsp_podziału – współczynnik podziału dla warstwy na której się znajdujemy Algorytm kontrolujący obliczenia związane z tym wzorem wygląda jak na Program 4-1.5.. Warunek podziału wygląda następująco: f < wsp_podziału[warstwa]. //pętla obliczania punktu S repeat { S = noiseV(P). //weź losową liczbę dla punktu S if ( (warstwa < max_ilość_warstw) and //jeśli może być więcej warstw (f < wsp_podziału[warstwa]) ) //warunek podziału { warstwa += 1. na którym zastosowano 3 poziomy funkcji noiseV zwracającej wynik typu B – współrzędne najbliższego punktu ze zbioru S. Na powyższym przykładzie dla obydwu etapów był on równy 0.Drugie podejście do stworzenia fraktalnej funkcji noiseV polega na zastosowaniu podpodziałów już podzielonej przestrzeni. Na ilustracji C niektóre z podzielonych wcześniej komórek uległy kolejnemu podziałowi. gdzie: f – liczba losowa z przedziału [0. } //S – wynik: punkt ze zbioru S najbliższy punktowi P // na ‘warstwa’ warstwie Program 4-1 Algorytm fraktalnego podpodziału przestrzeni 44 . A – podział na 1 poziomie B – podział na 2 poziomach C – podział na 3 poziomach Rysunek 4-9 Ilustracja fraktalnego podpodziału przestrzeni Na ilustracji B niektóre z komórek zostały podzielone funkcją noiseV o dwukrotnie większej częstotliwości.// przechodzimy do kolejnej warstwy P = P * d. Podział komórek na każdym etapie (w każdej iteracji) jest kontrolowany za pomocą współczynników prawdopodobieństwa podziału. niezmienna dla danej komórki (ustalana na podstawie obecnego najbliższego punktu ze zbioru S. opcjonalne przesunięcie dzięki któremu // sąsiednie komórki nie łączą się ze sobą } else break. // zmieniamy częstotliwość (patrz: opis fraktalnego // szumu Perlina) P = P + S. let warstwa = 0. //oblicz najbliższy punkt ze zbioru S f = losowa(S). Efekt takich podpodziałów będzie wyglądał jak na Rysunek 4-9.

7 + turbulenceV3*0.7 + turbulenceV4*0. 0.8 )* ( -turbulenceV1*0.4 + turbulenceV3 ) Tabela 4-6 Przykłady złożonych funkcji wykorzystujących fractalVn i turbulenceVn 45 .5.Ciekawe efekty daje użycie złożonych funkcji.6fractalV3*0. 3. 0.5. Oznaczmy przez fractalVn oraz turbulenceVn funkcję fraktalną używającą fractalV(P. F = ( turbulenceV1*0.9) F = ( -fractalV1*0.7 – turbulenceV2*0.2 – turbulenceV2*0.6 turbulenceV2*0.2 – turbulenceV3*0.4 ) F = ( fractalV1*0.8 + turbulenceV2*0.4 fractalV2*0.5) lub turbulenceV(P.3 ) * ( turbulenceV1*0.2 fractalV2*0.8 ) F = ( turbulenceV1 + turbulenceV2*0. 3. Przykładowe rezultaty tak uzyskanych funkcji znajdują się w Tabela 4-6.8 + turbulenceV3 + turbulenceV*0.7 + turbulenceV4*0. 0.6 – turbulenceV3*0.5) zwracającą n-ty najbliższy punkt. 0.9 ) * (-fractalV1*0.3 fractalV4*0.6 ) * ( turbulenceV1*0. których składowe zwracane są przez funkcje fractalV bądź turbulenceV.

Y ( y1 ......metryka Chebycheva 46 . xn ).. Y ( y1 ... yn )) = Max ( x1 − y1 . Y ) ≤ dist (Y .. Z ) o metryka Manhattan: odległość między dwoma punktami w przestrzeni nwymiarowej jest równa sumie odległości między poszczególnymi wymiarami..... dist ( X ( x1 . czyli zachowujące równanie trójkąta ([Cahn].. x2 − y2 . jedyną różnicą jest wykorzystana metryka): A – metryka Euklidesa B .. Zastosowanie nieeuklidesowych metryk Diagram Voronoi zdefiniowany wg [Fukuda 2000] w Rozdziale 3 wykorzystuje metrykę Euklidesa do stwierdzenia odległości dist od punktów należących do zbioru S dist ( X ( x1 . Nazwa Manhattan pochodzi stąd.. xn ). y2 . że w mieście odległości między 2 punktami nie można zmierzyć prostą.. Z ) + dist ( X . które można tutaj zastosować: metryki Euklidesowe. Y ( y1 . nie są proste do wykorzystania praktycznego polegającego na symulacji dobrze znanych z natury wzorów.Niewątpliwie są to najciekawsze z zaprezentowanych tutaj wzorów. lecz liniami prostopadłymi do siebie. Y ) =     ∑ xi2  ∑ yi2   n  n  Oto przykłady wzorów uzyskanych dzięki tym metrykom (wszystkie wzory zostały uzyskane przy użyciu tego samego drzewa cieniowania. [Duda]). y2 . dist ( X . x2 . jeśli chodzi o parametry. yn )) = ∑ xi − yi n o metryka Chebycheva: odległość między dwoma punktami w przestrzeni nwymiarowej jest równa maksimum z różnic między poszczególnymi wymiarami dist ( X ( x1 . y2 . jednak ze względu na swoją złożoność. yn )) = ∑ (x − y ) i i n 2 • Istnieje jeszcze co najmniej kilka ciekawych metryk. x2 . x2 ..... xn − yn ) • metryki nieeuklidesowe [Fielding] o metryka cosinusowa: cosinus kąta między dwoma wektorami ∑ xi yi n dist ( X . xn ).

Euklidesowa P P Chebycheva Manhattan P C – metryka Manhattan Strefy punktów o równych odległościach od punktu P dla różnych metryk. Wynik 3D to współrzędne tego punktu. wartości większe . Rysunek 4-10 Wpływ zastosowania różnych metryk odległości Funkcje bazowe Zaimplementowane zostały 2 funkcje bazowe wykorzystujące algorytm podziału przestrzeni według diagramu Voronoi. 0) 0 0 3 persisten ce float 0.duży. identyfikator parametru P metrics fractal octaves typ wartość domyślna opis point int int int (0. Wynik skalarny jest dla punktu P odległością od najbliższego punktu ze zbioru S. Wartość ‘border_dist’ jest odległością od ‘granicy’ komórki. Ich metryki zostały przedstawione w Tabela 4-7 i Tabela 4-8. natomiast amplituda a ai+1 = ai*persistence Wartości mniejsze powodują mały wpływ dalszych oktaw szumu. 47 . 2 – turbulencja fraktalna Maksymalna ilość oktaw (warstw) szumu Częstotliwość oktawy i+1 fi+1 jest równa fi+1= fi * (1/persistence). NoiseWorley Produkuje wartości szumu Worleya (wynikającego z podziału przestrzeni według diagramu Voronoi) 1D oraz 3D. dla którego obliczyć wartość Jaką stosować metrykę obliczania odległości: 0 – euklidesowa 1 – Manhattan 2 – Chebycheva 0 – szum. 1 – szum fraktalny. 0.5 WEJŚCIA Punkt.

WYJŚCIA float Float Jednowymiarowa wartość szumu. identyfikator parametru P metrics typ wartość domyślna opis point int (0.. Częstotliwość warstwy i+1 fi+1 jest równa fi+1= fi * (1/persistence).5 wprowadzić do obrazu artefakty.5 WEJŚCIA Punkt. Domyślnie wartość eff y funkcji jest obliczana jako F1. wartości mniejsze od 0 są niedopuszczalne i zamieniane na 0. dla którego obliczyć wartość Jaką stosować metrykę obliczania odległości: 0 – euklidesowa 1 – Manhattan 2 – Chebycheva Współczynniki prawdopodobieństwa przejścia w danej komórce na następny poziom (do następnej warstwy). Poziom podpodziału w danej komórce jest rekurencyjnie kontrolowany za pomocą współczynników określających prawdopodobieństwo przejścia na następny poziom. Wynik 3D to współrzędne tego punktu. irregular ity border_di st Float Odległość do ‘ściany’ komórki Tabela 4-7 Specyfikacja funkcji bazowej NoiseWorley FractalNoiseWorley Produkuje wartości szumu Worleya (wynikającego z podziału przestrzeni według diagramu Voronoi) 1D oraz 3D na losowym poziomie podpodziału. Wartość ‘level’ jest poziomem podziału. Wartości większe od 1 mogą wprowadzić do obrazu artefakty..5] divide_fa FloatArra ctor y persisten ce float 0. Wartości większe od 1 mogą Float 0. natomiast amplituda a ai+1 = ai*persistence Wartości mniejsze powodują pojawienie się małych komórek na następnych warstwach. będąca współrzędnymi punktu środka color Color najbliższej komórki. Trójwymiarowa wartość szumu. Ta wartość powinna zawierać się w przedziale [0.Nieregularność komórek.1]. WYJŚCIA 48 . Ta wartość powinna zawierać się w przedziale [0. 0. Nieregularność komórek. Parametr linear_coeff nie ma znaczenia dla tego parametru wyjściowego. wartości mniejsze od 0 są niedopuszczalne i zamieniane na 0. 0) 0 [0. wartości większe – dużych komórek (dla wartości >1 komórki będą większe od tych na oryginalnej warstwie.1].5 irregular ity Float 0. Wynik skalarny jest dla punktu P odległością od najbliższego punktu ze zbioru S na danym poziomie. Wartości liniowych współczynników przy obliczaniu linear_co FloatArra [1] jednowymiarowej wartości szumu.

. które..1]... w których parametr A będzie kolejno przyjmował wartości 0. który chcemy symulować. ponieważ ilustracje przedstawiane w poprzednim punkcie zostały w większości wygenerowane półautomatycznie. B=1. . W rezultacie dostaniemy 11 obrazów. 1. kn] i rozdzielczości r dostaniemy ((k1-p1)*(k2-p2)* .1. W rzeczywistości. C=0 2:A=0. . Losowe parametry Na podstawie pokazanych przykładów można odnieść wrażenie. Rzeczywiście. [pn. System do budowy drzew cieniowania wykorzystany do badań udostępnia proste metody. że opisane algorytmy produkują jedynie wzory mniej lub bardziej abstrakcyjne.0. C=0 4:A=0. B=1. trudno jest zdecydować. Automatyzacja poszukiwania użytecznych wzorów proceduralnych Ze względu na różnorodność dostępnych algorytmów oraz ich kombinacji. dzięki którym można generować dowolną ilość obrazów. *(kn-pn))/r obrazów. dobierając wcześniej dla interesujących nas parametrów zakresy. Przykładowo. będąca wpółrzędnymi punktu środka najbliższej komórki. 0.. który z nich będzie dawał najlepsze efekty w interesującej nas dziedzinie. C[0.4. [p2. Dla 2 i większej ilości parametrów o zakresach [p1.1. C=1 49 . B[0. gdzie rozpatrzone zostaną wszystkie kombinacje parametrów....1] oraz rozdzielczość r = 1. mając dane następujące parametry i ich zakresy: A[0. Z tego powodu zastosowano kilka metod przyspieszających proces powstawania tekstury proceduralnej. C=1 . tzn. nie mające wiele wspólnego z tymi spotykanymi w naturze. system generuje kolejne obrazy.1] z rozdzielczością 0.. jakie daje konkretny algorytm. Przeszukiwanie domeny parametrów Po wstępnym zapoznaniu się z możliwościami. Nietrudno jednak w zbiorze tak stworzonych obrazów i drzew cieniowania wybrać te. C=1 3:A=0. Po ustaleniu przedziałów oraz rozdzielczości poszukiwania.1. Sposób działania tego mechanizmu jest oczywisty dla 1 parametru. Dalszy dobór parametrów pozostawiamy odpowiednio zawężonemu zakresowi losowych parametrów..2. z których będą losowane ich wartości. B=0. większość parametrów ręcznie zbudowanego drzewa cieniowania została dobrana losowo.. k2]. po kilku dalszych poprawkach. za pomocą metody dobierania losowych parametrów) wybieramy te przypadki. Każda z wartości z wybranego zakresu posiada takie samo prawdopodobieństwo wybrania. gdy staramy się lepiej zrozumieć wpływ jakiegoś wybranego parametru lub kilku parametrów na efekt końcowy. większość uzyskiwanych wzorów nie przypomina niczego spotykanego w rzeczywistości. k1]. będą mogły służyć do symulacji realnych zjawisk. 0. Została ona także wykorzystana do początkowej eksploracji możliwości algorytmów. Niech będzie nim A i niech będzie dany przedział przeszukiwania [0.float color level Float Color Int Jednowymiarowa wartość szumu Trójwymiarowa wartość szumu. powstała dzięki tej metodzie. Opisywany system posiada mechanizm przeszukiwania pewnej ustalonej domeny parametrów. 8:A=1. bądź całe drzewo cieniowania (np.0. które są najbardziej zbliżone do wzoru. bądź przeszukujemy ten zakres systematycznie. 4. Jest tak. największa ilość ciekawych symulacji odkrytych w trakcie badań. B=0. dostaniemy następujących 8 obrazów: 1:A=0. B=1. stosując iteracyjnie metodę parametrów losowych. Poziom zagłębienia (aktualna warstwa) Tabela 4-8 Specyfikacja funkcji bazowej FractalNoiseWorley 4. 4.2. Jest to sposób szczególnie przydatny wtedy.4.4.1].

w TexLib można wydzielić 4 główne moduły funkcjonalne: 1. za pomocą odpowiednich funkcji interfejsu. 5.1. To. sposób działania oraz wybrane aspekty implementacji biblioteki TexLib stworzonej i wykorzystywanej w trakcie badań nad teksturami proceduralnymi.3 5. który udostępnia funkcje definiowania i obsługi drzew cieniowania. Obsługa drzew cieniowania. jest zależne od jego implementacji. Architektura Zarówno bibliotekę jak i system.1.2. przekazać swój aktualny kontekst cieniowania. który jest niezbędny dla ewaluacji odpowiednich parametrów powierzchni przez bibliotekę.1. Aplikacja musi więc. 5. które ją wykorzystuje. Moduły funkcjonalne systemu renderującego Funkcje cieniujące mają dostęp do informacji związanych z aktualnym kontekstem cieniowania. jednak najczęściej funkcje interfejsu biblioteki są wywoływane z funkcji cieniujących (patrz: opis przebiegu renderingu w punkcie 2. SYSTEM funkcja cieniująca kontekst cieniowania BIBLIOTEKA TexLib kontekst cieniowania funkcje cieniujące obsługa drzew cieniowania interfejs serializacja GUI Diagram 5-1 Architektura biblioteki TexLib (moduły funkcjonalne) 5. Interfejs Biblioteka komunikuje się z systemem renderującym za pomocą interfejsu. Biblioteka do tworzenia tekstur proceduralnych TexLib W tym rozdziale opisana została architektura. Architektura biblioteki oraz potencjalnego systemu ją wykorzystującego przedstawiona została na Diagram 5-1. Dokładny przebieg procesu cieniowania został przedstawiony w punkcie 5. Moduł obsługi drzew cieniowania przechowuje definicje tekstur (będących złożeniami podstawowych funkcji cieniujących) oraz wykonuje ich 50 .3.1.5. można podzielić z naszego punktu widzenia na pewne moduły funkcjonalne (niekoniecznie pokrywające się z modułami wynikającymi z implementacji).1).1. Biblioteka Z punktu widzenia aplikacji i interfejsu do biblioteki. w jaki sposób interfejs jest używany przez system renderujący.

Aplikacja ta. Kontekst cieniowania.ewaluację. który nie wchodzi w skład biblioteki TexLib. czym zajmuje się moduł serializacji.2. 4.4 oraz 5. narzędzia wspomagające budowanie tekstur modyfikujących normalne cieniowanych powierzchni i inne. 5. Drzewa cieniowania mogą być z poziomu interfejsu budowane. Biblioteka może być łatwo rozszerzana o dodatkowe funkcjonalności związane z funkcjami cieniującymi dzięki dodatkowym modułom (oznaczonym na diagramie jako „dodatkowe funkcje cieniujące”). Moduł tworzy pliki w formacie *.4.2.5 przedstawiają schematy klas biblioteki. interpolacji. 51 .1. Diagramy 5. Zawarte są w nim wszystkie funkcje wykorzystywane w tej pracy do produkcji tekstur. 2.TREE został przedstawiony w dodatku Dodatek B). Są to między innymi funkcje związane z podstawowymi operacjami składania kilku innych funkcji. Przechowywaniem oraz dostarczaniem kontekstu odpowiednim funkcjom wewnątrz biblioteki TexLib zajmuje się moduł funkcjonalny oznaczony na Diagram 5-1 jako „kontekst cieniowania”. W trakcie procesu tworzenia obrazu (renderingu) biblioteka musi znać aktualny kontekst cieniowania (czyli współrzędne cieniowanego punktu. Podejście obiektowe dało możliwość zaprojektowania łatwej do rozbudowania architektury. informacje związane z antialiasingiem i wiele innych informacji). 5. Funkcje cieniujące.diagram klas 5. 5. normalna do powierzchni. Aplikacja wykorzystuje TexLib za pomocą innego interfejsu niż systemy renderujące (aczkolwiek jest zintegrowana z systemem do renderingu LADS. umożliwia wygodną budowę drzew cieniowania za pomocą standardowego graficznego interfejsu użytkownika. Diagramy klas Biblioteka została zaimplementowana C++ z wykorzystaniem technik obiektowych udostępnianych przez język programowani. Standardowo istnieje 1 moduł rozszerzający bibliotekę o nowe funkcje cieniujące oznaczony na diagramie jako „standardowy moduł funkcji cieniujących”. moduły z funkcjami cieniującymi to biblioteki łączone dynamicznie (DLL w przypadku Windows). opisana w rozdziale 6. odczytywane i wykorzystywane do ewaluacji konkretnych wartości modyfikujących własności powierzchni.2. Drzewa cieniowania mogą być zapisywane i odczytywane z dysku.3. standardowych funkcji cieniujących.TREE (opis formatu *. ale został na potrzeby tej pracy zaimplementowany jako oddzielna aplikacja. Serializacja. który z kolei wykorzystuje opisany interfejs do wizualizacji budowanych drzew cieniowania) 5. 3. zapisywane. Interfejs graficzny Na Diagram 5-1 został umieszczony jeszcze jeden moduł funkcjonalny – „interfejs graficzny”.1. Implementacja . Ilość dodatkowych modułów rozszerzających jest nieograniczona (implementacyjnie. Biblioteka posiada pewną liczbę wbudowanych.

Diagram 5-2 Diagram klas typów wartości 52 .

Diagram 5-3 Diagram klas związanych ze wzorami 53 .

Diagram 5-4 Diagram klas funkcji zarządzających wzorami 54 .

Diagram 5-5 Diagram klas podstawowych implementacji algorytmów szumów 55 .

Każda klasa pochodna od CAbstractValue przeciąża operator przypisania. inicjację itd. W tym celu została też wprowadzona funkcja Initialise(). Funkcja Initialise() jest wywoływana dla każdej wartości przed rozpoczęciem renderingu (w czasie inicjalizacji drzewa cieniowania) • Tworzenie wartości losowych.2. Inicjowane są także wartości parametrów wejściowych. Wartości te są ustalane w funkcji Initialise(). Są one opisane odpowiednio przez klasy CLinkIn oraz CLinkOut. wartość domyślna (tylko dla parametrów wejściowych) oraz aktualna. Każda wartość może przybierać wartości losowe. Tabela 5-1 zawiera opis tych funkcji. Powinna zaznaczyć wszystkie wartości parametrów wyjściowych jako nieaktualne (te właśnie operacje wykonuje domyślna implementacja. która powinna ustawić poprawne wartości parametrów 56 Invalidate(int id) Evaluate() . jeśli wartość parametru o identyfikatorze id staje się nieaktualna (np. Po niej dziedziczą klasy wartości konkretnych typów (Int. czy odczytywana wartość jest poprawna. Float. Funkcja. Klasy te przechowują dane o parametrach takie. czy też należy wymusić jej odświeżenie przez właściciela. przeciążanie nie jest więc zwykle konieczne). czyli funkcję cieniującą. Point. Opisy najważniejszych klas Poniżej znajdują się opisy najważniejszych klas przedstawionych na diagramach (…) Klasa CAbstractValue (abstrakcyjna) Klasa opisująca abstrakcyjną wartość parametrów wejściowych i wyjściowych wzorów. których zmian nie przewiduje się w trakcie renderingu. Każda wartość umie zapisać się i odczytać z podanego strumienia. • Przechowywanie znacznika poprawności wartości.2. • Zliczanie statystyk. • Obsługa serializacji.5. Color. Każda funkcja cieniująca musi implementować kilka funkcji. dzięki czemu można jego implementacje wykorzystać do zliczania statystyk w czasie renderingu. jeśli zgłoszono taką potrzebę. które umożliwiają między innymi ewaluację odpowiednich parametrów. w czasie zmiany kontekstu wejściowego spowodowanej rozpoczęciem obliczeń dla kolejnej próbki). jak nazwa. którym jest parametr wyjściowy wzoru (patrz: klasa CLinkOut). która inicjalizuje wewnętrzne liczniki statystyk (dla każdej klasy pochodnej CAbstractValue są to inne parametry). Najważniejsze funkcjonalności tej klasy to: • Referencja do właściciela. W trakcie tego procesu wykonywane są wszystkie operacje. Każda wartość posiada swojego właściciela (wskaźnik m_pOwner). jeśli obiekt wartości nie ma właściciela (czyli jeśli żaden obiekt nie zmodyfikuje wylosowanej wartości) Klasa CPattern (abstrakcyjna) CPattern opisuje wzór. Nazwa funkcji Initialise() Opis funkcji Inicjacja wzoru. Dzięki temu obiekty wykorzystujące wartości typów pochodnych CAbstractValue mogą stwierdzić. konieczność ewaluacji wartości itp. Funkcja wywoływana. Sample). które nie muszą być powtarzane w trakcie renderingu. Vector. Ma to sens tylko wtedy. Funkcja cieniująca opisana przez CPattern zawiera pewną liczbę parametrów wejściowych i wyjściowych.

Istnieje także alternatywna postać – Evaluate(int id). których właścicielami (patrz: opis klasy CAbstractValue) mogą być obiekty CLinkOut. to oznacza to wartość stałą. różni się w ich przypadku nieco od reszty wzorów zdefiniowanych bądź to standardowo bądź przez użytkownika. Tabela 5-1 Funkcje wirtualne klasy CPattern Obiekty klasy CPattern posiadają wskaźnik na obiekt CPatternFactory (patrz: opis klasy CPatternFactory). Połączenia między parametrami wejściowymi i wejściowymi wzorów są realizowane przez klasy CLinkIn oraz CLinkOut.wyjściowych. Parametry wejściowe. Może istnieć tylko jeden obiekt tej klasy. czyli konteksty wejściowy i wyjściowy. Jeśli obiekt CLinkIn posiada wskaźnik na wartość bez właściciela. Klasa CManager posiada tablicę obiektów klas CPatternFactory. Initialise). Przechowuje także nazwę wzoru. czyli zbiór dowolnej ilości połączonych ze sobą wzorów i wartości. Zwykle jednak Evaluate(int id) wywołuje Evaluate(). które opisują konteksty – odpowiednio wejściowy oraz wejściowy. • Ładowanie zewnętrznych bibliotek wzorów (DLL) Klasa CShadeTree Klasa opisuje drzewo cieniowania. Specjalnym przypadkiem klas CPattern są klasy CInContext oraz COutContext. Klasa CPatternFactory (abstrakcyjna) Klasa pochodna CPatternFactory jest klasą pomocniczą dla każdej klasy pochodnej CPattern i służy tworzeniu nowych obiektów danego wzoru (patrz też: opis klasy CManager). Zachowanie niektórych funkcji (Evaluate. Klasa służy do zarządzania wzorami dostępnymi w bibliotece. Najważniejsze jej funkcjonalności to: • Przechowywanie informacji o wszystkich dostępnych wzorach.TREE). posiadają wskaźniki na wartości (CAbstractValue). Specjalnym przypadkiem są wzory CInContext oraz COutContext. Obiekty tych klas istnieją w drzewie cieniowania zawsze. Klasa CManager Implementuje wzorzec Singleton [Gamma 1995]. czyli obiekty klasy CLinkIn. Klasa ta zajmuje się także serializacją drzew cieniowania (zapisywaniem i ładowaniem plików *. bez obliczania innych. Wykorzystano tutaj wzorzec projektowy Abstract Factory [Gamma 1995]. Wzory oraz wartości stałe są przechowywane wewnątrz klasy w dwóch tablicach. które pozwalają na tworzenie nowych obiektów klas wzorów (funkcja New() w klasie CPatternFactory). 57 . i zawsze może być tylko jeden kontekst wejściowy i wyjściowy. która powinna obliczyć parametr o identyfikatorze id. ponieważ specyfika wzorów nie pozwala na obliczenie pojedynczego parametru wyjściowego.

W szczególności. kontrast. ustaw parametry w ‘tree’ jeśli to konieczne. gamma) Diagram 5-6 Faza cieniowania z uwzględnieniem biblioteki TexLib Biblioteka TexLib może być wykorzystywana w fazach obliczania przesunięcia. Przebieg fazy cieniowania z punktu widzenia systemu renderującego z uwzględnieniem wykorzystania TexLib wygląda jak na Diagram 5-6. (…) dla każdej próbki { (…) 58 . Niewątpliwie jednak przygotowanie kontekstu wejściowego (czyli obliczenie współrzędnych cieniowanego punktu.5. załaduj drzewo cieniowania ‘tree’ używając TexLib. Procesu renderingu z wykorzystaniem interfejsu biblioteki TexLib Ogólny schemat działania systemu renderującego został przedstawiony w punkcie 2.1. przezroczystości oraz koloru (zależy to od tego. jakie parametry powierzchni będą przez nią modyfikowane). (…) zainicjuj bibliotekę TexLib. Biblioteka nie zakłada żadnej kolejności wykonywania obliczeń związanych z modyfikacją parametrów powierzchni przez system renderujący. normalnej do powierzchni w tym punkcie. Sposób działania systemu wykorzystującego TexLib w fazie cieniowania opisuje dokładniej pseudokod Program 5-1. przesunięcia oraz przezroczystości Światła Tło i inne składowe bez modelu oświetlenia Zastosowanie modelu oświetlenia Przekształcenia dodatkowe (jasność. zainicjuj ‘tree’. kolejność nie musi wyglądać jak na diagramie powyżej. danych związanych z filtrowaniem (antyaliasingiem) musi nastąpić dla każdego cieniowanego punktu przed rozpoczęciem korzystania z TexLib. Przygotowanie kontekstu cieniowania dla próbki Obliczenie koloru.3.

} if (‘tree’ modyfikuje kolor) { pobierz wartość koloru z ’tree’. Uwaga: Zalecane jest używanie identyfikatorów liczbowych ze względu na wydajność. Identyfikator typu PTREE PINCX POUTCX Opis Wskaźnik na obiekt drzewa cieniowania Wskaźnik na obiekt kontekstu wejściowego Wskaźnik na obiekt kontekstu wyjściowego Identyfikator parametru wejściowego lub wyjściowego wzoru (także parametrów kontekstów). zaznacz wszystkie wartości parametrów wyjściowych wzorów nieaktualne. Tabela 5-2 Charakterystyczne typy interfejsu biblioteki TexLib ID 5.1. Inicjalizacja biblioteki. if (‘tree’ modyfikuje normalną) { pobierz wartość normalnej z ’tree’. Może być liczbą całkowitą identyfikującą jednoznacznie parametr w ramach wzoru (zwracany przez odpowiednie funkcje interfejsu) lub łańcuchem znaków z nazwą parametru. ustal wartość koloru w swoim kontekście. } (…) } skasuj drzewo cieniowania ‘tree’.3. } if (‘tree’ modyfikuje przezroczystość) { pobierz wartość przezroczystości z ’tree’. (…) ustaw kontekst cieniowania w TexLib. Wszystkie one są inicjowane wywołaniami odpowiednich funkcji interfejsu biblioteki z poziomu systemu renderującego. Poniżej znajduje się opis wszystkich tych faz wraz z opisem odpowiednich funkcji interfejsu biblioteki. ładuje zewnętrzne biblioteki wzorów (znajdujące się w dynamicznie łączonych bibliotekach w odpowiednim podkatalogu). proces renderingu przebiega w kilku fazach.wyznacz swój kontekst cieniowania dla próbki. ustal wartość normalnej w swoim kontekście. TexLib przygotowuje wzory standardowe. (…) przetwarzanie dodatkowe (post-processing). Inicjowane są także wszystkie statyczne tablice wartości i 59 . (…) jako Program 5-1 Faza cieniowania z użyciem TexLib Jak widać na powyższym pseudokodzie. Deklaracje funkcji interfejsu używają kilku specjalnych typów. które zostały opisane w Tabela 5-2. ustal wartość przezroczystości w swoim kontekście. Fazy procesu renderingu w bibliotece TexLib 1.

istnieje możliwość jego modyfikacji. to zostaną one przed operacją wczytania skasowane. 2. Ścieżki względne odnoszą się do katalogu roboczego aplikacji (systemu renderującego) wykorzystującego bibliotekę. POUTCX *outcx) Parametry incx (OUT) kontekst wejściowy nowo utworzonego drzewa cieniowania outcx (OUT) kontekst wyjściowy nowo utworzonego drzewa cieniowania Wartość zwracana Wskaźnik do nowo utworzonego drzewa cieniowania. Nie istnieją specjalne funkcje służące inicjalizacji biblioteki. Jeśli zawierało ono już jakieś wzory (zostało na przykład wcześniej wczytane za pomocą TCShadeTreeLoad). Tak zbudowane drzewo może zostać zapisane do pliku *. drzewo jest budowane za pomocą wywołań odpowiednich funkcji interfejsu (funkcje te są opisane dokładniej w punkcie 5. 60 . Tabela 5-3 Funkcje interfejsu biblioteki związane z tworzeniem drzew cieniowania 3. losowe tablice mieszające). Alternatywnie. To wywołanie zostało zaznaczone w Program 5-1. jeśli operacja wczytania powiodła się. Procedura inicjacji drzewa cieniowania nie powinna być wywoływana dla każdej cieniowanej próbki ze względów wydajnościowych. którego nazwa jest określona parametrem fileName.4. patrz: Dodatek B) • definicja drzewa używa nieznanych wzorów (tzn. Inicjalizacja drzewa cieniowania.TREE z którego odczytać definicję drzewa.TREE z definicją drzewa cieniowania. Jest to związane z wydajnością. tree (IN) Wartość zwracana true. wzorów dołączanych jako dodatki w formie bibliotek DLL) Ładuje drzewo z pliku. przezroczyście dla użytkownika. Parametr tree musi zawierać wskaźnik na wcześniej utworzone drzewo. o czym była mowa w punkcie 2. Przed rozpoczęciem renderingu biblioteka inicjuje wzór.TREE i odczytanie przy następnej potrzebie. Jeśli wzór został załadowany. Operacja wczytania może nie powieść się z kilku powodów: • nie istnieje plik o podanej nazwie • plik zawiera nieprawidłową definicję drzewa (jest niepoprawny syntaktycznie. bool TCShadeTreeLoad(PTREE tree. Większość systemów daje możliwość inicjacji tekstur proceduralnych wywołując przed rozpoczęciem renderingu (ale już po ustawieniu parametrów tekstury) odpowiednią procedurę. Ta operacja jest wykonywana przy pierwszym użyciu dowolnej funkcji interfejsu która tego wymaga. które zawiera tylko 2 standardowe wzory: InContext oraz OutContext.4).inne zmienne. char *fileName) Parametry wskaźnik na wcześniej stworzone drzewo cieniowania (za pomocą funkcji TCShadeTreeCreate) fileName (IN) nazwa pliku *. Budowa drzewa cieniowania. jeśli operacja tworzenia nie powiodła się Tworzy nowe drzewo cieniowania. false w przeciwnym wypadku. lub wartość PTREE_NULL. PTREE TCShadeTreeCreate(PINCX *incx. TexLib ładuje wskazany plik *. Takie wywołanie nie zmieniłoby jednak wyglądu generowanego obrazu. które nie ulegają zmianie w trakcie działania biblioteki (np.

Określenie kontekstu cieniowania Obliczenie własności każdej próbki.5) Wartość zwracana 0 jeśli podany parametr wyjściowy kontekstu wyjściowego nie jest modyfikowany. czy system chce używać antialiasingu czy nie. jak i większości innych opisywanych tu funkcji interfejsu. zależne od tego. System musi poinformować TexLib o rozpoczęciu obliczeń dla nowej próbki wywołaniem odpowiedniej procedury interfejsu. tzn. jeśli inicjalizacja powidła się. Istnieją dwa tryby ewaluacji: punktowy i powierzchniowy (ang. Ustawienie kontekstu wymaga różnej ilości operacji. Każde pobranie może (ale nie musi. a. Ewaluacja Ewaluacja jest od strony systemu renderującego bardzo prosta i polega na pobieraniu wyjść kontekstu wyjściowego aktywnego drzewa cieniowania. Po tym powinno nastąpić ustawienie kontekstu wejściowego dla aktywnego drzewa cieniowania. drzewo zawiera cykle proste (właściwie taka sytuacja nie powinna się zdarzyć. ponieważ narzędzia służące do budowy drzew cieniowania – opisywane dalej – nie pozwalają nazbudowanie nieprawidłowego drzewa Funkcja inicjalizuje podane drzewo cieniowania. Rendering. jakie wartości tego kontekstu są przez konkretne drzewo wykorzystywane b. point i area). W tym czasie inicjalizowane są także wszystkie wzory i zmienne wchodzące w skład drzewa. jej normalną czy też przezroczystość. czy kontekst wejściowy zmienił się od czasu poprzedniego żądania obliczenia) wywołać ciąg ewaluacji wewnątrz drzewa. Zastosowanie tej. można znaleźć w aplikacji opisanej w rozdziale 6. false w przeciwnym wypadku. Tabela 5-4 Funkcje interfejsu biblioteki służące do inicjalizacji drzewa cieniowania 4. którą dostarczy system renderujący wiąże się z kilkoma operacjami. int TCShadeTreeOutCxModified(PTREE tree. czy dane drzewo cieniowania modyfikuje podany parametr kontekstu wyjściowego. Zgłoszenie odpowiedniego żądania odbywa się poprzez ustawienie odpowiedniej zmiennej kontekstu wejściowego biblioteki. zależnie od tego. wartość różna od 0 w przeciwnym wypadku Funkcja służy do badania. 61 . dowiedzieć. System renderujący może w ten sposób zbadać. Operacja inicjalizacji może się nie powieść z kilku powodów: • brak pamięci do inicjalizacji tablic lub stworzenia potrzebnych obiektów w jednym ze wzorów • nieprawidłowe drzewo cieniowania. które z parametrów swojego kontekstu zmieniać na podstawie kontekstu wyjściowego drzewa cieniowania. ID id) Parametry tree (IN) id (IN) wskaźnik na drzewo cieniowania identyfikator parametru wyjściowego kontekstu wyjściowego drzewa (definicje parametrów – patrz punkt 5.bool TCShadeTreeInitialise(PTREE tree) Parametry tree (IN) wskaźnik na drzewo cieniowania Wartość zwracana true. zależy to od tego. czy dane drzewo modyfikuje kolor powierzchni. Łatwo się w ten sposób np.

jeśli funkcja zwraca wartość 0). które zależą od tych zdeaktualizowanych za pomocą TCShadeTreeInvalidate ). Jeśli nie jest (tzn. void TCShadeTreeInCxSetxxx(PTREE tree.5) wartość parametru wyjściowego kontekstu wyjściowego Funkcja służy do pobierania obliczonych przez drzewo cieniowania wartości. co może prowadzić do polepszenia wydajności.5) Wartość zwracana 0. system renderujący nie musi ustawiać tej wartości kontekstu w czasie renderingu. który jest używany przez dane drzewo. void TCShadeTreeInvalidateAll(PTREE tree) void TCShadeTreeInvalidate(PTREE tree. jeśli parametr wejściowy kontekstu wejściowego podanego drzewa cieniowania jest używany przez jakiś wzór. wartość różna od 0 w przeciwnym wypadku Funkcja sprawdza.void TCShadeTreeOutCxGetxxx(PTREE tree. natomiast druga tylko jeden. Pierwsza postać funkcji dezaktualizuje wszystkie parametry wejściowe. gdzie xxx.5) wartość parametru wejściowego kontekstu wejściowego Wartość zwracana Nic Funkcja ustawia wartość kontekstu wejściowego drzewa. yyy) Parametry tree (IN) id (IN) yyy (IN) wskaźnik na drzewo cieniowania identyfikator parametru wyjściowego kontekstu wyjściowego drzewa (definicje parametrów – patrz punkt 5. ID id. czy podany parametr wejściowego kontekstu wejściowego jest używany przez jakikolwiek wzór. ponieważ przeliczane będą tylko te parametry wyjściowe. podany parametr (w ten sposób możemy uzyskać pewną optymalizację ewaluacji drzewa cieniowania. Tabela 5-5 Funkcje interfejsu biblioteki wykorzystywane w trakcie renderingu 62 . Drzewo nie przeliczy swoich parametrów wyjściowych jeśli system nie wywoła jednej z powyższych funkcji. yyy według Tabela 5-6 Parametry tree (IN) id (IN) yyy (OUT) Wartość zwracana Nic wskaźnik na drzewo cieniowania identyfikator parametru wyjściowego kontekstu wyjściowego drzewa (definicje parametrów – patrz punkt 5. yyy). ID id) Parametry tree (IN) id (IN) wskaźnik na drzewo cieniowania identyfikator parametru wejściowego kontekstu wejściowego Wartość zwracana Nic Funkcja powiadamia drzewo cieniowania o deaktualizacji wartości parametru wejściowego kontekstu wejściowego. ID id. ID id) Parametry tree (IN) id (IN) wskaźnik na drzewo cieniowania identyfikator parametru wyjściowego kontekstu wyjściowego drzewa (definicje parametrów – patrz punkt 5. Musi być wywoływana dla każdego parametru kontekstu wejściowego biblioteki. int TCShadeTreeInCxUsed(PTREE tree.

2): CPattern oraz CPatternFactory. FLOAT[3] * Tabela 5-6 Przyrostki funkcji interfejsu i odpowiadające im parametry 5. Przykładowa klasa CPatternFactory dla wzoru o nazwie „Checker” jest widoczna na Program 5-2. 63 . Operacje te są wykonywane po wywołaniu odpowiednich funkcji interfejsu. druga istnieje w celach pomocniczych pomocniczych. Zakończenie działania biblioteki Zakończenie działania wiąże się ze skasowaniem wszystkich użytych drzew cieniowania oraz zwolnieniem wykorzystywanych obiektów pomocniczych. Na definicje wzoru składają się pochodne 2 klas (opisanych wcześniej w punkcie 5.. Interfejs programistyczny-rozszerzanie biblioteki o nowe wzory Wspomniano już o tym. Tabela 5-7 Funkcje interfejsu biblioteki związane z kończeniem działania 5.4. FLOAT * int. Int Float Point Color Vector Sample FloatArray ColorArray Parametry funkcji zależne od przyrostka funkcje Get… int * FLOAT * FLOAT[3] FLOAT[3] FLOAT[3] TSample * int *. Uwaga: parametr tree musi być prawidłowym wskaźnikiem na drzewo cieniowania. void TCShadeTreeDestroy(PTREE tree) Parametry tree (IN) wskaźnik na drzewo cieniowania Wartość zwracana Nic Funkcja kasuje podane drzewo cieniowania.Przyrostek funkcji. za pomocą której możemy dowolnie rozszerzać możliwości biblioteki. FLOAT[3] * funkcje Set… int FLOAT FLOAT[3] FLOAT[3] FLOAT[3] TSample int. np: TCShadeTreeOutCxGet. Zwolniona zostanie pamięć po wszystkich wykorzystywanych obiektach oraz odładowane zostaną biblioteki dynamiczne z dodatkowymi wzorami. że TexLib wykorzystuje dodatkowe dynamicznie ładowane biblioteki z implementacją nowych wzorów. jako „fabryka” nowych obiektów wzoru.. FLOAT * int *. Każdy nowy wzór musi być zdefiniowany według pewnych reguł i implementować ściśle określone funkcjonalności. void TTerminate() Parametry Nic Wartość zwracana Nic Funkcja powinna być wywołana po zakończeniu pracy z biblioteką. Jest to jedyna. ale dająca duże możliwości metoda. Pierwsza z nich implementuje właściwy algorytm obliczający pewne parametry wyjściowe.

Zawartość kontekstu cieniowania w popularnych systemach grafiki fotorealistycznej Biblioteka i jej wzory działają na pewnym standardowym kontekście cieniowania. zawierającą funkcje. Parametry bardziej zaawansowane. która po zawołaniu zwróci tablicę obiektów typu CPatternFactory (dla każdego nowego typu należy stworzyć jeden obiekt CPatternFactory). aby udostępniały jak największy zakres działania. czy w końcu wydajnością. związane z antyaliasingiem wzorów. Istnieją parametry. dokładnością obliczeń. każdy z systemów ma swoje charakterystyczne zmienne. virtual void Evaluate(). virtual void EvaluateArea(). virtual void Initialise(CShadeTree *pShadeTree = NULL).5. virtual char *GetName() { return name. char CFactoryPattern::name[] = „Checker”. jednocześnie jednak biorąc pod uwagę to. możliwość wykorzystania tekstury podczas renderingu radiosity w 64 . że każdy system działa w odmienny sposób. RenderMan. class CPatternChecker : public CPattern { public: CPatternChecker(CFactoryChecker *pFactory). nie są już niestety traktowane w ten sam sposób przez systemy do grafiki 3D i różnią się bardzo oferowanymi możliwościami. }. Program 5-3 zawiera przykładową deklarację CPatternFactory. }. które są wykorzystywane i udostępniane w interfejsach programistycznych do tworzenia tekstur proceduralnych w prawie każdym systemie. ustalonym na podstawie analizy kilku kontekstów popularnych systemów do renderingu (3dsMAX. Program 5-3 Przykładowa klasa typu CPattern Biblioteka DLL zawierająca definicje nowych wzorów musi ponadto zawierać publiczną (eksportowaną) funkcję o sygnaturze TPatternFactories *Init(). które nie występują w innych programach. LightWave. Parametry dobrano tak.class CFactoryChecker : public CPatternFactory { virtual CPattern *New() { return new CPatternChecker(this). }. które są w CPattern zadeklarowane jako abstrakcyjne. a więc których pokrycie jest konieczne w klasach pochodnych. }. Zwykle są one związane z pewnymi niestandardowymi możliwościami lub sposobami działania (np. 5. BMRT. Program 5-2 Przykładowa klasa typu CPatternFactory Klasa dziedzicząca po CPattern implementuje kilka metod umożliwiających jej wykorzystanie w drzewach cieniowania. Obiekty te (ich funkcja New()) posłużą bibliotece do tworzenia obiektów wzorów. LADS). Wartości zmiennych opisujących podobne charakterystyki cieniowanej próbki mogą się znacznie różnić między różnymi systemami [T&M 1998]. Ponadto. private : static char name[].

związane z antialiasingiem oraz inne. 5. Im większa wartość Curve. Jej metody oraz atrybuty dają dostęp między innymi do zmiennych opisanych w Tabela 5-8 Wybrane zmienne kontekstu cieniowania systemu 3dsMAX release 3 (niektóre z nich są dostępne przez wywołanie funkcji. Opisuje jak szybko zmienia się normalna. na którą nie ma wpływu użycie SetNormal) Normalna trójkąta) geometryczna (normalna do cieniowanego Aktualna wartość czasu (jeśli aktualnie renderowana jest animacja) antialiasing Antialias DP DUVW boolean punkt punkt float Określa.jednym z systemów implikuje obecność w kontekście cieniowania zmiennych pozwalających na dokładną identyfikację cieniowanego wielokąta – w ten sposób można wykorzystać wcześniej obliczone oświetlenie). czy antialiasingu cieniowanie powinno używać metod Pochodna P względem piksela. Używana do celów antialiasingu. Pochodne UVW dla punktu. Poniżej znajduje się zestawienie najważniejszych informacji. Mówi o tym.1. tym większa powierzchnia musi być próbkowana. jak szybko zmienia się pozycja względem ekranu. 3dsMAX release3 Jest to system. Dla każdego systemu przedstawiono 3 kategorie zmiennych: podstawowe. inne Curve Node obiekt Jest to wskaźnik do obiektu przechowującego informacje na 65 .5. które popularne systemy udostępniają w swoich interfejsach do programowania tekstur proceduralnych. Klasa ShadeContext udostępnia kontekst cieniowania. Odpowiadają one przedstawionej wyżej klasyfikacji. wszystkie przedstawione parametry są tylko do odczytu): Nazwa Typ podstawowe ScreenUV UVW P V Normal OrigNormal Gnormal CurTime Opis punkt 2D Znormalizowane położenie piksela na ekranie punkt punkt punkt punkt punkt punkt float Współrzędne w układzie UVW Współrzędne cieniowanego punktu Wektor widoku o początku w punkcie położenia kamery i kierunku do cieniowanego punktu (znormalizowany) Normalna w kierunku obserwatora (można ją zmodyfikować za pomocą funkcji SetNormal) Oryginalna normalna do powierzchni (normalna wynikająca z geometrii. Zmienna jest używana głównie do antyaliasingu podczas tworzenia obliczania mapowania środowiskowego. która udostępnia programiście obiektowy interfejs budowy modułów rozszerzeń (między innymi funkcji cieniujących).

że dla obiektu na czarnym tle ( I’=(0. przezroczystość oraz współczynnik załamania (ang: index of refraction) 5. 0. N. Jest to wskaźnik do obiektu cieniowanej geometrii. 0) powierzchnia będzie miała kolor C. 0 – powierzchnia niewidoczna) Przezroczystość. Jest to filtr. Należy zauważyć różnicę między tą zmienną a zmienną alpha.. LightWorks LightWorks Application Development System jest opisany w . posiada atrybuty opisujące kolor. przez który mnożony jest kolor spoza powierzchni. Dla alpha = 0 powierzchnia będzie niewidoczna. 1. 1) może wydawać się jaśniejsza. macierze transformacji. Ng wektor Normalne: używana do cieniowania oraz geometryczna – normalna aktualnie renderowanego trójkąta.2.INode temat cieniowanego ‘węzła’ sceny. w której materiał pozostawia wyniki obliczeń. Nazwa Typ podstawowe C P I E alpha Opis kolor punkt Kolor powierzchni w aktualnie cieniowanym punkcie Współrzędne w układzie obiektu aktualnie cieniowanego punktu Położenie obserwatora Współczynnik pokrycia powierzchni (1 – powierzchnia pokrywa całkowicie. Jasność I próbki po uwzględnieniu alpha i T jest wyliczana z modelu (I’ oznacza jasność spoza płaszczyzny): wektor Wektor kierunku patrzenia punkt float T kolor I = alpha * C + alpha * T * I '+ (1 − alpha) I ' Zauważmy. Udostępnia między innymi informacje przedstawione w Tabela 5-9 Wybrane zmienne kontekstu cieniowania systemu LightWorks. ponieważ do koloru C dodany zostanie komponent koloru spoza płaszczyzny. 66 . która steruje widocznością powierzchni. Mogą być układane w hierachii. tymczasem dla T = (0. Współrzędne barycentryczne cieniowanego trójkąta Współczynnik załamania światła GetEvalObject BarycentricCoords GetIOR obiekt Object punkt float Tabela 5-8 Wybrane zmienne kontekstu cieniowania systemu 3dsMAX release 3 Klasa ShadeOutput.. klucze animacji.5. 0) ) parametr T nie ma znaczenia. Dla T= (1. Węzły posiadają swoje nazwy. 0.

dv Pochodne koordynat tekstury oraz parametrów powierzchni – wektor opisują jak zmienia się pozycja wraz ze zmianą parametrów powierzchni. RenderMan RenderMan to jeden z niewielu systemów implementujących standard opisu scen trójwymiarowych o nazwie RenderMan Interface. kamery. opisanej parametrycznie oraz wektor Kierunek „nadchodzącego” promienia. s.u. float Zmiana parametrów powierzchni LADS udostępnia wielokąt. Tabela 5-10 Wybrane zmienne kontekstu cieniowania standardu opisu scen 3D RenderMan Interface Nazwa Typ podstawowe Opis P punkt Współrzędne cieniowanego punktu w lokalnym układzie współrzędnych. s. itp. dPdv ds.) I E N. Zmiana parametrów powierzchni. du. pixel polygon Tabela 5-9 Wybrane zmienne kontekstu cieniowania systemu LightWorks 5. antialiasing dPdu. v. t float Parametry powierzchni koordynaty tekstury. Parametry powierzchni koordynaty tekstury. Jest między innymi wykorzystywany w produkcji profesjonalnych efektów specjalnych do filmów. Odpowiednie funkcje pozwalają na przekształcenie punktu do dowolnego innego układu (np. świata. dPdu. która wielokąt umożliwia bardzo dokładny analityczny antialiasing (funkcja cieniująca powinna obliczyć kolor średni dla powierzchni ograniczonej do pixel polygon. Ng u. dv wektor float Pochodne parametrów powierzchni – opisują jak zmienia się pozycja wraz ze zmianą parametrów powierzchni. kolor Kolor oraz filtr (przez który mnożony jest kolor promienia przez powierzchnię) powierzchni. który ma kształt przecięcia aktualnie cieniowanej powierzchni z piramidą widzenia wychodzącą z obliczanego piksela. t L C. O Kierunek promienia przecinającego powierzchnię (wektor od wektor punktu położenia kamery. antialiasing opisanej parametrycznie oraz dPds. dPdt. Jest to informacja. v.5. dt. jeśli przekształcenie kamery określona kamerę typu „pinhole”). Normalne: używana do cieniowania oraz geometryczna – normalna aktualnie renderowanego trójkąta. punkt wektor float Położenie obserwatora. Ma duże możliwości właśnie dzięki interfejsowi teksturowania proceduralnego.. dPdv du. 67 .3.

Incident vector). Zmienne są przedstawione w Tabela 5-11. Można ją zinterpretować jako przybliżenie średnicy okręgu opisanego na wielokącie pixel polygon obliczanym przez renderer LightWorks. pochodne P: dPds. które można czytać i modyfikować jako własności powierzchni (C. dPdu. LightWave System LightWave. 5.5. Kierunek promienia przecinającego powierzchnię w cieniowanym punkcie (od ang. Biblioteka TexLib rozdziela te dwa rodzaje zmiennych i umieszcza je w dwóch osobnych kontekstach: wejściowym i wyjściowym. które są niezbędne do ewaluacji trójwymiarowych tekstur proceduralnych oraz kilka. udostępnia w swoim interfejsie wartość spotSize.inne time dtime dPdtime float float wektor Aktualny czas (jeśli renderowana jest animacja) Ilość czasu „zawarta” w aktualnie obliczanej klatce animacji. Punkt położenia obserwatora (od ang. L. Przezroczystość powierzchni. biblioteka może tylko modyfikować wcześniej ustaloną przez wykorzystujący ją system wartość. musimy więc znać wartość ustaloną przez system. która jest przybliżonym promieniem okręgu. w którym można zawrzeć powierzchnię cieniowanej płaszczyzny widocznej przez aktualnie obliczany piksel obrazu. alpha). Kontekst wejściowy jest zbiorem pewnych najczęściej używanych w innych systemach zmiennych. Wybrano te. prócz standardowych wartości P. Podobnie jak w przypadku koloru C. które nie są dostępne we wszystkich systemach. Kontekst w bibliotece TexLib W interfejsach tekstur proceduralnych we wszystkich opisanych systemach istnieją wartości tylko do odczytu (zwykle P. W takim przypadku musimy znać ten wcześniej nałożony kolor płaszczyzny. s. N. Określa jak pozycja P zmienia się w jednostce czasu (wartość zdeterminowana przez motion blur na scenie) Tabela 5-10 Wybrane zmienne kontekstu cieniowania standardu opisu scen 3D RenderMan Interface 5. Zmienna P N Typ (Tabela 4-2) Opis Point Vector Współrzędne aktualnie cieniowanego punktu w układzie lokalnym obiektu Wektor normalny do aktualnie cieniowanej płaszczyzny Kolor płaszczyzny w cieniowanym punkcie P. Eye point) C Color T Color I E Vector Point 68 . s. t. System renderujący może stosować drzewo cieniowania TexLib na przykład do modyfikacji już rzutowanej na geometrię tekstury tradycyjnej. dPdv) i takie. T.4.5. t.5. a których obecność znacznie zwiększa potencjalne możliwości biblioteki. N. dPdt. I.

ds. dPdu. dPdv. W przypadku systemu LADS spotSize jest przekątną prostokąta opisanego na pixel polygon.u. spotSize są wykorzystywane właściwie wyłącznie dla wzorów. du. dv. dPdt. Wartość czasu. Wszystkie wzory udostępniające ten tryb zaczną go wykorzystywać. v. dPdv ds. ponieważ to. du. dv Float Vector Float Parametry powierzchni opisanej parametrycznie oraz koordynaty tekstury. Wartość AA=0 oznacza wyłączenie antialiasingu. dt. jak time będzie wykorzystany zależy od systemu wykorzystującego bibliotekę) time Float Tabela 5-11 Zmienne kontekstu wejściowego biblioteki TexLib Wartości dPds. AA≠0 oznacza włączenie antialiasingu. Służy do renderingu animacji i jest umowną wartością zmiennoprzecinkową (tzn. dPdt. dt. Zmiana parametrów powierzchni Średnica okręgu opisanego na wielokącie będącym przecięciem stożka widzenia wychodzącego z aktualnie cieniowanego piksela oraz cieniowanej płaszczyzny. s.. dPdt.) spotSize może być obliczany następująco: spotSize = max( dPdu * du ^ dPdv * dv .. t. nie można interpretować upływu czasu od wartości time=0 do time=1 jako np. gdzie ^ oznacza iloczyn wektorowy 2 wektorów spotSize Float AA Int Zmienna przełączająca użycie antialiasingu analitycznego (od ang. itp. 1 sekundy. Jest to wartość podobna do tej wykorzystywanej w systemie LightWave. Analytic Antialiasing). Definicję tej struktury przedstawia Program 5-4. MinSpotSize) . Ze względu na wygodę użycia zostały one zamknięte w jednej strukturze typu TSample. /* * derivatives */ 69 . typedef struct { /* * analytic antialiasing toggle */ int AA. w których potrzebny jest antialiasing. dPdu. dPds. Dla systemów liczących antialiasing analityczny jedynie za pomocą pochodnych punktu P (dPds. Pochodne koordynat tekstury oraz parametrów powierzchni – opisują jak zmienia się pozycja wraz ze zmianą parametrów powierzchni.

FLOAT dPds[3]. Część wzorów. dt. Wzory specjalne. ang. Podczas uruchamiania aplikacji. przezroczystości oraz normalnej do płaszczyzny. P Point T alpha Color Float Tabela 5-12 Zmienne kontekstu wyjściowego biblioteki TexLib 5. /* * antialiasing filter size */ FLOAT spotSize. displacement). dPdt[3]. takie jak CalculateNormal. to zmienną tą wykorzystuje się zwykle przesuwając wejściowy punkt P wzdłuż wektora normalnego N. Multiply itp. Program 5-4 Definicja typu struktury TSample znajdującej się w interfejsie TexLib Zawartość kontekstu wyjściowego umożliwia zmianę koloru. dPdv[3]. Add. /* * changes in texture/parameter space */ FLOAT ds. Każda 70 . W czasie tego procesu wszystkie biblioteki DLL z podkatalogu Patterns są wczytywane do pamięci.1. dPdu[3]. Zmienna C N Typ (patrz Tabela 4-2) Opis Color Vector Nowy kolor płaszczyzny dla punktu P kontekstu wejściowego Zmodyfikowana normalna dla punktu P kontekstu wejściowego Zmodyfikowany punkt P kontekstu wejściowego. du. Uwaga: Nie każdy system udostępnia możliwość modyfikacji płaszczyzny (przemieszczenia. NoisePerlin) są zdefiniowane w bibliotece patterns. są zdefiniowane w rdzeniu biblioteki a tym samym dostępne bez dodatkowych plików DLL. ale obsługuje ją niewiele systemów (jest nim np. Jeśli tak.dll umieszczonej w podkatalogu aplikacji wykorzystującej TexLib o nazwie Patterns. raytracer Blue Moon Rendering Tool). Wzory definiowane w bibliotekach DLL TexLib wykorzystuje biblioteki DLL do rozszerzania zbioru podstawowych wzorów. TexLib jest inicjalizowany. Zmodyfikowana przezroczystość. które mogą być dystrybuowane z biblioteką jako standardowe (np.6.6. Współczynnik pokrycia powierzchni. Istnieje także możliwość przesunięcia punktu P. Wybrane szczegóły implementacyjne 5. } TSample. dv.

pFactories->Add(new CFactoryWzor1()) //… pFactories->Add(new CFactoryWzorN()).biblioteka z definicjami wzorów oprócz definicji samych klas wzorów (patrz punkt 5. Po wyliczeniu parametru P wzoru B zakończona zostanie ewaluacja parametru color wzoru A i wynik zostanie przekazany do kontekstu wyjściowego. Ewaluacja drzewa cieniowania Wszystkie parametry wzorów. return pFactories. aby takie połączenia tworzyć w każdym budowanym drzewie cieniowania. ponieważ nie ma żadnego parametru kontekstu wyjściowego. } Program 5-5 Inicjacja wzorów w bibliotece DLL 5. Funkcja zwraca tablicę obiektów fabryk wzorów. Należy także zwrócić uwagę na to. Nie będą prawidłowe (będą równe wartościom domyślnym) jeśli nie ma jawnego połączenia między nimi w drzewie cieniowania. w tym także kontekstów.6. że rozpoczęcie ewaluacji drzewa może być rozpoczęte tylko przez próbę odczytania przez system wykorzystujący je któregoś z parametrów wyjściowych kontekstu wyjściowego.. że parametry kontekstu wejściowego. które posiadają swoje odpowiedniki w kontekście wyjściowym nie muszą być koniecznie w kontekście wyjściowym prawidłowe.2. Ewaluacja rozpoczyna się od parametru color wzoru A. po czym następuje pobranie koloru black lub white. Należy zauważyć wynikające stąd możliwości optymalizacji od strony systemu wykorzystującego TexLib. Nie musi on bowiem uzupełniać parametrów kontekstu wejściowego. 71 . są ewaluowane tylko w razie potrzeby. Wymusza to ewaluację parametru P wzoru E. który by zależał od któregoś z nich. Pobranie koloru white wiąże się z dalszym obliczeniem P wzoru D i pobraniem wcześniej przeliczonego parametru P wzoru E (parametr P wzoru E jest więc liczony tylko raz na próbkę). Przeanalizujmy kolejność ewaluacji parametrów drzewa pokazanego na Diagram 5-7. { TPatternFactories *pFactories. Oczywiście nic nie stoi na przeszkodzie.4) musi zawierać eksportowaną funkcję o nazwie Init i deklaracji: PATTERNS_API TPatternFactories *Init(). Próba pobrania parametru wyjściowego dowolnego wzoru powoduje ciąg ewaluacji wszystkich parametrów. od których dany parametr zależy. pFactories = new TPatternFactories(). których drzewo cieniowania nie używa. Żaden z parametrów wzoru C nigdy nie będzie obliczony. Wynika stąd. Tablicę tworzy się w sposób podany w Program 5-5 PATTERNS_API TPatternFactories *Init().

polega na obliczeniu we wzorze tylko tych parametrów wyjściowych. Jeśli na początku ewaluacji (po wejściu do 72 . Zwykle wzory wypełniają wszystkie swoje wyjścia.. Rozpoznawanie cykli odbywa się w trakcie procesu renderingu i jest oparte na flagach w obiektach klasy CPattern. których ewaluacja jest potrzebna. Parametrami funkcji są identyfikatory wyjść. i czyści ją po odczytaniu ostatniego potrzebnego parametru wyjściowego innego wzoru.. trudna jednak do wykorzystana w praktyce.3.Diagram 5-7 Przykład kolejności ewaluacji parametrów drzewa cieniowania Jeszcze jedna możliwość optymalizacji. Istnieje jednak możliwość obliczenia tylko potrzebnych wartości dzięki funkcjom w klasie CPattern o deklaracjach void Evaluate(int ID). void EvaluateArea(int ID). ponieważ takie rozwiązanie jest prostsze do zaimplementowania. Domyślna implementacja tych funkcji polega na wywołaniu odpowiednio Evaluate() oraz EvaluateArea(). które są potrzebne.6. nawet tych nigdy nie używanych. Zapobieganie cyklom Wspomniano już. że drzewa cieniowania nie mogą zawierać cykli prostych. Każdy obiekt wykorzystujący wyjścia innych wzorów ustawia flagę m_bBeingEvaluated na początku funkcji Evaluate. co powoduje obliczenie wszystkich parametrów wyjściowych. 5.

które podzielić można na dwie grupy. W szczególności. Pewne szczegóły tego procesu są podane w punkcie 6. Posiada rozbudowany system programowania tekstur proceduralnych. procedur cieniujących (ang: shaders).7. który pozwala na modyfikację dowolnych parametrów powierzchni za pomocą kilku rodzajów tzw. LADS został zaprojektowany do szybkiego tworzenia aplikacji. shaders) systemu LADS.1. ) flaga jest ustawiona. Aplikacja Interfejs API Geometry Repository System Services Modul 3 LightWorks Diagram 5-8 Architektura systemu LADS Modul n 73 . Edytor drzew cieniowania używa tego systemu w połączeniu z biblioteką TexLib do wizualizacji drzew cieniowania. 2. Integracja systemu LADS z biblioteką TexLib. Rendering z wykorzystaniem renderera LADS z poziomu Edytora. że drzewo cieniowania zawiera cykl. System do renderingu fotorealistycznego LightWorks LADS (LightWorks Application Development System) jest pakietem wspomagającym budowę aplikacji wykorzystujących grafikę trójwymiarową. Wiąże się ona z obsługą drzew cieniowania oraz wykorzystaniem danych dostarczanych przez kontekst wyjściowy biblioteki na poziomie procedur cieniujących (ang. wizualizacja obrazów obliczonych przez pakiet. 5. Integracja z pakietem LADS do renderingu fotorealistycznego Integracja aplikacji Edytora z LADS posiada wiele aspektów. to oznacza to. Obsługa odpowiednich funkcjonalności LADS z poziomu interfejsu Edytora. które zawiera OutContext biblioteki TexLib. 1.7.. w których zachodzi potrzeba wykorzystania technik grafiki trójwymiarowej. Dostarcza też wszystkich parametrów InContext tej biblioteki.. umożliwia modyfikację wszystkich parametrów.jednej z funkcji Evaluate. 5. Drugi aspekt integracji z pakietem LADS jest mniej ciekawy z punktu widzenia grafiki trójwymiarowej i tekstur proceduralnych.3. Architektura systemu jest przedstawiona na Diagram 5-8.

Istnieją dwa podstawowe moduły systemu wykorzystywane przez większość pozostałych. Jego miejsce w procesie renderingu pokazuje Diagram 5-9. Większość modułów jest zależna od innych. radiosity).Jak widać. które powierzchnie są w danym pikselu widoczne. struktura systemu LADS opiera się na modułach. Dla wszystkich tych rodzajów dla tego samego piksela kontekst jest taki sam. alokowanie pamięci – moduł System Services) oraz przechowywaniem geometrii (moduł Geometry Repository). a komunikacja aplikacji z systemem oraz modułów między sobą odbywa się za pomocą interfejsu będącego zbiorem funkcji API. tif. Korzystają one z modułu określania widoczności określając. moduł cieniujący określanie widoczności (visibility processor) funkcja cieniująca cieniowanie (shading) funkcja cieniująca Diagram 5-9 Architektura procesu renderingu w systemie LADS Funkcje cieniujące należą właśnie do modułu teksturowania. opcjonalnych modułów. który zajmuje się odczytywaniem scen z przykładową geometrią • moduł zajmujący się określaniem widoczności geometrii • moduł cieniowania • moduł udostępniający interfejs do tworzenia tekstur proceduralnych. Są one odpowiedzialne za udostępnianie funkcjonalności związanych z konkretnym systemem operacyjnym (np. Istnieje kilka rodzajów funkcji cieniujących. raytracing. tga oraz bmp • Command Interpreter Module. Algorytm cieniowania jest realizowany przez procedury z modułu cieniowania. jednak różnią się one dostępem do globalnych zmiennych go reprezentujących. 74 . Dla każdego piksela tworzony jest następnie przez procedury modułu cieniowania odpowiedni kontekst wywołania funkcji cieniujących. Rolę kluczowych dla naszych zastosowań rodzajów funkcji przedstawia Tabela 5-13. W konfiguracji systemu używanej wraz z Edytorem występują dodatkowo następujące moduły: • drivery służące do wyświetlania renderowanych obrazów w okienku systemu Windows oraz umożliwiające zapis obrazów na dysk w formatach jpg. Moduł określania widoczności realizuje w ten sposób jeden z kilku wbudowanych algorytmów renderingu (scanline. Spośród wszystkich wymienionych modułów nas najbardziej interesuje moduł interfejsu tekstur proceduralnych. które odpowiedzialne są za określenie różnych właściwości powierzchni.

aby funkcja mogła zainicjować swoje zmienne zależne tylko od parametrów. które nie zmieniają się w trakcie procesu renderingu. dla każdej próbki wywoływane są funkcje preview lub full shaderów. że proces ten może być wykonywany dla jednego piksela obrazu kilkakrotnie dla różnych powierzchni. Jest ona odpowiednikiem inicjalizacji drzewa cieniowania w bibliotece TexLib.Typ funkcji cieniującej (ang. Określa widoczność oraz przezroczystość płaszczyzny. Rendering kończy się wywołaniem dla każdego z shaderów funkcji unload. Element ten jest jednak najbardziej nas interesującą częścią produkcji obrazu przez system LightWorks. Modyfikuje normalną do powierzchni symulując w ten sposób jej nierówności. Należy pamiętać o tym. zależnie od trybu tworzenia obrazu. że właśnie tutaj następuje integracja funkcjonalności biblioteki TexLib z systemem do renderingu. Nie jest to więc algorytm modułu cieniowania a jedynie jego element. Tabela 5-13 Typy funkcji cieniujących modułu cieniowania systemu LADS Dokładny przebieg procesu określania własności powierzchni jest przedstawiony na Diagram 5-10. Wynika to z tego. 75 . Przestrzeń tekstury Shader DISPLACEMENT Shader TRANSPARENCY Światła Shader COLOUR Model oświetlenia Postprocessing Diagram 5-10 Przebieg procesu ewaluacji własności powierzchni w systemie LADS Każdy shader posiada funkcję uniforms. która jest wołana przed rozpoczęciem renderingu po to. shader) Opis COLOUR TRANSPARENCY DISPLACEMENT Określa kolor cieniowanej płaszczyzny. W czasie procesu renderingu .

W systemie LightWorks występuje pojęcie materiału. inaczej dopiero w TRANSPARENCY lub COLOUR.5. } } function preview/full { if ( jest to pierwszy shader w procesie renderingu DISPLACEMENT->TRANSPARENCY->COLOUR ) { ustaw kontekst wejściowy drzewa ‘tree’ { 76 . [. ponieważ DISPLACEMENT nie będzie istniał w materiale).h” //plik nagłówkowy interfejsu biblioteki TexLib shader DISPLACEMENT/TRANSPARENCY/COLOUR { function uniforms { if (istnieje już ‘tree’) pobierz istniejące drzewo ‘tree’ else { //wczytaj drzewo cieniowania z pliku tree = TCShadeTreeCreate(kontekst_wej. czy drzewo cieniowania normalną N czy też nie (jeśli tak. TRANSPARENCY i DISPLACEMENT) biorące udział w procesie cieniowania przedstawionym na Diagram 5-10. Obsługa biblioteki TexLib jest w każdym z nich zależna od tego w jakim momencie procesu cieniowania jest on używany oraz jakie inne shadery są wykorzystywane. Wykorzystanie biblioteki TexLib w procesie cieniowania systemu LightWorks Drzewa cieniowania TexLib mogą modyfikować jedną. //jeśli operacja się udała – zainicjuj drzewo if (tree) TCShadeTreeInitialise(tree). w procesie cieniowania LightWorks wykorzystywane są różne shadery. kontekst_wyj). nazwa_pliku). Tak więc na przykład to. Algorytm działania znajduje na Program 5-6 (program jest przykładem użycia interfejsu biblioteki TexLib).. Edytor tworzy materiał zawierający odpowiednie rodzaje shaderów. kilka.7. w którym momencie tworzone i niszczone jest drzewo cieniowania zależy od tego. jakie parametry są kontrolowane przez aktualne drzewo cieniowania.2. W zależności od tego. jeśli drzewo cieniowania modyfikuje parametr kontekstu wyjściowego C • shader typu TRANSPARENCY jeśli drzewo modyfikuje parametry T i/lub alpha • shader typu DISPLACEMENT jeśli drzewo modyfikuje parametr N lub P Na potrzeby Edytora zdefiniowano specjalne shadery każdego z tych 3 typów. W zależności od tego jakie własności są rzeczywiście modyfikowane (odpowiednia funkcja interfejsu biblioteki pozwala się tego dowiedzieć).] #include „TexLib/CInterf.. to drzewo musi być utworzone w shaderze DISPLACEMENT. Mogą być w nim zawarte wszystkie rodzaje funkcji (między innymi COLOUR. lub nie modyfikować żadnej z własności powierzchni. Są to: • shader typu COLOR. Materiał jest zbiorem shaderów. TCShadeTreeLoad(tree.

} function unload { //skasuj wykorzystane drzewo if (drzewo ‘tree’ nie skasowane) TCShadeTreeDeleteDestroy(tree). Zakładamy. } break. N). Przykładowa implementacja shadera LADS wykorzystującego TexLib Program 5-7 zawiera przykładową definicję shadera typu COLOUR wykorzystującego kolor obliczony przez odpowiednie drzewo cieniowania TexLib. outN) TCShadeTreeOutCxGetVector(tree. C/N/P/I/s/t/…) zaznacz_globalnie_kontekst_jako_ustawiony_dla_tej_próbki. Jedynym parametrem shadera jest nazwa pliku zawierającego definicję drzewa cieniowania.P. case TRANSPARENCY: { if (TCShadeTreeOutCXModified(tree. inX. P). outT) TCShadeTreeOutCxGetColor(tree.s. outC.N.7.I. że drzewo wykorzystuje podstawowe wartości kontekstu wejściowego oraz modyfikuję wartość C kontekstu wyjściowego. } break. outN.3. alpha). case COLOUR: { TCShadeTreeOutCxGetColor(tree. } break..} // ustaw C. out_alpha) TCShadeTreeOutCxGetColor(tree. } //zdeaktualizuj kontekst wejściowy drzewa TCShadeTreeInvalidateAll(tree).h" //nagłówek systemu LADS //nagłówek zawierajacy f-cje interfejsu TexLib //deklaracja shadera typu COLOUR colour shader "texlib sample" 77 . T). } } [. else TCShadeTreeOutCxGetPoint(tree. out_alpha. if (TCShadeTreeOutCXModified(tree. C).. //pobierz wyniki switch (rodzaj_tego_shadera) { case DISPLACEMENT: { if (TCShadeTreeOutCxModified(tree.h" #include "texlib/cinterf. TRANSPARENCY oraz COLOUR używających biblioteki TexLib 5. outP. inX) TCShadeTreeInCxSetXXX(tree. outT. #include "li/lishader.t oraz sample jeśli używane w drzewie: if (TCShadeTreeInCxUsed(tree.] Program 5-6 Algorytm działania shaderów DISPLACEMENT.

&outcx). //wczytanie definicji drzewa z pliku o podanej nazwie TCShadeTreeLoad(tree. inI. //ustawnie wartości kontekstu wejściowego. P. PINCX incx. TCShadeTreeInCxSetFloat ( tree. in_s. TCShadeTreeInCxSetPoint ( tree.. } uniforms function //funkcja wywoływana przed każdym renderingiem { //kasujemy drzewo cieniowania. I. Co). } //funkcja wywoływana po stworzeniu obiektu shadera load function { 78 . //zainicjowanie drzewa cieniowania TCShadeTreeInitialise(tree). koordynaty tekstury TCShadeTreeInCxSetVector( tree. TCShadeTreeInCxSetFloat ( tree. są zdefiniowanie w cinterf. TCShadeTreeInCxSetVector( tree. inN.. I ). które zostało stworzone przed poprzednim //renderingiem if ( tree notequal NULL ) TCShadeTreeDestroy(tree). outC. //funkcja wywoływana podczas niszczenia obiektu //shadera w systemie LADS } unload function { } if ( tree notequal NULL ) { TCShadeTreeDestroy(tree).h //zmienne N. s ). //utworzenie nowego drzewa cieniowania tree = TCShadeTreeCreate(&incx. s.//deklaracja parametru shadera z nazwą pliku z drzewem cieniowania parameter "file name" LtString p_filename = "" . które pozostaną stałe //w czasie tego renderingu. tree = NULL. //zmienna przechowująca obiekt drzewa cieniowania //obiekt kontekstu wejściowego drzewa cieniowania //obiekt kontekstu wyjściowego drzewa cieniowania shader function //funkcja definiująca kolor powierzchni { //ustawienie parametrów kontekstu wejściowego //wartości in. PTREE tree. t są zmiennymi globalnymi shadera i zawierają //wartości odpowiednio normalną. w tym przypadku wartość czasu TCShadeTreeInCxSetFloat(tree. POUTCX outcx. kierunek promienia //kolidujacego z płaszczyzną. P ). in_t. wsp. inP. 0). //kontekst został zmieniony – należy o tym poinformować bibliotekę TCShadeTreeInvalidateAll(tree). p_filename). //pobranie wartości wyjściowej drzewa – koloru powierzchni TCShadeTreeOutCxGetColor(tree. punktu. N ). in_time. t ).

lib oraz pliki *.lib systemu LADS. Wykonanie renderingu po przypisaniu shadera do obiektów na scenie spowoduje wykonanie funkcji uniforms wczytującej drzewo oraz funkcji shader dla każdej cieniowanej próbki. 79 .tree (patrz Dodatek B) zawierającego definicję drzewa cieniowania. należy stworzyć jego instancję i podać nazwę pliku *. Po zainicjowaniu shadera w tworzonej aplikacji. } Program 5-7 Przykładowa imlementacja shadera LADS wykorzystującego TexLib Kompilacja shadera wymaga użycia narzędzia dostarczanego z systemem oraz dostepności wszystkich wymaganych nagłówków (między innymi nagłówka cinterf. Do konsolidacji niezbędny jest plik biblioteki texlib.tree = NULL.h zawierającego deklaracje biblioteki TexLib).

• Losowe dobieranie wybranych parametrów z pewnego ustalonego zakresu. • Możliwość renderingu animacji o dowolnej ilości klatek. 3. w dowolnej rozdzielczości. Stało się tak między innymi dzięki wbudowanemu systemowi półautomatycznego doboru parametrów oraz możliwości szybkiego podglądu wyników (za naciśnięciem jednego klawisza). Wizualizacja działania drzew cieniowania • Możliwość szybkiego podglądu działania drzewa. Prezentuje wizualnie strukturę tekstur proceduralnych w przejrzysty i prosty sposób. 2. przez co pozwala na pracę z wieloma teksturami jednocześnie umożliwiając łatwe porównywanie efektów działania kilku algorytmów.1. *.lwc. maksymalna.6. Poniżej znajduje się zestawienie możliwości Edytora podzielone na kilka kategorii. Konstrukcja drzew cieniowania • Wizualizacja struktury drzew w postaci diagramów • Łatwe wstawianie nowych wzorów i wartości za pomocą odpowiednich okienek dialogowych. Edytor drzew cieniowania Ten rozdział przedstawia system działający w oparciu o graficzny interfejs użytkownika umożliwiający prostą i szybką edycję drzew cieniowania (zwany dalej w tekście Edytorem) oraz ich rendering z wykorzystaniem systemu do renderingu LADS. Każdy z parametrów wzorów wchodzących w skład drzewa cieniowania posiada elementy interfejsu użytkownika pozwalające na jego łatwą zmianę oraz łatwo dostępny opis zastosowania. Aplikacja okazała się w trakcie badań wspaniałym i bardzo użytecznym narzędziem do poszukiwania nowych wzorów proceduralnych. 6. końca oraz skoku między kolejnymi klatkami (obsługa wartości ‘time’ w kontekście wejściowym biblioteki). • Zawsze widoczne opisy każdego z parametrów wzorów. • Statystyki każdego z parametrów wyjściowych (wartości minimalna. • Tworzenie połączeń między parametrami wzorów i wartościami z użyciem technologii drag & drop. • Obsługa i wizualizacja wszystkich parametrów znajdujących się w kontekście wyjściowych TexLib. ustalenia czasu startu. wybór koloru za pomocą standardowego okienka wyboru koloru Windows). przy użyciu kilku trybów dostępnych w systemie LightWorks oraz przy zastosowaniu dowolnej sceny zdefiniowanej w formacie *. Edycja wartości parametrów • Dobór wartości ułatwiony za pomocą GUI (np. 1. • Eksport do plików *. odchylenie standardowe i inne). średnia. • Przeszukiwanie pewnej domeny parametrów (od pewnej ustalonej wartości do wartości końcowej.jpg. z zadaną rozdzielczością).tiff (animacje mogą być eksportowane do automatycznie numerowanych plików) 80 . Edytor jest aplikacją typu MDI (MultiDocument Interface).tga oraz *. Funkcjonalność aplikacji Edytora Edytor realizuje założenie mówiące o łatwości obsługi tekstur proceduralnych.

Widok edytora diagramów drzew cieniowania. Lista w oknie Add Pattern zawiera identyfikatory wszystkich 81 .1. Dodawanie i usuwanie wzorów i wartości Edytor udostępnia dwa sposoby dodawania nowych wzorów i wartości. 6. Interfejs użytkownika Edytor jest aplikacją uruchamianą w systemie Windows i wykorzystuje standardowy interfejs graficzny użytkownika tego systemu. Tutaj odbywa się edycja drzew cieniowania.• Eksport plików *.tree dla każdej renderowanej klatki animacji (ważne jeśli renderujemy ciąg klatek z losowo dobieranymi parametrami). Rysunek 6-1 Widok ogólny Edytora drzew cieniowania Okno aplikacji jest podzielone na 3 części: 1. Tutaj wyświetlane są szczegółowe informacje dla aktualnie zaznaczonego w oknie 2 wzoru. Pierwszy polega na użyciu menu kontekstowego. Po kliknięciu prawym przyciskiem myszy w oknie edytora diagramu pojawi się menu jak na Rysunek 6-2. 3. Istnieje oddzielne okno dla każdego otwartego dokumentu.2. Ogólny widok aplikacji jest przedstawiony na Rysunek 6-1. 2. Rysunek 6-2 Menu kontekstowe dodawania wzorów i wartości Alternatywną drogą jest wybranie z menu aplikacji pozycji Add. Widok właściwości wzoru. W obydwu przypadkach wybranie Add Pattern doprowadzi nas do okna dialogowego widocznego na Rysunek 6-3. 6.2. Standardowe menu oraz pasek narzędzi aplikacji typu Multi Document Interface.

dostępnych wzorów – standardowo wbudowanych w bibliotekę oraz dodatkowych, zdefiniowanych w bibliotekach DLL.

Rysunek 6-3 Okienko dialogowe dodawania nowego wzoru

Wybranie jednej z pozycji i naciśnięcie OK. spowoduje umieszczenie w edytorze diagramów w miejscu kursora myszki symbolu dodanego wzoru. Wybranie opcji Add Value spowoduje ukazanie się okienka Add new value (Rysunek 6-4), gdzie z listy typu ComboBox możemy wybrać typ nowej wartości a w okienku edycyjnym Properties wpisać własności. Dla podanego na rysunku przykładu Properties powinno zawierać trzy oddzielone spacjami wartości zmiennoprzecinkowe z zakresu [0..1]. Formaty dla innych typów zawiera Tabela 6-1.

Rysunek 6-4 Okienko dialogowe dodawania nowej wartości stałej

Typ
Int Float Color Point Vector FloatArray

Format tekstowy w okienku Properties Liczba całkowita, Przykład: „-1” Liczba zmiennoprzecinkowa, Przykład: „0.5” 3 liczby zmiennoprzecinkowe oddzielone spacjami, Przykład „.2 .9 .4” Jak Color Jak Color Seria liczb zmiennoprzecinkowych poprzedzona liczbą naturalną, oddzielone jedną lub więcej spacjami. Pierwsza liczba określa rozmiar 82

tablicy, następne są jej elementami. Jeśli liczba elementów jest mniejsza od zadeklarowanego rozmiaru, to pozostałe elementy są inicjowane zerami. Przykład: ”3 .2 4.5 -2.25” – trójelementowa tablica Seria trójek liczb zmiennoprzecinkowych poprzedzona liczbą naturalną, oddzielone jedną lub więcej spacjami. Pierwsza liczba określa rozmiar tablicy, każda następująca trójka liczb określa kolejny kolor. Podobnie jak w przypadku FloatArray, elementy nie podane są inicjowane zerami (kolorem czarnym w przypadku, gdy brakuje jakiejś trójki). Przykład: ”2 0 0 0 1 1 1” – kolor czarny i biały

ColorArray

Tabela 6-1 Format tekstowy wartości typów w bibliotece TexLib

Okienko Add Value zawiera nieaktywny przycisk Properties. Aktywuje się on po otworzeniu tego samego dialogu za pomocą podwójnego kliknięcia na już stworzonej wartości. W tym przypadku umożliwia on, zależnie od typu wartości, ustawienie jej parametrów. Dla wartości typu Color przycisk Properties otwiera standardowe w Windows okno wyboru kolorów (Rysunek 6-5).

Rysunek 6-5 Właściwości wartości stałych

W przypadku innych typów (Int, Float, Point, Vector, FloatArray, ColorArray) Properties pozwala na ustawienie parametrów randomizacji. Randomizacja polega na losowym dobraniu wartości przed rozpoczęciem renderingu. Dialog Value Properties pozwlaa na ustalenie zakresu losowania oraz, w przypadku tablic, minimalnej i maksymalnej ilości elementów (Rysunek 6-6). Randomizacja jest szczególnie użyteczna podczas renderingu zestawu obrazków (animacji).

83

Rysunek 6-6 Właściwości wartości stałych związane z losowością (właściwości wartości typu FloatArray).

6.2.2. Tworzenie połączeń między wzorami
Tworzenie powiązań pomiędzy parametrami wzorów odbywa się w oknie edytora diagramów. Aby zrealizować połączenie między parametrem pewnego wzoru a wyjściem innego wzoru należy: • Kliknąć prawym przyciskiem myszy na wzorze, którego parametr wejściowy chcemy połączyć z innym. Pojawi się menu kontekstowe (Rysunek 6-7) w którym poniżej pozycji INPUTS: znajduje się lista parametrów wejściowych. Wybieramy jeden z nich. • Za wskaźnikiem myszy zacznie podążać linia o początku w symbolu wzoru. • Kliknąć lewym przyciskiem myszy na wzorze, którego parametr wyjściowy chcemy wykorzystać lub na wartości stałej. W pierwszym przypadku (Rysunek 6-8) menu kontekstowe zawierać będzie pozycję OUTPUTS: oraz następującą po niej listę parametrów wyjściowych wraz z opisem typu każdego z nich. Wybieramy jeden z parametrów, przy czym jego typ musi być taki sam jak typ parametru wejściowego wybranego w poprzednim kroku. Jeśli typy nie będą zgodne, Edytor wyświetli odpowiednią informację, a proces tworzenia połączenie nie powiedzie się.

84

że operacja powiodła się.Rysunek 6-7 Proces tworzenia połączenia między parametrami – wybieranie parametru wejściowego Po tych operacjach na diagramie pojawi się linia łączące wybrane wzory (lub wzór i wartość stałą). co oznacza. opisana nazwami połączonych parametrów. Rysunek 6-8 Proces tworzenia połączenia między parametrami – wybieranie parametru wyjściowego 85 .

. jest tutaj lista wszystkich parametrów z podanym typem a po Rysunek 6-9 Widok właściwości wzorów.. a właściwie parametrów wejściowych wzorów. o średnia („avg”).3. 2-parametry wyjściowe poniżej dostajemy szczegółowy opis.. liczona jako wartosci avg = ∑ n n o odchylenie standardowe („stdDev”)..2. tekst „No description”). mówiącej o przyjmowanym zakresie parametrów.6. Część oznaczona jako 2 opisuje parametry wyjściowe. które wykorzystują ten parametr) • zależnie od typu parametru. zależnie od parametru • powtórzonej informacji o źródle danych • wartości domyślnej („DEFAULT:. Podobnie jak wyżej. zależnie od potrzeby • liczbę użytkowników tego parametru (czyli innych wzorów. liczone jako stdDev = n∑ ( wartosci2 ) − (∑ wartosci ) 2 n(n − 1) 86 . Część oznaczona jako 1 opisuje parametry wejściowe. Dla każdego parametru zaznaczony jest jego typ oraz źródło wartości: • DEFAULT: jeśli parametr używa swojej domyślnej wartości • CONSTANT: jeśli parametr używa wartości stałej (jest połączony z wartością w drzewie cieniowania) • X of NAME: jeśli używa parametru wyjściowego X wzoru o nazwie NAME Po wybraniu dowolnego parametru z listy (podświetleniu) poniżej pojawia się szczegółowy opis w postaci: • tekstowej informacji (na rysunku . W przypadku parametrów wyjściowych opis zawiera: • informację tekstową o parametrze – opis produkowanych wartości. o wartość maksymalna („max”). ich znaczeniu itp. 1zaznaczeniu konkretnego parametru w okienku parametry wejściowe..”). Właściwości wzorów Część okna roboczego oznaczona jako 3 na Rysunek 6-1 pokazuje wszystkie parametry wybranego wzoru oraz ich właściwości. wyświetlane są także statystyki z ostatniego renderingu: o wartość minimalna („min”). Rysunek 6-9 przedstawia właściwości przykładowego wzoru Checker. możliwych zastosowań itp..

87 .lwc z opisem geometrii (wszystkie sceny znajdują się w podkatalogu Scenes katalogu z którego uruchomiony został Edytor). jak wiele pikseli jest zajętych przez powierzchnię. o ilość obliczeń parametru („sets”).4. po wybraniu której ukazuje się okno z ustawieniami sceny (Rysunek 6-11). Należy zauważyć. w którym płaszczyzna ma kolor niezależny od oświetlenia. Dostępne są opcje „plastic” – model oświetlenia typu plastik. zależy od rozdzielczości obrazu oraz tego.2. że liczba ta może się różnić (i zwykle różni się) dla różnych systemów renderujących. 6. założenia. które mogą wymuszać ewaluację wzoru więcej niż jeden raz na piksel. W praktyce jest przydatne do ustawiania wartości progowych wyboru koloru dla wzoru Interpolator3D. Opcje renderingu są dostępne po wybraniu z menu Render pozycji Parameters (Rysunek 6-12).Odchylenie standardowe opisuje to. Rendering Edytor pozwala na rendering dowolnej sceny zapisanej w formacie *..lwc systemu LADS spełniającej opisane w punkcie . Po zaznaczeniu sceny w okienu na prawo pojawi się podgląd. Można tutaj także wybrać scenę *.. oraz „constant” – model. jak szeroko wartości są rozproszone od wartości średniej. Jest to w praktyce liczba ewaluacji wzoru do którego należy parametr. w którym materiał przeznaczony do użycia z drzewem cieniowania ma nałożony wzór trójwymiarowej czerwono-zielonej kratki. ponieważ niektóre z nich używają technik nadpróbkowania lub innych podobnych technik wygładzania tekstur (antialiasingu). której parametry są opisywane danych drzewem cieniowania. który będzie używał drzewo cieniowania aktywnego dokumentu. Menu Scene zawiera pozycję Parameters (Rysunek 6-10). Rysunek 6-10 Menu parametrów sceny Rysunek 6-11 Okienko dialogowe z ustawieniami parametrów sceny Dialog ten pozwala na wybranie modelu oświetlenia dla materiału.

Render animation przełącza tryb renderingu animacji. który posłużył do jego generacji. Jest to szczególnie przydatne przy renderingu z losowymi parametrami.TREE jest jedynym źródłem informacji na temat wartości parametrów który zostały zastosowane. Okienka edycyjne Start time. Pozostawienie okienka FileName pustego lub wpisanie tam błędnego katalogu spowoduje.. jeśli ma być zapisany na dysku. Sekcja Animation opisuje sposób renderowania animacji. FULL oraz RTFULL. Sekcja Output to file określa nazwę pliku oraz format obrazka. że obraz nie zostanie zapisany. Jeśli renderujemy wiele obrazów. Obrazki są zapisywane na dysk z nazwami podanymi w oknie 88 .Rysunek 6-12 Menu renderingu Okno dialogowe Rendering Settings zawiera szereg opcji dotyczących formatu obrazka.. to odpowiedni plik *. końca oraz rozdzielczość czasową renderingu kolejnych klatek. Opcja Write tree file always oznacza zapisywanie razem z obrazkiem pliku *. Czas jest podczas tworzenia kolejnych klatek animacji dostarczany do kontekstu wejściowego drzewa w parametrze time. Rysunek 6-13 Okienko dialogowe z parametrami renderingu Sekcja Output zawiera rozmiar obrazka (rozmiar może być dowolną liczbą naturalną nie większą niż 4096) oraz tryb renderingu. formatu zapisu na dysk oraz animacji (Rysunek 6-13). Ich opis można znaleźć w punkcie.TREE . Dostępne są 3 tryby renderingu wykorzystywane przedz LightWorks: PREVIEW. End time oraz Step określają odpowiednio czas startu.

lecz 2 typach: ST i TREE. Serializacja drzew cieniowania Edytor odczytuje i zapisuje pliki w formacie ST (ang.FileName z przyrostkiem będącym kolejnym numerem klatki. Rysunek 6-14 Wizualizacja postępu procesu renderingu Rendering rozpoczyna wybranie z menu opcji Render/Render. Zaimportowany diagram nie będzie posiadał poprawnego formatowania (tzn. ale w trakcie procesu korzysta z odpowiadającego mu TREE. Wybranie opcji Save.2. 6. 6. Dodatkowe informacje związane z interfejsem użytkownika oraz konfiguracją Edytora są zapisywane w plikach ST. test0002. Pliki typu TREE zawierają opis drzewa cieniowania i są serializowane (zapisywane i odczytywane) przez bibliotekę. Widok ekrany w czasie procesu renderingu przedstawia Rysunek 6-14.3. Dla przykładu z Rysunek 6-13 powstałyby pliki test0001. Pliki te dodatkowo zawierają odwołanie do definicji drzewa cieniowania – czyli pliku TREE. bądź Save As z menu File powoduje więc utworzenie 2 plików o tej samej nazwie. naciśnięcie kombinacji Ctrl+R lub naciśnięcie przycisku Render.jpg itd. symbole wzorów nie będą poprawnie rozłożone na ekranie). Pliki te znajdują się w tym samym katalogu i są potrzebne w trakcie odczytywania. Edytor odczytuje pliki typu ST. Wybrane szczegóły implementacyjne Poniżej opisane zostały niektóre z aspektów integracji Edytora z systemem LADS.5. 89 . w oknie Rendering settings. Edytor umożliwia ponadto import drzew bezpośrednio z pliku TREE po wybraniu opcji File/Import from TREE..jpg. shade tree) oraz TREE.

Plik sceny *.3. symulujące realne warunki renderingu i używane dalej do testów wydajności biblioteki (patrz Rozdział 7). 6.6. System LADS udostępnia kilka trybów renderingu. przez to interfejs użytkownika jest cały czas aktywny. 3. bez antialiasingu. Umożliwiało to dodanie opcji przerwania renderingu w jego trakcie.1). Drzewo cieniowania zostanie wykorzystane do renderingu tej właśnie geometrii. Scena musi definiować materiał matShadeTree. którą wybierze użytkownik. Aktywacją/deaktywacją świateł na scenie steruje Edytor. w którym używany jest wbudowany raytracer. Scena musi opisywać listę obiektów geometrii o ustalonej nazwie primList (od ang. Będzie także posiadał model oświetlenia zdefiniowany przez użytkownika Edytora (patrz punkt 6. 90 . Istnieją też sceny o bardzo skomplikowanej geometrii (100 tysięcy trójkątów). Materiał ten będzie wykorzystywał aktywne drzewo cieniowania i będzie przypisany do geometrii primList. Edytor korzysta z jednego z tych trybów zależnie od opcji.lwc zawiera ciąg wywołań funkcji API systemu. która powiadamia go w odpowiednim momencie o chęci przerwania renderingu.1. primitive). Sceny wykorzystywane wraz z Edytorem muszą spełniać pewne specjalne wymagania: 1. Scena musi definiować listę świateł o ustalonej nazwie lightList. w tym: • PREVIEW – szybki tryb renderingu scanline. Rendering Rendering sceny jest wykonywany w oddzielnym wątku. • FULL – tryb z antialiasingiem analitycznym • RTFULL – tryb. Wszystkie pliki opisujące sceny muszą znajdować się w podkatalogu Scenes Edytora. Scena musi definiować widok o nazwie camera. 4. Podczas inicjacji są stamtąd odczytywane a ich nazwy umieszczane w odpowiednim okienku dialogowym umożliwiającym potem ich wybór.3. Wzory TexLib nie używają antialiasingu analitycznego. 2. Zdefiniowano kilka podstawowych scen zawierających prostą geometrię. Opis scen trójwymiarowych Sceny są opisane w formacie LWC systemu LADS. Od strony systemu LADS użyty został mechanizm call-back (wykorzystywany w tym systemie nader często) – LADS woła co jakiś określony czas funkcję callback Edytora.2. metodą antialiasngu jest tutaj nadpróbkowanie.

Ocenę przeprowadzono na podstawie opisanych w punkcie 2. • jakość obrazu.2. • porównanie ze zjawiskami występującymi w naturze. Cel i zakres ekperymentów Celem badań eksperymentalnych była ocena możliwości oraz zaimplementowanych algorytmów w dziedzinie symulacji naturalnych powierzchni. Ocena łatwości użycia jest. Każde z nich zostało opisane pod kątem sposobu wykorzystania zaimplementowanych algorytmów (topologii drzew) oraz dziedziny symulowanych zjawisk. 7.4 parametrów: • wydajność algorytmów (czasowa i pamięciowa). W ramach analizy osiągniętych rezultatów przedstawiono wyniki czasowe oraz porównanie wygenerowanych obrazów z fotografiami lub obrazami uzyskanymi innymi metodami grafiki komputerowej. Obrazy przedstawiające stosunkowo złożone sceny posłużyły także do oceny jakości rozumianej jako ocena ilości zniekształceń wynikających z uproszczeń bądź niedokładności symulacji. wraz z jego schematem (uproszczonym w razie potrzeby) • nazwę pliku źródłowego z definicją drzewa cieniowania 91 . Wybrane obrazy posłużyły dalej do porównań z fotografiami rzeczywistych zjawisk bądź z najlepszymi ze znanych symulacji stworzonych za pomocą innych metod grafiki komputerowej. Badania eksperymentalne Ten rozdział zawiera opis zakresu przeprowadzonych eksperymentów. Przedstawione zostały także przykładowe obrazy stworzone przy użyciu opisanego w Rozdziale 6 Edytora. • łatwość użycia. subiektywna. Symulacje zjawisk występujących w naturze W tym punkcie zebrane zostały najciekawsze wyniki eksperymentów mających na celu stworzenie jak najbardziej realnie wyglądających symulacji.1. zestawienie oraz analizę ich wyników. 7. i została opracowana na podstawie doświadczeń zebranych w trakcie przeprowadzania eksperymentów. Testy wydajnościowe zostały przeprowadzone przy użyciu kilku różnych zestawów obiektów symulujących zmienne warunki wykorzystania biblioteki. wydajności W ramach badań stworzonych zostało szereg drzew cieniowania symulujących przykładowe zjawiska opisane w punkcie 3. podobnie jak ocena jakości obrazu. za pomocą którego został stworzony. Każdy z prezentowanych wzorów posiada: • kilka obrazów przedstawiających go w praktycznym wykorzystaniu • opis dziedziny realizowanych symulacji • opis drzewa cieniowania. W skład zestawienia wyników wchodzą kolorowe fotorealistyczne obrazy oraz opis metody ich uzyskania i sposobów ulepszenia.7.1.

który został przekazany funkcji Interpolate3D. Skóra salamandry [SALAMANDRA. które symulują wygląd skóry salamandry plamistej.7.1. Interpolate3D zwraca kolor zależny od przekazanej wartości.TREE] Wzór przypominający skórę salamandry plamistej. Ustalone zostały 4 kolory.2. Drzewo cieniowania Do utworzenia wzoru wykorzystany został iloczyn jednowymiarowych wyników funkcji NoiseWorley. Wykorzystanie praktyczne 92 .

Obydwa interpolatory pobierają jako parametry wyniki funkcji NoiseWorley. Cienie kaustyczne [CAUSTICS. Drzewo cieniowania Wzór powstaje z sumowania 2 warstw kolorów (funkcja Add) pochodzących z interpolatorów kolorów (Interpolator3D).7. że wzór ten daje się łatwo animować.2. Jest to zabieg często stosowany przy wzorach składanych z kilku warstw.TREE] Wzór symulujący cienie kaustyczne często widoczne na dnie basenu. Efekt ten uzyskuje się przesuwając punkt cieniowania z klatki na klatkę za pomocą następującej konstrukcji: 93 . Ciekawostką jest to.2. Jedna z nich jest także obliczana na podstawie punktu P zniekształcanego wcześniej za pomocą szumu (NoisePerlin). druga jest obliczana na podstawie pewnej kombinacji liniowej. przy czym jedna z nich jest wersją fraktalną.

Katalog Images/Water zawiera klatki takiej przykładowej animacji.Punkt P uzyskany z funkcji TransformSample można dalej przekazywać tak. Wykorzystanie praktyczne 94 . jak do tej pory robiliśmy to z P pochodzącym bezpośrednio z kontekstu wejściowego. Efekt animacji jest bardzo realistyczny.

95 . Wynik funkcji Leather jest interpretowany jako wysokość (i przekazywany do funkcji CalculateNormal) lub jako współczynnik. Skóra wyprawiona [LEATHER.3.TREE] Wzór symulujący kolor oraz fakturę powierzchni wyprawionej skóry zwierzęcej.7. Drzewo cieniowania Całość symulacji zawarta jest w funkcji bazowej Leather. Wykorzystuje ona NoiseWorley oraz NoisePerlin tworząc kilka warstw zniekształceń. na podstawie którego Interpolator3D ustala kolor.2.

Wykorzystanie praktyczne 96 .

Pierwsza (wewnętrzna jeśli zinterpretować diagram używając zapisu matematycznego) zwracająca wartości trójwymiarowe służy wstępnemu podziałowi przestrzeni na komórki. Drzewo cieniowania Ten wzór składa się z 2 warstw: warstwa podstawowa.2. których kolor jest następnie ustalany przy użyciu kolejnej funkcji NoiseWorley • warstwa dodatkowa. który podnosi realizm obrazu Punkt P jest przed przekazaniem do jakichkolwiek innych funkcji zniekształcany w funkcji TransformSample. która wykorzystuje złożenie funkcji NoiseWorley. Jeszcze jedna funkcja NoiseWorley oraz odpowiadająca jej CalculateNormal realizuje odwzorowanie nierówności powierzchni.TREE] Wzór symulujący kolor oraz fakturę skóry węża. wprowadzająca szum.4.7. Skóra węża [SNAKE. • 97 .

Wykorzystanie praktyczne 98 .

7.2. 99 . Spękana ziemia [SOIL2.TREE] Wzór symulujący fakturę spękanej ziemi na dnie wyschniętego jeziora.5. Drzewo cieniowania Działanie tego drzewa cieniowania jest zbliżone do drzewa symulującego skórę salamandry.

które dobrze widoczne jest na poniższej ilustracji: 100 .TREE] Wzór przypominający fragmenty obrazów H.R.Giger’a [GIGER.R.2. Drzewo cieniowania Wzór jest tworzony za pomocą 2 fraktalnych jednowymiarowych funkcji NoiseWorley.Giger’a – autora między innymi scenografii do filmów serii Obcy.6. Twórczość H. Dodatkowo dodano odwzorowanie nierówności powierzchni.Wykorzystanie praktyczne 7. których wyniki są mnożone.

Wykorzystanie praktyczne 101 .

3. W celu oszacowania ilości czasu przeznaczonego przez system renderujący (w tym przypadku LADS) na cieniowanie z użyciem biblioteki TexLib. Dodatkowo. a kierunek patrzenia jest do niej prostopadły. Scena opt. optymistyczny i pośredni ze względu na rolę obliczeń przeprowadzanych wewnątrz TexLib. Materiał wykorzystujący badane drzewa cieniowania jest wykorzystywany tylko na ok. 30 trójkątach tworzących na środku sceny niewielkich rozmiarów sferę i pojawia się na 7% pikseli wynikowego obrazu. stosowany jest uproszczony model oświetlenia.7. którego materiał wykorzystuje jedno z drzew cieniowania TexLib.3. Ocena efektywności 7. kiedy stosunkowo mało obliczeń jest przeprowadzanych w bibliotece. Punkt obserwatora znajduje się nad nią. zajmuje 100% obrazu. Wszystkie materiały używają standardowego modelu oświetlenia typu plastic. 102 .1. Na scenie pes. 256MB pamięci operacyjnej i systemem WindowsXP Professional. układających się we fragment fraktalnego tetrahedronu. 100 tysięcy niezależnych trójkątów.lwc istnieje tylko 1 obiekt – złożona z 2 trójkątów płaszczyzna. który nie bierze pod uwagę żadnych świateł znajdujących się na scenie. że można je uznać za przypadki pesymistyczny. • Przypadek optymistyczny to taki. zastosowano 3 sceny oraz 3 różne drzewa cieniowania. W ten sposób płaszczyzna wypełnia całą powierzchnię obrazu. Konfiguracja scen została dobrana tak. Warunki eksperymentu Eksperymenty wydajnościowe zostały przeprowadzone przy użyciu komputera z procesorem Intel Pentium III Celeron 800MHz.lwc zawiera stosunkowo złożoną geometrię zawierającą ok. • W przypadku traktowanym jako pesymistyczny. obiekt.

a obiekt wykorzystujący w materiale TexLib zajmuje 10% obrazu wynikowego. Jednak nawet dla scen z prostą geometrią wpływ prędkości systemu renderującego ma istotne znaczenie. Cieniowanie w takim przypadku może być sprawą drugorzędną. Dla każdej ze scen został zmierzony czas renderingu bez wykorzystania TexLib. Ilość oraz rodzaj funkcji bazowych umieszczonych w drzewie cieniowania jest najważniejszym czynnikiem decydującym o prędkości uzyskania wyników dla większości scen.lwc jest sceną podobną do mid. normalną oraz przezroczystość powierzchni. • Używane wartości kontekstu wejściowego.tree – jak salamandra. że 52% pikseli wynikowego obrazu zawiera obiekt z materiałem wykorzystującym badane drzewo cieniowania.w.tree – bardziej złożony wzór złożony z 4 funkcji bazowych (w tym 2 stosunkowo wolne NoiseWorley) oraz 6 połączeń między nimi. Nie wykonuje żadnych dodatkowych obliczeń. który można uznać za pośredni.lwc. Kolejne pomiary dotyczą 6 różnych drzew cieniowania: • empty.tree – wzór kopiujący wartości C. • Ilość modyfikowanych atrybutów kontekstu wyjściowego.tree – j.• • Scena mid.. • Złożoność drzewa cieniowania. że wzór modyfikuje zarówno kolor jak i normalną do powierzchni. • salamandra. Koszt ewaluacji tego drzewa jest równy kosztowi zainicjowania oraz każdorazowej inicjacji kontekstu wejściowego dla wszystkich obliczanych próbek. Ewaluacja niektórych z tych atrybutów (których drzewo cieniowania i tak nie używa) może bowiem zająć niepotrzebnie czas. Scena mid2. Większość z systemów renderujących będzie się posługiwała oddzielną funkcją cieniującą (shaderem) dla modyfikacji każdego z atrybutów kontekstu wyjściowego. Może to wnieść dodatkowy koszt to procesu generacji. Znajduje się na niej umiarkowana ilość geometrii. • salamandra3. jakie atrybuty kontekstu wejściowego są wykorzystywane w drzewie i przekazywać bibliotece tylko te potrzebne. Czynniki wpływające na czas generowania obrazu Czynnikami mającymi największy wpływ na czas generacji obrazu są: • System renderujący. Dalsza analiza tego wpływu znajduje się w punkcie 7. z tą różnicą. że wzór modyfikuje kolor. Modyfikuje kolor powierzchni 7.2. która używa TexLib.tree. powinna brać pod uwagę to. T kontekstu wejściowego do kontekstu wyjściowego. 103 . Różni się od niej tym. • complex. Wzór modyfikuje tylko kolor powierzchni. • checker. Przy scenach zawierających skomplikowaną geometrię największa ilość obliczeń jest przeznaczana na przekształcenia geometryczne.tree – najbardziej skomplikowany wzór. Implementacja shadera konkretnego systemu renderującego.3. N.3. złożony z najbardziej wymagających algorytmów fraktalnych wersji NoiseWorley – FractalNoiseWorley. z tą różnicą. jako czas bazowy. Z oczywistych względów ma on duże znaczenie na generację obrazu.tree – prosty wzór trójwymiarowej kratki. Tutaj większość czasu procesora przypadająca na obliczenia cieniowania będzie przeznaczona na ewaluację 6 funkcji bazowych. do którego odnoszą się dalsze pomiary. • salamandra2.lwc reprezentuje przypadek. Największą ilość czasu zajmuje w tym przypadku komunikacja między biblioteką TexLib a systemem renderującym.3.

732 24.255 31.283 111.561 69. scena nazwa wzoru none empty checker salamandra salamandra2 salamandra3 complex none empty checker salamandra salamandra2 salamandra3 complex none empty checker salamandra salamandra2 salamandra3 complex none empty checker salamandra salamandra2 salamandra3 complex pomiary czasu* [s] 6.888 5.895 58.787 235.540 1.330 65. Tabele i wykresy pochodzą ze skoroszytu w formacie MS Excel znajdującego się w pliku Images\pomiary.3.176 25.622 1.787 120.150 1.3.lwc (przypadek pośredni) mid2.500 6. Uwzględniono wszystkie kombinacje scen i wzorów opisanych w punkcie 7.lwc (przypadek pesymistyczny) *) Wszystkie czasy zostały zmierzone przy użyciu wbudowanego zegara aplikacji Edytora drzew cieniowania.632 1.807 17.443 Teval [s] 0.922 2.952 0.392 19.863 2.148 1.990 11.296 24.818 opt.463 10.743 3.578 109.366 17.135 1.297 24.480 1.739 1.123 2.205 14.846 235.733 64.660 25.453 24.993 3.659 17.3.626 1.154 238.238 24.273 58.466 111.130 3. przy użyciu trybu renderingu PREVIEW systemu LADS (brak nadpróbkowania oraz antialiasingu geometrycznego wygładzającego artefakty na brzegach geometrii).895 60.000 0.040 120.623 1.lwc pes.200 średni czas T [s] 6.883 2.081 18.740 24.612 66.109 6.893 2.629 6.430 111.912 1.804 17.600 1.233 234.960 11.183 7.440 31. 104 .852 14.944 65.976 236.153 7.000 0.711 1.289 6.742 3.801 1. Obrazy wyrenderowane zostały w rozdzielczości 800x600.860 111.lwc (przypadek optymistyczny) mid.993 22.074 1. Rezultaty liczbowe Tabela 7-1 zawiera wyniki pomiarów czasów renderingu dla różnych konfiguracji scen oraz drzew cieniowania.000 0.892 2.794 13.350 7.437 5.541 15.033 235.879 2.732 1.922 0.335 0.189 6.733 24.950 31.863 1.144 0.300 11.540 235.763 1.162 234.180 24.762 3.659 237.193 7.029 3.394 111.963 3.196 6.176 7.277 24.384 1.255 111.xls Tabela 7-1 Wyniki pomiarów czasów renderingu Czas renderingu pokazany w Tabela 7-1 w kolumnie T jest sumarycznym czasem trwania wszystkich operacji potoku renderingu.547 111.589 238.083 11.588 25.630 6.383 7.457 111.906 59.133 120.722 1.134 1.533 15.587 109.561 29.188 0.749 3.899 59.440 24.927 25.852 1.714 22.732 24.000 0.W kolejnym punkcie znajduje się bardziej szczegółowa analiza wszystkich czynników mających wpływ na prędkość generacji obrazów.414 118.731 24.510 6. 7.200 120.174 1.115 31.1.

Teval jest z kolei następującą sumą czasów: Teval = Tinit + samples * (Tctx + T patterns ) . obliczamy jako różnicę całkowitego czasu T i czasu renderingu sceny bez użycia TexLib (z wzorem oznaczonym w tabeli jako none). dla badanych obrazów w rozdzielczości 800x600 wartość ta jest równa48e4. W mocy tego założenia czas każdego renderingu zawiera czas inicjacji pojedynczego drzewa cieniowana. Potwierdza to Wykres 7-1. jest w takim przypadku wykorzystywany substytut. najbardziej złożony – complex).151/48e4) i na potrzeby dalszej analizy pomijalną. (Należy zaznaczyć. 105 . Tctx – czas przygotowywania kontekstu kontekstu wejściowego dla drzewa oraz wszystkich innych operacji związanych z komunikacją między biblioteką a systemem renderującym (poinformowanie biblioteki o zmianie kontekstu.15e-7s dla jednej próbki – 0.) Niewiele większy wpływ niż Tinit ma na całkowity czas ewaluacji drzewa cieniowania także czas Tctx. przekazanie wyników obliczeń). gdzie T init ≈ 0 Średnia jego wartość dla 4 użytych w testach scen wynosi: 0. gdzie: Tinit – czas inicjacji drzewa oraz poszczególnych funkcji bazowych. że Tinit jest relatywnie mały (bliski 0) dla wszystkich wzorów i może być pominięty jako czynnik wpływający na czas Teval. Tak obliczony czas jest umieszczony w kolumnie Teval. Czas Teval dla wszystkich scen w wierszu empty jest następującą sumą (nie występuje tu czas związany z obliczeniami funkcji bazowych): Teval = Tinit + samples * Tctx . co jest wartością stosunkowo niewielką (równą 3. Badania wykazały. który wykorzystuje TexLib. który system przeznacza na ewaluację drzewa cieniowania TexLib. posiadający najprostszy model oświetlenia (kolor stały).Najbardziej interesujący nas czas. wpływ ilości pikseli cieniowanych za pomocą TexLib na całkowity czas ewaluacji drzewa cieniowania będzie liniowy. czyli czas. Jeśli na scenie znajdował się więcej niż obiekt. Widać to już na krzywych z Wykres 7-1. Zamiast materiału. Ta uwaga jest istotna. Tpatterns – czas ewaluacji wszystkich funkcji w drzewie dla pojedynczej próbki samples – liczba próbek. jeśli analizujemy wielkości czasów związane z inicjacją drzewa cieniowania i poszczególnych funkcji wchodzących w jego skład. Czas renderingu w oczywisty sposób bardzo mocno zależy od wykorzystanych w drzewie funkcji bazowych.151s. gdzie pokazano czasy dla 3 wzorów o różnym stopniu skomplikowania (najprostszy – checker. że w każdym renderingu istniało i było ewaluowane tylko jedno drzewo cieniowania. to każdy z nich wykorzystywał to samo drzewo cieniowania. Jak się można spodziewać.

311 16. jakie wartości kontekstu wyjściowego modyfikujemy. Wykres 7-2 przedstawia przyrosty czasu generacji obrazu w zależności od tego. W przypadku odwzorowania nierówności powierzchni (modyfikacji normalnej N) używamy jednak w większości przypadków funkcji bazowej CalculateNormal.lwc (T=19.071 0. W zależności od stopnia złożoności tej funkcji.8s) 29.czas ewaluacji drzewa cieniowania Teval [s] 120 100 80 60 40 20 0 0 20 40 60 80 100 % pikseli cieniowanych za pomocą TexLib na obrazie checker salamandra complex Wykres 7-1 Czas ewaluacji drzewa cieniowania w zależności od pokrycia obrazu pikselami cieniowanymi za pomocą TexLib Generalnie. czas renderingu zależy w niewielkim stopniu od tego.lwc (T=22. salamandra2 oraz salamandra3.991 175. różnią się tylko ilością modyfikowanych parametrów wyjściowych) 100% 90% 80% 70% 60% 50% 40% 30% 20% 10% 0% 1.381 modyfikacja przezroczystości (T) modyfikacja normalnej N modyfikacja koloru (C) 5. jak wcześniej opisano.5s) 5.871 sceny (w nawiasie podano czasy ewaluacji drzewa cieniowania Teval) Wykres 7-2 Procentowy przyrost czasu generacji obrazu po wprowadzeniu zmian kolejnych parametrów kontekstu wyjściowego 106 . której działanie opiera się na kilkukrotnej ewaluacji funkcji wysokości.587 mid2.021 1. Kolejne przyrosty uzyskano z różnic czasów generacji tych 3 scen (sceny te. Został on stworzony na podstawie czasów Teval dla scen salamandra. jakie parametry kontekstu wyjściowego są modyfikowane.lwc (T=110s) 58. czas renderingu może znacznie wzrosnąć.lwc (T=235s) 1.081 opt.746 13.993 mid.721 79.162 pes.

modyfikacja normalnej ma znaczny wpływ na szybkość generacji obrazu.4s) sceny Wykres 7-3 Stosunek czasów cieniowania wykonywanego przy użyciu TexLib do czasów innych operacji przeprowadzanych w systemie do renderigu Cieniowanie z każdym z przypadków zajmuje znaczną ilość czasu.Jak widać. Zestawienia przykładowych obrazów zawarte są w Tabela 7-2.lwc (T=66. Oto jak przedstawia się procentowy udział czasu spędzonego na ewaluacji drzew cieniowania w tych 3 różnych przypadkach (Do stworzenia wykresu użyto danych zmierzonych przy wykorzystaniu wzoru complex).lwc (T=120.879 mid2. sięgającą nawet 98%.lwc (T=15s) 1. Świadczy o tym większy procentowy udział czasu w scenach generowanych najszybciej (opt.922 118.196 1.4. mid. W testach wykorzystano sceny.8s) 1.818 cieniowanie TexLib obl. Wpływ dodania modyfikacji parametrów alpha bądź T jest natomiast niezależny od stopnia skomplikowania sceny i jest związany raczej z czasem inicjacji dodatkowego shadera. które można przyjąć za przypadki optymistyczny.1s) mid.lwc) oraz jego stała (ok.335 64. 7. pesymistyczny i pośredni. 1s) wartość dla wszystkich przypadków. 100% 90% 80% 70% 60% 50% 40% 30% 20% 10% 0% 10.lwc (T=17. geometryczne+ cieniowanie 6.porównania W tym punkcie porównano fotorealistyczne obrazy uzyskane dzięki TexLib z innymi – naturalnymi lub wygenerowanymi innymi metodami grafiki komputerowej. Ocena jakości .952 13.739 opt. 107 .lwc. a więc jest zależny od konkretnego systemu. jeśli chodzi o znaczenie obliczeń wykonywanych wewnątrz biblioteki.626 pes.

) efekt może być trudny do odróżnienia od zdjęcia. ponieważ w praktyce. której kilkadziesiąt wygenerowanych klatek można znaleźć w katalogu Water. Kształt cętek uległby wtedy zniekształceniu zmniejszając efekt sztuczności. tekstura ta byłaby użyta prawdopodobnie na obiekcie nie będącym. Nie jest to jednak duży mankament. jednak ogólne wrażenie jest bardzo dobre. płaszczyzną. co jest jeszcze bardziej podkreślone w animacji. stąd łatwo odróżnić obraz sztuczny od naturalnego. skóra wyprawiona Ta symulacja jest jedną z najbardziej realistycznych. Symulacja wygląda jednak bardzo naturalnie. jak tutaj. torba itp.Fotografia lub obraz wygenerowany innymi metodami grafiki komputerowej Obraz wygenerowany przy pomocy TexLib skóra węża Obraz wygenerowany w tym przypadku posiada nieco różniący się od przykładowego wzór. 108 . a po nałożeniu tekstury na modele skórzanych przedmiotów (np. Mała wielkość detali nie pozwala na powyższych obrazach tego docenić. tapicerka samochodu. Brak jej w tej prostej scenie naszej symulacji. co dodaje obrazowi pewnej głębi. Istnieją tutaj także dosyć znaczne różnice w kolorystyce. Zdjęcie po lewej stronie nie przedstawia płaszczyzny. cienie kaustyczne Cienie kaustyczne na powyższym zdjęciu są widziane pod pewnym kątem.

bądź nieprzewidzianych efektów składania funkcji bazowych.3. jako że wiele naturalnych powierzchni ma charakter komórkowy. Obydwie przyczyny występowania artefaktów mogą być rozwiązane za pomocą algorytmów antialiasingu. przebarwienia). Nic nie stoi na przeszkodzie. Można jednak powiedzieć. W tym przykładzie chodziło o pokazanie ogólnej faktury ziemi bez zbytniego rozbudowywania topologii drzewa cieniowania.5. Dziedzina możliwych symulacji jest ponadto bardzo duża. Na obrazach występują artefakty wynikające bądź z występowania w obrazie wysokich częstotliwości (efekty aliasingu). że wygenerowany obraz posiada nieco mniej szczegółów niż zdjęcie (drobne nierówności ziemi.wyschnięta ziemia Kolejny przykład dobrej symulacji naturalnego zjawiska. aby symulację wzbogacić o dodatkowe elementy oparte na szumie czy kolejnych warstwach „pęknięć”. Mocną stroną opracowanych technik jest realizm produkowanych symulacji. Porównanie z naturalnymi zdjęciami zamieszczonymi powyżej pokazuje. kiedy jakość obrazu uzyskiwana dzięki TexLib odbiega od ideału. w punkcie 3. Można zauważyć. a produkcja takich właśnie jest z użyciem TexLib najprostsza. które tutaj nie zostały zaimplementowane. których funkcjonalność jest ograniczona skończonym zbiorem algorytmów i ich parametrów. to w stworzonym systemie nie istnieje ograniczenie liczby parametrów. Tabela 7-2 Porównanie tekstur uzyskanych dzięki TexLib z naturalnymi zjawiskami 7. Podsumowanie Ocena łatwości generowania nowych tekstur jest trudna do przeprowadzenia ze względu na brak danych zebranych od większej liczby użytkowników systemu. że stosunek możliwości do stopnia skomplikowania procesu tworzenia symulacji zjawisk rzeczywistych jest bardzo wysoki i znacznie przewyższa znane systemy opisywane np. Drzewa cieniowania nie mają bowiem ograniczenia stopnia skomplikowania. że można uzyskać stosunkowo prostymi drzewami cieniowania zaskakująco dobre efekty. Jeśli traktować wartości stałe w drzewie cieniowania jako odpowiedniki parametrów w systemach do generacji tekstur. Są przypadki. 109 .

a przecież proces ich tworzenia od pomysłu do gotowego obrazu trwał krótko w porównaniu w tradycyjnym podejściem do implementacji tekstur proceduralnych. Podsumowanie Tekstury proceduralne uchodzą za niepraktyczne ze względu na koszt ich uzyskania. każdy krok ewolucji populacji kończyłby się prezentacją wyników użytkownikowi. zgodnie z założeniami. który udostępnia interfejs teksturowania proceduralnego w postaci pewnego „języka cieniowania” (który w szczególnych przypadkach jest zwykłym C bądź C++). opracowano jednak interfejs języka C. Ponieważ trudno wyobrazić sobie funkcję oceniającą każdego z osobników populacji (czyli obraz generowany przez dane drzewo cieniowania). może pokusić się o implementacje własnych. Implementacja dobrej tekstury może trwać długo w stosunku do uzyskania zdjęcia danej powierzchni. Istnieje jeszcze wiele sposobów rozbudowy stworzonego systemu. Edytor drzew cieniowania został zintegrowany z bardzo dobrym pakietem do grafiki fotorealistycznej – LADS. W istniejącej wersji żadna z funkcji bazowych nie realizuje antialiasingu analitycznego. ponieważ umożliwia uniknięcie nieporozumień i przypadków nieumiejętnego użycia parametrów. będzie nowe drzewo. statystyki wartości parametrów wyjściowych oraz wiele innych udogodnień sprawia. chromosomem będzie pojedyncze drzewo cieniowania. którzy będą ich potem bezpośrednio używać. Jest to jednak tylko przykładowa integracja. jako. natomiast genem możemy nazwać składową funkcję cieniującą. który odrzucałby 110 . i mogą być projektowane nawet przez tych. biblioteka TexLib może być użyta z każdym systemem. w połączeniu z aplikacją wykorzystującą graficzny. a podnosi za to wymagania wydajnościowe. które nie zawsze przynosi bardzo dobre efekty. bądź właśnie LADS). Jednym z ciekawszych jest rozbudowa Edytora o możliwości budowy drzew cieniowania za pomocą programowania genetycznego. TexLib została zaimplementowana w C++. Sprowadza się to do mniej lub bardziej sprawnego nadpróbkowania. intuicyjny interfejs użytkownika. które będzie zawierało elementy obydwu drzew źródłowych. zdaje się dewaluować to twierdzenie. Traktując zbiór drzew cieniowania jako populację. Opracowana biblioteka funkcji bazowych TexLib. Tworzenie tekstur przez osoby bezpośrednio zainteresowane ich wykorzystaniem jest bardzo dobrym rozwiązaniem. że tworzenie nowych wzorów nie jest przy użyciu TexLib żmudnym zajęciem dla wtajemniczonych. a osiągnąwszy biegłość i wystarczające zrozumienie efektów ich składania. stosowanie raz zaimplementowanych rozwiązań wielokrotnie (w postaci funkcji bazowych lub wcześniej zaprojektowanych fragmentów drzew cieniowania). że.8. Otwartą sprawą pozostaje antialiasing funkcji bazowych. co wymusza stosowanie metod antialiasingu dostarczanych przez systemy do renderingu. Uzyskano tym sposobem także świetne narzędzie do twórczej nauki o teksturach proceduralnych. Wynikiem działania operatora krzyżowania 2 chromosomów będących drzewami cieniowania. Możliwość szybkiego wprowadzania i podglądu zmian w opracowywanym wzorze. Zadanie to ułatwi system rozszerzeń oparty na bibliotekach DLL. będzie używał podstawowych operatorów genetycznych: mutacji i krzyżowania. Mutacja natomiast stworzy nowe drzewo cieniowania zastępując pewną liczbę składowych funkcji innymi. Jest wręcz przeciwnie – nowe tekstury powstają z łatwością. czyli artystów. Etap algorytmu genetycznego realizujący ewolucję. co w pewnych przypadkach jest jedyną możliwością integracji (przykładem może być RenderMan. Student może ławo przeprowadzać doświadczenia na predefiniowanych funkcjach bazowych. Tekstury wykorzystane w Rozdziale 7 dają w większości przypadków zdecydowanie więcej niż zadowalające efekty.

o ile w czasie pierwszej generacji obrazu dla nowych parametrów obserwacji sceny zapamiętamy dla każdego piksela informacje o płaszczyźnie. oraz modelu oświetlenia. jednak we wszystkich nie używano tak funkcjonalnie rozbudowanych drzew cieniowania. Za pomocą odpowiedniego systemu bylibyśmy zdolni do wyświetlenia obrazu ze zmienionymi atrybutami powierzchni z pominięciem systemu renderującego i całego standardowego potoku renderingu. 111 . ponieważ regeneracja obrazu byłaby dla części scen oraz części parametrów danego drzewa o wiele szybsza (w niektórych przypadkach w czasie rzeczywistym). co prawda. Kolejną możliwością rozbudowy. Istniejące rozwiązanie pozwala. Edycja drzew cieniowania stałaby się wtedy jeszcze wygodniejsza. do której należy. jest udostępnienie podglądu zmian drzewa cieniowania w Edytorze w czasie rzeczywistym. Jest to możliwe. jednak polega on zawsze na regeneracji całego obrazu. Wiadomo o kilku podobnych podejściach do generacji tekstur.niepotrzebne osobniki. na szybki podgląd zmian. usprawniającą proces tworzenia tekstur.

SIGGRAPH 2000: Advanced RenderMan 2 [Fukuda 2000] K.html [Blinn 9/1998] Jim Blinn. A. Kukla.aca. Department of Computer Science and Electrical Engineering.htm.edu/~ccarter/hub_paper/section3_3.mit. Gamma. Clonal Mosaic Model for the Synthesis of Mammalian Coat Patterns. A Method of Generating Stone Wall Patterns. Reading Mass.ch/~fukuda/polyfaq/polyfaq. D. Warszawa 1995 [Watt 2000] Alan Watt. Egerton and W. Fukuda.mmu.. Cellular Textures. Generation Textures on Arbitrary Surfaces Using Reaction–Diffusion. Johnson. July 2000 [Foley] J.umbc. Frequently Asked Questions in Polyhedral Computation. Walter. Aspects of visualization. Texturing and Modeling.jde. SIGGRAPH '90 Conference Proceedings. Addison-Wesley.W. pp. Turk. London 1999 [Rogers] David F. . The RenderMan Interface 3. State of Art In Computer Graphics. October 2000 [Miyata 1990] K. 1998 [Pixar] Pixar. M. W. 1995 [T&M 1998] D. Academic Press Professional.edu/~mcm/6. Porto Alegre – Brasil. Marzec 1995 [Fielding] Alan Fielding. D.csee. Worley. Ebert. LIBTEX – A Software Toolkit for Texture Synthesis in Computer – Generated Images.edu/~legakis/gallery_cellular. K.lcs.uk/multivar/dist. Department of Mathematics. Walter. Bedwell.S. A Cellular Texture Basis function.lcs. M. 3/4 2000 [Cahn] J. [Turk 1991] G. Ten More Unsolved Problems in Computer Graphics.838j/talk. Design Patterns: Elements of Reusable Object-Oriented Software. J. Rogers.html [Walter 1992] M.mit.html.mit. Wprowadzenie do grafiki komputerowej. R. Addison-Wesley.Carter. http://www. Literatura [Gamma 1995] E.. 1990. Peachey. Crystal Shapes and Phase Equilibria: A Common Mathematical Basis. Reimers. 2002 112 .edu/~ebedwe/skin/img/ [Legakis] Justin Legakis. Foley.387-394. E. S. Miyata.ac. Fournier. Vlissides. http://www. University of Maryland Baltimore County. F. IEEE Computer Graphics and applications 9/10 1998 [Glassner 3/2000] Andrew Glassner.2. Musgrave. Computer Graphics: Mathematical First Steps. July 1991 [Worley] Steven Worley. How PhotoRealistic RenderMan Works.ifor. Swiss Federal Institute of Technology. Distance and Similarity Measures. 1992 [Walter 1998] M.9. Wydawnictwo Naukowo-Techniczne.ethz. http://graphics. Harlow 2000 [Egerton 1999] Patricia A. http://pruffle.C. Springer-Verlag. The Digital Ceraunoscope. New York 1994 [Apodaca] Tony Apodaca. A procedural texture for epidermal tissue.Cahn.html. IEEE Computer Graphics and applications. http://graphics. Perlin.math. Helm. 3D Computer Graphics. Computer Graphics (SIGGRAPH ’91 Proceedings). 25(4):289-298. Prentice Hall. K. Hall. R. http://obelia. J. A procedural approach. Department of Computer Science University of British Columbia [Kukla] J. Instituto de Informatica.

informacje potrzebne do implementacji antialiasingu analitycznego Tabela 9-1 Typy danych interfejsu wzorów. Tabela 1 zawiera klasy definiujące dostępne typy danych oraz ich opis (wszystkie klasy CValue.1.1.h tablica float[3] lub double[3] tablica float[3] lub double[3] tablica float[3] lub double[3] tablica float[] lub double[] tablica float[3][] lub double[3][] struktura opisująca aktualną próbkę. fotorealistycznych obrazów używanych w filmie. Dla użytkownika funkcja bazowa jest funkcją posiadającą pewne wejścia i wyjścia. A. dzięki czemu możliwy jest rendering obrazów bezpośrednio z poziomu aplikacji. klasa (przedrostek CValue*) opis Int Float Point Vector Color ArrayFloat ArrayColor Sample int float lub double. 113 .Dodatek A. zależnie od definicji FLOAT w pliku types. Instrukcja dla studentów A. Funkcja ustalająca te wartości to właśnie tekstura proceduralna.1. Od tradycyjnych tekstur będących najczęściej dwuwymiarowymi zdjęciami lub innymi obrazami. przestrzennych bądź przestrzennych animacji.2.1. W ćwiczeniu wykorzystana zostanie rozszerzalna biblioteka funkcji cieniujących TexLib oraz aplikacja – edytor służący do definiowania drzew cieniowania złożonych z funkcji cieniujących zdefiniowanych w bibliotece. Cel ćwiczenia Celem ćwiczenia jest zapoznanie się z pojęciem tekstur proceduralnych. odróżniają je między innymi: • niezależność od docelowej rozdzielczości – większość procedur potrafi wygenerować dowolną ilość detali zależnie od odległości obserwatora od obserwowanej powierzchni • możliwość generacji tekstur wielowymiarowych (dwuwymiarowych. dziedziczą po abstrakcyjnej klasie wartości CAbstractValue). Edytor został zintegrowany z system do generowaniu grafiki fotorealistycznej LightWorks Application Development System.. zawiera np. Propozycja ćwiczenia laboratoryjnego A.3. Biblioteka do tworzenia drzew cieniowania Biblioteka zawiera zbiór tzw. funkcji bazowych. podstawowymi technikami ich generacji oraz zaprojektowanie i zaimplementowanie własnych algorytmów produkujących wysokiej jakości fotorealistyczne obrazy. czyli tekstur czterowymiarowych) • stosunkowo mały rozmiar definicji (w porównaniu z wysokiej jakości zdjęciami) • parametryczny interfejs umożliwiający generację wielu różnych obrazów za pomocą jednej procedury A. Ich generacja polega na obliczeniu pewnych właściwości powierzchni (wynikających z modelu powierzchni) na podstawie kontekstu cieniowania (czyli informacji o aktualnie cieniowanej próbce obrazu: współrzędnych punktu w jednym z układów współrzędnych tekstury bądź przestrzeni).1. reklamie wizualizacji architektonicznej itd.tekstury proceduralne Tekstury proceduralne to dzisiaj podstawa generacji profesjonalnych. Każde wejście i wyjście ma określony typ. Wprowadzenie .

//ewaluacja virtual void Evaluate() = 0. CAbstractValue *GetInputValidValue(UINT in). virtual void Initialise() = 0. virtual ~CPattern().. która jest stała i której zmiana jest niedostępna dla użytkownika • wartości dostarczonej przez użytkownika (która pozostaje stała przez cały czas renderingu) • wyjścia innego wzoru. //pobieranie aktualnych wartości parametrów wejściowych/wyjściowych CAbstractValue *GetInputBoundValue(UINT in). Rysunek 9-1 Przykładowy diagram funkcji bazowych Widzimy na nim 6 funkcji bazowych oznaczonych prostokątami. class CPattern { public: CPattern(CPatternFactory *pFactory).Każde z wejść funkcji bazowej może pobierać dane z 3 źródeł: • swojej domyślnej wartości. opisywanego dalej) jest zamieszczony na Rysunek 9-1. /*. którego typ jest kompatybilny (w praktyce oznacza to identyczny typ) Przykładowy diagram funkcji bazowych (pochodzący z edytora drzew cieniowania. Wartości w owalach to zdefiniowane przez użytkownika stałe. przy czym biegną one od parametru wyjściowego do wejściowego. CAbstractValue *GetOutputValue(UINT out). Opis funkcji klasy CPattern zawiera Tabela 9-2. Strzałki symbolizują połączenie parametrów wyjściowych z wejściowymi.*/ 114 . Funkcje bazowe są zdefiniowane jako klasy dziedziczące po klasie CPattern (której deklarację przedstawia Program 9-1)..

której odpowiednia metoda zwraca nowe obiekty CPattern. AddInput Funkcja służy do dodawania nowych parametrów wejściowych i powinna być używana tylko w konstruktorze. int type). GetOutputValue Funkcja zwraca wskaźnik na obiekt odpowiedniej wartości wyjściowej. Wykonywane operacje zależą od konkretnej implementacji. że część parametrów wejściowych danej funkcji bazowej może ulegać zmianie w trakcie procesu renderingu. której identyfikator jest podawany jako parametr. Jest to „fabryka funkcji cieniujących”. Evaluate Funkcja abstrakcyjna obliczająca dla danych parametrów wyjściowych oraz zmiennych zainicjowanych w funkcji Initialise wartości parametrów wyjściowych. które zależą od parametrów wejściowych. której zadaniem w pochodnej klasie jest inicjacja wzoru. int type. która z kolei wymusi ewaluację Leather oraz InContext. Należy zwrócić uwagę na to. jednak zasadą jest. Program 9-1 Skrócona definicja klasy CPattern nazwa funkcji (prototypy znajdują się w Program 9-1) opis konstruktor Parametrem kontruktora jest obiekt klasy dziedziczącej po CPatternFactory... UINT AddOutput(String name. /*. który jest aktualnie wykorzystywany przez parametr wejściowy o podanym identyfikatorze in. że będą niezmienne. że inicjowane są tutaj wszystkie wartości niezmienne dla danych parametrów wejściowych. Przykład definicji znajduje się w projekcie sample_src/sample_ptn Initialise Funkcja abstrakcyjna. co do których zakładamy. GetInputBoundValue Funkcja zwraca wskaźnik na obiekt wartości. używany potem w 115 . GetInputValidValue Funkcja zwraca wskaźnik na obiekt aktualnej wartości.*/ private: //fabryka obiektów podawana jako parametr konstruktora klasy CPatternFactory *m_pFactory. dlatego inicjowane powinny być tylko te zmienne. Jest używana w funkcji Evaluate do ustawiania wartości parametrów wyjściowych. Informację o takim założeniu należy umieścić w dokumentacji funkcji cieniującej.protected: //funckje dodające nowe parametry wejściowe/wyjściowe //name – nazwa parametru //type – jeden z predefiniowanych typów parametrów //value – oznacza wartość domyślną UINT AddInput(String name. Dla przykładu. W razie potrzeby wartość ta jest ewaluowana. }. CAbstractValue *value). wywołanie GetInputValidValue dla funkcji Checker z parametrem okreslającym identyfikator wejścia white spowoduje ewaluację funkcji Interpolator3D. Wartością zwracaną jest identyfikator.

s. dPdu.AddOutput wywołaniach GetInput. Są to. du. dPdv ds. używany potem w wywołaniach GetOutpuValue. dPdt. Kierunek promienia przecinającego powierzchnię w cieniowanym punkcie (od ang. Analytic Antialiasing). Przezroczystość powierzchni.* Istnieją dwie specjalne klasy funkcji bazowych określające kontekst cieniowania i służące do komunikacji biblioteki TexLib z wykorzystującym je systemem do renderingu. Zmiana parametrów powierzchni Średnica okręgu opisanego na wielokącie będącym przecięciem stożka widzenia wychodzącego z aktualnie cieniowanego piksela oraz cieniowanej płaszczyzny. widoczne na Rysunek 9-1. Wartością zwracaną jest identyfikator. Funkcja służy do dodawania nowych prametrów wyjściowych i powinna być używana tylko w kontruktorze. MinSpotSize) . Wartość AA=0 oznacza wyłączenie antialiasingu. Może to być (zależnie od systemu renderujacego) w przybliżeniu wartość: spotSize = max( dPdu * du ^ dPdv * dv . AA≠0 oznacza włączenie antialiasingu. Zawiera on następujące parametry: Zmienna P N C T I E u. dt. Pochodne koordynat tekstury oraz parametrów powierzchni – opisują jak zmienia się pozycja wraz ze zmianą parametrów powierzchni. t dPds. znajduje się w plikach sample_src/sample_ptn/sample_ptn. Incident vector). Funkcja InContext określa dla każdej ewaluacji drzewa (każdej próbki) kontekst wejściowy. Eye point) Parametry powierzchni opisanej parametrycznie oraz koordynaty tekstury.. InContext oraz OutContext. dv Typ (CValue. gdzie ^ oznacza iloczyn wektorowy 2 wektorów Zmienna przełączająca użycie antialiasingu analitycznego (od ang. Tabela 9-2 Opis metod klasy CPattern Przykład definicji wzoru Checker. na którym można oprzeć własne implementacje funkcji bazowych. v.. 116 spotSize Float AA Int . Punkt położenia obserwatora (od ang.) Opis Point Vector Color Color Vector Point Float Vector Float Współrzędne aktualnie cieniowanego punktu w układzie lokalnym obiektu Wektor normalny do aktualnie cieniowanej płaszczyzny Kolor płaszczyzny w cieniowanym punkcie P..

Katalog sample_src/sample_ptn/ zawiera przykładowy projekt Visual C++6. 2. ponieważ to. 1 sekundy. Tworzenie nowej klasy definiującej funkcję bazową odbywa się w następujący sposób: 1. Drzewo cieniowania może za jego pomocą modyfikować kilka atrybutów powierzchni: Zmienna C N Typ (patrz Tabela 4-2) Opis Color Vector Nowy kolor płaszczyzny dla punktu P kontekstu wejściowego Zmodyfikowana normalna dla punktu P kontekstu wejściowego Zmodyfikowany punkt P kontekstu wejściowego.in. Nową klasę funkcji cieniujących należy zarejestrować w bibliotece za pomocą wywołania metody Add w funkcji Init biblioteki DLL (patrz plik sample_ptn.cpp). nie można interpretować upływu czasu od wartości time=0 do time=1 jako np. displacement). Jeśli tak. Definicja parametrów nowej funkcji cieniującej za pomocą wywołań AddInput/Output w konstruktorze nowej klasy. Pliki nagłówkowe oraz niezbędny do konsolidacji bibliotek DLL plik texlib.Wszystkie wzory udostępniające ten tryb zaczną go wykorzystywać. jak time będzie wykorzystany zależy od systemu wykorzystującego bibliotekę) time Float Funkcja OutContext określa kontekst wyjściowy. w aplikacji Edytora drzew cieniowania. są ładowane automatycznie przez TexLib. Utworzenie klasy pochodnej CPattern oraz odpowiadającej jej klasy CPatternFactory. ang. znaleźć można w katalogu TexLib. Rejestracja pozwoli na wykorzystanie nowego wzoru m. które. 117 . po umieszczeniu w podkatalogu Patterns. 3. 4. Służy do renderingu animacji i jest umowną wartością zmiennoprzecinkową (tzn. Wartość czasu. Zmodyfikowana przezroczystość. Implementacja funkcji Initialise oraz Evaluate nowej klasy typu CPattern. Współczynnik pokrycia powierzchni.lib zawierający implementację biblioteki TexLib. P Point T alpha Color Float Interfejs do tworzenia funkcji bazowych Wzory definiowane są w bibliotekach DLL. to zmienną tą wykorzystuje się zwykle przesuwając wejściowy punkt P wzdłuż wektora normalnego N. który można wykorzystać do stworzenia własnej biblioteki funkcji cieniujących. Uwaga: Nie każdy system udostępnia możliwość modyfikacji płaszczyzny (przemieszczenia.0.

wykorzystując przykładowy projekt • użyć nowej funkcji w drzewie cieniowania modyfikującym odpowiednie atrybuty powierzchniowe.lwc) o jakość uzyskiwanych obrazów (poprzez porównanie z podobnymi efektami realizowanymi za pomocą innych metod grafiki fotorealistycznej lub zdjęciami) o jakość parametryzacji. mid2. mid.pdf.h.1. float k1. 118 . Edytor drzew cieniowania Edytor drzew cieniowania służy do szybkiej edycji drzew cieniowania. float a. Są to między innymi: • podstawowe funkcje często używane w definicji tekstur proceduralnych: o float FLOOR(float x) oraz float CEIL(float x) o float CLAMP(float x.5. Obsługa Edytora jest opisana w oddzielnym dokumencie Edytor. float k2. float x0. A. diagramu Voronoi ([Worley]). • klasa CNoiseFractal – obliczająca fraktalne wersje powyższych funkcji ([T&M 1998]). float x0.1.lwc. float b) o float SMOOTHSTEP(float x) o float LERP(float t.3 „Interfejs do tworzenia funkcji bazowych”. float x1) o float SPLINE(float x.lwc. float x1) oraz float SMOOTHSTEP_INTERP(float t.1. float k0. czyli jej intuicyjność oraz wpływ parametrów na uzyskiwane rezultaty • przygotować sprawozdanie według zamieszczonego niżej opisu Zadania wymienione dalej są uszeregowane według rosnącego stopnia trudności.Predefiniowane narzędzia definicji tekstur Biblioteka zawiera zbiór klas będących narzędziami do tworzenia tekstur proceduralnych. float k3) • klasa CNoisePerlin – obliczająca wartości szumu Perlina (metodą gradientową) ([T&M 1998]). Wszystkie narzędzia można wykorzystywać przy implementacji własnych funkcji cieniujących po włączeniu nagłówka utils. które będzie symulowało wygląd kamienia naturalnego.4.lwc oraz pes. ich zapisywania i odczytywnia. Zadania Zadanie polega na stworzeniu biblioteki DLL rozszerzającej zbiór funkcji bazowych biblioteki TexLib oraz przeprowadzenia eksperymentów. • klasa CNoiseWorley – realizująca podział przestrzeni wg. Każde z poniższych zadań należy wykonać według następującego algorytmu: • utworzyć nową funkcję (lub kilka funkcji) bazową zgodnie z opisem w punkcie A. Dokumentacja narzędzi znajduje się w powyższym pliku nagłówkowym. A. wymagane przy konkretnym zadaniu • zaimplementować odpowiednie metody klas nowych funkcji • stworzyć bibliotekę DLL i umieścić ją w podkatalogu Patterns katalogu Edytora drzew cieniowania • przeprowadzić eksperymenty mające na celu ocenę jakości oraz wydajności implementacji: o wydajność stworzonych algorytmów dla scen testowych (sceny opt. Zadanie 1 Zaprojektować drzewo cieniowania z użyciem predefiniowanych funkcji bazowych.

formujących się chmur. Powinna więc działać w przestrzeni określonej przez s. Wygenerować klatki animacji chmur za pomocą funkcjonalności Edytora drzew cieniowania. Funkcja powinna być możliwa do użycia w drzewie cieniowania o topologii przedstawionej na diagramie na Rysunek 9-2. Dodatkowym wymaganiem jest możliwość generacji wzorów okresowych (zapętlających się). dzięki którym gotową teksturę będzie można używać z odwzorowaniem zapętlającym do teksturowania nieskończenie dużych powierzchni. Zadanie 3 Zdefiniować funkcję cieniującą. Zadanie 4 Zdefiniować funkcję bazową modyfikującą kolor oraz realizującą odwzorowanie nierówności powierzchni symulującą wygląd kory drzewa. Drzewo ma wykorzystywać parametr time kontekstu wejściowego do generacji animacji przepływających. Rysunek 9-2 Przykładowy diagram drzewa cieniowania 119 .t. top. płaskie tekstury.Zadanie 2 Zbudować drzewo cieniowania generujące obraz chmur typu cumulus. abstrakcyjnych lub naturalnych wzorów. która przy wykorzystaniu odpowiedniej sceny (np. Funkcja powinna umożliwiać generację kilku rodzajów ciekawych.lwc) może posłużyć do generacji obrazów możliwych do wykorzystania jako tradycyjne.t jak i lokalnej R3 obiektu. Może być zdefiniowana zarówno w przestrzeni s.

prosty model oświetlenia można zastąpić fizycznie poprawnym.Zadanie 5 Zdefiniować funkcję bazową modyfikującą kolor oraz realizującą odwzorowanie nierówności powierzchni symulującą wygląd łuski ryby.1. Funkcja powinna być możliwa do użycia w drzewie cieniowania o topologii przedstawionej na diagramie z Rysunek 9-2 i powinna wykorzystywać lokalny układ współrzędnych R3 obiektu. „Soap Bubbles”. nr 3-4/2000 Wskazówka: funkcja musi wykorzystywać kierunek promienia I i odpowiednio modyfikować atrybut alpha oraz C. Analiza zjawiska wyładowań atmosferycznych znajduje się w artykule: Andrew Glassner. IEEE Computer Graphics and applications. Sprawozdanie Rysunek 9-4 Piana na powierzchni piwa Do zadania powinno powstać sprawozdanie zawierające między innymi: • opis użytych algorytmów • opis sposobu przeprowadzania eksperymentów i ich cele • wyniki eksperymentów w postaci: o zestawienia czasów renderingu dla różnych scen oraz ustawień parametrów wejściowych o prezentacji obrazów przedstawiających zastosowanie stworzonych funkcji w praktyce 120 . nr 9-10/2000 Wskazówka: funkcja powinna śledzić dla każdej próbki promień o kierunku I pobranym z kontekstu wejściowego. Należy zasymulować prosty model oświetlenia. A. który jest opisany między innymi w artykule: Andrew Glassner. „The Digital Ceraunoscope: Synthetic Thunder and Lightning”. dzięki której będzie można uzyskać efekt przezroczystych baniek (jak na Rysunek 9-4). Funkcja powinna działać w układzie współrzędnych R3 świata. Zadanie 6 Zdefiniować funkcję bazową realizującą prosty Rysunek 9-3 Rybia łuska rendering „wolumetryczny”. Funkcja powinna działać w lokalnym układzie współrzędnych R3 obiektu. IEEE Computer Graphics and applications.6. Rozkład baniek w przestrzeni przypomina diagram Voronoi. wizualizującą efekty wyładowań atmosferycznych. Zadanie 7 Zdefiniować funkcję bazową. Dodatkowo.

2. Computer Graphics: Mathematical First Steps. F. intuicyjność ich użycia i wpływu na efekty) jakość sprawozdania Ocena efektów wizualnych to nie tylko subiektywna ocena walorów plastycznych wykonana przez prowadzącego. Tutaj przyjrzeć się należy realizmowi stworzonych wzorów (porównania z przykładami wziętymi z natury) oraz możliwościom tworzenia różnych wariantów wzoru. SIGGRAPH 2000: Advanced RenderMan 2 A. Pomóc ma w tym przykładowy projekt. State of Art In Computer Graphics. K. 1998 [Worley] Steven Worley.S. Addison-Wesley. Peachey.1.7. D. Musgrave. a student mógł skupić się dalej na implementacji właściwych algorytmów. Hall. Texturing and Modeling. K.0 umożliwiający stworzenie biblioteki DLL rozszerzającej TexLib. London 1999 [Rogers] David F. Aspects of visualization. How PhotoRealistic RenderMan Works. który można znaleźć w katalogu sample_src. Aplikacja Edytora drzew cieniowania wraz z dokumentem opisującym sposób jej obsługi (podkatalog Editor) Przykładowe drzewa cieniowania (podkatalog Editor\Trees) Dokument zawierający instrukcję dla studentów wraz z przykładowymi zadaniami. Program dobrano tak.1. Harlow 2000 [T&M 1998] D. S. Egerton and W. July 2000 [Apodaca 2000] Tony Apodaca. trafność i skuteczność zastosowanych sposobów generacji tekstury wydajność zastosowanych algorytmów łatwość obsługi zdefiniowanych wzorów (dobór parametrów. Realizacja ćwiczenia przez studenta nie powinna zająć w czasie trwania semestru więcej niż 3-4 tygodnie. 1h.A. zakładając jedną godzinę zajęć laboratoryjnych tygodniowo. aby wstępna implementacja oraz konfiguracja projektu zajęła ok. A Cellular Texture Basis function. 3D Computer Graphics.2. Ujednolicenie scen pomoże dodatkowo w porównywaniu wyników osiąganych przez różne osoby (podkatalog Scenes). których studenci powinni używać do testów swoich rozwiązań. • • • • Ocena Ocenie powinny podlegać następujące właściwości prac: efekty wizualne.lib oraz koniecznymi plikami nagłówkowymi (podkatalog Project) Sceny.838j/talk.edu/~mcm/6.lcs.. http://graphics.mit. Prentice Hall. Perlin. jakie 121 .2. A. wraz z plikami potrzebnymi do kompilacji i konsolidacji – plikiem texlib. Rogers. The RenderMan Interface 3. Zalecenia dla prowadzącego to: Wszystkie dane niezbędne do przeprowadzenia ćwiczenia znajdują się w katalogu Lab. Academic Press Professional. A procedural approach. Są • • • • • Przykładowy projekt Visual C++ 6. Worley. Springer-Verlag. Literatura [Egerton 1999] Patricia A. New York 1994 [Watt 2000] Alan Watt.html [Pixar] Pixar. Ebert.

którą można wykorzystać do porównania czasów osiąganych przez algorytmy. po implementację rendererów wolumetrycznych czy rendererów obiektów opisanych za pomocą funkcji gęstości (tzw.1.2. Bardzo ważnym elementem oceny jest łatwość i intuicyjność obsługi zdefiniowanej funkcji. Edytor drzew cieniowania udostępnia funkcję obliczania czasu renderingu.daje przyjęte rozwiązanie. jakie pełnią i ich wpływ na działnie algorymtu.2. Istotna jest ilość parametrów. str 209). ich nazwy oraz funkcje. hipertekstur) ([T&M 1998]. co sugerują nazwy i zdrowy rozsądek. a jedynie zaznajomienia się z pojęciem tekstur proceduralnych i zaprojektowania pewnych drzew cieniowania z użyciem Edytora. kto nie zna algorytmu stojącego za interfejsem. Łatwo w ten sposób kontrolować stopień trudności zadań: od tworzenia ładnie wyglądających obrazów z użyciem predefiniowanych funkcji bazowych (ułatwia to studentom zrozumienie zasad tworzenia tekstur. Mogą także nie wymagać implementacji. Zadania studentów mogą polegać na symulacji bardzo różnych powierzchni i zjawisk naturalnych. Algorytm powinien być oceniany za swoją oryginalność. Generalnie. Możliwe modyfikacje ćwiczenia Prowadzący ma duże możliwości modyfikacji ćwiczenia. Są one zalecane do eksperymentów także w instrukcji dla studentów. prostotę i skuteczność. Wydajność najlepiej sprawdzać stosując standardowe sceny z przypisanymi do pewnych elementów geometrii teksturami. 122 . parametry powinny być zrozumiałe dla kogoś. Przykłady wszystkich z tych rodzajów zadań zostały umieszczone w instrukcji dla studentów. A.3. Powinny działać zgodnie z tym. Bardziej szczegółowy opis scen można znaleźć w punkcie 7. różnic między teksturami powierzchniowymi i przestrzennymi) przez definicję nieskomplikowanych tekstur modyfikujących kolor. Przykłady takich scen można znaleźć w katalogu Scenes.

posiada swój indeks. definicji stałych wartości oraz definicji powiązań między wejściami i wyjściami.1.3. Każda część posiada swój nagłówek. B. Indeks 1 posiada InContext – kontekst wejściowy.0 1.Dodatek B.0 #BINDINGS 2 „P” 1 „P” 2 „white” –1 2 2 „black” –1 1 3 „C” 2 „C” Program 9-2 Przykładowy plik zawierający definicję drzewa cieniowania B.0 0. na ostatnim miejscu znajduje się OutContext – kontekst wyjściowy. Zawsze występują tutaj przynajmniej 2 standardowe wzory. Format pliku zapisu drzewa cieniowania (*. Definicja wartości Każda wartość.1.0 0.1. Format pliku *. Są to: • #PATTERNS – rozpoczyna definicję wzorów • #VALUES – rozpoczyna definicję wartości stałych • #BINDINGS – rozpoczyna definicję powiązań Program 2 zawiera przykładową definicję drzewa cieniowania // Drzewo cieniowania tworzące teksturę // koloru (dwukolorowej trójwymiarowej // kratki). który może przyjąć jedną z następujących postaci: INT FLOAT POINT VECTOR COLOR ARRAY_FLOAT ARRAY_COLOR Tabela 9-3 Identyfikatory typów występujące w definicji wartości w pliku *. Druga wartość to identyfikator typu.1. Definicja wzorów Każda linia oznacza instancję wzoru o podanej nazwie.0 1.0 2 COLOR 1.tree) B.2. podobnie jak wzór.tree 123 . #PATTERNS 1 InContext 2 Checker 3 OutContext #VALUES 1 COLOR 0.tree Plik definicji drzewa cieniowania składa się z 3 części: definicji wzorów.

4.1.B. Definicja powiązań Definicja powiązania wygląda następująco: id_pat id_in [ id_pat2 | -1] [ id_out | id_val ] id_pat id_in id_pat2 id_out id_val Przykładowo. definicja 3 „thresholds” 2 „array_of_floats” 124 .

You're Reading a Free Preview

Pobierz
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->