PureBasic

djes a écrit :ATHOW> Excellent

Polux a écrit :ATHOW> très fort!!!! j'adore l'effet! c tip top!

Crystal Noir a écrit :C'est clair c'est bien foutu

Merci les gars... venant de deux développeurs de BGAmes, je jubile, là...

J'espère que le jeu final vous intéressera !

ATHOW a écrit :
djes a écrit :ATHOW> Excellent

Polux a écrit :ATHOW> très fort!!!! j'adore l'effet! c tip top!

Crystal Noir a écrit :C'est clair c'est bien foutu
Merci les gars... venant de deux développeurs de BGAmes, je jubile, là...

J'espère que le jeu final vous intéressera !

En plus, on ne s'est pas donné le mot!

j'ai booté sous windows exprès pour voir, c'est vrai que ca claque pas mal

Merci !

Question idiote : qu'est ce qui empèche la compilation/l'exécution sous Linux ?

(Je précise que je n'ai jamais fait tourner PB sous Linux, un jour peut être)

Edit : Ah ! Les sprite3D utilisent DirectX, c'est ca ?

sous linux, c'est OpenGL, et le subsystem m'empeche de faire fonctionné correctement les sprite3D...
j'ai trouvé la parade, j'utilise ma propre lib de sprite

Au lieu de rebooter, pourquoi ne pas essayer wine, je suis arrive a lancer pleins de logiciels windows sous linux encore mieux de nombreux jeux, bon je n'ai pas essayé purebasic par manque de temps, mais ca devrait le faire

j'utilise déjà Wine

, j'ai pas pensé à cela

@Cpl

J'ai vu ton lien: le code que tu avais posté est excellent pour comprendre la base de la 3D.

@Athow

C'est sanglant ton truc!

Je viens de faire la modif du code pour manipuler les angles avec la souris et les flèches de direction gauche et droite. J'ai un problème, le même que j'ai avec mon code. Il y a encore une subtilité de la 3D (une barrière dont je n'ai de nom) que l'on arrive pas à maîtriser.

Avec les flèches gauches et droite, quand on met l'angle Y à PI/2 ou -PI/2 (environ 1.6), si on bouge la souris pour faire évoluer les 2 autres angles X et Z, on voit le bug.

Code : Tout sélectionner

Structure World3D 
x.f 
y.f 
z.f 
EndStructure 

Global Dim Point3D.World3D(8) 
Global Dim Point2D.World3D(8) 
Global Dim Sommet.World3D(8) 

#Xoff = 512 
#Yoff = 384 
#Zoff = 250 

Global Dim Matrice.f(3,3) 

; /****************************************************************************/ 
; /* Rotation() : effectue la rotation des points Sommets -> Point3D           */ 
; /****************************************************************************/ 

Procedure Rotation(Xa.f,Ya.f,Za.f) 


  matrice(0,0) = Cos(Za)*Cos(Ya) 
  matrice(1,0) = Sin(Za)*Cos(Ya) 
  matrice(2,0) = -Sin(Ya) 

  matrice(0,1) = Cos(Za)*Sin(Ya)*Sin(Xa) - Sin(Za)*Cos(Xa) 
  matrice(1,1) = Sin(Za)*Sin(Ya)*Sin(Xa) + Cos(Xa)*Cos(Za) 
  matrice(2,1) = Sin(Xa)*Cos(Ya) 

  matrice(0,2) = Cos(Za)*Sin(Ya)*Cos(Xa) + Sin(Za)*Sin(Xa) 
  matrice(1,2) = Sin(Za)*Sin(Ya)*Cos(Xa) - Cos(Za)*Sin(Xa) 
  matrice(2,2) = Cos(Xa)*Cos(Ya) 
  
  
  For i = 0 To 7 
    Point3D(i)\x = matrice(0,0)*Sommet(i)\x + matrice(1,0)*Sommet(i)\y + matrice(2,0)*Sommet(i)\z 
    Point3D(i)\y = matrice(0,1)*Sommet(i)\x + matrice(1,1)*Sommet(i)\y + matrice(2,1)*Sommet(i)\z 
    Point3D(i)\z = matrice(0,2)*Sommet(i)\x + matrice(1,2)*Sommet(i)\y + matrice(2,2)*Sommet(i)\z 
  Next i  
  
EndProcedure 

Procedure Projection() 
; /****************************************************************************/ 
; /* Projection() : projette en perspective les points après rotation.        */ 
; /****************************************************************************/ 
For i = 0 To 7 
 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 

Procedure Initialiser() 
; /****************************************************************************/ 
; /* Initialiser() : initialise les coordonnees des sommets du cube           */ 
; /****************************************************************************/ 
  Sommet(0)\x = -100 : Sommet(0)\y = -100 : Sommet(0)\z = -100 
  Sommet(1)\x =  100 : Sommet(1)\y = -100 : Sommet(1)\z = -100 
  Sommet(2)\x =  100 : Sommet(2)\y =  100 : Sommet(2)\z = -100 
  Sommet(3)\x = -100 : Sommet(3)\y =  100 : Sommet(3)\z = -100 
  Sommet(4)\x =  100 : Sommet(4)\y = -100 : Sommet(4)\z =  100 
  Sommet(5)\x = -100 : Sommet(5)\y = -100 : Sommet(5)\z =  100 
  Sommet(6)\x = -100 : Sommet(6)\y =  100 : Sommet(6)\z =  100 
  Sommet(7)\x =  100 : Sommet(7)\y =  100 : Sommet(7)\z =  100 

EndProcedure 

Procedure ligne(a.l,b.l,couleur.l) 
  LineXY(Point2D(a)\x,Point2D(a)\y,Point2D(b)\x,Point2D(b)\y,couleur); 
EndProcedure 

Procedure Update() 
Static Couleur.l 

Couleur = RGB(100,100,255) 

 StartDrawing(ScreenOutput()) 
  For i = 0 To 7 

; Circle(Point2D(i)\x,Point2D(i)\y,3,Couleur) 
; 
; Locate(Point2D(i)\x,Point2D(i)\y) 
; DrawText(Str(i)) 
; 
; 
;  ligne(0,1,couleur) 
;  ligne(1,2,couleur) 
;  ligne(2,3,couleur) 
;  ligne(3,0,couleur) 
;  ligne(4,5,couleur) 
;  ligne(5,6,couleur) 
;  ligne(6,7,couleur) 
;  ligne(7,4,couleur) 
;  ligne(0,5,couleur) 
;  ligne(1,4,couleur) 
;  ligne(2,7,couleur) 
;  ligne(3,6,couleur) 


  Next i 
 StopDrawing() 
EndProcedure 





InitSprite () :InitSprite3D() : InitKeyboard () : InitMouse () 
OpenScreen (1024,768,32, "" ) 



;Création de faces (sprite3D()) 

CreateSprite(0,64,64,#PB_Sprite_Texture) 
 StartDrawing(SpriteOutput(0)) 
  Box(0,0,64,64,$82E67D) 
   StopDrawing() 
    CreateSprite3D(0,0) 

CreateSprite(1,64,64,#PB_Sprite_Texture) 
 StartDrawing(SpriteOutput(1)) 
  Box(0,0,64,64,$0552FA) 
   StopDrawing() 
    CreateSprite3D(1,1) 

CreateSprite(2,64,64,#PB_Sprite_Texture) 
 StartDrawing(SpriteOutput(2)) 
  Box(0,0,64,64,$FD0202) 
   StopDrawing() 
    CreateSprite3D(2,2) 

CreateSprite(3,64,64,#PB_Sprite_Texture) 
 StartDrawing(SpriteOutput(3)) 
  Box(0,0,64,64,$00FFFF) 
   StopDrawing() 
    CreateSprite3D(3,3) 
    
 CreateSprite(4,64,64,#PB_Sprite_Texture) 
 StartDrawing(SpriteOutput(4)) 
  Box(0,0,64,64,$FDFF02) 
   StopDrawing() 
    CreateSprite3D(4,4)    
    
 CreateSprite(5,64,64,#PB_Sprite_Texture) 
 StartDrawing(SpriteOutput(5)) 
  Box(0,0,64,64,$B3FF4C) 
   StopDrawing() 
    CreateSprite3D(5,5)    

Initialiser() 


Repeat 
  ExamineKeyboard () : ExamineMouse() : ClearScreen (0) 

  Start3D() 

  
  If KeyboardPushed(#PB_Key_Left): Yangle.f + 0.01: EndIf
  If KeyboardPushed(#PB_Key_Right): Yangle.f - 0.01: EndIf
  Zangle.F + MouseDeltaX() * 0.01
  Xangle.F + MouseDeltaY() * 0.01
  StartDrawing(ScreenOutput() )
  DrawText(0, 0, "Angle X = " + StrF(Xangle) )
  DrawText(0, 16, "Angle Y = " + StrF(Yangle) )
  DrawText(0, 32, "Angle Z = " + StrF(Zangle) )
  StopDrawing()
  
  Sprite3DQuality(1) 


  DisplaySprite3D(0,0,0) 
  DisplaySprite3D(1,0,0) 
  DisplaySprite3D(2,0,0) 
  DisplaySprite3D(3,0,0) 
  DisplaySprite3D(4,0,0) 
  DisplaySprite3D(5,0,0) 



  TransformSprite3D(0,Point2D(0)\x,Point2D(0)\Y,Point2D(1)\x,Point2D(1)\Y,Point2D(2)\x,Point2D(2)\Y,Point2D(3)\x,Point2D(3)\Y) 
  TransformSprite3D(1,Point2D(1)\x,Point2D(1)\Y,Point2D(4)\x,Point2D(4)\Y,Point2D(7)\x,Point2D(7)\Y,Point2D(2)\x,Point2D(2)\Y) 
  TransformSprite3D(2,Point2D(4)\x,Point2D(4)\Y,Point2D(5)\x,Point2D(5)\Y,Point2D(6)\x,Point2D(6)\Y,Point2D(7)\x,Point2D(7)\Y) 
  TransformSprite3D(3,Point2D(5)\x,Point2D(5)\Y,Point2D(0)\x,Point2D(0)\Y,Point2D(3)\x,Point2D(3)\Y,Point2D(6)\x,Point2D(6)\Y) 
  TransformSprite3D(4,Point2D(5)\x,Point2D(5)\Y,Point2D(4)\x,Point2D(4)\Y,Point2D(1)\x,Point2D(1)\Y,Point2D(0)\x,Point2D(0)\Y) 
  TransformSprite3D(5,Point2D(3)\x,Point2D(3)\Y,Point2D(2)\x,Point2D(2)\Y,Point2D(7)\x,Point2D(7)\Y,Point2D(6)\x,Point2D(6)\Y) 

  Rotation(Xangle,Yangle,Zangle) 
  Projection() 
  Update() 


  Stop3D() 
  FlipBuffers () 
Until KeyboardPushed ( #PB_Key_Escape )

ne te casse pas la tête avec ca, c'est le glimbal lock ( cf : exalead ou google )
tu peut résoudre le problème en utilisant les quaternions, mais cela dépasse mes compétences, le seul ici capable de te repondre correctement est je pense Tmyke ou Comtois.

En effet, c'est le fameux 'Gimbal Lock', que l'on pourrait résumer à une perte d'un degré de liberté.
Comme la matrice de rotation finale dépend de l'ordre des multiplications des axes , il est possible que
parfois, l'une des rotations autour d'un axe soit confondu avec un autre axe de rotation.

Par exemple, supposons qu'un objet ai tourné dans l'ordre Z,Y et X et que la rotation autour de Y soit de 90°.
Dans ce cas, la rotation suivant Z se fait correctement, puisque c'est la première. L'axe Y tourne également
correctement. Néanmoins, après cette rotation, l'axe X et l'axe Z sont confondus.

Du coup, toutes rotation autour de l'axe X tourne l'objet suivant Z!

La seule solution a ce problème est d'utiliser les quaternions comme le dit si bien Cpl.Baotr, mais je pense
que cela dépasse le cadre du code que tu fournis plus haut...

Pourquoi ne pas faire également tourner les axes dans ce cas? Dans un monde 3D il y a les axes locaux (un pour chaque objet), et les axes globaux (le même pour tous les objets). Faire tourner un objet par rapport aux axes globaux n'a pas de sens dans la nature (vous allez me dire la Terre : mais dans ce cas il s'agit bien d'un axe local, et il faut prendre un référentiel plus grand, le système solaire par ex).

Dans le cas des axes locaux, si tu tournes par rapport à l'axe local Y, tu fais tourner également les axes locaux X et Z. Ensuite si tu tournes par rapport à l'axe local X, tu fais tourner les axes locaux Y et Z : il n'y a donc jamais de gimbal lock. L'inconvénient est bien sûr qu'il est difficile de savoir quelle est alors l'orientation finale par rapport aux axes globaux. Je pense qu'on peut le faire avec de savants calculs, ou alors en simulant une boussole et un fil à plomb

L'autre inconvénient est qu'il y plus de calculs, mais il faut savoir ce que l'on veut.

A ce sujet, j'aimerais bien que dans la preview du modeleur de lightwave on utilise ce principe, trop souvent on bloque à cause du gimbal lock, c'est pénible! Alors qu'il n'y a pas de problèmes dans le layout...

J'ai fait fausse route!

Comme je ne comprends rien à tout le vocabulaire que employez et que je constate que vous n'avez pas d'algo derrière ces mots (ce n'est pas une critique : moi non plus je n'y pige vraiment rien) je pars de ce que je sais... pour découvrir ce que j'ignore. Et n'hésitez pas à y apporter vos observations. On essaie juste de rester dans le simple pour y arriver!

A*Je suis sur Terre;
B*Il me faut seulement 2 valeurs pour me situer sur la surface de la Terre;
C*Les géographes ont pour convention lattitude et longitude;
D*Je ne suis pas géographe;
E*Cependant, mon exemple de code sur l'ellipse plus haut répond aux critères de la règles B. J'ai donc du concret!
F*La règle B permet d'avoir un vecteur unitaire spatial Vu{Ry; Rz}
G*Multiplier Vu par un réel donne un point P dans l'espace.

H*Il me manque donc une procédure qui à partir de 3 angles de rotations Tx, Ty et Tz me donne Ry et Rz!!!!

Challenge?

j'ai rien compris

mais le problème c'est bien les quaternions , je les avais mis en application sous pb lorsque j'étais encore sous windows, mais je suis sous linux maintenant , donc j'ai plus rien de tous cela...

par contre , a partir de mon code plus haut , tu peut adapté les quaternions facilement , google code search peut t'aider aussi tu sais

Cpl.Bator a écrit :sous linux, c'est OpenGL, et le subsystem m'empeche de faire fonctionné correctement les sprite3D...
j'ai trouvé la parade, j'utilise ma propre lib de sprite

Tiens, je suis justement entrain d'en faire une pour avoir un accès identique GNU/Linux & Windows !
C'est quoi ta lib ?

PureBasic

Comme les sprite3Ds sont à la mode...