Documentation

import { initWindow, windowShouldClose, beginDrawing,
         endDrawing, clearBackground, drawText,
         Colors, closeWindow } from "bloom";

initWindow(800, 450, "Hello Bloom");

while (!windowShouldClose()) {
  beginDrawing();
  clearBackground(Colors.RAYWHITE);
  drawText("Hello, Bloom!", 190, 200, 20, Colors.DARKGRAY);
  endDrawing();
}

closeWindow();

initWindow(800, 600, "My Game");
setTargetFPS(60);

while (!windowShouldClose()) {
  const dt = getDeltaTime();  // seconds since last frame

  // 1. Update game state
  playerX = playerX + speed * dt;

  // 2. Draw everything
  beginDrawing();
  clearBackground(Colors.BLACK);
  // ... draw calls here ...
  endDrawing();
}

closeWindow();

my-game/
  src/
    main.ts           # Entry point
    player.ts
    enemies.ts
  assets/
    sprites/          # PNG, JPG
    models/           # glTF, OBJ
    sounds/           # WAV, OGG, MP3
    fonts/            # TTF, OTF
  package.json

import { initWindow } from "bloom/core";
import { drawRect } from "bloom/shapes";
import { vec3Add } from "bloom/math";

// Or import everything from the barrel export:
import { initWindow, drawRect, vec3Add } from "bloom";

// Vectors
interface Vec2  { x: number; y: number }
interface Vec3  { x: number; y: number; z: number }
interface Vec4  { x: number; y: number; z: number; w: number }

// Visual
interface Color { r: number; g: number; b: number; a: number }  // 0-255
interface Rect  { x: number; y: number; width: number; height: number }

// Cameras
interface Camera2D {
  offset: Vec2;    // camera offset (screen center)
  target: Vec2;    // camera target (world position)
  rotation: number; // rotation in degrees
  zoom: number;     // zoom level (1.0 = no zoom)
}

interface Camera3D {
  position: Vec3;   // camera position
  target: Vec3;     // look-at point
  up: Vec3;         // up direction
  fovy: number;     // field of view Y (degrees)
  projection: number; // 0 = perspective, 1 = orthographic
}

// Resources (handle-based)
interface Texture { handle: number; width: number; height: number }
interface Font    { handle: number; size: number }
interface Sound   { handle: number }
interface Music   { handle: number }
interface Model   { handle: number }

// Quaternion
interface Quat { x: number; y: number; z: number; w: number }

// 3D Geometry
interface Ray         { position: Vec3; direction: Vec3 }
interface BoundingBox { min: Vec3; max: Vec3 }
interface RayHit {
  hit: boolean; distance: number;
  point: Vec3; normal: Vec3;
}
interface FrustumPlanes { planes: Vec4[] }

// Matrix (column-major, 16 elements)
type Mat4 = number[];

// One-shot actions (menus, jumping, shooting)
if (isKeyPressed(Key.SPACE)) jump();
if (isKeyPressed(Key.ENTER)) selectMenuItem();

// Continuous movement (hold to move)
if (isKeyDown(Key.LEFT))  x -= speed * dt;
if (isKeyDown(Key.RIGHT)) x += speed * dt;
if (isKeyDown(Key.W))     y -= speed * dt;
if (isKeyDown(Key.S))     y += speed * dt;

// Mouse
const mouse = getMousePosition();
if (isMouseButtonPressed(MouseButton.LEFT)) {
  shoot(mouse.x, mouse.y);
}

const camera: Camera2D = {
  offset: { x: 400, y: 300 },    // center of 800x600 screen
  target: { x: player.x, y: player.y }, // follow player
  rotation: 0,
  zoom: 1.0
};

// Smooth follow
camera.target.x += (player.x - camera.target.x) * 8 * dt;
camera.target.y += (player.y - camera.target.y) * 8 * dt;

beginMode2D(camera);
// World-space drawing here — moves with camera
drawRect(player.x, player.y, 32, 32, Colors.BLUE);
endMode2D();

// Screen-space drawing here — stays fixed (HUD)
drawText("Score: 100", 10, 10, 20, Colors.WHITE);

const camera: Camera3D = {
  position: { x: 10, y: 10, z: 10 }, // eye position
  target: { x: 0, y: 0, z: 0 },     // look-at point
  up: { x: 0, y: 1, z: 0 },         // up direction
  fovy: 45,                       // field of view (degrees)
  projection: 0                   // 0=perspective, 1=orthographic
};

beginMode3D(camera);
drawCube({ x: 0, y: 0, z: 0 }, 2, 2, 2, Colors.RED);
drawGrid(10, 1);
endMode3D();

// Rectangle vs Rectangle (AABB)
const player: Rect = { x: 100, y: 100, width: 32, height: 32 };
const enemy: Rect  = { x: 120, y: 110, width: 32, height: 32 };

if (checkCollisionRecs(player, enemy)) {
  // Get the overlap area
  const overlap = getCollisionRec(player, enemy);
}

// Circle vs Circle
if (checkCollisionCircles(
  { x: 100, y: 100 }, 20,  // center1, radius1
  { x: 130, y: 110 }, 15   // center2, radius2
)) {
  // collision!
}

// Point in rectangle (mouse clicks, UI)
const mouse = getMousePosition();
if (checkCollisionPointRec(mouse, button)) {
  // hovering over button
}

initAudio();

// Sound effects (loaded fully, play instantly)
const hitSound = loadSound("sounds/hit.wav");
const coinSound = loadSound("sounds/coin.ogg");
setSoundVolume(coinSound, 0.7);

// Background music (streamed)
const bgm = loadMusic("music/theme.ogg");
setMusicVolume(bgm, 0.5);
playMusic(bgm);

while (!windowShouldClose()) {
  updateMusicStream(bgm);  // REQUIRED every frame

  if (playerHit) playSound(hitSound);
  if (coinCollected) playSound(coinSound);

  // ... drawing ...
}

closeAudio();

const ballRect: Rect = {
  x: ballX - BALL_RADIUS, y: ballY - BALL_RADIUS,
  width: BALL_RADIUS * 2, height: BALL_RADIUS * 2
};

if (checkCollisionRecs(ballRect, leftPaddle) && ballVelX < 0) {
  ballVelX = -ballVelX;
  // Angle varies based on where ball hits paddle
  const hitPos = (ballY - leftPaddleY) / PADDLE_HEIGHT;
  ballVelY = BALL_SPEED * (hitPos - 0.5) * 2;
}

const camera: Camera2D = {
  offset: { x: SCREEN_WIDTH / 2, y: SCREEN_HEIGHT / 2 },
  target: { x: player.x * TILE_SIZE, y: player.y * TILE_SIZE },
  rotation: 0, zoom: 1.0
};

// Smooth easing toward player each frame
camera.target.x += (targetX - camera.target.x) * 8 * dt;
camera.target.y += (targetY - camera.target.y) * 8 * dt;

// Zoom with +/- keys
if (isKeyDown(Key.EQUAL)) camera.zoom = clamp(camera.zoom + dt, 0.5, 3.0);
if (isKeyDown(Key.MINUS)) camera.zoom = clamp(camera.zoom - dt, 0.5, 3.0);

// Pre-allocate pool (no allocations during gameplay)
const particles: Particle[] = [];
for (let i = 0; i < MAX_PARTICLES; i++) {
  particles.push({ x: 0, y: 0, vx: 0, vy: 0,
    life: 0, maxLife: 0, color: Colors.WHITE, active: false });
}

// Spawn by reusing inactive entries
function spawnExplosion(x: number, y: number) {
  for (let i = 0; i < MAX_PARTICLES; i++) {
    if (!particles[i].active) {
      const angle = randomFloat(0, Math.PI * 2);
      const speed = randomFloat(50, 200);
      particles[i].x = x; particles[i].y = y;
      particles[i].vx = Math.cos(angle) * speed;
      particles[i].vy = Math.sin(angle) * speed;
      particles[i].life = randomFloat(0.3, 0.8);
      particles[i].active = true;
      break;
    }
  }
}