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 # Core services for the `flat` API for 2D games
19 intrude import geometry
::points_and_lines
# For _x, _y and _z
21 import matrix
::projection
22 import more_collections
23 import performance_analysis
26 intrude import gamnit
::cameras
27 intrude import gamnit
::cameras_cache
28 import gamnit
::dynamic_resolution
30 # Visible 2D entity in the game world or UI
32 # Similar to `gamnit::Actor` which is in 3D.
34 # Each sprite associates a `texture` to the position `center`.
35 # The appearance is modified by `rotation`, `invert_x`,
36 # `scale`, `red`, `green`, `blue` and `alpha`.
37 # These values can be changed at any time and will trigger an update
38 # of the data on the GPU side, having a small performance cost.
40 # For a sprite to be visible, it must be added to either the world `sprites`
41 # or the `ui_sprites`.
42 # However, an instance of `Sprite` can only belong to a single `SpriteSet`
43 # at a time. The final on-screen position depends on the camera associated
47 # # Load texture and create sprite
48 # var texture = new Texture("path/in/assets.png")
49 # var sprite = new Sprite(texture, new Point3d[Float](0.0, 0.0, 0.0))
51 # # Add sprite to the visible game world
52 # app.sprites.add sprite
54 # # Extra configuration of the sprite
55 # sprite.rotation = pi/2.0
58 # # Show only the blue colors
63 # To add a sprite to the UI it can be anchored to screen borders
64 # with `ui_camera.top_left` and the likes.
67 # # Place it a bit off the top left of the screen
68 # var pos = app.ui_camera.top_left.offset(128.0, -128.0, 0)
70 # # Load texture and create sprite
71 # var texture = new Texture("path/in/assets.png")
72 # var sprite = new Sprite(texture, pos)
74 # # Add it to the UI (above world sprites)
75 # app.ui_sprites.add sprite
79 # Texture drawn to screen
80 var texture
: Texture is writable(texture_direct
=)
82 # Texture drawn to screen
83 fun texture
=(texture
: Texture)
85 if isset _texture
and texture
!= self.texture
then
87 if texture
.root
!= self.texture
.root
then needs_remap
89 texture_direct
= texture
92 # Center position of this sprite in world coordinates
93 var center
: Point3d[Float] is writable(center_direct
=), noautoinit
95 # Center position of this sprite in world coordinates
96 fun center
=(center
: Point3d[Float]) is autoinit
do
97 if isset _center
and center
!= self.center
then
99 self.center
.sprites_remove
self
102 center
.sprites_add
self
103 center_direct
= center
106 # Last animation set with `animate`
107 var animation
: nullable Animation = null
109 # Animation on the shader, if this changes it `needs_remap`
110 private var shader_animation
: nullable Animation = null
112 # Animation start time, relative to `sprite_set.time`
114 # At -1.0 if animation started before being assigned a `sprite_set`.
115 private var animation_start
= 0.0
117 # Number of loops to show `animation`
118 private var animation_loops
= 0.0
120 # Start the `animation` for `n_loops`, replacing the static `texture`
122 # By default, if `n_loops` is not set, the animation plays once.
123 # If `n_loops == -1.0` then the animation loops infinitely.
124 # Otherwise, the animation repeats, e.g. it repeats twice and a half
125 # if `n_loops == 2.5`.
127 # The animation can be stopped using `animate_stop`.
128 fun animate
(animation
: Animation, n_loops
: nullable Float)
130 if not animation
.valid
then print_error
"{class_name}::animate: invalid animation {animation}"
132 var shader_animation
= shader_animation
133 if shader_animation
== null or animation
.frames
.first
.root
!= shader_animation
.frames
.first
.root
then
134 # Resort with the new animation texture
140 var sprite_set
= sprite_set
141 animation_start
= if sprite_set
!= null then sprite_set
.time
else -1.0
142 animation_loops
= n_loops
or else 1.0
143 self.shader_animation
= animation
144 self.animation
= animation
147 # Stop any active `animation` to display the static `texture`
150 if animation
== null then return
155 # Rotation on the Z axis, positive values turn counterclockwise
156 var rotation
= 0.0 is writable(rotation_direct
=)
158 # Rotation on the Z axis, positive values turn counterclockwise
159 fun rotation
=(value
: Float)
161 if isset _rotation
and value
!= rotation
then needs_update
162 rotation_direct
= value
165 # Mirror `texture` horizontally, inverting each pixel on the X axis
166 var invert_x
= false is writable(invert_x_direct
=)
168 # Mirror `texture` horizontally, inverting each pixel on the X axis
169 fun invert_x
=(value
: Bool)
171 if isset _invert_x
and value
!= invert_x
then needs_update
172 invert_x_direct
= value
175 # Scale applied to this sprite
177 # The basic size of `self` depends on the size in pixels of `texture`.
178 var scale
= 1.0 is writable(scale_direct
=)
180 # Scale applied to this sprite
182 # The basic size of `self` depends on the size in pixels of `texture`.
183 fun scale
=(value
: Float)
185 if isset _scale
and value
!= scale
then needs_update
189 # Red tint applied to `texture` on draw
190 fun red
: Float do return tint
[0]
192 # Red tint applied to `texture` on draw
193 fun red
=(value
: Float)
195 if isset _tint
and value
!= red
then needs_update
199 # Green tint applied to `texture` on draw
200 fun green
: Float do return tint
[1]
202 # Green tint applied to `texture` on draw
203 fun green
=(value
: Float)
205 if isset _tint
and value
!= green
then needs_update
209 # Blue tint applied to `texture` on draw
210 fun blue
: Float do return tint
[2]
212 # Blue tint applied to `texture` on draw
213 fun blue
=(value
: Float)
215 if isset _tint
and value
!= blue
then needs_update
219 # Transparency applied to `texture` on draw
220 fun alpha
: Float do return tint
[3]
222 # Transparency applied to `texture` on draw
223 fun alpha
=(value
: Float)
225 if isset _tint
and value
!= alpha
then needs_update
229 # Tint applied to `texture` on draw
231 # Alternative to the accessors `red, green, blue & alpha`.
232 # Changes inside the array do not automatically set `needs_update`.
234 # Require: `tint.length == 4`
235 var tint
: Array[Float] = [1.0, 1.0, 1.0, 1.0] is writable(tint_direct
=)
237 # Tint applied to `texture` on draw, see `tint`
238 fun tint
=(value
: Array[Float])
240 if isset _tint
and value
!= tint
then needs_update
244 # Draw order, higher values cause this sprite to be drawn latter
246 # Change this value to avoid artifacts when drawing non-opaque sprites.
247 # In general, sprites with a non-opaque `texture` and sprites closer to
248 # the camera should have a higher value to be drawn last.
250 # Sprites sharing a `draw_order` are drawn in the same pass.
251 # The sprite to sprite draw order is undefined and may change when adding
252 # and removing sprites, or changing their attributes.
256 # Changing this value may have a negative performance impact if there are
257 # many different `draw_order` values across many sprites.
258 # Sprites sharing some attributes are drawn as group to reduce
259 # the communication overhead between the CPU and GPU,
260 # and changing `draw_order` may break up large groups into smaller groups.
261 var draw_order
= 0 is writable(draw_order_direct
=)
263 # Set draw order, see `draw_order`
264 fun draw_order
=(value
: Int)
266 if isset _draw_order
and value
!= draw_order
then needs_remap
267 draw_order_direct
= value
270 # Is this sprite static and added in bulk?
272 # Set to `true` to give a hint to the framework that this sprite won't
273 # change often and that it is added in bulk with other static sprites.
274 # This value can be ignored in the prototyping phase of a game and
275 # added only when better performance are needed.
276 var static
= false is writable(static_direct
=)
278 # Is this sprite static and added in bulk? see `static`
279 fun static
=(value
: Bool)
281 if isset _static
and value
!= static
then needs_remap
282 static_direct
= value
285 # Request an update on the CPU
287 # This is called automatically on modification of any value of `Sprite`.
288 # However, it can still be set manually if a modification can't be
289 # detected or by subclasses.
293 if c
== null then return
294 if c
.last_sprite_to_update
== self then return
295 c
.sprites_to_update
.add
self
296 c
.last_sprite_to_update
= self
299 # Request a resorting of this sprite in its sprite list
301 # Resorting is required when `static` or the root of `texture` changes.
302 # This is called automatically when such changes are detected.
303 # However, it can still be set manually if a modification can't be
304 # detected or by subclasses.
308 if l
!= null then l
.sprites_to_remap
.add
self
311 # Current context to which `self` was sorted
312 private var context
: nullable SpriteContext = null
315 private var context_index
: Int = -1
317 # Current context to which `self` belongs
318 private var sprite_set
: nullable SpriteSet = null
321 # Animation for sprites, set with `Sprite.animate`
323 # Two main services create animations:
324 # * The constructors accepts an array of textures and the number of frames per
325 # seconds: `new Animation(array_of_subtextures, 10.0)`
326 # * The method `Texture::to_animation` uses the whole texture
327 # dividing it in frames either on X or Y:
328 # `new Texture("path/in/assets.png").to_animation(30.0, 0, 12)`
331 # Frames composing this animation
333 # All frames must share the same `Texture::root`, be on a vertical or
334 # horizontal line, be spaced equally and share the same dimensions.
335 var frames
: SequenceRead[Texture]
337 # Frames per seconds, a higher value makes this animation faster
339 # The animation speed is also affected by `SpriteSet::time_mod`.
342 # Are the `frames` valid for an animation? (see the requirements in `frames`)
343 var valid
: Bool is lazy
do
344 var r
: nullable RootTexture = null
349 if r
!= f
.root
then return false
353 # TODO check for line, constant distance, and same aspect ratio.
360 # Default graphic program to draw `sprites`
361 private var simple_2d_program
= new Simple2dProgram is lazy
363 # Camera for world `sprites` and `depth::actors` with perspective
365 # By default, the camera is configured to a height of 1080 units
366 # of world coordinates at `z == 0.0`.
367 var world_camera
: EulerCamera is lazy
do
368 var camera
= new EulerCamera(app
.display
.as(not null))
370 # Aim for full HD pixel resolution at level 0
371 camera
.reset_height
1080.0
377 # Camera for `ui_sprites` using an orthogonal view
378 var ui_camera
= new UICamera(app
.display
.as(not null)) is lazy
380 # World sprites drawn as seen by `world_camera`
381 var sprites
= new SpriteSet
383 # UI sprites drawn as seen by `ui_camera`, over world `sprites`
384 var ui_sprites
= new SpriteSet
386 # Main method to refine in clients to update game logic and `sprites`
387 fun update
(dt
: Float) do end
389 # Display `texture` as a splash screen
391 # Load `texture` if needed and resets `ui_camera` to 1080 units on the Y axis.
392 fun show_splash_screen
(texture
: Texture)
396 var splash
= new Sprite(texture
, ui_camera
.center
.offset
(0.0, 0.0, 0.0))
397 ui_sprites
.add splash
399 var display
= display
400 assert display
!= null
401 glClear gl_COLOR_BUFFER_BIT
403 ui_camera
.reset_height
1080.0
404 glViewport
(0, 0, display
.width
, display
.height
)
405 frame_core_ui_sprites display
408 ui_sprites
.remove splash
412 # Support and implementation
414 # Main clock used to count each frame `dt`, lapsed for `update` only
415 private var clock
= new Clock is lazy
417 # Performance clock to for `frame_core_draw` operations
418 private var perf_clock_main
= new Clock
420 # Second performance clock for smaller operations
421 private var perf_clock_sprites
= new Clock is lazy
423 redef fun create_gamnit
429 # Prepare the flat framework services
432 var display
= display
433 assert display
!= null
435 var gl_error
= glGetError
436 assert gl_error
== gl_NO_ERROR
else print_error gl_error
439 var program
= simple_2d_program
440 program
.compile_and_link
442 var gamnit_error
= program
.error
443 assert gamnit_error
== null else print_error gamnit_error
446 gl
.capabilities
.blend
.enable
447 glBlendFunc
(gl_ONE
, gl_ONE_MINUS_SRC_ALPHA
)
450 gl
.capabilities
.depth_test
.enable
451 glDepthFunc gl_LEQUAL
454 # Prepare viewport and background color
455 glViewport
(0, 0, display
.width
, display
.height
)
456 glClearColor
(0.0, 0.0, 0.0, 1.0)
458 gl_error
= glGetError
459 assert gl_error
== gl_NO_ERROR
else print_error gl_error
462 for tex
in all_root_textures
do
464 gamnit_error
= tex
.error
465 if gamnit_error
!= null then print_error gamnit_error
467 glTexParameteri
(gl_TEXTURE_2D
, gl_TEXTURE_MIN_FILTER
, gl_LINEAR
)
468 glTexParameteri
(gl_TEXTURE_2D
, gl_TEXTURE_MAG_FILTER
, gl_LINEAR
)
480 simple_2d_program
.delete
483 var display
= display
484 if display
!= null then display
.close
487 redef fun on_resize
(display
)
491 world_camera
.mvp_matrix_cache
= null
492 ui_camera
.mvp_matrix_cache
= null
494 # Update all sprites in the UI
495 for sprite
in ui_sprites
do sprite
.needs_update
504 redef fun frame_core
(display
)
507 var gl_error
= glGetError
508 assert gl_error
== gl_NO_ERROR
else print_error gl_error
510 # Update game logic and set sprites
511 perf_clock_main
.lapse
512 var dt
= clock
.lapse
.to_f
515 sys
.perfs
["gamnit flat update client"].add perf_clock_main
.lapse
517 # Draw and flip screen
518 frame_core_draw display
522 gl_error
= glGetError
523 assert gl_error
== gl_NO_ERROR
else print_error gl_error
526 private var frame_dt
= 0.0
528 # Draw the whole screen, all `glDraw...` calls should be executed here
529 protected fun frame_core_draw
(display
: GamnitDisplay)
531 frame_core_dynamic_resolution_before display
533 perf_clock_main
.lapse
534 frame_core_world_sprites display
535 perfs
["gamnit flat world_sprites"].add perf_clock_main
.lapse
537 frame_core_ui_sprites display
538 perfs
["gamnit flat ui_sprites"].add perf_clock_main
.lapse
540 frame_core_dynamic_resolution_after display
543 private fun frame_core_sprites
(display
: GamnitDisplay, sprite_set
: SpriteSet, camera
: Camera)
545 var simple_2d_program
= app
.simple_2d_program
546 simple_2d_program
.use
547 simple_2d_program
.mvp
.uniform camera
.mvp_matrix
549 sprite_set
.time
+= frame_dt
*sprite_set
.time_mod
550 simple_2d_program
.time
.uniform sprite_set
.time
555 assert glGetError
== gl_NO_ERROR
558 # Draw world sprites from `sprites`
559 protected fun frame_core_world_sprites
(display
: GamnitDisplay)
561 frame_core_sprites
(display
, sprites
, world_camera
)
564 # Draw UI sprites from `ui_sprites`
565 protected fun frame_core_ui_sprites
(display
: GamnitDisplay)
567 # Reset only the depth buffer
568 glClear gl_DEPTH_BUFFER_BIT
570 frame_core_sprites
(display
, ui_sprites
, ui_camera
)
576 # Vertices coordinates of the base geometry
578 # Defines the default width and height of related sprites.
579 private var vertices
: Array[Float] is lazy
do
582 return [-0.5*w
, 0.5*h
, 0.0,
588 # Coordinates of this texture on the `root` texture, in `[0..1.0]`
589 private var texture_coords
: Array[Float] is lazy
do
592 var b
= offset_bottom
600 # Coordinates of this texture on the `root` texture, inverting the X axis
601 private var texture_coords_invert_x
: Array[Float] is lazy
do
604 var b
= offset_bottom
612 # Convert to a sprite animation at `fps` speed with `x` or `y` frames
614 # The arguments `x` and `y` set the number of frames in the texture.
615 # Use `x` for an horizontal arrangement or `y` for vertical.
616 # One and only one of the arguments must be different than 0,
617 # as an animation can only be on a line and cannot wrap.
618 fun to_animation
(fps
: Float, x
, y
: Int): Animation
620 assert (x
== 0) != (y
== 0)
622 var n_frames
= x
.max
(y
)
623 var frames
= new Array[Texture]
625 var dx
= (x
/n_frames
).to_f
/n_frames
.to_f
626 var dy
= (y
/n_frames
).to_f
/n_frames
.to_f
627 var w
= if x
== 0 then 1.0 else dx
628 var h
= if y
== 0 then 1.0 else dy
631 for i
in n_frames
.times
do
632 frames
.add
new RelativeSubtexture(root
, left
, top
, left
+w
, top
+h
)
637 return new Animation(frames
, fps
)
641 # Graphic program to display simple models with a texture, translation, rotation and scale
642 private class Simple2dProgram
643 super GamnitProgramFromSource
645 redef var vertex_shader_source
= """
646 // Vertex coordinates
647 attribute vec4 coord;
650 attribute vec4 color;
652 // Vertex translation
653 attribute vec4 translation;
656 attribute float scale;
658 // Vertex coordinates on textures
659 attribute vec2 tex_coord;
661 // Model view projection matrix
664 // Current world time, in seconds
668 attribute vec4 rotation_row0;
669 attribute vec4 rotation_row1;
670 attribute vec4 rotation_row2;
671 attribute vec4 rotation_row3;
673 // Animation speed, frames per seconds
674 attribute float a_fps;
676 // Number of frames in the animation
677 attribute float a_n_frames;
679 // World coordinate of the animation (for aspect ratio)
680 attribute vec2 a_coord;
682 // Animation texture coordinates of the first frame
683 attribute vec2 a_tex_coord;
685 // Animation texture coordinates difference between frames
686 attribute vec2 a_tex_diff;
688 // Animation start time, in reference to `time`
689 attribute float a_start;
691 // Number of loops to play of the animation
692 attribute float a_loops;
696 return mat4(rotation_row0, rotation_row1, rotation_row2, rotation_row3);
699 // Output to the fragment shader
700 varying vec4 v_color;
701 varying vec2 v_coord;
703 // Is there an active animation?
704 varying float v_animated;
710 float end = a_start + a_loops/a_fps*a_n_frames;
711 if (a_fps != 0.0 && (a_loops == -1.0 || time < end)) {
713 float frame = mod(floor((time-a_start)*a_fps), a_n_frames);
714 v_coord = a_tex_coord + a_tex_diff*frame;
715 c = vec3(a_coord, coord.z);
724 gl_Position = (vec4(c * scale, 1.0) * rotation() + translation)* mvp;
725 v_color = vec4(color.rgb*color.a, color.a);
727 """ @ glsl_vertex_shader
729 redef var fragment_shader_source
= """
730 precision mediump float;
732 // Does this object use a texture?
733 uniform bool use_texture;
735 // Texture to apply on this object
736 uniform sampler2D texture0;
738 // Texture to apply on this object
739 uniform sampler2D animation;
741 // Input from the vertex shader
742 varying vec4 v_color;
743 varying vec2 v_coord;
744 varying float v_animated;
748 if (v_animated > 0.5) {
749 gl_FragColor = v_color * texture2D(animation, v_coord);
750 if (gl_FragColor.a <= 0.01) discard;
751 } else if (use_texture) {
752 gl_FragColor = v_color * texture2D(texture0, v_coord);
753 if (gl_FragColor.a <= 0.01) discard;
755 gl_FragColor = v_color;
758 """ @ glsl_fragment_shader
760 # Vertices coordinates
761 var coord
= attributes
["coord"].as(AttributeVec4) is lazy
763 # Should this program use the texture `texture`?
764 var use_texture
= uniforms
["use_texture"].as(UniformBool) is lazy
766 # Visible texture unit
767 var texture
= uniforms
["texture0"].as(UniformSampler2D) is lazy
769 # Coordinates on the textures, per vertex
770 var tex_coord
= attributes
["tex_coord"].as(AttributeVec2) is lazy
772 # Color tint per vertex
773 var color
= attributes
["color"].as(AttributeVec4) is lazy
775 # Translation applied to each vertex
776 var translation
= attributes
["translation"].as(AttributeVec4) is lazy
778 # Rotation matrix, row 0
779 var rotation_row0
= attributes
["rotation_row0"].as(AttributeVec4) is lazy
781 # Rotation matrix, row 1
782 var rotation_row1
= attributes
["rotation_row1"].as(AttributeVec4) is lazy
784 # Rotation matrix, row 2
785 var rotation_row2
= attributes
["rotation_row2"].as(AttributeVec4) is lazy
787 # Rotation matrix, row 3
788 var rotation_row3
= attributes
["rotation_row3"].as(AttributeVec4) is lazy
791 var scale
= attributes
["scale"].as(AttributeFloat) is lazy
793 # Model view projection matrix
794 var mvp
= uniforms
["mvp"].as(UniformMat4) is lazy
796 # World time, in seconds
797 var time
= uniforms
["time"].as(UniformFloat) is lazy
802 # Texture of all the frames of the animation
803 var animation_texture
= uniforms
["animation"].as(UniformSampler2D) is lazy
805 # Frame per second of the animation
806 var animation_fps
= attributes
["a_fps"].as(AttributeFloat) is lazy
808 # Number of frames in the animation
809 var animation_n_frames
= attributes
["a_n_frames"].as(AttributeFloat) is lazy
811 # Coordinates of each frame (mush be shared by all frames)
812 var animation_coord
= attributes
["a_coord"].as(AttributeVec2) is lazy
814 # Texture coordinates of the first frame
815 var animation_tex_coord
= attributes
["a_tex_coord"].as(AttributeVec2) is lazy
817 # Coordinate difference between each frame
818 var animation_tex_diff
= attributes
["a_tex_diff"].as(AttributeVec2) is lazy
820 # Animation start time, in seconds and in reference to `dt`
821 var animation_start
= attributes
["a_start"].as(AttributeFloat) is lazy
823 # Number of loops of the animation, -1 for infinite
824 var animation_loops
= attributes
["a_loops"].as(AttributeFloat) is lazy
827 redef class Point3d[N
]
829 # Associate each point to its sprites
831 private var sprites
: nullable Array[Sprite] = null
833 private fun sprites_add
(sprite
: Sprite)
835 var sprites
= sprites
836 if sprites
== null then
837 sprites
= new Array[Sprite]
838 self.sprites
= sprites
843 private fun sprites_remove
(sprite
: Sprite)
845 var sprites
= sprites
846 assert sprites
!= null
847 sprites
.remove sprite
851 # Notify `sprites` on attribute modification
853 private fun needs_update
855 var sprites
= sprites
856 if sprites
!= null then for s
in sprites
do s
.needs_update
861 if isset _x
and v
!= x
then needs_update
867 if isset _y
and v
!= y
then needs_update
873 if isset _z
and v
!= z
then needs_update
878 redef class OffsetPoint3d
881 if isset _x
and v
!= x
then needs_update
887 if isset _y
and v
!= y
then needs_update
893 if isset _z
and v
!= z
then needs_update
898 # Set of sprites sorting them into different `SpriteContext`
900 super HashSet[Sprite]
902 # Animation speed multiplier (0.0 to pause, 1.0 for normal speed, etc.)
903 var time_mod
= 1.0 is writable
905 # Seconds elapsed since the launch of the program, in world time responding to `time_mod`
908 # Map texture then static vs dynamic to a `SpriteContext`
909 private var contexts_map
= new HashMap4[RootTexture, nullable RootTexture, Bool, Int, Array[SpriteContext]]
911 # Contexts in `contexts_map`, sorted by draw order
912 private var contexts_items
= new Array[SpriteContext]
914 # Sprites needing resorting in `contexts_map`
915 private var sprites_to_remap
= new Array[Sprite]
917 # Add a sprite to the appropriate context
918 private fun map_sprite
(sprite
: Sprite)
920 assert sprite
.context
== null else print_error
"Sprite {sprite} belongs to another SpriteSet"
922 # Sort by texture and animation texture
923 var texture
= sprite
.texture
.root
924 var animation
= sprite
.animation
925 var animation_texture
= if animation
!= null then
926 animation
.frames
.first
.root
else null
927 var draw_order
= sprite
.draw_order
928 var contexts
= contexts_map
[texture
, animation_texture
, sprite
.static
, draw_order
]
931 if contexts
!= null then
932 for c
in contexts
.reverse_iterator
do
933 var size
= c
.sprites
.length
+ 1
934 if size
* 4 <= 0xffff then
941 if context
== null then
942 var usage
= if sprite
.static
then gl_STATIC_DRAW
else gl_DYNAMIC_DRAW
943 context
= new SpriteContext(texture
, animation_texture
, usage
, draw_order
)
945 if contexts
== null then
946 contexts
= new Array[SpriteContext]
947 contexts_map
[texture
, animation_texture
, sprite
.static
, draw_order
] = contexts
952 contexts_items
.add context
953 sprite_draw_order_sorter
.sort
(contexts_items
)
956 context
.sprites
.add sprite
957 context
.sprites_to_update
.add sprite
958 context
.last_sprite_to_update
= sprite
960 sprite
.context
= context
961 sprite
.sprite_set
= self
963 if animation
!= null and sprite
.animation_start
== -1.0 then
965 sprite
.animation_start
= time
969 # Remove a sprite from its context
970 private fun unmap_sprite
(sprite
: Sprite)
972 var context
= sprite
.context
973 assert context
!= null
974 context
.sprites
.remove sprite
976 sprite
.context
= null
977 sprite
.sprite_set
= null
980 # Draw all sprites by all contexts
983 # Remap sprites that may need to change context
984 for sprite
in sprites_to_remap
do
986 # Skip if it was removed from this set after being modified
987 if sprite
.sprite_set
!= self then continue
992 sprites_to_remap
.clear
995 for context
in contexts_items
do context
.draw
1000 if contexts_items
.has
(e
.context
) then return
1008 if e
isa Sprite then unmap_sprite e
1011 redef fun remove_all
(e
)
1013 if not has
(e
) then return
1019 for sprite
in self do
1020 sprite
.context
= null
1021 sprite
.sprite_set
= null
1024 for c
in contexts_items
do c
.destroy
1026 contexts_items
.clear
1027 sprites_to_remap
.clear
1032 for sprite
in self do
1033 sprite
.context
= null
1036 for c
in contexts_items
do c
.destroy
1038 contexts_items
.clear
1039 sprites_to_remap
.clear
1041 for sprite
in self do
1047 # Context for calls to `glDrawElements`
1049 # Each context has only one `texture` and `usage`, but many sprites.
1050 private class SpriteContext
1053 # Context config and state
1055 # Only root texture drawn by this context
1056 var texture
: nullable RootTexture
1058 # Only animation texture drawn by this context
1059 var animation_texture
: nullable RootTexture
1061 # OpenGL ES usage of `buffer_array` and `buffer_element`
1062 var usage
: GLBufferUsage
1064 # Draw order shared by all `sprites`
1067 # Sprites drawn by this context
1068 var sprites
= new GroupedSprites
1070 # Sprites to update since last `draw`
1071 var sprites_to_update
= new Set[Sprite]
1073 # Cache of the last `Sprite` added to `sprites_to_update` since the last call to `draw`
1074 var last_sprite_to_update
: nullable Sprite = null
1076 # Sprites that have been update and for which `needs_update` can be set to false
1077 var updated_sprites
= new Array[Sprite]
1079 # Buffer size to preallocate at `resize`, multiplied by `sprites.length`
1081 # Require: `resize_ratio >= 1.0`
1082 var resize_ratio
= 1.2
1087 # OpenGL ES buffer name for vertex data
1088 var buffer_array
: Int = -1
1090 # OpenGL ES buffer name for indices
1091 var buffer_element
: Int = -1
1093 # Current capacity, in sprites, of `buffer_array` and `buffer_element`
1094 var buffer_capacity
= 0
1096 # C buffers used to pass the data of a single sprite
1097 var local_data_buffer
= new GLfloatArray(float_per_vertex
*4) is lazy
1098 var local_indices_buffer
= new CUInt16Array(indices_per_sprite
) is lazy
1103 # Number of GL_FLOAT per vertex of `Simple2dProgram`
1104 var float_per_vertex
: Int is lazy
do
1105 return 4 + 4 + 4 + # vec4 translation, vec4 color, vec4 coord,
1106 1 + 2 + 4*4 + # float scale, vec2 tex_coord, vec4 rotation_row*,
1107 1 + 1 + # float a_fps, float a_n_frames,
1108 2 + 2 + 2 + # vec2 a_coord, vec2 a_tex_coord, vec2 a_tex_diff,
1109 1 + 1 # float a_start, float a_loops
1112 # Number of bytes per vertex of `Simple2dProgram`
1113 var bytes_per_vertex
: Int is lazy
do
1114 var fs
= 4 # sizeof(GL_FLOAT)
1115 return fs
* float_per_vertex
1118 # Number of bytes per sprite
1119 var bytes_per_sprite
: Int is lazy
do return bytes_per_vertex
* 4
1121 # Number of vertex indices per sprite draw call (2 triangles)
1122 var indices_per_sprite
= 6
1127 # Allocate `buffer_array` and `buffer_element`
1130 var bufs
= glGenBuffers
(2)
1131 buffer_array
= bufs
[0]
1132 buffer_element
= bufs
[1]
1134 var gl_error
= glGetError
1135 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1138 # Destroy `buffer_array` and `buffer_element`
1141 glDeleteBuffers
([buffer_array
, buffer_element
])
1142 var gl_error
= glGetError
1143 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1149 # Resize `buffer_array` and `buffer_element` to fit all `sprites` (and more)
1152 app
.perf_clock_sprites
.lapse
1154 # Allocate a bit more space
1155 var capacity
= (sprites
.capacity
.to_f
* resize_ratio
).to_i
1157 var array_bytes
= capacity
* bytes_per_sprite
1158 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
1159 assert glIsBuffer
(buffer_array
)
1160 glBufferData
(gl_ARRAY_BUFFER
, array_bytes
, new Pointer.nul
, usage
)
1161 var gl_error
= glGetError
1162 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1164 # GL_TRIANGLES 6 vertices * sprite
1165 var n_indices
= capacity
* indices_per_sprite
1166 var ius
= 2 # sizeof(GL_UNSIGNED_SHORT)
1167 var element_bytes
= n_indices
* ius
1168 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
1169 assert glIsBuffer
(buffer_element
)
1170 glBufferData
(gl_ELEMENT_ARRAY_BUFFER
, element_bytes
, new Pointer.nul
, usage
)
1171 gl_error
= glGetError
1172 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1174 buffer_capacity
= capacity
1176 sys
.perfs
["gamnit flat gpu resize"].add app
.perf_clock_sprites
.lapse
1179 # Update GPU data of `sprite`
1180 fun update_sprite
(sprite
: Sprite)
1182 var context
= sprite
.context
1183 if context
!= self then return
1185 var sprite_index
= sprite
.context_index
1186 assert sprite_index
!= -1
1190 var data
= local_data_buffer
1194 data
[o
+ 0] = sprite
.center
.x
1195 data
[o
+ 1] = sprite
.center
.y
1196 data
[o
+ 2] = sprite
.center
.z
1200 data
[o
+ 4] = sprite
.tint
[0]
1201 data
[o
+ 5] = sprite
.tint
[1]
1202 data
[o
+ 6] = sprite
.tint
[2]
1203 data
[o
+ 7] = sprite
.tint
[3]
1206 data
[o
+ 8] = sprite
.scale
1209 data
[o
+ 9] = sprite
.texture
.vertices
[v
*3+0]
1210 data
[o
+10] = sprite
.texture
.vertices
[v
*3+1]
1211 data
[o
+11] = sprite
.texture
.vertices
[v
*3+2]
1215 var texture
= texture
1216 if texture
!= null then
1217 var tc
= if sprite
.invert_x
then
1218 sprite
.texture
.texture_coords_invert_x
1219 else sprite
.texture
.texture_coords
1220 data
[o
+13] = tc
[v
*2+0]
1221 data
[o
+14] = tc
[v
*2+1]
1226 if sprite
.rotation
== 0.0 then
1227 # Cache the matrix at no rotation
1228 rot
= once
new Matrix.identity
(4)
1230 rot
= new Matrix.rotation
(sprite
.rotation
, 0.0, 0.0, 1.0)
1232 data
.fill_from_matrix
(rot
, o
+15)
1234 var animation
= sprite
.animation
1235 if animation
== null then
1236 for i
in [31..40] do data
[o
+i
] = 0.0
1239 data
[o
+31] = animation
.fps
1242 data
[o
+32] = animation
.frames
.length
.to_f
1245 data
[o
+33] = animation
.frames
.first
.vertices
[v
*3+0]
1246 data
[o
+34] = animation
.frames
.first
.vertices
[v
*3+1]
1249 var tc
= if sprite
.invert_x
then
1250 animation
.frames
.first
.texture_coords_invert_x
1251 else animation
.frames
.first
.texture_coords
1252 data
[o
+35] = tc
[v
*2]
1253 data
[o
+36] = tc
[v
*2+1]
1258 if animation
.frames
.length
> 1 then
1259 dx
= animation
.frames
[1].texture_coords
[0] - animation
.frames
[0].texture_coords
[0]
1260 dy
= animation
.frames
[1].texture_coords
[1] - animation
.frames
[0].texture_coords
[1]
1266 data
[o
+39] = sprite
.animation_start
1269 data
[o
+40] = sprite
.animation_loops
1272 o
+= float_per_vertex
1275 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
1276 glBufferSubData
(gl_ARRAY_BUFFER
, sprite_index
*bytes_per_sprite
, bytes_per_sprite
, data
.native_array
)
1278 var gl_error
= glGetError
1279 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1288 var indices
= local_indices_buffer
1289 var io
= sprite_index
*4
1297 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
1298 glBufferSubData
(gl_ELEMENT_ARRAY_BUFFER
, sprite_index
*6*2, 6*2, indices
.native_array
)
1300 gl_error
= glGetError
1301 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1304 # Draw all `sprites`
1306 # Call `resize` and `update_sprite` as needed before actual draw operation.
1308 # Require: `app.simple_2d_program` and `mvp` must be bound on the GPU
1311 if buffer_array
== -1 then prepare
1313 assert buffer_array
> 0 and buffer_element
> 0 else
1314 print_error
"Internal error: {self} was destroyed"
1318 glBindBuffer
(gl_ARRAY_BUFFER
, buffer_array
)
1319 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, buffer_element
)
1321 # Resize GPU buffers?
1322 var update_everything
= false
1323 if sprites
.capacity
> buffer_capacity
then
1324 # Try to defragment first
1325 var moved
= sprites
.defragment
1327 if sprites
.capacity
> buffer_capacity
then
1328 # Defragmentation wasn't enough, grow
1331 # We must update everything
1332 update_everything
= true
1333 for s
in sprites
.items
do if s
!= null then sprites_to_update
.add s
1335 # Just update the moved sprites
1336 for s
in moved
do sprites_to_update
.add s
1338 else if sprites
.available
.not_empty
then
1339 # Defragment a bit anyway
1340 # TODO defrag only when there's time left on a frame
1341 var moved
= sprites
.defragment
(1)
1342 for s
in moved
do sprites_to_update
.add s
1345 # Update GPU sprites data
1346 if sprites_to_update
.not_empty
or update_everything
then
1347 app
.perf_clock_sprites
.lapse
1349 if update_everything
then
1350 for sprite
in sprites
.items
do if sprite
!= null then
1351 update_sprite
(sprite
)
1354 for sprite
in sprites_to_update
do update_sprite
(sprite
)
1357 sprites_to_update
.clear
1358 last_sprite_to_update
= null
1360 sys
.perfs
["gamnit flat gpu update"].add app
.perf_clock_sprites
.lapse
1363 # Update uniforms specific to this context
1364 var texture
= texture
1365 app
.simple_2d_program
.use_texture
.uniform texture
!= null
1366 if texture
!= null then
1367 glActiveTexture gl_TEXTURE0
1368 glBindTexture
(gl_TEXTURE_2D
, texture
.gl_texture
)
1369 app
.simple_2d_program
.texture
.uniform
0
1371 var gl_error
= glGetError
1372 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1374 var animation
= animation_texture
1375 if animation
!= null then
1376 glActiveTexture gl_TEXTURE1
1377 glBindTexture
(gl_TEXTURE_2D
, animation
.gl_texture
)
1378 app
.simple_2d_program
.animation_texture
.uniform
1
1380 gl_error
= glGetError
1381 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1383 # Configure attributes, in order:
1384 # vec4 translation, vec4 color, float scale, vec4 coord, vec2 tex_coord, vec4 rotation_row*,
1385 # a_fps, a_n_frames, a_coord, a_tex_coord, a_tex_diff, a_start, a_loops
1388 var p
= app
.simple_2d_program
1389 var sizeof_gl_float
= 4 # sizeof(GL_FLOAT)
1391 var size
= 4 # Number of floats
1392 glEnableVertexAttribArray p
.translation
.location
1393 glVertexAttribPointeri
(p
.translation
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1394 offset
+= size
* sizeof_gl_float
1395 gl_error
= glGetError
1396 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1399 glEnableVertexAttribArray p
.color
.location
1400 glVertexAttribPointeri
(p
.color
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1401 offset
+= size
* sizeof_gl_float
1402 gl_error
= glGetError
1403 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1406 glEnableVertexAttribArray p
.scale
.location
1407 glVertexAttribPointeri
(p
.scale
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1408 offset
+= size
* sizeof_gl_float
1409 gl_error
= glGetError
1410 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1413 glEnableVertexAttribArray p
.coord
.location
1414 glVertexAttribPointeri
(p
.coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1415 offset
+= size
* sizeof_gl_float
1416 gl_error
= glGetError
1417 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1420 glEnableVertexAttribArray p
.tex_coord
.location
1421 glVertexAttribPointeri
(p
.tex_coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1422 offset
+= size
* sizeof_gl_float
1423 gl_error
= glGetError
1424 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1427 for r
in [p
.rotation_row0
, p
.rotation_row1
, p
.rotation_row2
, p
.rotation_row3
] do
1429 glEnableVertexAttribArray r
.location
1430 glVertexAttribPointeri
(r
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1432 offset
+= size
* sizeof_gl_float
1433 gl_error
= glGetError
1434 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1438 glEnableVertexAttribArray p
.animation_fps
.location
1439 glVertexAttribPointeri
(p
.animation_fps
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1440 offset
+= size
* sizeof_gl_float
1441 gl_error
= glGetError
1442 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1445 glEnableVertexAttribArray p
.animation_n_frames
.location
1446 glVertexAttribPointeri
(p
.animation_n_frames
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1447 offset
+= size
* sizeof_gl_float
1448 gl_error
= glGetError
1449 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1452 glEnableVertexAttribArray p
.animation_coord
.location
1453 glVertexAttribPointeri
(p
.animation_coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1454 offset
+= size
* sizeof_gl_float
1455 gl_error
= glGetError
1456 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1459 glEnableVertexAttribArray p
.animation_tex_coord
.location
1460 glVertexAttribPointeri
(p
.animation_tex_coord
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1461 offset
+= size
* sizeof_gl_float
1462 gl_error
= glGetError
1463 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1466 glEnableVertexAttribArray p
.animation_tex_diff
.location
1467 glVertexAttribPointeri
(p
.animation_tex_diff
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1468 offset
+= size
* sizeof_gl_float
1469 gl_error
= glGetError
1470 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1473 glEnableVertexAttribArray p
.animation_start
.location
1474 glVertexAttribPointeri
(p
.animation_start
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1475 offset
+= size
* sizeof_gl_float
1476 gl_error
= glGetError
1477 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1480 glEnableVertexAttribArray p
.animation_loops
.location
1481 glVertexAttribPointeri
(p
.animation_loops
.location
, size
, gl_FLOAT
, false, bytes_per_vertex
, offset
)
1482 offset
+= size
* sizeof_gl_float
1483 gl_error
= glGetError
1484 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1487 for s
in sprites
.starts
, e
in sprites
.ends
do
1489 glDrawElementsi
(gl_TRIANGLES
, l
*indices_per_sprite
, gl_UNSIGNED_SHORT
, 2*s
*indices_per_sprite
)
1490 gl_error
= glGetError
1491 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1495 for attr
in [p
.translation
, p
.color
, p
.scale
, p
.coord
, p
.tex_coord
,
1496 p
.rotation_row0
, p
.rotation_row1
, p
.rotation_row2
, p
.rotation_row3
: Attribute] do
1497 if not attr
.is_active
then continue
1498 glDisableVertexAttribArray
(attr
.location
)
1499 gl_error
= glGetError
1500 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1503 glBindBuffer
(gl_ARRAY_BUFFER
, 0)
1504 glBindBuffer
(gl_ELEMENT_ARRAY_BUFFER
, 0)
1505 gl_error
= glGetError
1506 assert gl_error
== gl_NO_ERROR
else print_error gl_error
1510 # Representation of sprite data on the GPU
1512 # The main purpose of this class is to optimize the use of contiguous
1513 # space in GPU memory. Each contiguous memory block can be drawn in a
1514 # single call. The starts index of each block is kept by `starts,
1515 # and the end + 1 by `ends`.
1517 # The data can be compressed by a call to `defragment`.
1520 # intrude import gamnit::flat
1522 # var array = new GroupedArray[String]
1523 # assert array.to_s == ""
1531 # assert array.to_s == "[a,b,c,d,e,f]"
1532 # assert array.capacity == 6
1535 # assert array.to_s == "[b,c,d,e,f]"
1538 # assert array.to_s == "[c,d,e,f]"
1541 # assert array.to_s == "[c,d,e]"
1544 # assert array.to_s == "[c][e]"
1547 # assert array.to_s == "[A][c][e]"
1550 # assert array.to_s == "[A,B,c][e]"
1553 # assert array.to_s == "[A,B,c]"
1556 # assert array.to_s == "[A,B,c,D]"
1559 # assert array.to_s == "[A,B,c,D,E]"
1560 # assert array.capacity == 6
1561 # assert array.length == 5
1568 # assert array.to_s == ""
1571 # assert array.to_s == "[a]"
1573 private class GroupedArray[E
]
1575 # Memory with actual objects, and null in empty slots
1576 var items
= new Array[nullable E
]
1578 # Number of items in the array
1581 # Number of item slots in the array
1582 fun capacity
: Int do return items
.length
1584 # List of available slots
1585 var available
= new MinHeap[Int].default
1587 # Start index of filled chunks
1588 var starts
= new List[Int]
1590 # Index of the spots after filled chunks
1591 var ends
= new List[Int]
1593 # Add `item` to the first available slot and return its index
1594 fun add
(item
: E
): Int
1598 if available
.not_empty
then
1599 # starts & ends can't be empty
1601 var i
= available
.take
1604 if i
== starts
.first
- 1 then
1605 # slot 0 free, 1 taken
1608 # slot 0 and more free
1611 else if starts
.length
>= 2 and ends
.first
+ 1 == starts
[1] then
1616 # at end of first chunk
1623 if ends
.is_empty
then
1627 return ends
.last
- 1
1630 # Remove the first instance of `item`
1633 var index
= items
.index_of
(item
)
1634 remove_at
(item
, index
)
1637 # Remove `item` at `index`
1638 fun remove_at
(item
: E
, index
: Int)
1645 for s
in starts
, e
in ends
do
1646 if s
<= i
and i
< e
then
1652 if starts
.is_empty
then
1657 else if e-1
== i
then
1658 # last item of chunk
1662 # first item of chunk
1666 ends
.insert
(ends
[ii
], ii
+1)
1668 starts
.insert
(i
+1, ii
+1)
1680 # Defragment and compress everything into a single chunks beginning at 0
1682 # Returns the elements that moved as a list.
1685 # intrude import gamnit::flat
1687 # var array = new GroupedArray[String]
1694 # assert array.to_s == "[b][d]"
1696 # var moved = array.defragment
1697 # assert moved.to_s == "[d]"
1698 # assert array.to_s == "[d,b]"
1699 # assert array.length == 2
1700 # assert array.capacity == 2
1704 # assert array.to_s == "[d,b,e,f]"
1706 fun defragment
(max
: nullable Int): Array[E
]
1708 app
.perf_clock_sprites
.lapse
1709 max
= max
or else length
1711 var moved
= new Array[E
]
1712 while max
> 0 and (starts
.length
> 1 or starts
.first
!= 0) do
1713 var i
= ends
.last
- 1
1722 if starts
.length
== 1 and starts
.first
== 0 then
1723 for i
in [length
..capacity
[ do items
.pop
1727 sys
.perfs
["gamnit flat gpu defrag"].add app
.perf_clock_sprites
.lapse
1733 var ss
= new Array[String]
1734 for s
in starts
, e
in ends
do
1737 var item
: nullable Object = items
[i
]
1738 if item
== null then item
= "null"
1740 if i
!= e-1
then ss
.add
","
1748 # Optimized `GroupedArray` to use `Sprite::context_index` and avoid using `index_of`
1749 private class GroupedSprites
1750 super GroupedArray[Sprite]
1755 item
.context_index
= index
1759 redef fun remove
(item
) do remove_at
(item
, item
.context_index
)
1762 redef class GLfloatArray
1763 private fun fill_from_matrix
(matrix
: Matrix, dst_offset
: nullable Int)
1765 dst_offset
= dst_offset
or else add_index
1766 var mat_len
= matrix
.width
*matrix
.height
1767 assert length
>= mat_len
+ dst_offset
1768 native_array
.fill_from_matrix_native
(matrix
.items
, dst_offset
, mat_len
)
1769 add_index
+= mat_len
1773 redef class NativeGLfloatArray
1774 private fun fill_from_matrix_native
(matrix
: matrix
::NativeDoubleArray, dst_offset
, len
: Int) `{
1776 for (i = 0; i < len; i ++)
1777 self[i+dst_offset] = (GLfloat)matrix[i];
1782 private var sprite_draw_order_sorter
= new DrawOrderComparator is lazy
1785 # Sort `SpriteContext` by their `draw_order`
1786 private class DrawOrderComparator
1789 # This class can't set COMPARED because
1790 # `the public property cannot contain the private type...`
1791 #redef type COMPARED: SpriteContext
1793 # Require: `a isa SpriteContext and b isa SpriteContext`
1794 redef fun compare
(a
, b
)
1795 do return a
.as(SpriteContext).draw_order
<=> b
.as(SpriteContext).draw_order