Search  

---

C:/temp/src/j2k/Beta/3D/Object3d.cpp

Go to the documentation of this file.

// Classes des objets 3D et derivées.

#include "objet3d.hpp"
#include <math.h>

///////////////////////////////////////////////////////////////////////////////
// La classe des fenêtres de projection.
// La classe des boites limites.
// La classe des sphères limites.
// La classe de base des objets 3D.
// La classe des capteurs visuels.
///////////////////////////////////////////////////////////////////////////////

void CapteurVisuel3D::CalculPerspective ()
   {
   // on prend pour le calcul, le vecteur inverse.
   Vector3DH direction( _direction.b, _direction.a );

   // Calcul de la distance D du point de visée à l'observateur.
   realtype D = _direction.norme();

   // theta: angle entre le vecteur direction et sa projection sur le plan XOY.
   // Calcul des sin et cos.
   realtype costheta = 0.0f,
         sintheta = 0.0f;

   direction.cos_sinangle_ver(costheta, sintheta);

   // phi : angle entre la projection du vecteur direction sur le plans XOY et
   // l'axe des abscisses.
   // Calcul des sin et cos.
   // Nb - le cas particulier où la visée est verticale rend la projection sur
   //      le plans XOY égale à un point. Dans ce cas, il n'y à pas de calcul
   //      d'angle possible. On suppose donc phi=0;

   realtype cosphi= 0.0f,
         sinphi= 0.0f;

   direction.cos_sinangle_hor(cosphi, sinphi);

   // on intialise la matrice perspective
   _perspective.setIdentity();

   // On initialise la matrice de changement de repère.
   Matrice44 mat;
   mat.setIdentity();

   // Etape 1. On effectue la première translation de changement de repère.
   mat.setTranslateX(-direction.compox());
   mat.setTranslateY(-direction.compoy());
   mat.setTranslateZ(-direction.compoz());

   _perspective.multiplyByMatrix(mat);

   // Etape 2. Rotation négative autour de l'axe Z0 de PI/2-phi.
   // nous avons cos PI/2-phi = sin phi
   //            sin PI/2-phi = -cos phi
   // or nous effectuons un changement de repère ce qui implique la matrice
   // inverse d'ou phi devient -phi
   // nous avons cos -phi = cos phi
   //            sin -phi = -sin phi
   //     |sinphi  cosphi 0 0|
   //     |-cosphi sinphi 0 0|
   // B = |  0       0    1 0|
   //     |  0       0    0 1|
   //
   mat.setIdentity();
   mat.setRotateZ(sinphi,
                    cosphi);
   _perspective.multiplyByMatrix(mat);

   // Etape 3. Rotation positive autour de l'axe X1 de PI/2+theta
   // nous avons cos PI/2+theta = -sin theta
   //            sin PI/2+theta = cos theta
   // or nous effectuons un changement de repère ce qui implique la matrice
   // inverse d'ou phi devient -theta
   // nous avons cos -theta = cos theta
   //            sin -theta = -sin theta
   //     |  1       0         0       0|
   //     |  0  -sintheta  -costheta   0|
   // B = |  0   costheta  -sintheta   0|
   //     |  0       0         0       1|
   //
   mat.setIdentity();
   mat.setRotateX(-sintheta,
                    -costheta );
   _perspective.multiplyByMatrix(mat);

   // Etape 4. Changement de sens d'axe X. repère direct.
   mat.setIdentity();
   mat.xx = -1.0f;

   _perspective.multiplyByMatrix(mat);

   // Etape 5. Rotation du spin.
   realtype spin    = ((realtype)(M_PI) / 180.0f)* _spin,
            cosspin = (realtype)cos( spin ),
            sinspin = (realtype)sin( spin );

   mat.setIdentity();
   mat.setRotateZ(cosspin, -sinspin);

   _perspective.multiplyByMatrix(mat);

   // Etape 6. Normalisation et projection perspective à un point de fuite.
   mat.setIdentity();
   realtype ouverture     = (realtype)(M_PI / 180.0f)* _ouverture,
            halfsizeprojy = (realtype)tan(ouverture)* D,
            halfsizeprojx = halfsizeprojy*( _fenetre._halfsize.x/
                                                _fenetre._halfsize.y);

   // 6a - Normalisation xy
   mat.xx = 1.0f/halfsizeprojx;
   mat.yy = 1.0f/halfsizeprojy;

   // 6b - perspective Z.
   mat.zw = 1.0f / D;

   _perspective.multiplyByMatrix(mat);
   }

void CapteurVisuel3D::VisualisationFilaireObjet( HDC dc, RObjet3D obj )
   {
   int        cardsommet = obj.data.cardsommets;
   PPixel     pixels     = new Pixel[ cardsommet ];
   Sommet3DH  transform;

   // transformation des sommets.
   for ( int i = 0; i < cardsommet; i ++ )
     {
     Sommet3DH& sommet = obj.data.sommets[i];
     transform.x = sommet.x;
     transform.y = sommet.y;
     transform.z = sommet.z;
     transform.w = sommet.w;

     transform.multiplyByMatrix(_perspective);

     // on initialise les coordonées écran.
     pixels[i].x = (int)((transform.x/transform.w)*
                                _fenetre._halfsize.x );
     pixels[i].y = (int)((transform.y/transform.w)*
                                _fenetre._halfsize.y );
     }

   int    cardarc = obj.data.cardarcs;

   // affichage des arcs.
   for ( int i = 0; i < cardarc; i ++ )
     {
     RArcD arc = obj.data.arcs[i];
     Pixel& pixelini = pixels[arc.sini-1],//la numérotation commence à 1
            pixelfin = pixels[arc.sfin-1];//la table à 0. D'où - 1.

     MoveToEx(dc, pixelini.x, pixelini.y, NULL);
     LineTo(dc, pixelfin.x, pixelfin.y);
     }

   if ( pixels ) delete [] pixels;
   }

void CapteurVisuel3D::VisualisationFilaireScene( HDC dc)
 {
 if (!_dans ) return;
 _dans->VisualisationFilaire( dc, (RCapteurVisuel3D)*this );
 }

///////////////////////////////////////////////////////////////////////////////
// La classe des scènes 3D.
///////////////////////////////////////////////////////////////////////////////
void Scene3D::VisualisationFilaire( HDC hdc, RCapteurVisuel3D obs )
 {
 if (!_obj ) return;

 obs.VisualisationFilaireObjet( hdc, (RObjet3D)(*_obj) );
 }

---