Renderman (Partie 4)

RETOUR

Les shaders de volume

Un volume est une région de l'espace remplie d'un matériau qui modifie la lumière qui le traverse (un zone de brume, une flaque d'eau, une atmosphère poussiéreuse, ...).

Pas de notion de volume en Renderman -> représentation d'une surface fermée. Attribution d'un shader pour l'intérieur d'un objet, pour l'extérieur d'un objet et pour l'atmosphère.

RtVoid RiInterior(char *name,parameterlist);

RtVoid RiExterior(char *name,parameterlist);

RtVoid RiAtmosphere(char *name,parameterlist);

Quand de la lumière entre dans une surface, le shader extérieur est appelé pour modifier la lumière avant qu'elle ne touche la surface.

A l'intérieur d'un objet, c'est le shader intérieur qui est appelé.

Pour le parcours objet -> observateur c'est le shader atmosphère qui est utilisé.

Shaders prédéfinis

• Mixe la couleur backgroundcolor et la lumière réfléchie par une surface S.

backgroundcolor est retourné si la distance S-Observateur est supérieure à maxdist.

La lumière réfléchie est retourné inchangée si la distance S-Observateur est inférieure à mindist.

Entre les deux, le mixage est réalisé linéairement.

RiAtmosphere("depthcue",
     "mindistance",RtFloat *mindist,
     "maxdistance",RtFloat *maxdist,
     "background",RtColor backgroundcolor,
     RI_NULL) ;

RtColor color = {.9F,.9F,.5F};
RtColor bkcolor = {.05F,.05F,.05F};
RtPoint Square[4]    =
 { {5.0F,5.0F,0.0F},{-5.0F,5.0F,0.0F},
   {-5.0F,-5.0F,0.0F},{5.0F,-5.0F,0.0F} };

void main(void) {
  RiBegin(RI_NULL);
  RiFormat(400,400,1.0F);
  RiDisplay("PinDeck.tif",
            RI_FILE,RI_RGB,
            RI_NULL);
  RiLightSource("ambientlight",RI_NULL);
  RiLightSource("distantlight",RI_NULL);
  RtFloat fov = 45.0F ;
  RiProjection("perspective",
               RI_FOV,(RtPointer) &fov,
               RI_NULL);
  RiTranslate(0.0F,0.0F,6.0F);
  RiWorldBegin();
  RtFloat ka = 0.1F ;
  RtFloat kd = 0.7F ;
  RtFloat ks = 0.2F ;
  RiSurface("plastic",
            "Ka",&ka,
            "Kd",&kd,
            "Ks",&ks,
            RI_NULL);
  RtFloat min = 3.0F ;
  RtFloat max = 5.5F ;
  RiAtmosphere("depthcue",
               "mindistance",&min,
               "maxdistance",&max,
               "background",bkcolor,
               RI_NULL) ;
  RiColor(color);
  Go();
  RiWorldEnd();
  RiEnd();
}

• Mixe la couleur fogcolor et la lumière réfléchie par une surface S.

Le mixage est réalisé exponentiellement en fonction de la distance surface-observateur d selon le poids (1-e^-d/distance).

RiAtmosphère("fog",
       "background",RtColor fogcolor,
       "distance",RtFloat *distance,
       RI_NULL) ;

RtColor color = {.9F,.9F,.5F};
RtColor bkcolor = {.05F,.05F,.05F};
RtPoint Square[4]    =
 { {5.0F,5.0F,0.0F},{-5.0F,5.0F,0.0F},
   {-5.0F,-5.0F,0.0F},{5.0F,-5.0F,0.0F} };

void main(void) {
  RiBegin(RI_NULL);
  RiFormat(400,400,1.0F);
  RiDisplay("PinDeck.tif",
            RI_FILE,RI_RGB,
            RI_NULL);
  RiLightSource("ambientlight",RI_NULL);
  RiLightSource("distantlight",RI_NULL);
  RtFloat fov = 70.0F ;
  RiProjection("perspective",
               RI_FOV,(RtPointer) &fov,
               RI_NULL);
  RiTranslate(0.0F,0.0F,4.0F);
  RiWorldBegin();
  RtFloat ka = 0.1F ;
  RtFloat kd = 0.7F ;
  RtFloat ks = 0.2F ;
  RiSurface("plastic",
            "Ka",&ka,
            "Kd",&kd,
            "Ks",&ks,
            RI_NULL);
  RtFloat min = 1.3F ;
  RiAtmosphere("fog",
               "distance",&min,
               "background",bkcolor,
               RI_NULL) ;
  RiColor(color);
  Go();
  RiWorldEnd();
  RiEnd();
}

Sans brouillard

Avec brouillard

• réutilisation de code,

• extensibilité,

• indépendance entre les aspects modélisation et rendu.

Les shaders permettent le contrôle des lumières, de l'aspect des objets et des caractéristiques de l'intérieur des objets.

A l'utilisation, un shader se présente comme une fonction Renderman classique possédant un nom et une liste de paramètres.

La liste des paramètres commence par le nom du shader qui référence le fichier dans lequel sa description est contenue.

Ce nom est suivi d'une parameterlist permettant de transmettre les véritables paramètres.

Ecriture d'un shader (Renderman Shading Language)

Renderman propose un certain nombre de shaders prédéfinis.

Il est possible d'en écrire d'autres soi-même.

-> Utilisation du Renderman Shading Language pour la description du shader

-> Compilation pour obtenir un fichier utilisable par Renderman

Caractéristiques du langage R.S.L.

• R.S.L. est proche de C.

• Un shader ne peut adopter que certains types : light, surface,...

• Les paramètres d'un shader peuvent être initialisés.

• On peut définir des variables locales de certains types classiques, mais aussi du type color et point.

• R.S.L. définit un certain nombre de variables globales. Ces variables sont remplies avant l'appel au shader.

• R.S.L. propose des fonctions spéciales prédéfinies.

• R.S.L. propose des opérateurs spéciaux sur certains types.

• R.S.L. ne retourne pas de valeur explicite, mais affecte une ou plusieurs variables globales.

Exemples

le shader ambientlight

/* ambientlight.sl - Standard ambient light
 *  source for RenderMan Interface.
 * (c) Copyright 1988, Pixar.
 *
 * The RenderMan (R) Interface Procedures
 * and RIB Protocol are:
 * Copyright 1988, 1989, Pixar.
 * All rights reserved.
 * RenderMan (R) is a registered
 * trademark of Pixar. */

light ambientlight(float intensity = 1;
	           color lightcolor = 1;) {
  Cl = intensity * lightcolor;
  L = 0;
}

light ambientlight(float intensity = 1;
                   color lightcolor = 1;)

Entête de shader de source lumineuse ambientlight

Deux paramètres :

• intensity de type flottant initialisé à 1

• lightcolor de type couleur initialisé à blanc

  Cl = intensity * lightcolor;
  L = 0 ;

Calcul du résultat et retour par la variable globale Cl

le shader pointlight

/* ambientlight.sl - Standard ambient light
 *  source for RenderMan Interface.
 * (c) Copyright 1988, Pixar.
 *
 * The RenderMan (R) Interface Procedures
 * and RIB Protocol are:
 * Copyright 1988, 1989, Pixar.
 * All rights reserved.
 * RenderMan (R) is a registered
 * trademark of Pixar. */

light pointlight (
    float intensity = 1;
    color lightcolor = 1;
    point from = point "shader" (0,0,0);) {
  illuminate(from)
  Cl = intensity*lightcolor/(L.L);
}

light pointlight (
    float intensity = 1;
    color lightcolor = 1;
    point from = point "shader" (0,0,0);) {

Entête de shader de source lumineuse pointlight

Trois paramètres :

• intensity de type flottant initialisé à 1

• lightcolor de type couleur initialisé à blanc

• from de type point initialisé à (0,0,0) dans le repère du shader (repère courant)

  illuminate(from)

Appel à la fonction illuminate

-> calcul l'illumination entre un point P et une source ponctuelle située en from

-> résultat dans la variable globale L (vecteur from-P))

  Cl = intensity*lightcolor/(L.L);

Calcul du résultat et retour par la variable globale Cl

Utilisation de la variable globale L

Types de shaders

Outre les trois types déjà mentionnés, R.S.L. permet la définition de trois autres types de shaders:

Types de données

R.S.L. permet la définition des types de données suivants:

Structuration

• if - then - else

if (expression  booléenne) expression else expression

• while

while (expression booléenne) expression

• for

for ( expression ; expression booléenne ; expression) expression

• break

break [n]: Interuption de n boucle(s) for ou while imbriquées

• continue

continue [n]: Redémarage de boucles imbriquées

• return

return expression

Repères

Les variables du types color et point peuvent être exprimées dans différents systèmes de coordonnées.

Dans un shader, les couleurs et les points subiront automatiquement un changement de repère ayant pour conséquence la consistance de ces données.

Une variable peut être initialisée en donnant sa valeur dans un repère -> cette valeur est automatiquement traduite dans le repère associé au shader.

Exemple

color c1 = color "hsv" (0.8,0.2,0.1) ;
color c2 = color "rgb" (0.3,0.6,0.2) ;
point p = point "shader" (3.4,5,8) ;

"hsv" -> hue, saturation, value
"rgb" -> red, green, blue
...

"shader" -> repère lié à l'objet sur
         lequel le shader est instancié
"current" -> repère courant
...

Variables globales

Les variables globales de R.S.L. sont très importantes.

Ce sont elles qui permettent de communiquer aux shaders les informations dont ils ont besoin pour leurs calculs.

Elles permettent aussi aux shaders de rendre leurs résultats.

Variables globales des shaders de surface

Variables globales : accès en fonction du type de shader

* Derrière solar(), illuminate() ou illuminance()

# Accessible seulement pour les AreaLightSource

Syntaxe proche du C en particulier pour les opérateurs logiques et arithmétiques qui peuvent s'appliquer sur tous les types de variables.

Renderman propose l'utilisation de fonctions mathématiques au sein des shaders.

Fonctions spéciales

• noise()

Calcule 1, 2 ou 3 valeurs aléatoires flotantes entre 0 et 1. Plusieurs variantes en fonction du nombre et du type des arguments.

• noise(float val);

• noise(float u,float v);

• noise(point pt);

• p = point noise(...);

• p = color noise(...);

• illuminance()

Illuminance() permet aux shaders de surface de connaître l'ensemble de la lumière touchant un point d'une surface.

illuminance(point pos[,point axe,float a]) statement

Illuminance teste toute les lumières pour déterminer celles touchant pos selon un angle inférieur à a vis à vis de l'axe axe et de la position pos. statement est éxécuté pour chacune de ces lumières. La valeur obtenue est rendue par l'intermédiaire de L.

• illuminate()

illuminate() prend le problème en sens inverse. Il permet d'évaluer la lumière provenant d'un point pos et touchant un autre point p. On tient compte pour cette évaluation du fait que p doit se trouver dans le cone d'apex pos, d'axe axe et d'angle a.

illuminate(point pos[,point axe,float a]) statement

• solar()

solar() est voisin de illuminate(), mais se restreint aux illuminations provenant de certaines directions, sans tenir compte de la position de leurs sources d'émission.

solar([point axe,float a]) statement

Une gallerie de Shaders

Outils

R.S.L. propose un certain nombre de fonctions prêtes à l'emploi:

• fonctions mathématiques

• fonctions de calcul d'illumination et de couleur

• fonction de mapage

• fonctions géométriques

Blue Moon Rendering Tools (BMRT)

Introduction

BMRT : Ensemble d'outils permettant la programmation et l'affichage d'images générées au moyen de Renderman

Freeware

Existe dans les environnements :

• Windows

• LINUX

• IBM RS/6000 (AIX)

• SGI (IRIX 5.2)

• SUN Sparc (Solaris)

• HP 800 et 700 (HP-UX)

• DEC Alpha

• NeXT STEP

• ...