Cet article est une traduction de (https://www.cs.unc.edu/~rademach/xroads-RT/RTarticle.html) Par Paul Rademacher

Malgré que les graphiques en trois dimensions sur ordinateur existent depuis de nombreuses décennies, il y a eu une augmentation d’intérêts généraux vers ce domaine les deux dernières années.

Juste un rapide coup d’oeil aux dernières superproductions suffit à voir la fascination du public envers la nouvelle génération de graphismes. Aussi excitants que soient les graphismes, cependant, il y a une barrière définie qui empêche la plupart des gens d’en apprendre sur eux. Tout d’abord, il y a beaucoup de mathématiques et de théorie impliqués. Au-delà de ça, obtenir juste une fenêtre pour afficher des graphiques en 2D, même simples peuvent souvent être une tâche intimidante.

Dans cet article, nous allons parler d’une méthode graphique 3D puissante mais simple connu sous le nom de “Ray Tracing”, qui peut être comprise et mise en oeuvre sans utiliser beaucoup de maths ou les subtilités des systèmes de fenêtres. Les seules connaissances mathématiques que nous utiliserons sont la base de vecteurs, les produits scalaires, et les produits croisés. Nous allons passer la plupart de la théorie derrière le ray tracing, en se concentrant plutôt sur un aperçu général de la technique dans une perspective axée sur la mise en oeuvre.

Qu’est ce que le lancer de rayons ?

Le traçage au moyen de rayons est une technique de rendu graphique en trois dimensions qui comporte des interactions lumineuses très complexes. Cela signifie que vous pouvez créer des images avec des réflexions, des surfaces transparentes et des ombrages, et ce avec des résultats étonnants. Nous discutons du traçage par rayons dans cet article d’introduction au graphisme car c’est une méthode très simple à comprendre et à mettre en oeuvre. C’est basé sur l’idée que vous pouvez modéliser la réflexion et la réfraction de manière récursive en suivant le chemin que la lumière prend alors qu’elle rebondit à l’intérieur d’un environnement.

Certaines terminologies

Avant de présenter la description complète du lancer de rayons, nous devrions nous mettre d’accord sur la terminologie de base. Lors de la création de toute sorte de graphiques informatiques, vous devez avoir une liste d’objets que vous souhaitez que votre logiciel rende. Ces objets font partie d’une scène ou d’un monde (Fig. 2), de telle sorte que lorsque nous parlerons de “regarder le monde,” que nous ne soyons pas dans un défi philosophique, mais que nous fassions seulement allusion au lancer de rayons dessinant les objets provenant d’un point de vue. Dans les graphiques, cette perspective est appelée l’oeil ou caméra.

Suite à l’analogie de cette caméra, tout comme une caméra doit filmer l’endroit sur lequel on projette la scène et l’enregistrer, dans les graphiques, nous avons une fenêtre d’affichage sur laquelle nous dessinons la scène. La différence est que tandis que dans les caméras le film est placé derrière l’ouverture ou le point de focal, dans les graphiques de la fenêtre d’affichage le point de focal est en face. Donc, la couleur de chaque point d’un vrai film est causée par un rayon lumineux (en fait, un groupe de rayons) qui passe à travers l’ouverture et frappe le film, en infographie chaque pixel de l’image finale est causée par un rayon de lumière simulée qui frappe la fenêtre d’affichage sur la trajectoire de l’oeil. Les résultats sont cependant les mêmes.

Comme vous l’aurez deviné, notre objectif est de trouver la couleur de chaque point de la fenêtre d’affichage. Nous divisons la fenêtre d’affichage en petits carrés, où chaque carré correspond à un pixel de l’image finale. Si vous voulez créer une image avec une résolution de 640×400, vous allez décomposer la fenêtre d’affichage dans une grille de 640 carrés sur la largeur par 400 carrés sur la hauteur. Le vrai problème est donc d’attribuer une couleur à chaque carré. C’est ce que fait le lancer de rayons.

Comment ça marche ?

Le lancer de rayons est ainsi nommé parce qu’il essaie de simuler le chemin que les rayons lumineux prennent à mesure qu’ils rebondissent autour du monde – ils sont tracés à travers la scène. L’objectif est de déterminer la couleur de chaque rayon de lumière qui frappe la fenêtre d’affichage avant d’atteindre l’oeil.

Un rayon de lumière peut être pensé comme un seul photon (bien que ce ne soit pas rigoureusement exact parce que la lumière a également des propriétés d’ondes – mais j’ai promis qu’il n’y aurait pas de théorie). Le nom “lancer de rayons” est un peu trompeur parce que l’hypothèse naturelle serait que les rayons sont tracés à partir de leur point d’origine, la source de lumière, et vers leur destination, l’oeil (voir Fig 3). Ce serait une façon précise de le faire, mais malheureusement, cela a tendance à être très difficile en raison du nombre considérable impliqué.

Considérez le tracer d’un rayon de cette manière à travers une scène avec une lumière et un objet, comme une table. Nous commençons par l’ampoule, mais d’abord on doit décider de combien de rayons on souhaite tirer à partir de l’ampoule. Ensuite, pour chaque rayon, nous devons décider dans quelle direction il va. Il y a vraiment une infinité de directions dans lesquelles il peut voyager – comment savoir laquelle choisir ? Disons que nous avons répondu à ces questions et sommes en train de tracer un nombres de photons. Certains vont atteindre l’oeil directement, d’autres vont rebondir autour, puis rejoindre l’oeil, et beaucoup, beaucoup d’autres ne frappement probablement jamais l’oeil. Pour tous les rayons qui ne parviennent jamais à l’oeil, l’effort pour les tracer a été gaspillé.

Pour nous éviter ce gaspillage d’efforts. nous traçons seulement les rayons qui sont certains de frapper la fenêtre d’affichage et d’atteindre l’oeil. Il semble d’abord qu’il soit impossible de savoir à l’avance où les rayons atteignent l’oeil. Après tout, tout rayon donné peut rebondir autour de la salle à plusieurs reprises avant d’atteindre l’oeil. Cependant, si nous regardons le problème à l’envers, nous voyons qu’il y a une solution très simple.

Au lieu de tracer les rayons à partir de la source de lumière, nous les traçons à l’envers, à partir de l’oeil. Considérons un point quelconque de la fenêtre d’affichage dont nous essayons de déterminer la couleur. Sa couleur est donnée par la couleur du rayon lumineux qui passe par ce point sur la fenêtre d’affichage et de l’oeil atteint. Nous pouvons tout aussi bien suivre le rayon à l’envers en commençant par l’oeil et passer par le point sur son chemin dans la scène. Les deux rayons seront identiques, à l’exception de leur direction: si le rayon d’origine est venu directement de la source de lumière, le rayon inverse ira directement à la source de lumière; si l’original a rebondit sur une première surface, le rayon inverse aura également rebondit sur la surface. Vous pouvez le voir en regardant la figure 3, en inversant simplement les directions des flèches. Donc, la méthode inverse fait la même chose que la méthode originale, sauf qu’elle ne gaspille pas d’effort sur les rayons qui ne parviennent jamais à l’oeil.

Ceci est alors la façon dont le lancer de rayon fonctionne en infographie. Pour chaque pixel sur la fenêtre de vue, nous définissons un rayon qui va de l’œil à ce point. Nous suivons ce rayon jusque dans la scène et à mesure qu’il rebondit sur différents objets. La couleur finale du rayon (et donc du pixel correspondant) est donné par les couleurs des objets éclairés par le rayon à mesure qu’il traverse la scène.

Tout comme dans la méthode de la source de lumière vers les yeux, il pourrait il y avoir un très grand nombre de rebonds et il pourrait ne jamais frapper l’oeil, dans la méthode inverse il pourrait il y avoir de nombreux rebondissements avant que chaque rayon frappe la lumière. Puisqu’il faut établir une limite sur le nombre de rebonds à suivre pour un rayon, on fait l’approximation suivante : chaque fois qu’un rayon rencontre un objet, on suit un seul nouveau rayon à partir du point d’intersection directement vers la source de lumière (Fig. 4).

Dans la figure, nous voyons deux rayons, a et b, qui coupent la sphère violette. Pour déterminer la couleur de a, nous suivons le nouveau rayon directement vers la source de lumière. La couleur de a dépendra alors de plusieurs facteurs, décrit dans la partie Couleur et Trame ci-dessous. Comme vous pouvez le voir, b aura une ombre parce que le rayon b qui traverse la source de lumière est bloquée par la sphère elle-même. Le rayon a aura également une ombre si un autre objet bloque le rayon a.

Réflexion et Réfraction

Comme les ombres sont faciles à manipuler, voyons la réflexion et la réfraction. Dans l’exemple ci-dessus, on ne tenait compte que d’un seul rebond, de l’oeil vers la source de lumière. Pour gérer la réflexion, nous allons considérer également de multiples rebondissements à partir des objets, et pour gérer la réfraction nous allons considérer ce qui se passe quand un rayon traverse un objet partiellement ou entièrement transparent.

Si un objet reflète nous allons simplement suivre un nouveau rayon du point d’intersection vers la direction de la réflexion. Le rayon réfléchi est l’image miroir du rayon d’origine, pointant vers l’extérieur à partir de la surface. Si l’objet est dans une certaine mesure transparent, alors nous allons aussi tracer un rayon réfracté dans la surface. Si les matériaux de chaque côté de la surface ont des indices de réfraction différents tels que l’air d’un côté et de l’eau sur l’autre, alors le rayon réfracté va se plier, comme l’image d’une paille dans un verre d’eau. Si le milieu existe sur les deux côtés de la surface, alors le rayon réfracté se déplace dans la même direction que le rayon original et ne se plie pas.

Les directions des rayons reflétés et rétractés sont donnés par les formules suivantes. Pour un rayon de direction V, et avec une surface normale N (la surface normale est seulement la direction perpendiculaire à la surface – pointant directement loin de lui),la direction du rayon réfléchi Rl est donnée par

c1 = -dot_product(N, V) // Produit scalaire
Rl = V + (2 * N * c1)

A noter que puisque V, N, et Rl sont des vecteurs avec x, y, et z, le calcul est effectué par composant. La direction du rayon réfracté Rr est donnée par

// n1 = indice de réfraction du milieu d'origine
// n2 = indice de réfraction du nouveau milieu
n = n1 / n2 c2 = sqrt(1 - n2 * (1 - c1^2))
Rr = (n * V) + (n * c1 - c2) * N

Réflexion et réfraction récursive

La figure 6 montre un exemple d’objets qui sont à la fois dans un état de réflexion et de réfraction (il ne montre pas les rayons de chaque intersection de la source de lumière, pour des raison de clarté). Notez comment les rayons deviennent beaucoup plus compliqué une fois la réflexion et la réfraction ajoutés.

Maintenant, chaque rayon réfléchies et réfractées peut engendrer deux autres rayons, chacun d’eux peuvent alors en faire encore deux, et ainsi de suite. Cet agencement des rayons puis des sous-rayons conduit à l’idée d’un arbre de rayons. Le noeud racine de cette arbre est le rayon initial (a sur la figure) à partir de l’oeil, et chaque noeud de l’arbre est soit réfléchi ou rétracté à partir d’un rayon au-dessus. Chaque feuille de l’arbre est soit un rayon qui a frappé un objet non-réfléchissant et non-transparent, ou lorsque la profondeur de l’arbre atteint un maximum.

Aussi compliqué que cela paraisse, il y a en fait un moyen très simple de mettre en oeuvre cet arbre de rayons : des appels de fonctions récursives. Pour chaque point de la fenêtre d’affichage nous appelons une fonction trace_ray(), en lui passant le rayon de l’oeil vers le point. Si le premier objet rencontré par le rayon n’est pas réfléchissant et pas transparent, la fonction détermine simplement la couleur du point d’intersection et retourne cette couleur. Si ce rayon frappe un objet réfléchissant, alors, la fonction appelle trace_ray() de manière récursive, mais avec le rayon réfléchi à la place. Si l’objet rencontré est transparent, la fonction appelle aussi trace_ray() avec le rayon réfracté en tant que paramètre. Les couleurs renvoyées par ces deux appels de fonctions sont combinés avec la couleur de l’objet et la couleur combinée est retournée. Ceci peut être facilement exprimée en pseudo-code comme ceci :

Color trace_ray( Ray original_ray )
{
    Color point_color, reflect_color, refract_color
    Object obj 

    obj = get_first_intersection( original_ray )
    point_color = get_point_color( obj )

    if ( object is reflective )
        reflect_color = trace_ray( get_reflected_ray( original_ray, obj ) )
    if ( object is refractive )
        refract_color = trace_ray( get_refracted_ray( original_ray, obj ) )

    return ( combine_colors( point_color, reflect_color, refract_color ))
}

Où une couleur est le triplet (R, G, B) pour les composantes rouge, vert et bleu de la couleur, qui peuvent chacun varier entre zéro et un. Cette fonction, avec quelques routines d’intersection, est vraiment tout ce qui est nécessaire pour écrire un traceur de rayons.

Intersections

L’un des calculs de base nécessaires par le traceur de rayons est une routine d’intersection pour chaque type d’objet dans la scène : une pour les sphères, une pour des cubes, une pour des cônes, et ainsi de suite. Si un rayon coupe un objet, la routine d’intersection de l’objet renvoie la distance du point à l’origine du rayon, le vecteur normal au point d’intersection, et, si le mappage de texture est utilisé, une coordonnée correspondance sera faite entre le point d’intersection et l’image de texture ( voir plus loin dans le Mappage de Texture).

La distance du point d’intersection est nécessaire parce que si un rayon coupe plus d’un objet, nous choisissons celui avec le point d’intersection le plus proche. La normale est utilisée pour déterminer l’ombre du point, car il décrit la direction dans laquelle la surface est confrontée, et affecte donc la quantité de lumière que reçoit le point (voir Couleur et Trame).

Intersection d’une Sphère

Pour chaque type d’objet que le traceur de rayons supporte, vous avez besoin d’une routine d’intersection séparée. Nous allons limiter notre traceur de rayons à la manipulation des sphères uniquement, car la routine d’intersection pour une sphère est parmi les plus simples. La dérivation suivante de l’intersection d’une sphère est basée sur [Glassner90], page 388.

La figure 7 montre la géométrie d’un rayon R (à l’origine E et la direction V) recoupant une sphère de centre O et de rayon r. Selon le schéma,

v2 + b2 = c2 and d2 + b2 = r2 // (Par simple géométrie)
// et ainsi
d = sqrt( r2 - (c2 - v2))

Pour déterminer si une intersection se produit, nous calculons la valeur de d, si d >= 0, alors une intersection valide se produit. Si le rayon d ne coupe pas, alors d sera inférieur à zéro. Après avoir trouvé la valeur de d, la distance de E au point d’intersection P est (c – d). Le pseudo-code pour tout cela est :

v = dot_product( EO, V )
disc = r2 - ((dot_product( EO, EO ) - v2 )

if ( disc < 0 )
    //no intersection
else
    d = sqrt( disc )
    P = E + (v - d) * V

La couleur et l’ombre

Il y a beaucoup de façons différentes pour déterminer la couleur d’un point d’intersection. Certaines méthodes sont très simples – comme dans le “flat shading”, où chaque point de l’objet a la même couleur. Certaines techniques, telles que la méthode de Cook-Torrance [Cook82] – sont assez complexes, et prennent en compte de nombreux attributs physiques de la matière en question.

Nous allons décrire ici un modèle simple connu comme l’ombrage Lambertian ou cosinus ombrage. Il détermine la luminosité d’un point sur la base du vecteur normal et le vecteur du point de la source lumineuse. Si les deux coïncident (la surface est directement face à la source de lumière) alors le point est à pleine intensité. Si l’angle entre les deux vecteurs augmente, comme lorsque la surface est inclinée à l’abri de la lumière, alors la luminosité diminue. Ce modèle est connu sous le nom “cosinus ombrage” parce que la fonction mathématique met en oeuvre facilement l’effet ci-dessus : elle renvoie la valeur 1 quand un angle de zéro est donné, et renvoie zéro quand on lui un donne un angle de quatre vingt dix degrés (lorsque la surface et la source lumineuse sont perpendiculaire). Ainsi, pour trouver la luminosité d’un point, nous prenons simplement le cosinus de l’angle entre les deux vecteurs. Cette valeur peut être calculée rapidement, car elle est égal au produit scalaire des deux vecteurs Donc, en prenant le produit scalaire de la surface normale et le vecteur de la longueur vers la lumière, nous obtenons une valeur comprise entre -1 et 1. Les valeurs de -1 à 0 indiquent que la surface est face à la source de lumière, de sorte qu’elle ne reçoit aucune lumière. La valeur 0 signifie que la surface est directement perpendiculaire à la source de lumière (elle frôle le milieu), et ainsi de nouveau ne reçoit aucune lumière. Les valeurs supérieures à 0 indiquent que la surface reçoit un peu de lumière, avec une réception maximal lorsque le produit scalaire est à 1.

Dans le cas où le résultat du produit scalaire est zéro ou en dessous de zéro, nous avons peut-être une partie de l’objet avec un noir intense. Après tout, même quand un objet est complètement bloquée à partir d’une source de lumière, il y a encore les rebonds de la lumière autour de ce qu’elle éclaire dans une certaine mesure. Pour cette raison, nous ajoutons un peu de lumière ambiante pour chaque objet, ce qui signifie que la quantité minimale de lumière d’un objet est en fait au-dessus de zéro. Si nous fixons le coefficient ambiant à 20%, par exemple, alors, même dans l’ombre totale un objet recevra 20% d’illumination, et sera donc un peu visible. Si 20% d’éclairage est toujours présent, alors les 80% restants sont déterminée par le cosinus ombrage. La valeur de 80% dans ce cas est connu comme le coefficient de diffusion, qui est juste (1 – coefficient de la température ambiante). Le calcul de la couleur finale est alors :

shade = dot_product( light_vector, normal_vector )

if ( shade < 0 )
    shade = 0
    point_color = object_color * ( ambient_coefficient + 
    diffuse_coefficient * shade )

Le “Mapping” des textures

Jusqu’ici, nous avons supposé que chaque point sur un objet donné a la même couleur de base, et ne varie que par le cosinus ombrage qui rend l’objet plus claire ou plus foncée. Cependant, il y a une autre façon de colorer des objets, qui attribue des images entières aux objets au lieu de couleurs simples. Connu comme le mappage de texture, en effet, nous “collons” des images aux surfaces des objets. Un exemple que certainement tout le monde va reconnaître est dans les jeux du style “Doom”, où les murs sont dessinées de motifs en pierre ou en métal au lieu de couleurs simples. Ces programmes commence avec de petites images de ces modèles (appelés textures), puis recouvre les murs avec ces images. Ce revêtement est appelé mappage car il mappe chaque pixel de l’image sur des points constituant les parois. Le mappage de texture est beaucoup plus lent que l’attribution d’une couleur unique à chaque objet, car elle nécessite de déterminer et aller chercher le pixel de texture appropriée correspondant à chaque point que nous dessinons. Il est devenu très commun dans les quelques dernières années, cependant, merci au progrès de la vitesse des processeurs et des algorithmes graphiques plus rapides.

Alors que le mappage de texture produit des effets très agréable, ce n’est pas une caractéristique difficile à mettre en oeuvre. Tout ce qui est nécessaire est une routine qui renvoie les coordonnées d’un pixel de texture étant donné les coordonnées d’un point sur un objet. Les coordonnées de texture sont mentionnées comme (u, v), où u est l’emplacement horizontal du point de l’image, et v est la position verticale du point. Le traceur de rayons récupère alors le pixel au point (u, v), à partir de l’image de texture, et l’ajuste au besoin en utilisant le cosinus ombrage pour la rendre plus claire ou plus foncée.

Mappage de texture des sphères

La meilleure façon de mapper la texture sur une sphère est en définissant v soit la latitude du point et u la longitude du point de la sphère. De cette façon, la texture de l’image sera “enveloppé” autour de la sphère, un peu comme une carte du monde rectangulaire est enroulé autour d’une globe.

D’abord, nous trouvons les deux vecteurs d’unité de longueur Vn et Ve, depuis le point du centre de la sphère vers le “pôle nord” et un point sur l’équateur, respectivement. Nous trouvons alors le vecteur Vp, du centre de la sphère au point que nous allons colorer. La latitude est tout simplement l’angle entre Vp et Vn. Depuis, nous avons noté ci-dessus que le produit scalaire de deux vecteurs est égale au cosinus de l’angle des deux vecteurs, nous pouvons trouver l’angle de cette façon :

phi = arccos( -dot_product( Vn, Vp ))

Et puisque v doit varier entre zéro et un :

v = phi / PI

nous devons trouver ensuite la longitude tel que :

theta = ( arccos( dot_product( Vp, Ve ) / sin( phi )) ) / ( 2 * PI) 

if ( dot_product( cross_product( Vn, Ve ), Vp ) > 0 )
    u = theta
else
    u = 1 - theta

La dernière comparaison vérifie simplement de quel côté du vecteur Ve le point est (dans le sens horaire ou antihoaire), et que u se positionne en conséquence. Maintenant, la couleur du point est le pixel (u * texture_width, v * texture_height) au sein de la texture de l’image. Pour plus d’informations à ce sujet, lire [Glassner89], page 48.

Mettre le tout ensemble

Maintenant que nous avons couvert la base du lancer de rayons, les intersections, la couleur et le mappage de texture, il est peut-être pas encore évident de savoir comment reconstituer ces concepts ensemble dans un programme. Voici donc un aperçu de la façon dont un programme de tracé de rayons simple pourrait fonctionner :

Tout d’abord, nous devons définir la scène que nous voulons rendre. Nous créons un fichier de saisie de texte qui décrit les objets de la scène, en précisant l’emplacement, les attributs (comme le rayon de la sphère), la couleur et la texture optionnelle de chaque objet. Nous spécifions alors où doivent être situés la camera et la vue d’affichage. Pour plus de simplicité, nous pouvons supposer que la caméra est toujours sur l’axe Z pointant vers l’origine, et que la fenêtre d’affichage se trouve à l’origine. Nous devons aussi déterminer la taille de la fenêtre d’affichage, qui est spécifié par un champ de vue (FOV) en paramètre. Le champ de vision détermine la taille de la fenêtre d’affichage, et donc combien de la scène est visible. Basé sur ces paramètres, nous pouvons calculer les coins supérieur gauche et inférieur droit de la fenêtre.

Maintenant que nous avons les points supérieurs gauche et inférieur droit, nous divisons la fenêtre dans la résolution requise pour notre image de sortie, par exemple, de 640 par 400. Nous intervenons à travers chacun des 640×400 points de la fenêtre d’affichage, définissant un rayon de l’oeil à ces points. Pour chaque rayon, nous calculons son intersection avec tout les objets de la scène. Si il ne coupe pas d’objets, nous plaçons le rayon – et donc le pixel correspondant – à la couleur de fond. Sinon, nous choisissons l’objet avec l’intersection la plus proche. Si l’objet est réfléchissant, nous appelons la fonction de lancer de rayons à nouveau de manière récursive, en lui passant la direction réfléchi. Si l’objet est transparent, nous faisons la même chose avec la direction réfractée. La fonction d’appel calcule ensuite la couleur de l’objet, si elle est saisie, et combine cette couleur avec les couleurs des rayons réfléchies et réfractées.

Lorsque l’appel du traceur de rayons de l’origine de l’oeil vers la fenêtre d’affichage, la couleur sera la couleur finale de ce pixel – en tenant compte de la réflexion, réfraction, et les ombres. Cette couleur de pixel est alors écrite dans le fichier de sortie. Lorsque tous les points de la fenêtre de vue ont été traitées de cette façon, vous aurez une image de lancer de rayons terminé.

Exemple d’images

Voici quelques images créées avec le code simple disponible en ligne. Ils démontrent les techniques décrites dans cet article. Pour certaines images créées avec les fonctionnalités complètes du traceur de rayons, consultez les liens dans la section Ressources Internet ci-dessous.

Ressources Internet

Il existe de nombreuses ressources de lancer de rayons sur Internet. Voici certaines des meilleures :

Il existe un puissant programme gratuit de lancer de rayons appelé POV-Ray (pour Persistence of Vision Ray Tracer), disponibles pour presque chaque plate-forme à l’adresse http://www.povray.org. il est disponible à la fois sous forme de source et de binaire, et leur page web contient des liens vers d’autres informations de lancer de rayons ainsi qu’une belle galerie d’images créées avec POV-Ray.

Radiance (http://radsite.lbl.gov/radiance/HOME.html) est un traceur de rayons orientés vers l’analyse de l’éclairage, plutôt que de simplement faire de jolie images.

Rayshade (http://www-graphics.stanford.edu/~cek/rayshade/raysh/ade.html) est un traceur de rayons rapide avec un support pour le traitement parallèle.

Les outils “Blue Moon Rendering” (http://www.seas.gwu.edu/student.gritz/bmrt.html) est un lancer de rayons qui exécute le “Renderman” donnant de l’ombre avec le langage. Ce langage est utilisée par des sociétés telles que l’industrie Light & Magic et Pixar pour créer à peu près tous les effets spéciaux époustouflant par ordinateur des vingt dernières années. Ce logiciel professionnel est plutôt cher, Le paquet gratuit de Larry Gritz est une façon idéal de jouer avec le langage “Renderman”.

Une bonne page générale sur le lancer de rayons peut être trouvé ici http://www.cm.cf.ac.uk/Ray.Tracing/, avec des liens vers de l’informations sur le lancer de rayons et plus de logiciels.

Les nouvelles du lancer de rayons (http://www.acm.org/tog/resources/RTNews/html/index.html) ce lien est une publication sur l’électronique avec beaucoup de bonnes informations sur le lancer de rayons.

Références et suggestions de lecture

1. Cook, R.L., and Torrance, K.E. A Reflectance Model for Computer Graphics. ACM Trans. on Graphics 1, 1 (Jan 1982)

2. Foley, J. D., and Van Dam, A. Computer Graphics: Principes et Pratiques, deuxième édition. Addison-Wesley New York, N.Y. 1990

3. Glassner, A. (ed) An Introduction to Ray Tracing. Academic Press New York, N.Y. 1989.

4. Glassner, A. (ed) Graphics Gems. Academic Press New York, N.Y. 1990.

5. Watt, A., and Watt, M. Advanced Animation and Rendering Techniques. Addison-Wesley New York, N.Y. 1990.