PureBasic

Salut à tous, je propose de faire un mini moteur 3D extra simple.
Pour ce challenge, ce sera juste le survol d'une matrice toute bête ^^

voici un exemple concret :

File:1->Demonstration3D.rar

On controle la caméra avec la souris et les touches fléchées
Bouton gauche de la souris pour faire varier la matrice.

il est bien evident que je n'utilise pas ogre ni aucune lib, mais les fonctions 2DDrawing pour afficher les fils de fer, les calculs sont fait maison

Bien sur, je n'ai rien inventé, j'ai tout trouvé sur le net. mon meilleur ami est gougueulle

Voici une piste qui pourra vous aider http://membres.lycos.fr/heulin/3D/Plan3D.html

Je donnerais la source dans un mois, le 4 octobre prochain.

En espérant voir des "challengeurs"

@++

ps: si vous sécher, n'hésitez pas à posé vos questions ici. ou part MP

Je peux participer?

Autre source plus rigolotte

La CAO sans peine (JP Petit) c'est gratuit

http://www.savoir-sans-frontieres.com/J ... _peine.htm

@Djes Oui, mais avec ta méthode

@Frenchy , bon lien , mais dans notre cas , il n'aidera pas grand monde

@++

Je préfére garder la surprise

Bon , y a pas beaucoup de candidats

Les maths n'ont jamais bouffés personne

D'ailleurs je comprend 1/10 de ce que j'ai codé

(initsprite() etc...) après c'est du chinois

, je rigole, rien qu'avec le 1°er lien du haut , on peut s'en sortir

Cpl.Bator a écrit :Bon , y a pas beaucoup de candidats Les maths n'ont jamais bouffés personne

Ouai sa on sait pas car si qlq'un a été bouffé par une formule de maths ou pire une équation, il ne pourrait pas témoigner

.

L'idée est simpa mais je suis pas calé en matière de graphisme

. Et puis entre l'IUT, le permi et l'anglais ^^, je sais pas si je pourrais mener ce truc à bien, enfin je regarderai peut-être ce que sa dit ^^.

Bonne chance au challangers

C'est pas que ça ne m'intéresse pas, c'est plutôt le fait que c'est la rentrée scolaire et je risque fort de ne plus avoir le temps de faire de la programmation en plus des projets déja en cours. Même les projets en cours seront ralentis. Si j'ai le temps je vais peut-être me lancer ...

Et je confirme, avec ce qui est présenté sur le lien que Cpl.Bator à donnée, n'importe qui peut s'en sortir. Il suffit simplement de traduire le code C dans la Syntaxe de PB. Ne pas oublier de donner les crédits lorsque cela est opportun.

A+
Guimauve

J'ai commencé avec un cube, pas de caméra, et j'ai des problèmes lorsque je fais tourner le cube sur lui-même. Je commence à comprendre pourquoi les matrices ne sont pas fiable pour calculer des rotations 3D successives.

Je donne le code maintenant, je n'ai pas vraiment atteind l'objectif du challenge. Hélas, j'ai trop de chose à faire et pas assez de temps pour le faire.

Bon courage à tout les Challengers

A+
Guimauve

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Nom du projet : Mini Moteur 3D - Cube 2
; Fichier : Cube 2.pb
; Version : 1.0.0
; Programmation = Truc bizarre dans l'animation
; Programmé par : Guimauve
; Date : 07-09-2006
; Mise à jour : 07-09-2006
; Codé avec PureBasic V4.00
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
;
; Pendant l'animation, le cube ne ressemble plus
; à un cube, pourquoi ? Après un certain temps le
; cube redevient un cube.
;
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

#Xoff = 400
#Yoff = 300
#Zoff = 500

Global Dim SinTable.d(359)
Global Dim CosTable.d(359)

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; CODE GÉNÉRÉ AUTOMATIQUEMENT, NE PAS MODIFIER À
; MOINS D'AVOIR UNE RAISON TRÈS TRÈS VALABLE !!!
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Déclaration de la Structure >>>>>

Structure Point3
  
  x.l
  y.l
  z.l
  
EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les mutateurs >>>>>

Macro SetPoint3x(ObjetA, P_x)
  
  ObjetA\x = P_x
  
EndMacro

Macro SetPoint3y(ObjetA, P_y)
  
  ObjetA\y = P_y
  
EndMacro

Macro SetPoint3z(ObjetA, P_z)
  
  ObjetA\z = P_z
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les observateurs >>>>>

Macro GetPoint3x(ObjetA)
  
  ObjetA\x
  
EndMacro

Macro GetPoint3y(ObjetA)
  
  ObjetA\y
  
EndMacro

Macro GetPoint3z(ObjetA)
  
  ObjetA\z
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Update >>>>>

Macro UpdatePoint3(ObjetA, P_x, P_y, P_z)
  
  SetPoint3x(ObjetA, P_x)
  SetPoint3y(ObjetA, P_y)
  SetPoint3z(ObjetA, P_z)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Macro de déboguage >>>>>

Macro DebugPoint3(ObjetA)
  
  Debug "(" + Str(GetPoint3x(ObjetA)) + ", " + Str(GetPoint3y(ObjetA)) + ", " + Str(GetPoint3z(ObjetA)) + ")"
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code généré en : 16 ms <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Procedure InitSinCosTable()
  
  For Index = 0 To 359
    
    SinTable(Index) = Sin(Index *#PI /180)
    CosTable(Index) = Cos(Index *#PI /180)
    
  Next
  
EndProcedure

Procedure RotationCube(Sommet.Point3(1), Point3D.Point3(1), Xa, Ya, Za)
  
  ; Initialisation de la matrice de rotation 3*3
  
  Dim Matrice.f(2,2)
  
  Matrice(0, 0) = CosTable(Za) * CosTable(Ya)
  Matrice(1, 0) = SinTable(Za) * CosTable(Ya)
  Matrice(2, 0) = -SinTable(Ya)
  
  Matrice(0, 1) = CosTable(Za) * SinTable(Ya) * SinTable(Xa) - SinTable(Za) * CosTable(Xa)
  Matrice(1, 1) = SinTable(Za) * SinTable(Ya) * SinTable(Xa) + CosTable(Xa) * CosTable(Za)
  Matrice(2, 1) = SinTable(Xa) * CosTable(Ya)
  
  Matrice(0, 2) = CosTable(Za) * SinTable(Ya) * CosTable(Xa) + SinTable(Za) * SinTable(Xa)
  Matrice(1, 2) = SinTable(Za) * SinTable(Ya) * CosTable(Xa) - CosTable(Za) * SinTable(Xa)
  Matrice(2, 2) = CosTable(Xa) * CosTable(Ya)

  ; Calcul de la rotation
  
  For i = 0 To 7
    
    SetPoint3x(Point3D(i), Matrice(0, 0) * GetPoint3x(Sommet(i)) + Matrice(1, 0) * GetPoint3y(Sommet(i)) + Matrice(2, 0) * GetPoint3z(Sommet(i)))
    SetPoint3y(Point3D(i), Matrice(0, 1) * GetPoint3x(Sommet(i)) + Matrice(1, 1) * GetPoint3y(Sommet(i)) + Matrice(2, 1) * GetPoint3z(Sommet(i)))
    SetPoint3z(Point3D(i), Matrice(0, 2) * GetPoint3x(Sommet(i)) + Matrice(1, 2) * GetPoint3y(Sommet(i)) + Matrice(2, 2) * GetPoint3z(Sommet(i)))
    
  Next 
  
EndProcedure

Procedure InitCube(Array.Point3(1))
  
  UpdatePoint3(Array(0), -100, -100, -100)
  UpdatePoint3(Array(1),  100, -100, -100)
  UpdatePoint3(Array(2),  100,  100, -100)
  UpdatePoint3(Array(3), -100,  100, -100)
  UpdatePoint3(Array(4),  100, -100,  100)
  UpdatePoint3(Array(5), -100, -100,  100)
  UpdatePoint3(Array(6), -100,  100,  100)
  UpdatePoint3(Array(7),  100,  100,  100)
  
EndProcedure

Procedure DrawCubeLine(Array.Point3(1), a,b,Couleur)
  
  x1 = (GetPoint3x(Array(a))*256)/(GetPoint3z(Array(a)) + #Zoff) + #Xoff
  y1 = (GetPoint3y(Array(a))*256)/(GetPoint3z(Array(a)) + #Zoff) + #Yoff
  
  x2 = (GetPoint3x(Array(b))*256)/(GetPoint3z(Array(b)) + #Zoff) + #Xoff
  y2 = (GetPoint3y(Array(b))*256)/(GetPoint3z(Array(b)) + #Zoff) + #Yoff
  
  LineXY(x1, y1, x2, y2, Couleur)
  
EndProcedure

Procedure WireFrame(Array.Point3(1), Couleur)
  
  StartDrawing(ScreenOutput()) ;>
    
    DrawCubeLine(Array(), 0, 1, Couleur)
    DrawCubeLine(Array(), 1, 2, Couleur)
    DrawCubeLine(Array(), 2, 3, Couleur)
    DrawCubeLine(Array(), 3, 0, Couleur)
    
    DrawCubeLine(Array(), 4, 5, Couleur)
    DrawCubeLine(Array(), 5, 6, Couleur)
    DrawCubeLine(Array(), 6, 7, Couleur)
    DrawCubeLine(Array(), 7, 4, Couleur)
    
    DrawCubeLine(Array(), 0, 5, Couleur)
    DrawCubeLine(Array(), 1, 4, Couleur)
    DrawCubeLine(Array(), 2, 7, Couleur)
    DrawCubeLine(Array(), 3, 6, Couleur)
    
  StopDrawing() ;<
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Dim Sommet.Point3(7) ; Cube Original
Dim Point3D.Point3(7) ; Cube après la rotation
; Dim Point2D.Point2(7) ; Projection 2D du cube après la rotation

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Initialize DirectX >>>>>

If InitKeyboard() = 0 Or InitSprite() = 0 
  MessageRequester("ERROR","Cant initialize DirectX!",#MB_ICONERROR)
  End 
EndIf 

; <<<<<<<<<<<<<<<<<<<<<<
; <<<<< OpenScreen >>>>>

ScreenW = GetSystemMetrics_(#SM_CXSCREEN)
ScreenH = GetSystemMetrics_(#SM_CYSCREEN)

If OpenScreen(ScreenW, ScreenH, 32, "Mini Moteur 3D") = 0 
  If OpenScreen(ScreenW, ScreenH, 24, "Mini Moteur 3D") = 0 
    If OpenScreen(ScreenW, ScreenH, 16, "Mini Moteur 3D") = 0 
      MessageRequester("ERROR", "Cant open DirectX screen!", #MB_ICONERROR)
      End
    EndIf
  EndIf
EndIf 

InitSinCosTable()
InitCube(Sommet())

Repeat 
  
  If IsScreenActive() 
    
    ClearScreen(#Black)
    
    RotationCube(Sommet(), Point3D(), Xa.w, Ya.w, Za.w);
    WireFrame(Point3D(), #Red)
    
    Xa = (Xa + 1) % 360
    Ya = (Ya + 2) % 360
    Za = (Za + 3) % 360
    
    StartDrawing(ScreenOutput());>
      DrawingMode(#PB_2DDrawing_Transparent)
      DrawText(5, 5, "Angle de rotation autour de x = " + Str(Xa), #Yellow)
      DrawText(5,25, "Angle de rotation autour de y = " + Str(Ya), #Yellow)
      DrawText(5,45, "Angle de rotation autour de z = " + Str(Za), #Yellow)
      
    StopDrawing();<
    
    FlipBuffers() 
    
  Else 
    
    Delay(10) 
    
  EndIf 
  
  ExamineKeyboard() 
  
Until KeyboardReleased(#PB_Key_Escape) 

CloseScreen() 

End 

; <<<<<<<<<<<<<<<<<<<<<<<<
; <<<< FIN DU FICHIER <<<<
; <<<<<<<<<<<<<<<<<<<<<<<<

Le problème ne vient pas des matrices, mais de la perte de précision qu'engendre ta conversion en degrés.
Au passage, on a aussi une perte de précisions avec les radians mais bien moindre puisque c'est "natif".

Bien joué Guimmauve ! je n'ai pas pu tester mais, j'ai vu 2-3 trucs a corrigé

#Xoff & #Yoff , définissent le point de fuite de l'écran,
je testerais le code, quand je serais sur mon pc , je te dirais plus en détails à ce moment là

; Pendant l'animation, le cube ne ressemble plus
; à un cube, pourquoi ? Après un certain temps le
; cube redevient un cube.

C'est un effet d'optique !

ca me fait la même chose

Il ne manque plus qu'a faire une matrice de translation, une fonction qui multiplie les 2 matrices (Projection = Rotation X translation), au total ca fait 3 matrices, ensuite , ca devrais être bon

Lorsque j'ai fait mon cours de CAO à l'université les transformations géométrique ont toujours été faites à l'aide de Matrice 4X4 pour les rotations, les translations, les mises à l'échelle, les mirroirs et non des matrice 3X3. J'ai déja tout ca de programmé et donc bouger la géométrie n'est vraiment un problème dans mon cas.

Le premier problème est d'afficher en 2D un objet en 3D pas seulement en fil de fer mais en polygones remplis avec l'effet de lumière sur la surface. Soit avec une couleur, soit avec une texture au format *.bmp ou autre.

Le 2e problème est de donner l'effet de perspective correct. J'ai vu des exemples mais j'y comprends rien. Faire des trucs sans comprendre c'est pas toujours une bonne chose.

Dans le cas présent, j'ai simplement traduit un code C vers PB sans trop me prendre la tête. Et ça marche plus ou moins. (Le code vient du lien donné plus haut par Cpl.Bator)

J'aurais bien besoin d'un exemple plus complèt et d'une bonne référence pour y arriver.

A+
Guimauve

Je ne te cache pas que j'utilise aussi des matrices 4x4 et quelques fonctions complementaire, comme la multiplication des matrices par exemple, la persepective est obtenu via une division des x/y que tu utilises dans ton code :

Code : Tout sélectionner

(GetPoint3x(Array(a))*256)/(GetPoint3z(Array(a)) + #Zoff) + #Xoff 
  y1 = (GetPoint3y(Array(a))*256)/(GetPoint3z(Array(a)) + #Zoff) + #Yoff

Personellement , je trouve que tu t'es pris la tête pour convertir le code C en basic. notament avec des macros par forcement utiles.

Voici comment je gère les matrices :

Code : Tout sélectionner

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  


Procedure MATRICE_Rotate_XYZ(*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_Translate_XYZ(*MATRICE.MATRIX4x4 , x.f,y.f,z.f) 
  *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 
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

Voila quelques liens qui pourront certainement aider ceux qui ce lance dans ce challenge :

http://www.mandragor.org/tutoriels/3d/0

http://membres.lycos.fr/javamus/articles/mqfaq.html

http://cours-info.iut-bm.univ-fcomte.fr ... ib/tp5.pdf

http://www.onversity.net/cgi-bin/progar ... =a1405#080

http://eraquila.iquebec.com/site/theo/matrice.htm

En ce qui concerne le plaquage de textures ou de face pleines, le premier lien du premier post convient très bien, le seul véritable problème c'est l'optimisation, j'ai eu beau vouloir optimiser, mais faire du software , c'est pas facile pour l'optimisation que ce soit en c++ ou en pure, c'est pareil.
Il faudra pas dépasser des résolutions comme le 640x480 (sur un 19 pouces, c'est pas super

)
Pour ce qui est de la perspective, j'utilise la meme formule que toi, elle rend plutot bien

Personellement , je trouve que tu t'es pris la tête pour convertir le code C en basic. notament avec des macros pas forcement utiles.

L'utilisation des Macros pour cacher le chemin d'accès à une structure de données, je te l'accorde, c'est parfaitement inutile. La seule chose que ça fait c'est de faire travailler le compilateur un peu plus.

Sauf que dans ma philosophie d'écriture du code, lorsque j'utilise une strcuture de donnée, je n'accède jamais directement à la Structure partout dans le code. Je cache le chemin d'accès dans des Macros. De l'ordre, de la dicipline.

C'est pas compliqué, soit je prends le temps de faire construire les Macros par mon petit utilitaire, soit MATRAQUE.

L'ennui c'est vous avez l'impression que c'est plus long de faire comme ça. Et bien moi je trouve que de ne pas faire ça c'est bien plus long. De plus le code est très lourd.

Ça c'est ma macro pour initialiser une matrice 4X4 pour une translation 3D.

Code : Tout sélectionner

Macro TranslationMatrix4X4(Translation, Trans_x, Trans_y, Trans_z)
   
   IdentityMatrix4X4(Translation)
   SetMatrix4X4Number(Translation, 0, 3, Trans_x)
   SetMatrix4X4Number(Translation, 1, 3, Trans_y)
   SetMatrix4X4Number(Translation, 2, 3, Trans_z)
   
EndMacro

Ça c'est l'initialisation d'une matrice pré - inversé pour trouver les coefficients d'un segment de spline Cubique Paramétrique.

Code : Tout sélectionner

Define.Matrix4X4 Coefficient
UpdateMatrix4X4Line(Coefficient, 0,  2, -2,  1,  1)
UpdateMatrix4X4Line(Coefficient, 1, -3,  3, -2, -1)
UpdateMatrix4X4Line(Coefficient, 2,  0,  0,  1,  0)
UpdateMatrix4X4Line(Coefficient, 3,  1,  0,  0,  0)

En regardant simplement les 4 dernières valeurs de chacune des lignes je vois le contenu de la matrice très facilement.

Selon mon point de vue, c'est bien plus facile à suivre lorsque qu'on lit le code.

Le plus important, c'est d'être à l'aise avec sa manière d'écrire le code. Moi je ne peux plus faire autrement. Vraiment désolé.

A+
Guimauve

N.B. Merci pour les nouveaux lien.

PureBasic

[Challenge] Mini Moteur 3D

[Challenge] Mini Moteur 3D