Windows 10 timer resolution - jerky movement even with _LIMIT

[IfThenOrElse]

I have been experimenting a bit and found that if I measure the time in a _GL sub (normally for open GL rendering) it seem to work the way I want it to. It's a hack-ish way of doing it and i dont know why it works, if the timer get the time from the GPU instead just because its inside the _GL sub or if the measured time just happened to be at the right place... someone might know..

I found this because I was going to try to learn how to render with open GL instead of just using putimage like Ive done so far. I have noticed that programs that use open GL seem very smooth. The one where they simulate the pandemic in particular: https://www.qb64.org/forum/index.php?topic=2827.0
The green dots simulating people moves super smooth in the open GL version that can be found some posts down the page. If you change the size of them to larger ones its really noticable.

Anyway, below is the new code I made. Since i am new to this I dont really understand why it works better, it may just be better placement of the timers and have completely nothing to do with the _GL sub per see. By the way, the 320x240 res screen is just from me experimenting as well. If I manage to make a game I will try to adjust it so i have like a native low resolution for the game and then scale it to whatever the player has as desktop. But thats for later.

Do anyone else see a difference in movement?

Code: QB64: [Select]

1. tvscreen43& = _NEWIMAGE(320, 240, 32)
2.  
3. SCREEN tvscreen43&
4. _MOUSEHIDE
5. _FULLSCREEN
6.  
7. IF _FULLSCREEN = 0 THEN _FULLSCREEN _OFF
8. CLS
9.  
10.  
11. CONST ScreenEndLeft = 0
12. CONST ScreenEndRight = 320 '1920
13. CONST ScreenEndTop = 0
14. CONST ScreenEndBottom = 240 '1080
15. CONST ScreenWidth = 320 '1920
16. CONST ScreenHeight = 240 '1080
17. CONST ScreenCenterX = (ScreenWidth / 2)
18. CONST ScreenCenterY = (ScreenHeight / 2)
19.  
20.  
21. TYPE Shot
22.     alive AS _BYTE
23.     x AS SINGLE
24.     y AS SINGLE
25.     speed AS SINGLE
26.     spriteheight AS INTEGER
27.     spritewidth AS INTEGER
28.     dir AS _BYTE
29.     angle AS SINGLE
30.     stepy AS SINGLE
31.     stepx AS SINGLE
32.     sprite AS INTEGER
33.  
34. END TYPE
35. OPTION BASE 0
36. REDIM SHARED Shots(0) AS Shot
37.  
38. 'Shot sprite
39. '8x8px
40. '(Part of code is borrowed from somewhere like a tutorial or something...).
41. ShotSpriteData:
42. DATA &HFFFC00FC,&HFFFC00FC,&HFF000000,&HFF000000,&HFF000000,&HFF000000,&HFFFC00FC,&HFFFC00FC
43. DATA &HFFFC00FC,&HFF000000,&HFFF7D8A5,&HFFF7D8A5,&HFFF7D8A5,&HFFF7D8A5,&HFF000000,&HFFFC00FC
44. DATA &HFF000000,&HFFF7D8A5,&HFFF7D8A5,&HFFFFFEFF,&HFFFFFEFF,&HFFF7D8A5,&HFFF7D8A5,&HFF000000
45. DATA &HFF000000,&HFFF7D8A5,&HFFFFFEFF,&HFFFFFEFF,&HFFFFFEFF,&HFFFFFEFF,&HFFF7D8A5,&HFF000000
46. DATA &HFF000000,&HFFF7D8A5,&HFFFFFEFF,&HFFFFFEFF,&HFFFFFEFF,&HFFFFFEFF,&HFFF7D8A5,&HFF000000
47. DATA &HFF000000,&HFFF7D8A5,&HFFF7D8A5,&HFFFFFEFF,&HFFFFFEFF,&HFFF7D8A5,&HFFF7D8A5,&HFF000000
48. DATA &HFFFC00FC,&HFF000000,&HFFF7D8A5,&HFFF7D8A5,&HFFF7D8A5,&HFFF7D8A5,&HFF000000,&HFFFC00FC
49. DATA &HFFFC00FC,&HFFFC00FC,&HFF000000,&HFF000000,&HFF000000,&HFF000000,&HFFFC00FC,&HFFFC00FC
50.  
51. RESTORE ShotSpriteData
52. FOR y = 0 TO 7: FOR x = 0 TO 7
53.         READ sprite#: PSET (x, y), sprite#
54. NEXT x: NEXT y
55. DIM SHARED shotsprite AS INTEGER
56. _SETALPHA 0, _RGB32(252, 0, 252), shotsprite%
57. shotsprite% = _NEWIMAGE(8, 8, 32)
58. _PUTIMAGE (0, 0), 0, shotsprite%
59. CLS
60.  
61.  
62. 'Set some properties of the shot
63. Shots(0).x! = 0
64. Shots(0).y! = 100
65. Shots(0).spritewidth% = 8
66. Shots(0).spriteheight% = 8
67. Shots(0).dir%% = 0
68. Shots(0).sprite% = shotsprite%
69.  
70. SCREEN tvscreen43&
71.  
72. _DISPLAYORDER _SOFTWARE , _HARDWARE
73. _GLRENDER _BEHIND
74.  
75. DIM SHARED AllowGL AS _BYTE
76. DIM SHARED endtime_gltest AS DOUBLE
77. DIM SHARED starttime_gltest AS DOUBLE
78. DIM SHARED delta_gltest AS DOUBLE
79.  
80. AllowGL%% = -1
81.  
82. DO
83.     _LIMIT 60
84.  
85.     Shots(0).x! = (Shots(0).x! + 2)
86.  
87.     IF Shots(0).x! >= (ScreenEndRight + Shots(0).spritewidth%) THEN Shots(0).x! = (ScreenEndLeft - Shots(0).spritewidth%)
88.  
89.  
90. LOOP UNTIL INKEY$ = CHR$(27)
91. _FREEIMAGE shotsprite%
92. SYSTEM
93.  
94.  
95. SUB _GL ()
96.     IF AllowGL%% = 0 THEN EXIT SUB
97.  
98.     endtime_gltest# = TIMER(0.001)
99.     starttime_gltest# = TIMER(0.001)
100.  
101.     delta_gltest# = (endtime_gltest# - starttime_gltest#)
102.  
103.     IF delta_gltest# <= (1 / 60) THEN
104.  
105.         DO
106.             delta_gltest# = (TIMER(0.001) - starttime_gltest#)
107.         LOOP UNTIL delta_gltest# >= (1 / 60)
108.         CLS
109.         _PUTIMAGE (INT(Shots(0).x!), Shots(0).y!), Shots(0).sprite%
110.         PRINT (delta_gltest# * 1000)
111.         _DISPLAY
112.  
113.     END IF
114.  
115.     '   _GLEND
116.     '    _GLFLUSH
117.  
118. END SUB
119.  

[IfThenOrElse]

Well.. the timers did not make sense, doing this is enough to wait for a while. The thing seem to be to find a balance where the "game loop" manage to do its thing and then "render" the image as fast as possible. A lot to learn...:

Code: QB64: [Select]

1.     starttime_gltest# = TIMER(0.001)
2.  
3.     DO
4.         delta_gltest# = (TIMER(0.001) - starttime_gltest#)
5.     LOOP UNTIL delta_gltest# >= (1 / 70)
6.     CLS
7.     _PUTIMAGE (INT(Shots(0).x!), Shots(0).y!), Shots(0).sprite%
8.     PRINT (delta_gltest# * 1000)
9.     _DISPLAY

Even this seem to work in the _GL sub:

Code: QB64: [Select]

1.     _DELAY (1 / 60)
2.     CLS
3.     _PUTIMAGE (INT(Shots(0).x!), Shots(0).y!), Shots(0).sprite%
4.     PRINT (delta_gltest# * 1000)
5.     _DISPLAY
6.