2.2.2.1 L'objet boîte

Le box est un des objets les plus utilisés. Nous essayons cet exemple à la place de la sphère :

box {
	<-1, 0,-1>,	// Coin proche en bas à gauche
	<1, 0.5, 3>	// Coin éloigné en haut à droite
	texture {
		T_Stone25	// Prédéfini dans stones.inc
		scale 4	// Même échelle dans toutes les directions
	}
	rotate y*20	// Equivalent à "rotate <0, 20, 0>"
}

Dans cet exemple, nous voyons qu'une boîte est définie par la position dans l'espace de ses coins opposés. Le premier vecteur contient généralement les coordonnées x, y et z minimales et le deuxième vecteur contient les valeurs maximales, sinon ils doivent désigner deux coins opposés. Les objets boîtes ne peuvent être définis que parallèlement aux axes du monde virtuel. Nous pouvons les tourner selon n'importe quel angle, plus tard.

Note : nous pouvons utiliser des formules mathématiques simples sur les valeurs et les vecteurs. Dans le paramètre de rotation, nous multiplions l'élément y du vecteur par 20. C'est la même chose que <0, 1, 0>*20 ou <0, 20, 0>.

2.2.2.2 L'objet cône

Voici un autre exemple montrant comment utiliser un cone :

cone {
	<0, 1, 0>, 0.3	// Centre et rayon d'une extrémité
	<1, 2, 3>, 1.0	// Centre et rayon de l'autre extrémité
	texture {T_Stone25 scale 4}
}

La forme cône est définie par le centre et le rayon de chaque extrémité. Dans cet exemple, un bout est à <0, 1, 0> avec un rayon de 0.3 tandis que l'autre est centré à <1, 2, 3> avec un rayon de 1. Si nous voulons que le cône se termine en pointe, nous utiliserons un rayon à 0. Les surfaces aux extrémités sont parallèles entre elles, et perpendiculaires à l'axe du cône. Si vous voulez un cône ouvert, donc sans surface d'extrémité, vous devez ajouter le mot clé open après le second rayon, comme ceci :

cone {
	<0, 1, 0>, 0.3	// Centre et rayon d'une extrémité
	<1, 2, 3>, 1.0	// Centre et rayon de l'autre extrémité
	open	// Ouvre les extrémités
	texture {T_Stone25 scale 4}
}

2.2.2.3 L'objet cylindre

Nous pouvons également définir un cylinder comme ceci :

cylinder {
	<0, 1, 0>,	// Centre d'une fin
	<1, 2, 3>,	// Centre de l'autre fin
	0.5	// Rayon
	open	// Ouvre les extrémités
	texture {T_Stone25 scale 4}
}

2.2.2.4 L'objet plan

Essayons un standard graphique : le sol en damier. Nous ajoutons l'objet suivant à notre première version du fichier demo.pov, celui incluant la sphère.

plane {<0, 1, 0>,-1
	pigment {
		checker color Red, color Blue
	}
}

L'objet défini ici est un plan infini. Le vecteur <0, 1, 0> est la normale de surface du plan (c'est-à-dire que si nous nous tenions sur la surface, la normale pointerait vers le haut). Le nombre qui suit est la distance du plan, le long de la normale, par rapport à l'origine -- dans ce cas, le plancher est placé à y = -1 donc la sphère à y = 1, rayon = 2, est posée dessus.

Note : même si aucune texture n'est donnée, elle est implicite ici. Nous avons trouvé que taper continuellement des déclarations emboîtées comme texture {pigment} peut être fatigant, aussi POV-Ray nous libère de la déclaration de texture dans de nombreuses circonstances. En général, nous n'avons besoin du bloc texture qu'autour d'une identification de texture (comme la T_Stone25 vue auparavant), ou lorsque nous créons des textures stratifiées (qui sont vues plus tard).

Ce pigment utilise le modèle échiquier et signale que les deux couleurs rouge et bleu doivent être utilisées.

Comme les vecteurs <1, 0, 0>, <0, 1, 0> et <0, 0, 1> sont souvent utilisés, POV-Ray a trois vecteurs prédéfinis, respectivement identifiés x, y et z, et qui peuvent être utilisés comme raccourcis. Donc le plan peut être défini comme suit :

plane {y,-1
	pigment { ... }
}

Note : nous n'utilisons pas les parenthèses autour des identifiants de vecteur.

En regardant le plancher, nous remarquons que la balle crée une ombre. Les ombres sont calculées avec beaucoup de précision par les raytraceurs, donnant des ombres précises et contrastées. Dans le monde réel, les pénombres ou les ombres douces sont souvent rencontrées. Plus tard, nous apprendrons comment utiliser des sources de lumières étendues pour adoucir les ombres.

2.2.2.5 L'objet tore

Un torus peut être pensé comme un beignet ou un tube replié sur lui-même. C'est une forme très utilisée dans toutes sortes de CSG, aussi POV-Ray a adopté ce polynôme quartique de quatrième ordre comme forme primitive. La syntaxe est si simple que c'est une forme facile à utiliser, dès que l'on a appris ce que les deux nombres signifient. Au lieu d'une lecture sur le sujet, créons-en une et faisons quelques expériences avec elle.

Nous créons un fichier appelé tordemo.pov et le modifions comme suit :

#include "colors.inc"
camera {
	location <0, .1,-25>
	look_at 0
	angle 30
}
background {color Gray50}	// pour s'assurer que le tore est facile à voir
light_source {<300, 300,-1000> White}
torus {
	4, 1	// rayon majeur et mineur
	rotate -90*x	// ainsi nous pouvons le voir d'en haut
	pigment {Green}
}

Nous traçons cette scène.

Bon, c'est bien un beignet. Essayons de changer les rayons majeur et mineur et voyons ce qui arrive. Nous les changeons comme suit :

torus {5, .25	// rayon majeur et mineur

Cela ressemble plus à un cerceau ! Essayons ceci :

torus {3.5, 2.5	// rayon majeur et mineur

Wharf ! Un beignet avec un gros problème de poids !

Avec une syntaxe si simple, il n'y a pas grand chose à faire, à part changer la texture. Est-ce sûr ? Voyons...

Les tores sont très utiles dans les CSG. Faisons une petite expérience. Créons une différence avec un tore et une boîte :

difference {
	torus {
		4, 1
		rotate x*-90	// ainsi nous pouvons le voir d'en haut
	}
	box {<-5,-5,-1>, <5, 0, 1>}
	pigment {Green}
}

Intéressant... un demi tore. Maintenant, nous en ajoutons un autre, projeté d'une autre manière. Déclarons seulement le demi tore d'origine avec les transformations, pour pouvoir l'utiliser encore :

#declare Half_Torus = difference {
	torus {
		4, 1
		rotate -90*x	// ainsi nous pouvons le voir d'en haut
	}
	box {<-5,-5,-1>, <5, 0, 1>}
	pigment {Green}
}
#declare Flip_It_Over = 180*x;
#declare Torus_Translate = 8;	// twice the major radius

Maintenant, nous créons une union de deux Half_Torus :

union {
	object {Half_Torus}
	object {Half_Torus
		rotate Flip_It_Over
		translate Torus_Translate*x
	}
}

Cela nous donne un objet en forme de S, mais nous ne pouvons pas tout voir avec la caméra actuelle. Ajoutons quelques chaînons, trois dans chaque direction, déplaçons l'objet le long de l'axe z et tournons-le autour de l'axe y pour en voir plus. Nous notons également la présence d'un défaut là où les deux demi tores se rencontrent. Cela est dû à notre vision directe depuis le plan x-z. Nous changerons les coordonnées y de la caméra de 0 à 0.1 pour éliminer cela.

union {
	object {Half_Torus}
	object {Half_Torus
		rotate Flip_It_Over
		translate x*Torus_Translate
	}
	object {Half_Torus
		translate x*Torus_Translate*2
	}
	object {Half_Torus
		rotate Flip_It_Over
		translate x*Torus_Translate*3
	}
	object {Half_Torus
		rotate Flip_It_Over
		translate -x*Torus_Translate
	}
	object {Half_Torus
		translate -x*Torus_Translate*2
	}
	object {Half_Torus
		rotate Flip_It_Over
		translate -x*Torus_Translate*3
	}
	object {Half_Torus
		translate -x*Torus_Translate*4
	}
	rotate y*45
	translate z*20
}

Ceci rendu, nous voyons quelque chose ressemblant à un sympathique serpent ondulant. Mais nous voulons quelque chose d'utile, qui peut être vu dans le réel. Pourquoi pas une chaîne ?

En y pensant, nous réalisons qu'un anneau de chaîne peut être facilement modélisé en utilisant deux demi tores et deux cylindres. Nous créons un nouveau fichier. Nous pouvons utiliser les mêmes caméra, fond, sources de lumière, objets déclarés et transformations que dans tordemo.pov:

#include "colors.inc"
camera {
	location <0, .1,-25>
	look_at 0
	angle 30
}
background {color Gray50}
light_source {<300, 300,-1000> White}
#declare Half_Torus = difference {
	torus {
		4, 1
		sturm
		rotate x*-90	// ainsi nous pouvons le voir depuis le haut
	}
	box {<-5,-5,-1>, <5, 0, 1>}
	pigment {Green}
}
#declare Flip_It_Over = x*180;
#declare Torus_Translate = 8;

Maintenant, nous fabriquons un tore complet avec deux demi tores :

union {
	object {Half_Torus}
	object {Half_Torus rotate Flip_It_Over}
}

Cela semble une méthode onéreuse pour faire un tore, mais nous allons séparer les deux moitiés pour allouer de l'espace aux cylindres. D'abord, nous déclarons les cylindres, avant l'union :

#declare Chain_Segment = cylinder {
	<0, 4, 0>, <0,-4, 0>, 1
	pigment {Green}
}

Nous ajoutons maintenant les deux Chain_Segments à l'union, et les déplaçons pour qu'ils s'alignent avec le rayon mineur du tore, de chaque côté :

union {
	object {Half_Torus}
	object {Half_Torus rotate Flip_It_Over}
	object {Chain_Segment translate x*Torus_Translate/2}
	object {Chain_Segment translate -x*Torus_Translate/2}
}

Maintenant, nous déplaçons les deux demi tores en y et -y pour que les fins tronquées rencontrent les extrémités des cylindres. Cette distance est égale à la moitié de Torus_Translate précédemment déclaré :

union {
	object {
		Half_Torus
		translate y*Torus_Translate/2
	}
	object {
		Half_Torus
		rotate Flip_It_Over
		translate -y*Torus_Translate/2
	}
	object {
		Chain_Segment
		translate x*Torus_Translate/2
	}
	object {
		Chain_Segment
		translate -x*Torus_Translate/2
	}
}

Nous rendons un maillon de chaîne. Mais nous n'avons pas fini ! Qui a entendu parler d'une chaîne verte ? Nous ferions mieux d'utiliser une jolie couleur métallique. D'abord, nous enlevons tous les blocs de pigmentation des tores et cylindres. Puis nous ajoutons une nouvelle déclaration de texture or juste avant l'union qui crée le maillon. Finalement, nous ajoutons la texture à l'union et la déclarons comme un maillon unique :

#declare Half_Torus = difference {
	torus {
		4, 1
		sturm
		rotate x*-90	// ainsi nous pouvons le voir depuis le haut
	}
	box {<-5,-5,-1>, <5, 0, 1>}
	pigment {Green}
}

#declare Chain_Gold = texture {
	pigment {BrightGold}
	finish {
		ambient .1
		diffuse .4
		reflection .25
		specular 1
		metallic
	}
}

#declare Link = union {
	object {
		Half_Torus
		translate y*Torus_Translate/2
	}
	object {
		Half_Torus
		rotate Flip_It_Over
		translate -y*Torus_Translate/2
	}
	object {
		Chain_Segment
		translate x*Torus_Translate/2
	}
	object {
		Chain_Segment
		translate -x*Torus_Translate/2
	}
	texture {Chain_Gold}
}

Maintenant, nous faisons l'union de deux maillons. Le second doit être déplacé selon y de manière à ce que leurs deux bords internes se touchent, comme une chaîne normale. La distance est le double de Torus_Translate moins 2 (double du rayon mineur). Cela peut être décrit par l'expression :

Torus_Translate*2-2*y

Nous déclarons cette expression comme ceci :

#declare Link_Translate = Torus_Translate*2-2*y;

Dans le bloc objet, nous utiliserons cette déclaration, que nous multiplierons pour créer de nouveaux maillons. Maintenant, nous faisons tourner le second maillon de 90*y pour qu'il soit perpendiculaire au premier, comme dans une vraie chaîne. Finalement, nous réduisons l'échelle à 1/4 pour en voir la totalité :

union {
	object {Link}
	object {Link translate y*Link_Translate rotate y*90}
	scale .25
}

Nous rendons ceci et nous voyons une paire de maillons très réaliste. Si nous voulons toute une chaîne, nous devons déclarer cette union et faire une nouvelle union de cette déclaration. Nous devons nous assurer d'avoir enlevé l'échelle de l'objet déclaré :

#declare Link_Pair = union {
	object {Link}
	object {Link translate y*Link_Translate rotate y*90}
}

Maintenant, nous déclarons notre chaîne :

#declare Chain = union {
	object {Link_Pair}
	object {Link_Pair translate y*Link_Translate*2}
	object {Link_Pair translate y*Link_Translate*4}
	object {Link_Pair translate y*Link_Translate*6}
	object {Link_Pair translate -y*Link_Translate*2}
	object {Link_Pair translate -y*Link_Translate*4}
	object {Link_Pair translate -y*Link_Translate*6}
}

Et finalement, nous créons notre chaîne avec deux transformations pour la voir plus facilement. Cela inclut la réduction par un facteur de 1/10, et la rotation pour voir clairement chaque maillon :

object {Chain scale .1 rotate <0, 45,-45>}

L'objet tore peut être utilisé pour créer des chaînes

Nous rendons cela et voyons une chaîne en or très réaliste, traversant l'écran en diagonale.