PureBasic

Je résiste pas quand je vois "2D" donc je viens foutre un peu le bordel ^^

J'ai pas envie d'entrer dans le débat mais je voulais juste signaler qu'on ne fait en pratique pas de tests de performances avec le debugger. On recueille plutôt les infos pour les afficher ensuite (la solution la plus simple pour moi étant le messageRequester) .

Déjà que les tests de performances sont biaisés en conditions réelles (on ne maîtrise ni le taux d'occupation de la machine cible ni ses performances) avec le debugger on grimpe beaucoup plus haut dans l'imprécision.

Dri

PS. je répète bien que je n'entre pas dans le débat de fond

et pour info , votre flou , ça porte un nom

c'est le Motion blur !

ça vous aidera dans vos recherches internet

ici quelques demos dont le fameux cube blur

http://pagesperso-orange.fr/josh83/demoz/3dengfr.htm

Huitbit a écrit :Intéressant tout ça...
Je ne savait pas qu'il y avait tout ça derrière un petit delay() !

Quant à l'article
http://www.nofrag.com/2003/nov/24/8629/
Cet effet de flou est tel qu'au cinéma, 18 images par seconde suffisent à rendre les mouvements fluides
Un bon sprite est un sprite flou
Ce concept est révolutionnaire!
Un graphiste en a-t-il déjà tenu compte lors de la création de ses planches de sprites ?

Hasta la vista !

2000 images seconde, çà va pas être facile avec notre matos !

quand tu fait une planche de sprites, faut que tout soit bien net... la 2D est une chose, la 3D en est une autre et le sujet du post est: Performance d'un jeu en 2D. Donc l'idéal c'est d'avoir une image en mouvement aussi net que lorsqu'elle est en pause... Et là y a un os.

Parce qu'un écran lcd, faut exactement la même résolution de l'écran, et tout le monde n'a pas la même taille. Donc en mode graphique et une carte pas dernier cri, c'est flou.

En mode fenêtre, j'ai l'impression qu'il y a une très légère saccade, même à 58 i/s. Le joueur s'en fiche parce que c'est insignifiant, mais c'est pas fluide, fluide quoi( comme sur console pour cité Djes).

Mais bon, c'est l'aspiration de tout artiste: atteindre la perfection...

ça va dépendre de ce qui va être conçu, en fait...

Des fois, le graphisme doit être parfait. D'autre fois, il n'y a pas besoin : le jeux fait son chemin quand même...

J'ai testé le jeu de tonton. Il a quand même assuré le bougre!

Dobro a écrit :et pour info , votre flou , ça porte un nom

c'est le Motion blur !

ça vous aidera dans vos recherches internet

ici quelques demos dont le fameux cube blur

http://pagesperso-orange.fr/josh83/demoz/3dengfr.htm

Oui tu as raison, appelons un chat un chat

On en parle surtout en 3D, l'implémentation en 2D n'est pas répandue; je me demande ce que ça donnerait.

Dr. Dri a écrit : je répète bien que je n'entre pas dans le débat de fond

trop tard, tu as déjà mis un doigt dans ce rouage infernal

Ollivier a écrit :J'ai testé le jeu de tonton. Il a quand même assuré le bougre!

mise à jour( gestion joypad). Il a organisé les data de façon déconcertante, moi qui voulais modifier le design des vaisseaux, c'est rapé.

la version d'origine, les tirs vont beaucoup plus loin...
http://www.youtube.com/watch?v=yyxeU2PVdoQ
... et la téléportation, c'est salvateur.

yo! beauregard!
la longueur du tir est etabli par nombre de trame

cherche un "nb_trame=50"

je livrerai tantot, le secret du vaisseau.

tonton a écrit :yo! beauregard!
la longueur du tir est etabli par nombre de trame

cherche un "nb_trame=50"

je livrerai tantot, le secret du vaisseau.

bien, c'est mieux en augmentant la valeur de cette variable, et aussi celle pour la vitesse des tirs( le vaisseau allait plus vite que ces derniers, çà faisait bizarre)

Pour la téléportation du vaisseau dans une zone vide de l'écran, c'est un petit casse tête, alors je te laisse faire

Cpl.Bator a écrit :vous vous barrez dans des complications...
vos écrans sont limité en nombres d'images par secondes (un écran à 60hz , livre 60 images secondes) donc inutile d'inverser les buffers 100,120,300x par secondes... autant gardé le temps CPU pour faire autre chose , rendre la main à l'OS , faire marché vos algos , etc...

Je te quote mais ce n'est pas dans le but de te reprendre ou de te démontrer le contraire, et puis sur le sujet les Tontons et Djes en savent un rayon, bien au-delà de ce que j'ai pu voir. (je me demande si ce n'est pas eux qui parlaient de driver dédié & mode superviseur pour des animations à la "VBL")

Pour moi, c'est bien la synchronisation qui compte, la précision de l'intervalle entre les frames. Biensur il faut atteindre un frame rate équivalent au refresh écran, mais tout de fois 58 FPS ou 64 FPS à 60 Hz ce n'est pas "fluide". (comme sur une bonne vieille console, une arcade, un Amiga ou autre

) Edit: j'utilise depuis peu Powerstrip pour être en 50Hz avec les emulateurs. Le reste du temps, à 60 Hz l'écran est en fait à 59.884Hz. (peut être même variable)

Quelque part ce n'est jamais réelement fluide sur un OS comme Windows, on remarque quand même de petites fluctuations, surtout avec des trucs old school qui ne font pas de cadeaux.
Couleur contrastée à mort (genre pure RGB à O ou 255) graphismes au pixel précis et tranchant sur fond noir, et scrolling linéaire avec si possible du parallaxe pour bien mettre en évidence le problème. (multiscroller, starfield etc)

Il y a longtemps j'avais lu un commentaire de l'excellent codeur/musicien des Farbraush, Kebby. Je ne prétend pas comprendre le truc mais ce qu'il disait (l'idée principale) rejoingnait un peu ce qui avait été dit ici, noyer le truc dans du blur. (Ce qui va bien en 3D)

Dernièrement j'ai remarqué qu'en mode fenêtré je n'arrivais pas à me débarrasser des saccades si je met le moindre Delay(1) ou plus
(Néanmoins il y en a encore, bien plus qu'en mode fullscreen)

J'ai noté que d'autre personnes laissaient 50% d'util de l'UC pour de petites animations (des anims old school en C++ et OpenGL en mode fenetré) quitte a se faire charrier par le type qui va regarder le gestionnaire des taches.

Cela dit ce n'est pas le genre d'application qu'on lance en même temps qu'un Cubase ou autre truc bien lourd.

Buckethead a écrit :Dernièrement j'ai remarqué qu'en mode fenêtré je n'arrivais pas à me débarrasser des saccades si je met le moindre Delay(1) ou plus
(Néanmoins il y en a encore, bien plus qu'en mode fullscreen)

Pour ma part, ma réflexion se base sur des choses bêtes. Il y a 20 ans, le Sudoku n'existait pas! Et bien que l'on puisse ne pas aimer cette catégorie de jeu, ce serait se voiler la face que de ne pas admettre qu'il y a eu un succès massif mondial en terme d'amusement, avec un bras d'honneur à la technologie informatique qui double de puissance tous les deux ans (La technologie était suffisante pour créer un "créateur de grille" en 1980!).

Alors qu'en est-il d'afficher une animation qui se met à jour "seulement" 30 fois par secondes? Dans cet ensemble de moyens qui peut sembler "rétro" à côté des 120 FPS et autres, il y a quand même carrément de quoi s'amuser!

Je n'ai pas le temps mais le jeu de Tonton est un support facilement "accélérable". Je ne vous apprends pas grand chose à vous dire qu'il suffit de prendre l'exemple 3D de Comtois, pour saisir que la plus "merdique" des cartes vidéo actuelles libère suffisamment de ressources du CPU central pour allier qualité de défilement et partage des tâches (=fiabilité et stabilité de l'OS, même si sous Linux, on s'en fout!).

Si ce code ci-dessous en 3D est suffisamment fluide, la 2D est jouable. Pour le Blur Motion 2D (merci Dobro pour le rappel!), il n'y a pas besoin de lourd: le lissage des texture s'en charge très bien!

(Ne pas oublier de rajouter directx9 dans Menu>Compiler>Compiler options>Library sub-system, sinon ça ne marchera pas...)

Code : Tout sélectionner

;PB 4.30 le 10/01/09 (Comtois) 

InitEngine3D()
InitSprite()
InitKeyboard()

;Pour enregistrer au format PNG
UsePNGImageEncoder()

ExamineDesktops()
;OpenScreen(DesktopWidth(0), DesktopHeight(0), DesktopDepth(0), "Tutoriel 3D")
OpenWindow(0, 0, 0, DesktopWidth(0), DesktopHeight(0), "", $80000000)
OpenWindowedScreen(WindowID(0), 0, 0, DesktopWidth(0), DesktopHeight(0), 0, 0, 0)

;Pour charger une texture, mesh, entity , etc, indiquer le chemin où se trouvent ces médias
Add3DArchive("/", #PB_3DArchive_FileSystem)

Enumeration
  #VueDessus
  #VueArriere
  #VueCote
  #VueAvant
EndEnumeration

Global Angle.f, Vitesse.f
Define.l Options, ModeCamera, i

ModeCamera = #VueArriere

Macro NEW_X(x, Angle, Distance)
  ((x) + Cos((Angle) * 0.0174533) * (Distance))
EndMacro

Macro NEW_Z(z, Angle, Distance)
  ((z) - Sin((Angle) * 0.0174533) * (Distance))
EndMacro

;- Declaration des procédures
Declare.f CurveValue(actuelle.f, Cible.f, P.f)
Declare GestionCamera(Mode.l)

;-Mesh
#Mesh = 0
CreateMesh(#Mesh, 100)
Options = #PB_Mesh_Vertex | #PB_Mesh_Normal | #PB_Mesh_Color | #PB_Mesh_UVCoordinate
SetMeshData(#Mesh, Options      , ?Sommets, 24)
SetMeshData(#Mesh, #PB_Mesh_Face, ?Triangles, 12)

;-Textures
#Texture = 0
CreateImage(#Texture, 64, 64)

;Remplissage de la texture en blanc
StartDrawing(ImageOutput(#Texture))
Box(0, 0, ImageWidth(#Texture), ImageHeight(#Texture), $FFFFFF)
DrawingMode(#PB_2DDrawing_Outlined) ; Pour tracer le contour
Box(0, 0, ImageWidth(#Texture), ImageHeight(#Texture), 0)
StopDrawing()

;Enregistre l'image dans le même répertoire que le code source
Fichier$="TextureDVP1.PNG"
SaveImage(#Texture, Fichier$, #PB_ImagePlugin_PNG)

;Maintenant on peut charger notre texture
LoadTexture(#Texture, Fichier$)


#TextureSol = 1
CreateImage(#TextureSol, 128, 128)

;Remplissage de la texture en blanc
StartDrawing(ImageOutput(#TextureSol))
Box(0, 0, ImageWidth(#TextureSol), ImageHeight(#TextureSol), $FFFFFF)
For i = 0 To 127 Step 10
  Line(i, 0, 0, ImageHeight(#TextureSol), $0000FF)
  Line(0, i, ImageWidth(#TextureSol), 0, $0000FF)
Next i

DrawingMode(#PB_2DDrawing_Outlined) ; Pour tracer le contour
Box(0, 0, ImageWidth(#TextureSol), ImageHeight(#TextureSol), $000088)
StopDrawing()


;Enregistre l'image dans le même répertoire que le code source
Fichier$="TextureDVP2.PNG"
SaveImage(#TextureSol, Fichier$, #PB_ImagePlugin_PNG)

;Maintenant on peut charger notre texture
LoadTexture(#TextureSol, Fichier$)

;-Matière
#Matiere = 0
CreateMaterial(#Matiere, TextureID(#Texture))

#MatiereSol = 1
CreateMaterial(#MatiereSol, TextureID(#TextureSol))

;-Entity
#Entity = 0
CreateEntity(#Entity, MeshID(#Mesh), MaterialID(#Matiere))
ScaleEntity(#Entity, 10, 10, 10) ; Agrandi l'entity
EntityLocate(#Entity, 500, 5, 500)

#EntitySol = 1
CreateEntity(#EntitySol, MeshID(#Mesh), MaterialID(#MatiereSol))
ScaleEntity(#EntitySol, 1000, 2, 1000) ; Agrandi l'entity
EntityLocate(#EntitySol, 500, -5, 500)

;-Camera
#Camera = 0
CreateCamera(#Camera, 0, 0, 100, 100)

;-Light
AmbientColor(RGB(55,55,55)) ; Réduit la lumière ambiante pour mieux voir les lumières
#LightRouge = 0 : CreateLight(#LightRouge,RGB(255, 0, 0),    0, 500,    0)
#LightBleue = 1 : CreateLight(#LightBleue,RGB(0, 0, 255),    0, 500, 1000)
#LightVerte = 2 : CreateLight(#LightVerte,RGB(0, 255, 0), 1000, 500, 1000)

;- Sprite pour afficher l'aide


;- Petit échauffement pour éviter un claquage...
CreateSprite(64000, 256, 24)
   StartDrawing(SpriteOutput(64000) )
      DrawText(0, 0, "Please wait...", #White, #Black)
   StopDrawing()
   For i = 0 To 1 << 8
      ExamineKeyboard()
      FrameRate = Engine3DFrameRate(#PB_Engine3D_Current)
      CameraLocate(#Camera, Px, Py, Pz)
      CameraLookAt(#Camera, EntityX(#Entity), EntityY(#Entity), EntityZ(#Entity))
      RenderWorld()
      DisplayTransparentSprite(64000, 0, 0)
      FlipBuffers()
   Next
FreeSprite(64000)
Delay(100)
;- Démarrage
Repeat
  Delay(1)
;  Delay(1)
;  Delay(1)
  FrameRate = Engine3DFrameRate(#PB_Engine3D_Current)
  Vitesse = 240 / FrameRate
  If Vitesse > 10: Vitesse = 10: EndIf
  If ExamineKeyboard()
    ;Change la vue de la caméra
    If KeyboardReleased(#PB_Key_F1)
      ModeCamera = #VueDessus
    ElseIf KeyboardReleased(#PB_Key_F2)
      ModeCamera = #VueArriere
    ElseIf KeyboardReleased(#PB_Key_F3)
      ModeCamera = #VueCote
    ElseIf KeyboardReleased(#PB_Key_F4)
      ModeCamera = #VueAvant
    EndIf

    If KeyboardPushed(#PB_Key_Left)
      Angle + Vitesse
      RotateEntity(#Entity, 0, Angle, 0, #PB_Absolute)
    ElseIf KeyboardPushed(#PB_Key_Right)
      Angle - Vitesse
      RotateEntity(#Entity, 0, Angle, 0, #PB_Absolute)
    EndIf
   
    If KeyboardPushed(#PB_Key_Up)
      MoveEntity(#Entity, NEW_X(0, Angle , Vitesse), 0, NEW_Z(0, Angle, Vitesse))
    ElseIf KeyboardPushed(#PB_Key_Down)
      MoveEntity(#Entity, NEW_X(0, Angle , -Vitesse), 0, NEW_Z(0, Angle, -Vitesse))
    EndIf

  EndIf

  GestionCamera(ModeCamera)

  RenderWorld()

  FlipBuffers()

Until KeyboardPushed(#PB_Key_Escape)


Procedure.f CurveValue(actuelle.f, Cible.f, P.f)
  ;Calcule une valeur progressive allant de la valeur actuelle à la valeur cible
  Define.f Delta
  Delta = Cible - actuelle
  If P > 1000.0 : P = 1000.0 : EndIf
  ProcedureReturn  (actuelle + ( Delta * P / 1000.0))
EndProcedure

Procedure GestionCamera(Mode.l)
  Define.f Px, Py, Pz, Pv
  Static AngleCamera.f

  Pv = 25 * (60 / Engine3DFrameRate(#PB_Engine3D_Current) )

  Select Mode

    Case #VueDessus
      AngleCamera = CurveValue(AngleCamera, Angle + 180, Pv)
      Px = CurveValue(CameraX(#Camera), NEW_X(EntityX(#Entity), AngleCamera, 40), Pv)
      Py = CurveValue(CameraY(#Camera), EntityY(#Entity) + 140, Pv)
      Pz = CurveValue(CameraZ(#Camera), NEW_Z(EntityZ(#Entity), AngleCamera, 40), Pv)

    Case #VueArriere
      AngleCamera = CurveValue(AngleCamera, Angle + 180, Pv)
      Px = CurveValue(CameraX(#Camera), NEW_X(EntityX(#Entity), AngleCamera, 80), Pv)
      Py = CurveValue(CameraY(#Camera), EntityY(#Entity) + 40, Pv)
      Pz = CurveValue(CameraZ(#Camera), NEW_Z(EntityZ(#Entity), AngleCamera, 80), Pv)

    Case #VueCote
      AngleCamera = CurveValue(AngleCamera, Angle + 120, Pv)
      Px = CurveValue(CameraX(#Camera), NEW_X(EntityX(#Entity), AngleCamera, 80), Pv)
      Py = CurveValue(CameraY(#Camera), EntityY(#Entity) + 40, Pv)
      Pz = CurveValue(CameraZ(#Camera), NEW_Z(EntityZ(#Entity), AngleCamera, 80), Pv)

    Case #VueAvant
      AngleCamera = CurveValue(AngleCamera, Angle, Pv)
      Px = CurveValue(CameraX(#Camera), NEW_X(EntityX(#Entity), AngleCamera, 80), Pv)
      Py = CurveValue(CameraY(#Camera), EntityY(#Entity) + 40, Pv)
      Pz = CurveValue(CameraZ(#Camera), NEW_Z(EntityZ(#Entity), AngleCamera, 80), Pv)

  EndSelect

  CameraLocate(#Camera, Px, Py, Pz)
  CameraLookAt(#Camera, EntityX(#Entity), EntityY(#Entity), EntityZ(#Entity))
EndProcedure


;{ Définition du cube
DataSection
  Sommets:
  ;Dessus 0 à 3
  Data.f -0.5,0.5,-0.5
  Data.f 0,1,0
  Data.l 0
  Data.f 0,0

  Data.f 0.5,0.5,-0.5
  Data.f 0,1,0
  Data.l 0
  Data.f 0,1

  Data.f 0.5,0.5,0.5
  Data.f 0,1,0
  Data.l 0
  Data.f 1,1

  Data.f -0.5,0.5,0.5
  Data.f 0,1,0
  Data.l 0
  Data.f 1,0

  ;Dessous 4 à 7
  Data.f -0.5,-0.5,0.5
  Data.f 0,-1,0
  Data.l 0
  Data.f 0,0

  Data.f 0.5,-0.5,0.5
  Data.f 0,-1,0
  Data.l 0
  Data.f 0,1

  Data.f 0.5,-0.5,-0.5
  Data.f 0,-1,0
  Data.l 0
  Data.f 1,1

  Data.f -0.5,-0.5,-0.5
  Data.f 0,-1,0
  Data.l 0
  Data.f 1,0

  ;Devant 8 à 11
  Data.f -0.5,0.5,0.5
  Data.f 0,0,1
  Data.l 0
  Data.f 0,0

  Data.f 0.5,0.5,0.5
  Data.f 0,0,1
  Data.l 0
  Data.f 0,1

  Data.f 0.5,-0.5,0.5
  Data.f 0,0,1
  Data.l 0
  Data.f 1,1

  Data.f -0.5,-0.5,0.5
  Data.f 0,0,1
  Data.l 0
  Data.f 1,0

  ;Derrière 12 à 15
  Data.f 0.5,0.5,-0.5
  Data.f 0,0,-1
  Data.l 0
  Data.f 0,0

  Data.f -0.5,0.5,-0.5
  Data.f 0,0,-1
  Data.l 0
  Data.f 0,1

  Data.f -0.5,-0.5,-0.5
  Data.f 0,0,-1
  Data.l 0
  Data.f 1,1

  Data.f 0.5,-0.5,-0.5
  Data.f 0,0,-1
  Data.l 0
  Data.f 1,0

  ;Cote gauche 16 à 19
  Data.f -0.5,0.5,-0.5
  Data.f -1,0,0
  Data.l 0
  Data.f 0,0

  Data.f -0.5,0.5,0.5
  Data.f -1,0,0
  Data.l 0
  Data.f 0,1

  Data.f -0.5,-0.5,0.5
  Data.f -1,0,0
  Data.l 0
  Data.f 1,1

  Data.f -0.5,-0.5,-0.5
  Data.f -1,0,0
  Data.l 0
  Data.f 1,0

  ;Cote droit 20 à 23
  Data.f 0.5,0.5,0.5
  Data.f 1,0,0
  Data.l 0
  Data.f 0,0

  Data.f 0.5,0.5,-0.5
  Data.f 1,0,0
  Data.l 0
  Data.f 0,1

  Data.f 0.5,-0.5,-0.5
  Data.f 1,0,0
  Data.l 0
  Data.f 1,1

  Data.f 0.5,-0.5,0.5
  Data.f 1,0,0
  Data.l 0
  Data.f 1,0

  Triangles:
  ;Face en Haut
  Data.w 2,1,0
  Data.w 0,3,2
  ;Face en Bas
  Data.w 6,5,4
  Data.w 4,7,6
  ;Face Avant
  Data.w 10,9,8
  Data.w 8,11,10
  ;Face Arrière
  Data.w 14,13,12
  Data.w 12,15,14
  ;Face Gauche
  Data.w 18,17,16
  Data.w 16,19,18
  ;Face Droite
  Data.w 22,21,20
  Data.w 20,23,22
EndDataSection
;}

L'autre jour, avec vers l'infini, j'étais à 36% temps cpu, et cette nuit chuis à 8% seulement... c'est bizarre. Je dois fatiguer, là... je met Delay à 1, amusant, encore 8% je comprend plus. Sans delay, osons oser...ah ! 99% ouf ! mmh... à moins que c'est parce que j'ai mis dirextx9, mais c'est sur l'autre code source, mmhgrml...

hop, je décide de tester avec le jeu de ma vie, et le delay(12), il ne le digère pas. Mais un delay(4) s'avère être un bon digestif( 70% temps cpu).

Ma petite conclusion, c'est qu'il faudrait une commande qui fusionne les 2 commande flipbuffer et delay-> flipbufferdelay() qui s'occuperai de maintenir un bon framerate tout seul, comme un grand.

Ollivier a écrit :Je n'ai pas le temps mais le jeu de Tonton est un support facilement "accélérable".

il n'utilise pas de sprite. il n'utilise pas de delay, comme moi... jusqu'à ton intervention et celle de norswap, ce qui m'a fait me remettre en question. J'ai mis la version mode fenêtre avec un delay, résultat 30% temps cpu.
La 4.30 gère peut être mieux ou différement les choses ?...

En tout cas, pour le code que tu viens de mettre, c'est du 2% maxi. Tiens, un delay(100) avant repeat, c'est curieux çà ! Avec la 3D, ce delay(100) est une belle curiosité... mmh, j'imagine que ce delay(100) donne de la stabilité ?...

là, un code sans sprite aussi, avec un beau delay( 8 ):
http://www.purebasic.fr/german/viewtopi ... c&start=20

Sur mon dernier code (animation en fenêtre) : 50% CPU et 5% avec un Delay(1) mais par contre une belle saccade environ toutes les 15 frames.

Le problème c'est en premier lieu la saccade, et pas le fait que ca tourne à 30 FPS. Tout de même ca me chagrinerais d'afficher un petit scrolling à 30 FPS avec un Core duo @ 3GHz.
Biensur avec les animations en 3D on le remarque moins, tout comme avec un vieux plasma en 2D.

Un exemple très simple qui saccade chez moi avec le delay(1) (que j'ai ôté en bas du code)

Code : Tout sélectionner

; Test
InitSprite()
hwnd=OpenWindow(1,0,0,800,600,"test", #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget  ) 
OpenWindowedScreen (hwnd,0,0,800,600,0,0,0)

Dim x(120) : Dim v(120)
For y = 0 To 120
 x(y) = Random(800) : v(y) = 1 + Random(4)
Next y

Repeat
ClearScreen(0) 

StartDrawing(ScreenOutput())
 For y = 0 To 120
  x(y) = x(y) + v(y)
   If x(y) > 800 : x(y) = 0 : EndIf
  c = 100 +v(y) * 25
  Box(x(y), 5*y, v(y), v(y) ,RGB(c,c,c))
 Next y
StopDrawing()

If WindowEvent() = #PB_Event_CloseWindow : End : EndIf

;Delay(1) ;*

FlipBuffers(1)
ForEver

normal que ça saccade !!

un delay() doit se mettre APRES un flipbuffer ! pas avant !

si vous aviez fait du Stos basic, vous sauriez cela !!

parcequ'en Stos on manipulais directement le buffer de fond des sprites,
buffer video vu, et buffer video calculé ...

le flipbufer c'est un swap entre la memoire video calculé (celle ou se dessine le sprite) , et la memoire video affiché (celle qu'on vois..)

si tu met un delay() avant le swap, c'est normal qu'il y est une petite saccade
puisque tu empeche l'ecran d'apparaitre !!

met ton delay apres, tu verra

comme ça :

Code : Tout sélectionner


; Test
InitSprite()
hwnd=OpenWindow(1,0,0,800,600,"test", #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget  )
OpenWindowedScreen (hwnd,0,0,800,600,0,0,0)

Dim x(120) : Dim v(120)
For y = 0 To 120
    x(y) = Random(800) : v(y) = 1 + Random(4)
Next y

Repeat
    
    
    StartDrawing(ScreenOutput())
        For y = 0 To 120
            x(y) = x(y) + v(y)
            If x(y) > 800 : x(y) = 0 : EndIf
            c = 100 +v(y) * 25
            Box(x(y), 5*y, v(y), v(y) ,RGB(c,c,c))
        Next y
    StopDrawing()
    
    If WindowEvent() = #PB_Event_CloseWindow : End : EndIf
    
   
    
    FlipBuffers(1)
    ClearScreen(0)
     Delay(10) ;*
ForEver

de plus logiquement on met le clearscreen après l'affichage
puisque après l'affichage on met un coup de balais sur l'écran pour préparer le prochain travail

beaucoup on tendance a commencer par nettoyer avant de dessiner
personnellement je trouve plus logique de balayer ma surface de travail a la fin du travail

parce que c'est pas très malin d'arriver au boulot et de commencer a passer le balais

autre chose !!

les sprites sont pas la pour faire jolis !!

là tu dessine des box directement a l'écran !!

tu a choisi la technique la plus lente qui soit !!

si tu avait fait des sprites , tu aurai pu voir la difference !!

voici ton exemple , en utilisant les sprites !!

(1001 sprites pour te montrer que ça va quand meme mieux !!

)

Structure sprite
    x.l
    y.l
    vitesse.l
EndStructure
nbr_sprite=1000
Dim sprite.sprite(nbr_sprite)

; Test
InitSprite ()
EcranX = GetSystemMetrics_ ( #SM_CXSCREEN )
EcranY = GetSystemMetrics_ ( #SM_CYSCREEN )

hwnd= OpenWindow (1,0,0,EcranX,EcranY, "test" , #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget )
OpenWindowedScreen ( WindowID (1),0,0,EcranX,EcranY,0,0,0)

; *********** prepare les parametres de chaque sprite *****************
For t=0 To nbr_sprite
    sprite(t)\x = Random (EcranX)+1
    sprite(t)\y= Random (EcranY)+1
    sprite(t)\vitesse= Random (4)+1
   CreateSprite (t, sprite(t)\vitesse, sprite(t)\vitesse)
     ; dessine le sprite
StartDrawing ( SpriteOutput (t))
     Box (0,0, sprite(t)\vitesse, sprite(t)\vitesse, RGB ( Random (100)+100, Random (100)+100, Random (100)+100))
StopDrawing ()

Next t
; ***************************************************************
Repeat

     For t= 0 To nbr_sprite
         DisplaySprite (t,sprite(t)\x,sprite(t)\y)

        sprite(t)\x=sprite(t)\x+sprite(t)\vitesse
         If sprite(t)\x>EcranX
            sprite(t)\x=0
         EndIf

     Next t



     If WindowEvent () = #PB_Event_CloseWindow : End : EndIf



     FlipBuffers ( #PB_Screen_SmartSynchronization )
     ClearScreen (0)
      Delay (1) ;*
ForEver