3.4.11 Les modèles

POV-Ray utilise une méthode appelée surfaçage tridimensionnel de masse, pour définir la couleur, le bosselage et les autres propriétés d'une surface. Vous spécifiez la façon dont la texture varie sur la surface grâce à un modèle. Les modèles sont utilisés dans les spectres de pigments, de normales et de textures, ainsi que dans la densité des médias.

Tous les modèles sont tridimensionnels. Pour tous les points de l'espace, chaque modèle a une valeur unique. Les modèles ne s'appliquent pas autour d'une surface comme le papier peint sur un objet. Ils sont en 3d, et les objets sont creusés en eux, comme dans la pierre ou le bois.

Considérez un bloc de bois. Il contient des bandes claires et sombres qui sont des cylindres concentriques, les anneaux de croissance du bois. Sur la fin du bloc, vous voyez ces cercles concentriques. Sur sa longueur, vous voyez les lignes qui sont les veines. Toutefois, le modèle existe à travers tout le bloc. Si vous coupez ou creusez le bois, cela révélera le modèle interne. Similairement, un oignon est constitué de sphères concentriques, visibles seulement si vous le coupez. Le marbre est constitué de couches torturées de sédiments colorés, qui se sont durcis en pierre.

Ces modèles massifs peuvent être simulés en utilisant des fonctions mathématiques. D'autres modèles aléatoires, comme le granite, ou les bosses, ou les dents, peuvent être générés en utilisant un système numérique aléatoire et une fonction de bruit.

Dans chaque cas, les coordonnées x, y, z d'un point sur la surface, sont utilisées pour calculer quelque fonction mathématique, qui retourne une valeur numérique. Utilisée avec les spectres de couleurs ou de pigments, cette valeur donne la couleur à utiliser. Dans la déclaration de normale, la fonction du modèle modifie ou perturbe le vecteur normal de surface, pour donner une apparence bosselée. Avec un spectre de textures, cela détermine les combinaisons de textures complètes à utiliser. Avec les intensités de médias, cela donne les densités de particules ou de gaz.

Les sections suivantes décrivent chaque modèle. Voir les sections "Le pigment", "La normale", "Les textures modélisées" et "La densité" pour plus de détails sur la façon d'utiliser ces modèles. Sauf autre indication, tous les modèles utilisent l'onde de type ramp_wave par défaut, mais peuvent utiliser toute onde et peuvent être utilisés avec color_map, pigment_map, normal_map, slope_map, texture_map, density et density_map.

Note : quelques modèles ont un spectre de couleurs intégré qui ne donne pas de motif dans les tons de gris. Cela peut donner des résultats inattendus quand l'un de ces modèles est utilisé sans un spectre de couleurs défini par l'utilisateur, par exemple dans les fonctions ou le média.

3.4.11.1 Agate

Le modèle agate est un modèle en bande similaire au marbre, mais il utilise une fonction de turbulence spéciale, différente de la fonction traditionnelle. La turbulence traditionnelle peut aussi bien être utilisée, mais ce n'est pas nécessaire, car agate est déjà très turbulente. Vous pouvez contrôler le niveau de turbulence programmée par ajout du mot clé optionnel agate_turb, suivi d'une valeur numérique. Par exemple :

pigment {
	agate
	agate_turb 0.5
	color_map {MyMap}
}

Le modèle agate a un spectre de couleurs par défaut intégré, qui donne un modèle brun et blanc avec des transitions douces.

agate utilisé dans une normale :

normal {
	agate [Bump_Size]
	[MODIFIERS...]
}

3.4.11.2 'average'

Le modèle average n'est pas, techniquement, un type de modèle, mais il est dans cette liste car sa syntaxe est similaire aux autres modèles. Un type de modèle spécifie typiquement comment les couleurs et les normales sont choisies dans un pigment_map, texture_map, density_map ou normal_map, toutefois, average dit à POV-Ray de faire une moyenne de tous les modèles spécifiés. Il était fait, à l'origine, pour être utilisé dans une déclaration de normale, avec un spectre de normales, comme méthode pour spécifier plus d'un modèle de normale sur la même surface. Toutefois, il peut aussi être utilisé dans la déclaration de pigment, avec un spectre de pigments, ou dans une déclaration de texture, avec un spectre de textures, ou dans une densité de media avec un spectre de densités pour moyenner les couleurs.

Utilisé avec les pigments, la syntaxe est :

AVERAGED_PIGMENT:
	pigment {
		pigment_map {
			PIGMENT_MAP_ENTRY...
		}
	}
PIGMENT_MAP_ENTRY:
	[ [Weight] PIGMENT_BODY ]

Où Weight est une valeur numérique optionnelle, à 1.0 par défaut. Cette valeur est le poids relatif appliqué à ce pigment. Chaque PIGMENT_BODY est tout ce qui peut être dans une déclaration pigment {...}. Le mot clé pigment et les parenthèses {} peuvent être omis.

Note : les parenthèses [] font partie de PIGMENT_MAP_ENTRY. Elles ne sont pas des symboles de notation pour relever les parties optionnelles. Elles entourent chaque entrée de pigment_map.

Il peut y avoir de 2 à 256 entrées dans le spectre.

Par exemple :

pigment {
	average
	pigment_map {
		[1.0 Pigment_1]
		[2.0 Pigment_2]
		[0.5 Pigment_3]
	}
}

Les trois pigments sont calculés. La valeur du poids est multipliée par la couleur résultante. Puis elle est divisée par le poids total, qui ici est de 3.5. Cela fonctionne de la même manière avec texture_map ou density_map.

Utilisé avec un spectre de normales, dans une déclaration de normale, de multiples copies de la normale de surface d'origine sont créées et perturbées par chaque modèle. Les normales perturbées sont pesées, ajoutées et normalisées.

Voir les sections "Les spectres et les listes de pigments", "Les spectres et listes de normales", "Les spectres de textures" et "Les spectres et listes de densités" pour plus d'information.

3.4.11.3 'boxed'

Le modèle boxed crée un cube de 2x2x2 unités, centré sur l'origine. Il est calculé par : value = 1.0 - min(1, max(abs(X), abs(Y), abs(Z))). Il commence à 1.0 à l'origine et change pour une valeur minimale de 0.0 en approchant de tout plan à une unité de l'origine. Il reste à 0.0 pour toutes les aires au delà de cette distance. Ce modèle a été créé à l'origine pour les halos ou les médias, mais il peut être utilisé partout où un modèle peut prendre place.

3.4.11.4 'bozo'

Le modèle bozo est une fonction de bruit aléatoire très lissée, traditionnellement utilisée avec quelque turbulence pour créer les nuages. Le modèle spotted est identique au bozo, mais dans les versions précédentes, il n'autorisait pas l'ajout de turbulence. C'est maintenant possible pour tous les modèles, il y a donc redondance mais ils sont retenus tous deux pour la compatibilité. Le modèle bumps est aussi identique au bozo, quand il est utilisé en dehors de la déclaration de normale. Dans ce dernier cas, les bosses utilisent une méthode de perturbation de la normale de surface légèrement différente, avec une fonction de bruit similaire.

La fonction de bruit de bozo a les propriétés suivantes :

1. Elle est définie sur l'espace 3D, c'est-à-dire qu'elle prend x, y, et z et renvoie la valeur de bruit.

2. Si deux points sont éloignés, les valeurs de bruit sont relativement aléatoires.

3. Si deux points sont proches, les valeurs de bruit sont également proches.

Vous pouvez visualiser cela comme une grande pièce et un thermomètre allant de 0.0 à 1.0. Chaque point de la pièce a une température. Les points éloignés ont des températures relativement aléatoires. Les points proches ont des températures proches. La température change doucement, mais aléatoirement au cours de votre déplacement dans la pièce.

Maintenant, plaçons un objet dans cette pièce, avec un artiste. L'artiste mesure la température en chaque point de l'objet, et peint ce point avec une couleur dépendant de la température. Nous obtenons une texture bozo.

Le modèle bozo a un spectre de couleurs par défaut intégré qui donne un motif vert, bleu, rouge et blanc avec des transitions sèches.

Note : l'apparence du modèle bozo dépend du générateur de bruit utilisé. Le type par défaut est 2. Cela peut être changé en utilisant le mot clé noise_generator (voir la section "Les modificateurs de modèles / Les générateurs de bruit").

3.4.11.5 'brick'

Le modèle brick génère un modèle de briques. Les briques sont décalées d'une demi brique à chaque rang, dans les direction x et z. Un liant de mortier entoure chaque brique. La syntaxe est :

pigment {
	brick COLOR_1, COLOR_2
	[brick_size <Size>] [mortar Size]
}

où COLOR_1 est la couleur du joint, et COLOR_2 celle de la brique. Si aucune couleur n'est donnée, le défaut est un gris sombre et un rouge profond. La taille par défaut de l'ensemble brique et mortier est <8, 3, 4.5> unités. L'épaisseur du joint par défaut est de 0.5 unités. Ces valeurs peuvent être changées en utilisant les modificateurs de modèle optionnels brick_size et mortar. Vous pouvez aussi utiliser des déclarations de pigment au lieu des couleurs. Par exemple :

pigment {
	brick pigment {Jade}, pigment {Black_Marble}
}

Cet exemple utilise des normales :

normal {brick 0.5}

La valeur numérique est une taille de bosse optionnelle. Vous pouvez aussi utiliser des déclarations complètes de normales. Par exemple :

normal {
	brick normal {bumps 0.2}, normal {granite 0.3}
}

Avec les textures, la syntaxe est :

texture {
	brick texture {T_Gold_1A}, texture {Stone12}
}

Ceci est un modèle de groupement qui ne peut pas utiliser les modificateurs de type onde, color_map ou slope_map.

Le modèle brick a un spectre de couleurs par défaut intégré qui donne des briques rouges et un mortier gris.

3.4.11.6 'bumps'

Le modèle bumps était fait, à l'origine, pour être un modèle de normales. Il utilise une fonction de bruit aléatoire très lissée, qui créé une apparence de collines, quand la taille est grande, ou une peau d'orange, quand la taille est petite. Usuellement, les bosses sont séparées de 1 unité.

Quand il est utilisé comme modèle de normale, il utilise une fonction spéciale de perturbation de la normale. Cela signifie que ce modèle ne peut pas être utilisé avec les modificateurs de type normal_map, slope_map ou onde, dans une déclaration de normale.

Utilisé comme modèle de pigment ou de texture, le modèle de bosses est identique à bozo ou spotted, et est similaire aux bosses ordinaires, mais il n'est pas identique comme le sont la plupart des normales comparées aux pigments.

Note : l'apparence du modèle bump dépend du générateur de bruit utilisé. Le type par défaut est 2. Cela peut être changé en utilisant le mot clé noise_generator (voir la section "Les modificateurs de modèles / Les générateurs de bruit").

3.4.11.7 'cells'

Le modèle cells remplit un espace 3D avec des cubes unitaires. Chaque cube prend une valeur aléatoire entre 0 et 1.

cells n'est pas très adapté pour une normale car il n'a pas de transition adoucie d'une valeur grise à l'autre.

3.4.11.8 'checker'

Le modèle checker crée un motif de carrés alternés de deux couleurs. La syntaxe est :

pigment { checker [COLOR_1 [, COLOR_2]] [PATTERN_MODIFIERS...] }

Si aucune couleur n'est spécifiée, le bleu et le vert sont utilisés.

Ce modèle est une série de cubes d'une unité de côté. Imaginez des bandes de cubes de 1 centimètre de côté, faits de deux couleurs différentes en pâte à modeler. Maintenant, arrangeons-les en motif en damier, en les posant les unes près des autres, alternées rang après rang, pour avoir les couleurs alternées dans toutes les directions. Eventuellement, vous voudrez avoir un cube plus grand. Le modèle en damier sur chaque côté est ce que produit ce modèle appliqué à une boîte. Finalement, imaginez que vous découpez ce cube pour obtenir une sphère, ou une toute autre forme. C'est ce que vous donnera le modèle en damier sur un objet de n'importe quelle sorte.

Vous pouvez aussi utiliser des déclarations de pigment au lieu des couleurs. Par exemple :

pigment {checker pigment {Jade}, pigment {Black_Marble}}

Avec les normales, la syntaxe est :

normal {checker 0.5}

La valeur numérique est une taille de bosse optionnelle. Vous pouvez aussi utiliser des déclarations de normales complètes. Par exemple :

normal {
	checker normal {gradient x scale .2},
	normal {gradient y scale .2}
}

Avec les textures, la syntaxe est :

texture {checker texture {T_Wood_3A}, texture {Stone12}}

Le modèle checker a un spectre de couleurs par défaut intégré qui donne des pavés bleus et verts.

Cela remplace les textures en pavés des versions précédentes. Vous pouvez toujours utiliser ces dernières, mais cela sera obsolète dans les versions futures, donc le damier est mieux.

Ceci est un modèle de bloc, qui ne peut pas utiliser les modificateurs de type onde, color_map ou slope_map.

3.4.11.9 Les modèles craquelures

Le modèle crackle est une série de polygones aléatoires en pavés.

Il y a différents types :

Craquelure standard
Mathématiquement, crackle(p) = 0 est un diagramme Voronoi en 3-D d'un champ de points semi aléatoires, et crackle(p) < 0 est la distance de la série, selon le plus court chemin (un diagramme Voronoi est l'emplacement de points équidistants de leurs plus proches voisins, d'une série de points disjoints, comme les membranes de l'eau savonneuse l'est des centres des bulles).

Avec une grande échelle et aucune turbulence, cela donne un assez bon mur de pierre ou dallage.
Avec une petite échelle et aucune turbulence, cela donne un assez bon vernis de céramique.
En utilisant une grande turbulence, cela donne un bon marbre qui élimine le problème de couches apparemment parallèles du marbre traditionnel.

form

pigment {
	crackle form <FORM_VECTOR>
	[PIGMENT_ITEMS ...]
}
normal {
	crackle [Bump_Size]
	form <FORM_VECTOR>
	[NORMAL_ITEMS ...]
}

form détermine la combinaison linéaire des distances utilisées pour créer le modèle. C'est un vecteur.
Le premier composant détermine le multiple de la distance au point le plus proche à utiliser pour déterminer la valeur du modèle en un point particulier.
Le second composant détermine le coefficient appliqué à la distance qui suit immédiatement.
Le troisième composant à la distance de taille suivante.

Le standard est <-1, 1, 0> (aussi le défaut), correspondant à la différence dans les distances du plus proche point et du second plus proche dans le tableau de la cellule. Un autre form communément utilisé est <1, 0, 0>, correspondant à la distance au plus proche point, qui produit un modèle qui ressemble en gros à une collection aléatoire de sphères ou de cellules en intersection.
D'autres form peuvent créer de très intéressant effets, mais c'est mieux de garder la somme des coefficients basse.
Si la valeur calculée finale est trop basse ou trop haute, le pigment résultant sera saturé par la couleur basse ou haute du spectre de couleurs. Dans ce cas, essayez de multiplier le vecteur par une constante.

Metric

pigment {
	crackle metric METRIC_VALUE
	[PIGMENT_ITEMS ...]
}
normal {
	crackle [Bump_Size]
	metric METRIC_VALUE
	[NORMAL_ITEMS ...]
}

Le changement de la mesure modifie la fonction utilisée pour déterminer quel centre de cellule est le plus proche, dans le but de déterminer dans quelle cellule va un point particulier. La fonction de distance euclidienne standard a une mesure de 2. Son changement modifie la frontière des cellules. Une valeur de 3, par exemple, cause une courbure des frontières, tandis qu'une très large valeur contraint les frontières à un très petit nombre d'orientations possibles.
Le défaut est 2, comme utilisé par la texture de craquelure standard.
Des valeurs autres que 1 ou 2 peuvent conduire à des temps de rendu substanciellement allongés, car la méthode utilisée pour les calculer n'est pas très efficace.

offset

pigment {
	crackle offset OFFSET_VALUE
	[PIGMENT_ITEMS ...]
}
normal {
	crackle [Bump_Size]
	offset OFFSET_VALUE
	[NORMAL_ITEMS ...]
}

L'offset est utilisé pour déplacer le modèle de l'espace standard xyz selon une quatrième dimension.
Il peut être utilisé pour arrondir les parties anguleuses d'une texture cellulaire cellulaire ou d'un champ de niveaux en évitant aux distances de tomber à zéro.
Il peut être aussi utilisé pour déplacer les valeurs calculées dans une fourchette spécifique si le résultat est saturé par une des extrémités du spectre de couleurs.
L'offset par défaut est zéro.

solid

pigment {
	crackle solid
	[PIGMENT_ITEMS ...]
}
normal {
	crackle [Bump_Size]
	solid
	[NORMAL_ITEMS ...]
}

Provoque la génération de la même valeur pour tous les points d'une cellule spécifique. Cela a des applications pratiques dans la fabrication de fenêtres étamées ou de pierres à pavé. Il n'y a pas de place pour le joint, mais il peut être créé par superposition, ou application de texture, d'une texture craquelée standard en contenant une unie.
Le défaut de ce paramètre est la désactivation.

3.4.11.10 'cylindrical'

Le modèle cylindrical crée un cylindre d'une unité de rayon le long de l'axe y. Il est calculé par : value = 1.0-min(1, sqrt(X^2 + Z^2)). Il commence à 1.0 à l'origine et varie pour une valeur minimale de 0.0 comme il approche de l'axe y à une unité de distance. Il reste à 0.0 pour toutes les aires au delà de cette distance. Ce modèle a été originellement créé pour le halo ou le média, mais il peut être utilisé partout où peut se placer un modèle.

3.4.11.11 'density_file'

Le modèle density_file est un modèle bitmap 3D qui occupe un cube d'une unité, à la position <0, 0, 0> à <1, 1, 1>. Le fichier de données est un fichier binaire brut créé par POV-Ray est appelé format df3. La syntaxe pourvoit à la possibilité d'ajouter d'autres formats dans le futur. Ce modèle a été créé à l'origine pour le halo ou le média, mais il peut être utilisé partout où un modèle a sa place. La syntaxe est :

pigment {
	density_file df3 "filename.df3"
	[interpolate Type] [PIGMENT_MODIFIERS...]
}

où "filename.df3" est le nom de fichier du fichier de données.

En tant que modèle de normale, la syntaxe est :

normal {
	density_file df3 "filename.df3" [, Bump_Size]
	[interpolate Type]
	[NORMAL_MODIFIERS...]
}

Le numérique optionnel Bump_Size doit suivre le nom de fichier, et tout autre modificateur doit le suivre.

Le modèle de densité occupe un cube d'une unité sans prendre en compte les dimensions en voxels. Il reste à 0.0 pour toutes les aires au-delà du cube. Les données, entre 0 et 255, dans le cas d'une résolution 8 bit, sont transformées en valeur numérique entre 0.0 et 1.0.

Le mot clé interpolate peut être spécifié par ajouter de l'interpolation. La valeur par défaut est zéro, ne donnant aucune interpolation. Une valeur de un donne une interpolation tri-linéaire, une valeur de deux spécifie une interpolation tri-cubique.

Voyez les scènes d'exemple pour le fichier de données include\spiral.df3, et les scènes qui les utilisent : scenes\textures\patterns\densfile.pov, scenes\interior\media\galaxy.pov.

3.4.11.12 'dents'

Le modèle dents était désigné, à l'origine, pour être un modèle de normale. Il est spécialement intéressant avec les textures métalliques. Il donne l'impression que des creux ont été faits avec un marteau. Usuellement les creux sont séparés d'une unité.

En tant que modèle de normale, il utilise une fonction spéciale de perturbation de la normale. Cela signifie qu'il ne peut pas être utilisé avec les modificateurs de type normal_map, slope_map ou onde, dans une déclaration de normale.

En tant que modèle de pigment ou de texture, le modèle de creux est similaire au creux ordinaire, mais il n'est pas identique comme le sont la plupart des normales comparées aux pigments.

3.4.11.13 'facets'

normal {
	facets [coords SCALE_VALUE | size FACTOR]
	[NORMAL_ITEMS...]
}

Le modèle facets est défini pour être utilisé comme une normale, il causera une erreur en tant que pigment.
Il y a deux formes de modèles de facettes. L'une est plus adaptée aux surfaces arrondies, et l'autre aux surfaces plates.

Si coords est spécifié, le modèle de facettes crée des facettes avec une taille du même ordre que celle donnée dans SCALE_VALUE. Cette version de facettes est plus adaptée aux surfaces plates, mais elle fonctionne aussi avec les surfaces courbes. Les frontières des facettes coïncident avec les frontières des cellules dans le modèle de craquelure standard. La version coords de ce modèle peut être similaire à un modèle de craquelures avec la spécification solid.

Si size est spécifié, La texture à facettes utilise une fonction différente qui crée des facettes seulement sur des surfaces courbes. Le FACTOR détermine comment de nombreuses facettes sont créées, avec de petites valeurs créant plus de facettes, mais ce n'est en relation avec aucune mesure du monde réel. Le même facteur créera le même modèle de facettes sur une sphère de toute taille.
Ce modèle crée des facettes en cisaillant les vecteurs de normale vers les vecteurs les plus proches dans une grille perturbée de vecteurs de normale. A cause de cela, si une surface a des vecteurs de normale qui ne varient pas selon un axe ou plus, il n'y aura pas de frontière de facette le long de ces axes.

3.4.11.14 Les modèles de fractale

Les modèles de fractales supportées dans POV-Ray :

La série de Mandelbrot avec des exposants jusqu'à 33.(la formule pour cela est : z(n+1) = z(n)^p + c, où p est l'exposant correspondant).
L'équivalent de la série de Julia.
Les fractales magnet1 et magnet2 (qui sont dérivées de quelques transfomations de renormalisation magnétique; vois l'aide de fractint pour les détails).
Les versions 'Mandelbrot' et 'Julia' sont supportées.

Pour les séries de Mandelbrot et de Julia, de hauts exposants seront ralentis pour deux raisons :

Pour les exposants 2,3 et 4 un algorithme optimisé est utilisé. Des esposants plus élevés utilisent un algorithme générique pour abaisser un nombre complexe en un exposant entier, et cela est un peu plus lent que la version optimisée de certains exposants.
Plus l'exposant est élevé, plus ce sera lent. Cela parce que la quantité d'opérations nécessaires pour rabattre un nombre complexe en un exposant entier est directement proportionnelle à l'exposant. Cela signifie que l'exposant 10 sera (très) grossièrement deux fois plus lent que l'exposant 5.

Syntaxe :

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]

Où :

ITERATIONS est le nombre d'itérations de l'algorithme.

COMPLEX est un vecteur 2D donnant un nombre complexe.

MAGNET_TYPE est 1 ou 2.

exponent est un entier entre 2 et 33. S'il n'est pas donné, le défaut est 2.

interior et exterior spécifient des algorithmes de coloration spéciaux. Vous pouvez spécifier l'un d'eux ou les deux en même temps. Ils ne fonctionnent qu'avec les modèles de fractale.
EXTERIOR_TYPE et INTERIOR_TYPE sont des valeurs entières entre 0 et 6 (inclusif). Quand ce n'est pas spécifié, la valeur par défaut de INTERIOR_TYPE est 0, et 1 pour EXTERIOR_TYPE.
FACTOR est un numérique. La valeur retournée du modèle est multipliée par FACTOR avant d'être retournée. Cela peut être utilisé pour dimensionner la fourchette de valeur du modèle lors de l'utilisation de la coloration intérieure et extérieure (cela est souvent nécessaire pour obtenir l'effet voulu). La valeur par défaut de FACTOR est 1.

Les différentes valeurs de EXTERIOR_TYPE et INTERIOR_TYPE ont les significations suivantes :

0 : retourne juste 1
1 : pour l'extérieur : le nombre d'itérations jusqu'au crédit divisé par ITERATIONS.
Note : ceci n'est pas dimensionné par FACTOR (puisqu'il est dimensionné en interne par 1/ITERATIONS).
Pour interior : la valeur absolue du point le plus petit dans l'orbite du point calculé
2 : partie réelle du dernier point dans l'orbite
3 : partie imaginaire du dernier point dans l'orbite
4 : partie réelle au carré du dernier point dans l'orbite
5 : partie imaginaire au carré du dernier point dans l'orbite
6 : valeur absolue du dernier point dans l'orbite

Exemple :

box {
	<-2,-2, 0>, <2, 2, 0.1>
	pigment {
		julia <0.353, 0.288>, 30
		interior 1, 1
		color_map { 
			[0 rgb 0]
			[0.2 rgb x]
			[0.4 rgb x+y]
			[1 rgb 1]
			[1 rgb 0]
		}
	}
}

3.4.11.15 La fonction comme modèle

Vous autorise l'utilisation d'un bloc function { } comme modèle.

pigment {
	function { USER_DEFINED_FUNCTIONS }
	[PIGMENT_MODIFIERS...]
}

Déclaration d'une fonction :
Par défaut, une fonction prend trois paramètres (x,y,z) et vous n'avez pas à spécifier les noms de paramètres lors de la déclaration. Lors de l'utilisation d'un identificateur, les paramètres doivent être spécifiés.

#declare Foo = function { x + y + z}
pigment {
	function { Foo(x, y, z) }
	[PIGMENT_MODIFIERS...]
}

D'un autre côté, si vous avez besoin de plus ou moins de trois paramètres lors de la déclaration de la fonction, vous devez aussi explicitement spécifier les noms de paramètres.

#declare Foo = function(x, y, z, t) { x + y + z + t}
pigment {
	function { Foo(x, y, z, 4) }
	[PIGMENT_MODIFIERS...]
}

Utilisation d'une fonction dans une normale :

#declare Foo = function { x + y + z}
normal {
	function { Foo(x, y, z) } [Bump_Size]
	[MODIFIERS...]
}

3.4.11.16 La fonction image

Syntaxe :

function Width, Height { FUNCTION_BODY }

Pas vraiment un modèle, mais donné ici par convenance. Ce mot clé définit au nouveau type d'image bitmap interne. Les pixels de l'image sont dérivés de Function_Body, avec Function_Body pouvant être un fonction régulière, une fonction modèle ou une fonction pigment. Dans le cas d'une fonction pigment, l'image en sortie sera en couleur, dans le cas d'une fonction modèle ou régulière, l'image en sortie sera dans des tons de gris. Toutes les variantes de pigments dans des tons de gris sont aussi disponibles dans l'utilisation de la syntaxe d'une fonction régulière. Dans les autres cas, l'image utilisera 16 bits par composant.

Note : les fonctions sont évaluées sur le plan x-y. Cela est différent d'un type d'image modèle pour la raison qu'il rend l'utilisation de fonctions uv plus facile.

La hauteur et la largeur spécifient la résolution de l'image bitmap interne qui en résulte. L'image est prise depuis la région carrée <0, 0, 0>, <1, 1, 0>.

La déclaration function peut être utilisée partout où une spécification d'image comme tga ou png peut être utilisée. Quelques utilisations incluent la création de champs de niveaux depuis des textures procédurales, ou de placage d'une texture 3D, ou d'une fonction autour d'un cylindre ou de son extrusion le long d'un axe.

Exemples:

plane {
	y,-1
	pigment {
		image_map {
			function 10, 10 {
				pigment {checker 1, 0 scale .5}
			}
		}
		rotate x*90
	}
}

height_field {
	function 200, 200 {
		pattern {
			bozo
		}
	}
	translate -0.5
	scale 10
	pigment {rgb 1}
}

Note : pour les champs de niveaux et les autres situations où la couleur n'est pas nécessaire, il est plus simple d'utiliser function n,n {pattern{...}} plutôt que function n,n {pigment{...}}. Les fonctions modèle retournent un scalaire, pas un vecteur de couleurs, donc un modèle est en tons de gris.

3.4.11.17 Gradient

L'un des plus simples modèles est le modèle gradient. Il est spécifié comme :

pigment {
	gradient <Orientation>
	[PIGMENT_MODIFIERS...]
}

où <Orientation> est le vecteur pointant dans la direction de mélange des couleurs. Par exemple :

pigment {gradient x}	// les bandes de couleur varient à mesure que vous vous déplacez
			// le long de la direction "x".

produit un série de douces bandes de couleur en couche. Les points à x = 0 ont la première couleur de la palette. A mesure que x augmente, elle passe lentement à la dernière couleur à x = 1. Là, il reprend la première couleur, et varie graduellement à la dernière à x = 2. Avec les versions antérieures de POV-Ray 3.5, le modèle s'inverse pour les valeurs négatives. Ce n'est plus le cas [1]. L'utilisation de gradient y ou de gradient z fait varier les couleurs selon l'axe y ou z. Tout vecteur peut être utilisé, mais x, y et z sont les plus communs.

En tant que modèle de normale, le gradient donne une apparence de vague. La syntaxe est :

normal {
	gradient <Orientation> [, Bump_Size]
	[NORMAL_MODIFIERS...]
}

où le vecteur <Orientation> est un paramètre obligatoire, mais le numérique Bump_Size, qui suit, est optionnel.

Note : la virgule est requise surtout si Bump_Size est négatif.

[1] Si seulement la fourchette -1 à 1 était utilisée dans l'ancien gradient, par exemple dans un sky_sphere, cela peut être remplacé par le modèle planar ou marble avec inversion du spectre de couleurs. Aussi faites tourner le modèle sur d'autres orientations que y. Une solution plus générale est d'utiliser function{abs(x)} comme modèle au lieu de gradient x et de même pour gradient y et gradient z.

3.4.11.18 Granite

Ce modèle utilise une simple fonction de bruit 1/f, fractale, pour donner un bon modèle de granite. Il est utilisé avec des spectres de couleurs créatives, dans stones.inc, pour créer de magnifiques textures empilées de pierre.

Comme modèle de normale, il crée une surface extrêmement bosselée, comme un chemin empierré.

Note : l'apparence du modèle granite dépend du générateur de bruit utilisé. Le type par défaut est 2. Cela peut être changé par l'utilisation du mot clé noise_generator (voir la section "Les modificateurs de modèles / Le générateur de bruit").

3.4.11.19 'hexagon'

Le modèle hexagon est un modèle de bloc qui génère un motif répétitif d'hexagones dans le plan x-y. Dans ce cas, imaginez des bâtons de section hexagonale, parallèles à l'axe des y, et groupés comme dans l'image suivante. Trois couleurs séparées peuvent être spécifiées, comme ceci :

pigment {
	hexagon [COLOR_1 [, COLOR_2 [, COLOR_3]]]
	[PATTERN_MODIFIERS...]
}

Le modèle hexagone

Les trois couleurs se répèteront dans le modèle avec COLOR_1 centrée sur l'origine, COLOR_2 dans la direction +z et COLOR_3 sur les autres côtés. Chaque côté fait une unité de long. Les bâtons hexagonaux de couleur s'étendent à l'infini dans les directions +y et -y. Si aucune couleur n'est spécifiée, les couleurs bleu, vert et rouge seront utilisées par défaut.

Vous pouvez aussi utiliser les déclarations de pigment à la place des couleurs. Par exemple :

pigment {
	hexagon
	pigment {Jade},
	pigment {White_Marble},
	pigment {Black_Marble}
}

Avec les normales, la syntaxe est :

normal {hexagon 0.5}

La valeur numérique est une taille de bosse optionnelle. Vous pouvez aussi utiliser les déclarations complètes de normales. Par exemple :

normal {
	hexagon
	normal {gradient x scale .2},
	normal {gradient y scale .2},
	normal {bumps scale .2}
}

Avec les textures, la syntaxe est :

texture {
	hexagon
	texture {T_Gold_3A},
	texture {T_Wood_3A},
	texture {Stone12}
}

Le modèle hexagon a un spectre de couleurs par défaut intégré qui donne des pavés rouges, bleus et verts.

Ceci est un modèle de bloc qui ne peut pas utiliser les modificateurs de type onde, color_map ou slope_map.

3.4.11.20 Le modèle image

Au lieu de placer les couleurs de l'image sur l'objet comme une application d'image, un image_pattern spécifie une texture complète (couleur, pigment, normale ou texture) basée sur la valeur de gris en ce point.
Cette valeur de gris est recherchée dans une liste et l'élément correspondant est alors utilisé pour la texture en ce point particulier. Pour les valeurs entre les éléments de la liste, une texture moyenne est calculée.
Cela prend la spécification d'une image standard et a une option, use_alpha qui fonctionne comme use_color ou use_index.

Syntaxe :

PIGMENT:
	pigment {
		IMAGE_PATTERN
		color_map { COLOR_MAP_BODY } |
		colour_map { COLOR_MAP_BODY } | 
		pigment_map { PIGMENT_MAP_BODY }
	}

NORMAL:
	normal {
		IMAGE_PATTERN [Bump_Size]
		normal_map { NORMAL_MAP_BODY }
	}

TEXTURE:
	texture {
		IMAGE_PATTERN
		texture_map { TEXTURE_MAP_BODY }
	}

IMAGE_PATTERN
	image_pattern {
		BITMAP_TYPE "bitmap.ext"
		[IMAGE_MAP_MODS...]
	}
IMAGE_MAP_MOD:
	map_type Type | once | interpolate Type | use_alpha
ITEM_MAP_BODY:
	ITEM_MAP_IDENTIFIER | ITEM_MAP_ENTRY...
ITEM_MAP_ENTRY:
	[ GRAY_VALUE  ITEM_MAP_ENTRY... ]

C'est aussi utile pour créer des masques de textures, comme ce qui suit :

texture {
	image_pattern {tga "image.tga" use_alpha}
	texture_map {
		[0 Mytex]
		[1 pigment {transmit 1}]
	}
}

Note : ce modèle utilise une image pour obtenir les valeurs de gris. Si vous voulez exactement les mêmes possibilités mais avec des valeurs de gris venant d'un pigment, vous pouvez utiliser pigment_pattern.

3.4.11.21 Leopard

Léopard crée un modèle géométrique régulier de tâches circulaires. La formule utilisée est : value = Sqr((sin(x)+sin(y)+sin(z))/3)

3.4.11.22 'marble'

Le modèle marble est très similaire au modèle gradient x. Le modèle gradient utilise un type d'onde ramp_wave par défaut, ce qui signifie qu'il utilise les couleurs de la palette de 0.0 à 1.0 à la position x = 1, mais là, il saute à la première couleur pour x > 1 et répète le modèle encore et encore. Toutefois, le modèle marbre utilise le type onde triangle_wave, dans lequel il utilise la palette de 0 à 1, puis inverse le spectre pour aller de 1 vers 0. Par exemple :

pigment {
	gradient x
	color_map {
		[0.0 color Yellow]
		[1.0 color Cyan]
	}
}

Ceci passe du jaune au cyan, puis repasse abruptement au jaune pour reprendre. Le remplacement de gradient x par marble, fait passer de jaune à cyan, tandis que x va de 0.0 à 0.5, puis va de cyan à jaune entre 0.5 et 1.0.

Les précédentes versions ne vous autorisaient pas le changement des types d'onde. Maintenant que vous pouvez changer pour tout type d'onde, la distinction entre ces deux modèles n'est qu'un problème de type d'onde par défaut.

Avec la turbulence, et une palette de couleur appropriée, cela donne des veines de couleur dans un marbre réaliste, un jade ou tout autre type de pierre. Par défaut, marble n'a pas de turbulence.

Le modèle marble a un spectre de couleurs par défaut intégré qui donne un motif rouge, noir et blanc avec des transitions douces et abruptes.

3.4.11.23 Le modèle objet

Le modèle object prend un objet en entrée. Il génère un modèle à liste de couleurs, de deux éléments. Le fait qu'un point appartienne à un élément ou à l'autre dépend du fait qu'il est dans l'objet spécifié ou non.

Les objets utilisés dans le modèle object ne peuvent avoir de texture et doivent être pleins - ce sont les mêmes limitations que pour bounded_by et clipped_by.

Syntaxe :

object {
	OBJECT_IDENTIFIER | OBJECT {}
	LIST_ITEM_A, LIST_ITEM_B
}

Où OBJ_IDENTIFIER est l'objet cible (qui doit être déclaré), ou utilisant la syntaxe complète d'un objet. LIST_ITEM_A et LIST_ITEM_B sont les couleurs, pigments, ou tout ce que le modèle contrôle. LIST_ITEM_A est utilisé pour tous les points en-dehors de l'objet, et LIST_ITEM_B est utilisé pour tous les points dans l'objet.

Exemple :

pigment {
	object {
		myTextObject
		color White
		color Red
	}
	turbulence 0.15
}

Note : Ceci est un modèle de bloc qui ne peut pas utiliser les modificateurs de type onde, color_map ou slope_map.

3.4.11.24 'onion'

onion est un modèle de sphères concentriques, comme les couches d'un oignon. Value = mod(sqrt(Sqr(X)+Sqr(Y)+Sqr(Z)), 1.0). Chaque couche a une unité d'épaisseur.

3.4.11.25 Le modèle pigment

Utilise tout pigment comme modèle. Au lieu d'utiliser le modèle directement sur l'objet, un pigment_pattern convertit d'abord le pigment en tons de gris. Pour chaque point, la valeur de gris est recherchée dans une liste et l'élément correspondant est alors utilisé pour la texture en ce point. Pour des valeurs entre deux éléments de la liste, une texture moyenne est calculée.
Les éléments de texture peuvent être une couleur, un pigment, une normale ou une texture et sont spécifiés dans un color_map, pigment_map, normal_map ou texture_map.
Il prend une spécification de pigment standard.

Syntaxe :

PIGMENT:
	pigment {
		pigment_pattern { PIGMENT_BODY }
		color_map { COLOR_MAP_BODY } |
		colour_map { COLOR_MAP_BODY } |
		pigment_map { PIGMENT_MAP_BODY }
	}

NORMAL:
	normal {
		pigment_pattern { PIGMENT_BODY } [Bump_Size]
		normal_map { NORMAL_MAP_BODY }
	}

TEXTURE:
	texture {
		pigment_pattern { PIGMENT_BODY }
		texture_map { TEXTURE_MAP_BODY }
	}

ITEM_MAP_BODY:
	ITEM_MAP_IDENTIFIER | ITEM_MAP_ENTRY...
ITEM_MAP_ENTRY:
	[ GRAY_VALUE  ITEM_MAP_ENTRY... ]

Ce modèle est aussi utile quand les modèles parents et enfants doivent être transformés indépendamment l'un de l'autre. La transformation de pigment_pattern n'affectera pas les textures enfants. Quand l'une des textures enfants doit être transformée, faites l'application au MAP_ENTRY spécifique.

Cela peut être utilisé avec tout pigment, allant d'un simple damier à des pigments emboîtés très complexes. Par exemple :

pigment {
	pigment_pattern {
		checker White, Black
		scale 2
		turbulence .5
	}
	pigment_map {
		[0, checker Red, Green scale .5]
		[1, checker Blue, Yellow scale .2]
	}
}

Note : ce modèle utilise un pigment pour obtenir des valeurs de gris. Si vous voulez obtenir le modèle depuis une image, vous devez utiliser image_pattern.

3.4.11.26 'planar'

Le modèle planar crée une raie horizontale à plus ou moins 1 au dessus et au dessous du plan X-Z. Il est calculé par : value =1.0 - min(1, abs(Y)). Il commence à 1.0 à l'origine et passe à un minimum de 0.0 quand la valeur Y approche de la distance 1 du plan X-Z. Il reste à 0.0 pour toutes les aires au delà de cette distance. Ce modèle à été originellement créé pour le halo ou le média, mais il peut être utilisé partout où un modèle a sa place.

3.4.11.27 'quilted'

Il était, à l'origine, fait pour être un modèle de normale. Il est nommé ainsi car il peut créer un motif comme un molleton, ou une surface dallée. Les carrés sont des cubes 3-D d'une unité de côté.

Comme modèle de normale, il utilise une fonction de perturbation de la normale spéciale. Donc il ne peut pas être utilisé avec les modificateurs de type normal_map, slope_map ou onde, dans une déclaration de normale.

En tant que modèle de pigment, ou modèle de texture, il est similaire à la normale molletonnée, mais pas identique comme la plupart des normales comparées aux pigments.

Les deux paramètres control0 et control1, ajustent la courbure de la couture ou de la gouge entre les carreaux.

La syntaxe est :

pigment { quilted [QUILTED_MODIFIERS...] }
QUILTED_MODIFIERS:
	control0 Value_0 | control1 Value_1 | PIGMENT_MODIFIERS

Les valeurs doivent être généralement gardées entre 0.0 et 1.0. La valeur par défaut est 1.0. Pensez au joint aux intersections, comme à une ligne inclinée.

Modèle molleton avec c0=0 et différentes valeurs de c1

Modèle molleton avec c0=0.33 et différentes valeurs de c1

Modèle molleton avec c0=0.67 et différentes valeurs de c1

Modèle molleton avec c0=1 et différentes valeurs de c1

Cette pente droite peut être courbée en ajustant les valeurs de contrôle. L'ajustement se fait en haut et en bas de la courbe. Une valeur de 0 aux deux bouts donnera une pente linéaire, comme au-dessus, procurant un bord franc. Une valeur de 1 donnera une courbe en forme de "s", aboutissant à un bord plus arrondi.

La syntaxe d'utilisation comme une normale est :

normal {
	quilted [Bump_Size]
	[QUILTED_MODIFIERS...]
}
QUILTED_MODIFIERS:
	control0 Value_0 | control1 Value_1 | PIGMENT_MODIFIERS

3.4.11.28 'radial'

Le modèle radial est un mélange radial autour de l'axe des y. La couleur pour 0.0 commence dans la direction +x, et plaque la palette de couleurs d'est en ouest, avec 0.25 dans la direction des -z, 0.5 en -x, 0.75 à +z et 1.0 à +x. Typiquement, il est utilisé avec une modificateur de fréquence, pour créer des bandes multiples qui radient depuis l'axe des y. Par exemple :

pigment {
	radial color_map {[0.5 Black][0.5 White]}
	frequency 10
}

crée 10 bandes blanches et 10 bandes noires radiant autour de l'axe y.

Le modèle radial a un spectre de couleurs par défaut intégré qui donne un motif jaune, magenta et cyan avec de douces transitions.

3.4.11.29 'ripples'

Le modèle ripples a été fait comme modèle de normale. Il rend la surface semblable à des ondulations sur l'eau. Elles rayonnent de 10 endroits aléatoires, dans une aire cubique de une unité de <0, 0, 0> à <1, 1, 1>. Retaillez le modèle pour rendre les centres plus proches ou plus éloignés.

Usuellement, les ondulations sont séparées d'une unité. Le mot clé frequency change cet espace. Le mot clé phase peut être utilisé pour faire bouger les ondulations pour une animation réaliste.

Le nombre de centres des ondulations peut être changé avec le paramètre global :

global_settings {number_of_waves Count}

n'importe où dans la scène. Cela affecte toute la scène. Vous ne pouvez pas changer le nombre de centres pour chaque modèle, individuellement. Voir la section "Number_Of_Waves" pour les détails.

En tant que modèle de normales, les ondulations utilisent une fonction de perturbation spéciale de la normale. Donc, ce modèle ne peut pas être utilisé avec des modificateurs de type normal_map, slope_map ou onde, dans une déclaration de normale.

Dans un modèle de pigment ou de texture, ce modèle est similaire à la normale ondulation, mais n'est pas identique comme le sont la plupart des normales comparées aux pigments.

3.4.11.30 'slope'

Le modèle slope utilise la normale de surface pour calculer l'inclinaison en un point donné. Il crée alors la valeur du modèle dépendante de l'inclinaison et optionnellement de l'altitude. Il peut être utilisé pour les pigments, les normales et les textures, mais pas pour les densités de média. Pour les pigments, la syntaxe est :

pigment {
	slope {
		<Direction> [, Lo_slope, Hi_slope ]
		[ altitude <Altitude> [, Lo_alt, Hi_alt ]]
	}
	[PIGMENT_MODIFIERS...]
}

La valeur de l'inclinaison à un point donné est dépendante de l'angle entre le vecteur <Direction> et la normale de surface en ce point. Par exemple :
- Quand la normale de surface pointe à l'opposé du vecteur <Direction> (180 degrés), l'inclinaison est 0.0.
- Quand la normale de surface est perpendiculaire au vecteur <Direction> (90 degrés), l'inclinaison est 0.5.
- Quand la normale de surface est parallèle au vecteur <Direction> (0 degrés), l'inclinaison est 1.0.

En utilisant la variante la plus simple de la syntaxe :

slope {<Direction>}

la valeur du modèle pour un point donné est identique à celle de l'inclinaison. <Direction> est un vecteur tridimensionnel et sera habituellement <0,-1, 0> pour les paysages, mais toute direction peut être utilisée.

En spécifiant Lo_slope et Hi_slope vous avez plus de contrôle :

slope {<Direction>, Lo_slope, Hi_slope}

Lo_slope et Hi_slope spécifient la fourchette d'inclinaisons utilisées, ainsi vous pouvez contrôler quelles sont les valeurs d'inclinaisons correspondantes aux valeurs de modèle. Lo_slope est la valeur d'inclinaison qui donne 0.0 et Hi_slope est la valeur d'inclinaison qui donne 1.0.

Par exemple, si vous avez un height_field et <Direction> mis à <0,-1, 0>, alors les valeurs de l'inclinaison varieront seulement de 0.0 à 0.5 parce que les champs de niveaux ne peuvent pas avoir de surplombs. Si vous ne spécifiez pas Lo_slope et Hi_slope, vous devez garder en mémoire que la texture des aires horizontales doit être à 0.0 et que la texture pour les aires verticales à 0.5 lors de la construction de texture_map. La partie entre 0.5 et 1.0 n'est pas utilisée ici. Mais, en plaçant Lo_slope et Hi_slope respectivement à 0.0 et 0.5, la fourchette de l'inclinaison sera étendue sur tout le spectre de texture, et ce spectre peut alors être défini de 0.0 à 1.0.

En ajoutant un vecteur optionnel <Altitude> :

slope {
	<Direction>
	altitude <Altitude>
}

le modèle sera non seulement influencé par l'inclinaison mais aussi par un gradient spécial. <Altitude> est un vecteur tridimensionnel qui spécifie la direction du gradient. Quand <Altitude> est spécifié, la valeur du modèle est une moyenne de la valeur de l'inclinaison et du gradient. Les poids sont les longueurs des vecteurs <Direction> et <Altitude>. Aussi si <Direction> est plus long que <Altitude> cela signifie que l'inclinaison a plus d'effet sur le résultat que le gradient. Sinon, si <Altitude> est plus long, alors le gradient a plus d'effet que l'inclinaison.

En ajoutant le vecteur <Altitude>, le gradient par défaut est défini de 0 à 1 unité le long de l'axe spécifié. C'est bon si votre objet est défini dans cette fourchette, sinon une correction est nécessaire. Cela peut être fait avec les paramètres optionnels Lo_alt et Hi_alt :

slope {
	<Direction>
	altitude <Altitude>, Lo_alt, Hi_alt
}

Ils définissent la fourchette du gradient le long de l'axe défini par le vecteur <Altitude>.

Par exemple, avec un vecteur <Altitude> placé sur y et un objet allant de -3 à 2 sur l'axe y, les paramètres Lo_alt et Hi_alt doivent être respectivement à -3 et 2.

Note :

Vous pouvez utiliser le mot clé turbulence dans les définitions du modèle d'inclinaison mais il peut donner des résultats inattendus. turbulence est une distortion tridimensionnelle d'un modèle. Puisque l'inclinaison est seulement définie sur les surfaces des objets, une turbulence tridimensionnelle n'est pas applicable sur ce composant. Toutefois, si vous utilisez l'altitude, le composant altitude du modèle sera affecté par la turbulence.
Si votre objet est plus grand que la fourchette d'altitude que vous avez spécifié, vous pouvez avoir des discontinuitées inattendues. Dans ce cas il vaut mieux ajuster les valeurs de Lo_alt et Hi_alt pour qu'elles correspondent à votre objet.
Le modèle d'inclinaison ne fonctionne pas pour sky_sphere, car c'est une caractéristique d'arrière-plan qui n'a pas de surface. De même, il ne fonctionne pas pour les densités de média.

3.4.11.31 'spherical'

Le modèle spherical crée une sphère d'une unité de rayon centrée sur l'axe y. Il est calculé par : value = 1.0-min(1, sqrt(X^2 + Y^2 + Z^2)). Il commence à 1.0 à l'origine et passe à une valeur maximale de 0.0 quand il approche de l'unité de distance à l'origine, dans toutes les directions. Il reste à 0.0 pour toutes les aires au delà de cette distance. Ce modèle a été créé originellement pour le halo ou le média, mais il peut être utilisé partout où un modèle a sa place.

3.4.11.32 'spiral1'

Il crée une spirale qui s'enroule autour de l'axe des z, comme une vis. Dans une coupe selon le plan x-y, cela ressemble aux bras d'une galaxie spirale. Sa syntaxe est :

pigment {
	spiral1 Number_of_Arms
	[PIGMENT_MODIFIERS...]
}

La valeur Number_of_Arms détermine le nombre de bras qui s'enroulent autour de l'axe z.

Comme modèle de normale, la syntaxe est :

normal {
	spiral1 Number_of_Arms [, Bump_Size]
	[NORMAL_MODIFIERS...]
}

où la valeur Number_of_Arms est requise, mais le numérique Bump_Size qui le suit est optionnel.

Note : la virgule est requise, spécialement quand Bump_Size est négatif.

Il utilise le type d'onde triangle_wave par défaut, mais il peut avoir tout autre type d'onde.

3.4.11.33 'spiral2'

Il crée une double spirale s'enroulant autour de l'axe z, comme spiral1, sauf que ce sont deux spirales s'enroulant en sens opposé. Le résultat ressemble à un filet de basket ou à une pomme de pin. Le centre du tournesol a aussi une similitude avec le modèle à double spirale. Sa syntaxe est :

pigment {
	spiral2 Number_of_Arms
	[PIGMENT_MODIFIERS...]
}

La valeur Number_of_Arms détermine le nombre de bras de la spirale autour de l'axe z. Comme modèle de normale, la syntaxe est :

normal {
	spiral2 Number_of_Arms [, Bump_Size]
	[NORMAL_MODIFIERS...]
}

où la valeur Number_of_Arms est requise, mais le numérique Bump_Size qui le suit est optionnel.

Note : la virgule est requise, spécialement quand Bump_Size est négatif.

Il utilise le type d'onde triangle_wave par défaut, mais il peut avoir tout autre type d'onde.

3.4.11.34 'spotted'

Il est identique au modèle bozo. Les précédentes versions n'autorisaient pas de turbulence avec le modèle tacheté. Maintenant que tous peuvent utiliser la turbulence, il n'y a plus de différence entre ces deux modèles. Voir la section "Le modèle bozo" pour les détails.

3.4.11.35 'waves'

Il était originellement fait pour les modèles de normales. Il simule une surface comme des vagues sur l'eau. Il ressemble au modèle ripples, sauf que les éléments sont circulaires et larges. L'effet est de faire des vagues qui ressemblent plus à celles de l'océan profond. Elles rayonnent de 10 positions aléatoires dans un cube d'une unité, de <0, 0, 0> à <1, 1, 1>. Retaillez le modèle pour rendre les centres plus proches ou plus écartés.

D'habitude, les vagues sont éloignées d'une unité. Le mot clé frequency change cet espace entre les vagues. Le mot clé phase peut être utilisé pour faire bouger les vagues pour une animation réaliste.

Le nombre de centres peut être changé avec le paramètre global :

global_settings {number_of_waves Count}

n'importe où dans la scène. Cela affecte la totalité, c'est-à-dire que vous ne pouvez pas avoir un nombre de centres de vagues différent entre des modèles individuels. Voir la section "Number_Of_Waves" pour les détails.

En tant que modèle de normale, il utilise une fonction de perturbation spéciale de la normale. Donc, il ne peut pas être utilisé avec les modificateurs de type normal_map, slope_map ou onde, dans une déclaration de normale.

Pour un modèle de pigment ou de texture, il est similaire à la normale de vagues, mais pas comme la plupart des normales comparées aux pigments.

3.4.11.36 'wood'

Il consiste en cylindres concentriques centrés sur l'axe z. Correctement colorés, les bandes ressemblent aux anneaux de croissance et aux veines du vrai bois. Une petite quantité de turbulence doit être ajoutée pour plus de réalisme. Par défaut, wood n'a pas de turbulence.

Au contraire d'autres modèles, le type d'onde par défaut est triangle_wave. Cela signifie que comme marble, wood utilise les valeurs 0.0 à 1.0 d'une palette de couleurs, puis les répète dans l'ordre inverse. Toutefois, vous pouvez utiliser tout autre type d'onde.

Le modèle wood a un spectre de couleurs par défaut intégré qui donne un modèle brun clair et brun foncé avec des transitions soudaines.

3.4.11.37 'wrinkles'

Il a été originellement fait pour les modèles de normale. Il utilise un modèle de bruit de type 1/f, similaire au granite, mais les éléments y sont plus tranchés. Il peut être utilisé pour simuler du cellophane ou de l'aluminium froissé. Il fait aussi une excellente texture de stuc.

En tant que modèle de normale, il utilise une fonction spéciale de perturbation de la normale. Donc, il ne peut pas être utilisé avec les modificateurs de type normal_map, slope_map ou onde, dans une déclaration de normale.

Comme modèle de pigment ou de texture, il est similaire à la normale, mais pas comme la plupart des normales, comparées aux pigments.

Note : l'apparence du modèle rides dépend du générateur de bruit utilisé. Le type par défaut est 2. Cela peut être changé en utilisant le mot clé noise_generator (voir la section "Les modificateurs de modèles / Les générateurs de bruit").