Vol libre dans un champ d'étoiles

[G-Rom]

notamment la partie en rouge , je ne m'étonne pas que sur mon NC10
(qui n'as pas de carte graph 3D) , ça rame !!

il n'y aurai pas moyen de pré-calculer (prédessiner...),la position des etoiles
au lieu de redessiner l'immensité des étoiles de la galaxie a chaque boucle Repeat ??

je dis ça, car chez moi ton code Rame, grave de chez grave !

Si tu regarde bien le code , tu aurais vu que la boucle que tu cite ne contiens uniquement les point à l'écran , donc déjà optimisé à ce niveau.
ensuite , si tu veut améliorer les perf , utilise des sprite3D ( si ton pc le supporte ).
Sinon le but de code est de "comprendre" comment on dessine de la 3D. le tout est de comprendre qu'en réalité c'est le monde qui tourne autour de la caméra, elle , elle reste "fixe"


@Sph , bizarre...

[Backup]

Sinon le but de code est de "comprendre" comment on dessine de la 3D. le tout est de comprendre qu'en réalité c'est le monde qui tourne autour de la caméra, elle , elle reste "fixe"


@Sph , bizarre...

arg ! j'avais réedité mon post ...

le fait est que redessiner la position de l'univers, me parait plus lourds
que de redessiner la position de l'observateur seulement... non ?

mais peut etre qu'effectivement, on dois redessiner toutes les etoiles
dans le cadre de ce que vois l'observateur...

tu sais , le representation 3D n'est pas ma specialité

je pensais naivement, que les etoiles ne bougeais pas
et que c'etait l'observateur qui bouge
et que son cadre (sa vue) et seulement elle etait redessiné
et pas l'ensemble de l'univers ....

[G-Rom]

même si je bouge "que" l'observateur , il faut quand même savoir ou se trouve toutes les étoiles pour savoir ou & si ont les dessine , non ?

edit:

Après on peut encore optimisé avec un octree , mais c'est pas le but du code.

[Backup]

oui

mais peut etre seulement dans le Cadre de sa vue, peut etre pas besoin de redessiner
l'univers entier non ? (enfin je te redis, je n'y connais rien )

[G-Rom]

Comment tu détermine le cadre de la vue sans parcourir toutes les étoiles?
essaye d'ajouté un pseudo octree , tu découpes le monde 3D en cubes , dans chaque cubes il y a des étoiles.
si le cube est visible , tu calcules la positions des étoiles.

[Backup]

Comment tu détermine le cadre de la vue sans parcourir toutes les étoiles?
essaye d'ajouté un pseudo octree , tu découpes le monde 3D en cubes , dans chaque cubes il y a des étoiles.
si le cube est visible , tu calcules la positions des étoiles.

je sais pas moi, peut etre un truc tout con qui pourrait marcher

chaque etoile tu la numerote
et si cette etoile est dans le cadre de l'observateur (l'ecran)
tu l'affiche
sinon, tu l'affiche pas !
(lorsque je dis tu l'affiche , je veux dire, tu prends en compte son existance)

de toute façon toutes etoiles en dehors du cadre observateur (ecran), ne dois pas etre affichée ça sert pas

alors bien sur, apres on peut décider de mettre un filtre par rapport a la distance de l'observateur
a partir d'une certaine distance, on affiche pas ! meme si c'est dans le cadre
(c'est ce qui se passe dans les FPS "effet brouillard")

enfin jdis ça, je repete, je n'y connais rien du tout


comment je sais si l'etoile est dans l'ecran ?
ben plusieurs solutions

1 une mise a jour permanente de la position par rapport a l'observateur
(aussi lourd que de tout redessiner)

2 un angle part de l'observateur
et on determine si l'etoile est dans cet angle ou pas ...
angle qui sera la largeur (hauteur) de la résolution
et de la profondeur de l'effet brouillard cité ci dessus

ne me demande pas comment, j'y connais rien

[G-Rom]

En gros , donc , tu reproduis se que j'ai codé plus haut
le problème en 3D , c'est que les positions des étoiles sont exprimées en coordonnées spatiale par rapport à l'origine du monde 3D
le monde origine commence en 0,0,0. Tout les objets on des positions par rapport à l'origine , même la caméra.
au moment du rendu , on bouge l'origine du monde à la position de la caméra, toute les étoiles sont donc affecté par se mouvement , ensuite on applique la rotation de la caméra. , ensuite on parcours les étoiles , qui eux on aussi leur propres mouvements , on applique les translations , les rotations.
Avec tout les mouvements & rotation , les objets on des nouvelles positions ( l'origine à bougé , les objets on bougé eux mêmes , etc... ).
les positions sont par rapport à la caméra , et non plus par rapport à l'origine 0,0,0 ( qui à bougé )
Tu as ensuite plusieurs possibilité pour le rendu:

- Tu découpes ton monde en un gros cube , qui lui même possèdes d'autres cube , qui eux même en possède d'autres , c'est un octree :



Tu appliques les transformation ( mouvement & rotation ) à ton octree , couplé à un frustum culling* , tu détermines quel cube de ton octree tu voit , chaque octree possède une liste d'étoiles qui sont à l'intérieur ( à déterminé lors de la création de l'étoile OctreeX = PositionX / Taille Octree , etc..)
tu n'auras donc qu'a parcourir quelques élément de ton octree pour savoir se qui est visible ou non :




ne te laisse pas impressionné par la complexité des images , c'est très simple en fait.

frustum culling : c'est une sorte de cone fait à partir de la position de la camera , du fov , de la vue proche et lointaine maximum , à partir de là on construit
6 plans , un des plan correspond à ton écran , le plan plus loin à ton écran toujours mais éloigné , les autres le bas & haut & les coté.
Suivant la "normale" des plans , on détermine si un objet est dans le champ de vision.



voila. dis moi que tu as compris , j'ai pas envie de codé tout ca ^^

[Backup]

je peux pas affirmer que j'ai tout compris

mais je pense que ton code rame chez moi
parce qu'il doit y avoir de nombreuses etoiles qui sont prises en compte
dans ton code, alors meme qu'elle ne sont pas visibles a l'ecran .

c'est sur ce point précis, que j'essaie d'attirer ton attention

je ne suis pas assez doué en 3D, mais intuitivement, je sent
que ton code, rame sur mon ordi, parceque trop d'informations sont traitées
(meme les étoiles qui ne sont pas a l'ecran)

mon NC10 est capable de faire tourner des jeux comme

Medal of honor Allied Assault
Quake
Quake 2
Quake 3
Counter Strike 1.6
Call Of Duty
Duke Nukem 3d
Alien Versus Predator
Alien Versus Predator 2
Unreal Tournament
Unreal Tournament 2004 (donc surement le 2003)
Halo (avec baisse de framerate important selon endroit mais tourne aux environts de 20/25fps)
Max Payne
GTA
GTA 2
GTA 3

quand meme !! (et sans carte graphique 3D !!)

et la ton code ,Rame grave , juste a cause de 5000 petites étoiles
c'est donc, que pleins d'informations sont pris en compte
inutilement....

je regrette d'etre une bille en 3D

mais , il me semble que ton code, a quelque chose qui déconne
Merci pour tes explications

[G-Rom]

mais , il me semble que ton code, a quelque chose qui déconne
Merci pour tes explications

Non , ca ne "déconne" pas.
Comme je te l'ai dis , on optimise via un octree+frustum culling , pour traité que les partie "visible" par lot , mais ce n'est pas le but du code.
ici , je parle de projection , une méthode employé dans de nombreux moteur 3D.
je vais te faire un petit package pour que tu comprennes bien.

[djes]

La lenteur du code n'a rien à voir avec le nombre d'étoiles affichées ou pas. Ca vient plutôt des milliers d'allocations/libérations de mémoire à chaque boucle...

[Backup]

ha !! bah c'est ptete ça qui deconne

[G-Rom]

La lenteur du code n'a rien à voir avec le nombre d'étoiles affichées ou pas. Ca vient plutôt des milliers d'allocations/libérations de mémoire à chaque boucle...

?

Regarde les sources d'un moteur 3D , tu verras que beaucoup de traitement est effectuer par le CPU , le GPU est utilisé pour la rasterization qui est plus long que tout le reste.

[djes]

Regarde mieux, tu verras qu'aucun moteur digne de ce nom ne ferait une allocation par point, en plus dans la boucle d'affichage! Tu alloues au départ un espace mémoire pour tes vertex que tu remplis au fur et à mesure, avec à la rigueur une nouvelle allocation si tu dépasses ton buffer, et tu ne fais pas confiance à l'OS. Nous on est sur Windows, n'oublie pas!!!!

[G-Rom]

Regarde mieux le code:

ClearList(StarsRendering())

la liste StarsRendering() ne contient que les points à afficher.
sa taille est variable en fonction du nombre de point visible. , on l'efface car on repart avec une liste vierge.

matrix4_identity(*MATRIX_MODELVIEW)
matrix4_translate(*MATRIX_MODELVIEW,CamX,CamY,CamZ)
matrix4_rotate(*MATRIX_MODELVIEW,CamPitch,1,0,0)
matrix4_rotate(*MATRIX_MODELVIEW,CamYaw ,0,1,0)
matrix4_rotate(*MATRIX_MODELVIEW,CamRoll ,0,0,1)

*MATRICE_PROJVIEW.matrix4 = matrix4(*MATRICE_PROJECTION)

matrix4_multiply(*MATRICE_PROJVIEW,*MATRIX_MODELVIEW)

On met à jour les matrices de rotation , la seule allocation est l'avant dernière ligne ( 16 floats )

C'est ici qu'il faut optimisé , car là on parcours toute les étoiles , il faudrais mettre en place un octree
pour ne pas à avoir à parcourir toute les étoiles.

For i = 0 To #NB_STAR-1
matrix4_identity(@Star(i)\mat_view)
matrix4_translate(@Star(i)\mat_view,Star(i)\position\x,Star(i)\position\y,Star(i)\position\z)

*MATRIX_MODELPROJ.matrix4 = matrix4(@Star(i)\mat_view)

Encore une allocation de 16 floats. puis projection à l'écran , le résultat part dans *ScreenCoordinate ( 3 floats)

matrix4_multiply(*MATRICE_PROJVIEW,*MATRIX_MODELPROJ)
;On projette :
*ScreenCoordinate.vector3 = matrix4_coordinate(*MATRICE_PROJVIEW,@Star(i)\position)
*ScreenCoordinate\x * 0.5 / *ScreenCoordinate\z + 0.5
*ScreenCoordinate\y * 0.5 / *ScreenCoordinate\z + 0.5
*ScreenCoordinate\x * ScreenW
*ScreenCoordinate\y * ScreenH

Si le point est visible , on l'ajoute à la liste d'étoiles à rendre.
nous ne somme pas encore dans la boucle de rendu

If *ScreenCoordinate\z>1
If *ScreenCoordinate\x>0 And *ScreenCoordinate\x<ScreenW-1 And *ScreenCoordinate\y>0 And *ScreenCoordinate\y<ScreenH-1
AddElement(StarsRendering())
StarsRendering()\ScreenCoordinate\x = *ScreenCoordinate\x
StarsRendering()\ScreenCoordinate\y = *ScreenCoordinate\y
StarsRendering()\ScreenCoordinate\z = *ScreenCoordinate\z
EndIf
EndIf

free_vector3(*ScreenCoordinate)
Next

on efface se dont l'on a plus besoin , et on commence à mettre des plots
(Remplace avec des sprites 3D , tu verras que c'est plus rapide )
et on parcours la liste d'étoile à rendre , pas besoin de testé si plot() est dans l'écran
on l'a déjà fait plus haut.

free_matrix4(*MATRICE_PROJVIEW)

StartDrawing(ScreenOutput())
ForEach StarsRendering()
Plot(StarsRendering()\ScreenCoordinate\x,StarsRendering()\ScreenCoordinate\y,$FFFFFF)
Next
StopDrawing()

Regarde mieux, tu verras qu'aucun moteur digne de ce nom ne ferait une allocation par point

Tu te mélanges les pinceaux , ici , il n'est pas question de vertex , mais considère l'étoile comme un objet à part entière.
donc , chaque objet à son propre espace , et oui je suis au courant qu'un moteur3D n'alloue pas une/des matrice(s) par vertex...
j'ai pas commencer la 3D hier
je rappelle encore une fois qu'il est question de projection. pas de technique d'occlusion.

[djes]

Moi, je n'ai jamais parlé que du problème de lenteur. Et le problème de lenteur vient de ces lignes, répétées autant de fois qu'il y d'étoiles, soit 5000 fois :

Ligne 408 :

Code : Tout sélectionner

*MATRIX_MODELPROJ.matrix4 = matrix4(@Star(i)\mat_view)

qui renvoie à

Code : Tout sélectionner

ProcedureDLL.i matrix4(*pointer=#Null)
  *m.matrix4 = AllocateMemory(SizeOf(matrix4))
  
  If *pointer<>#Null
    CopyMemory(*pointer,@*m\m,64)
  EndIf 
  
  ProcedureReturn *m  
EndProcedure

Ligne 412 :

Code : Tout sélectionner

*ScreenCoordinate.vector3 = matrix4_coordinate(*MATRICE_PROJVIEW,@Star(i)\position)

Code : Tout sélectionner

ProcedureDLL.i matrix4_coordinate(*m.matrix4,*v.vector3)
  *temp.vector3 = AllocateMemory(SizeOf(vector3))
   *temp\x = *v\x * *m\m[0] + *v\y * *m\m[4] + *v\z * *m\m[8]  + *m\m[12]
   *temp\y = *v\x * *m\m[1] + *v\y * *m\m[5] + *v\z * *m\m[9]  + *m\m[13]
   *temp\z = *v\x * *m\m[2] + *v\y * *m\m[6] + *v\z * *m\m[10] + *m\m[14]
  ProcedureReturn *temp
EndProcedure

+ les lignes correspondant à la libération mémoire

C'est l'OS qui gère ces allocations/libérations. Windows est une mule. Vire ça et tu auras une vitesse normale (5000 étoiles sur un PC moderne c'est de la roupie de sansonnet). Sur Linux c'est peut-être fluide, mais pas avec Windows.

Pour le reste, je m'en contrefous, j'ai juste parlé du problème de lenteur, je ne me permettrais pas de parler de la 3D