Sprite

Play Demo

Sprite2D demo — renders textures as 2D quads via Draw2D.draw_texture().

Generates test textures programmatically, then renders them as sprites. Demonstrates:

  • Sprite2D as a Node2D in the scene tree

  • passing an RGBA uint8 ndarray directly as the Sprite2D.texture source

  • Tinting via vertex colour

  • Rotation

Source Code

  1"""Sprite2D demo — renders textures as 2D quads via Draw2D.draw_texture().
  2
  3Generates test textures programmatically, then renders them as sprites.
  4Demonstrates:
  5  - Sprite2D as a Node2D in the scene tree
  6  - passing an RGBA uint8 ndarray directly as the Sprite2D.texture source
  7  - Tinting via vertex colour
  8  - Rotation
  9"""
 10
 11
 12import math
 13
 14import numpy as np
 15
 16from simvx.core import Node2D, Sprite2D, Text2D
 17from simvx.core.math.types import Vec2
 18from simvx.graphics import App
 19
 20
 21def _make_checkerboard(size: int = 64, cell: int = 8) -> np.ndarray:
 22    """Generate a checkerboard RGBA texture."""
 23    img = np.zeros((size, size, 4), dtype=np.uint8)
 24    for y in range(size):
 25        for x in range(size):
 26            if (x // cell + y // cell) % 2 == 0:
 27                img[y, x] = [200, 60, 60, 255]
 28            else:
 29                img[y, x] = [60, 60, 200, 255]
 30    return img
 31
 32
 33def _make_gradient(size: int = 64) -> np.ndarray:
 34    """Generate a horizontal gradient RGBA texture."""
 35    img = np.zeros((size, size, 4), dtype=np.uint8)
 36    for x in range(size):
 37        t = x / (size - 1)
 38        r = int(255 * t)
 39        g = int(255 * (1 - t))
 40        img[:, x] = [r, g, 80, 255]
 41    return img
 42
 43
 44def _make_star(size: int = 64) -> np.ndarray:
 45    """Generate a simple star shape RGBA texture."""
 46    img = np.zeros((size, size, 4), dtype=np.uint8)
 47    cx, cy = size // 2, size // 2
 48    for y in range(size):
 49        for x in range(size):
 50            dx, dy = x - cx, y - cy
 51            dist = math.sqrt(dx * dx + dy * dy)
 52            angle = math.atan2(dy, dx)
 53            # Star pattern: 5 points
 54            r = (size * 0.4) * (0.5 + 0.5 * abs(math.cos(2.5 * angle)))
 55            if dist < r:
 56                brightness = int(255 * (1 - dist / r))
 57                img[y, x] = [255, 220, 50, brightness]
 58    return img
 59
 60
 61class SpriteScene(Node2D):
 62    """Root scene that creates and displays sprites."""
 63
 64    def ready(self):
 65        self._time = 0.0
 66
 67        # Bake the three test textures as ndarrays; Sprite2D.texture accepts
 68        # the array directly — no file I/O.
 69        checker = _make_checkerboard()
 70        gradient = _make_gradient()
 71        star = _make_star()
 72
 73        self.checker = self.add_child(Sprite2D(
 74            texture=checker,
 75            position=Vec2(200, 200),
 76            width=128, height=128,
 77            name="Checker",
 78        ))
 79
 80        self.gradient = self.add_child(Sprite2D(
 81            texture=gradient,
 82            position=Vec2(500, 200),
 83            width=128, height=128,
 84            colour=(0.8, 1.0, 0.8, 1.0),  # green tint
 85            name="Gradient",
 86        ))
 87
 88        self.star = self.add_child(Sprite2D(
 89            texture=star,
 90            position=Vec2(350, 400),
 91            width=192, height=192,
 92            name="Star",
 93        ))
 94
 95        self.small_checker = self.add_child(Sprite2D(
 96            texture=checker,
 97            position=Vec2(700, 400),
 98            width=64, height=64,
 99            scale=Vec2(0.5, 0.5),
100            colour=(1.0, 1.0, 0.5, 0.8),  # yellow tint, slightly transparent
101            name="SmallChecker",
102        ))
103
104        self.add_child(Text2D(text="Sprite2D Demo", x=10, y=10, font_scale=1.5, name="Title"))
105        self.add_child(Text2D(text="Checker | Gradient (tinted) | Star | Rotating", x=10, y=40, name="Info"))
106
107    def process(self, dt: float):
108        self._time += dt
109        # Rotate the star sprite
110        self.star.rotation = self._time * 0.5
111        # Bob the gradient sprite
112        self.gradient.position = Vec2(500, 200 + 30 * math.sin(self._time * 2))
113
114
115if __name__ == "__main__":
116    App(width=900, height=600, title="SimVX Sprite2D Demo").run(SpriteScene())