Moteur3D Software

[Anonyme]

En fait, tout ce qui est calcul de Vertex est fait par le cpu, le rendu software passe par le cpu aussi (Calcul + rendu) = perte de perf
Alors que les cartes graphiques sont là pour aléger tout ce prossesus

Cpu = calcul des vertex dans l'espace
Gpu = Rendu

Cpu+Gpu = + de perfs

Bien sur, c'est beaucoup plus complexe que ca, c'était pour schématiser.

[tonton]

@Progi1984

en fait mon challenge est le suivant :

- Trouver des algos optimiser de remplissage de polygones
- Pouvoir charger un fichier possedant une liste de vertex et de faces pour ensuite pouvoir les projeter sur l'ecran via un autre algo
-Gerer l'éclairage (gouraud) de manière software (sans passer par les API comme DX ou Opgl)
- il y a plein d'autre truc, comme le clipping, les octree, le zbuffer....

Mais dans ce challenge perso, il y a beaucoup d'obstacle pour un non matheux comme moi, mais cela ne me fait pas peur du tout, pour le moment je m'en sors bien ^^
En final, j'aimerais disposer d'un petit moteur à la Duke nukem 3D.
et pourquoi pas par la suite l'améiorrer via une api graphique.
mais bon, je n'en suis pas là

content de voir que je ne suis pas le seul fou a vouloir faire ca
a part les matrices, pas besoin de connaissance en math, mais surtout
du bon sens(t as demontrer que t en avais) et du temps sont nécéssaire.
j ai traité ce que southaite faire mais seulement en assembleur pour
la plupart des routines. n ésite pas en tout cas si t as des questions auquelles je puisse repondre....

[Anonyme]

Merci Tonton pour tes reponses.

Je fesais plusieurs erreur dans mon code, je n'avais pas de matrice identité. il falait alors attendre la premiére transformation pour voir l'objet, le problème est fixé.

Voici comment je procède en gros :

Code : Tout sélectionner

ID = Chargememt de l'objet.asc
Matrice_identité( ID )

repeat

Translation_objet(ID,x,y,z)    <- Grace à l'id on accède directement à la matrice de translation via un pointeur, Une multiplication est faite : Matrice_Translation * Matrice_Rotation = Matrice_Finale

ensuite je calcule la nouvelle positions des points3D en fonction de la Objet()\matrice_finale

Rotation_ObjetXYZ(ID , xa,ya,za) <- idem

Ensuite la formule de projection qui convertit les points3D en points2D à l'écran

forever

j'ai essayer de Faire Camera()\Matrice_Translation,rotation,finale
puis de multiplier ces matrices par celle des objets puis de réorienté les points3D en fonction de Camera()\Matrice_Finale, j'ai du loupé quelque chose

Pour être plus clair voici la structure que j'utilise :

Code : Tout sélectionner

Structure VERTEX
  x.f
  y.f 
  z.f
  ObjectID.l  
EndStructure 


Structure SOFTWARE_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            


Structure Objects
  id.l
  x.f
  y.f
  z.f
  Nombre_Face.l
  Nombre_Vertex.l
  Matrice_Identity.SOFTWARE_MATRIX4x4
  Matrice_Rotation.SOFTWARE_MATRIX4x4
  Matrice_Translation.SOFTWARE_MATRIX4x4
  Matrice_Finale.SOFTWARE_MATRIX4x4
EndStructure

Structure Cameras
  Matrice_Identity.SOFTWARE_MATRIX4x4
  Matrice_Rotation.SOFTWARE_MATRIX4x4
  Matrice_Translation.SOFTWARE_MATRIX4x4
  Matrice_Finale.SOFTWARE_MATRIX4x4
EndStructure

[tonton]

voici un petit code qui utilise juste une matrice camera.
regarde le code pour voir les touches de déplacement.

Code : Tout sélectionner

InitSprite() 
InitKeyboard() 
InitMouse() 
OpenScreen(1024,768, 32, "") 
 x.l  
 y.l
 z.l

 cx.f  ;cos (alpha)
 sx.f  ;sin (alpha)

 cy.f ;cos (betha)
 sy.f ;sin (betha)

 Nx.f
 Ny.f
 Nz.f

 a.f
 w1.f
 pox.f   ;point observateur X
 poy.f  ;point observateur Y
 poz.f  ;point observateur Z

 d.f  ; facteur perspective (variable fixe)  

 pox=0
 poy=0
 poz=1000
 d=1200
 alpha.f
 beta.f
 addd=?dat
 adddr=?dat1
 liai=?dat2

deb1:
    addd1=addd
    adddr1=adddr
    liai1=liai
 
    cx=Cos(alpha)
    sx=Sin(alpha)
    cy=Cos(beta)
    sy=Sin(beta)

    Nx=cx*sy
    Ny=-sx
    Nz=-cx*cy

    a=1/cx

    StartDrawing(ScreenOutput()) 
deb2:
    MOV eax,addd1
    MOV ebx,[eax]
    MOV ecx,[eax+4]
    MOV edx,[eax+8]
    ADD eax,12
    MOV addd1,eax 
    MOV  x,ebx
    MOV  y,ecx
    MOV  z,edx
    
    ;**************************  matrice camera ****************************
    
    x1 = -x*a*Nz + z*a*Nx + a*(pox*Nz-poz*Nx)
    y1 = -x*a*Nx*Ny + y*(1/a) - z*a*Ny*Nz + a*Ny*(pox*Nx+poz*Nz)-(poy/a)
    z1 = -x*Nx -y*Ny -z*Nz + pox*Nx+poy*Ny+poz*Nz 
    w1 = -(x*Nx)/d -(y*Ny)/d -(z*Nz)/d + (pox*Nx+poy*Ny+poz*Nz)/d  
    
    ;***********************************************************************
    ;transformation 2D , par division de X2 et de Y2 par W1 
   ;Z1 donne directement la profondeur pour l utilisation du zbuffer ou autre...
    x2=(x1/w1)+500  
    y2=(y1/w1)+300   



    MOV  ebx,x2
    MOV  ecx,y2
    MOV eax,adddr1
    MOV [eax],ebx
    MOV [eax+4],ecx
    ADD eax,8
    MOV adddr1,eax 

    pt+1
    If pt=8
    pt=0
    Goto finani0 
    EndIf
    Goto deb2
finani0:   
    addd1=addd 
    adddr1=adddr
    liai1=liai
liaison:
    MOV eax,liai1
    MOV ebx,[eax]
    MOV ecx,[eax+4]
    ADD eax,8
    MOV liai1,eax 
    SAL  ebx,3
    SAL  ecx,3
    MOV eax,adddr1
    MOV edx,[eax+ebx]
    MOV edi,[eax+ebx+4]
    MOV ebx,[eax+ecx]
    MOV esi,[eax+ecx+4]
    MOV adddr1,eax 
    MOV  x1,edx
    MOV  y1,edi
    MOV  x2,ebx
    MOV  y2,esi
    LineXY(x1,y1,x2,y2,RGB(0,255,0)) 
    pt+1
    If pt=24
    pt=0
    Goto finani1 
    EndIf
    Goto liaison
finani1:
    StopDrawing() 
    FlipBuffers() 
    ClearScreen(RGB(0,0,0)) 
    stopit: 
    ExamineKeyboard() 
    If KeyboardPushed(#PB_Key_Escape) 
    End 
    EndIf 
            ;************************  touche deplacement camera **************************
    If KeyboardPushed(#PB_Key_Up)   ; l observateur leve la tronche
    alpha+0.01      
    EndIf
    If KeyboardPushed(#PB_Key_Down)  ; l observateur baisse la tronche
    alpha-0.01
    EndIf
    If KeyboardPushed(#PB_Key_Left)   ;l observateur tourne la tronche a gauche
    beta+0.01
    EndIf
    If KeyboardPushed(#PB_Key_Right) ;l observateur tournel a tronche a droite
    beta-0.01
    EndIf
    If KeyboardPushed(#PB_Key_Pad6) ; l observateur se deplace a droite
    pox-1
    EndIf
    If KeyboardPushed(#PB_Key_Pad4)  ;l observateur se deplace a gauche
    pox+1
    EndIf
    If KeyboardPushed(#PB_Key_Pad2); l observateur se deplace vers le bas
    poy-1
    EndIf
    If KeyboardPushed(#PB_Key_Pad8) ; l observateur se deplace vers le haut
    poy+1
    EndIf
    If KeyboardPushed(#PB_Key_Add) ; l observateur avance
    poz+1
    EndIf
    If KeyboardPushed(#PB_Key_Subtract)  ;l observateur recule
    poz-1
    EndIf
    Goto deb1 
 !section '.data' 
dat2:
 ! DD  0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7
Dat:    
 ! DD 100, 100, 100
 ! DD 100, -100,100
 ! DD -100, -100,100
 ! DD -100, 100,100
 ! DD 100, 100, -100
 ! DD 100, -100, -100
 ! DD -100, -100, -100
 ! DD -100, 100,-100
dat1: 
 ! rd 1600  

pour ton code je connais pas bien le basic, mais je ferais ca

Structure Objects
id.l
x.f
y.f
z.f
Nombre_Face.l
Nombre_Vertex.l
Matrice_Identity.SOFTWARE_MATRIX4x4
Matrice_Rotation.SOFTWARE_MATRIX4x4
Matrice_Translation.SOFTWARE_MATRIX4x4
;;;;;;;;;;; Matrice_Finale.SOFTWARE_MATRIX4x; c est quoi ca????EndStructure

Structure Cameras
Matrice_camera.SOFTWARE_MATRIX4x4
EndStructure.

[Anonyme]

Je crois que tu viens de m'éclairer

Code : Tout sélectionner

Structure Objects 
id.l 
x.f 
y.f 
z.f 
Nombre_Face.l 
Nombre_Vertex.l 
Matrice_Identity.SOFTWARE_MATRIX4x4 
Matrice_Rotation.SOFTWARE_MATRIX4x4 
Matrice_Translation.SOFTWARE_MATRIX4x4 
;;;;;;;;;;; Matrice_Finale.SOFTWARE_MATRIX4x; c est quoi ca????EndStructure 

Structure Cameras 
Matrice_camera.SOFTWARE_MATRIX4x4 
EndStructure.

En fait je multipliai mes matrices comme ceci :

MatMul( Mat_ObjetRotation * Mat_ObjetTranslation ) = Objet Matrice Finale

Mais a la place je vais essayer ceci : MatMul( Mat_ObjetRotation * Mat_ObjetTranslation ) = Camera Matrice Finale

Ensuite j'effectue l'opération qu'il y a dans ton code pour le mouvement de la camera :

Code : Tout sélectionner

  x1 = -x*a*Nz + z*a*Nx + a*(pox*Nz-poz*Nx) 
    y1 = -x*a*Nx*Ny + y*(1/a) - z*a*Ny*Nz + a*Ny*(pox*Nx+poz*Nz)-(poy/a) 
    z1 = -x*Nx -y*Ny -z*Nz + pox*Nx+poy*Ny+poz*Nz 
    w1 = -(x*Nx)/d -(y*Ny)/d -(z*Nz)/d + (pox*Nx+poy*Ny+poz*Nz)/d  

Si c'est test sont positif, je te roule une galoche

[Anonyme]

la camera n'a que 2 axes d'orientation.
Regarde ce lien :
http://www.cubic.org/docs/camera.htm

je ne comprends pas comment aussi par la suite tu peu implémenter des matrices propres a chaque objets. surement du au fait que je pige pas grand chose à l'asm

je récapitule

Mes objets disposent :

Matrice rotation XYZ
Matrice Translation XYZ
Matrice Finale

Mes Camera disposent :

Matrice rotation XYZ
Matrice Translation XYZ
Matrice Finale

Mon véritable problème est comment les combinés entre elles , est ce que j'ai trop de matrice , pas assez
en tout cas merci pour ton aide

[tonton]

la matrice donnée n a que deux axe de rotation X Y. pour le 3eme axe Z
c est un peut plus complexe car il faut créé un point de visé, et faire tourné toute la scene autour de l axe "point de visé/point observateur.
mais commencons cool.
l ordre d utilisation des matrices est importante.

1: d abord metre les objet a l échelle , (c est juste une mutiplication sur chaque point).
2: ensuite faut les orienter avec la matrice de rotation XYZ.
3: ensuite les placer dans la scene avec la matrice de translation.

4:apres seulement tu appliques la matrice de camera.

pour une scene fixe, plus la peine de refaire les etapes 1,2,3

c 'est cette technique que j utilise pour mon moteur.

j' aimerais bien voir ton code si c est pas un secret defense

[Anonyme]

mes codes ne sont jamais secret défonce

File:1->3D.rar


c'est le seul codes qui fonctionne a peu près
l'autre est trop "dépouillé" pour être compréhensible, mais le principe reste le meme dans celui là.


dans ce code, le vilain p'tit canard devrait faire une rotation en X sur lui meme pendant que la "camera" fait une rotation autour de lui, mais il ne prend en compte que la rotation de la camera et pas celle du vilain canard.

[djes]

J'ai fait un chargeur d'objets lightwave il y a quelques temps, si ça t'intéresse. Il y a des matrices aussi, notamment la gestion de la rotation autour de l'axe des objets. Ca peut être optimisé!
http://djes.free.fr/purebasic/djes_lwo_loader_src.zip

[Anonyme]

Impossible de tester, problème d'include puis problème de structure déjà declarer

[djes]

Ah oui, excuse, j'ai modifié. http://djes.free.fr/purebasic/djes_lwo_loader_src.zip

[tonton]

j ai regardé ton code mon caporal,
tu utilise les meme matrice pour les objet et pour la camera.
y en a pas bon.....
pour les objet touche a rien. pour la matrice camera, faut remplace par la matrice que je t ai donné.

de plus t as gardé ca:

""""
Procedure Projection()
For i = 0 To #Max_Facettes
Point2D(i)\x=(Point3D(i)\x*256)/(Point3D(i)\z+#Zoff)+#Xoff;
Point2D(i)\y=(Point3D(i)\y*256)/(Point3D(i)\z+#Zoff)+#Yoff;
Next i
EndProcedure ."""

il faut me virer ca....., la matrice camera gere la perpective en elle meme.

je vais essayé de fusionné nos deux programmes, bien que je tousses avec purebasic, mais faut bien s y metre un jour.

[Anonyme]

Merci , tonton , c'est bien ce qu'il me semblait !
je cherchais dans ton code la formule de projection, j'ai vu que tu traite l'info directement sur la matrice, je vais en faire de meme, je vais en chier pour comprendre d'ou sorte toutes tes variables
je vais faire des tests, si cela est concluant, je met le code pour qu'il soit compréhensible de tous, puis je diffuse sur le forum.

@Djes, j'ai vu l'include OpenGL, Fonctionne t'il ? car je ne vois que les objet en wireframe.


En tout cas merci encore

[tonton]

j ai rajouter un commentaire sur les variables de la matrice, sur mon code
du dessus ,sur ce sujet.

[Anonyme]

Merci tonton, t'on aide m'est précieuse