• La classe Voxel
• La classe Camera
• La classe ReadableImage

La classe Voxel
 

C'est la grosse classe du projet. Elle hérite de la classe Applet, elle est Runnable et c'est elle qui contient toutes les méthodes de calcul et d'affichage. La description qui suit est celle de la version de base de la classe Voxel (Voxel.java). Les version optimisés (Voxel2.java et Voxel3.java) ont une structure similaire, à certains effets additionnels près (l'effet Lens Flare, le brouillard et les reflets de vagues). Si les algorithmes de calcul diffèrent, le rôle de chaque classe est le même.

Ses variables de classes sont les suivantes :

•    pour le double buffering :
•    MemoryImageSource backBuffer : le buffer d'image associé au tableau backBufferData qui permet l'affichage de l'image à l'écran
•    int backBufferData[] : le tableau d'entiers où seront écrites et stockées les couleurs de tous les pixels du buffer
•    les images utilisées :
• ReadableImage heightMap : notre carte des altitudes (à partir d'une image en niveaux de gris
• ReadableImage texture : la texture appliquéesur notre paysage (à partir d'une image en couleur, elle "colle" parfaitement à la heightmap)
•   ReadableImage ombresNuages : l'ombre des nuages appliquée (à partir d'une image en niveau de gris)
•   private ReadableImage nuages : la texture des nuages (à partir d'une image en couleur)

•    pour les nuages
•     int altitudeNuages
•     double zoomNuages : coefficient de zoom appliqué opur l'affichage des nuages
•  
•     pour la mer
•     int niveauMer;
•     double vaguesX[], vaguesZ[] : deux tableaux de décimaux où seront calculés les variation des vagues à partir de fonctions trigonométriques
•     double houle : coefficient d'amplitude de variation pour les vagues
•     parametres du rayon (principalement pour les test)
•     boolean ombreNuages : faut-il afficher l'ombre des nuages ?
•     private boolean ciel : faut-il afficher un ciel ?
•     private boolean fog : faut-il calculer l'effet de brouillard ?
•     private boolean reflexionEau : faut-il afficher l'eau ?
•     private boolean flares : faut-il afficher les lens flare ?
•     pour le Lens Flare
•     ReadableImage shine1, flare1, flare5 : la forme des halos à "décalquer" sur notre paysage (à partir d'images en niveau de gris)
•     double soleilRy, soleilRxz : décrit l'orentation du soleil
•     puis en vrac :
•     boolean readyToRun : l'applet n'est pas "runnée" avant l'initialisation
•     int dimX, dimY : les dimension de notre fenêtre en nombre de pixels (on l'initialisera à (320,320))
•     Camera camera : notre objet caméra
•     int temps : variable de temps qu'on incrémentera à chaque rafraichissement pour faire bouger les vagues et l'ombre des nuages

 
 
Puis on a les méthodes suivantes :
•     void init(int X, int Y) : initialise toutes les variables de classes (les paramètres X et Y sont les valeurs d'initialisation de dimX et dimY)

•     double hypot(double X, double Y) et int modulo(int n, int m) : deux méthodes de calculs mathématiques simples

•     boolean estDansLeChampDeVision : retourne true si le soleil est dans le champ de vision de la caméra (pour les lens flare)

•     void paint(graphics g) : lance la méthode de calcul de l'image, puis affiche l'image (alors dans le buffer) à l'écran. Pendant l'initialisation la méthode affiche un message d'attente. Le paramètre g est destiné à désigner le Graphics de notre applet (this.getGraphics()).

•     void paintFlare(int x, int y, int seuil, int lum, double coefJaune, ReadableImage flare) : calcule la couleur des pixels d'un halo lumineux de l'effet de lentille à partir de la méthode de calque décrite dans le dossier de réalisation. Les paramètre sont :
• x et y les coordonnées du halo lumineux
• le seuil de blancheur à partir duquel on applique le calque (voir shéma)
• lum, l'intensité lumineuse du halo (coefficient de blanchissement)
• coefJaune : un coefficient donnant une teinte jaune au halo
• flare : la calque à appliquer

•     les méthodes de gestion de l'applet :
• void start() : on y lance l'initialisation
• void update() : on y lance l'affichage (la méthode paint())
• void stop()
•     public void lancerRayon(  int screenX, int screenY,
        double angleFOVy,
        double Xdepart, double Ydepart, double Zdepart,
        double RXdepart, double RYdepart, int step,
        int offsetNuages ) :
C'est la principale méthode méthode de calcul. Elle calcule tous les pixels d'une abscisse donnée. Les paramètres sont :
• screenX et screenY : les coordonnées écran du point à partir duquel le rayon est lancé. On lancera la méthode en faisant défiler screenX sur toute la largeur de la fenêtre. screenY désignera toujours le point le plus bas de la fenêtre à l'appel de la méthode (l'ordonnée augmentera à l'intérier de la méthode alors que l'abscisse est constante à l'intérieurde la méthode)
• angleFOVy : l'angle de champ vertical de la caméra pour savoir où arrêter le rayon en hauteur
• RXdepart, RYdepart et RZdepart : l'orientation du rayon au départ. RX et Rz resteront constants dans la méthode, alors que RY augmentera au fur et à mesure.
• step : définit l'incrément qu'on utilisera pour avancer sur le rayon.
• offsetNuage : définit l'ombre des nuages à appliquer
La méthode regroupe le calcul des points des montagnes (selon l'algorithme de RayTracing ou de RaySurfing selon les versions) et du ciel, le calcul du brouillard et de l'ombre des nuages (la description des algorithmes se trouve dans le dossier de réalisation). La couleur des pixels calculés est stockée dans le buffer.

Les reflets de l'eau et l'effet lens flare sont calculés par d'autres méthodes :
 

• public void lancerReflet(          int screenX, int screenY,
 int t,
 double Xdepart,double Ydepart,double Zdepart,
 double RXZdepart, double RYdepart, int step,
 int offsetNuages)
Cette méthode est lancée par la méthode lancerRayon quand un rayon arrive au niveau de la mer. Les paramètres sont les mêmes que pour lancerRayon. angleFOV n'est pas nécessaire puisque le reflet n'est lancé que pour un pixel (pas de balayage). Le paramètre t désigne la distance parcourue sur le rayon incident, qu'on récupére pour ne pas dépasser la portée de la caméra sur le rayon réfléchi.
 
• pubilc void calculateImage() : la méthode effectue les opérations suivantes :
• elle actualise la position de la caméra.
• elle incrémente la varible de temps.
• elle lance tous les rayons nécessaires pour couvrir toute la largeur de la fenêtre.
• elle lance l'affichage du soleil et des 4 halos lumineux du lens flare (dans Voxel.java uniquement).
calculateImage() est appelée par la méthode paint().

La classe Camera
 

Elle contient toute les informations et les méthodes nécessaires à la gestion de la caméra. Les "informations", ce sont les attributs regroupés en quatre groupe :

• les coordonnées de position (repère global cartésien) : posX, posY, posZ
• les coordonnées d'orientation (les angles du repère sphérique global) : rotY et rotXZ
• les coordonnées de vitesse (dans le repère sphérique local) :
• vTangente (vitesse longitudinale)
• vPerpY, vPerpXZ (vitesses angulaire)
• les distance définissant le champ de vision de la caméra :
• FOV (distance séparant la caméra de l'écran de projection)
• farDistance (distance maximale de vision de la caméra)
• fogDistance (distance à partir de laquelle on commence à percevoir l'effet du brouillard)
On trouve des shémas explicatifs dans le dossier de réalisation.

Les méthodes dela classe sont :

• public void init(X, Y, Z, vT, vPY, vPXZ, rY, rXZ, fov, farD, fogD) : initialise les attributs avec les valeurs passées en paramètre
• pubic void upDate() : déplace la caméra en fonction des paramètres de vitesse (les formules de déplacement sont dans le dossier de réalisation)
• les accesseur retournant la valeur de chacun des attributs

La classe ReadableImage
 

Elle hérite de la classe ImageIcon. On y ajoute simplement un attribut : un tableau d'entiers nommé buffer[].
Le but de cette classe est de pouvoir copier, stocker et lire les d'un fichier image .jpg ou .gif.

Les deux seules méthodes implémentés sont :

• public ReadableImage(string fileName) : un constructeur qui recopie les pixel d'un fichier nommé fileName dans le tableau buffer[}.
• public void getBuffer() : retourne le tableau buffer[].