1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
7 # http://www.apache.org/licenses/LICENSE-2.0
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
15 # Simple API for 2D games, built around `Sprite` and `App::update`
17 # Client programs should implement `App::update` to execute game logic and
18 # add instances of `Sprite` to `App::sprites` and `App::ui_sprites`.
19 # At each frame, all sprites are drawn to the screen.
21 # This system relies on two cameras `App::world_camera` and `App::ui_camera`.
23 # * `App::world_camera` applies a perspective effect to draw the game world.
24 # This camera is designed to be moved around to see the world as well as to
25 # zoom in and out. It is used to position the sprites in `App::sprites`.
27 # * `App::ui_camera` is a simple orthogonal camera to display UI objects.
28 # This camera should mostly be still, it can still move for chock effects
29 # and the like. It can be used to standardize the size of the UI across
30 # devices. It is used to position the sprites in `App::ui_sprites`.
32 # See the sample game at `contrib/asteronits/` and the basic project template
33 # at `lib/gamnit/examples/template_flat/`.
37 intrude import geometry
::points_and_lines
# For _x, _y and _z
38 import matrix
::projection
39 import more_collections
40 import performance_analysis
43 import gamnit
::cameras
44 import gamnit
::dynamic_resolution
45 import gamnit
::limit_fps
47 import android_two_fingers_motion
is conditional
(android
)
49 # Draw a `texture` at `center`
51 # An instance of `Sprite` can only belong to a single `SpriteSet` at
52 # a time. The on screen position depends on the camera associated
56 # Texture drawn to screen
57 var texture
: Texture is writable(texture_direct
=)
59 # Texture drawn to screen
60 fun texture
=(value
: Texture)
62 if isset _texture
and value
!= texture
then
64 if value
.root
!= texture
.root
then needs_remap
66 texture_direct
= value
69 # Center position of this sprite in world coordinates
70 var center
: Point3d[Float] is writable(center_direct
=), noautoinit
72 # Center position of this sprite in world coordinates
73 fun center
=(value
: Point3d[Float]) is autoinit
do
74 if isset _center
and value
!= center
then
76 center
.sprites_remove
self
79 value
.sprites_add
self
83 # Rotation on the Z axis, positive values go counterclockwise
84 var rotation
= 0.0 is writable(rotation_direct
=)
86 # Rotation on the Z axis, positive values go counterclockwise
87 fun rotation
=(value
: Float)
89 if isset _rotation
and value
!= rotation
then needs_update
90 rotation_direct
= value
93 # Mirror `texture` horizontally, inverting each pixel on the X axis
94 var invert_x
= false is writable(invert_x_direct
=)
96 # Mirror `texture` horizontally, inverting each pixel on the X axis
97 fun invert_x
=(value
: Bool)
99 if isset _invert_x
and value
!= invert_x
then needs_update
100 invert_x_direct
= value
103 # Scale applied to this sprite
105 # The default size of `self` depends on the size in pixels of `texture`.
106 var scale
= 1.0 is writable(scale_direct
=)
108 # Scale applied to this sprite, see `scale`
109 fun scale
=(value
: Float)
111 if isset _scale
and value
!= scale
then needs_update
115 # Red tint applied to `texture` on draw
116 fun red
: Float do return tint
[0]
118 # Red tint applied to `texture` on draw
119 fun red
=(value
: Float)
121 if isset _tint
and value
!= red
then needs_update
125 # Green tint applied to `texture` on draw
126 fun green
: Float do return tint
[1]
128 # Green tint applied to `texture` on draw
129 fun green
=(value
: Float)
131 if isset _tint
and value
!= green
then needs_update
135 # Blue tint applied to `texture` on draw
136 fun blue
: Float do return tint
[2]
138 # Blue tint applied to `texture` on draw
139 fun blue
=(value
: Float)
141 if isset _tint
and value
!= blue
then needs_update
145 # Transparency applied to `texture` on draw
146 fun alpha
: Float do return tint
[3]
148 # Transparency applied to `texture` on draw
149 fun alpha
=(value
: Float)
151 if isset _tint
and value
!= alpha
then needs_update
155 # Tint applied to `texture` on draw
157 # Alternative to the accessors `red, green, blue & alpha`.
158 # Changes inside the array do not automatically set `needs_update`.
160 # Require: `tint.length == 4`
161 var tint
: Array[Float] = [1.0, 1.0, 1.0, 1.0] is writable(tint_direct
=)
163 # Tint applied to `texture` on draw, see `tint`
164 fun tint
=(value
: Array[Float])
166 if isset _tint
and value
!= tint
then needs_update
170 # Is this sprite static and added in bulk?
172 # Set to `true` to give a hint to the framework that this sprite won't
173 # change often and that it is added in bulk with other static sprites.
174 # This value can be ignored in the prototyping phase of a game and
175 # added only when better performance are needed.
176 var static
= false is writable(static_direct
=)
178 # Is this sprite static and added in bulk? see `static`
179 fun static
=(value
: Bool)
181 if isset _static
and value
!= static
then needs_remap
182 static_direct
= value
185 # Request an update on the CPU
187 # This is called automatically on modification of any value of `Sprite`.
188 # However, it can still be set manually if a modification can't be
189 # detected or by subclasses.
193 if c
!= null then c
.sprites_to_update
.add
self
196 # Request a resorting of this sprite in its sprite list
198 # Resorting is required when `static` or the root of `texture` changes.
199 # This is called automatically when such changes are detected.
200 # However, it can still be set manually if a modification can't be
201 # detected or by subclasses.
205 if l
!= null then l
.sprites_to_remap
.add
self
208 # Current context to which `self` was sorted
209 private var context
: nullable SpriteContext = null
211 # Current context to which `self` belongs
212 private var sprite_set
: nullable SpriteSet = null
216 # Default graphic program to draw `sprites`
217 private var simple_2d_program
= new Simple2dProgram is lazy
219 # Camera for world `sprites` and `depth::actors` with perspective
221 # By default, the camera is configured to respect the resolution
222 # of the screen in world coordinates at `z == 0.0`.
223 var world_camera
: EulerCamera is lazy
do
224 var camera
= new EulerCamera(app
.display
.as(not null))
226 # Aim for pixel resolution at level 0
233 # Camera for `ui_sprites` using an orthogonal view
234 var ui_camera
: UICamera = new UICamera(app
.display
.as(not null)) is lazy
236 # World sprites to draw as seen by `world_camera`
237 var sprites
: Set[Sprite] = new SpriteSet
239 # UI sprites to draw as seen by `ui_camera`, drawn over world `sprites`
240 var ui_sprites
: Set[Sprite] = new SpriteSet
242 # Main method to refine in clients to update game logic and `sprites`
243 fun update
(dt
: Float) do end
245 # Display `texture` as a splash screen
247 # Load `texture` if needed and resets `ui_camera` to 1080 units on the Y axis.
248 fun show_splash_screen
(texture
: Texture)
252 ui_camera
.reset_height
1080.0
254 var splash
= new Sprite(texture
, ui_camera
.center
)
255 ui_sprites
.add splash
257 var display
= display
258 assert display
!= null
259 glClear gl_COLOR_BUFFER_BIT
260 frame_core_ui_sprites display
263 ui_sprites
.remove splash
267 # Support and implementation
269 # Main clock used to count each frame `dt`, lapsed for `update` only
270 private var clock
= new Clock is lazy
272 # Performance clock to for `frame_core_draw` operations
273 private var perf_clock_main
= new Clock
275 # Second performance clock for smaller operations
276 private var perf_clock_sprites
= new Clock is lazy
282 var display
= display
283 assert display
!= null
285 var gl_error
= glGetError
286 assert gl_error
== gl_NO_ERROR
else print_error gl_error
289 var program
= simple_2d_program
290 program
.compile_and_link
292 var gamnit_error
= program
.error
293 assert gamnit_error
== null else print_error gamnit_error
296 gl
.capabilities
.blend
.enable
297 glBlendFunc
(gl_SRC_ALPHA
, gl_ONE_MINUS_SRC_ALPHA
)
300 gl
.capabilities
.depth_test
.enable
301 glDepthFunc gl_LEQUAL
304 # Prepare viewport and background color
305 glViewport
(0, 0, display
.width
, display
.height
)
306 glClearColor
(0.0, 0.0, 0.0, 1.0)
308 gl_error
= glGetError
309 assert gl_error
== gl_NO_ERROR
else print_error gl_error
312 for tex
in all_root_textures
do
314 gamnit_error
= tex
.error
315 if gamnit_error
!= null then print_error gamnit_error
317 glTexParameteri
(gl_TEXTURE_2D
, gl_TEXTURE_MIN_FILTER
, gl_LINEAR
)
318 glTexParameteri
(gl_TEXTURE_2D
, gl_TEXTURE_MAG_FILTER
, gl_LINEAR
)
325 simple_2d_program
.delete
328 var display
= display
329 if display
!= null then display
.close
332 redef fun frame_core
(display
)
334 # Prepare to draw, clear buffers
335 glClear
(gl_COLOR_BUFFER_BIT
| gl_DEPTH_BUFFER_BIT
)
338 var gl_error
= glGetError
339 assert gl_error
== gl_NO_ERROR
else print_error gl_error
341 # Update game logic and set sprites
342 perf_clock_main
.lapse
343 var dt
= clock
.lapse
.to_f
345 sys
.perfs
["gamnit flat update client"].add perf_clock_main
.lapse
347 # Draw and flip screen
348 frame_core_draw display
352 gl_error
= glGetError
353 assert gl_error
== gl_NO_ERROR
else print_error gl_error
356 # Draw the whole screen, all `glDraw...` calls should be executed here
357 protected fun frame_core_draw
(display
: GamnitDisplay)
359 frame_core_dynamic_resolution_before display
361 perf_clock_main
.lapse
362 frame_core_world_sprites display
363 perfs
["gamnit flat world_sprites"].add perf_clock_main
.lapse
365 frame_core_ui_sprites display
366 perfs
["gamnit flat ui_sprites"].add perf_clock_main
.lapse
368 frame_core_dynamic_resolution_after display
371 private fun frame_core_sprites
(display
: GamnitDisplay, sprite_set
: SpriteSet, camera
: Camera)
373 var simple_2d_program
= app
.simple_2d_program
374 simple_2d_program
.use
375 simple_2d_program
.mvp
.uniform camera
.mvp_matrix
381 # Draw world sprites from `sprites`
382 protected fun frame_core_world_sprites
(display
: GamnitDisplay)
384 frame_core_sprites
(display
, sprites
.as(SpriteSet), world_camera
)
387 # Draw UI sprites from `ui_sprites`
388 protected fun frame_core_ui_sprites
(display
: GamnitDisplay)
390 # Reset only the depth buffer
391 glClear gl_DEPTH_BUFFER_BIT
393 frame_core_sprites
(display
, ui_sprites
.as(SpriteSet), ui_camera
)
399 # Vertices coordinates of the base geometry
401 # Defines the default width and height of related sprites.
402 private var vertices
: Array[Float] is lazy
do
405 return [-0.5*w
, 0.5*h
, 0.0,
411 # Coordinates of this texture on the `root` texture, in `[0..1.0]`
412 private var texture_coords
: Array[Float] is lazy
do
415 var b
= offset_bottom
423 # Coordinates of this texture on the `root` texture, inverting the X axis
424 private var texture_coords_invert_x
: Array[Float] is lazy
do
427 var b
= offset_bottom
436 # Graphic program to display simple models with a texture, translation, rotation and scale
437 private class Simple2dProgram
438 super GamnitProgramFromSource
440 redef var vertex_shader_source
= """
441 // Vertex coordinates
442 attribute vec4 coord;
445 attribute vec4 color;
447 // Vertex translation
448 attribute vec4 translation;
451 attribute float scale;
453 // Vertex coordinates on textures
454 attribute vec2 tex_coord;
456 // Model view projection matrix
460 attribute vec4 rotation_row0;
461 attribute vec4 rotation_row1;
462 attribute vec4 rotation_row2;
463 attribute vec4 rotation_row3;
467 return mat4(rotation_row0, rotation_row1, rotation_row2, rotation_row3);
470 // Output to the fragment shader
471 varying vec4 v_color;
472 varying vec2 v_coord;
476 gl_Position = (vec4(coord.xyz * scale, 1.0) * rotation() + translation)* mvp;
480 """ @ glsl_vertex_shader
482 redef var fragment_shader_source
= """
483 precision mediump float;
485 // Does this object use a texture?
486 uniform bool use_texture;
488 // Texture to apply on this object
489 uniform sampler2D texture0;
491 // Input from the vertex shader
492 varying vec4 v_color;
493 varying vec2 v_coord;
498 gl_FragColor = v_color * texture2D(texture0, v_coord);
499 if (gl_FragColor.a <= 0.1) discard;
501 gl_FragColor = v_color;
504 """ @ glsl_fragment_shader
506 # Vertices coordinates
507 var coord
= attributes
["coord"].as(AttributeVec4) is lazy
509 # Should this program use the texture `texture`?
510 var use_texture
= uniforms
["use_texture"].as(UniformBool) is lazy
512 # Visible texture unit
513 var texture
= uniforms
["texture0"].as(UniformSampler2D) is lazy
515 # Coordinates on the textures, per vertex
516 var tex_coord
= attributes
["tex_coord"].as(AttributeVec2) is lazy
518 # Color tint per vertex
519 var color
= attributes
["color"].as(AttributeVec4) is lazy
521 # Translation applied to each vertex
522 var translation
= attributes
["translation"].as(AttributeVec4) is lazy
524 # Rotation matrix, row 0
525 var rotation_row0
= attributes
["rotation_row0"].as(AttributeVec4) is lazy
527 # Rotation matrix, row 1
528 var rotation_row1
= attributes
["rotation_row1"].as(AttributeVec4) is lazy
530 # Rotation matrix, row 2
531 var rotation_row2
= attributes
["rotation_row2"].as(AttributeVec4) is lazy
533 # Rotation matrix, row 3
534 var rotation_row3
= attributes
["rotation_row3"].as(AttributeVec4) is lazy
537 var scale
= attributes
["scale"].as(AttributeFloat) is lazy
539 # Model view projection matrix
540 var mvp
= uniforms
["mvp"].as(UniformMat4) is lazy
543 redef class Point3d[N
]
544 # Get a new `Point3d[Float]` with an offset of each axis of `x, y, z`
545 fun offset
(x
, y
, z
: Numeric): Point3d[Float]
547 return new Point3d[Float](self.x
.to_f
+x
.to_f
, self.y
.to_f
+y
.to_f
, self.z
.to_f
+z
.to_f
)
551 # Associate each point to its sprites
553 private var sprites
: nullable Array[Sprite] = null
555 private fun sprites_add
(sprite
: Sprite)
557 var sprites
= sprites
558 if sprites
== null then
559 sprites
= new Array[Sprite]
560 self.sprites
= sprites
565 private fun sprites_remove
(sprite
: Sprite)
567 var sprites
= sprites
568 assert sprites
!= null
569 sprites
.remove sprite
573 # Notify `sprites` on attribute modification
575 private fun needs_update
577 var sprites
= sprites
578 if sprites
!= null then for s
in sprites
do s
.needs_update
583 if isset _x
and v
!= x
then needs_update
589 if isset _y
and v
!= y
then needs_update
595 if isset _z
and v
!= z
then needs_update
600 # Set of sprites sorting them into different `SpriteContext`
601 private class SpriteSet
602 super HashSet[Sprite]
604 # Map texture then static vs dynamic to a `SpriteContext`
605 var contexts_map
= new HashMap2[GamnitRootTexture, Bool, SpriteContext]
607 # Contexts in `contexts_map`
608 var contexts_items
= new Array[SpriteContext]
610 # Sprites needing resorting in `contexts_map`
611 var sprites_to_remap
= new Array[Sprite]
613 # Add a sprite to the appropriate context
614 fun map_sprite
(sprite
: Sprite)
616 assert sprite
.context
== null else print_error
"Sprite {sprite} belongs to another SpriteSet"
618 var texture
= sprite
.texture
.root
619 var context
= contexts_map
[texture
, sprite
.static
]
621 if context
== null then
622 var usage
= if sprite
.static
then gl_STATIC_DRAW
else gl_DYNAMIC_DRAW
623 context
= new SpriteContext(texture
, usage
)
625 contexts_map
[texture
, sprite
.static
] = context
626 contexts_items
.add context
629 context
.sprites
.add sprite
630 context
.sprites_to_update
.add sprite
632 sprite
.context
= context
633 sprite
.sprite_set
= self
636 # Remove a sprite from its context
637 fun unmap_sprite
(sprite
: Sprite)
639 var context
= sprite
.context
640 assert context
!= null
641 context
.sprites
.remove sprite
643 sprite
.context
= null
644 sprite
.sprite_set
= null
647 # Draw all sprites by all contexts
650 for sprite
in sprites_to_remap
do
654 sprites_to_remap
.clear
656 for context
in contexts_items
do context
.draw
661 if contexts_items
.has
(e
.context
) then return
669 if e
isa Sprite then unmap_sprite e
672 redef fun remove_all
(e
)
674 if not has
(e
) then return
681 for c
in contexts_items
do c
.destroy
687 # Context for calls to `glDrawElements`
689 # Each context has only one `texture` and `usage`, but many sprites.
690 private class SpriteContext
693 # Context config and state
695 # Only root texture drawn by this context
696 var texture
: nullable GamnitRootTexture
698 # OpenGL ES usage of `buffer_array` and `buffer_element`
699 var usage
: GLBufferUsage
701 # Sprites drawn by this context
702 var sprites
= new GroupedArray[Sprite]
704 # Sprites to update since last `draw`
705 var sprites_to_update
= new Set[Sprite]
707 # Sprites that have been update and for which `needs_update` can be set to false
708 var updated_sprites
= new Array[Sprite]
710 # Buffer size to preallocate at `resize`, multiplied by `sprites.length`
712 # Require: `resize_ratio >= 1.0`
713 var resize_ratio
= 1.2
718 # OpenGL ES buffer name for vertex data
719 var buffer_array
: Int = -1
721 # OpenGL ES buffer name for indices
722 var buffer_element
: Int = -1
724 # Current capacity, in sprites, of `buffer_array` and `buffer_element`
725 var buffer_capacity
= 0
727 # C buffers used to pass the data of a single sprite
728 var local_data_buffer
= new GLfloatArray(float_per_vertex
*4) is lazy
729 var local_indices_buffer
= new CUInt16Array(indices_per_sprite
) is lazy
734 # Number of GL_FLOAT per vertex of `Simple2dProgram`
735 var float_per_vertex
: Int is lazy
do
736 # vec4 translation, vec4 color, vec4 coord,
737 # float scale, vec2 tex_coord, vec4 rotation_row*
742 # Number of bytes per vertex of `Simple2dProgram`
743 var bytes_per_vertex
: Int is lazy
do
744 var fs
= 4 # sizeof(GL_FLOAT)
745 return fs
* float_per_vertex
748 # Number of bytes per sprite
749 var bytes_per_sprite
: Int is lazy
do return bytes_per_vertex
* 4
751 # Number of vertex indices per sprite draw call (2 triangles)
752 var indices_per_sprite
= 6
757 # Allocate `buffer_array` and `buffer_element`
760 var bufs
= glGenBuffers
(2)
761 buffer_array
= bufs
[0]
762 buffer_element
= bufs
[1]
764 var gl_error
= glGetError
765 assert gl_error
== gl_NO_ERROR
else print_error gl_error
768 # Destroy `buffer_array` and `buffer_element`
771 glDeleteBuffers
([buffer_array
, buffer_element
])
772 var gl_error
= glGetError
773 assert gl_error
== gl_NO_ERROR
else print_error gl_error
779 # Resize `buffer_array` and `buffer_element` to fit all `sprites` (and more)
782 app
.perf_clock_sprites
.lapse
784 # Allocate a bit more space
785 var capacity
= (sprites
.capacity
.to_f
* resize_ratio
).to_i
787 var array_bytes
= capacity
* bytes_per_sprite
788 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
789 assert glIsBuffer
(buffer_array
)
790 glBufferData
(gl_ARRAY_BUFFER
, array_bytes
, new Pointer.nul
, usage
)
791 var gl_error
= glGetError
792 assert gl_error
== gl_NO_ERROR
else print_error gl_error
794 # GL_TRIANGLES 6 vertices * sprite
795 var n_indices
= capacity
* indices_per_sprite
796 var ius
= 2 # sizeof(GL_UNSIGNED_SHORT)
797 var element_bytes
= n_indices
* ius
798 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
799 assert glIsBuffer
(buffer_element
)
800 glBufferData
(gl_ELEMENT_ARRAY_BUFFER
, element_bytes
, new Pointer.nul
, usage
)
801 gl_error
= glGetError
802 assert gl_error
== gl_NO_ERROR
else print_error gl_error
804 buffer_capacity
= capacity
806 sys
.perfs
["gamnit flat gpu resize"].add app
.perf_clock_sprites
.lapse
809 # Update GPU data of `sprite`
810 fun update_sprite
(sprite
: Sprite)
812 var sprite_index
= sprites
.index_of
(sprite
)
813 if sprite_index
== -1 then return
817 var data
= local_data_buffer
821 data
[o
+ 0] = sprite
.center
.x
822 data
[o
+ 1] = sprite
.center
.y
823 data
[o
+ 2] = sprite
.center
.z
827 data
[o
+ 4] = sprite
.tint
[0]
828 data
[o
+ 5] = sprite
.tint
[1]
829 data
[o
+ 6] = sprite
.tint
[2]
830 data
[o
+ 7] = sprite
.tint
[3]
833 data
[o
+ 8] = sprite
.scale
836 data
[o
+ 9] = sprite
.texture
.vertices
[v
*3+0]
837 data
[o
+10] = sprite
.texture
.vertices
[v
*3+1]
838 data
[o
+11] = sprite
.texture
.vertices
[v
*3+2]
842 var texture
= texture
843 if texture
!= null then
844 var tc
= if sprite
.invert_x
then
845 sprite
.texture
.texture_coords_invert_x
846 else sprite
.texture
.texture_coords
847 data
[o
+13] = tc
[v
*2+0]
848 data
[o
+14] = tc
[v
*2+1]
853 if sprite
.rotation
== 0.0 then
854 # Cache the matrix at no rotation
855 rot
= once
new Matrix.identity
(4)
857 rot
= new Matrix.rotation
(sprite
.rotation
, 0.0, 0.0, 1.0)
859 data
.fill_from
(rot
.items
, o
+15)
861 o
+= float_per_vertex
864 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
865 glBufferSubData
(gl_ARRAY_BUFFER
, sprite_index
*bytes_per_sprite
, bytes_per_sprite
, data
.native_array
)
867 var gl_error
= glGetError
868 assert gl_error
== gl_NO_ERROR
else print_error gl_error
877 var indices
= local_indices_buffer
878 var io
= sprite_index
*4
886 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
887 glBufferSubData
(gl_ELEMENT_ARRAY_BUFFER
, sprite_index
*6*2, 6*2, indices
.native_array
)
889 gl_error
= glGetError
890 assert gl_error
== gl_NO_ERROR
else print_error gl_error
895 # Call `resize` and `update_sprite` as needed before actual draw operation.
897 # Require: `app.simple_2d_program` and `mvp` must be bound on the GPU
900 if buffer_array
== -1 then prepare
902 assert buffer_array
> 0 and buffer_element
> 0 else
903 print_error
"Internal error: {self} was destroyed"
907 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
908 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
910 # Resize GPU buffers?
911 if sprites
.capacity
> buffer_capacity
then
912 # Try to defragment first
913 var moved
= sprites
.defragment
915 if sprites
.capacity
> buffer_capacity
then
916 # Defragmentation wasn't enough, grow
919 # We must update everything
920 for s
in sprites
.items
do if s
!= null then sprites_to_update
.add s
922 # Just update the moved sprites
923 for s
in moved
do sprites_to_update
.add s
925 else if sprites
.available
.not_empty
then
926 # Defragment a bit anyway
927 # TODO defrag only when there's time left on a frame
928 var moved
= sprites
.defragment
(1)
929 for s
in moved
do sprites_to_update
.add s
932 # Update GPU sprites data
933 if sprites_to_update
.not_empty
then
934 app
.perf_clock_sprites
.lapse
936 for sprite
in sprites_to_update
do update_sprite
(sprite
)
937 sprites_to_update
.clear
939 sys
.perfs
["gamnit flat gpu update"].add app
.perf_clock_sprites
.lapse
942 # Update uniforms specific to this context
943 var texture
= texture
944 app
.simple_2d_program
.use_texture
.uniform texture
!= null
945 if texture
!= null then
946 glActiveTexture gl_TEXTURE0
947 glBindTexture
(gl_TEXTURE_2D
, texture
.gl_texture
)
948 app
.simple_2d_program
.texture
.uniform
0
950 var gl_error
= glGetError
951 assert gl_error
== gl_NO_ERROR
else print_error gl_error
953 # Configure attributes, in order:
954 # vec4 translation, vec4 color, float scale, vec4 coord, vec2 tex_coord, vec4 rotation_row*
956 var p
= app
.simple_2d_program
957 var sizeof_gl_float
= 4 # sizeof(GL_FLOAT)
959 var size
= 4 # Number of floats
960 glEnableVertexAttribArray p
.translation
.location
961 glVertexAttribPointeri
(p
.translation
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
962 offset
+= size
* sizeof_gl_float
963 gl_error
= glGetError
964 assert gl_error
== gl_NO_ERROR
else print_error gl_error
967 glEnableVertexAttribArray p
.color
.location
968 glVertexAttribPointeri
(p
.color
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
969 offset
+= size
* sizeof_gl_float
970 gl_error
= glGetError
971 assert gl_error
== gl_NO_ERROR
else print_error gl_error
974 glEnableVertexAttribArray p
.scale
.location
975 glVertexAttribPointeri
(p
.scale
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
976 offset
+= size
* sizeof_gl_float
977 gl_error
= glGetError
978 assert gl_error
== gl_NO_ERROR
else print_error gl_error
981 glEnableVertexAttribArray p
.coord
.location
982 glVertexAttribPointeri
(p
.coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
983 offset
+= size
* sizeof_gl_float
984 gl_error
= glGetError
985 assert gl_error
== gl_NO_ERROR
else print_error gl_error
988 glEnableVertexAttribArray p
.tex_coord
.location
989 glVertexAttribPointeri
(p
.tex_coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
990 offset
+= size
* sizeof_gl_float
991 gl_error
= glGetError
992 assert gl_error
== gl_NO_ERROR
else print_error gl_error
995 for r
in [p
.rotation_row0
, p
.rotation_row1
, p
.rotation_row2
, p
.rotation_row3
] do
997 glEnableVertexAttribArray r
.location
998 glVertexAttribPointeri
(r
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1000 offset
+= size
* sizeof_gl_float
1001 gl_error
= glGetError
1002 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1006 for s
in sprites
.starts
, e
in sprites
.ends
do
1008 glDrawElementsi
(gl_TRIANGLES
, l
*indices_per_sprite
, gl_UNSIGNED_SHORT
, 2*s
*indices_per_sprite
)
1009 gl_error
= glGetError
1010 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1014 for attr
in [p
.translation
, p
.color
, p
.scale
, p
.coord
, p
.tex_coord
,
1015 p
.rotation_row0
, p
.rotation_row1
, p
.rotation_row2
, p
.rotation_row3
: Attribute] do
1016 if not attr
.is_active
then continue
1017 glDisableVertexAttribArray
(attr
.location
)
1018 gl_error
= glGetError
1019 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1022 glBindBuffer
(gl_ARRAY_BUFFER
, 0)
1023 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, 0)
1024 gl_error
= glGetError
1025 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1029 # Representation of sprite data on the GPU
1031 # The main purpose of this class is to optimize the use of contiguous
1032 # space in GPU memory. Each contiguous memory block can be drawn in a
1033 # single call. The starts index of each block is kept by `starts,
1034 # and the end + 1 by `ends`.
1036 # The data can be compressed by a call to `defragment`.
1039 # var array = new GroupedArray[String]
1040 # assert array.to_s == ""
1048 # assert array.to_s == "[a,b,c,d,e,f]"
1049 # assert array.capacity == 6
1052 # assert array.to_s == "[b,c,d,e,f]"
1055 # assert array.to_s == "[c,d,e,f]"
1058 # assert array.to_s == "[c,d,e]"
1061 # assert array.to_s == "[c][e]"
1064 # assert array.to_s == "[A][c][e]"
1067 # assert array.to_s == "[A,B,c][e]"
1070 # assert array.to_s == "[A,B,c]"
1073 # assert array.to_s == "[A,B,c,D]"
1076 # assert array.to_s == "[A,B,c,D,E]"
1077 # assert array.capacity == 5
1078 # assert array.length == 5
1085 # assert array.to_s == ""
1088 # assert array.to_s == "[a]"
1090 private class GroupedArray[E
]
1092 # Memory with actual objects, and null in empty slots
1093 var items
= new Array[nullable E
]
1095 # Number of items in the array
1098 # Number of item slots in the array
1099 fun capacity
: Int do return items
.length
1102 fun index_of
(item
: E
): Int do return items
.index_of
(item
)
1104 # List of available slots
1105 var available
= new MinHeap[Int].default
1107 # Start index of filled chunks
1108 var starts
= new List[Int]
1110 # Index of the spots after filled chunks
1111 var ends
= new List[Int]
1113 # Add `item` to the first available slot
1118 if available
.not_empty
then
1119 # starts & ends can't be empty
1121 var i
= available
.take
1124 if i
== starts
.first
- 1 then
1125 # slot 0 free, 1 taken
1128 # slot 0 and more free
1131 else if starts
.length
>= 2 and ends
.first
+ 1 == starts
[1] then
1136 # at end of first chunk
1143 if ends
.is_empty
then
1149 # Remove the first instance of `item`
1152 var i
= items
.index_of
(item
)
1158 for s
in starts
, e
in ends
do
1159 if s
<= i
and i
< e
then
1165 if starts
.is_empty
then
1170 else if e-1
== i
then
1171 # last item of chunk
1175 # first item of chunk
1179 ends
.insert
(ends
[ii
], ii
+1)
1181 starts
.insert
(i
+1, ii
+1)
1193 # Defragment and compress everything into a single chunks beginning at 0
1195 # Returns the elements that moved as a list.
1198 # var array = new GroupedArray[String]
1205 # assert array.to_s == "[b][d]"
1207 # var moved = array.defragment
1208 # assert moved.to_s == "[d]"
1209 # assert array.to_s == "[d,b]"
1210 # assert array.length == 2
1211 # assert array.capacity == 2
1215 # assert array.to_s == "[d,b,e,f]"
1217 fun defragment
(max
: nullable Int): Array[E
]
1219 app
.perf_clock_sprites
.lapse
1220 max
= max
or else length
1222 var moved
= new Array[E
]
1223 while max
> 0 and (starts
.length
> 1 or starts
.first
!= 0) do
1224 var i
= ends
.last
- 1
1232 if starts
.length
== 1 and starts
.first
== 0 then
1233 for i
in [length
..capacity
[ do items
.pop
1237 sys
.perfs
["gamnit flat gpu defrag"].add app
.perf_clock_sprites
.lapse
1243 var ss
= new Array[String]
1244 for s
in starts
, e
in ends
do
1247 var item
: nullable Object = items
[i
]
1248 if item
== null then item
= "null"
1250 if i
!= e-1
then ss
.add
","