UNE TERRE QUI TOURNE (3D)

//1 suele classe

import java.applet.*;
import java.awt.*;
import java.lang.Math;
import java.awt.*;
import java.awt.image.*;

public class go extends Applet implements Runnable
{
 int ecranX[],ecranY[],Px[],triangleaire[],yMOINSy[],Px2[],
     xCoins[],yCoins[],x[],y[],rotation[][],bloc[],xMOINSx[],
     XmoinsX[],YmoinsY[],triangle[][],lesCouleurs[],
     i,ii,j,iii,k,largeurEcran,hauteurEcran,densitéeX = 20,
     densitéeY = 60,densitée,xx,yy,
     maxi,nbElements,nbSommets,milieux,milieuy,x2,debutx,debuty,finx,
     finy,point1x,point1y,point2x,point2y,point3x,point3y,
     signe,xmin,xmax,ymin,ymax,L,H,picsou,pixel,h,l,numero,
     X1,X2,X3,Y3,Y2,y1,y2,x3,y3,e,f,a,Y1,gg,lSUR2,hSUR2,m,n,
     maximum = 1000000000,xDplt,yDplt,sens = 1,
     b,c,d,hauteur,largeur,nbObjets,
     x11,y11,x12,y12,x21,y21,x22,y22,xGravite,yGravite,zGravite,
     densiteex,densiteey,iiii,ao,bo,co;
 double xBarycentre[],
        yBarycentre[],zBarycentre[],xNormale[],yNormale[],zNormale[],
        xSommet3D[],xSommet2D[],ySommet2D[],ySommet3D[],zSommet3D[],
        distance1,distance2,distance3,pas,x1,poids1,poids2,poids3,
        u1,u2,u3,v1,v2,v3,
        xVux,yVux,zVux,xVuy,yVuy,zVuy,xVuz,longueur,
        yVuz,zVuz,xCam,yCam,zCam,distance,largeurplanvu,hauteurplanvu,
        rapport1,rapport2,e00,e01,e02,e03,e10,e11,e12,e13,e20,e21,e22,
        e23,e30,e31,e32,e33,ix1,igrek1,zed1,ix2,igrek2,zed2,ix3,igrek3,zed3,
        xPoint1,xPoint2,xPoint3,yPoint1,yPoint2,yPoint3,zPoint1,zPoint2,zPoint3,
        xCentre,yCentre,zCentre,xNormal,yNormal,zNormal,poids11,
        poids21,poids31,dist,tre,
        toutPetit = 0.00001,ix,igrek,zed,un,deux,cosPhy,sinPhy,cosTheta,
        sinTheta,theta,phy;
 PixelGrabber grosPx;
 Graphics g3,g2;
 Image Imagecachee3,saphir,Imagecachée;
 boolean tournerTerre,visible;
 MediaTracker myTracker=new MediaTracker(this);
 Font F = new Font("TimesRoman",1,14);

 public void init()
 {
  largeurEcran = new Integer(getParameter("largeurEcran")).intValue();
  hauteurEcran = new Integer(getParameter("hauteurEcran")).intValue();
  setBackground(Color.black);// new Color(125,125,152));
  Imagecachée = createImage(largeurEcran,hauteurEcran);
  g2 = Imagecachée.getGraphics();
  saphir = getImage(getDocumentBase(),"terre.gif");
  myTracker.addImage(saphir,0);
  try
   {
     myTracker.waitForID(0);
   }
  catch (InterruptedException e){System.err.println ("Erreur : " + e);}

  nbSommets = densitée = (densitéeX+1)*(densitéeY+1);
  xSommet3D = new double[densitée];
  ySommet3D = new double[densitée];
  zSommet3D = new double[densitée];
  xSommet2D = new double[densitée];
  ySommet2D = new double[densitée];
  ecranX = new int[densitée];
  ecranY = new int[densitée];
  k = 0;
  for(int j=0;j<=densitéeY;j++)
  {
   deux = (double)j/densitéeY;
   phy = 2*Math.PI*deux;
   cosPhy = Math.cos(phy);
   sinPhy = Math.sin(phy);
   for(int i=0;i<=densitéeX;i++)
   {
    un = (double)i/densitéeX;
    xSommet2D[k] = deux;
    ySommet2D[k] = un;
    theta = Math.PI*un;
    sinTheta = Math.sin(theta);
    xSommet3D[k] = cosPhy*sinTheta;
    ySommet3D[k] = Math.cos(theta);
    zSommet3D[k] = sinTheta*sinPhy;
    k++;
   }
  }
  k = 0;
  nbElements = densitéeX*densitéeY;
  triangle = new int[nbElements][4];
  for(int j=0;j<densitéeY;j++)
   for(int i=0;i<densitéeX;i++)
   {
   triangle[k] = new int[]{(densitéeX+1)*(j)+i,
                           (densitéeX+1)*(j)+i+1,
                           (densitéeX+1)*(1+j)+i+1,
                           (densitéeX+1)*(1+j)+i};
   k++;
  }
  for(int i=0;i<densitée;i++)
  {
   xSommet3D[i] *= 10;
   ySommet3D[i] *= 10;
   zSommet3D[i] *= 10;
  }
  lesCouleurs = new int[saphir.getHeight(this)*saphir.getWidth(this)];
  grosPx = new PixelGrabber(saphir,0,0,saphir.getWidth(this),saphir.getHeight(this),lesCouleurs,0,saphir.getWidth(this));
  try
  {
   grosPx.grabPixels();
  }
  catch(InterruptedException ee){}
  largeur = saphir.getWidth(this);
  hauteur = saphir.getHeight(this);
  xBarycentre = new double[nbElements];
  yBarycentre = new double[nbElements];
  zBarycentre = new double[nbElements];
  xNormale = new double[nbElements];
  yNormale = new double[nbElements];
  zNormale = new double[nbElements];
  for(int i=0;i<nbElements;i++)
  {
   xBarycentre[i] = (xSommet3D[triangle[i][0]]+xSommet3D[triangle[i][1]]+xSommet3D[triangle[i][2]]+xSommet3D[triangle[i][3]])/4;
   yBarycentre[i] = (ySommet3D[triangle[i][0]]+ySommet3D[triangle[i][1]]+ySommet3D[triangle[i][2]]+ySommet3D[triangle[i][3]])/4;
   zBarycentre[i] = (zSommet3D[triangle[i][0]]+zSommet3D[triangle[i][1]]+zSommet3D[triangle[i][2]]+zSommet3D[triangle[i][3]])/4;
   ix = xNormale[i] = (ySommet3D[triangle[i][2]]-ySommet3D[triangle[i][0]])*(zSommet3D[triangle[i][1]]-zSommet3D[triangle[i][3]])-
                      (zSommet3D[triangle[i][2]]-zSommet3D[triangle[i][0]])*(ySommet3D[triangle[i][1]]-ySommet3D[triangle[i][3]]);
   igrek = yNormale[i] = (zSommet3D[triangle[i][2]]-zSommet3D[triangle[i][0]])*(xSommet3D[triangle[i][1]]-xSommet3D[triangle[i][3]])-
                         (xSommet3D[triangle[i][2]]-xSommet3D[triangle[i][0]])*(zSommet3D[triangle[i][1]]-zSommet3D[triangle[i][3]]);
   zed = zNormale[i] = (xSommet3D[triangle[i][2]]-xSommet3D[triangle[i][0]])*(ySommet3D[triangle[i][1]]-ySommet3D[triangle[i][3]])-
                       (ySommet3D[triangle[i][2]]-ySommet3D[triangle[i][0]])*(xSommet3D[triangle[i][1]]-xSommet3D[triangle[i][3]]);
   longueur = Math.sqrt(ix*ix+igrek*igrek+zed*zed);
   xNormale[i] /= longueur;
   yNormale[i] /= longueur;
   zNormale[i] /= longueur;
  }
  Imagecachee3 = createImage(largeurEcran,hauteurEcran);
  g3 = Imagecachee3.getGraphics();
  lSUR2 = largeurEcran/2;hSUR2 = hauteurEcran/2;
  xVux = 1;yVux = 0;zVux = 0;xVuy = 0;yVuy = 1;zVuy = 0;
  xVuz = 0;yVuz = 0;zVuz = 1;xCam = 0;yCam = 0;zCam = 70;
  dist = distance = Math.sqrt(xCam*xCam+yCam*yCam+zCam*zCam);
  largeurplanvu = distance;
  hauteurplanvu = distance*hauteurEcran/largeurEcran;
  rapport1 = (double)largeurEcran/largeurplanvu;
  rapport2 = (double)hauteurEcran/hauteurplanvu;
  distance = 100000;
  x = new int[3];
  y = new int[3];
  xCoins = new int[4];
  yCoins = new int[4];
  xCoins[0] = 0;
  xCoins[1] = largeurEcran;
  xCoins[2] = largeurEcran;
  xCoins[3] = 0;
  yCoins[0] = 0;
  yCoins[1] = 0;
  yCoins[2] = hauteurEcran;
  yCoins[3] = hauteurEcran;
  rotation = new int[][]{{0,1},{0,2},{1,2}};
  xMOINSx = new int[3];
  yMOINSy = new int[3];
  XmoinsX = new int[4];
  YmoinsY = new int[4];
  XmoinsX[0] = largeurEcran;
  XmoinsX[1] = 0;
  XmoinsX[2] = -largeurEcran;
  XmoinsX[3] = 0;
  YmoinsY[0] = 0;
  YmoinsY[1] = hauteurEcran;
  YmoinsY[2] = 0;
  YmoinsY[3] = -hauteurEcran;
  xDplt =5;
  yDplt = -9;
  Px = new int[largeurEcran*hauteurEcran];
  a=0;
 }

 public void run(){}

 public void tourner()
 {
  int secondes=24*60*60;
  boolean aaaa=false;
 }

 public void paint(Graphics g)
 {
  for(i=0;i<100;i--)
  {
  g2.clearRect(0,0,largeurEcran,hauteurEcran);
  dist += yDplt*0.05*sens;
  if(dist>0.001 && dist<200)
  {
   largeurplanvu = dist;
   hauteurplanvu = (dist*hauteurEcran)/largeurEcran;
   rapport1 = largeurEcran/largeurplanvu;
   rapport2 = hauteurEcran/hauteurplanvu;
  }
  else
   sens *= -1;
  ix1 = xDplt*0.005;xVux = xVux+xVuz*ix1;yVux = yVux+yVuz*ix1;
  zVux = zVux+zVuz*ix1;ix1 = Math.sqrt(xVux*xVux+yVux*yVux+zVux*zVux);
  xVux /= ix1;yVux /= ix1;zVux /= ix1;xVuz = yVux*zVuy-zVux*yVuy;
  yVuz = xVuy*zVux-zVuy*xVux;zVuz = xVux*yVuy-yVux*xVuy;
  xCam = xVuz*distance;yCam = yVuz*distance;zCam = zVuz*distance;
  ix1 = -(xCam*xCam+yCam*yCam+zCam*zCam);
  e00 = xCam*xCam+ix1;e01 = xCam*yCam;e02 = xCam*zCam;e10 = yCam*xCam;
  e11 = yCam*yCam+ix1;e12 = yCam*zCam;e20 = zCam*xCam;e21 = zCam*yCam;
  e22 = zCam*zCam+ix1;e33 = ix1;
  xmin = maximum;
  ymin = maximum;
  xmax = -maximum;
  ymax = -maximum;
  visible = true;
  for(ii=0;ii<nbSommets;ii++)
  {
   ix2 = xSommet3D[ii];igrek2 = ySommet3D[ii];zed2 = zSommet3D[ii];
   ix3 = xCam*ix2+yCam*igrek2+zCam*zed2+e33;
   ix1 = (e00*ix2+e01*igrek2+e02*zed2)/ix3;
   igrek1 = (e10*ix2+e11*igrek2+e12*zed2)/ix3;
   zed1 = (e20*ix2+e21*igrek2+e22*zed2)/ix3;
   a = ecranX[ii] = lSUR2+(int)((ix1*xVux+igrek1*yVux+zed1*zVux)*rapport1+0.5);
   b = ecranY[ii] = hSUR2-(int)((ix1*xVuy+igrek1*yVuy+zed1*zVuy)*rapport2+0.5);
   if(a<0 && b<0)
    visible = false;
   xmin = Math.min(a,xmin);
   ymin = Math.min(b,ymin);
   xmax = Math.max(a,xmax);
   ymax = Math.max(b,ymax);
  }
  xmin =  Math.max(0,xmin);
  ymin =  Math.max(0,ymin);
  L = Math.min(largeurEcran-xmin,xmax-xmin);
  H = Math.min(hauteurEcran-ymin,ymax-ymin);
  if(visible)
  for(iii=0;iii<L*H;iii++)
    Px[iii] = 0;
  for(numero = 0;numero<nbElements;numero++)
  {
   triangleaire = triangle[numero];
   a = triangleaire[0];
   b = triangleaire[1];
   c = triangleaire[2];
   d = triangleaire[3];
   yPoint1 = ySommet3D[a];
   zPoint1 = zSommet3D[a];
   xPoint2 = xSommet3D[b];
   yPoint2 = ySommet3D[b];
   zPoint2 = zSommet3D[b];
   xPoint3 = xSommet3D[c];
   yPoint3 = ySommet3D[c];
   zPoint3 = zSommet3D[c];
   xCentre = xBarycentre[numero];
   yCentre = yBarycentre[numero];
   zCentre = zBarycentre[numero];
   xNormal = xNormale[numero];
   yNormal = yNormale[numero];
   zNormal = zNormale[numero];
   x[0] = X1 = ecranX[a];
   y[0] = Y1 = ecranY[a];
   x[1] = X2 = ecranX[b];
   y[1] = Y2 = ecranY[b];
   x[2] = X3 = ecranX[c];
   y[2] = Y3 = ecranY[c];
   xMOINSx[0] = X1-X2;
   yMOINSy[0] = Y1-Y2;
   xMOINSx[1] = X1-X3;
   yMOINSy[1] = Y1-Y3;
   xMOINSx[2] = X2-X3;
   yMOINSy[2] = Y2-Y3;
   ix1 = xCam-xCentre;
   igrek1 = yCam-yCentre;
   zed1 = zCam-zCentre;
   if((1-(xNormal*ix1+yNormal*igrek1+zNormal*zed1)/
    Math.sqrt(ix1*ix1+igrek1*igrek1+zed1*zed1)/
    Math.sqrt(xNormal*xNormal+yNormal*yNormal+zNormal*zNormal))/2>0.5)
   {
    for(int tt=0;tt<2;tt++)
    {
     visible = X1 >= 0 && X1 <= largeurEcran &&
               Y1 >= 0 && Y1 <= hauteurEcran ||
               X2 >= 0 && X2 <= largeurEcran &&
               Y2 >= 0 && Y2 <= hauteurEcran ||
               X3 >= 0 && X3 <= largeurEcran &&
               Y3 >= 0 && Y3 <= hauteurEcran;
     if(!visible)
     {
      for(ii=0;ii<4;ii++)
       for(iii=0;iii<3;iii++)
       {
        bloc = rotation[iii];
        point1x = bloc[0];
        point1y = bloc[1];
        point2x = xCoins[ii];
        point2y = yCoins[ii];
        e = xCoins[(ii+1)%4];
        f = yCoins[(ii+1)%4];
        x11 = x[point1x]-point2x;
        y11 = y[point1x]-point2y;
        x12 = x[point1x]-e;
        y12 = y[point1x]-f;
        x21 = x[point1y]-point2x;
        y21 = y[point1y]-point2y;
        x22 = x[point1y]-e;
        y22 = y[point1y]-f;
        e = xMOINSx[iii];
        f = yMOINSy[iii];
        gg = x11*f-y11*e;
        h = x12*f-y12*e;
        gg = (gg>=0)?1:-1;
        h = (h>0)?1:-1;
        if(h == -gg)
        {
         e = XmoinsX[ii];
         f = YmoinsY[ii];
         gg = x11*f-y11*e;
         h = x21*f-y21*e;
         gg = (gg>=0)?1:-1;
         h = (h>0)?1:-1;
         if(h == -gg)
         {
          visible = true;
          iii = ii = 4;
         }
        }
      }
     }
     if(visible)
     {
  if(Y1<Y2)
  {
   if(Y1<Y3)
   {
    if(Y2<Y3)
    {
     ao = a;bo = b;co = c;
    }
    else
    {
     ao = a;bo = c;co = b;
    }
   }
   else
   {
    ao = c;bo = a;co = b;
   }
  }
  else
  {
   if(Y2<Y3)
   {
    if(Y1<Y3)
    {
     ao = b;bo = a;co = c;
    }
    else
    {
     ao = b;bo = c;co = a;
    }
   }
   else
   {
    ao = c;bo = b;co = a;
   }
  }
  debutx = ecranX[ao]-xmin;
  debuty = ecranY[ao]-ymin;
  milieux = ecranX[bo]-xmin;
  milieuy = ecranY[bo]-ymin;
  finx = ecranX[co]-xmin;
  finy = ecranY[co]-ymin;
  u2 = xSommet2D[bo];
  v2 = ySommet2D[bo];
  u1 = xSommet2D[ao]-u2;
  v1 = ySommet2D[ao]-v2;
  u3 = xSommet2D[co]-u2;
  v3 = ySommet2D[co]-v2;
  maxi = hauteur*largeur-1;
  point2y = finy-debuty;
  if(point2y != 0)
  {
   point2x = finx-debutx;
   pas = (double)point2x/point2y;
   point3y = milieuy-debuty;
   point3x = milieux-debutx;
   signe = point3y*point2x-point3x*point2y;
   tre = Math.abs((double)signe);
   if(signe != 0)
   {
    signe = signe>0?1:-1;
    x1 = debutx;
    point1y = finy-milieuy;
    point1x = finx-milieux;
    distance1 = milieuy*point1x-milieux*point1y;
    distance3 = debuty*point3x-debutx*point3y;
    for(int y1=debuty;y1<finy;y1++)
    {
     if(y1>=0 && y1<H)
     {
      x2 = (int)x1;
      do
      {
       poids1 = x2*point1y-y1*point1x+distance1;
       poids3 = x2*point3y-y1*point3x+distance3;
       if(x2>=0 && x2<L)
       {
        poids11 = Math.abs(poids1/tre);
        poids31 = Math.abs(poids3/tre);
        pixel = lesCouleurs[(int)((poids11*u1+u2+poids31*u3+0.5)*largeur)+(int)((poids11*v1+v2+poids31*v3)*hauteur+0.5)*largeur];
        Px[x2+L*y1] = (0xff000000 | ((0xff & pixel>>16 )<< 16 | (0xff & pixel>>8) << 8 | 0xff & pixel));
       }
       x2 -= signe;
      }
      while(y1<milieuy && signe*poids3>=0 ||
            y1>=milieuy && signe*poids1>=0);
     }
     x1 += pas;
    }
   }
  }
  }

     x[1] = X2 = ecranX[d];
     y[1] = Y2 = ecranY[d];
     xPoint2 = xSommet3D[d];
     yPoint2 = ySommet3D[d];
     zPoint2 = zSommet3D[d];
     xMOINSx[0] = X1-X2;
     yMOINSy[0] = Y1-Y2;
     xMOINSx[2] = X2-X3;
     yMOINSy[2] = Y2-Y3;
     b = d;
    }
   }
  }
  g2.drawImage(createImage(new MemoryImageSource(L,H,Px,0,L)),xmin,ymin,L,H,this);
  g.drawImage(Imagecachée,0,0,this);
 }
}

}

Télécharger le zip

• EBAUCHE DE MOTEUR 3D
• UN LOGICIEL DE DESSIN 3D
• LE RUBIX CUBE EN 3D AVEC OU SANS IMAGES

• APPLICATION MEMO EN J2ME POUR PALM TREO 500
• SIMULATION D'UNE CHAINE DE PRODUCTION
• GESTION DES PERSONNELS
• PETIT PROGRAMME DE COPIE RAPIDE DE FICHIER
• PANNEAU À AFFICHAGE NUMÉRIQUE LCD

• TÉLÉCHARGEMENT D'IMAGES (POCHETTES CD, DVD, LIVRES...) SUR INTERNET
• PASSAGE D'UNE IMAGE PAR SERIALIZATION (LA CLASS IMAGE N'EST PAS SERIALIZABLE)
• UN LOGICIEL DE DESSIN 3D
• MEMORYIMAGESOURCE & DOUBLE BUFFER
• FAIRE DEFILER UNE IMAGE