Ah!

Voila les petits exécutables:

http://jeannoel.roueste.free.fr/Amiga/starship6800x0.exe
http://jeannoel.roueste.free.fr/Amiga/starshipAOS4.exe
http://jeannoel.roueste.free.fr/Amiga/starshipMorphos.exe
http://jeannoel.roueste.free.fr/Amiga/starshipWarpos.exe

Et la source (attention, j'y ai rien expliqué encore, j'en referai 1 plus tard avec explications ;-) )

http://jeannoel.roueste.free.fr/Amiga/starship3d4.hws

J'explique un peux quand même, j'ai donc travaillé qu'avec des tableaux et tableau multi dimensionnel, du trie, j'ai ajouter le calcule zmoyen pour chaque triangle (sa me sert d'adresse dans les tableaux pour les coordonnées en X et Y), après le bordel dans le code, j'ai tous rassemblé dans les boucles et éliminé celles qui ne servais à rien... il reste plus que 5 boucles (sur la dizaine que j'avais mis lol)

Et je maitrise pas encore les accés mémoire, mais le but est de remplacé les tableaux par les accès direct mémoire (normalement avec hollywood on peut) et j'espère que se sera plus rapide.

Y'a un peut (bon ok, beaucoup) de clipping, mais c'est parce que j'utilise pas le Zbuffer et mon trie est plutôt simpliste, a modifier.

Par contre, il y a une distortion sur la rotation, mais je sais pas d'ou sa vient (faut encore que je cherche), petit plus, l'objet suis le pointeur de la souris ;-) (c'est nul mais sa m'éclate lol)

Amusez-vous bien avec mon code, et si vous avez des questions, biper moi

Edit: J'oublier, vous pouvez me faire un ti retour sur la vitesse, les bugs et tout le toutim (à tester sur sam460 comme sa on voi si hollywood est compatible ;-) )
Respect
Message édité par : artblink / 21-12-2010 23:53
Message édité par : artblink / 21-12-2010 23:56

tiens je croyais que tu allais te coucher à 23h ;-)
Je fais un test et je te tiens au courant....

hihihi,

Quand je suis dans un truc, c'est tjrs a fond lol... j'arrivai pas a m'endormir ;-)

4 fps sur G4@1400, quelque soit le rendu utilisé, avec ou sans antialias, quelque soit le niveau de zoom.

Ca marche bien, ça plante pas, manque juste un peu de ZBuffer effectivement.

Faudrait que je teste sur un 1200 en Amos voir combien de fois c'est plus rapide qu'Hollywood sur un G4 :)

Ou la vache....

4FPS??!!! lol

Bon, je devrais revoir ma copie :-P

J'y retourne, parceque 4FPS sur un G4!!! je suis trop déçu

Mon compteur FPS marche bien?

Respect

Bah ta machine de developpement c'est quoi? Tu as combien de FPS? A moins que tu sois sous UAE je vois pas quelle machine peut te donner un résultat fluide :-)

J'utilise une version de dév hollywood sur mon PC de dev (core2duo E4600 2,4Ghz et 4go de mémoire) et la version que j'ai posté est la plus rapide, mon PC affiche 300 Image par seconde avec mon compteur de FPS (apparait à côtés de l'objet 3D)

Mais a mon avis je m'y prend mal, je joue avec des tableaux, mais peut être que le PPC est plus habile avec les calcules ou bien la vitesse de traçage est mieux optimisé pour mon PC (GEForce 8800 GTX) ou les accès mémoire sont trop lent ou j'en sais rien en fait... :-(

J'y connais rien en processeur et architecture informatique, va falloir que je fasse des recherches sur internet.

Je suis tellement content quand je trouve des nouvelles routines et que sa marche que je les tests pas sur mon microAone et je les posts de suite.

:paf

Je vais trouvé même si je dois y passer la semaine la dessus

Vu tout ce que tu fais dans PRG et toutes les boucles qu'il y a avec les calculs de racine carrée je pense que c'est là que tu pourrais gagner du temps en optimisant (en particulier la partie avec les deux boucles imbriquées de 169 éléments.
Je pense que tu devrais tenter de chercher du côté du pseudo code que je t'avais donné pour faire un tri rapide (ou qsort en anglais). Je ne connais pas la syntaxe de la commande Sort, mais il y a peut-être moyen de l'utiliser directement pour trier ton tableau complexe puisque tu semble lui passer en paramètre le comparateur à utiliser pour déterminer la relation d'ordre entre les éléments...

Coucou alex, j'essai... mais sa merdouille, j'arrive pas à l'intégrer dans mon programme.. il doit y avoir un ti truc à faire

La j'ai réussi à à optimiser un peux, j'ai remplacé les fichiers .exe et le fichier source.

Qui peux retester pour voir.

Pour info, en C:

A=A+1 est-il plus rapide que Add A,1?
Les accés dans des tableaux sont-ils plus rapides qu'un calcule?
J'ai vu que la division pour le risc n'est pas implémenté dans se type de processeur (sur wiki) donc une division demande beaucoup de temps machine à se type de proc... c'est vrai?

Bien vu alex, quand j'enlève la commande Break, je chute a 150 FPS... c'est mon tri en Z qui transforme mon PRG en usine à gaz

Merci de votre aide ;-)

Respect
Message édité par : artblink / 23-12-2010 12:41
Message édité par : artblink / 23-12-2010 13:31

salut artblink

Réponses:

-> En C il n'y a pas d'instruction Add(), on va utiliser A++ ou A = A +1 (pour faire simple) selon le compilateur utilisé (et son optimiseur) et le processeur utilisé la rapidité peut varier.

-> Oui accéder à un tableau est plus rapide qu'un calcul (en C)

-> il est vrai que toutes les opérations ne sont pas forcément supportées par tous les processeurs. Concernant la division ne t'en fait pas le processeur sait gérer. Je pense que tu n'est pas encore arriver à ce niveau d'optimisation bas niveau (que tu ne pourras vraisemblablement pas atteindre avec un langage aussi haut niveau qu'Hollywood de toutes façons).

Sinon un rapide coup d'oeil à ton code et une rapide (petite) optimisation sans chercher à comprendre ton code :


For I=0 To 169
; régle 1 : éviter recalculer dans une boucle imbriquée des choses qui dépendent de la boucle supérieure
Local ABz=VZ[I*3+1]-VZ[I*3]
Local ACz=VZ[I*3+2]-VZ[I*3]

For T=0 To 169
If ZM[I]=Tri[T].TZM
U[0]=Tri[T].TXE1
U[1]=Tri[T].TYE1
U[2]=Tri[T].TXE2
U[3]=Tri[T].TYE2
U[4]=Tri[T].TXE3
U[5]=Tri[T].TYE3

Local ABx=U[2]-U[0]
Local ABy=U[3]-U[1]
Local ACx=U[4]-U[0]
Local ACy=U[5]-U[1]

Local Nx=ABy*ACy-ABz*ACy
Local Ny=ABz*ACx-ABx*ACz
Local Nz=ABx*ACy-ABy*ACx

Local D1=Sqrt(Nx^2+Ny^2+Nz^2)

If D1<>0
Nx=Nx/D1
Ny=Ny/D1
Nz=Nz/D1
Else
Nx=Ny=Nz=1
EndIf

; règle 2 : utiliser au maximum les variables déjà calculées
; Local A=(U[2]-U[0])*(U[5]-U[1])-(U[4]-U[0])*(U[3]-U[1])
Local A=ABx*ACy-ACx*ABy
; règle 3 : éviter de faire des successions de If quand ils sont exclusifs les uns des autres, préférer switch ou l'utilisation de ElseIf
;If Nx>0 Then couleur=$6666
;If Nx>0.1 Then couleur=$7777
;If Nx>0.2 Then couleur=$8888
;If Nx>0.3 Then couleur=$9999
;If Nx>0.4 Then couleur=$AAAA
;If Nx>0.5 Then couleur=$BBBB
;If Nx>0.6 Then couleur=$CCCC
;If Nx>0.7 Then couleur=$DDDD
;If Nx>0.8 Then couleur=$EEEE
;If Nx>0.9 Then couleur=$FFFF
If Nx>0.9 Then couleur=$FFFF
ElseIf Nx>0.8 Then couleur=$EEEE
ElseIf Nx>0.7 Then couleur=$DDDD
ElseIf Nx>0.6 Then couleur=$CCCC
ElseIf Nx>0.5 Then couleur=$BBBB
ElseIf Nx>0.4 Then couleur=$AAAA
ElseIf Nx>0.3 Then couleur=$9999
ElseIf Nx>0.2 Then couleur=$8888
ElseIf Nx>0.1 Then couleur=$7777
ElseIf Nx>0 Then couleur=$6666
If A<0 Then Polygon(CX,CY,U,3,couleur)
Break
EndIf
Next
Next

tu verras que j'ai ajouté des commentaires sur les optimisations que j'ai faites.
Une dernière remarque: l'utilisation du tableau U semble inutile, comme il n'est utilisé que dans le calcul des variables locales AB(x|y) et AC(x|y) tu pourrais t'en passer et utiliser directement l'accès au tableau Tri pour calculer ces variables.