3.1.1 Les bases du langage

Le langage de POV-Ray est constitué d'identificateurs, de mots clés réservés, d'expressions décimales, de chaînes de caractères, de symboles spéciaux et de commentaires. Le texte des scènes de POV-Ray est dans un format libre. Vous pouvez placer les déclarations sur des lignes séparées, ou sur la même ligne, comme vous le désirez. Vous pouvez ajouter des lignes vides, des espaces ou des tabulations tant que vous ne découpez pas les mots clés ou les identificateurs.

3.1.1.1 Identificateurs et mots clés

POV-Ray vous permet de définir des identificateurs que vous utiliserez plus tard, dans la scène. Ils peuvent avoir de 1 à 40 caractères de long. Ils peuvent contenir des lettres majuscules ou minuscules, des nombres de 0 à 9 ou le caractère souligné ("_"). Le premier caractère doit être alphabétique. La déclaration des identificateurs est couverte plus loin.

POV-Ray a un certain nombre de mots réservés, qui sont listés ci-dessous.

a
`aa_level aa_threshold abs absorption accuracy acos acosh adaptive adc_bailout agate agate_turb all`	`all_intersections alpha altitude always_sample ambient ambient_light angle aperture append arc_angle area_light array`	`asc ascii asin asinh assumed_gamma atan atan2 atanh autostop average`
b
`b_spline background bezier_spline bicubic_patch black_hole blob blue`	`blur_samples bounded_by box boxed bozo break brick`	`brick_size brightness brilliance bump_map bump_size bumps`
c
`camera case caustics ceil cells charset checker chr circular clipped_by clock clock_delta clock_on collect`	`color color_map colour colour_map component composite concat cone confidence conic_sweep conserve_energy contained_by control0 control1`	`coords cos cosh count crackle crand cube cubic cubic_spline cubic_wave cutaway_textures cylinder cylindrical`
d
`debug declare default defined degrees density density_file density_map`	`dents df3 difference diffuse dimension_size dimensions direction disc`	`dispersion dispersion_samples dist_exp distance div double_illuminate`
e
`eccentricity else emission end`	`error error_bound evaluate exp`	`expand_thresholds exponent exterior extinction`
f
`face_indices facets fade_color fade_colour fade_distance fade_power falloff falloff_angle false fclose`	`file_exists filter final_clock final_frame finish fisheye flatness flip floor focal_point`	`fog fog_alt fog_offset fog_type fopen form frame_number frequency fresnel function`
g
`gather gif global_lights`	`global_settings gradient granite`	`gray gray_threshold green`
h
`height_field hexagon`	`hf_gray_16 hierarchy`	`hypercomplex hollow`
i
`if ifdef iff ifndef image_height image_map image_pattern image_width include`	`initial_clock initial_frame inside inside_vector int interior interior_texture internal interpolate`	`intersection intervals inverse ior irid irid_wavelength isosurface`
j
`jitter jpeg`	`julia julia_fractal`
l
`lambda lathe leopard light_group light_source`	`linear_spline linear_sweep ln load_file local`	`location log look_at looks_like low_error_factor`
m
`macro magnet major_radius mandel map_type marble material material_map matrix max max_extent`	`max_gradient max_intersections max_iteration max_sample max_trace max_trace_level media media_attenuation media_interaction merge mesh`	`mesh2 metallic method metric min min_extent minimum_reuse mod mortar`
n
`natural_spline nearest_count no no_bump_scale no_image`	`no_reflection no_shadow noise_generator normal normal_indices`	`normal_map normal_vectors number_of_waves`
o
`object octaves off offset omega`	`omnimax on once onion open`	`orient orientation orthographic`
p
`panoramic parallel parametric pass_through pattern perspective pgm phase phong phong_size photons`	`pi pigment pigment_map pigment_pattern planar plane png point_at poly poly_wave polygon`	`pot pow ppm precision precompute pretrace_end pretrace_start prism prod projected_through pwr`
q
`quadratic_spline quadric quartic`	`quaternion quick_color quick_colour`	`quilted`
r
`radial radians radiosity radius rainbow ramp_wave rand range ratio`	`read reciprocal recursion_limit red reflection reflection_exponent refraction render repeat`	`rgb rgbf rgbft rgbt right ripples rotate roughness`
s
`samples save_file scale scallop_wave scattering seed select shadowless sin sine_wave sinh size sky sky_sphere slice slope`	`slope_map smooth smooth_triangle solid sor spacing specular sphere sphere_sweep spherical spiral1 spiral2 spline split_union spotlight spotted`	`sqr sqrt statistics str strcmp strength strlen strlwr strupr sturm substr sum superellipsoid switch sys`
t
`t tan tanh target text texture texture_list texture_map tga thickness`	`threshold tiff tightness tile2 tiles tolerance toroidal torus trace transform`	`translate transmit triangle triangle_wave true ttf turb_depth turbulence type`
u
`u u_steps ultra_wide_angle undef union`	`up use_alpha use_color use_colour use_index`	`utf8 uv_indices uv_mapping uv_vectors`
v
`v v_steps val variance vaxis_rotate`	`vcross vdot version vertex_vectors vlength`	`vnormalize vrotate vstr vturbulence`
w
`warning warp water_level`	`waves while width`	`wood wrinkles write`
x
`x`
y
`y`	`yes`
z
`z`

Tous les mots réservés sont en minuscules. Par conséquent, il est recommandé que vos identificateurs aient au moins un caractère majuscule, ainsi, vous êtes sûr qu'il n'y aura pas de conflit.

3.1.1.2 Les commentaires

Les commentaires sont du texte inclus pour rendre le fichier plus facile à lire ou à comprendre. Ils sont ignorés par le raytraceur, et ne sont là que pour votre information. Il y a deux types de commentaires dans POV-Ray.

Deux signes de division sont utilisés pour les commentaires sur une seule ligne. Tout ce qui est derrière ces deux caractères (//) est ignoré par le raytraceur. Par exemple :

// Cette ligne est ignorée

Vous pouvez avoir des commandes sur la ligne devant ce commentaire, comme ici :

object {FooBar}	// Ceci est un objet

L'autre type de commentaire est utilisé pour les lignes multiples. Il commence avec "/*" et fini avec "*/". Tout ce qui se trouve entre est ignoré. Par exemple :

/* Ces lignes
sont ignorées
Par le
raytraceur */

Cela peut être pratique si vous voulez extraire temporairement des éléments de la scène. Les commentaires de plusieurs lignes peuvent englober des commentaires d'une ligne (//), et peuvent donc commenter des portions entières de scène, temporairement ou de façon permanente. Les commentaires sur plusieurs lignes peuvent être emboîtés, ce qui suit est légal :

/* Voici un commentaire
// Ceci aussi
/* Ceci aussi */
*/

Utilisez les commentaires généreusement. Bien utilisés, ils améliorent réellement la lisibilité de la scène.

3.1.1.3 Les expressions numériques

Beaucoup d'endroits du langage de POV-Ray requièrent que vous entriez un ou plusieurs nombres à virgule flottante. C'est un nombre décimal. Les nombres flottants peuvent être spécifiés en utilisant des identificateurs ou des fonctions qui retourneront des valeurs décimales. Vous pouvez également créer des expressions flottantes complexes par combinaison de vos opérateurs familiers.

Quand POV-Ray a besoin d'un entier, il vous autorise la saisie d'un nombre décimal qu'il tronque. Quand POV-Ray a besoin d'une valeur logique ou booléenne, il interprète toute valeur différente de zéro comme vraie, et la valeur zéro comme fausse. Parce que les comparaisons de décimales sont sujettes aux erreurs d'arrondis, POV-Ray accepte les valeurs extrêmement proches de zéro comme fausses dans les fonctions booléennes. Typiquement, les valeurs dont la valeur absolue est moindre qu'une valeur epsilon prédéfinie, sont considérées comme fausses dans les expressions logiques. La valeur d'epsilon est dépendante du système, mais est généralement vers 1.0e-10. Deux nombres flottants a et b sont considérés comme identiques si abs(a-b) < epsilon.

Leur syntaxe complète est donnée ici. Les explications détaillées sont dans les sous-sections suivantes.

FLOAT:
	NUMERIC_TERM [SIGN NUMERIC_TERM]
SIGN:
	+ | -
NUMERIC_TERM:
	NUMERIC_FACTOR [MULT NUMERIC_FACTOR]
MULT:
	* | /
NUMERIC_FACTOR:
	FLOAT_LITERAL |
	FLOAT_IDENTIFIER |
	SIGN NUMERIC_FACTOR |
	FLOAT_FUNCTION |
	FLOAT_BUILT-IN_IDENT |
	( FULL_EXPRESSION ) |
	! NUMERIC_FACTOR
VECTOR DECIMAL_POINT DOT_ITEM FLOAT_LITERAL:
	[DIGIT...] [DECIMAL_POINT] DIGIT... [EXP [SIGN] DIGIT...]
DIGIT:
	0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
DECIMAL_POINT:
	.
EXP:
	e | E
DOT_ITEM:
	x | y | z | t | u | v | red | blue | green | filter |
	transmit | gray
FLOAT_FUNCTION:
	abs( FLOAT ) | acos( FLOAT ) | acosh( FLOAT ) | asc( STRING ) |
	asin( FLOAT ) | asinh( FLOAT ) | atan( FLOAT) | atanh( FLOAT) |
	atan2( FLOAT , FLOAT ) | ceil( FLOAT ) | cos( FLOAT ) | 
	cosh( FLOAT ) | defined(IDENTIFIER ) | degrees( FLOAT ) | 
	dimensions( ARRAY_IDENTIFIER ) |
	dimension_size( ARRAY_IDENTIFIER , FLOAT ) | 
	div( FLOAT , FLOAT ) | exp( FLOAT ) | file_exists( STRING ) |
	floor( FLOAT ) | int( FLOAT ) | ln(FLOAT) | log( FLOAT ) |
	max( FLOAT , FLOAT, ... ) | min( FLOAT , FLOAT, ... ) |
	mod( FLOAT , FLOAT ) | pow( FLOAT , FLOAT ) |
	radians( FLOAT ) | rand( FLOAT ) | seed( FLOAT ) |
	select( FLOAT, FLOAT, FLOAT [,FLOAT]) | sin( FLOAT ) |
	sinh( FLOAT ) | sqrt( FLOAT ) | strcmp( STRING , STRING ) |
	strlen( STRING ) | tan( FLOAT ) | tanh( FLOAT ) |
	val( STRING ) | vdot( VECTOR , VECTOR ) | vlength( VECTOR ) | 
	FLOAT_BUILT-IN_IDENT:
		clock | clock_delta | clock_on | false | final_clock |
		final_frame | frame_number | initial_clock | initial_frame |
		image_width | image_height | no | off | on | pi | true |
		version | yes |
	FULL_EXPRESSION:
		LOGICAL_EXPRESSION [? FULL_EXPRESSION : FULL_EXPRESSION]
LOGICAL_EXPRESSION:
	REL_TERM [LOGICAL_OPERATOR REL_TERM]
LOGICAL_OPERATOR:
	& | | (note : cela signifie qu'un 'et commercial' ou une barre verticale sont des opérateurs logiques)
REL_TERM:
	FLOAT [REL_OPERATOR FLOAT]
REL_OPERATOR:
	< | <= | = | >= | > | !=
INT:
	FLOAT (note : toute syntaxe qui requière un entier INT acceptera un FLOAT et il sera tronqué en entier en interne par POV-Ray).

Note : FLOAT_IDENTIFIERS sont des identificateurs préalablement déclarés pour avoir des valeurs décimales. La syntaxe DOT_ITEM est un vecteur ou un opérateur de couleur, mais il retourne une valeur décimale. Voir "Les opérateurs vectoriels" ou 'Les opérateurs de couleur' pour les détails. Un ARRAY_IDENTIFIER est juste le nom d'un tableau préalablement déclaré, il n'inclut pas les [], ni l'index. La syntaxe pour STRING est dans la section "Les chaînes de caractères".

3.1.1.3.1 Les flottants signés

Les flottants signés sont représentés par un signe optionnel ('+' ou '-'), un point décimal optionnel, et des nombres. Si le chiffre est un entier, vous pouvez omettre le point décimal et les zéros qui suivent. S'il est entièrement décimal, vous pouvez omettre les zéros non significatifs. POV-Ray supporte la notation scientifique pour les nombres extrêmement grands ou petits. Les chiffres suivants sont tous valides :

-2.0 -4 34 3.4e6 2e-5 .3 0.6

3.1.1.3.2 Les identificateurs

Les identificateurs numériques peuvent être déclarés pour rendre les scènes plus lisibles et pour les paramétrer de manière à ce que le changement d'une déclaration conduise au changement d'autres valeurs. Un identificateur est déclaré comme ceci.

FLOAT_DECLARATION:
	#declare IDENTIFIER = EXPRESSION;    |
	#local IDENTIFIER = EXPRESSION;

Où IDENTIFIER est le nom de l'identificateur, jusqu'à 40 caractères de long, et EXPRESSION est toute expression valide qui évalue une valeur numérique.

Note : il doit y avoir un point-virgule à la fin d'une déclaration numérique. S'il est omis, cela entraîne une erreur et certaines macros ne fonctionneront pas correctement. Voir "#declare vs. #local" pour des informations sur leur étendue.

Voici quelques exemples.

#declare Count = 0;
#declare Rows = 5.3;
#declare Cols = 6.15;
#declare Number = Rows*Cols;
#declare Count = Count+1;

Comme le dernier exemple le montre, vous pouvez redéclarer un identificateur numérique, et vous pouvez utiliser la déclaration précédente dans cette nouvelle déclaration. Il y a quelques identificateurs intégrés que POV-Ray déclare pour vous. Voir "Les identificateurs intégrés" pour les détails.

3.1.1.3.3 Les opérateurs

Les expressions arithmétiques : les expressions mathématiques de base peuvent être créées avec des flottants signés, des identificateurs ou des fonctions utilisant les opérateurs suivants, dans l'ordre de priorité...

`( )`	expressions en parenthèses d'abord
`+A -A !A`	unaire moins, unaire plus et 'non' logique
`A*B A/B`	multiplication et division
`A+B A-B`	addition et soustraction

Les expressions relationnelles, logiques et conditionnelles peuvent aussi être créées. Toutefois, il y a la restriction que ces types d'expressions doivent être entre parenthèses. Cette restriction, qui n'est pas imposée par la plupart des langages, est nécessaire car POV-Ray autorise le mélange de nombre flottants et de vecteurs. Sans les parenthèses, il y a une ambiguïté. Les parenthèses ne sont pas obligatoires pour le non logique, comme montré au-dessus. Les opérateurs et leur priorité sont montrés ici.

Les expressions relationnelles : les opérandes sont des expressions arithmétiques, et le résultat est toujours booléen, avec 1 pour vrai et 0 pour faux. Tous les opérateurs relationnels ont la même priorité.

`(A < B)`	A est plus petit que B
`(A <= B)`	A est plus petit ou égal à B
`(A = B)`	A est égal à B (c.a.d. abs(A-B)<EPSILON)
`(A != B)`	A n'est pas égal à B (c.a.d. abs(A-B)>=EPSILON)
`(A >= B)`	A est plus grand ou égal à B
`(A > B)`	A est plus grand que B

Les expressions logiques : les opérandes sont convertis en valeurs booléennes, avec 0 pour faux et 1 pour vrai. Le résultat est toujours booléen. Tous les opérateurs logiques ont la même priorité.

Note : ce ne sont pas des opérations sur les bits, elles sont logiques.

`(A & B)`	vrai seulement si A et B sont vrais tous deux, autrement c'est faux
`(A \| B)`	vrai si A ou B ou les deux sont vrais

Les expressions conditionnelles : l'opérande C est booléen, tandis que A et B sont n'importe quelle expression. Le résultat est du même type que A et B.

(C ? A : B) si C alors A sinon B

En assumant que les différents identificateurs ont été déclarés, les exemples sont des expressions valides...

1+2+3	2*5	1/3	Row*3	Col*5
(Offset-5)/2	This/That+Other*Thing
((This<That) & (Other>=Thing)?Foo:Bar)

Les expressions sont évaluées de gauche à droite, avec les parenthèses internes en premier, puis les unaires +, - ou !, puis les multiplications ou divisions, puis les additions ou soustractions, puis le relationnel, le logique et enfin le conditionnel.

3.1.1.3.4 Les fonctions

POV-Ray définit une variété de fonctions intégrées pour manipuler les nombres, vecteurs et chaînes. L'appel se fait avec un mot clé spécifiant le nom de la fonction, suivi d'un paramètre entre parenthèses. Les paramètres sont séparés par des virgules. Par exemple :

keyword(param1, param2)

Ce qui suit sont des fonctions qui retournent des valeurs numériques. Elles prennent des paramètres décimaux, entiers, vectoriels ou des chaînes. Assumez que A et B sont toute expression valide qui donne une valeur numérique, I est un numérique tronqué en entier, S, S1, S2 etc. sont des chaînes, et V, V1, V2 etc. sont des vecteurs. O est un identificateur objet d'un objet prédéclaré.

abs(A) Valeur absolue de A. Si A est négatif, donne -A sinon donne A.

acos(A) Arc-cosinus de A. Donne l'angle, en radians, dont le cosinus est A.

acosh(A) Cosinus hyperbolique inverse de A.

asc(S) Retourne un entier dans la fourchette de 0 à 255, qui est la valeur ASCII du premier caractère de S. Par exemple asc("ABC") est 65, car c'est la valeur du caractère 'A'.

asin(A) Arc sinus de A. Retourne l'angle en radians, dont le sinus est A.

asinh(A) Sinus hyperbolique inverse de A

atan2(A,B) Arc tangente de (A/B). Retourne l'angle en radians, dont la tangente est (A/B). Retourne la valeur appropriée, même si B est zéro. Utilisez atan2(A,1) pour calculer l'usuelle fonction atan(A).

atanh(A) Tangente hyperbolique inverse de A

ceil(A) Plafond de A. Retourne le plus petit entier au-dessus de A. Arrondit à l'entier supérieur le plus proche.

cos(A) Cosinus of A. Retourne le cosinus de l'angle A, en radians.

cosh(A) Cosinus hyperbolique de A.

defined(IDENTIFIER) Retourne true si l'identificateur est défini. C'est spécialement utile pour détecter la fin de fichier après une directive #read car l'identificateur de fichier est automatiquement non défini en fin de fichier. Voir "La directive #read" pour les détails.

degrees(A) Convertit les radians en degrés. Retourne l'angle en degré dont la valeur en radians est A. La formule est degrees=A/pi*180.0.

dimensions( ARRAY_IDENTIFIER ) Retourne le nombre de dimensions d'un tableau précédemment déclaré. Par exemple, si vous faites #declare MyArray=array[6][10] alors dimensions(MyArray) donne 2.

dimension_size( ARRAY_IDENTIFIER, FLOAT ) Retourne la taille d'une dimension donnée d'un tableau précédemment déclaré. Elles sont numérotées de gauche à droite, en commençant à 1. Par exemple si vous faites #declare MyArray=array[6][10] alors dimension_size(MyArray,2) donne 10.

div(A,B) Division entière. La partie entière de (A/B).

exp(A) Exponentiel de A. Retourne la valeur de e à la puissance A, où e est la base du logarithme naturel, c'est-à-dire la valeur non répétitive approximativement égale à 2.71828182846.

file_exists(S) Essaie d'ouvrir le fichier spécifié dans la chaîne S. Le dossier courant et tous ceux désignés par les options Library_Path ou +L sont auscultés. Voir "Chemins de bibliothèque" pour les détails. Retourne 1 sur une réussite, sinon 0.

floor(A) Plancher de A. Retourne l'entier le plus grand au-dessous de A. Arrondit vers le bas vers le plus proche entier.

inside(O,V) Il retourne soit 0.0, quand le vecteur V est en dehors de l'objet, spécifié par l'identificateur objet O, ou 1.0 si il est dedans.

Note : inside n'accepte pas les identificateurs objet d'objets non solides.

int(A) Partie entière de A. Retourne l'entier tronqué de A. Arrondit vers zéro.

log(A) Logarithme de A. Retourne le logarithme base 10 de la valeur A.

ln(A) Logarithme naturel de A. Retourne le logarithme naturel de base e de la valeur A.

max(A,B,...) Maximum de deux valeurs numériques ou plus. Retourne A, s'il est le plus grand. Sinon, retourne B.

min(A,B,...) Minimum de deux valeurs numériques ou plus. Retourne A, s'il est le plus petit. Sinon, retourne B.

mod(A,B) Valeur de A modulo B. Retourne le reste, après la division entière de A/B. La formule est mod=((A/B)-int(A/B))*B.

pow(A,B) Exponentiel. Retourne la valeur de A à la puissance B.

Note : Pour un A négatif et un B non entier, la fonction a une valeur en retour non définie. Le résultat peut dépendre de la plate-forme de compilation de POV-Ray.

radians(A) Converti les degrés en radians. Retourne l'angle en radians dont la valeur en degrés est A. La formule est radians=A*pi/180.0.

rand(I) Retourne le nombre pseudo aléatoire suivant, pour le canal spécifié par l'entier I. Vous devez appeler seed() pour initialiser un canal aléatoire, avant d'appeler rand(). Les nombres sont uniformément distribués, et ont des valeurs entre 0.0 et 1.0, inclus. Les nombres générés par des canaux différents sont des variables aléatoires indépendantes.

seed(I) Initialise un nouveau canal pseudo aléatoire, avec la valeur racine initiale A. Le nombre correspondant à ce canal aléatoire est retourné. Tout nombre de canaux pseudo aléatoires peuvent être utilisés comme dans l'exemple suivant :

#declare R1 = seed(0);
#declare R2 = seed(12345);
sphere {<rand(R1), rand(R1), rand(R1)>, rand(R2)}

Les générateurs aléatoires multiples sont très utiles dans les situations où vous utilisez rand() pour placer un groupe d'objets, puis décidez d'utiliser rand() plus tard pour générer quelques couleurs, ou pour placer un autre groupe d'objets. Sans des canaux rand() séparés, tous vos objets bougeraient à chaque ajout d'un rand(). C'est très agaçant.

select(A, B, C [,D]) Il peut être utilisé avec trois ou quatre paramètres. Select compare le premier argument avec zéro, selon l'entrée il retournera B, C ou D. A,B,C,D peuvent être des numériques ou des fonctions.
Lors de l'utilisation avec trois paramètres, si A < 0 il retournera B, sinon C (A >= 0).
Lors de l'utilisation avec quatre paramètres, si A < 0 il retournera B. Si A = 0 il retournera C. Sinon il retournera D (A > 0).

Exemple :
Si A a les valeurs consécutives -2, -1, 0, 1, et 2 :

// A =  -2 -1 0 1 2
select (A,-1, 0, 1)	//donne  -1 -1 0 1 1 
select (A,-1, 1)	//donne  -1 -1 1 1 1

sin(A) Sinus de A. Retourne le sinus de l'angle A en radians.

sinh(A) Le sinus hyperbolique de A.

sqrt(A) racine carrée de A. Retourne la valeur dont A est le carré.

strcmp(S1,S2) Compare les chaînes S1 à S2. Retourne une valeur numérique nulle si elles sont égales, positive si S1 vient après S2 dans l'ordre ASCII, négative dans les autres cas.

strlen(S) Longueur de S. Retourne un entier qui est le nombre de caractères de la chaîne S.

tan(A) Tangente de A. Retourne la tangente de l'angle A en radians.

tanh(A) La tangente hyperbolique de A.

val(S) Converti la chaîne S en nombre. Retourne une valeur numérique qui représente le texte de S. Par exemple val("123.45") est le nombre 123.45.

vdot(V1,V2) Produit vectoriel de V1 et V2. Retourne une valeur numérique qui est le produit vectoriel (parfois appelé le produit scalaire) de V1 avec V2. Elle est directement proportionnelle à la longueur des deux vecteurs et au cosinus de l'angle entre eux. La formule est vdot=V1.x*V2.x + V1.y*V2.y + V1.z*V2.z. Voir la scène de démonstration animée VECT2.POV pour une illustration.

vlength(V) Longueur de V. Retourne une valeur numérique qui est la longueur du vecteur V. La formule est vlength=sqrt(vdot(A,A)). Peut être utilisé pour calculer la distance entre deux points. Dist=vlength(V2-V1).

Voir les sections "Les fonctions vectorielles" et "Les fonctions chaînes de caractères" pour d'autres fonctions qui retournent des vecteurs et des chaînes. En plus de ces fonctions intégrées, vous pouvez définir vos propres fonctions en utilisant la directive #macro. Voir la section "Macros définies par l'utilisateur" pour plus de détails.

3.1.1.3.5 Les constantes intégrées

Les constantes sont :

false | no | off | on | pi | true | yes

La plupart des identificateurs programmés ne changent jamais de valeur. Ils sont initialisés au début de chaque scène, comme dans les lignes suivantes.

#declare pi = 3.1415926535897932384626;
#declare true = 1;
#declare yes = 1;
#declare on = 1;
#declare false = 0;
#declare no = 0;
#declare off = 0;

L'identificateur numérique programmé pi est évidemment utile dans les expressions mathématiques concernant les cercles. on, off, yes, no, true et false sont utilisées comme des constantes booléennes.

Les constantes on, off, yes, no, true et false sont le plus souvent utilisées comme valeurs booléennes avec des modificateurs d'objets ou des paramètres comme sturm, hollow, hierarchy, smooth, media_attenuation et media_interaction. Chaque fois que vous voyez une syntaxe de la forme keyword [Bool], si vous spécifiez le mot clé sans le booléen optionnel alors il devient keyword on. Vous n'avez pas besoin d'utiliser un booléen, mais c'est une bonne idée pour la lisibilité. Vous devez utiliser l'un des booléens faux ou une expression donnant zéro pour le désactiver.

Note : certains de ces mots clés sont on par défaut, si aucun mot clé n'est spécifié.

Par exemple :

object {MyBlob}	// sturm désactivé par défaut
				// mais hierarchy activé par défaut
object {MyBlob sturm}	// active sturm
object {MyBlob sturm on}	// active sturm
object {MyBlob sturm off}	// désactive sturm
object {MyBlob hierarchy}	// ne fait rien, hierarchy est déjà actvé
object {MyBlob hierarchy off}	// désactive hierarchy

3.1.1.3.6 Les variables intégrées

Il y a de nombreux identificateurs numériques intégrés. Vous pouvez les utiliser pour spécifier des valeurs, ou créer des expressions, mais vous ne pouvez pas les redéclarer pour changer leur valeur.

Ceux en relation avec l'horloge :

clock | clock_delta | clock_on | final_clock | final_frame
frame_number | initial_clock | initial_frame

Ces mots clés autorisent l'utilisation des valeurs de l'horloge qui ont été fixées dans les options de la ligne de commande (ou le fichier INI). Ils représentent des valeurs décimales ou entières, lues depuis les options d'animation. Vous ne pouvez pas les redéfinir.

clock
L'identificateur intégré clock est utilisé pour contrôler les animations dans POV-Ray. A la différence d'autres systèmes d'animation, l'animation dans POV-Ray ne dépend pas des numéros de page. Au lieu de cela, vous devez dessiner vos scènes avec l'horloge comme base. Pour les scènes non animées, cet identificateur est à 0, mais vous pouvez le mettre à n'importe quelle valeur, avec l'option Clock=n.n dans le fichier INI ou le commutateur +Kn.n dans la ligne de commande, pour passer une seule valeur décimale à votre scène.

D'autres options INI ou commutateurs peuvent être utilisés pour l'animation des scènes par une boucle automatique à travers des pages rendues en utilisant différentes valeurs de l'horloge. Par défaut, la valeur de l'horloge est à 0 pour la première page, et à 1 pour la dernière. Toutes les autres pages sont entre ces deux valeurs.
Par exemple, si votre objet est supposé faire un tour complet lors de l'animation, vous pouvez spécifier rotate 360*clock*y. Ainsi, tandis que l'horloge va de 0 à 1, l'objet tourne sur l'axe y de 0 à 360 degrés.

Bien que la valeur de l'horloge change de page en page, elle ne changera jamais pendant l'analyse de la scène.

clock_delta
L'identificateur intégré clock_delta retourne la quantité de temps entre deux valeurs d'horloge. Bien que la plupart des animations ne demandent que la valeur de l'horloge, certains calculs sont plus faciles si vous connaissez le temps passé depuis la dernière page. Des précautions doivent être prises. Si vous rendez un petit nombre de pages, le résultat risque d'être différent de celui avec un grand nombre de pages dans la même période. Sur les scènes non animées, le défaut est 1.0. Voir la section "Les options d'animation" pour plus de détails.

clock_on
Avec cet identificateur, le statut de l'horloge peut être vérifié : 1 est activée, 0 est désactivée.

#if(clock_on=0)
	//matériel pour une image
#else
	//un peu d'animation
#end

frame_number
Si vous préférez définir l'animation des scènes de POV-Ray selon le numéro entier des pages, cet identificateur peut être utilisé.
Il lit le numéro de la page en cours de rendu.

#if(frame_number=1)
	//matériel pour la première image ou page
#end
#if(frame_number=2)
	//matériel pour la seconde image ou page
#end
#if(frame_number=n)
	//matériel pour la enième image ou page
#end

initial_clock
Cet identificateur lit la valeur fixée dans l'option du fichier INI Initial_Clock=n.n ou le commutateur de ligne de commande +KIn.n.

final_clock
Cet identificateur lit la valeur fixée dans l'option du fichier INI Final_Clock=n.n ou le commutateur de ligne de commande +KFn.n.

initial_frame
Cet identificateur lit la valeur fixée dans l'option du fichier INI Initial_Frame=n ou le commutateur de ligne de commande +KFIn.

final_frame
Cet identificateur lit la valeur fixée dans l'option du fichier INI Final_Frame=n ou le commutateur de ligne de commande +KFFn.

Note : ces valeurs sont celles actuellement utilisées. Quand l'option 'cyclic animation' est activée, elles peuvent être différentes de celles originellement placées dans les options.

Ceux relatifs à la taille d'image sont :

image_width | image_height

image_width
Cet identificateur lit la valeur fixée dans l'option du fichier INI Width=n ou le commutateur de ligne de commande +Wn.

image_height
Cet identificateur lit la valeur fixée dans l'option du fichier INI Height=n ou le commutateur de ligne de commande +Hn.

Vous pouvez utiliser ces mots clés pour fixer le ratio de la caméra (les vecteurs haut et droit). L'angle de vue de la caméra couvre toute la largeur de l'image rendue. Le ratio de la caméra suivra toujours celui de la hauteur et de la largeur de l'image, sans prendre en compte la taille de l'image fixée. Utilisez-les comme ceci :

up y*image_height
right x*image_width

Vous pouvez également rendre des éléments de la scène dépendants de la taille de l'image :

#if (image_width < 300) crand 0.1 #else crand 0.5 #end

ou:

image_map {
	pattern image_width, image_width {	//rend la résolution du motif
		gradient x	//dépendante de la largeur du rendu
		color_map {[0.0 ... ][1.0 ... ]}
	}
}

Celle relative à la version est :

FLOAT_BUILT-IN_IDENT:
	version

L'identificateur numérique intégré version contient l'option de compatibilité de version. Bien que la valeur par défaut soit la version actuelle de POV-Ray, elle peut être modifiée par l'option INI Version=n.n ou par le commutateur +MVn.n. Cela dit à POV-Ray d'analyser la scène en utilisant la syntaxe d'une version précédente.

L'option INI ou le commutateur affectent seulement le paramétrage initial. A la différence d'autres identificateurs programmés, vous pouvez changer sa valeur dans la description de la scène. Vous n'utilisez pas #declare pour faire ce changement, mais la directive de langage #version. De tels changements peuvent être nombreux dans la même scène.

Avec l'identificateur version, la directive #version vous permet de sauver et de restaurer les valeurs précédentes. Le nouvel identificateur #local est très utile ici. Par exemple, supposons que mystuff.inc est en version 1. Au début du fichier, vous pouvez mettre :

#local Temp_Vers = version;	// Sauve la valeur précédente
#version 1.0;	// Change pour le mode 1.0
...	// Le matériel de version 1.0 vient ici...
#version Temp_Vers;	// Restaure la version précédente

Note : un point-virgule doit terminer la directive #version. S'il est oublié, cela génère une erreur, et certaines macros ne fonctionneront pas correctement.

3.1.1.4.1 Syntaxe

Les vecteurs consistent en deux à cinq expressions numériques cernées de parenthèses < et >. Les termes sont séparés par des virgules. Par exemple, voici un vecteur typique à trois composants :

<1.0, 3.2,-5.4578>

Les virgules sont nécessaires pour bien séparer les éléments et éviter les ambiguïtés et penser que le second terme est une expression numérique unique 3.2-5.4578 et qu'il n'y a pas de troisième terme. Si vous voyez un message d'erreur comme "Float expected but '>' found instead", vous avez probablement oublié une virgule.

Quelques fois, POV-Ray requiert que vous spécifiez des chiffres et des vecteurs côte à côte. Les règles sur les vecteurs autorisent le mélange de vecteurs avec des vecteurs, ou de vecteurs avec des chiffres, c'est pourquoi les virgules sont requises partout où une ambiguïté peut prendre place. Par exemple <1, 2, 3>-4 est évalué comme le mélange d'un chiffre et d'un vecteur, où 4 est soustrait de chaque composant, donnant <-3,-2,-1>. Par contre, la virgule dans <1, 2, 3>,-4 signifie que c'est un vecteur suivi d'un chiffre.

Chaque composant peut être une expression numérique complète. Par exemple est un vecteur valide.

3.1.1.4.2 Les identificateurs

Les identificateurs vectoriels peuvent être déclarés pour rendre les scènes plus lisibles et paramétrables de manière à ce que la modification d'une déclaration unique change plusieurs valeurs. Un identificateur est déclaré de la manière suivante.

VECTOR_DECLARATION:
	#declare IDENTIFIER = EXPRESSION; |
	#local IDENTIFIER = EXPRESSION;

Où IDENTIFIER est le nom de l'identificateur, jusqu'à 40 caractères de long, et EXPRESSION est toute expression valide qui donne une valeur vectorielle.

Note : il doit y avoir un point-virgule après l'expression. S'il est oublié , il génère un message d'erreur et certaines macros ne fonctionneront pas bien. Voir "#declare vs. #local" pour plus d'information.

Voici quelques exemples....

#declare Ici = <1, 2, 3>;
#declare Là = <3, 4, 5>;
#declare Saut = <Foo*2, Bar-1, Bob/3>;
#declare Route = Là-Ici;
#declare Saut = Saut+<1, 2, 3>;

Note : vous appelez l'identificateur vectoriel en utilisant son nom, sans parenthèses. Comme le montre l'exemple précédent, vous pouvez déclarer à nouveau un identificateur vectoriel en utilisant sa valeur précédente. Il y a plusieurs identificateurs intégrés que POV-Ray déclare pour vous. Voir section "Les identificateurs vectoriels intégrés" pour plus de détails.

3.1.1.4.3 Les opérateurs

Les vecteurs peuvent aussi être combinés en expressions comme les valeurs numériques. Les opérations sont faites composant par composant. Par exemple <1, 2, 3> + <4, 5, 6> vaut la même chose que <1+4, 2+5, 3+6> ou <5, 7, 9>. Les autres opérations sont faites sur le même principe. Par exemple (<1, 2, 3> = <3, 2, 1>) vaut <0, 1, 0> car seul les seconds composants sont égaux. En admettant que cela n'est pas très utile, c'est constructif avec d'autres opérations vectorielles.

Les expressions conditionnelles comme (C ? A : B) demandent que C soit une expression numérique, mais A et B peuvent être des expressions vectorielles. Le résultat est que la totalité de la condition équivaut à un vecteur valide. Par exemple, si Foo et Bar sont des numériques, alors (Foo < Bar ? <1, 2, 3> : <5, 6, 7>) équivaut au vecteur <1, 2, 3> si Foo est inférieur à Bar et <5, 6, 7> dans l'autre cas.

Vous devez utiliser l'opérateur point pour extraire un composant d'un vecteur. Supposons que l'identificateur Spot a été défini comme un vecteur. Alors Spot.x est une valeur numérique qui est le premier composant de ce vecteur x, y, z. De même, Spot.y et Spot.z référencent le second et troisième composant. Si Spot était un vecteur UV à deux composants, vous pourriez utiliser Spot.u et Spot.v pour les extraire. Pour un vecteur 4D, utilisez .x, .y, .z et .t pour extraire chaque composant. L'opérateur point est aussi utilisé dans les expressions de couleurs, qui seront étudiées plus tard.

3.1.1.4.4 L'opérateur promotion

Vous pouvez utiliser une expression numérique seule pour définir un vecteur dont tous les composants sont identiques. POV-Ray sait quand il a besoin d'un vecteur, et il transformera un numérique en vecteur si c'est nécessaire. Par exemple, la déclaration de taille de POV-Ray requiert un vecteur à trois composants. Si vous spécifiez une taille de 5, POV-Ray l'interprète comme la taille <5, 5, 5>, qui signifie un agrandissement dans les trois dimensions.

Les versions précédentes à la version 3.0 n'autorisaient cette utilisation de numériques, comme vecteurs, que en quelques endroits, comme la taille et la turbulence. Maintenant, vous pouvez utiliser ce truc partout. Par exemple...

box {0, 1}	// Comme box {<0, 0, 0>, <1, 1, 1>}
sphere {0, 1}	// Comme sphere {<0, 0, 0>, 1}

Quand il y a transformation d'un numérique en vecteur de 2, 3, 4 ou 5 composants, tous prennent la valeur du numérique. Toutefois, dans la transformation d'un vecteur en vecteur contenant plus de composants, tous les composants supplémentaires sont mis à zéro. Par exemple, si POV-Ray attend un vecteur 4D et que vous donniez 9, le résultat est <9, 9, 9, 9>, mais si vous donnez <7, 6>, le résultat est <7, 6, 0, 0>.

3.1.1.4.5 Les fonctions

POV-Ray définit une variété de fonctions intégrées pour manipuler les nombres, vecteurs et chaînes. L'appel se fait avec un mot clé spécifiant le nom de la fonction, suivi d'une liste de paramètres entre parenthèses. Les paramètres sont séparés par des virgules. Par exemple :

keyword(param1,param2)

Ce qui suit sont les fonctions qui retournent des vecteurs. Elles prennent un ou plusieurs paramètres décimaux, entiers, vecteurs ou chaînes. Assumez que A et B sont toute expression valide qui donne un vecteur, et que F est toute expression numérique.

min_extent ( OBJECT_IDENTIFIER ), max_extent ( OBJECT_IDENTIFIER ). Le min_extent et le max_extent donnent les coordonnées minimales et maximales d'une boîte encapsulante d'objet déclaré (Coin1 et Coin2), vous permettant de trouver les dimensions et la position de l'objet.

Note : cela n'est pas parfait, dans certains cas (comme les intersections et différences CSG ou les isosurfaces) la boîte encapsulante ne représente pas les dimensions réelles de l'objet.

Exemple:

#declare Sphere = sphere {
	<0, 0, 0>, 1
	pigment {rgb <1, 0, 0>}
}
#declare Min = min_extent (Sphere);
#declare Max = max_extent (Sphere);
object {Sphere}
box {
	Min, Max
	pigment {rgbf <1, 1, 1, 0.5>}
}

trace(OBJECT_IDENTIFIER, A, B, [VECTOR_IDENTIFIER]). trace vous aide à trouver l'exacte position de l'intersection d'un rayon avec une surface d'objet. Elle trace un rayon partant du point A dans la direction spécifiée par le vecteur B. Si le rayon touche l'objet spécifié, cette fonction retourne les coordonnées de l'intersection. Sinon, elle retourne <0, 0, 0>. Si un quatrième paramètre est fourni avec l'identificateur du vecteur, la normale de l'objet au point d'intersection (n'incluant pas les perturbations de la normale dues aux textures) est stockée dans ce vecteur. si aucune intersection n'est trouvée, le vecteur de la normale est replacé à <0, 0, 0>.

Note : vérifier le vecteur de la normale avec <0, 0, 0> est la seule méthode valable pour déterminer comment l'intersection se fait, les intersections peuvent et ont lieu n'importe où, même en <0, 0, 0>.

Exemple:

#declare MySphere = sphere {<0, 0, 0>, 1}
#declare Norm = <0, 0, 0>;
#declare Start = <1, 1, 1>;
#declare Inter = trace (MySphere, Start, <0, 0, 0>-Start, Norm);
object {
	MySphere
	texture {
		pigment {rgb 1}
	}
}
#if (vlength(Norm)!=0)
	cylinder {
		Inter, Inter+Norm, .1
		texture {
			pigment {color red 1}
		}
	}
#end

vaxis_rotate(A, B, F) tourne A autour de B par F. Les coordonnées x, y, z d'un point de l'espace désigné comme le vecteur A étant données, fait tourner ce point autour d'un axe arbitraire donné par le vecteur B selon un angle en degrés donné par la valeur numérique F. Le résultat est un vecteur contenant les nouvelles coordonnées de ce point.

vcross(A, B) croise les produits de A et de B. Retourne un vecteur qui est le produit croisé des deux vecteurs. Le vecteur résultant est perpendiculaire aux deux originaux, et sa longueur est égale à l'aire du parallélogramme qu'ils dessinent. Ou dit autrement, le produit croisé peut aussi être formulé comme : AxB = |A| * |B| * sin(angle(A,B)) * perpendicular_unit_vector(A,B). Donc la longueur du vecteur résultant est proportionnelle au sinus de l'angle entre A et B. Voir la scène de démonstration animée VECT2.POV pour une illustration.

vnormalize(A) normalisation du vecteur A. Retourne un vecteur de longueur unitaire qui a la même direction que A. La formule est vnormalize(A)=A/vlength(A).

Note : vnormalize(<0, 0, 0>) donnera une erreur.

vrotate(A, B) tourne A autour de l'origine par B. Les coordonnées x, y, z d'un point de l'espace désignées comme le vecteur A, étant données, fait tourner ce point autour de l'origine, selon une quantité donnée par le vecteur B. Le fait tourner autour de l'axe x avec un angle donné en degrés par la valeur numérique B.x. De même, B.y et B.z spécifient l'angle de rotation en degré autour des axes y et z. Le résultat est un vecteur contenant les nouvelles coordonnées x, y, z du point.

vturbulence(Lambda, Omega, Octaves, A) vecteur de la turbulence en A. Les coordonnées x, y et z d'un point de l'espace désigné par le vecteur A étant données, donne le vecteur de turbulence pour ce point, basé sur les valeurs données pour lambda, omega et octaves.
La quantité de turbulence peut être contrôlée en multipliant le vecteur de turbulence avec un multiple. La fréquence de changement du vecteur de turbulence peut être contrôlée en multipliant A avec un multiple. Le vecteur de turbulence retourné par la fonction peut être ajouté au point d'origine A pour donner une version agitée du point. Exemple :

#declare MyVector = MyVector + Amount*vturbulence(2, 0.5, 6, MyVector*Frequency);

Voir la section "Les fonctions numériques" pour d'autres fonctions qui sont en relation avec les vecteurs mais qui retournent des numériques. En plus des fonctions intégrées précédentes, vous pouvez aussi définir vos propres fonctions en utilisant la directive #macro. Voir la section "Les macros définies par l'utilisateur" pour plus de détails.

3.1.1.4.6 Les constantes intégrées

Il y a plusieurs identificateurs vectoriels intégrés. Vous pouvez les utiliser pour spécifier des valeurs ou pour créer des expressions, mais vous ne pouvez pas les redéclarer pour changer leurs valeurs. Ils sont :

VECTOR_BUILT-IN_IDENT:
	x | y | z | t | u | v

Ils ne changent jamais de valeur. Ils sont définis comme suit au début de chaque scène.

#declare x = <1, 0, 0>;
#declare y = <0, 1, 0>;
#declare z = <0, 0, 1>;
#declare t = <0, 0, 0, 1>;
#declare u = <1, 0>;
#declare v = <0, 1>;

Les identificateurs x, y, et z procurent une plus grande lisibilité aux scènes lors de leur utilisation dans les expressions vectorielles. Par exemple....

plane {y, 1}	// Le vecteur de la normale est évidemment "y".
plane {<0, 1, 0>, 1}	// Cela est plus dur à lire.
translate 5*x	// Déplace de 5 unités dans la direction "x".
translate <5, 0, 0>	// Ceci est moins évident.

Une expression comme 5*x s'évalue en 5*<1, 0, 0> ou <5, 0, 0>.

De même, u et v peuvent être utilisés dans les vecteurs 2D. Pour les 4D, vous avez x, y, z et t et POV-Ray fera évoluer x, y et z en 4D quand c'est nécessaire.

3.1.1.5 La spécification des couleurs

COLOR:
	COLOR_BODY |
	color COLOR_BODY |	(cela signifie que le mot clé color ou
	colour COLOR_BODY	colour peut précéder optionnellement
				toute spécification de couleur)
COLOR_BODY:
	COLOR_VECTOR |
	COLOR_KEYWORD_GROUP |
	COLOR_IDENTIFIER
COLOR_VECTOR:
	rgb <3_Term_Vector> |
	rgbf <4_Term_Vector> |
	rgbt <4_Term_Vector> |
	[ rgbft ] <5_Term_Vector>
COLOR_KEYWORD_GROUP:
	[ COLOR_KEYWORD_ITEM ]...
COLOR_KEYWORD_ITEM:
	COLOR_IDENTIFIER |
	red Red_Amount |
	blue Blue_Amount |
	green Green_Amount |
	filter Filter_Amount |
	transmit Transmit_Amount

Note : COLOR_IDENTIFIERS sont des identificateurs précédemment déclarés pour avoir des valeurs de couleur. Les termes vectoriels 3, 4, et 5 sont usuellement directs mais peuvent être des expressions vectorielles ou des numériques promus en vecteurs. Voir "L'opérateur promotion" et les sections précédentes.

POV-Ray vous demande souvent de spécifier une couleur. Elles sont constituées de cinq composants. Les trois premiers sont red, green et blue. Ils donnent l'intensité des couleurs primaires, en utilisant un système d'addition des couleurs, comme les phosphores de votre écran.

Le quatrième composant, appelé filtre, spécifie la quantité de transparence filtrée d'un substance. Quelques exemples réels de transparence filtrée sont les vitraux, ou les cellophanes teintés. La lumière passant à travers de tels objets est tintée par la couleur de la matière, car elle absorbe certaines fréquences, laissant les autres passer. La couleur de l'objet est soustraite de la lumière qui passe, c'est pourquoi elle est appelée transparence soustractive.

Le cinquième composant, appelé transmission, donne la quantité de lumière non filtrée qui passe. Quelques exemples réels sont les tissus fins, les filets à maille fine et la poussière sur les surfaces. Dans ces exemples, toutes les fréquences sont autorisées à passer à travers de petits trous. Bien que la lumière passant à travers est diminuée, sa couleur reste inchangée.

La couleur de l'objet et la couleur transmise à travers l'objet contribuent ensemble aux 100% de la couleur finale. Donc si transmit est mis à 0.9, la couleur transmise correspond à 90% et la couleur de l'objet contribue à 10%. Cela est vrai aussi en dehors de la fourchette 0-1, donc par exemple, si transmit est à 1.7, la couleur transmise contribue à 170% et celle de l'objet à moins 70%. L'utilisation de valeurs de transmit en dehors de la fourchette 0-1 peut créer des effets spéciaux intéressants, mais ne correspondra à aucun phénomène du monde réel. Un exemple :

#version 3.5;
global_settings {assumed_gamma 1.0}
camera {location -2.5*z look_at 0 orthographic}
box {
	0, 1
	texture {
		pigment {
			gradient y
			colour_map {
				[0, red 1]
				[1, blue 1]
			}
		}
		finish {ambient 1}
	}
	texture {
		pigment {
			gradient x
			colour_map {
				[0, rgb 0.5 transmit -3]
				[1, rgb 0.5 transmit 3]
			}
		}
		finish {ambient 1}
	}
	translate <-0.5,-0.5, 0>
	scale <3, 2, 1>
}

Lors de l'utilisation de valeur de transmit pour des effets spéciaux, vous pouvez visualiser ainsi : la valeur de transmit est égale au contraste. 1.0 n'apporte aucun changement au contraste, 0.5 est un demi contraste, 2.0 est un contraste doublé et ainsi de suite. Vous pouvez dire que transmit 'dimensionne' les couleurs. La couleur de l'objet est la valeur 'médiane'. Toutes les couleurs seront proches de la valeur 'médiane' si transmit est entre 0 et 1, et toutes les couleurs s'éloigneront de la valeur 'médiane' si transmit est plus grand que 1. Si transmit est négatif, les couleurs seront inversées autour de la valeur 'médiane'. Rgb 0.5 est classique pour représenter la valeur 'médiane', mais d'autres valeurs peuvent être utilisées pour d'autres effets. La valeur 'médiane' est réellement une couleur, et les couleurs non grises peuvent être utilisées pour des effets intéressants. Les composants red, green et blue sont gérés séparemment.

Note : les précédentes versions de POV-Ray utilisaient le mot clé alpha pour spécifier la transparence filtrante. Toutefois, ce mot est souvent utilisé pour la transparence non filtrante. Pour cette raison, alpha n'est plus utilisée.

Chacun des cinq composants d'une couleur est une valeur numérique, normalement dans le fourchette 0.0 à 1.0. Toutefois, toutes les valeurs, même négatives, peuvent être utilisées.

Sous certaines circonstances, le mot clé color est optionnel, et peut être omis. Nous supportons aussi l'appellation anglaise ou canadienne colour. Les couleurs peuvent être données avec des vecteurs, des mots clés avec des numériques ou des identificateurs. Vous pouvez également créer des expressions de couleur très complexes avec la combinaison de tous les opérateurs familiers. La syntaxe a évolué depuis la première version de POV-Ray. Nous avons maintenu la syntaxe avec les mots clés, et ajouté une notation vectorielle plus courte. Chacune des deux syntaxes est acceptable, toutefois, les vecteurs sont plus faciles d'emploi dans la création d'expressions de couleur.

La syntaxe pour combiner des termes de couleur dans des expressions de couleur suit les règles des vecteurs et des expressions numériques. Dans la syntaxe pour les expressions vectorielles, certains des éléments sont définis dans la section des expressions numériques. Voir "Les expressions numériques" pour ces définitions. Des explications détaillées sur les attributs spécifiques aux couleurs sont données dans les sous-sections suivantes.

3.1.1.5.1 Les vecteurs de couleur

La syntaxe pour un vecteur de couleur est ...

COLOR_VECTOR:
	rgb <3_Term_Vector> |
	rgbf <4_Term_Vector> |
	rgbt <4_Term_Vector> |
	[ rgbft ] <5_Term_Vector>

...où les vecteurs sont des expressions vectorielles valides de 3, 4 ou 5 composants. Par exemple :

color rgb <1.0, 0.5, 0.2>

Ceci spécifie une couleur où le composant rouge est 1.0 ou à 100% de la pleine intensité. Le vert est 0.5 ou à 50% de la pleine intensité et le bleu est 0.2 ou 20% de la pleine intensité. Toutefois, les composants filtre et transmission ne sont pas spécifiés, mais ils existent et sont à 0, ou aucune transparence.

Le mot clé rgbf demande un quatrième composant qui est le filtre, alors que la transmission est toujours à 0. De même, le mot clé rgbt requiert un quatrième composant, qui est la transmission, tandis que le filtre est mis à zéro.

Le mot clé rgbft vous autorise la spécification des cinq composants. En interne, les cinq composants sont toujours utilisés.

Sous certaines circonstances, si le vecteur contient 5 composants, ou s'il y a un identificateur de couleur dans l'expression, le mot clé rgbtf est optionnel.

3.1.1.5.2 Les mots clés des couleurs

L'ancienne syntaxe des mots clés de couleurs est toujours utile, et certains la préfère.

COLOR_KEYWORD_GROUP:
	[ COLOR_KEYWORD_ITEM ]...
COLOR_KEYWORD_ITEM:
	COLOR_IDENTIFIER |
	red Red_Amount | blue Blue_Amount | green Green_Amount | 
	filter Filter_Amount | transmit Transmit_Amount

Bien que le mot clé color soit optionnel, il est plus commun de le voir. Il est suivi par certains des cinq mots clés additionnels red, green, blue, filter, ou transmit. Chacun de ces composants est suivi d'une expression numérique. Par exemple :

color red 1.0 green 0.5

Cela spécifie une couleur ou le rouge est 1.0 ou à 100% d'intensité, et le vert à 50%. Bien que le bleu, le filtre et la transmission ne soient pas spécifiés, ils existent et sont à zéro. L'ordre des composants n'a pas d'importance et s'ils ne sont pas définis, ils prennent la valeur par défaut 0. Le COLOR_IDENTIFIER peut aussi être spécifié, mais il doit toujours être le premier du groupe. Voir "Les pièges communs des couleurs" pour les détails.

3.1.1.5.3 Les identificateurs de couleur

Les identificateurs de couleurs peuvent être déclarés pour rendre les scènes plus lisibles et paramétrables. Ils sont déclarés selon les manières suivantes.

COLOR_DECLARATION:
	#declare IDENTIFIER = COLOR; |
	#local IDENTIFIER = COLOR;

Où IDENTIFIER est le nom de l'identificateur, jusqu'à 40 caractères de long, et COLOR est toute spécification valide.

Note : il doit y avoir un point virgule à la fin de chaque déclaration. S'il est omis, cela génèrera un message d'erreur, ou gênera le fonctionnement des macros. Voir "#declare vs. #local" pour plus d'information.

Voici quelques exemples....

#declare White = rgb <1, 1, 1>;
#declare Cyan = color blue 1.0 green 1.0;
#declare Weird = rgb <Foo*2, Bar-1, Bob/3>;
#declare LightGray = White*0.8;
#declare LightCyan = Cyan red 0.6;

Comme le montre l'exemple LightGray, vous n'avez pas besoin de mot clé de couleur quand vous créez une expression basée sur des déclarations de couleur antérieures. Le dernier exemple montre que vous pouvez utiliser un identificateur de couleur avec la syntaxe de style mot clé. Assurez vous que l'identificateur vient le premier, avant tout mot clé de composant.

Comme les numériques et les vecteurs, vous pouvez redéfinir les couleurs en cours de scène, mais cela doit être rare.

3.1.1.5.4 Les opérateurs de couleur

Les vecteurs de couleur peuvent être combinés dans des expressions, comme les numériques ou les vecteurs. Les opérations sont effectuées composant par composant. Par exemple rgb <1.0, 0.5, 0.2>*0.9 vaut la même chose que rgb <1.0, 0.5, 0.2>*<0.9, 0.9, 0.9> ou rgb <0.9, 0.45, 0.18>. Les autres opérations sont faites sur le même principe de composant par composant.

Vous pouvez utiliser l'opérateur point pour extraire un composant d'une couleur. Supposons que l'identificateur Shade a été précédemment déclaré comme couleur. Alors, Shade.red est la valeur du composant rouge dans Shade. De même, Shade.green, Shade.blue, Shade.filter et Shade.transmit extraient les valeurs des autres composants de la couleur. Shade.gray donne la valeur en gris du vecteur de couleur.

3.1.1.5.5 Les pièges courants des couleurs

La variété et la complexité des méthodes de spécification des couleurs peuvent conduire à des erreurs communes. Voici certains points à considérer lors de la création d'une couleur.

Quand on utilise la transparence, les couleurs qui passent sont multipliées par les composants des couleurs primaires. Par exemple, si une lumière grise comme rgb <0.9, 0.9, 0.9> passe à travers un filtre comme rgbf <1.0, 0.5, 0.0, 1.0>, le résultat est rgb <0.9, 0.45, 0.0>, avec un rouge intact, la division par deux du vert, et le blocage complet du bleu. Beaucoup d'utilisateurs font l'erreur de déclarer un objet clair avec

color filter 1.0

mais cela déclare les couleurs primaires à zéro. Vous avez créé un filtre noir total, aussi aucune lumière ne passe au travers. La solution est

color red 1.0 green 1.0 blue 1.0 filter 1.0

color transmit 1.0

Dans le deuxième exemple, les valeurs des couleurs primaires n'ont pas d'importance. Toute la lumière passe intacte au travers. Un autre piège est l'utilisation d'identificateurs et d'expressions de couleur avec des mots clés de couleur. Par exemple...

color My_Color red 0.5

Cela substitue mon composant rouge de My_Color par le composant rouge de 0.5. Toutefois...

color My_Color + red 0.5

ajoute 0.5 au composant rouge de My_Color et encore moins clair...

color My_Color * red 0.5

Cela divise mon rouge par deux, comme désiré, mais multiplie aussi le vert, le bleu, le filtre et la transmission par zéro ! Le morceau d'expression après l'opérateur devient rgbft <0.5, 0, 0, 0, 0>, comme une couleur avec ses 5 composants.

L'exemple suivant n'entraîne aucun changement.

color red 0.5 My_Color

Cela parce que l'identificateur écrase la valeur précédente. Les identificateurs doivent toujours être les premiers avec les mots clés de couleur. Autre chose à considérer : certaines syntaxes de POV-Ray n'utilisent que la part rgb d'une spécification de couleur. Dans ces cas, il est légal d'utiliser un numérique. Par exemple :

finish {ambient 1}

Le mot clé ambient attend une couleur, donc 1 est promu en <1, 1, 1, 1, 1>, ce qui n'est pas un problème. Toutefois

pigment {color 0.4}

est légal, mais il peut ne pas donner ce que vous attendez. Le 0.4 est promu en <0.4, 0.4, 0.4, 0.4, 0.4>, avec le filtre et la transmission également à 0.4. Vous avez plus de chance de vouloir...

pigment {color rgb 0.4}

où un vecteur de 3 composants est attendu. Donc, le 0.4 est promu en <0.4, 0.4, 0.4, 0.0, 0.0>, avec un filtre et une transmission à 0, la valeur par défaut. Finalement, un autre problème survient avec l'utilisation de l'opérateur point dans les directives #declare ou #local. Voyez ceci :

#declare MyColor = rgb <0.75, 0.5, 0.75>;
#declare RedAmt = MyColor.red;

Maintenant, RedAmt devrait être un numérique, mais c'est une couleur. POV-Ray regarde le premier mot clé après l'égalité pour deviner le type d'identificateur. Il voit MyColor et pense que vous voulez déclarer une couleur. Il calcule la valeur 0.75 et la transforme en rgbft <0.75, 0.75, 0.75, 0.75, 0.75>. Cela demanderait une modification majeure pour contourner ce problème, alors nous nous contentons de vous avertir. Ce qui suit fonctionne normalement.

#declare RedAmt = 0.0+MyColor.red;
#declare RedAmt = 1.0*MyColor.red;
#declare RedAmt = (MyColor.red);

3.1.1.6.1 Les fonctions somme et produit

prod(i, b, n, a) La fonction produit.

fonction produit

sum(i, b, n, a) La fonction somme.

fonction somme

Pour prod et sum : i est tout nom de variable et a est toute expression, dépendant habituellement de i. b et n sont aussi toute expression.
Exemple :

#declare factorial = function(C) { prod(i, 1, C, i) }
#declare A = factorial(5);

Le premier paramètre est le nom de la variable d'itération. Le second est la valeur initiale de l'expression et le troisième est la valeur finale. Celles-ci ne dépendent pas de la variable d'itération mais cette dernière reste utilisée dans ces deux expressions (parce qu'il arrive qu'elle soit déjà définie) mais sa valeur est indéfinie. La dernière expression est l'expression courante qui sera itérée. Elle peut utiliser toute variable de la portée.

La portée d'une variable d'itération est la séquence d'opération de la fonction. Donc, la variable d'itération est seulement définie lors de son utilisation au sein de la fonction sum/prod. Bien sûr, les fonctions sum/prod peuvent être emboîtées. Toutefois, il y a une limite d'un maximum de 56 variables locales définies simultanément, ce qui signifie essentiellement que toute combinaison de fonctions sum/prod ne doit pas aller plus bas que le niveau 56.

La variable d'itération est incrémentée de un à chaque passage, mais sa valeur initiale et finale peut être n'importe quelle valeur. L'itération se poursuivra tant que la valeur d'itération est plus petite ou égale à la valeur finale.

Note : parce que la valeur d'itération est une variable décimale, l'ajout de un entraîne une dérive sur de longues itérations, et donc la précision du calcul en virgule flottante peut avoir un effet et doit être considérée en autorisant une erreur raisonable sur la valeur finale !

Si l'expression à ajouter a un signe négatif, elle doit bien sûr être soustraite. Donc le changement du signe autorisera la génération de valeurs négatives dans la fonction somme. De même la multiplication par 1/expression crée effectivement une division lors de l'utilisation dans la fonction produit.

Evidemment pour fonctionner au premier passage, la valeur initiale du résultat est l'élément neutre de l'opération. Donc, un calcul de somme commence avec 0 et un calcul de produit commence avec 1 comme assumé dans les sommes et produits en mathématiques classiques.

Il doit être noté que mathématiquement, la somme et le produit sont redondants parce que :

log10(prod(i, b, n, a)) = sum(i, b, n, log10(a))

qui implique qu'une somme peut être représentée comme un produit et vice-versa, en observant les contraintes mathématiques usuelles des logarithmes, bien sûr. Toutefois, comme les logarithmes et leurs inverses (les puissances) sont lents à calculer, les deux sont fournies...

3.1.1.6.2 Les fonctions et les macros

Vous pouvez utiliser des macros dans des fonctions, mais les macros ne seront appelées qu'une fois lors de la définition de la fonction, pas à chaque fois qu'elle est appelée. Vous ne pouvez pas passer des variables de fonction à des macros.

Vous pouvez passer des fonctions aux macros, et la façon de le faire est plus explicite avec un exemple :

#macro Foo(Bar, X)
	#declare Y = Bar(X);
	#declare Z = Bar(Y);
#end
#declare FUNC = function(n) {n+2}
Foo(FUNC, 1)
#debug str(Y, 5, 5)
	#debug "\n"
	#debug str(Z, 5, 5)
	#debug "\n"

3.1.1.6.3 La déclaration de fonctions numériques définies par l'utilisateur

Vous déclarez une fonction définie par l'utilisateur en utilisant les directives #declare ou #local. Par défaut, une fonction prend trois paramètres et vous n'avez pas besoin de définir explicitement leurs noms. Les trois paramètres par défaut sont x, y et z. Par exemple :

#declare foo = function {x + y * z}

Si vous avez besoin de plus ou moins de paramètres, vous devez spécifier leur liste.

Note : x et u comme y et v sont équivalents donc vous n'avez pas besoin de spécifier ces noms. Vous ne devez pas, non plus, spécifier deux paramètres ou plus avec le même nom. Cela aboutirait à une erreur d'analyse ou à des résultats inattendus.

Ce qui suit sont des fonctions valides avec des paramètres :

#declare foo2 = function(x, y, z) {x + y * z}
#declare foo3 = function(k1, k2, z, y) {x + y * z + k1 * y + k2}
#declare foo4 = function(h) {h * h + h}
#declare foo4 = function(u, v) {x + y * v}	// = u + v*v
#declare foo4 = function(x, v, z) {u + y * v + z}	// = x + v*v + z

Les limites :

Le nombre minimal de paramètre par fonction est 1.
Le nombre maximal de paramètres autorisés par fonction est 56.
Le nombre maximal de blocs function par scène est 1048575.
Le nombre maximal d'opérateur par fonction est d'environ 200000. Les limites seront différentes selon les types d'opérateurs utilisés dans la fonction.
La profondeur maximale pour l'emboîtement de fonctions est 1024.
Le nombre maximal de constantes dans l'ensemble des fonctions est 1048575.

Note : La redéclaration directe de fonctions est interdite. La méthode à suivre est de leur faire un undef d'abord.

Il y a un type de fonction numérique spécial. Vous pouvez déclarer une fonction pattern.

Note : la syntaxe est identique à celle des modèles, toutefois, vous ne pouvez pas spécifier les couleurs. Il donne toujours un numérique et non un vecteur, comme ce que retourne une fonction contenant un pigment.

#declare foo = function {
	pattern {
		checker
	}
}

Note : Le nombre de paramètres des types de fonctions spéciaux est automatiquement déterminé, donc vous n'avez pas à spécifier leurs noms.

3.1.1.6.4 La déclaration de fonctions vectorielles définies par l'utilisateur

En toute logique vous ne pouvez déclarez des fonctions vectorielles qu'en utilisant un des types de fonction spéciaux. Les types supportés sont les fonctions transform et spline. Par exemple :

#declare foo = function {
	transform {
		rotate <90, 0, 0>
		scale 4
	}
}
#declare myvector = foo(4, 3, 7);
#declare foo2 = function {
	spline {
		linear_spline
		0.0, <0, 0, 0>
		0.5, <1, 0, 0>
		1.0, <0, 0, 0>
	}
}
#declare myvector2 = foo2(0.7);

La fonction de courbes prend la taille d'un vecteur en compte. Donc, une fonction contenant une courbe avec cinq composants retournera aussi un vecteur à cinq composants, une fonction contenant une courbe avec deux composants retournera un vecteur à deux composants, et ainsi de suite.

Note : Le nombre de paramètres des types de fonctions spéciaux est automatiquement déterminé, donc vous n'avez pas à spécifier leurs noms.

3.1.1.6.5 La déclaration de fonctions de couleur définies par l'utilisateur

En toute logique vous ne pouvez déclarez des fonctions de couleur qu'en utilisant un des types de fonction spéciaux. Le type supporté est la fonction pigment. Vous pouvez utiliser tout pigment valide. Voici un exemple très simple :

#declare foo = function {
	pigment {
		color red 1
	}
}
#declare Vec = foo(1, 2, 3)

Un exemple utilisant un modèle :

#declare foo = function {
	pigment {
		crackle
		color_map {
			[0.3, color Red]
			[1.0, color Blue]
		}
	}
}
#declare Val = foo(2, 3, 4).gray

Note : Le nombre de paramètres des types de fonctions spéciaux est automatiquement déterminé, donc vous n'avez pas à spécifier leurs noms.

3.1.1.6.6 Les fonctions prédéfinies en interne

Plusieurs fonctions sont prédéfinies. Ces fonctions internes sont accessibles par "functions.inc", aussi il doit être inclus dans votre scène.
Le nombre de paramètres requis, et ce qu'ils contrôlent, est aussi donné dans le fichier inclus, mais le chapitre "functions.inc" dans la section "Le fichier inclus standard" donne plus d'information.

3.1.1.7.1 La syntaxe des chaînes

Les chaînes littérales commencent avec une apostrophe double, suivie de, au maximum, 256 caractères, et finissent avec une autre apostrophe double. Vous pouvez changer la table de caractères en utilisant l'option global_settings charset. Voici des chaînes littérales valides :

"Ici" "Là" "myfile.gif" "textures.inc"

Note : si vous devez placer une double apostrophe dans le texte, vous devez la faire précéder d'un 'backslash'.

Exemple

"Joe dit \"Hello\" en entrant."

est converti en :

Joe dit "Hello" en entrant.

Si vous devez inscrire un 'backslash', vous devez en spécifier deux. Par exemple :

"Ceci est un backslash \\ et ceci en est deux \\\\"

est converti en :

Ceci est un backslash \ et ceci en est deux \\

Les utilisateurs de Windows doivent être particulièrement attentifs à cela car le 'backslash' est aussi le séparateur d'adresses. Par exemple, le code suivant ne donne pas le résultat attendu :

#declare DisplayFont = "c:\windows\fonts\lucon.ttf"
text {ttf DisplayFont "Hello", 2, 0 translate y*1.50}

Les nouveaux utilisateurs attendront la création d'un objet texte utilisant la police "c:\windows\fonts\lucon.ttf". Au lieu de cela, il y aura un message d'erreur disant qu'il ne peut pas trouver le fichier de police "c:windowsontslucon.ttf".

La forme correcte de ce code est :

#declare DisplayFont = "c:\\windows\\fonts\\lucon.ttf"
text {ttf DisplayFont "Hello", 2, 0 translate y*1.50}

La disparition des 'backslash' se produit dans toutes les chaînes de caractères littérales de POV-Ray. Il y a aussi d'autres codes de formatage comme \n pour la nouvelle ligne. Voir "Le formatage de texte" pour les détails.

3.1.1.7.2 Les identificateurs de chaîne

Les identificateurs de chaîne peuvent être déclarés pour rendre la scène plus lisible et plus paramétrable. Ils sont déclarés comme ceci.

STRING_DECLARATION:
	#declare IDENTIFIER = STRING |
	#local IDENTIFIER = STRING

Où IDENTIFIER est le nom de l'identificateur, jusqu'à 40 caractères de long, et STRING est toute spécification de chaîne valide.

Note : au contraire des numériques, vecteurs et couleurs, il n'y a pas de point-virgule à la fin de la déclaration. Voir "#declare vs. #local" pour plus d'information.

Voici quelques exemples...

#declare Font_Name = "ariel.ttf"
#declare Inc_File = "myfile.inc"
#declare Nom = "John"
#declare Nom = concat(Nom, " Doe")

Comme le montre le dernier exemple, vous pouvez redéclarer un identificateur de chaîne, et pouvez y utiliser des valeurs précédemment déclarées.

3.1.1.7.3 Les fonctions de chaînes

keyword(param1, param2)

Ce qui suit sont les fonctions qui retournent du texte. Elles prennent un ou plusieurs paramètres numériques, vectoriels, ou chaîne de caractères. Assumez que A est toute expression valide qui se résout en numérique; B, L et P sont des numériques tronqués en entiers, S, S1, S2 etc. sont des chaînes de caractères.

chr(B) Caractère dont la valeur est B. Retourne une chaîne d'un seul caractère. La valeur du caractère est spécifiée par l'entier B qui doit être dans la fourchette 0 à 65535 si vous spécifiez charset utf8 dans global_settings et entre 0 et 127 si vous spécifiez charset ascii. Référez-vous à la documentation spécifique à votre plate-forme si vous spécifiez charset sys. Par exemple chr(70) est "F". Pour le rendu de caractères, vous devez savoir que les caractères sont dépendants de la police utilisée.

concat(S1, S2, ...) Concatène les chaînes S1 et S2. Retourne une chaîne qui est la concaténation de tous les paramètres textes. Doit avoir au moins deux paramètres, mais peut en avoir plus. Par exemple :

concat("Value is ", str(A, 3, 1), " inches")

Si la valeur numérique A était 12.34321, le résultat est "Value is 12.3 inches" qui est une chaîne.

str(A, L, P): Convertit le nombre A en une chaîne formatée. Retourne une chaîne formatée pour représenter la valeur numérique A. Le paramètre numérique L spécifie la longueur minimale de la chaîne, et le type de remplissage à gauche si la chaîne est plus courte que le minimum. Si L est positif, le remplissage est fait d'espaces. S'il est négatif, des zéros seront utilisés. La longueur minimale de la chaîne formatée est abs(L). Si elle a besoin d'être plus grande, elle sera ajustée à la taille nécessaire pour représenter la valeur.

Le paramètre entier P spécifie le nombre de décimales après le point décimal. Si P est négatif, alors une précision par défaut, spécifique au compilateur, est utilisée. Voici quelques exemples :

str(123.456, 0, 3)	"123.456"
str(123.456, 4, 3)	"123.456"
str(123.456, 9, 3)	"  123.456"
str(123.456,-9, 3)	"00123.456"
str(123.456, 0, 2)	"123.46"
str(123.456, 0, 0)	"123"
str(123.456, 5, 0)	"  123"
str(123.000, 7, 2)	" 123.00"
str(123.456, 0,-1)	"123.456000" (spécifique à la plate-forme)

strlwr(S) Minuscule de S. Retourne une nouvelle chaîne dans laquelle toutes les majuscules sont converties en minuscules. La chaîne originale n'est pas affectée. Par exemple strlwr("Hello There!") donne "hello there!".

strupr(S) Majuscule de S. Retourne une nouvelle chaîne dans laquelle toutes les minuscules sont converties en majuscules. La chaîne originale n'est pas affectée. Par exemple strupr("Hello There!") donne "HELLO THERE!".

substr(S, P, L) Sous-chaîne de S. Retourne une chaîne qui est un sous-ensemble des caractères de S, commençant à la position donnée par l'entier P, pour une longueur donnée par l'entier L. Par exemple substr("ABCDEFGHI",4,2) donnera "DE". Si P+L-1>strlen(S), une erreur apparaît.

vstr(N, A, S, L, P) Convertit le vecteur A en une chaîne de caractères formatée. Donne une représentation en chaîne formatée du vecteur A où les éléments du vecteur sont séparés par le paramètre de chaîne S. Le paramètre entier N spécifie la quantité de dimensions du vecteur A. N est coupé automatiquement à la fourchette de 2 à 5 sans avertissement. La spécification d'un vecteur A avec plus de dimensions que données par N donnera une erreur.
La paramètre entier L spécifie la longueur minimale de la chaîne et le type de remplissage à gauche si la représentation en chaîne est plus courte que le minimum. L'entier P spécifie le nombre de décimales après le symbole décimal. Si P est négatif alors une précision par défaut spécifique au compilateur est utilisée. La fonction de L et P est la même que dans str. Voici quelques exemples :

vstr(2, <1, 2>, ", ", 0, 1)	"1.0, 2.0"
vstr(5, <1, 2, 3, 4, 5>, ", ", 0, 1)	"1.0, 2.0, 3.0, 4.0, 5.0"
vstr(1, 1, ", ", 0, 1)	"1.0, 1.0"
vstr(2, 1, ", ", 0, 1)	"1.0, 1.0"
vstr(5, 1, ", ", 0, 1)	"1.0, 1.0, 1.0, 1.0, 1.0"
vstr(7, 1, ", ", 0, 1)	"1.0, 1.0, 1.0, 1.0, 1.0"
vstr(3, <1, 2>, ", ", 0, 1)	"1.0, 2.0, 0.0"
vstr(5, <1, 2, 3>, ", ", 0, 1)	"1.0, 2.0, 3.0, 0.0, 0.0"
vstr(3, <1, 2, 3, 4>, ", ", 0, 1)	erreur

Voir la section "Les fonctions numériques" pour d'autres fonctions en relation avec les chaînes, mais qui retournent du numérique. Vous pouvez aussi définir vos propres fonctions en utilisant la directive #macro. Voir la section "Les macros définies par l'utilisateur" pour plus de détails.