PATTERN_MODIFIER:
	BLEND_MAP_MODIFIER | AGATE_MODIFIER | DENSITY_FILE_MODIFIER |
	QUILTED_MODIFIER | BRICK_MODIFIER | SLOPE_MODIFIER |
	noise_generator Number| turbulence <Amount> |
	octaves Count | omega Amount | lambda Amount |
	warp { [WARP_ITEMS...] } | TRANSFORMATION
BLEND_MAP_MODIFIER:
	frequency Amount | phase Amount | ramp_wave | triangle_wave |
	sine_wave | scallop_wave | cubic_wave | poly_wave [Exponent]
AGATE_MODIFIER:
	agate_turb Value
BRICK_MODIFIER:
	brick_size Size | mortar Size 
DENSITY_FILE_MODIFIER:
	interpolate Type
SLOPE_MODIFIERS:
	<Altitude>
	<Lo_slope, Hi_slope>
	<Lo_alt, Hi_alt>
QUILTED_MODIFIER:
	control0 Value | control1 Value
PIGMENT_MODIFIER:
	PATTERN_MODIFIER | COLOR_LIST | PIGMENT_LIST |
	color_map { COLOR_MAP_BODY } | colour_map { COLOR_MAP_BODY } |
	pigment_map { PIGMENT_MAP_BODY } | quick_color COLOR |
	quick_colour COLOR
COLOR NORMAL_MODIFIER:
	PATTERN_MODIFIER | NORMAL_LIST |
	normal_map { NORMAL_MAP_BODY } | slope_map { SLOPE_MAP_BODY } |
	bump_size Amount
TEXTURE_PATTERN_MODIFIER:
	PATTERN_MODIFIER | TEXTURE_LIST |
	texture_map { TEXTURE_MAP_BODY }
DENSITY_MODIFIER:
	PATTERN_MODIFIER | DENSITY_LIST | COLOR_LIST |
	color_map { COLOR_MAP_BODY } | colour_map { COLOR_MAP_BODY } |
	density_map { DENSITY_MAP_BODY }

dist_exp : 0
falloff : 2.0
frequency : 1.0
lambda : 2.0
major_radius : 1
map_type : 0
noise_generator : 2
octaves : 6
omega : 0.5
orientation : <0, 0, 1>
phase : 0.0
poly_wave : 1.0
strength : 1.0
turbulence : <0, 0, 0>

3.4.12.1 La transformation de modèles

translate, rotate, scale, transform et matrix sont les modificateurs de modèle les plus courants. Pour les détails, voir la section "Les transformations".

Ces modificateurs peuvent être placés dans les déclarations de pigment, de normale, de texture et de densité pour changer la position, la taille et l'orientation des modèles.

Les transformations sont faites dans l'ordre de la spécification. Toutefois, en général, l'ordre des transformations, relatif aux autres modificateurs de modèle, comme la turbulence, color_map et autres spectres, n'est pas important. Par exemple, changer la taille avant ou après la turbulence, ne fait pas de différence. La turbulence est faite en premier, puis le changement de taille, sans s'occuper de l'ordre dans le texte. Toutefois, l'ordre relatif aux déclarations warp est important. Voir "Les torsions" pour les détails.

3.4.12.2 La fréquence et la phase

Les modificateurs frequency et phase agissent comme un modificateur de taille et de déplacement pour des spectres de mélange. Ils n'ont d'effet que lorsque des spectres de mélange sont utilisés. Ces spectres sont color_map, pigment_map, normal_map, slope_map, density_map et texture_map. Ce propos utilise un spectre de couleurs comme exemple, mais les mêmes principes s'appliquent aux autres.

Le mot clé frequency ajuste le nombre de fois qu'une couleur se répète dans un cycle du modèle. Par exemple, gradient place les valeurs 0 à 1 du spectre de couleurs sur les emplacements x entre 0 et 1. En ajoutant frequency 2.0, la palette se place deux fois dans le même intervalle. La même chose peut être faite en utilisant scale 0.5*x, ainsi le mot clé frequency n'est pas aussi utile pour les modèles comme le gradient.

Toutefois, le modèle radial applique une fois la palette autour de l'axe y. Si vous voulez deux copies de la palette (ou 3, ou 10, ou 100), vous devez construire une palette plus grande. L'ajout de frequency 2.0 oblige la palette à se répéter une fois de plus par révolution. Essayez ceci :

pigment {
	radial
	color_map {[0.5 color Red][0.5 color White]}
	frequency 6
}

Le résultat est six jeux de rayures radiales rouges et blanches autour de l'objet.

Le nombre après la fréquence peut être de toute valeur. Celles plus grandes que 1.0 multiplient les copies du spectre utilisé. Entre 0.0 et 1.0, une fraction du spectre est utilisée. Les valeurs négatives inversent le spectre.

La valeur phase fait glisser les entrées de la palette, la faisant débuter et finir à un endroit différent. Dans l'exemple précédent, si vous rendez des pages successives avec phase 0 puis phase 0.1, phase 0.2 etc., vous pouvez créer une animation qui fera tourner les rayures. La même chose peut être aisément faite en faisant tourner le pigment radial avec rotate y*Angle, mais il y a des cas ou la phase est plus commode.

Quelquefois vous créez un magnifique spectre de couleur gradient ou bois, mais vous voulez l'ajuster avec précision. Vous pouvez réordonner le spectre de couleurs, mais c'est une galère. Un ajustement de phase fera tout glisser, sans modifier la taille. Essayez d'animer un pigment mandel pour un effet de rotation de la palette de couleurs.

Ces valeurs fonctionnent par application de la formule :

New_Value = fmod ( Old_Value * Frequency + Phase, 1.0 ).

La fréquence et la phase n'ont pas d'effet sur les modèles de bloc checker, brick et hexagon, ni sur image_map, bump_map ou material_map. Ils n'ont pas d'effet dans les déclarations de normales, utilisées avec les bumps, dents, quilted ou wrinkles, car ces modèles de normale ne peuvent pas utiliser normal_map ou slope_map.

Ils peuvent être utilisés avec les modèles de normale ripples et waves, même si ces deux modèles ne peuvent pas utiliser normal_map ou slope_map. Là, la fréquence ajuste l'espace entre les éléments, et la phase peut être ajustée entre 0.0 et 1.0, pour provoquer un mouvement relatif de l'élément par rapport à son centre, pour les animations.

3.4.12.3 Les formes d'ondes

POV-Ray vous permet d'appliquer des formes d'onde variées à la fonction du modèle avant de l'utiliser sur un spectre de mélange. Ces spectres sont color_map, pigment_map, normal_map, slope_map, density_map et texture_map.

La plupart de ces modèles utilisent les entrées dans l'ordre de 0.0 à 1.0. La différence est facilement visible quand ils sont utilisés comme modèles de normales, sans spectre. Les modèles comme gradient ou onion, génèrent une fissure qui ressemble à une pente qui décroît rapidement. Cela est le type d'onde ramp_wave, qui est le défaut pour la plupart des modèles. Pourtant, le bois et le marbre font ensuite une inversion de 1.0 à 0.0. Le résultat est une onde qui monte vers un pic, puis descend à nouveau, selon un type triangle_wave. Dans les versions précédentes, il n'était pas possible de changer le type d'onde. Vous pouviez simuler une onde triangulaire sur un modèle avec ramp_wave, en dupliquant les entrées de la carte dans l'ordre inverse, toutefois, on ne pouvait pas utiliser une vague en pente sur le bois ou le marbre.

Maintenant, tout modèle, avec palette, peut avoir son type d'onde réécrit. Par exemple :

pigment {wood color_map {MyMap} ramp_wave}

Disponibles également, les types sine_wave, scallop_wave, cubic_wave et poly_wave. Ces types sont les plus utiles dans les modèles de normale, comme type de spectre d'inclinaisons intégré. Le sine_wave prend le zigzag d'une onde en pente, et la transforme en vague de doux roulis, avec des transitions lissées. Le scallop_wave utilise la valeur absolue d'une onde sinusoïdale, ressemblant à du velours côtelé, lorsque la taille est petite, ou à un paquet de cylindres, quand la taille est grande. Le cubic_wave est une délicate courbe cubique de 0.0 à 1.0, avec une inclinaison nulle au début et à la fin. Le poly_wave est une fonction exponentielle. Il est suivi par une valeur numérique optionnelle qui spécifie l'exposant. Par exemple, poly_wave 2 commence doucement et monte rapidement à la fin, tandis que poly_wave 0.5 monte rapidement au début et s'aplanit à la fin. Si aucune valeur n'est donnée, le défaut est 1.0 qui donne une fonction linéaire identique à ramp_wave.

Bien que tous ces types d'onde peuvent être utilisés pour les pigments, normales, textures ou densités, leur effet n'est pas aussi évident que sur les normales.

Les types d'onde n'ont pas d'effet sur les modèles de bloc checker, brick, object et hexagon, et pas plus sur image_map, bump_map ou material_map. Ils n'ont également aucun effet dans les déclarations de normale, quand ils sont utilisés avec bumps, dents, quilted, ripples, waves ou wrinkles, car ces modèles ne peuvent pas utiliser normal_map ou slope_map.

3.4.12.4 Les générateurs de bruit

Il y a trois générateurs de bruit intégrés. Le changement de noise_generator changera l'apparence des modèles basés sur le bruit, comme bozo et le granit.

• noise_generator 1 le bruit qui était utilisé dans POV_Ray 3.1
• noise_generator 2 version 'à fourchette corrigée' de l'ancien bruit, elle ne montre pas les plateaux vus avec noise_generator 1
• noise_generator 3 génère le bruit de Perlin

Le défaut est noise_generator 2

Note : le générateur de bruit peut aussi être placé dans global_settings

3.4.12.5 La turbulence

Le mot clé turbulence est toujours supporté pour la compatibilité, mais il est préférable d'utiliser la caractéristique warp {turbulence}, qui n'a pas de limitation de turbulence dans l'ordre de transformation (la turbulence est toujours appliquée d'abord, avant toute taille, déplacement ou rotation, quelque soit l'ordre spécifié). Pour une discussion détaillée, voir La turbulence versus la turbulence par torsion.

L'ancien style de turbulence est géré différemment dans les textures agate, marbre, spiral1, spiral2 et bois.

3.4.12.6 Les torsions

La déclaration warp est un modificateur de modèle similaire à la turbulence. La turbulence fonctionne en prenant le point d'évaluation du modèle et en le poussant dans une série de sauts aléatoires. warp pousse le point selon des voies géométriques bien définies, non aléatoires. La déclaration warp dépasse aussi quelques limitations de la turbulence traditionnelle et des transformations en donnant à l'utilisateur plus de contrôle sur l'ordre d'application au modèle, de la turbulence, de la transformation et des modificateurs de torsion.

Actuellement, il y a sept types de torsions mais la syntaxe a été faite pour autoriser de futures extensions. La turbulence par torsion fournit un autre moyen de spécifier la turbulence. Les autres modifient le modèle selon une méthode géométrique.

La syntaxe pour l'utilisation de warp est :

WARP:
	warp { WARP_ITEM }
WARP_ITEM:
	repeat <Direction> [REPEAT_ITEMS...] |
	black_hole <Location>, Radius [BLACK_HOLE_ITEMS...] | 
	turbulence <Amount>; [TURB_ITEMS...]
	cylindrical [ orientation VECTOR | dist_exp FLOAT ]
	spherical [ orientation VECTOR | dist_exp FLOAT ]
	toroidal [ orientation VECTOR | dist_exp FLOAT |
		major_radius FLOAT ]
	planar [ VECTOR , FLOAT ]
REPEAT_ITEMS:
	offset <Amount> |
	flip <Axis>
BLACK_HOLE_ITEMS:
	strength Strength | falloff Amount | inverse |
	repeat <Repeat> | turbulence <Amount>
TURB_ITEMS:
	octaves Count | omega Amount | lambda Amount

Vous pouvez avoir autant de déclarations de torsions séparées que vous voulez dans chaque modèle. La disposition des déclarations de torsion par rapport aux autres modificateurs comme color_map ou turbulence n'est pas important. Toutefois, cette position relative aux autres et aux transformations a des conséquences. Les torsions et les transformations multiples sont calculées dans l'ordre de leur spécification. Par exemple, si vous faites un déplacement, puis une torsion, ou une torsion puis un déplacement, le résultat peut être différent.

3.4.12.6.1 Torsion trou noir

Une torsion black_hole est ainsi nommée car elle est similaire aux réels trous noirs. Comme dans le réel, vous ne pouvez pas le voir. La seule façon de détecter sa présence est par l'effet qu'il a sur son entourage.

Prenez, par exemple, le grain d'un bois. En utilisant la turbulence et d'autres fonctions modificatrices de texture, vous pouvez avoir un belle apparence aléatoire du grain. Mais il est régulier dans son imprévisibilité, il est aléatoirement régulier ! L'ajout d'un trou noir vous autorise la création d'un dérangement localisé du grain en de multiples endroits. Le trou noir peut avoir l'effet d'aspirer la texture alentour (comme la chose réelle), ou de la repousser. Dans le dernier cas, cela aura l'apparence d'un noeud dans le bois. Dans ce texte, nous utilisons régulièrement le grain du bois, car il est idéal pour expliquer les trous noirs. Toutefois, les trous noirs peuvent être utilisés avec toutes les textures. L'effet du trou noir peut être spécifié. Par défaut, il aspire avec une force exponentielle (carré inverse). Vous pouvez changer cela, si vous le voulez.

Les trous noirs peuvent être utilisés partout où une torsion est autorisée. La syntaxe est :

BLACK_HOLE_WARP:
	warp {
		black_hole <Location>, Radius
		[BLACK_HOLE_ITEMS...]
	}
BLACK_HOLE_ITEMS:
	strength Strength | falloff Amount | inverse | type Type | 
	repeat <Repeat> | turbulence <Amount>

Le minimum requis est le mot clé black_hole suivi par un vecteur <Location> suivi d'une virgule et d'un numérique Radius. Les trous noirs affectent tous les points à l'intérieur d'une région sphérique autour de la position, de rayon Radius. Cela est optionnellement suivi par tout nombre d'autres mots clés qui contrôlent la torsion de la texture.

Le mot clé falloff peut être utilisé avec une valeur numérique pour spécifier la puissance de déclin du trou noir. Le défaut est deux. La force du point noir, en un point donné, avant l'application du modificateur strength est donné ici.

Premièrement, convertir la distance entre le point et le centre du trou noir en proportion (0 à 1) de sa distance au bord. Un point sur le bord sera 0.0; au centre, il sera 1.0; à mi chemin, il sera 0.5, et ainsi de suite. Mentalement, vous pouvez considérer cela comme un facteur de proximité. Une proximité de 1.0 est au plus proche du centre (c'est-à-dire au centre), une proximité de 0.0 est aussi loin que possible du centre, tout en restant dans le trou noir, et une proximité de 0.5 signifie que le point est exactement à mi chemin entre les deux.

Appelons cette valeur c. Augmenter c à la puissance spécifiée dans falloff. Par défaut, falloff est 2, donc c'est c au carré. La valeur résultat est la force du trou noir à cette position, et elle est utilisée, après application du facteur de taille strength, pour déterminer le taux de perturbation du point dans l'espace. Par exemple, si c est 0.5, la force est 0.25, si c est 0.25, elle est de 0.125. Mais si c est exactement 1.0, la force est 1.0. Rappelez vous que plus c est petit, plus le point est éloigné du centre du trou noir. L'utilisation de la puissance par défaut de 2, permet de constater qu'au fur et à mesure que c se réduit, la force baisse exponentiellement selon un carré inverse. En bon français, la force est plus importante près du centre qu'en bordure.

En augmentant falloff, vous pouvez augmenter la magnitude du déclin. Une grande valeur signifiera que les points près du périmètre seront durement affectés, et que ceux près du centre seront fortement affectés. Une valeur de 1.0 pour falloff donnera un effet linéaire. Un point à mi chemin sera affecté d'une moitié de la force. Une valeur de falloff plus petite que un, mais positive, signifie que la force croît vers l'extérieur. Cela peut avoir des utilités, mais c'est un effet marginal. Rappelez vous que l'effet du trou noir cesse au-delà de son périmètre. Donc les points sur le périmètre seront fortement affectés, et ceux juste au-delà, pas du tout. Cela aboutirait à une bordure visible, comme une sphère. Une valeur de falloff nulle signifierait que la force serait de 1.0 en tout point du trou noir, puisque tout nombre plus grand que 0 à la puissance de 0 est 1.0.

Le mot clé strength peut être spécifié avec une valeur numérique pour vous donner un peu plus de contrôle sur la perturbation d'un point par le trou noir. Basiquement, la force d'un trou noir est multipliée par la valeur de strength, dont le défaut est 1.0. Si vous le mettez à 0.5, par exemple, tous les points dans le trou noir seront déplacés de seulement la moitié de la valeur habituelle. Si vous mettez 2.0, ils seront doublement déplacés.

Il y a, malgré tout, un plus à l'exemple précédent : le mouvement est limité au maximum de la distance originale au centre. Donc un point à 0.75 unités du centre, ne peut se déplacer que de 0.75 unités, que ce soit vers le centre ou vers l'extérieur, sans se soucier de la valeur strength. Le résultat est que vous aurez une zone exclusive près du centre, où tous les points dont la force finale excède ou est 1.0, seront déplacés d'une quantité fixe.

Si inverse est activé, les points sont éloignés du centre, au lieu d'être attirés.

Le mot clé repeat suivi d'un vecteur vous autorise la simulation de l'effet de plusieurs trous noirs, sans avoir à les déclarer explicitement. C'est un vecteur qui dit à POV-Ray d'utiliser le trou noir en de multiples lieux. L'utilisation de repeat divise logiquement votre scène en cubes, le premier étant localisé entre <0, 0, 0> et <Repeat>. Supposons que votre vecteur de répétition est <1, 5, 2>. Le premier cube sera entre <0, 0, 0> et <1, 5, 2>. Il se répète, donc il y en aura un autre en <-1,-5,-2>, <1, 5, 2>, <2, 10, 4> et ainsi de suite dans toutes les directions, ad infinitum.

Quand vous utilisez repeat, le centre du trou noir ne donne pas une position absolue, mais un décalage dans chaque bloc. On ne peut utiliser que des décalages positifs. Les valeurs négatives donneront des résultats imprévus.

Supposons que votre centre était <0.5, 1, 0.25> et le vecteur de répétition <2, 2, 2>. Cela nous donne un bloc à <0, 0, 0> et <2, 2, 2>, etc. Les centres des trous noirs seront <0, 0, 0> + <0.5, 1.0, 0.25>, c'est-à-dire <0.5, 1.0, 0.25>, et <2, 2, 2> + <0.5, 1.0, 0.25>, c'est-à-dire <2.5, 3.0, 2.25>.

A cause de la façon dont les répétitions sont calculées en interne, il y a une restriction sur les valeurs que vous spécifiez pour le vecteur répétition. Normalement, chaque trou noir doit être totalement contenu dans chaque bloc, sans débordement chez le voisin. Cela signifie que, pour chaque dimension x, y et z, le décalage au centre ne peut pas être plus petit que le rayon, et la répétition pour cette dimension doit être supérieure ou égale au centre plus le rayon, car toute autre valeur autoriserait le débordement du trou noir chez le voisin. Dit différemment, pour chaque x, y et z

Radius <= Offset ou Center <= Repeat - Radius.

Si le vecteur de répétition est trop petit pour remplir ce critère, il sera augmenté et un message d'alerte sera généré. Si le centre est inférieur au rayon, il sera aussi modifié, mais il n'y aura aucun message.

Notez que cela ne signifie pas que vous ne pouvez pas avoir de chevauchement de trous noirs. Vous le pouvez, et cela produit des effets très utiles. Cette restriction ne s'applique qu'à la répétition d'un même trou noir. Vous pouvez déclarer un second trou noir, qui se répète également, et ses éléments pourront chevaucher heureusement le premier, et donner les interactions appropriées. Il est légal d'avoir une répétition à 0, pour toute direction, signifiant que POV-Ray ne le répètera pas dans cette direction.

turbulence ne peut être utilisé dans un trou noir qu'avec repeat. Il ajoute un élément aléatoire dans la répétition des trous noirs, donnant un aspect plus naturel. Un bon exemple est une série de nœuds dans le bois - l'artifice serait visible s'ils étaient tous à une distance identique du précédent.

Le vecteur turbulence est une mesure ajoutée individuellement à chaque trou noir, multipliant chaque axe du vecteur par une quantité aléatoire, de 0 à 1. L'actuelle position résultante du centre du trou noir pour cet élément répété particulier est aléatoire (mais logique, donc le rendu peut être répété) et quelque part dans les coordonnées précédentes. Il y a un plus avec l'utilisation de la turbulence, identique au vecteur de répétition. Vous ne pouvez pas spécifier une valeur qui pourrait faire sortir le trou noir de son bloc.

Résumé, pour chaque x, y et z, le décalage du centre doit être >= au rayon, et la valeur de la répétition doit être >= centre + rayon + turbulence. L'exception est que la répétition peut être de 0 pour toute dimension, ce qui signifie qu'il n'y aura pas de répétition dans cette direction.

Quelques exemples sont donnés par

warp {
	black_hole <0, 0, 0>, 0.5
}
warp {
	black_hole <0.15, 0.125, 0>, 0.5
	falloff 7
	strength 1.0
	repeat <1.25, 1.25, 0>
	turbulence <0.25, 0.25, 0>
	inverse
}
warp {
	black_hole <0, 0, 0>, 1.0
	falloff 2
	strength 2
	inverse
}

3.4.12.6.2 La torsion répétée

La torsion repeat cause la répétition d'une partie du modèle. Il prend un morceau du modèle, et en fait de multiples copies côte à côte. Il a plusieurs utilisations, mais il a été fait pour faciliter la modélisation des textures plaquées de bois. Les plaques sont faites en prenant de très fines parties d'une poutre, et en les plaçant côte à côte sur quelque matériel en fond. Vous voyez des motifs en anneau presque identiques, côte à côte, mais chacun est une tranche de, peut-être, quelques millimètres d'épaisseur.

La syntaxe est :

REPEAT_WARP:
	warp { repeat <Direction> [REPEAT_ITEMS...] }
REPEAT_ITEMS:
	offset <Amount> | flip <Axis>

Le vecteur repeat spécifie la direction de chaque répétition de modèle, et la largeur de l'aire de répétition. Il doit être entièrement déployé sur un axe. En d'autres mots, deux de ses composants doivent être à 0. Par exemple :

pigment {
	wood
	warp {repeat 2*x}
}

qui signifie que de x = 0 à x = 2, vous aurez le modèle. Mais de x = 2 à x = 4 vous aurez exactement la même chose, déplacée de deux unités dans la direction x. Pour l'évaluer, vous prenez simplement la coordonnée x modulo 2. Malheureusement, vous avez une duplication exacte, ce qui n'est pas réaliste.

Le vecteur de décalage optionnel offset donne le déplacement du modèle à chaque répétition. Par exemple :

pigment {
	wood
	warp {repeat x*2 offset z*0.05}
}

signifie que nous faisons glisser la première copie de x = 0 à x = 2 en z = 0, mais de x = 2 à x = 4, nous décalons de z = 0.05. Pour les intervalles 4 à 6, nous passons à z = 0.10. Pour la copie n, nous sommes à z = 0.05*n. Ainsi, chaque copie est légèrement différente. Il n'y a pas de restriction sur le vecteur de décalage.

Enfin, le vecteur flip permet de faire une copie miroir du modèle. La première copie n'est pas inversée, la seconde oui, etc. C'est un vecteur à trois composants, mais chacun d'eux est traité comme une valeur booléenne, disant si une inversion doit se faire sur cet axe. Par exemple :

pigment {
	wood
	warp {repeat 2*x flip <1, 1, 0>}
}

signifie que toute copie doit être en miroir sur les axes x et y, mais pas sur z. Une valeur non nulle autorise l'inversion. L'importance de la valeur n'est pas prise en compte.

3.4.12.6.3 La turbulence versus la torsion turbulente

Le langage de POV-Ray contient une ambiguïté et une limitation sur la façon dont vous spécifiez la turbulence et les transformations, comme translate, rotate, scale, matrix et transform. La turbulence est faite en premier, puis les transformations sont faites dans l'ordre du texte. Par exemple, ceci :

pigment {
	wood
	scale .5
	turbulence .2
}

fonctionne exactement comme :

pigment {
	wood
	turbulence .2
	scale .5
}

La turbulence est toujours la première. Un meilleur exemple de cette limitation est avec une turbulence et une rotation inégales.

pigment {
	wood
	turbulence 0.5*y
	rotate z*60
}
// à comparer avec
pigment {
	wood
	rotate z*60
	turbulence 0.5*y
}

Le résultat sera le même, même si vous pensez qu'il sera différent.

Nous ne pouvons pas changer ceci dans POV-Ray maintenant, car beaucoup de scènes serait rendues différemment, si, soudainement, l'ordre des transformations par rapport à la turbulence prenait une importance, qu'elle n'avait pas.

Toutefois, en spécifiant la turbulence au sein d'une torsion, vous donnez une importance à l'ordre. Voici un exemple :

warp {turbulence <0, 1, 1> octaves 3 lambda 1.5 omega 0.3}

La signification est que ceci :

pigment {
	wood
	translate <1, 2, 3> rotate x*45 scale 2
	warp {turbulence <0, 1, 1> octaves 3 lambda 1.5 omega 0.3}
}

produit un résultat différent de :

pigment {
	wood
	warp {turbulence <0, 1, 1> octaves 3 lambda 1.5 omega 0.3}
	translate <1, 2, 3> rotate x*45 scale 2
}

Vous pouvez spécifier la turbulence, sans utiliser de déclaration de torsion. Toutefois, vous ne pouvez pas contrôler l'ordre d'exécution, sauf si vous la placez dans une torsion.

Les règles d'évaluation sont :

1. D'abord toute turbulence en dehors d'une déclaration de torsion est appliquée, sans se soucier de l'ordre par rapport aux torsions ou transformations.
2. Ensuite, toute déclaration de torsion, déplacement, rotation, taille ou matrice, sont appliquées une par une, dans leur ordre d'apparition. Si vous voulez une turbulence selon un ordre précis, spécifiez-la dans une déclaration de torsion, au bon endroit.

3.4.12.6.4 La torsion turbulente

Dans la déclaration warp, le mot clé turbulence suivi par un nombre ou un vecteur peut être utilisé pour brasser tout pigment, normal ou density. Des paramètres optionnels peuvent être utilisés avec la turbulence pour contrôler son calcul. La syntaxe est :

TURBULENCE_ITEM:
	turbulence <Amount> | octaves Count |
	omega Amount | lambda Amount

Les valeurs typiques de la turbulence vont de 0.0, aucune turbulence, à 1.0 ou plus, ce qui est très turbulent. Si un vecteur est spécifié, des quantités différentes de turbulence sont appliquées dans les directions x, y et z. Par exemple :

turbulence <1.0, 0.6, 0.1>

a plus de turbulence dans la direction x, une quantité modérée dans la direction y et une petite quantité dans la direction z.

La turbulence utilise une fonction de bruit aléatoire appelée DNoise. Elle est similaire au bruit du modèle bozo, sauf qu'elle donne une direction, plutôt qu'une valeur. Vous pouvez la percevoir comme la direction où souffle le vent en ce point. Les points proches génèrent la même valeur, mais les points éloignés sont aléatoirement différents.

La turbulence utilise DNoise pour pousser un point de plusieurs pas, appelés octaves. Nous repérons le point à évaluer, puis nous le poussons un peu, en utilisant la turbulence, pour avoir un autre point, puis nous retenons la couleur ou le modèle du nouveau point.

En fait, elle dit "Ne me donne pas la couleur de ce point, mais fait quelques pas aléatoires dans toutes les directions, puis donne moi la couleur". Chaque pas est, normalement, la moitié du précédent. Par exemple :

La marche aléatoire de la turbulence

La magnitude de ces pas est contrôlée par la valeur de la turbulence. Il y a trois paramètres supplémentaires qui contrôlent le calcul de la turbulence. Ils sont octaves, lambda et omega. Chacun est optionnel. Chacun est suivi par une valeur numérique. Chacun n'a aucun effet quand il n'y a pas de turbulence.

Octaves

Le mot clé octaves doit être suivi d'un entier pour contrôler le nombre de pas de la turbulence. La fourchette va de 1 à 10, avec le défaut à 6, qui est une assez haute valeur; vous ne verrez pas de grandes différences au-delà, car les pas seront trop petits. Les valeurs flottantes sont tronquées en entiers. De petits octaves donnent une turbulence douce, ondulée, qui se calcule vite. Les hauts octaves donnent une turbulence plus déchiquetée, brouillée, et qui se calcule plus lentement.

Lambda

Le paramètre lambda contrôle la façon statistiquement différente dont le déplacement aléatoire d'un octave est comparé au précédent. Le valeur par défaut est 2.0, qui est relativement aléatoire. Les valeurs proches de 1.0 redresseront le chemin aléatoire du précédent diagramme. Les pas en zigzag iront dans une direction plus proche. De grandes valeurs peuvent paraître plus tourbillonnantes, sous certaines circonstances.

Omega

La valeur omega contrôle la différence de longueur entre deux pas. Chaque pas successif de la turbulence est multipliée par la valeur oméga. Le défaut est 0.5, indiquant que chaque pas est la moitié du précédent. De hautes valeurs oméga signifient que les seconds, troisièmes, et autres pas suivants auront plus de contribution dans la turbulence, donnant un aspect plus tranché, plié, alors que de petites valeurs donnent une turbulence brouillée, tachetée en certains endroits.

3.4.12.6.5 La projection utilisant les torsions

Syntaxe :

CYLINDRICAL_WARP:
	warp { cylindrical [CYLINDRICAL_ITEMS...]}
CYLINDRICAL_ITEMS:
	orientation VECTOR | dist_exp FLOAT
SPHERICAL_WARP:
	warp { spherical [SPHERICAL_ITEMS...]}
SPHERICAL_ITEMS:
	orientation VECTOR | dist_exp FLOAT
TOROIDAL_WARP:
	warp { toroidal [TOROIDAL_ITEMS...]}
TOROIDAL_ITEMS:
	orientation VECTOR | dist_exp FLOAT | major_radius FLOAT
PLANAR_WARP:
	warp { planar [ VECTOR , FLOAT ]}

Avec les torsions cylindrical, spherical et toroidal vous pouvez tordre des damiers, des briques et autres modèles autour de cylindres, sphères, tores et autres objets. Dans le fond, ces torsions utilisent la même projection que ce qu'utilise l'application d'image.

Toutefois, il fait de la projection 3D et des concessions doivent être faites sur la profondeur. Cela est contrôlable par dist_exp (exposant distance). Avec le défaut 0, imaginez une boite <0, 0> to <1, 1> (pour le moment c'est <0, 0>, <dist^dist_exp, dist^dist_exp>) étirée à l'infini selon un vecteur orientation. La torsion prend ses points de cette boite.

Pour une sphère, dist_exp est la distance à l'origine, pour le cylindre c'est la distance à l'axe y, pour le tore c'est la distance au rayon majeur. (ou au rayon mineur si vous préférez le voir ainsi)

Les défauts :

orientation <0, 0, 1>
dist_exp 0
major_radius 1


Exemples :

torus {
	1, 0.5
	pigment {
		hexagon
		scale 0.1
		warp {
			toroidal 
			orientation y 
			dist_exp 1
			major_radius 1
		}
	}
}
sphere {
	0, 1
	pigment {
		hexagon
		scale <0.5/pi, 0.25/pi, 1>*0.1
		warp {
			spherical
			orientation y
			dist_exp 1
		}
	}
}
cylinder {
	-y, y, 1
	pigment {
		hexagon
		scale <0.5/pi, 1, 1>*0.1
		warp {
			cylindrical
			orientation y
			dist_exp 1
		}
	}
}

La torsion planar a été faite pour qu'un modèle fonctionne comme une application d'image, de taille infinie, et peut être utile en combinaison avec d'autres torsions en application. Par défaut, le pigment dans le plan x-y est extrudé le long de l'axe z. Le pigment peut être pris d'un autre plan, en spécifiant le vecteur optionnel (normale du plan) et le numérique (distance le long de la normale). Le résultat, encore une fois, est extrudé le long de l'axe z.

3.4.12.7 Les modificateurs de bitmap

Un modificateur bitmap est un modificateur utilisé dans image_map, bump_map ou material_map pour spécifier comment la bitmap en 2D doit être appliquée à la surface 3D. Plusieurs modificateurs de bitmap s'appliquent à des types particuliers d'application, et sont expliqués dans les sections appropriées. Les modificateurs suivants sont applicables aux trois types de bitmap.

3.4.12.7.1 L'option "once"

Normalement, il y a une répétition infinie des applications pour chaque carré d'une unité sur le plan x-y, comme des pavés. En ajoutant le mot clé once, après un nom de fichier, vous pouvez éliminer toutes les autres copies, sauf celle de (0, 0) à (1, 1). Dans les applications d'image, les aires en dehors de ce carré sont considérées comme transparentes. Pour les applications de bosses, elles sont plates, sans modification de la normale. Pour les applications de matériaux, elles prennent la première texture de la liste de textures.

Par exemple :

image_map {
	gif "mypic.gif"
	once
}

3.4.12.7.2 L'option "map_type"

La projection par défaut de l'image sur le plan x-y est appelé type de projection planaire. Cette option peut être changée en ajoutant le mot clé map_type suivi d'un entier spécifiant la façon d'appliquer l'image sur l'objet.

Un map_type 0 donne la projection planaire déjà décrite.

Un map_type 1 donne une projection sphérique. Il assume que l'objet est une sphère de toute taille, sise à l'origine. L'axe y est l'axe de pôles de la projection planaire. Les bords haut et bas de l'image touchent les pôles sans se soucier de la taille. Le bord gauche commence à l'axe positif des x, et couvre le modèle autour de la sphère, d'ouest en est, dans une rotation -y. La couverture est unique, donc le mot clé once n'y a pas de sens.

Avec map_type 2, vous avez une projection cylindrique. Il assume que vous avez un cylindre de tout diamètre, sur l'axe y. Le modèle s'applique autour du cylindre, comme la projection sphérique, mais il garde une hauteur d'une unité, entre y = 0 et y = 1. Cette bande est répétée à toutes les hauteurs, sauf si le mot clé once est utilisé.

Enfin, map_type 5 est une projection en forme de tore. Il assume qu'un tore de rayon majeur 1 est à l'origine, sur le plan x - z. Le modèle est appliqué de manière identique à la projection sphérique ou cylindrique. Toutefois, les bords haut et bas passent au-dessus et en dessous du tore, pour se rencontrer sur le bord interne.

Les types 3 et 4 sont toujours en développement.

Note : l'option map_type peut aussi être appliquée aux déclarations bump_map et material_map.

Par exemple:

sphere {<0, 0, 0>, 1
	pigment {
		image_map {
			gif "world.gif"
			map_type 1
		}
	}
}

3.4.12.7.3 L'option "interpolate"

L'ajout du mot clé interpolate peut adoucir l'aspect dentelé d'une bitmap. Quand POV-Ray demande une couleur d'une image, ou une valeur de bosse d'un spectre de bosses, il cherche souvent pour un point qui n'est pas directement sur un pixel, et fait un tri entre différents pixels voisins. Les interpolations donnent une valeur intermédiaire, adoucissant les écarts entre les pixels.

Bien que l'interpolation soit légale dans les applications de matériaux, la couleur du pixel est calculée avant le choix de la texture. Il ne fait pas l'interpolation de la couleur finale comme vous l'espérez. En général, cela ne sert aucun objectif, mais ce sera corrigé dans les versions futures.

Il y a deux types d'interpolation : interpolate 2 donne une interpolation bilinéaire, tandis que interpolate 4 donne des distances normalisées. Par exemple :

image_map {
	gif "mypic.gif"
	interpolate 2
}

Le défaut est aucune interpolation. La distance normalisée est la plus rapide des deux, la bilinéaire fait un meilleur travail de choix entre deux couleurs. Normalement, la bilinéaire est utilisée.

Si votre projection semble troublée, essayez l'interpolation avant de prendre une meilleure résolution. Les résultats peuvent être très bons.