Remaining sprite work

- UV bias
- Single sprite rendering
- Cache more stuff in context

Author: einarf

arcade/context.py

@@ -3,6 +3,7 @@
 Contains pre-loaded programs
 """
 
+from array import array
 from collections.abc import Iterable, Sequence
 from pathlib import Path
 from typing import Any
@@ -112,6 +113,7 @@ def __init__(
         self.sprite_list_program_no_geo["texture_id_data"] = 5
         self.sprite_list_program_no_geo["index_data"] = 6
 
+        # Geo shader single sprite program
         self.sprite_program_single = self.load_program(
             vertex_shader=":system:shaders/sprites/sprite_single_vs.glsl",
             geometry_shader=":system:shaders/sprites/sprite_list_geometry_no_cull_geo.glsl",
@@ -120,6 +122,34 @@ def __init__(
         self.sprite_program_single["sprite_texture"] = 0
         self.sprite_program_single["uv_texture"] = 1
         self.sprite_program_single["spritelist_color"] = 1.0, 1.0, 1.0, 1.0
+        # Non-geometry shader single sprite program
+        self.sprite_program_single_simple = self.load_program(
+            vertex_shader=":system:shaders/sprites/sprite_single_simple_vs.glsl",
+            fragment_shader=":system:shaders/sprites/sprite_list_simple_fs.glsl",
+        )
+        self.sprite_program_single_simple["sprite_texture"] = 0
+        self.sprite_program_single_simple["uv_texture"] = 1
+        self.sprite_program_single_simple["spritelist_color"] = 1.0, 1.0, 1.0, 1.0
+
+        # fmt: off
+        self.spritelist_geometry_simple = self.geometry(
+            [
+                BufferDescription(
+                    self.buffer(
+                        data=array("f", [
+                            -0.5, +0.5,  # Upper left
+                            -0.5, -0.5,  # lower left
+                            +0.5, +0.5,  # upper right
+                            +0.5, -0.5,  # lower right
+                        ])
+                    ),
+                    "2f",
+                    ["in_pos"]
+                ),
+            ],
+            mode=self.TRIANGLE_STRIP,
+        )
+        # fmt: on
 
         # Shapes
         self.shape_line_program: Program = self.load_program(

arcade/draw/rect.py

@@ -54,7 +54,7 @@ def draw_texture_rect(
         ctx.disable(ctx.BLEND)
 
     atlas = atlas or ctx.default_atlas
-    program = ctx.sprite_program_single
+    program = ctx.sprite_program_single_simple
 
     texture_id, _ = atlas.add(texture)
     if pixelated:
@@ -68,14 +68,13 @@ def draw_texture_rect(
     atlas.use_uv_texture(unit=1)
 
     geometry = ctx.geometry_empty
-    program["pos"] = rect.x, rect.y, 0
+    program["pos_rot"] = rect.x, rect.y, 0, angle
     program["color"] = color.normalized
     program["size"] = rect.width, rect.height
-    program["angle"] = angle
-    program["texture_id"] = float(texture_id)
+    program["texture_id"] = texture_id
     program["spritelist_color"] = 1.0, 1.0, 1.0, alpha_normalized
 
-    geometry.render(program, mode=gl.POINTS, vertices=1)
+    geometry.render(program, mode=gl.TRIANGLE_STRIP, vertices=4)
 
     if blend:
         ctx.disable(ctx.BLEND)

arcade/resources/system/shaders/sprites/sprite_list_simple_vs.glsl

@@ -52,7 +52,20 @@ void main() {
 
     mat4 mvp = window.projection * window.view;
 
-    // TODO: Half pixel offset
+    // Apply half pixel offset modified by bias.
+    // What bias to set depends on the texture filtering mode.
+    // Linear can have 1.0 bias while nearest should have 0.0 (unless scale is 1:1)
+    // uvs (
+    //     0.0, 0.0,
+    //     1.0, 0.0,
+    //     0.0, 1.0,
+    //     1.0, 1.0
+    // )
+    vec2 hp = 0.5 / vec2(textureSize(sprite_texture, 0)) * uv_offset_bias;
+    uv0 += hp;
+    uv1 += vec2(-hp.x, hp.y);
+    uv2 += vec2(hp.x, -hp.y);
+    uv3 += -hp;
 
     int vertex_id = gl_VertexID % 4;
     vec2 uvs[4] = vec2[4](uv0, uv2, uv1, uv3);

arcade/resources/system/shaders/sprites/sprite_single_simple_vs.glsl

@@ -0,0 +1,70 @@
+#version 330
+// vert/frag only version of the sprite list shader
+
+uniform WindowBlock {
+    mat4 projection;
+    mat4 view;
+} window;
+
+// Texture atlas
+uniform sampler2D sprite_texture;
+// Texture containing UVs for the entire atlas
+uniform sampler2D uv_texture;
+
+uniform vec4 pos_rot;  // rect.x, rect.y, 0, angle
+uniform vec4 color;  // color.normalized
+uniform vec2 size;  // rect.width, rect.height
+uniform int texture_id;
+
+// How much half-pixel offset to apply to the UVs.
+// 0.0 is no offset, 1.0 is half a pixel offset
+uniform float uv_offset_bias;
+
+// Output to frag shader
+out vec2 v_uv;
+out vec4 v_color;
+
+#include :system:shaders/lib/sprite.glsl
+
+
+const vec2 vertices[4] = vec2[4](
+    vec2(-0.5, +0.5),  // Upper left
+    vec2(-0.5, -0.5),  // lower left
+    vec2(+0.5, +0.5),  // upper right
+    vec2(+0.5, -0.5)   // lower right
+);
+
+void main() {
+    vec2 uv0, uv1, uv2, uv3;
+    getSpriteUVs(uv_texture, texture_id, uv0, uv1, uv2, uv3);
+
+    vec3 center = pos_rot.xyz;
+    float angle = radians(pos_rot.w);
+    mat2 rot = mat2(
+        cos(angle), -sin(angle),
+        sin(angle),  cos(angle)
+    );
+
+    mat4 mvp = window.projection * window.view;
+
+    // Apply half pixel offset modified by bias.
+    // What bias to set depends on the texture filtering mode.
+    // Linear can have 1.0 bias while nearest should have 0.0 (unless scale is 1:1)
+    // uvs (
+    //     0.0, 0.0,
+    //     1.0, 0.0,
+    //     0.0, 1.0,
+    //     1.0, 1.0
+    // )
+    vec2 hp = 0.5 / vec2(textureSize(sprite_texture, 0)) * uv_offset_bias;
+    uv0 += hp;
+    uv1 += vec2(-hp.x, hp.y);
+    uv2 += vec2(hp.x, -hp.y);
+    uv3 += -hp;
+
+    int vertex_id = gl_VertexID % 4;
+    vec2 uvs[4] = vec2[4](uv0, uv2, uv1, uv3);
+    v_color = color;
+    gl_Position = mvp * vec4(rot * (vertices[vertex_id] * size) + center.xy, 0.0, 1.0);
+    v_uv = uvs[vertex_id];
+}

arcade/sprite_list/sprite_list.py

@@ -1721,21 +1721,7 @@ def __init__(self, ctx: ArcadeContext, capacity: int, atlas: TextureAtlasBase) -
         # Program without geo shader
         self.program = self.ctx.sprite_list_program_no_geo
         self._atlas = atlas or self.ctx.default_atlas
-
-        # fmt: off
-        self._instance_buffer = self.ctx.buffer(
-            data=array("f", [
-                -0.5, +0.5,  # Upper left
-                -0.5, -0.5,  # lower left
-                +0.5, +0.5,  # upper right
-                +0.5, -0.5,  # lower right
-            ]),
-        )
-        # fmt: on
-        self._geometry = self.ctx.geometry(
-            [BufferDescription(self._instance_buffer, "2f", ["in_pos"])],
-            mode=self.ctx.TRIANGLE_STRIP,
-        )
+        self._geometry = self.ctx.spritelist_geometry_simple
 
         # Texture buffers for per-sprite data. These are looked up using gl_InstanceID
         self._storage_pos_angle: Texture2D = self.ctx.texture(