Textury vytvořené z fraktálů a matematických výrazů

8. 7. 2008

Doba čtení: 15 minut

Líbí se vám článek?
Podpořte redakci

V devatenácté části seriálu o raytraceru POV-Ray si řekneme, jakým způsobem je možné pracovat s procedurálními texturami vytvořenými pomocí fraktálů (například Mandelbrotovy množiny) či na základě matematické funkce, jejímiž parametry jsou souřadnice bodu, pro nějž se barva textury počítá.

Obsah

1. Procedurální textury vytvořené pomocí fraktálů
2. První demonstrační příklad – procedurální textura „mandel“
3. Možné modifikace textur vytvořených pomocí fraktálů
4. Druhý demonstrační příklad – modifikace procedurálních fraktálních textur
5. Starodávný program FRCT2POV a jeho využití při tvorbě fraktálních textur
6. Třetí demonstrační příklad – malá galerie fraktálních textur převedených programem FRCT2POV
7. Procedurální textury specifikované funkcí (vzorcem)
8. Čtvrtý demonstrační příklad – použití jednoduchých vzorců pro tvorbu textur
9. Obsah následující části seriálu

1. Procedurální textury vytvořené pomocí fraktálů

V POV-Rayi je možné vytvářet i velmi kvalitní procedurální textury, které jsou vypočtené pomocí jednoduchých iterativně opakovaných funkcí, jejichž výsledkem jsou obrázky se soběpodobnými útvary, takzvané fraktály. Samozřejmě je možné využít i specializované programy určené pro generování fraktálů (například FractInt, TieraZoom, XaoS, Fractal eXtreme, Ultra Fractal, Zplot, Brazil Fractal Builder atd.) a do POV-Raye „pouze“ importovat výsledné rastrové obrázky, ovšem to s sebou přináší některé problémy, od vyšší spotřeby paměti (v operační paměti musí být při renderingu uloženy všechny textury reprezentované rastrovým obrázkem) až po vznik nežádoucího aliasu, který se projeví především při tvorbě animací. Z tohoto důvodu je vhodnější použít přímo procedurální texturu nabízenou POV-Rayem; samozřejmě tam, kde jeho prostředky dostačují (například jsme omezeni na pouhé čtyři typy fraktálů a několik modifikujících parametrů). Na druhou stranu je možné u POV-Rayovské „fraktální“ procedurální textury využít vlastní barvové mapy s průhledností, použít překrývající se textury atd.

Obrázek 1: Mandelbrotova množina použitá ve formě procedurální textury (autor: David Grossman)

Mezi čtyři podporované typy fraktálů patří slavná Mandelbrotova množina, Juliova množina (jedná se vlastně o duální fraktál k Mandelbrotově množině), Mandelbrotova varianta fraktálu nazvaného Magnet a konečně Juliova varianta téhož fraktálu. Bližší popis těchto fraktálů byl (spolu se zdrojovými kódy demonstračních příkladů vytvořenými v Céčku) uveden v seriálu Fraktály v počítačové grafice (zde je podrobný obsah jednotlivých částí). U všech čtyř typů podporovaných fraktálů je možné specifikovat maximální počet iterací provedených při výpočtu barev jednotlivých bodů a způsob obarvení vnějších i vnitřních bodů. V případě Mandelbrotovy i Juliovy množiny lze zadat i mocninu použitou při výpočtu, která může být v rozsahu 2–33 (klasická Mandelbrotova množina používá iterační funkci s mocninou 2).

Obrázek 2: Devět fraktálních textur vypočtených v POV-Rayi

Syntaxe zápisu tohoto typu procedurální textury vypadá následovně (klíčová slova jsou psána malými písmeny):

MANDELBROT:
  mandel ITERATIONS [, BUMP_SIZE]
  [exponent EXPONENT]
  [exterior EXTERIOR_TYPE, FACTOR]
  [interior INTERIOR_TYPE, FACTOR]

JULIA:
  julia COMPLEX, ITERATIONS [, BUMP_SIZE]
  [exponent EXPONENT]
  [exterior EXTERIOR_TYPE, FACTOR]
  [interior INTERIOR_TYPE, FACTOR]

MAGNET MANDEL:
  magnet MAGNET_TYPE mandel ITERATIONS [, BUMP_SIZE]
  [exterior EXTERIOR_TYPE, FACTOR]
  [interior INTERIOR_TYPE, FACTOR]

MAGNET JULIA:
  magnet MAGNET_TYPE julia COMPLEX, ITERATIONS [, BUMP_SIZE]
  [exterior EXTERIOR_TYPE, FACTOR]
  [interior INTERIOR_TYPE, FACTOR]

Texturu je možné (a v případě použití fraktálních procedurálních textur většinou i nutné) zvětšit nebo s ní posouvat a rotovat s využitím modifikátorů scale, translate a rotate, popř. jejich kombinací. Pomocí modifikátoru scale se prakticky nahrazuje funkce „zoom“ známá snad ze všech aplikací, které pracují s fraktály vytvořenými v komplexní rovině. Volbami exterior a interior je možné určit, jakým způsobem budou vypočteny hodnoty sloužící pro vstup do barvové mapy.

Obrázek 3: Dalších dvanáct fraktálních textur vypočtených v POV-Rayi

2. První demonstrační příklad – procedurální textura „mandel“

V dnešním prvním demonstračním příkladu je ukázáno použití barvových map (převodu hodnoty maximálního počtu iterací na barvu) a také změny pohledu na texturu s využitím modifikátorů translate, rotate a scale. Pro zdárný raytracing tohoto demonstračního příkladu je zapotřebí ke zdrojovému textu dodat soubor s definicemi fraktálních textur, který je uložený pod tímto odkazem. Tento soubor bude použitý i v dalších demonstračních příkladech, jeho obsah byl získán převedením parametrů fraktálů vytvořených v aplikaci FractInt pomocí programu frct2pov, který bude popsán v dalších kapitolách.

// ------------------------------------------------------------
// Ukázka použití procedurální textury "mandel".
//
// rendering lze spustit příkazem:
//     povray +W1024 +H1024 +B100 +FN +D +Itextures.pov +Otextures.png
//
// !POZOR: scénu je nutné vykreslit se stejným horizontálním
//         i vertikálním rozlišením!
// ------------------------------------------------------------

#version 3.0
global_settings {
    assumed_gamma 2.2
}

#include "colors.inc"
#include "fractals.inc"        // soubor s definicí procedurálních textur

camera {                       // nastavení kamery
    orthographic               // bez perspektivy
    location < 0, 0, -1>       // pozice kamery
    right 15*x                 // šířka a výška snímané části scény
    up 15*y
    direction z                // směr pohledu kamery (k počátku)
}

light_source {                 // světelný zdroj
    <200, 200, -500>           // pozice
    color White                // barva
}

#declare COL1=-4.5;            // posuny objektů ve vztahu
#declare COL2= 0.0;            // k pomyslné mřížce
#declare COL3= 4.5;            // o rozměrech 3x3
#declare ROW1= 4.5;
#declare ROW2= 0.0;
#declare ROW3=-4.5;
#declare Z=0.0;

#declare OBJECT=box {          // testovací objekt - jednoduchý kvádr
    <-2,-2, 0>,
    < 2, 2, 1>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_01
        }
    }
    translate <COL1, ROW1, Z>
}


object {
    OBJECT
    texture {
        pigment {
            mandel_02
        }
    }
    translate <COL2, ROW1, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_03
        }
    }
    translate <COL3, ROW1, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_04
        }
    }
    translate <COL1, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_05
        }
    }
    translate <COL2, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_06
        }
    }
    translate <COL3, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_07
        }
    }
    translate <COL1, ROW3, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_08
        }
    }
    translate <COL2, ROW3, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_09
        }
    }
    translate <COL3, ROW3, Z>
}

// ------------------------------------------------------------
// finito
// ------------------------------------------------------------

Obrázek 4: Výsledek vykreslení prvního demonstračního příkladu

3. Možné modifikace textur vytvořených pomocí fraktálů

Kromě určení maximálního počtu iterací a změně měřítka (popř. i natočení a posuvu) procedurální textury je možné specifikovat i další dva důležité parametry nazvané frequency a phase. Pomocí parametru frequency se určuje, kolikrát se bude barvová mapa (resp. přechod reprezentovaný barvovou mapou) opakovat vůči původnímu (nemodifikovanému) vzorku. Čím vyšší je zadaná hodnota, tím rychlejší jsou barevné přechody.

Obrázek 5: Efekt postupné změny parametru frequency od 0,5 do 2,0

Parametrem phase se celý barevný vzorek posouvá, plynulou změnou tohoto parametru lze dosáhnout efektu známého pod názvem color cycling. Vzorec pro výpočet nové hodnoty value_new použité při vyhledání barvy v barvové mapě má následující tvar (funkce fmod(x, 1.0) vrací hodnoty v rozsahu 0,0–1,0):

value_new = fmod(value_old × frequency + phase, 1.0)

Obrázek 6: Efekt postupné změny parametru phase

Poznámka: pro vytvoření pátého a šestého obrázku byla použita definice Mandelbrotovy množiny uložená ve vkládaném souboru (viz druhá kapitola) pod názvem m_symetrie₀.

4. Druhý demonstrační příklad – modifikace procedurálních fraktálních textur

V dnešním druhém demonstračním příkladu je ukázáno využití parametru frequency. V prostřední řadě jsou zobrazené tři textury vytvořené pomocí jedné definice fraktálu. Zde se konkrétně jedná o Mandelbrotovu množinu. Jediné, čím se tyto textury od sebe odlišují, je právě parametr frequency. Totéž platí pro třetí řadu otexturovaných objektů – opět se jedná o stejné textury, které se odlišují pouze změněným parametrem frequency. Zdrojový text tohoto příkladu má tvar:

// ------------------------------------------------------------
// Další ukázka použití procedurální textury "mandel".
//
// rendering lze spustit příkazem:
//     povray +W1024 +H1024 +B100 +FN +D +Itextures.pov +Otextures.png
//
// !POZOR: scénu je nutné vykreslit se stejným horizontálním
//         i vertikálním rozlišením!
// ------------------------------------------------------------

#version 3.0
global_settings {
    assumed_gamma 2.2
}

#include "colors.inc"
#include "fractals.inc"        // soubor s definicí procedurálních textur

camera {                       // nastavení kamery
    orthographic               // bez perspektivy
    location < 0, 0, -1>       // pozice kamery
    right 15*x                 // šířka a výška snímané části scény
    up 15*y
    direction z                // směr pohledu kamery (k počátku)
}

light_source {                 // světelný zdroj
    <200, 200, -500>           // pozice
    color White                // barva
}

#declare COL1=-4.5;            // posuny objektů ve vztahu
#declare COL2= 0.0;            // k pomyslné mřížce
#declare COL3= 4.5;            // o rozměrech 3x3
#declare ROW1= 4.5;
#declare ROW2= 0.0;
#declare ROW3=-4.5;
#declare Z=0.0;

#declare OBJECT=box {          // testovací objekt - jednoduchý kvádr
    <-2,-2, 0>,
    < 2, 2, 1>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_10
        }
    }
    translate <COL1, ROW1, Z>
}


object {
    OBJECT
    texture {
        pigment {
            mandel_11
        }
    }
    translate <COL2, ROW1, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_12
        }
    }
    translate <COL3, ROW1, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_08
            frequency 1.0
        }
    }
    translate <COL1, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_08
            frequency 1.5
        }
    }
    translate <COL2, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_08
            frequency 2.0
        }
    }
    translate <COL3, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_10
            frequency 1.0
        }
    }
    translate <COL1, ROW3, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_10
            frequency 1.5
        }
    }
    translate <COL2, ROW3, Z>
}

object {
    OBJECT
    texture {
        pigment {
            mandel_10
            frequency 2.0
        }
    }
    translate <COL3, ROW3, Z>
}

// ------------------------------------------------------------
// finito
// ------------------------------------------------------------

Obrázek 7: Výsledek vykreslení druhého demonstračního příkladu

5. Starodávný program FRCT2POV a jeho využití při tvorbě fraktálních textur

Používání procedurálních textur vytvořených na základě fraktálů je oproti využití rastrových obrázků vykreslených v jiném (externím) programu sice výhodné, ať už z hlediska maximální kvality výsledku či nároků na operační paměť, ovšem ruční zadávání parametrů fraktálů přímo v POV-Rayi je namáhavé a neintuitivní. V počítačově dávné minulosti (konkrétně v roce 1994) však David Grossman vytvořil program nazvaný „Fractint to POV-Ray“, zkráceně pak FRCT2POV (jedná se o program určený pro MS-DOS, u kterého mohlo mít jméno souboru maximální délku osmi znaků). Pomocí tohoto programu je možné převádět parametry fraktálů (ne tedy až výsledné obrázky) vytvořené ve FractIntu do formátu POV-Raye, navíc se provede i transformace původní barvové palety na barvovou mapu (což zdaleka není totéž) – převod barev není přímočarý, provádí se různé optimalizace na počet barevných přechodů. Tento program pracuje korektně pro fraktály typu Mandelbrot (Mandelbrotova množina) a nepřímo i pro Magnet.

Tento program ve své podstatě z vlastních parametrů fraktálu vybírá hodnoty o maximálním počtu iterací, barvách a souřadnicích rohů výřezu fraktálu, který se má zobrazit. Na základě těchto informací je vytvořena barvová mapa, údaj o počtu iterací (ten se zkopíruje ze vstupu), hodnoty parametrů frequency a phase (ty jsou napevno nastaveny na základě konfigurace) a konečně je na takto vytvořenou výslednou texturu aplikována lineární transformace složená z operací translate (posun na střed otáčení), rotate (otáčení), scale (změna měřítka), rotate (zpětné otočení kvůli zkosení) a opět translate (posun textury zpět). Tato transformace je vypočtena na základě souřadnic rohů výřezu fraktálu – výsledná textura má rozměry +-1 v x-ové ose a +-0,75 v y-ové ose, ovšem konfigurací je možné tento poměr změnit.

Vzhledem k tomu, že se tento program pravděpodobně již nevyvíjí a ani se (opět pravděpodobně) nevyskytuje na Internetu, můžete pod tímto odkazem najít poslední funkční verzi, kterou mám k dispozici. Spustit ji lze prakticky v jakémkoli emulátoru MS-DOSu, popř. přímo v některé jeho grafické nadstavbě. Jedná se o freeware, free je ovšem nutné chápat tak, jak tomu bylo u DOSových programů v devadesátých letech minulého století.

6. Třetí demonstrační příklad – malá galerie fraktálních textur převedených programem FRCT2POV

V tomto demonstračním příkladu je použita velká část fraktálních textur uložených v externím souboru fractals.inc, jehož obsah byl získán převodem pomocí programu FRCT2POV. Textury jsou naneseny na objekt složený z koule, válce a krychle (takzvaný panák). Toto těleso bývá v demonstračních příkladech používáno velmi často právě při ukázkách různých možností texturování a/nebo osvětlování, protože obsahuje jak rovné povrchy (krychle), tak i povrchy zakřivené buď ve směru jedné osy (válec), tak i ve směru tří os (koule). Na posledních čtyřech objektech není nanesena textura Mandelbrotovy množiny ale textury dřeva získané ze standardních vkládaných souborů dodávaných spolu s POV-Rayem.

// ------------------------------------------------------------
// Vykreslení objektů pokrytých obrázky Mandelbrotových množin
//
// rendering lze spustit příkazem:
//     povray +W1024 +H768 +B100 +FN +D +Itextures.pov +Otextures.png
// ------------------------------------------------------------

#include "colors.inc"
#include "shapes.inc"
#include "textures.inc"
#include "fractals.inc"

#declare T01 = texture {mandel_01 phong 1}
#declare T02 = texture {mandel_02 phong 1}
#declare T03 = texture {mandel_03 phong 1}

#declare T04 = texture {mandel_04 phong 1}
#declare T05 = texture {mandel_05 phong 1}
#declare T06 = texture {mandel_06 phong 1}

#declare T07 = texture {mandel_07 phong 1}
#declare T08 = texture {mandel_08 phong 1}
#declare T09 = texture {mandel_09 phong 1}

#declare T10 = texture {mandel_10 phong 1}
#declare T11 = texture {m_rudy_1 phong 1}
#declare T12 = texture {mandelpot phong 1}

#declare T13 = texture {m_spirala_0 phong 1}
#declare T14 = texture {m_spirala_1 phong 1}
#declare T15 = texture {m_spirala_2 phong 1}

#declare T16 = texture {m_symetrie_0 phong 1}
#declare T17 = texture {m_symetrie_1 phong 1}
#declare T18 = texture {m_symetrie_2 phong 1}

#declare T19 = texture {m_zluty_0 phong 1}
#declare T20 = texture {m_zluty_1 phong 1}
#declare T21 = texture {m_zluty_2 phong 1}

#declare T22 = texture {f2p28 phong 1}
#declare T23 = texture {f2p29 phong 1}
#declare T24 = texture {DMFWood2 phong 1}

#declare T25 = texture {DMFWood3 phong 1}
#declare T26 = texture {DMFWood4 phong 1}
#declare T27 = texture {DMFWood5 phong 1}

camera {
   location <0, 5, -30>
   direction <0, 0,  1.35>
   look_at <0,5,0>
}

light_source {<0, 0, -1000> color red 0.658824 green 0.658824 blue 0.658824}
light_source {<150, 50, -200> color red 0.658824 green 0.658824 blue 0.658824}

#declare Stack =
union {
   object {UnitBox}
   object {Disk_Y translate <0,2,0>}
   sphere{<0, 4, 0>, 1}
}

#declare Dist = 0

#declare Row1 = 10.5
#declare Row2 = 3.5
#declare Row3 = -3.5

#declare Col1  = -12
#declare Col2  = -9
#declare Col3  = -6
#declare Col4  = -3
#declare Col5  = 0
#declare Col6  = 3
#declare Col7  = 6
#declare Col8  = 9
#declare Col9  = 12



object {
   Stack
   texture{T01}
   translate <Col1 Row1 Dist>
}

object {
   Stack
   texture{T02}
   translate <Col2 Row1 Dist>
}

object {
   Stack
   texture{T03}
   translate <Col3 Row1 Dist>
}

object {
   Stack
   texture{T04}
   translate <Col4 Row1 Dist>
}

object {
   Stack
   texture{T05}
   translate <Col5 Row1 Dist>
}

object {
   Stack
   texture{T06}
   translate <Col6 Row1 Dist>
}

object {
   Stack
   texture{T07}
   translate <Col7 Row1 Dist>
}

object {
   Stack
   texture{T08}
   translate <Col8 Row1 Dist>
}

object {
   Stack
   texture{T09}
   translate <Col9 Row1 Dist>
}

object {
   Stack
   texture{T10}
   translate <Col1 Row2 Dist>
}

object {
   Stack
   texture{T11}
   translate <Col2 Row2 Dist>
}

object {
   Stack
   texture{T12}
   translate <Col3 Row2 Dist>
}

object {
   Stack
   texture{T13}
   translate <Col4 Row2 Dist>
}

object {
   Stack
   texture{T14}
   translate <Col5 Row2 Dist>
}

object {
   Stack
   texture{T15}
   translate <Col6 Row2 Dist>
}

object {
   Stack
   texture{T16}
   translate <Col7 Row2 Dist>
}

object {
   Stack
   texture{T17}
   translate <Col8 Row2 Dist>
}

object {
   Stack
   texture{T18}
   translate <Col9 Row2 Dist>
}

object {
   Stack
   texture{T19}
   translate <Col1 Row3 Dist>
}

object {
   Stack
   texture{T20}
   translate <Col2 Row3 Dist>
}

object {
   Stack
   texture{T21}
   translate <Col3 Row3 Dist>
}

object {
   Stack
   texture{T22}
   translate <Col4 Row3 Dist>
}

object {
   Stack
   texture{T23}
   translate <Col5 Row3 Dist>
}

object {
   Stack
   texture{T24}
   translate <Col6 Row3 Dist>
}

object {
   Stack
   texture{T25}
   translate <Col7 Row3 Dist>
}

object {
   Stack
   texture{T26}
   translate <Col8 Row3 Dist>
}

object {
   Stack
   texture{T27}
   translate <Col9 Row3 Dist>
}

plane { z, 1.1 pigment {White} }

// ------------------------------------------------------------
// finito
// ------------------------------------------------------------

Obrázek 8: Galerie fraktálních textur, které jsem původně vytvořil v programu FractInt (poslední čtyři textury imitují dřevo, nejedná se o fraktály)

7. Procedurální textury specifikované funkcí (vzorcem)

Třetí verze POV-Raye obsahuje poměrně zajímavou variantu tvorby procedurální textury, která spočívá v tom, že se přímo do zdrojového kódu popisujícího trojrozměrnou scénu zapíše vzorec, pomocí kterého se vypočítá hodnota použitá pro výběr barvy z barvové mapy. V tomto vzorci se mohou vyskytovat nezávislé proměnné x, y a z, do nichž je dosazena souřadnice bodu, pro který se barva textury počítá. Výsledkem je potom reálné číslo, které je funkcí fmod() (zbytek po dělení) převedeno do rozsahu 0,0 až 1,0. Takto získaná hodnota se dosadí do vzorce uvedeného ve třetí kapitole a výsledek je již použit při výběru barvy z barvové mapy. V zadaném vzorci je možné použít jak základní algebraické operace, tak i volání goniometrických či logaritmických funkcí. Prozatím není možné použít ani podmínky ani smyčky (iterace); po jejich (teoretickém) přidání by bylo možné tímto typem textury nahradit všechny ostatní již dříve popsané procedurální textury. Jednalo by se o jednu z forem shaderů. Zápis má následující podobu:

pigment {
    function {sin(x*x+y*y)}
}

Obrázek 9: Procedurální textury zapsané pomocí vzorců (viz další kapitola), na než byla aplikována turbulence s mírou dosahující hodnoty 0,8

8. Čtvrtý demonstrační příklad – použití jednoduchých vzorců pro tvorbu textur

V dnešním posledním demonstračním příkladu je ukázána tvorba procedurálních textur zapsaných pomocí jednoduchých matematických výrazů. Při vykreslování není použita žádná explicitní barvová mapa i když její aplikaci by samozřejmě nic nebránilo, podobně jako u dalších typů procedurálních textur. Z tohoto důvodu je výsledkem obrázek ve stupních šedi, protože je v tomto případě vypočtená hodnota v každém bodu textury přímo mapována na všechny tři barvové složky (červenou, zelenou i modrou). První tři textury představují jednoduchý gradientní přechod s rozdílným sklonem, u dalších textur je buď v různé podobě využit výpočet vzdálenosti bodu od středu souřadné soustavy nebo se jedná o modifikované goniometrické funkce. Mimochodem, i obrázek číslo 9 vznikl vykreslením tohoto příkladu, pouze se změnila barvová mapa a na každou texturu byla aplikována turbulence s mírou dosahující hodnoty 0,8. Zdrojový kód tohoto demonstračního příkladu má tvar:

// ------------------------------------------------------------
// Ukázka použití procedurální textury zadané libovolnou funkcí.
//
// rendering lze spustit příkazem:
//     povray +W1024 +H1024 +B100 +FN +D +Itextures.pov +Otextures.png
//
// !POZOR: scénu je nutné vykreslit se stejným horizontálním
//         i vertikálním rozlišením!
// ------------------------------------------------------------

#version 3.0
global_settings {
    assumed_gamma 2.2
}

#include "colors.inc"

camera {                       // nastavení kamery
    orthographic               // bez perspektivy
    location < 0, 0, -1>       // pozice kamery
    right 15*x                 // šířka a výška snímané části scény
    up 15*y
    direction z                // směr pohledu kamery (k počátku)
}

light_source {                 // světelný zdroj
    <200, 200, -500>           // pozice
    color White                // barva
}

#declare COL1=-4.5;            // posuny objektů ve vztahu
#declare COL2= 0.0;            // k pomyslné mřížce
#declare COL3= 4.5;            // o rozměrech 3x3
#declare ROW1= 4.5;
#declare ROW2= 0.0;
#declare ROW3=-4.5;
#declare Z=0.0;

#declare OBJECT=box {          // testovací objekt - jednoduchý kvádr
    <-2,-2, 0>,
    < 2, 2, 1>
}

object {
    OBJECT
    texture {
        pigment {
            function {x}
        }
    }
    translate <COL1, ROW1, Z>
}


object {
    OBJECT
    texture {
        pigment {
            function {y}
        }
    }
    translate <COL2, ROW1, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {x+y}
        }
    }
    translate <COL3, ROW1, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {x*x+y*y}
        }
    }
    translate <COL1, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {sin(x)}
        }
    }
    translate <COL2, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {sin(x)+sin(y)}
        }
    }
    translate <COL3, ROW2, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {sin(x*x+y*y)}
        }
    }
    translate <COL1, ROW3, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {cos(x*x+y*y)}
        }
    }
    translate <COL2, ROW3, Z>
}

object {
    OBJECT
    texture {
        pigment {
            function {sin(x)*cos(y)}
        }
    }
    translate <COL3, ROW3, Z>
}

// ------------------------------------------------------------
// finito
// ------------------------------------------------------------

Obrázek 10: Procedurální textury zapsané pomocí vzorců

9. Obsah následující části seriálu

V další části seriálu o raytraceru POV-Ray si ukážeme, jakým způsobem je možné použít procedurální textury pro modulaci normál (normálových vektorů ploch tvořících hranici těles) neboli bump mapping. Jedná se o často používanou techniku, pomocí které je možné dosáhnout iluze zvlněného povrchu i v případě, že je povrch vykreslovaného tělesa dokonale rovný. Také si vysvětlíme způsob použití textur vytvořených z rastrových obrázků a volumetrických (objemových) dat.