Moteur 3D Software open source en PB

Gratteur · Message par **Gratteur** » mar. 08/mai/2007 14:29

Vite fait à partir des tutoriaux en C de Christophe Heulin.
J'ai modifié pas mal de choses pour travailler uniquement via des buffers (afin de simuler de l'objet).

Dans l'état actuel il faudrait dans un premier temps ajouter le Z-Buffer, le cliping 3D et modifier la perspective.

Voila le résultat : http://ns.gratteur.free.fr/Autre/Moteur3D.zip

Je peux donner les sources si ça interesse quelqu'un.
Bon je retourne à mes partielles à plus.

Anonyme · Message par **Anonyme** » mer. 09/mai/2007 9:53

Excelent ! j'aimerais voir tes sources ^^ j'aime bien décortiqué ces p'tites bêtes la ^^
à cause de typhoon, je recode de a à z mon moteur aussi ^^
j'en suis pas encore au même point que toi au niveau du rendu, mais ca va venir ^^. je ne sais pas encore si je vais mettre une couche ogl dessus ^^ ca me démange

Ton code c'est que issu du heulin ? en tout cas c'est sympa ^^
essaye de faire un cube avec des uv au lieu de la sphère.

File:1->Soft3D.exe

Coolman · Message par **Coolman** » mer. 09/mai/2007 12:57

Ce que je trouverais cool

, c'est un moteur 3D pure opengl fonctionnel pour win ,linux et macos, rien a barrer de directx et des monopoles

Ne me retorquez pas de le faire moi meme, les maths et moi, on a jamais ete vraiment d'accord

wolfjeremy · Message par **wolfjeremy** » mer. 09/mai/2007 14:57

Perso si je me lance la dedans je préfère attendre DX 10.

Mais je préfère laisser faire tmyke et sons DM3D lol (ça pourrait le faire en DX 10)

minirop · Message par **minirop** » mer. 09/mai/2007 15:32

Coolman a écrit :Ce que je trouverais cool , c'est un moteur 3D pure opengl fonctionnel pour win ,linux et macos, rien a barrer de directx et des monopoles

les moteurs sont soit DX soit DX + OGL alors suffit de prendre Ogre3D, TV3D,Irrlicht et tu choisis OGL en "rendering"

Anonyme · Message par **Anonyme** » mer. 09/mai/2007 15:54

Perso si je me lance la dedans je préfère attendre dx10

rien ne t'empêches de faire une couche software puis par la suite intégrer ogl ou dx

les moteurs sont soit DX soit DX + OGL alors suffit de prendre Ogre3D, TV3D,Irrlicht et tu choisis OGL en "rendering"

Y a un sacré boulot en amont pour en arrivé là

Ne me retorquez pas de le faire moi meme, les maths et moi, on a jamais ete vraiment d'accord

moi aussi , j'ai du mal avec les mattes

Coolman · Message par **Coolman** » mer. 09/mai/2007 16:50

*** les moteurs sont soit DX soit DX + OGL alors suffit de prendre Ogre3D, TV3D,Irrlicht et tu choisis OGL en "rendering"

Testés saufs TV3D, ogre est une usine a gaz, le port du wrapper purebasic pour irrlicht est incomplet...

*** moi aussi , j'ai du mal avec les mattes

Cpl.Bator, ce n'est pas mon impression, si je me rappelle bien, tu avais fait un moteur assez interessant mais abandonné assez rapidement, dommage...

Suis je le seul qui cherche un moteur basé sur opengl compact qui n'obligerait pas a distribuer 10 megas avec un petit jeux simple et sans pretention parce que ce serait mon objectif, je n'ai ni les ressources ni le temps de vouloir concurrencer les pros du dev de jeux, alors a quoi bon utiliser un moteur lourd avec directx 10 ou 1000 avec gestion shaders multiples textures 3D de la mort qui tue

, pour ca autant se tourner vers le c et acheter un moteur 3D commercial...

Anonyme · Message par **Anonyme** » mer. 09/mai/2007 17:34

Cpl.Bator, ce n'est pas mon impression, si je me rappelle bien, tu avais fait un moteur assez interessant mais abandonné assez rapidement, dommage...

j'ai mis presque 1 an avant d'en arriver là , c'est pas évident à mettre en place

tmyke · Message par **tmyke** » mer. 09/mai/2007 17:48

Je suis du meme avis que Cpl.Bator, beau travail. Si tu arrives a implenter les
quelques éléments que tu listes, cela sera très intéressant.
Toi et Cpl.Bator, pourquoi ne pas faire un moteur software OpenSource en
PB (donc multiplateforme) , avec après (comme le suggère Cpl.Bator) une surcouche OpenGL ?

PS:

wolfjeremy a écrit : Mais je préfère laisser faire tmyke et sons DM3D lol (ça pourrait le faire en DX 10)

DM3D + DX10 debut 2008 si tout va bien

Gratteur · Message par **Gratteur** » mer. 09/mai/2007 19:01

Je suis ravis que ça vous plaise, si vous voulez on peut essayer de développer un petit moteur sympas à partir de ce début de moteur et de ce que vous avez fait de votre coté.

Bon je vous donne les sources mais je vous préviens ce n’est ni commenté (à part 2 ou 3 procédures), ni harmonisé (des procédures similaires n’ont pas exactement les mêmes arguments), ni super optimisé (mais quand même un peu).

Voila le code source (il est relativement ralongé par des fonctions redondantes) :

Code : Tout sélectionner

Tout est dans l'archive du premier message

Pour l'instant je passe par un tableau pour la texture mais c'est temporaire. Certaines choses ne sont pas optimisées pour être plus simple à comprendre et parceque les structures ne sont définitives (notament des variables utilisées à la place de constantes).
Encore deux petites choses à ajouter : les facettes sont pour le moment triées par entité, il faudrait les trier à la fin pour avoir un affichage plus réaliste (et ne pas du tout les trier et implémenter le Z-buffer pour encore plus de réalisme), et les lumières semblent un brin foireuses.

Et voilà le code du chargeur de .asc (le format ascii de 3DSM) :

Code : Tout sélectionner

; Chargeur de fichiers .ASC - Par Gratteur - 2007

Procedure SommetsASC(fichier, nb_sommets, *sommets.SommetObjet, texture.b)
  Protected txt.s, pos
  For k=0 To nb_sommets-1
    txt = ReadString(fichier)
    If Left(txt, 6) = "Vertex"
      pos = FindString(txt, "X", 12)+3
      *sommets\x = ValF(StringField(Mid(txt, pos, 20), 1, " "))
      pos = FindString(txt, "Y", pos)+3
      *sommets\y = ValF(StringField(Mid(txt, pos, 20), 1, " "))
      pos = FindString(txt, "Z", pos)+3
      *sommets\z = ValF(StringField(Mid(txt, pos, 20), 1, " "))
      If texture
        pos = FindString(txt, "U", pos)+3
        *sommets\u = ValF(StringField(Mid(txt, pos, 20), 1, " "))*ltexture
        pos = FindString(txt, "V", pos)+3
        *sommets\v = ValF(StringField(Mid(txt, pos, 20), 1, " "))*htexture
      EndIf
      *sommets+sizeof\sommetobjet
    Else
      k-1
    EndIf
    If Eof(fichier)
      Break
    EndIf
  Next k
EndProcedure
Procedure FacettesASC(fichier, nb_facettes, *facettes.FacetteObjet)
  Protected txt.s
  For k=0 To nb_facettes-1
    txt = ReadString(fichier)
    If Left(txt, 4) = "Face"
      txt = Right(txt, Len(txt)-(10+Len(Str(k))))
      *facettes\a = Val(Mid(StringField(txt, 1, " "), 3, 5))
      *facettes\b = Val(Mid(StringField(txt, 2, " "), 3, 5))
      *facettes\c = Val(Mid(StringField(txt, 3, " "), 3, 5))
      *facettes\ab = Val(Mid(StringField(txt, 4, " "), 4, 5))
      *facettes\bc = Val(Mid(StringField(txt, 5, " "), 4, 5))
      *facettes\ca = Val(Mid(StringField(txt, 6, " "), 4, 5))
      *facettes+sizeof\facetteobjet
    Else
      k-1
    EndIf
    If Eof(fichier)
      Break
    EndIf
  Next k
EndProcedure
Procedure ChargerASC(nom.s)
  Protected *resultat, *mem, fichier, txt.s, nb_sommets, nb_facettes, texture.b
  fichier = ReadFile(#PB_Any, nom) 
  If fichier
    While Eof(fichier) = 0
      If Left(ReadString(fichier), 12) = "Named object"
        Repeat
          txt = ReadString(fichier)
          nb_sommets = FindString(txt, "Vertices", 0)
          nb_facettes = FindString(txt, "Faces", 0)
        Until (nb_sommets And nb_facettes) Or Eof(fichier)
        If nb_sommets And nb_facettes
          nb_sommets+10
          nb_sommets = Val(Trim(Mid(txt, nb_sommets, nb_facettes-nb_sommets)))
          nb_facettes+7
          nb_facettes = Val(Trim(Mid(txt, nb_facettes, Len(txt)+1-nb_facettes)))
          If nb_sommets And nb_facettes
            Repeat
              txt = ReadString(fichier)
              If Left(txt, 6) = "Mapped"
                texture = #True
                txt = ReadString(fichier)
                Break
              EndIf
            Until Left(txt, 11) = "Vertex list" Or Eof(fichier)
            If Eof(fichier) = 0
              *resultat = AllocateMemory(sizeof\resultatASC+nb_sommets*sizeof\sommetobjet+nb_facettes*sizeof\facetteobjet)
              If *resultat
                *mem = *resultat
                PokeL(*mem, nb_sommets) : *mem+4
                PokeL(*mem, nb_facettes) : *mem+4
                Repeat
                  If Left(txt, 11) = "Vertex list"
                    SommetsASC(fichier, nb_sommets, *mem, texture) : *mem+nb_sommets*sizeof\sommetobjet
                    Break
                  EndIf
                  txt = ReadString(fichier)
                Until Eof(fichier)
                Repeat
                  If Left(ReadString(fichier), 9) = "Face list"
                    FacettesASC(fichier, nb_facettes, *mem) ; *mem+nb_facettes*sizeof\facetteobjet
                    Break
                  EndIf
                Until Eof(fichier)
              EndIf
            EndIf
          EndIf
          Break
        EndIf
      EndIf
    Wend
    CloseFile(fichier)
  EndIf
  ProcedureReturn *resultat
EndProcedure

C'est carrément fait à la va vite et ça ne charge que le premier objet du fichier pour les besoins du fichier.

On peut encore beaucoup accélérer tout ça en travaillant directement dans le buffer vidéo et non avec la fonction plot().

Bon je retourne à mes révisions et je regarde ton moteur demain Cpl.Bator. ++

ps : Pour lire facilement le code je vous conseille de commencer par les fonctions :
- LoadObject()
- NewEntity()
- Projection()
- DisplaySommets()
Et ensuite de remonter les différents types d'affichage.

Mais vous pouvez aussi commencer par un cube :

Code : Tout sélectionner

; Cube3D - Par Gratteur - 2007

Global fps
#largeur = 800
#hauteur = 600
#noir = 0
#rouge = 255
#blanc = 16777215

#CPI = 0.017453292

Structure Sommet
  x.w
  y.w
  z.w
  xy.l
EndStructure
Structure Point3D
  x.w
  y.w
  z.w
EndStructure
Structure Point2D
  x.w
  y.w
EndStructure
Structure Objet3D
  nb_points.l
  sommet.l
  point3D.l
  point2D.l
EndStructure

Global cube1.Objet3D, Dim cube1p2D.Point2D(8), Dim cube1p3D.Point3D(8), Dim cube1s.Sommet(8)

Procedure InitGameTimer()
  Shared _GT_DevCaps.timecaps
  timeGetDevCaps_(_GT_DevCaps,SizeOf(timecaps))
  timeBeginPeriod_(_GT_DevCaps\wperiodmin)
EndProcedure
Procedure StopGameTimer()
  Shared _GT_DevCaps.timecaps
  timeEndPeriod_(_GT_DevCaps\wperiodmin)
EndProcedure
Procedure Timer()
  Static sfps, images, timer
  Protected t = timeGetTime_()
  If t-timer >= 1000
    timer = t
    fps = images-1
    images = 1
    If fps < 0
      fps = 0
    EndIf
  Else
    images+1
  EndIf
EndProcedure
Procedure DisplayFPS()
  Box(4, 6, 48, 14, #blanc)
  DrawingMode(#PB_2DDrawing_Outlined)
  Box(3, 5, 50, 16, 0)
  DrawingMode(#PB_2DDrawing_Transparent)
  If fps < 10
    DrawText(5, 5, "  "+Str(fps)+ " FPS", 0)
  Else
    DrawText(5, 5, Str(fps)+ " FPS", 0)
  EndIf
  DrawingMode(#PB_2DDrawing_Default)
EndProcedure

Procedure Ligne(p1, p2, point2D.Point2D(1))
  LineXY(point2D(p1)\x, point2D(p1)\y, point2D(p2)\x, point2D(p2)\y)
EndProcedure
Procedure FilDeFerCube1(point2D.Point2D(1))
  Ligne(0,1,point2D()) : Ligne(1,2,point2D()) : Ligne(2,3,point2D()) : Ligne(3,0,point2D())
  Ligne(4,5,point2D()) : Ligne(5,6,point2D()) : Ligne(6,7,point2D()) : Ligne(7,4,point2D())
  Ligne(0,5,point2D()) : Ligne(1,4,point2D()) : Ligne(2,7,point2D()) : Ligne(3,6,point2D())
EndProcedure
Procedure SommetCube1(point2D.Point2D(1))
  For i=0 To 7
    If point2D(i)\x >= 0 And point2D(i)\y >= 0 And point2D(i)\x < #largeur And point2D(i)\y < #hauteur
      Plot(point2D(i)\x, point2D(i)\y)
    EndIf
  Next i
EndProcedure

Procedure ProjectionCube1(point2D.Point2D(1), point3D.Point3D(1))
  Protected xoff = 400, yoff = 300, zoff = 300, d = 8, div
  For i=0 To 7
    div = point3D(i)\z+zoff
    point2D(i)\x = (point3D(i)\x<<d)/div + xoff
    point2D(i)\y = (point3D(i)\y<<d)/div + yoff
  Next i
EndProcedure
Procedure InitialiserCube1()
  cube1s(0)\x = -100 : cube1s(0)\y = -100 : cube1s(0)\z = -100
  cube1s(1)\x =  100 : cube1s(1)\y = -100 : cube1s(1)\z = -100
  cube1s(2)\x =  100 : cube1s(2)\y =  100 : cube1s(2)\z = -100
  cube1s(3)\x = -100 : cube1s(3)\y =  100 : cube1s(3)\z = -100
  cube1s(4)\x =  100 : cube1s(4)\y = -100 : cube1s(4)\z =  100
  cube1s(5)\x = -100 : cube1s(5)\y = -100 : cube1s(5)\z =  100
  cube1s(6)\x = -100 : cube1s(6)\y =  100 : cube1s(6)\z =  100
  cube1s(7)\x =  100 : cube1s(7)\y =  100 : cube1s(7)\z =  100
  For i=0 To 7
    cube1s(i)\xy = -(cube1s(i)\x*cube1s(i)\y)
    cube1p3D(i)\x = cube1s(i)\x
    cube1p3D(i)\y = cube1s(i)\y
    cube1p3D(i)\z = cube1s(i)\z
  Next i
  cube1\nb_points = 8
  cube1\sommet = @cube1s()
  cube1\point3D = @cube1p3D()
  cube1\point2D = @cube1p2D()
  ProjectionCube1(cube1p2D(), cube1p3D())
EndProcedure

Procedure Rotation(x.f, y.f, z.f, point3D.Point3D(1), sommet.Sommet(1))
  Protected Dim a.f(3), Dim matrice.f(3,3)
  x*#CPI : y*#CPI : z*#CPI
  matrice(0,0) = Cos(z)*Cos(y)
  matrice(1,0) = Sin(z)*Cos(y)
  matrice(2,0) = -Sin(y)
  matrice(0,1) = Cos(z)*Sin(y)*Sin(x) - Sin(z)*Cos(x)
  matrice(1,1) = Sin(z)*Sin(y)*Sin(x) + Cos(x)*Cos(z)
  matrice(2,1) = Sin(x)*Cos(y)
  matrice(0,2) = Cos(z)*Sin(y)*Cos(x) + Sin(z)*Sin(x)
  matrice(1,2) = Sin(z)*Sin(y)*Cos(x) - Cos(z)*Sin(x)
  matrice(2,2) = Cos(x)*Cos(y)
  a(0) = -(matrice(0,1)*matrice(0,0))
  a(1) = -(matrice(1,1)*matrice(1,0))
  a(2) = -(matrice(2,1)*matrice(2,0))
  For i=0 To 7
    point3D(i)\x = (matrice(0,1)+sommet(i)\x)*(matrice(0,0)+sommet(i)\y) + a(0)+sommet(i)\xy + matrice(0,2)*sommet(i)\z
    point3D(i)\y = (matrice(1,1)+sommet(i)\x)*(matrice(1,0)+sommet(i)\y) + a(1)+sommet(i)\xy + matrice(1,2)*sommet(i)\z
    point3D(i)\z = (matrice(2,1)+sommet(i)\x)*(matrice(2,0)+sommet(i)\y) + a(2)+sommet(i)\xy + matrice(2,2)*sommet(i)\z
  Next i
EndProcedure

Procedure Initialisation()
  Protected op = #PB_Window_Invisible|#PB_Window_SystemMenu|#PB_Window_TitleBar|#PB_Window_ScreenCentered
  OpenWindow(0, 0, 0, #largeur, #hauteur, "Moteur 3D", op)
  InitSprite()
  OpenWindowedScreen(WindowID(0), 0, 0, #largeur, #hauteur, 0, 0, 0)
  SetFrameRate(60)
  InitGameTimer()
  HideWindow(0, 0)
  InitialiserCube1()
EndProcedure
Procedure Main()
  Protected image, ax, ay, az
  Repeat
    If image = 1
      image = 0
      ax = (ax+1)%360
      ay = (ay+2)%360
      az = (az+1)%360
      Rotation(ax,ay,az,cube1p3D(),cube1s())
      ProjectionCube1(cube1p2D(),cube1p3D())
    Else
      image+1
    EndIf
    ClearScreen(#noir)
    If StartDrawing(ScreenOutput())
      FrontColor(#blanc)
      ;SommetCube1(cube1p2D())
      FilDeFerCube1(cube1p2D())
      DisplayFPS()
      StopDrawing()
    EndIf
    FlipBuffers()
    Timer()
    Delay(1)
  Until WindowEvent() = #PB_Event_CloseWindow
EndProcedure
Procedure Quitter()
  StopGameTimer()
  End
EndProcedure

Initialisation()
Main()
Quitter()

Anonyme · Message par **Anonyme** » mer. 09/mai/2007 19:31

oula, c'est un gros pavé

Tu peut aussi optimisé avec les matrices :
v'la une volée de fct° :

Code : Tout sélectionner

Structure VECTOR3
  x.f : y.f : z.f
EndStructure

Structure MATRIX4x4
  _11.f : _21.f : _31.f : _41.f
  _12.f : _22.f : _32.f : _42.f 
  _13.f : _23.f : _33.f : _43.f 
  _14.f : _24.f : _34.f : _44.f 
EndStructure 

;-MATRICES PROCS
Procedure MATRICE_INDENTITY(*MATRICE.MATRIX4x4)
  *MATRICE\_11 = 1 : *MATRICE\_21 = 0          : *MATRICE\_31 = 0           : *MATRICE\_41 = 0
  *MATRICE\_12 = 0 : *MATRICE\_22 = 1          : *MATRICE\_32 = 0           : *MATRICE\_42 = 0
  *MATRICE\_13 = 0 : *MATRICE\_23 = 0          : *MATRICE\_33 = 1           : *MATRICE\_43 = 0
  *MATRICE\_14 = 0 : *MATRICE\_24 = 0          : *MATRICE\_34 = 0           : *MATRICE\_44 = 1
EndProcedure

Procedure MATRICE_ROTATE(*MATRICE.MATRIX4x4 , Xa.f,Ya.f,Za.f)
  *MATRICE\_11 = Cos(Za)*Cos(Ya)                             : *MATRICE\_21 = Sin(Za)*Cos(Ya)                              : *MATRICE\_31 = -Sin(Ya)        :  *MATRICE\_41 = 0
  *MATRICE\_12 = Cos(Za)*Sin(Ya)*Sin(Xa) - Sin(Za)*Cos(Xa)   : *MATRICE\_22 = Sin(Za)*Sin(Ya)*Sin(Xa) + Cos(Xa)*Cos(Za)    : *MATRICE\_32 = Sin(Xa)*Cos(Ya) :  *MATRICE\_42 = 0
  *MATRICE\_13 = Cos(Za)*Sin(Ya)*Cos(Xa) + Sin(Za)*Sin(Xa)   : *MATRICE\_23 = Sin(Za)*Sin(Ya)*Cos(Xa) - Cos(Za)*Sin(Xa)    : *MATRICE\_33 = Cos(Xa)*Cos(Ya) :  *MATRICE\_43 = 0
  *MATRICE\_14 = 0                                           : *MATRICE\_24 = 0                                            : *MATRICE\_34 = 0               :  *MATRICE\_44 = 1 
EndProcedure

Procedure MATRICE_ROTATE_X(*MATRICE.MATRIX4x4,Angle.f)
  *MATRICE\_11 = 1 : *MATRICE\_21 = 0          : *MATRICE\_31 = 0           : *MATRICE\_41 = 0
  *MATRICE\_12 = 0 : *MATRICE\_22 = Cos(Angle) : *MATRICE\_32 = -Sin(Angle) : *MATRICE\_42 = 0
  *MATRICE\_13 = 0 : *MATRICE\_23 = Sin(Angle) : *MATRICE\_33 = Cos(Angle)  : *MATRICE\_43 = 0
  *MATRICE\_14 = 0 : *MATRICE\_24 = 0          : *MATRICE\_34 = 0           : *MATRICE\_44 = 1
EndProcedure

Procedure MATRICE_ROTATE_Y(*MATRICE.MATRIX4x4,Angle.f)
  *MATRICE\_11 = Cos(Angle) : *MATRICE\_21 = 0          : *MATRICE\_31 = -Sin(Angle) : *MATRICE\_41 = 0
  *MATRICE\_12 = 0          : *MATRICE\_22 = 1          : *MATRICE\_32 = 0           : *MATRICE\_42 = 0
  *MATRICE\_13 = Sin(Angle) : *MATRICE\_23 = 0          : *MATRICE\_33 = Cos(Angle)  : *MATRICE\_43 = 0
  *MATRICE\_14 = 0          : *MATRICE\_24 = 0          : *MATRICE\_34 = 0           : *MATRICE\_44 = 1
EndProcedure

Procedure MATRICE_ROTATE_Z(*MATRICE.MATRIX4x4,Angle.f)
  *MATRICE\_11 = Cos(Angle) : *MATRICE\_21 = -Sin(Angle): *MATRICE\_31 = 0 : *MATRICE\_41 = 0
  *MATRICE\_12 = Sin(Angle) : *MATRICE\_22 = Cos(Angle) : *MATRICE\_32 = 0 : *MATRICE\_42 = 0
  *MATRICE\_13 = 0          : *MATRICE\_23 = 0          : *MATRICE\_33 = 1 : *MATRICE\_43 = 0
  *MATRICE\_14 = 0          : *MATRICE\_24 = 0          : *MATRICE\_34 = 0 : *MATRICE\_44 = 1
EndProcedure

Procedure MATRICE_SCALE(*MATRICE.MATRIX4x4,Factor.f)
  *MATRICE\_11 * Factor  
  *MATRICE\_22 * Factor 
  *MATRICE\_33 * Factor 
  *MATRICE\_44 * Factor 
EndProcedure  

Procedure MATRICE_SCALEXYZ(*MATRICE.MATRIX4x4,xFactor.f,yFactor.f,zFactor.f)
  *MATRICE\_11 * xFactor  
  *MATRICE\_22 * yFactor 
  *MATRICE\_33 * zFactor 
  *MATRICE\_44 * 1
EndProcedure  

Procedure MATRICE_TRANSLATE(*MATRICE.MATRIX4x4 , x.f,y.f,z.f)
  Global V.VECTOR3
  *MATRICE\_11 = 1 : *MATRICE\_21 = 0 : *MATRICE\_31 = 0 : *MATRICE\_41 =  x
  *MATRICE\_12 = 0 : *MATRICE\_22 = 1 : *MATRICE\_32 = 0 : *MATRICE\_42 =  y
  *MATRICE\_13 = 0 : *MATRICE\_23 = 0 : *MATRICE\_33 = 1 : *MATRICE\_43 =  z
  *MATRICE\_14 = 0 : *MATRICE\_24 = 0 : *MATRICE\_34 = 0 : *MATRICE\_44 = 1
  V\x=*MATRICE\_41
  V\y=*MATRICE\_42
  V\z=*MATRICE\_43
EndProcedure

Procedure MATRICE_MULTIPLY(*m1.MATRIX4x4,*m2.MATRIX4x4,*MatriceF.MATRIX4x4)
  *MatriceF\_11 = *m1\_11 * *m2\_11 + *m1\_12 * *m2\_21 + *m1\_13 * *m2\_31 + *m1\_14 * *m2\_41
  *MatriceF\_12 = *m1\_11 * *m2\_12 + *m1\_12 * *m2\_22 + *m1\_13 * *m2\_32 + *m1\_14 * *m2\_42
  *MatriceF\_13 = *m1\_11 * *m2\_13 + *m1\_12 * *m2\_23 + *m1\_13 * *m2\_33 + *m1\_14 * *m2\_43
  *MatriceF\_14 = *m1\_11 * *m2\_14 + *m1\_12 * *m2\_24 + *m1\_13 * *m2\_34 + *m1\_14 * *m2\_44
  
  *MatriceF\_21 = *m1\_21 * *m2\_11 + *m1\_22 * *m2\_21 + *m1\_23 * *m2\_31 + *m1\_24 * *m2\_41
  *MatriceF\_22 = *m1\_21 * *m2\_12 + *m1\_22 * *m2\_22 + *m1\_23 * *m2\_32 + *m1\_24 * *m2\_42
  *MatriceF\_23 = *m1\_21 * *m2\_13 + *m1\_22 * *m2\_23 + *m1\_23 * *m2\_33 + *m1\_24 * *m2\_43
  *MatriceF\_24 = *m1\_21 * *m2\_14 + *m1\_22 * *m2\_24 + *m1\_23 * *m2\_34 + *m1\_24 * *m2\_44
  
  *MatriceF\_31 = *m1\_31 * *m2\_11 + *m1\_32 * *m2\_21 + *m1\_33 * *m2\_31 + *m1\_34 * *m2\_41
  *MatriceF\_32 = *m1\_31 * *m2\_12 + *m1\_32 * *m2\_22 + *m1\_33 * *m2\_32 + *m1\_34 * *m2\_42
  *MatriceF\_33 = *m1\_31 * *m2\_13 + *m1\_32 * *m2\_23 + *m1\_33 * *m2\_33 + *m1\_34 * *m2\_43
  *MatriceF\_34 = *m1\_31 * *m2\_14 + *m1\_32 * *m2\_24 + *m1\_33 * *m2\_34 + *m1\_34 * *m2\_44
  
  *MatriceF\_41 = *m1\_41 * *m2\_11 + *m1\_42 * *m2\_21 + *m1\_43 * *m2\_31 + *m1\_44 * *m2\_41
  *MatriceF\_42 = *m1\_41 * *m2\_12 + *m1\_42 * *m2\_22 + *m1\_43 * *m2\_32 + *m1\_44 * *m2\_42
  *MatriceF\_43 = *m1\_41 * *m2\_13 + *m1\_42 * *m2\_23 + *m1\_43 * *m2\_33 + *m1\_44 * *m2\_43
  *MatriceF\_44 = *m1\_41 * *m2\_14 + *m1\_42 * *m2\_24 + *m1\_43 * *m2\_34 + *m1\_44 * *m2\_44
EndProcedure 

Procedure MATRICE_ADD(*m1.MATRIX4x4,*m2.MATRIX4x4)
  *m1\_11 = *m1\_11 + *m2\_11 
  *m1\_12 = *m1\_12 + *m2\_12 
  *m1\_13 = *m1\_13 + *m2\_13 
  *m1\_14 = *m1\_14 + *m2\_14 
  
  *m1\_21 = *m1\_21 + *m2\_21 
  *m1\_22 = *m1\_22 + *m2\_22 
  *m1\_23 = *m1\_23 + *m2\_23 
  *m1\_24 = *m1\_24 + *m2\_24 
  
  *m1\_31 = *m1\_31 + *m2\_31 
  *m1\_32 = *m1\_32 + *m2\_32 
  *m1\_33 = *m1\_33 + *m2\_33 
  *m1\_34 = *m1\_34 + *m2\_34 
  
  *m1\_41 = *m1\_41 + *m2\_41 
  *m1\_42 = *m1\_42 + *m2\_42 
  *m1\_43 = *m1\_43 + *m2\_43 
  *m1\_44 = *m1\_44 + *m2\_44 
EndProcedure       

Procedure GET_AXIS_X_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3)
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_11
  *VECTOR\y=*MATRICE\_12
  *VECTOR\z=*MATRICE\_13
  ProcedureReturn *VECTOR
EndProcedure  

Procedure GET_AXIS_Y_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3 )
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_21
  *VECTOR\y=*MATRICE\_22
  *VECTOR\z=*MATRICE\_23
  ProcedureReturn *VECTOR
EndProcedure             

Procedure GET_AXIS_Z_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3)
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_31
  *VECTOR\y=*MATRICE\_32
  *VECTOR\z=*MATRICE\_33
  ProcedureReturn *VECTOR
EndProcedure            

Procedure GET_VECTOR_UP_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3)
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_11
  *VECTOR\y=*MATRICE\_21
  *VECTOR\z=*MATRICE\_31
  ProcedureReturn *VECTOR
EndProcedure   

Procedure GET_VECTOR_RIGHT_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3)
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_12
  *VECTOR\y=*MATRICE\_22
  *VECTOR\z=*MATRICE\_32
  ProcedureReturn *VECTOR
EndProcedure   

Procedure GET_VECTOR_DIRECTION_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3)
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_13
  *VECTOR\y=*MATRICE\_23
  *VECTOR\z=*MATRICE\_33
  ProcedureReturn *VECTOR
EndProcedure   

Procedure GET_VECTOR_POSITION_FROM_MATRICE(*MATRICE.MATRIX4x4,*VECTOR.VECTOR3)
  *VECTOR.VECTOR3 
  *VECTOR\x=*MATRICE\_41
  *VECTOR\y=*MATRICE\_42
  *VECTOR\z=*MATRICE\_43
  ProcedureReturn *VECTOR
EndProcedure

je mettrais en ligne mon .rar dès que c'est au point, y a trop d'include dans mon cas pour tout mettre ici.
@++

Gratteur · Message par **Gratteur** » mer. 09/mai/2007 19:38

Ouais, merci pour les matrices. Je crois qu'on pourrait déja pas mal optimiser avec des tables de sinus et cosinus précalculées, ça éviterait énormément de multiplications couteuses et on travaillerait avec des valeurs entières. Le code est long parcequ'il y a plein de procédures d'affichage différentes. Après mes partielles je vous simplifie et commente tout ça.

Dr. Dri · Message par **Dr. Dri** » mer. 09/mai/2007 21:16

ou simplement ne pas appeller deux fois les fonctions de trigo pour le même angle
c'est déjà un bon début d'optimisation

Dri

Gratteur · Message par **Gratteur** » mer. 09/mai/2007 22:08

Ca n'arrive pas pour les rotations, sauf dans l'exemple du cube tout en bas, mais c'est dans un but pédagogique. De même pas mal d'angles et de normales sont pré-calculés. Pour gagner un peu de temps de calcul il faudra passer directement le pointeur des sommets plutot que le numéro, même si c'est déja très rapide.

Coolman · Message par **Coolman** » jeu. 10/mai/2007 14:30

Cool

, merci des codes sources, le partage, y'a que ca de vrai dans ce monde de fous, reste a assimiler tout ca, qui c'est deja qui disait ne pas etre fort en math, menteur