Accueil

CPC


 Dev C sur CPC :

  • le C sur CPC
  • SDCC débuter
  • fichier BAT pour compiler
  • Dessiner Sur CPC
  • Optimiser le dessin
  • Ecrire du texte
  • Lire un fichier
  • Ecrire un fichier
  • Swap d'écran
  • CLS ultra rapide
  • H line
  • Attaquer le CRTC
  • Full Overscan
  • Put pixel très rapide
  • Afficher une image
  • Slide show 1
  • Bézier
  • faire un fichier pour Bézier

  • Quelque fonctions utile

  • Animation
  • 3D
  • Raster
  • Manche a balais

    Le plan du Site

  •  
      Ici les nouvelle du site  
     
    Recherche ?
    Saissisez un mot clé

     
      Quelques chiffres
    Visiteurs:4062
    Visiteurs aujourd'hui:17
     
     
    Me contacter
    Donnez votre avis
     
    Le site de Steph : Le CPC

    3D temps IREEL

    Face plaine


    On vas passé de la représentation en fil de fer à la représentation en face.
    Bon, c'est quoi une face en 3D, une face c'est en fait un triangle, pour notre cube, chaque faces seras composées de 2 triangles.
    Il nous faut donc savoir dessiner un triangle, c'est ce que l'on vas voire maintenant.
    Voici la fonction que j'ai prise, il y a surement mieux, on verras cela plus tard !

    #define SWAP(a,b)  { SwapTmp=a; \
                         a=b;   \
                         b=SwapTmp; }	
    unsigned int SwapTmp;
    
    #define Sign(v) (v > 0 ? 1 : (v < 0 ? -1 : 0))
    #define Abs(j) ((j < 0) ? -j : j) 
    
    void FillTriangle(unsigned int x1, unsigned char y1, unsigned int x2, unsigned char y2, unsigned int x3, unsigned char y3, unsigned char nColor)
    {
    	int dx1;
    	int dy1;
    	int err1;
    	int dx2;
    	int dy2;
    	int err2;
    	int xl;
    	int xr;
    
    	int y;
    
    	int sgn1;
    	int sgn2;
    
    	if(y1>y2)
    	{
    		SWAP(x1,x2);
    		SWAP(y1,y2);
    	}
    
    	if(y1>y3)
    	{
    		SWAP(x1,x3);
    		SWAP(y1,y3);
    	}
    
    	if(y2>y3)
    	{
    		SWAP(x2,x3);
    		SWAP(y2,y3);
    	}
    
    	dx1 = x3 - x1;
    	dy1 = y3 - y1;
    	err1 = 0;
    	dx2 = x2 - x1;
    	dy2 = y2 - y1;
    	err2 = 0;
    	xl = x1;
    	xr = x1;
    
    	y;
    
    	sgn1 = Sign(dx1);
    	sgn2 = Sign(dx2);
    
    	dx1 = Abs(dx1);
    	dx2 = Abs(dx2);
    
    	if (y1 == y2)
    	xr = x2;
    
    	for ( y = y1; y < y3; y++)
    	{
    		HLineFast(xl, xr, y, nColor);
    		err1 += dx1;
    		while (err1 > dy1)
    		{
    			xl += sgn1;
    			err1 -= dy1;
    		}
    		if (y == y2)
    		{ // On passe au tracé du second "demi-triangle"
    			dx2 = x3 - x2;
    			dy2 = y3 - y2;
    			sgn2 = Sign(dx2);
    			dx2 = Abs(dx2);
    			err2 = 0;
    		}
    		err2 += dx2;
    		while (err2 > dy2)
    		{
    			xr += sgn2;
    			err2 -= dy2;
    		}
    	}
    }
    

    On ne détaille pas trop, à vous de chercher un peut ;-)
    Il nous faut aussi modifier la structure d'un objet, oui pour lui rajouter les faces.
    On vas donc créer une structure pour les faces, et ajouter un tableau pour les faces dans la structure obj3D.
    Voici la nouvelle structure pour l'objet.

    typedef struct
    {
      unsigned char p1;
      unsigned char p2;
      unsigned char p3;
      
      unsigned char color;
    } face;
    
    typedef struct
    {
    	unsigned char nbPoints;	// un objet ne peut donc avoir que 255 points !
    	unsigned char nbFaces;	// un objet ne peut donc avoir que 255 faces !
    	
    	point3D Sommet[8];		// les sommets origineux
    	point3D Point3D[8];		// les sommets apres cacule
    	point2D Point2D[8];		// les sommets apres projection (dessin 2d)
    	
    	face Face[12];			// faces
    
    }obj3D;
    

    Il faut aussi dans la fonction Initialiser ajouter le remplissage du tableau de faces. (c'est mieux :-) ).
    On vas aussi ajouter un fonction pour dessineer les faces, un peut comme celle pour dessiner en fil de fer :

    void FacePlein1( unsigned char couleur, obj3D* obj )
    {
     unsigned char i;
    
      //for(i=0; i < obj->nbFaces; i++)
      for(i=0; i < 12; i++)
      {
    	FillTriangle(obj->Point2D[obj->Face[i].p1].x, obj->Point2D[obj->Face[i].p1].y, 
    				obj->Point2D[obj->Face[i].p2].x, obj->Point2D[obj->Face[i].p2].y, 
    				obj->Point2D[obj->Face[i].p3].x, obj->Point2D[obj->Face[i].p3].y, obj->Face[i].color );
      }
    }
    

    La fonction appel directement le fonction triangle en lui passant les 3 coordonées (point) de la face.
    N'oubliont pas d'appeler cette fonction à la place de FilDeFer !
    On compile et cela donne ca :


    L'animation est fidèle en temps vis à vis d'un CPC


    BEEEeeuuuuurrrrrRRRRKKKKKK ........ voila la 1er impression !
    Et oui, en fait la on dessine no face comme elle viennent, donc par moment on à l'impression que l'on a des troux, bas non, c'est juste que l'on affiche pas les face dans le bonne ordre.
    On vas donc ajouter a notre programme un tris des faces, et en plus on ne vas pas afficher les face qui se trouve caché !