POV-Ray est sensible à la casse, ce qui signifie que camera n'est pas la même chose que Camera. camera est un mot réservé du langage tandis que Camera ne l'est pas.

Il est possible (et heureusement) d'insérer des commentaires dans un code POV-Ray. Ils utilisent la syntaxe du C++ :

 /*
 ceci 
 est 
 un 
 commentaire
 sur
 plusieurs
 lignes
 */
 ceci n'est plus un commentaire
 // mais ceci est encore un commentaire

POV-Ray utilise un repère cartésien x,y,z indirect. Toutes les coordonnées sont à exprimer dans ce systeme. Par défault, la verticale de la caméra est suivant l'axe y, on a donc communément l'habitude de considérer le plan x,z comme horizontal.

POV-Ray n'est pas un langage typé, ce qui signifie que l'on déclare de la même manière un entier, un flottant, un vecteur ou encore un objet. Un vecteur doit être encadré de chevrons <>. Un objet doit être décrit entre accolades {}.

Toutes les insctructions du langage commencent par un #, ce qui n'est pas sans rappeler les directives préprocesseur du langage C. En effet, POV-Ray analyse d'abord une première fois le code source pour générer un code ne contenant plus aucune instruction, uniquement des descriptions d'objets, pour ensuite lancer le rendu de l'image.

Il est parfois possible de spécifier un scalaire quand POV-Ray attend un vecteur, il effectue alors la transformation suivante pour obtenir un vecteur.

Mais ceci n'est réellement utile que quand vous souhaitez alléger du code, car la compréhension du code s'en retrouve compliquée.

Un Hello World en raytracing consiste en une sphere posée sur un échiquier. Dans le code source il va nous falloir une sphère, un échiquier, une caméra, une source de lumière et un arrière-plan. C'est parti.

 camera{
     location <0,5,-8>
     look_at <0,2,0> 
 }
 
 light_source{
      <20,50,-50>, color rgb<1,1,1>
 }
 
 background{
      color rgb<1,1,1>
 }
 
 plane{
   y,0 
   pigment{
        checker color rgb <1,1,0>
                color rgb <0,1,1>
   }       
 }
 
 sphere{
   <0,2,0>,2
   pigment{
        color rgb <1,0,0>
   }     
 }

Le code source parle presque de lui-même. Il y a :

• Une caméra positionnée au point <0,5,-8> et qui regarde le point <0,2,0>.
• une source de lumière [light_source] positionnée au point <20,50,-50> de couleur <1,1,1> soit 100% de rouge, 100 % de vert et 100% de bleu, donc du blanc.
• un arrière-plan [background] coloré en blanc (<1,1,1>).
• un plan de normale y, situé a 0 unité de l'origine du repère (c'est donc le plan d'équation y=0). Ce plan est coloré selon un motif d'échiquier [checker] à deux couleurs : jaune (<1,1,0>) et cyan (<0,1,1>).
• une sphère centrée en <0,2,0>, de rayon 2 et colorée en rouge (<1,0,0>).

Essayez de calculer cette image dans differentes résolutions, vous ne verrez jamais d'effet de pixellisation, le contour de la sphere sera toujours arrondi et jamais en escalier.

Dans tout langage de programmation qui se respecte, il a des variables. En POV-Ray, les variables n'ont pas besoin d'être déclarées. La seule règle est de ne pas faire appel à une variable non initialisée dans des calculs. La syntaxe d'affectation d'une valeur à une variable est la suivante :

 #declare i=0;

POV-Ray n'est pas typé, rien ne vous empeche donc de faire

 #declare i=0;
 #declare i=i+1;
 #declare i="developpez.com";
 #declare i=<1,2,3>;

Pensez juste à ne pas mélanger des chaînes de caractères, des scalaires et des vecteurs dans des opérations non prévues pour ça.

Toutes les variables sont globales, sauf mention explicite (voir section sur les macros), elles seront donc connues dans tout le script y compris dans les fichiers annexe.