Bunnymark

a sprite-renderer stress test.

▶ Run in browser

Tags: 2d sprites performance stress-test

Thousands of Sprite2D nodes bounce under gravity, and every press adds a thousand more, so the count on screen when the frame rate starts to fall is a measure of the 2D renderer.

Every sprite shares one Texture built from a numpy RGBA array at startup: one upload and one GPU slot however many bunnies reference it. Each sprite takes its own colour tint.

The simulation lives in two numpy arrays, positions and velocities, and moves the whole population per frame in a handful of vectorised operations: gravity, integration, and a bounce off each edge of viewport_size, read every frame so the box follows the window. The nodes only display that state. The write-back is sprite.position[:] = row, which edits the sprite’s position in place; the change marks its transform dirty just as assigning a new Vec2 would, at a fraction of the cost.

A Label on a CanvasLayer shows the count and a frame rate averaged over a quarter of a second rather than one jittery frame.

Controls: Space, click or tap adds 1000 bunnies.

Source

# /// simvx
# tags = ["2d", "sprites", "performance", "stress-test"]
# web = { width = 960, height = 540, responsive = true }
# ///
"""Bunnymark: a sprite-renderer stress test.

Thousands of `Sprite2D` nodes bounce under gravity, and every press adds a
thousand more, so the count on screen when the frame rate starts to fall is a
measure of the 2D renderer.

Every sprite shares one `Texture` built from a numpy RGBA array at startup: one
upload and one GPU slot however many bunnies reference it. Each sprite takes its
own `colour` tint.

The simulation lives in two numpy arrays, positions and velocities, and moves
the whole population per frame in a handful of vectorised operations: gravity,
integration, and a bounce off each edge of `viewport_size`, read every frame so
the box follows the window. The nodes only display that state. The write-back
is `sprite.position[:] = row`, which edits the sprite's position in place; the
change marks its transform dirty just as assigning a new `Vec2` would, at a
fraction of the cost.

A `Label` on a `CanvasLayer` shows the count and a frame rate averaged over a
quarter of a second rather than one jittery frame.

Controls: Space, click or tap adds 1000 bunnies.
"""

import numpy as np

from simvx.core import Anchor, CanvasLayer, Input, Key, Label, Node2D, Pointer, Sprite2D, Texture
from simvx.graphics import App

BATCH = 1000
HALF = np.array([13.0, 16.0])  # half the bunny sprite, which is 26 x 32
GRAVITY = 980.0  # px/s^2, downward
BOUNCE = 0.85  # floor restitution
KICK_MIN = 140.0  # a floor bounce slower than this upward is re-kicked...
KICK_RANGE = (320.0, 760.0)  # ...to a fresh upward speed in this range


def bunny_image() -> np.ndarray:
    """A 26 x 32 bunny as an RGBA uint8 array: ears, head, body and face."""
    ys, xs = np.mgrid[0:32, 0:26]

    def ellipse(cx, cy, rx, ry):
        return ((xs - cx) / rx) ** 2 + ((ys - cy) / ry) ** 2 <= 1.0

    img = np.zeros((32, 26, 4), dtype=np.uint8)
    fur = ellipse(13, 22, 9, 8.5) | ellipse(13, 12, 7, 6.5) | ellipse(9, 5, 2.6, 5) | ellipse(17, 5, 2.6, 5)
    img[fur] = (235, 232, 238, 255)
    img[ellipse(9, 5, 1.2, 3.2) | ellipse(17, 5, 1.2, 3.2)] = (240, 170, 190, 255)  # inner ears
    img[ellipse(10.5, 11, 1.1, 1.3) | ellipse(15.5, 11, 1.1, 1.3)] = (40, 35, 45, 255)  # eyes
    img[ellipse(13, 14.5, 1.3, 0.9)] = (235, 140, 160, 255)  # nose
    return img


class Bunnymark(Node2D):
    input_context = {"spawn": [Key.SPACE, Pointer.PRIMARY]}

    def on_ready(self):
        self.rng = np.random.default_rng()
        self.texture = Texture(bunny_image())
        self.sprites: list[Sprite2D] = []
        self.pos = np.empty((0, 2))
        self.vel = np.empty((0, 2))
        hud = self.add_child(CanvasLayer())
        self.status = hud.add_child(Label(font_size=22, anchor=Anchor.TOP_LEFT, inset=12))
        self.frames, self.elapsed, self.fps = 0, 0.0, 0.0
        self.spawn(BATCH)

    def spawn(self, n: int):
        width, height = self.viewport_size
        pos = self.rng.uniform((HALF[0], HALF[1]), (width - HALF[0], height / 2), (n, 2))
        self.pos = np.concatenate([self.pos, pos])
        self.vel = np.concatenate([self.vel, self.rng.uniform((-260, -120), (260, 120), (n, 2))])
        for xy, tint in zip(pos, self.rng.uniform(0.55, 1.0, (n, 3)), strict=True):
            self.sprites.append(self.add_child(Sprite2D(texture=self.texture, position=xy, colour=(*tint, 1.0))))

    def on_update(self, dt: float):
        if Input.just_pressed("spawn"):
            self.spawn(BATCH)

        pos, vel = self.pos, self.vel
        low, high = HALF, np.asarray(self.viewport_size) - HALF
        vel[:, 1] += GRAVITY * dt
        pos += vel * dt
        # Bounce off every edge: point the velocity back inside, then clamp.
        vel[pos < low] = np.abs(vel[pos < low])
        vel[pos > high] = -np.abs(vel[pos > high])
        vel[pos[:, 1] > high[1], 1] *= BOUNCE
        # A floor bounce that lost most of its energy gets a fresh kick, so the
        # swarm never settles into a motionless row along the floor.
        tired = (pos[:, 1] > high[1]) & (vel[:, 1] > -KICK_MIN)
        vel[tired, 1] = -self.rng.uniform(*KICK_RANGE, np.count_nonzero(tired))
        np.clip(pos, low, high, out=pos)

        for sprite, row in zip(self.sprites, pos, strict=True):
            sprite.position[:] = row

        self.frames += 1
        self.elapsed += dt
        if self.elapsed >= 0.25:
            self.fps, self.frames, self.elapsed = self.frames / self.elapsed, 0, 0.0
        self.status.text = f"{len(self.sprites)} bunnies, {self.fps:.0f} fps\nSpace, click or tap: +{BATCH}"


if __name__ == "__main__":
    App(title="Bunnymark", width=960, height=540).run(Bunnymark())