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/`.
37 intrude import geometry
::points_and_lines
# For _x, _y and _z
39 import matrix
::projection
40 import more_collections
41 import performance_analysis
44 intrude import gamnit
::cameras
45 intrude import gamnit
::cameras_cache
46 import gamnit
::dynamic_resolution
47 import gamnit
::limit_fps
48 import gamnit
::camera_control
50 # Visible 2D entity in the game world or UI
52 # Similar to `gamnit::Actor` which is in 3D.
54 # Each sprite associates a `texture` to the position `center`.
55 # The appearance is modified by `rotation`, `invert_x`,
56 # `scale`, `red`, `green`, `blue` and `alpha`.
57 # These values can be changed at any time and will trigger an update
58 # of the data on the GPU side, having a small performance cost.
60 # For a sprite to be visible, it must be added to either the world `sprites`
61 # or the `ui_sprites`.
62 # However, an instance of `Sprite` can only belong to a single `SpriteSet`
63 # at a time. The final on-screen position depends on the camera associated
67 # # Load texture and create sprite
68 # var texture = new Texture("path/in/assets.png")
69 # var sprite = new Sprite(texture, new Point3d[Float](0.0, 0.0, 0.0))
71 # # Add sprite to the visible game world
72 # app.sprites.add sprite
74 # # Extra configuration of the sprite
75 # sprite.rotation = pi/2.0
78 # # Show only the blue colors
83 # To add a sprite to the UI it can be anchored to screen borders
84 # with `ui_camera.top_left` and the likes.
87 # # Place it a bit off the top left of the screen
88 # var pos = app.ui_camera.top_left.offset(128.0, -128.0, 0)
90 # # Load texture and create sprite
91 # var texture = new Texture("path/in/assets.png")
92 # var sprite = new Sprite(texture, pos)
94 # # Add it to the UI (above world sprites)
95 # app.ui_sprites.add sprite
99 # Texture drawn to screen
100 var texture
: Texture is writable(texture_direct
=)
102 # Texture drawn to screen
103 fun texture
=(value
: Texture)
105 if isset _texture
and value
!= texture
then
107 if value
.root
!= texture
.root
then needs_remap
109 texture_direct
= value
112 # Center position of this sprite in world coordinates
113 var center
: Point3d[Float] is writable(center_direct
=), noautoinit
115 # Center position of this sprite in world coordinates
116 fun center
=(value
: Point3d[Float]) is autoinit
do
117 if isset _center
and value
!= center
then
119 center
.sprites_remove
self
122 value
.sprites_add
self
123 center_direct
= value
126 # Rotation on the Z axis, positive values turn counterclockwise
127 var rotation
= 0.0 is writable(rotation_direct
=)
129 # Rotation on the Z axis, positive values turn counterclockwise
130 fun rotation
=(value
: Float)
132 if isset _rotation
and value
!= rotation
then needs_update
133 rotation_direct
= value
136 # Mirror `texture` horizontally, inverting each pixel on the X axis
137 var invert_x
= false is writable(invert_x_direct
=)
139 # Mirror `texture` horizontally, inverting each pixel on the X axis
140 fun invert_x
=(value
: Bool)
142 if isset _invert_x
and value
!= invert_x
then needs_update
143 invert_x_direct
= value
146 # Scale applied to this sprite
148 # The basic size of `self` depends on the size in pixels of `texture`.
149 var scale
= 1.0 is writable(scale_direct
=)
151 # Scale applied to this sprite
153 # The basic size of `self` depends on the size in pixels of `texture`.
154 fun scale
=(value
: Float)
156 if isset _scale
and value
!= scale
then needs_update
160 # Red tint applied to `texture` on draw
161 fun red
: Float do return tint
[0]
163 # Red tint applied to `texture` on draw
164 fun red
=(value
: Float)
166 if isset _tint
and value
!= red
then needs_update
170 # Green tint applied to `texture` on draw
171 fun green
: Float do return tint
[1]
173 # Green tint applied to `texture` on draw
174 fun green
=(value
: Float)
176 if isset _tint
and value
!= green
then needs_update
180 # Blue tint applied to `texture` on draw
181 fun blue
: Float do return tint
[2]
183 # Blue tint applied to `texture` on draw
184 fun blue
=(value
: Float)
186 if isset _tint
and value
!= blue
then needs_update
190 # Transparency applied to `texture` on draw
191 fun alpha
: Float do return tint
[3]
193 # Transparency applied to `texture` on draw
194 fun alpha
=(value
: Float)
196 if isset _tint
and value
!= alpha
then needs_update
200 # Tint applied to `texture` on draw
202 # Alternative to the accessors `red, green, blue & alpha`.
203 # Changes inside the array do not automatically set `needs_update`.
205 # Require: `tint.length == 4`
206 var tint
: Array[Float] = [1.0, 1.0, 1.0, 1.0] is writable(tint_direct
=)
208 # Tint applied to `texture` on draw, see `tint`
209 fun tint
=(value
: Array[Float])
211 if isset _tint
and value
!= tint
then needs_update
215 # Is this sprite static and added in bulk?
217 # Set to `true` to give a hint to the framework that this sprite won't
218 # change often and that it is added in bulk with other static sprites.
219 # This value can be ignored in the prototyping phase of a game and
220 # added only when better performance are needed.
221 var static
= false is writable(static_direct
=)
223 # Is this sprite static and added in bulk? see `static`
224 fun static
=(value
: Bool)
226 if isset _static
and value
!= static
then needs_remap
227 static_direct
= value
230 # Request an update on the CPU
232 # This is called automatically on modification of any value of `Sprite`.
233 # However, it can still be set manually if a modification can't be
234 # detected or by subclasses.
238 if c
== null then return
239 if c
.last_sprite_to_update
== self then return
240 c
.sprites_to_update
.add
self
241 c
.last_sprite_to_update
= self
244 # Request a resorting of this sprite in its sprite list
246 # Resorting is required when `static` or the root of `texture` changes.
247 # This is called automatically when such changes are detected.
248 # However, it can still be set manually if a modification can't be
249 # detected or by subclasses.
253 if l
!= null then l
.sprites_to_remap
.add
self
256 # Current context to which `self` was sorted
257 private var context
: nullable SpriteContext = null
260 private var context_index
: Int = -1
262 # Current context to which `self` belongs
263 private var sprite_set
: nullable SpriteSet = null
267 # Default graphic program to draw `sprites`
268 private var simple_2d_program
= new Simple2dProgram is lazy
270 # Camera for world `sprites` and `depth::actors` with perspective
272 # By default, the camera is configured to a height of 1080 units
273 # of world coordinates at `z == 0.0`.
274 var world_camera
: EulerCamera is lazy
do
275 var camera
= new EulerCamera(app
.display
.as(not null))
277 # Aim for full HD pixel resolution at level 0
278 camera
.reset_height
1080.0
284 # Camera for `ui_sprites` using an orthogonal view
285 var ui_camera
= new UICamera(app
.display
.as(not null)) is lazy
287 # World sprites drawn as seen by `world_camera`
288 var sprites
: Set[Sprite] = new SpriteSet
290 # UI sprites drawn as seen by `ui_camera`, over world `sprites`
291 var ui_sprites
: Set[Sprite] = new SpriteSet
293 # Main method to refine in clients to update game logic and `sprites`
294 fun update
(dt
: Float) do end
296 # Display `texture` as a splash screen
298 # Load `texture` if needed and resets `ui_camera` to 1080 units on the Y axis.
299 fun show_splash_screen
(texture
: Texture)
303 var splash
= new Sprite(texture
, ui_camera
.center
.offset
(0.0, 0.0, 0.0))
304 ui_sprites
.add splash
306 var display
= display
307 assert display
!= null
308 glClear gl_COLOR_BUFFER_BIT
309 frame_core_ui_sprites display
312 ui_sprites
.remove splash
316 # Support and implementation
318 # Main clock used to count each frame `dt`, lapsed for `update` only
319 private var clock
= new Clock is lazy
321 # Performance clock to for `frame_core_draw` operations
322 private var perf_clock_main
= new Clock
324 # Second performance clock for smaller operations
325 private var perf_clock_sprites
= new Clock is lazy
331 var display
= display
332 assert display
!= null
334 var gl_error
= glGetError
335 assert gl_error
== gl_NO_ERROR
else print_error gl_error
338 var program
= simple_2d_program
339 program
.compile_and_link
341 var gamnit_error
= program
.error
342 assert gamnit_error
== null else print_error gamnit_error
345 gl
.capabilities
.blend
.enable
346 glBlendFunc
(gl_SRC_ALPHA
, gl_ONE_MINUS_SRC_ALPHA
)
349 gl
.capabilities
.depth_test
.enable
350 glDepthFunc gl_LEQUAL
353 # Prepare viewport and background color
354 glViewport
(0, 0, display
.width
, display
.height
)
355 glClearColor
(0.0, 0.0, 0.0, 1.0)
357 gl_error
= glGetError
358 assert gl_error
== gl_NO_ERROR
else print_error gl_error
361 for tex
in all_root_textures
do
363 gamnit_error
= tex
.error
364 if gamnit_error
!= null then print_error gamnit_error
366 glTexParameteri
(gl_TEXTURE_2D
, gl_TEXTURE_MIN_FILTER
, gl_LINEAR
)
367 glTexParameteri
(gl_TEXTURE_2D
, gl_TEXTURE_MAG_FILTER
, gl_LINEAR
)
374 simple_2d_program
.delete
377 var display
= display
378 if display
!= null then display
.close
381 redef fun on_resize
(display
)
385 world_camera
.mvp_matrix_cache
= null
386 ui_camera
.mvp_matrix_cache
= null
388 # Update all sprites in the UI
389 for sprite
in ui_sprites
do sprite
.needs_update
392 redef fun frame_core
(display
)
395 var gl_error
= glGetError
396 assert gl_error
== gl_NO_ERROR
else print_error gl_error
398 # Update game logic and set sprites
399 perf_clock_main
.lapse
400 var dt
= clock
.lapse
.to_f
402 sys
.perfs
["gamnit flat update client"].add perf_clock_main
.lapse
404 # Draw and flip screen
405 frame_core_draw display
409 gl_error
= glGetError
410 assert gl_error
== gl_NO_ERROR
else print_error gl_error
413 # Draw the whole screen, all `glDraw...` calls should be executed here
414 protected fun frame_core_draw
(display
: GamnitDisplay)
416 frame_core_dynamic_resolution_before display
418 perf_clock_main
.lapse
419 frame_core_world_sprites display
420 perfs
["gamnit flat world_sprites"].add perf_clock_main
.lapse
422 frame_core_ui_sprites display
423 perfs
["gamnit flat ui_sprites"].add perf_clock_main
.lapse
425 frame_core_dynamic_resolution_after display
428 private fun frame_core_sprites
(display
: GamnitDisplay, sprite_set
: SpriteSet, camera
: Camera)
430 var simple_2d_program
= app
.simple_2d_program
431 simple_2d_program
.use
432 simple_2d_program
.mvp
.uniform camera
.mvp_matrix
438 # Draw world sprites from `sprites`
439 protected fun frame_core_world_sprites
(display
: GamnitDisplay)
441 frame_core_sprites
(display
, sprites
.as(SpriteSet), world_camera
)
444 # Draw UI sprites from `ui_sprites`
445 protected fun frame_core_ui_sprites
(display
: GamnitDisplay)
447 # Reset only the depth buffer
448 glClear gl_DEPTH_BUFFER_BIT
450 frame_core_sprites
(display
, ui_sprites
.as(SpriteSet), ui_camera
)
456 # Vertices coordinates of the base geometry
458 # Defines the default width and height of related sprites.
459 private var vertices
: Array[Float] is lazy
do
462 return [-0.5*w
, 0.5*h
, 0.0,
468 # Coordinates of this texture on the `root` texture, in `[0..1.0]`
469 private var texture_coords
: Array[Float] is lazy
do
472 var b
= offset_bottom
480 # Coordinates of this texture on the `root` texture, inverting the X axis
481 private var texture_coords_invert_x
: Array[Float] is lazy
do
484 var b
= offset_bottom
493 # Graphic program to display simple models with a texture, translation, rotation and scale
494 private class Simple2dProgram
495 super GamnitProgramFromSource
497 redef var vertex_shader_source
= """
498 // Vertex coordinates
499 attribute vec4 coord;
502 attribute vec4 color;
504 // Vertex translation
505 attribute vec4 translation;
508 attribute float scale;
510 // Vertex coordinates on textures
511 attribute vec2 tex_coord;
513 // Model view projection matrix
517 attribute vec4 rotation_row0;
518 attribute vec4 rotation_row1;
519 attribute vec4 rotation_row2;
520 attribute vec4 rotation_row3;
524 return mat4(rotation_row0, rotation_row1, rotation_row2, rotation_row3);
527 // Output to the fragment shader
528 varying vec4 v_color;
529 varying vec2 v_coord;
533 gl_Position = (vec4(coord.xyz * scale, 1.0) * rotation() + translation)* mvp;
537 """ @ glsl_vertex_shader
539 redef var fragment_shader_source
= """
540 precision mediump float;
542 // Does this object use a texture?
543 uniform bool use_texture;
545 // Texture to apply on this object
546 uniform sampler2D texture0;
548 // Input from the vertex shader
549 varying vec4 v_color;
550 varying vec2 v_coord;
555 gl_FragColor = v_color * texture2D(texture0, v_coord);
556 if (gl_FragColor.a <= 0.01) discard;
558 gl_FragColor = v_color;
561 """ @ glsl_fragment_shader
563 # Vertices coordinates
564 var coord
= attributes
["coord"].as(AttributeVec4) is lazy
566 # Should this program use the texture `texture`?
567 var use_texture
= uniforms
["use_texture"].as(UniformBool) is lazy
569 # Visible texture unit
570 var texture
= uniforms
["texture0"].as(UniformSampler2D) is lazy
572 # Coordinates on the textures, per vertex
573 var tex_coord
= attributes
["tex_coord"].as(AttributeVec2) is lazy
575 # Color tint per vertex
576 var color
= attributes
["color"].as(AttributeVec4) is lazy
578 # Translation applied to each vertex
579 var translation
= attributes
["translation"].as(AttributeVec4) is lazy
581 # Rotation matrix, row 0
582 var rotation_row0
= attributes
["rotation_row0"].as(AttributeVec4) is lazy
584 # Rotation matrix, row 1
585 var rotation_row1
= attributes
["rotation_row1"].as(AttributeVec4) is lazy
587 # Rotation matrix, row 2
588 var rotation_row2
= attributes
["rotation_row2"].as(AttributeVec4) is lazy
590 # Rotation matrix, row 3
591 var rotation_row3
= attributes
["rotation_row3"].as(AttributeVec4) is lazy
594 var scale
= attributes
["scale"].as(AttributeFloat) is lazy
596 # Model view projection matrix
597 var mvp
= uniforms
["mvp"].as(UniformMat4) is lazy
600 redef class Point3d[N
]
602 # Associate each point to its sprites
604 private var sprites
: nullable Array[Sprite] = null
606 private fun sprites_add
(sprite
: Sprite)
608 var sprites
= sprites
609 if sprites
== null then
610 sprites
= new Array[Sprite]
611 self.sprites
= sprites
616 private fun sprites_remove
(sprite
: Sprite)
618 var sprites
= sprites
619 assert sprites
!= null
620 sprites
.remove sprite
624 # Notify `sprites` on attribute modification
626 private fun needs_update
628 var sprites
= sprites
629 if sprites
!= null then for s
in sprites
do s
.needs_update
634 if isset _x
and v
!= x
then needs_update
640 if isset _y
and v
!= y
then needs_update
646 if isset _z
and v
!= z
then needs_update
651 redef class OffsetPoint3d
654 if isset _x
and v
!= x
then needs_update
660 if isset _y
and v
!= y
then needs_update
666 if isset _z
and v
!= z
then needs_update
671 # Set of sprites sorting them into different `SpriteContext`
672 private class SpriteSet
673 super HashSet[Sprite]
675 # Map texture then static vs dynamic to a `SpriteContext`
676 var contexts_map
= new HashMap2[RootTexture, Bool, SpriteContext]
678 # Contexts in `contexts_map`
679 var contexts_items
= new Array[SpriteContext]
681 # Sprites needing resorting in `contexts_map`
682 var sprites_to_remap
= new Array[Sprite]
684 # Add a sprite to the appropriate context
685 fun map_sprite
(sprite
: Sprite)
687 assert sprite
.context
== null else print_error
"Sprite {sprite} belongs to another SpriteSet"
689 var texture
= sprite
.texture
.root
690 var context
= contexts_map
[texture
, sprite
.static
]
692 if context
== null then
693 var usage
= if sprite
.static
then gl_STATIC_DRAW
else gl_DYNAMIC_DRAW
694 context
= new SpriteContext(texture
, usage
)
696 contexts_map
[texture
, sprite
.static
] = context
697 contexts_items
.add context
700 context
.sprites
.add sprite
701 context
.sprites_to_update
.add sprite
702 context
.last_sprite_to_update
= sprite
704 sprite
.context
= context
705 sprite
.sprite_set
= self
708 # Remove a sprite from its context
709 fun unmap_sprite
(sprite
: Sprite)
711 var context
= sprite
.context
712 assert context
!= null
713 context
.sprites
.remove sprite
715 sprite
.context
= null
716 sprite
.sprite_set
= null
719 # Draw all sprites by all contexts
722 for sprite
in sprites_to_remap
do
726 sprites_to_remap
.clear
728 for context
in contexts_items
do context
.draw
733 if contexts_items
.has
(e
.context
) then return
741 if e
isa Sprite then unmap_sprite e
744 redef fun remove_all
(e
)
746 if not has
(e
) then return
752 for sprite
in self do
753 sprite
.context
= null
754 sprite
.sprite_set
= null
757 for c
in contexts_items
do c
.destroy
763 # Context for calls to `glDrawElements`
765 # Each context has only one `texture` and `usage`, but many sprites.
766 private class SpriteContext
769 # Context config and state
771 # Only root texture drawn by this context
772 var texture
: nullable RootTexture
774 # OpenGL ES usage of `buffer_array` and `buffer_element`
775 var usage
: GLBufferUsage
777 # Sprites drawn by this context
778 var sprites
= new GroupedSprites
780 # Sprites to update since last `draw`
781 var sprites_to_update
= new Set[Sprite]
783 # Cache of the last `Sprite` added to `sprites_to_update` since the last call to `draw`
784 var last_sprite_to_update
: nullable Sprite = null
786 # Sprites that have been update and for which `needs_update` can be set to false
787 var updated_sprites
= new Array[Sprite]
789 # Buffer size to preallocate at `resize`, multiplied by `sprites.length`
791 # Require: `resize_ratio >= 1.0`
792 var resize_ratio
= 1.2
797 # OpenGL ES buffer name for vertex data
798 var buffer_array
: Int = -1
800 # OpenGL ES buffer name for indices
801 var buffer_element
: Int = -1
803 # Current capacity, in sprites, of `buffer_array` and `buffer_element`
804 var buffer_capacity
= 0
806 # C buffers used to pass the data of a single sprite
807 var local_data_buffer
= new GLfloatArray(float_per_vertex
*4) is lazy
808 var local_indices_buffer
= new CUInt16Array(indices_per_sprite
) is lazy
813 # Number of GL_FLOAT per vertex of `Simple2dProgram`
814 var float_per_vertex
: Int is lazy
do
815 # vec4 translation, vec4 color, vec4 coord,
816 # float scale, vec2 tex_coord, vec4 rotation_row*
821 # Number of bytes per vertex of `Simple2dProgram`
822 var bytes_per_vertex
: Int is lazy
do
823 var fs
= 4 # sizeof(GL_FLOAT)
824 return fs
* float_per_vertex
827 # Number of bytes per sprite
828 var bytes_per_sprite
: Int is lazy
do return bytes_per_vertex
* 4
830 # Number of vertex indices per sprite draw call (2 triangles)
831 var indices_per_sprite
= 6
836 # Allocate `buffer_array` and `buffer_element`
839 var bufs
= glGenBuffers
(2)
840 buffer_array
= bufs
[0]
841 buffer_element
= bufs
[1]
843 var gl_error
= glGetError
844 assert gl_error
== gl_NO_ERROR
else print_error gl_error
847 # Destroy `buffer_array` and `buffer_element`
850 glDeleteBuffers
([buffer_array
, buffer_element
])
851 var gl_error
= glGetError
852 assert gl_error
== gl_NO_ERROR
else print_error gl_error
858 # Resize `buffer_array` and `buffer_element` to fit all `sprites` (and more)
861 app
.perf_clock_sprites
.lapse
863 # Allocate a bit more space
864 var capacity
= (sprites
.capacity
.to_f
* resize_ratio
).to_i
866 var array_bytes
= capacity
* bytes_per_sprite
867 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
868 assert glIsBuffer
(buffer_array
)
869 glBufferData
(gl_ARRAY_BUFFER
, array_bytes
, new Pointer.nul
, usage
)
870 var gl_error
= glGetError
871 assert gl_error
== gl_NO_ERROR
else print_error gl_error
873 # GL_TRIANGLES 6 vertices * sprite
874 var n_indices
= capacity
* indices_per_sprite
875 var ius
= 2 # sizeof(GL_UNSIGNED_SHORT)
876 var element_bytes
= n_indices
* ius
877 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
878 assert glIsBuffer
(buffer_element
)
879 glBufferData
(gl_ELEMENT_ARRAY_BUFFER
, element_bytes
, new Pointer.nul
, usage
)
880 gl_error
= glGetError
881 assert gl_error
== gl_NO_ERROR
else print_error gl_error
883 buffer_capacity
= capacity
885 sys
.perfs
["gamnit flat gpu resize"].add app
.perf_clock_sprites
.lapse
888 # Update GPU data of `sprite`
889 fun update_sprite
(sprite
: Sprite)
891 var context
= sprite
.context
892 if context
!= self then return
894 var sprite_index
= sprite
.context_index
895 assert sprite_index
!= -1
899 var data
= local_data_buffer
903 data
[o
+ 0] = sprite
.center
.x
904 data
[o
+ 1] = sprite
.center
.y
905 data
[o
+ 2] = sprite
.center
.z
909 data
[o
+ 4] = sprite
.tint
[0]
910 data
[o
+ 5] = sprite
.tint
[1]
911 data
[o
+ 6] = sprite
.tint
[2]
912 data
[o
+ 7] = sprite
.tint
[3]
915 data
[o
+ 8] = sprite
.scale
918 data
[o
+ 9] = sprite
.texture
.vertices
[v
*3+0]
919 data
[o
+10] = sprite
.texture
.vertices
[v
*3+1]
920 data
[o
+11] = sprite
.texture
.vertices
[v
*3+2]
924 var texture
= texture
925 if texture
!= null then
926 var tc
= if sprite
.invert_x
then
927 sprite
.texture
.texture_coords_invert_x
928 else sprite
.texture
.texture_coords
929 data
[o
+13] = tc
[v
*2+0]
930 data
[o
+14] = tc
[v
*2+1]
935 if sprite
.rotation
== 0.0 then
936 # Cache the matrix at no rotation
937 rot
= once
new Matrix.identity
(4)
939 rot
= new Matrix.rotation
(sprite
.rotation
, 0.0, 0.0, 1.0)
941 data
.fill_from_matrix
(rot
, o
+15)
943 o
+= float_per_vertex
946 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
947 glBufferSubData
(gl_ARRAY_BUFFER
, sprite_index
*bytes_per_sprite
, bytes_per_sprite
, data
.native_array
)
949 var gl_error
= glGetError
950 assert gl_error
== gl_NO_ERROR
else print_error gl_error
959 var indices
= local_indices_buffer
960 var io
= sprite_index
*4
968 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
969 glBufferSubData
(gl_ELEMENT_ARRAY_BUFFER
, sprite_index
*6*2, 6*2, indices
.native_array
)
971 gl_error
= glGetError
972 assert gl_error
== gl_NO_ERROR
else print_error gl_error
977 # Call `resize` and `update_sprite` as needed before actual draw operation.
979 # Require: `app.simple_2d_program` and `mvp` must be bound on the GPU
982 if buffer_array
== -1 then prepare
984 assert buffer_array
> 0 and buffer_element
> 0 else
985 print_error
"Internal error: {self} was destroyed"
989 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
990 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
992 # Resize GPU buffers?
993 var update_everything
= false
994 if sprites
.capacity
> buffer_capacity
then
995 # Try to defragment first
996 var moved
= sprites
.defragment
998 if sprites
.capacity
> buffer_capacity
then
999 # Defragmentation wasn't enough, grow
1002 # We must update everything
1003 update_everything
= true
1004 for s
in sprites
.items
do if s
!= null then sprites_to_update
.add s
1006 # Just update the moved sprites
1007 for s
in moved
do sprites_to_update
.add s
1009 else if sprites
.available
.not_empty
then
1010 # Defragment a bit anyway
1011 # TODO defrag only when there's time left on a frame
1012 var moved
= sprites
.defragment
(1)
1013 for s
in moved
do sprites_to_update
.add s
1016 # Update GPU sprites data
1017 if sprites_to_update
.not_empty
or update_everything
then
1018 app
.perf_clock_sprites
.lapse
1020 if update_everything
then
1021 for sprite
in sprites
.items
do if sprite
!= null then
1022 update_sprite
(sprite
)
1025 for sprite
in sprites_to_update
do update_sprite
(sprite
)
1028 sprites_to_update
.clear
1029 last_sprite_to_update
= null
1031 sys
.perfs
["gamnit flat gpu update"].add app
.perf_clock_sprites
.lapse
1034 # Update uniforms specific to this context
1035 var texture
= texture
1036 app
.simple_2d_program
.use_texture
.uniform texture
!= null
1037 if texture
!= null then
1038 glActiveTexture gl_TEXTURE0
1039 glBindTexture
(gl_TEXTURE_2D
, texture
.gl_texture
)
1040 app
.simple_2d_program
.texture
.uniform
0
1042 var gl_error
= glGetError
1043 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1045 # Configure attributes, in order:
1046 # vec4 translation, vec4 color, float scale, vec4 coord, vec2 tex_coord, vec4 rotation_row*
1048 var p
= app
.simple_2d_program
1049 var sizeof_gl_float
= 4 # sizeof(GL_FLOAT)
1051 var size
= 4 # Number of floats
1052 glEnableVertexAttribArray p
.translation
.location
1053 glVertexAttribPointeri
(p
.translation
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1054 offset
+= size
* sizeof_gl_float
1055 gl_error
= glGetError
1056 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1059 glEnableVertexAttribArray p
.color
.location
1060 glVertexAttribPointeri
(p
.color
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1061 offset
+= size
* sizeof_gl_float
1062 gl_error
= glGetError
1063 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1066 glEnableVertexAttribArray p
.scale
.location
1067 glVertexAttribPointeri
(p
.scale
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1068 offset
+= size
* sizeof_gl_float
1069 gl_error
= glGetError
1070 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1073 glEnableVertexAttribArray p
.coord
.location
1074 glVertexAttribPointeri
(p
.coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1075 offset
+= size
* sizeof_gl_float
1076 gl_error
= glGetError
1077 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1080 glEnableVertexAttribArray p
.tex_coord
.location
1081 glVertexAttribPointeri
(p
.tex_coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1082 offset
+= size
* sizeof_gl_float
1083 gl_error
= glGetError
1084 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1087 for r
in [p
.rotation_row0
, p
.rotation_row1
, p
.rotation_row2
, p
.rotation_row3
] do
1089 glEnableVertexAttribArray r
.location
1090 glVertexAttribPointeri
(r
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1092 offset
+= size
* sizeof_gl_float
1093 gl_error
= glGetError
1094 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1098 for s
in sprites
.starts
, e
in sprites
.ends
do
1100 glDrawElementsi
(gl_TRIANGLES
, l
*indices_per_sprite
, gl_UNSIGNED_SHORT
, 2*s
*indices_per_sprite
)
1101 gl_error
= glGetError
1102 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1106 for attr
in [p
.translation
, p
.color
, p
.scale
, p
.coord
, p
.tex_coord
,
1107 p
.rotation_row0
, p
.rotation_row1
, p
.rotation_row2
, p
.rotation_row3
: Attribute] do
1108 if not attr
.is_active
then continue
1109 glDisableVertexAttribArray
(attr
.location
)
1110 gl_error
= glGetError
1111 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1114 glBindBuffer
(gl_ARRAY_BUFFER
, 0)
1115 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, 0)
1116 gl_error
= glGetError
1117 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1121 # Representation of sprite data on the GPU
1123 # The main purpose of this class is to optimize the use of contiguous
1124 # space in GPU memory. Each contiguous memory block can be drawn in a
1125 # single call. The starts index of each block is kept by `starts,
1126 # and the end + 1 by `ends`.
1128 # The data can be compressed by a call to `defragment`.
1131 # intrude import gamnit::flat
1133 # var array = new GroupedArray[String]
1134 # assert array.to_s == ""
1142 # assert array.to_s == "[a,b,c,d,e,f]"
1143 # assert array.capacity == 6
1146 # assert array.to_s == "[b,c,d,e,f]"
1149 # assert array.to_s == "[c,d,e,f]"
1152 # assert array.to_s == "[c,d,e]"
1155 # assert array.to_s == "[c][e]"
1158 # assert array.to_s == "[A][c][e]"
1161 # assert array.to_s == "[A,B,c][e]"
1164 # assert array.to_s == "[A,B,c]"
1167 # assert array.to_s == "[A,B,c,D]"
1170 # assert array.to_s == "[A,B,c,D,E]"
1171 # assert array.capacity == 6
1172 # assert array.length == 5
1179 # assert array.to_s == ""
1182 # assert array.to_s == "[a]"
1184 private class GroupedArray[E
]
1186 # Memory with actual objects, and null in empty slots
1187 var items
= new Array[nullable E
]
1189 # Number of items in the array
1192 # Number of item slots in the array
1193 fun capacity
: Int do return items
.length
1195 # List of available slots
1196 var available
= new MinHeap[Int].default
1198 # Start index of filled chunks
1199 var starts
= new List[Int]
1201 # Index of the spots after filled chunks
1202 var ends
= new List[Int]
1204 # Add `item` to the first available slot and return its index
1205 fun add
(item
: E
): Int
1209 if available
.not_empty
then
1210 # starts & ends can't be empty
1212 var i
= available
.take
1215 if i
== starts
.first
- 1 then
1216 # slot 0 free, 1 taken
1219 # slot 0 and more free
1222 else if starts
.length
>= 2 and ends
.first
+ 1 == starts
[1] then
1227 # at end of first chunk
1234 if ends
.is_empty
then
1238 return ends
.last
- 1
1241 # Remove the first instance of `item`
1244 var index
= items
.index_of
(item
)
1245 remove_at
(item
, index
)
1248 # Remove `item` at `index`
1249 fun remove_at
(item
: E
, index
: Int)
1256 for s
in starts
, e
in ends
do
1257 if s
<= i
and i
< e
then
1263 if starts
.is_empty
then
1268 else if e-1
== i
then
1269 # last item of chunk
1273 # first item of chunk
1277 ends
.insert
(ends
[ii
], ii
+1)
1279 starts
.insert
(i
+1, ii
+1)
1291 # Defragment and compress everything into a single chunks beginning at 0
1293 # Returns the elements that moved as a list.
1296 # intrude import gamnit::flat
1298 # var array = new GroupedArray[String]
1305 # assert array.to_s == "[b][d]"
1307 # var moved = array.defragment
1308 # assert moved.to_s == "[d]"
1309 # assert array.to_s == "[d,b]"
1310 # assert array.length == 2
1311 # assert array.capacity == 2
1315 # assert array.to_s == "[d,b,e,f]"
1317 fun defragment
(max
: nullable Int): Array[E
]
1319 app
.perf_clock_sprites
.lapse
1320 max
= max
or else length
1322 var moved
= new Array[E
]
1323 while max
> 0 and (starts
.length
> 1 or starts
.first
!= 0) do
1324 var i
= ends
.last
- 1
1333 if starts
.length
== 1 and starts
.first
== 0 then
1334 for i
in [length
..capacity
[ do items
.pop
1338 sys
.perfs
["gamnit flat gpu defrag"].add app
.perf_clock_sprites
.lapse
1344 var ss
= new Array[String]
1345 for s
in starts
, e
in ends
do
1348 var item
: nullable Object = items
[i
]
1349 if item
== null then item
= "null"
1351 if i
!= e-1
then ss
.add
","
1359 # Optimized `GroupedArray` to use `Sprite::context_index` and avoid using `index_of`
1360 private class GroupedSprites
1361 super GroupedArray[Sprite]
1366 item
.context_index
= index
1370 redef fun remove
(item
) do remove_at
(item
, item
.context_index
)
1373 redef class GLfloatArray
1374 private fun fill_from_matrix
(matrix
: Matrix, dst_offset
: nullable Int)
1376 dst_offset
= dst_offset
or else 0
1377 var mat_len
= matrix
.width
*matrix
.height
1378 assert length
>= mat_len
+ dst_offset
1379 native_array
.fill_from_matrix_native
(matrix
.items
, dst_offset
, mat_len
)
1383 redef class NativeGLfloatArray
1384 private fun fill_from_matrix_native
(matrix
: matrix
::NativeDoubleArray, dst_offset
, len
: Int) `{
1386 for (i = 0; i < len; i ++)
1387 self[i+dst_offset] = (GLfloat)matrix[i];