ruby2d 0.12.1 → 1.0.0

data/examples/logo_animation.rb

@@ -0,0 +1,251 @@
+# Logo animation
+# An animated version of the gem logo with staggered assembly and idle shimmer.
+#
+# Features staggered facet assembly with overshoot, idle floating with
+# color shimmer, a glow layer, sparkle particles, and a fade-in title.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 600          # window width in pixels
+HEIGHT = 500         # window height in pixels
+INTRO_DUR = 1.5      # seconds for each facet to ease into place
+STAGGER = 0.12       # seconds between successive facet starts
+SPARKLE_RATE = 21    # sparkles spawned per second along the outline
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Logo animation', width: WIDTH, height: HEIGHT
+set close_on_esc: true
+
+# === Geometry (same vertices as logo.rb) ===
+
+CX, CY = 299.0, 211.0
+
+VERTICES = {
+  left:  [ 75, 145], tl: [165,  55], tc: [299,  55], tr: [434,  55],
+  right: [524, 145], bot: [299, 368], il: [201, 145], ir: [398, 145]
+}
+
+FACETS = [
+  # Crown (left to right)
+  [:left, :tl, :il,    [0.91, 0.45, 0.43]],   # #e7746e
+  [:tl,   :tc, :il,    [0.86, 0.29, 0.25]],   # #dc4b40
+  [:il,   :tc, :ir,    [0.90, 0.39, 0.36]],   # #e5645c
+  [:tc,   :tr, :ir,    [0.82, 0.28, 0.24]],   # #d2473e
+  [:tr,   :right, :ir, [0.89, 0.36, 0.33]],   # #e35c53
+  # Pavilion (left to right)
+  [:left, :il, :bot,   [0.89, 0.33, 0.29]],   # #e3534b
+  [:il,   :ir, :bot,   [0.85, 0.28, 0.22]],   # #d84738
+  [:right, :ir, :bot,  [0.78, 0.26, 0.23]]    # #c7433a
+]
+
+OUTLINE_KEYS = [:left, :tl, :tc, :tr, :right, :bot]
+
+# === Intro: random starting offsets per facet ===
+
+srand(42)
+INTRO_OFFSETS = FACETS.map do
+  [rand(-500..500).to_f, rand(-400..400).to_f, rand(-200..200).to_f]
+end
+INTRO_END = FACETS.length * STAGGER + INTRO_DUR
+
+# === Text (drawn manually in render block) ===
+
+logo_text = Text.new('Ruby 2D', x: 0, y: 0, size: 40, add: false)
+
+# === Particles ===
+
+particles = []
+
+# === Starfield (fixed positions, each star twinkles independently) ===
+
+STARS = 90.times.map do
+  {
+    x: rand(0.0..WIDTH.to_f), y: rand(0.0..HEIGHT.to_f),
+    size: rand(1.0..2.5), brightness: rand(0.3..0.8),
+    phase: rand(0.0..Math::PI * 2), speed: rand(0.5..2.0)
+  }
+end
+
+# === Helpers ===
+
+def ease_out_back(t)
+  t = t.clamp(0.0, 1.0)
+  c1 = 1.70158
+  c3 = c1 + 1.0
+  1.0 + c3 * (t - 1.0) ** 3 + c1 * (t - 1.0) ** 2
+end
+
+def rotate_pt(x, y, cx, cy, a)
+  c, s = Math.cos(a), Math.sin(a)
+  dx, dy = x - cx, y - cy
+  [cx + dx * c - dy * s, cy + dx * s + dy * c]
+end
+
+def xform(vx, vy, cx, cy, sc, rot, tx, ty)
+  x = cx + (vx - cx) * sc
+  y = cy + (vy - cy) * sc
+  x, y = rotate_pt(x, y, cx, cy, rot)
+  [x + tx, y + ty]
+end
+
+# Wrap a flat [r, g, b, a] into a per-vertex color array for .render methods
+def color3(c) = [c, c, c]
+def color4(c) = [c, c, c, c]
+
+# === Update loop (particle state) ===
+
+update do |dt|
+  t = elapsed
+  idle_t = [t - INTRO_END, 0.0].max
+
+  # Spawn sparkles along the outline after intro settles
+  if idle_t > 0.5 && rand < SPARKLE_RATE * dt
+    vx, vy = VERTICES[OUTLINE_KEYS.sample]
+    float_y = Math.sin(idle_t * 1.2) * 10.0
+    particles << {
+      x: vx + rand(-20.0..20.0),
+      y: vy + rand(-20.0..20.0) + float_y,
+      vx: rand(-42.0..42.0),
+      vy: rand(-84.0..-18.0),
+      life: 1.0,
+      size: rand(2.0..5.0)
+    }
+  end
+
+  particles.each do |p|
+    p[:x] += p[:vx] * dt
+    p[:y] += p[:vy] * dt
+    p[:life] -= dt
+  end
+  particles.reject! { |p| p[:life] <= 0 }
+end
+
+# === Render loop (all drawing) ===
+
+render do
+  t = elapsed
+  idle_t = [t - INTRO_END, 0.0].max
+
+  # Global idle transforms
+  float_y    = Math.sin(idle_t * 1.2) * 10.0
+  global_rot = Math.sin(idle_t * 0.5) * 0.03
+  global_sc  = 1.0 + Math.sin(idle_t * 2.0) * 0.015
+
+  # --- Background gradient (deep navy → dark charcoal, slowly shifting) ---
+  shift = Math.sin(t * 0.15) * 0.02
+  top_l = [0.05 + shift, 0.06 + shift, 0.13 + shift * 2, 1.0]
+  top_r = [0.07 + shift, 0.06 + shift, 0.15 + shift * 2, 1.0]
+  bot_l = [0.10 - shift, 0.07 - shift, 0.09 - shift, 1.0]
+  bot_r = [0.08 - shift, 0.07 - shift, 0.11 - shift, 1.0]
+  Rectangle.render(x: 0, y: 0, width: 600, height: 500, color: [top_l, top_r, bot_r, bot_l])
+
+  # --- Starfield ---
+  STARS.each do |s|
+    twinkle = (Math.sin(t * s[:speed] + s[:phase]) * 0.5 + 0.5) * s[:brightness]
+    Square.render(
+      x: s[:x], y: s[:y], size: s[:size],
+      color: color4([0.7, 0.75, 1.0, twinkle])
+    )
+  end
+
+  # Smooth ramp for idle effects (0→1 over ~1.5 seconds after intro)
+  idle_blend = (idle_t / 1.5).clamp(0.0, 1.0)
+
+  # --- Glow layer (slightly larger, semi-transparent echo) ---
+  if idle_blend > 0.01
+    glow_pulse = (Math.sin(idle_t * 1.8) * 0.5 + 0.5) * 0.12 * idle_blend
+    glow_sc = global_sc * 1.07
+
+    FACETS.each do |v1k, v2k, v3k, rgb|
+      pts = [v1k, v2k, v3k].map do |k|
+        xform(*VERTICES[k], CX, CY, glow_sc, global_rot, 0, float_y)
+      end
+      Triangle.render(
+        x1: pts[0][0], y1: pts[0][1],
+        x2: pts[1][0], y2: pts[1][1],
+        x3: pts[2][0], y3: pts[2][1],
+        color: color3([rgb[0], rgb[1], rgb[2], glow_pulse])
+      )
+    end
+  end
+
+  # --- Facets ---
+  FACETS.each_with_index do |(v1k, v2k, v3k, rgb), i|
+    off_x, off_y, off_deg = INTRO_OFFSETS[i]
+
+    # Intro: ease from scattered position to final
+    ft   = (t - i * STAGGER) / INTRO_DUR
+    ease = ease_out_back(ft)
+
+    dx  = off_x * (1.0 - ease)
+    dy  = off_y * (1.0 - ease)
+    rot = off_deg * Math::PI / 180.0 * (1.0 - ease)
+    alpha = ft.clamp(0.0, 1.0)
+
+    # Color shimmer (fades in gradually via idle_blend)
+    shimmer = Math.sin(idle_t * 3.0 + i * 0.9) * 0.07 * idle_blend
+    color = [
+      (rgb[0] + shimmer).clamp(0.0, 1.0),
+      (rgb[1] + shimmer * 0.5).clamp(0.0, 1.0),
+      (rgb[2] + shimmer * 0.3).clamp(0.0, 1.0),
+      alpha
+    ]
+
+    pts = [v1k, v2k, v3k].map do |k|
+      xform(*VERTICES[k], CX, CY, global_sc, global_rot + rot, dx, dy + float_y)
+    end
+
+    Triangle.render(
+      x1: pts[0][0], y1: pts[0][1],
+      x2: pts[1][0], y2: pts[1][1],
+      x3: pts[2][0], y3: pts[2][1],
+      color: color3(color)
+    )
+  end
+
+  # --- Border (fades in after facets land) ---
+  border_alpha = ((t - FACETS.length * STAGGER) / INTRO_DUR).clamp(0.0, 1.0)
+
+  if border_alpha > 0.01
+    outline_pts = OUTLINE_KEYS.map do |k|
+      xform(*VERTICES[k], CX, CY, global_sc, global_rot, 0, float_y)
+    end
+
+    border_color = [1.0, 1.0, 1.0, border_alpha]
+
+    outline_pts.each_with_index do |pt, i|
+      npt = outline_pts[(i + 1) % outline_pts.length]
+      Line.render(
+        x1: pt[0], y1: pt[1], x2: npt[0], y2: npt[1],
+        stroke_width: 8, color: border_color
+      )
+    end
+
+    # Cap the joints with circles to close corner gaps
+    outline_pts.each do |pt|
+      Circle.render(x: pt[0], y: pt[1], radius: 4, sectors: 16, color: border_color)
+    end
+  end
+
+  # --- Sparkle particles ---
+  particles.each do |p|
+    a  = (p[:life] ** 0.6).clamp(0.0, 1.0)
+    sz = p[:size] * (0.3 + 0.7 * p[:life])
+    Square.render(
+      x: p[:x], y: p[:y] + float_y * 0.15,
+      size: sz, color: color4([1.0, 0.85, 0.7, a * 0.7])
+    )
+  end
+
+  # --- Logo text (slides up and fades in after intro) ---
+  text_t = [(t - INTRO_END - 0.3) * 1.5, 0.0].max.clamp(0.0, 1.0)
+  if text_t > 0.01
+    text_y = 400.0 + float_y + (1.0 - text_t) * 25.0
+    logo_text.render(x: 210, y: text_y, color: [0.93, 0.90, 0.88, text_t])
+  end
+end
+
+show

data/examples/lorenz_attractor.rb

@@ -0,0 +1,115 @@
+# Lorenz attractor
+# Lorenz's three-equation convection model traces its butterfly attractor in 3D.
+#
+# Edward Lorenz's three-equation toy model of atmospheric convection
+#
+#   dx/dt = σ (y − x)
+#   dy/dt = x (ρ − z) − y
+#   dz/dt = x y − β z
+#
+# never settles and never repeats, yet stays bounded inside a strange,
+# butterfly-shaped region. Here it's integrated step by step with
+# Euler, kept as a 3D trail, then perspective-projected and depth-shaded.
+# The view rotates so you can see the structure from every angle.
+# Press R to start over from a different seed point.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+SIGMA = 10.0             # classical Lorenz parameters
+RHO = 28.0
+BETA = 8.0 / 3.0
+DT = 0.005               # integration step (small enough for Euler stability)
+STEPS_PER_FRAME = 60     # integration steps applied each frame
+TRAIL_LEN = 2200         # how many trail points to keep
+SCALE = 11               # pixels per Lorenz unit
+CAMERA = 180.0           # camera distance in scaled units
+TILT = 0.35              # fixed tilt around the screen-X axis (radians)
+SPIN_RATE = 0.25         # idle rotation around the vertical axis (rad/sec)
+
+CX = WIDTH  / 2
+CY = HEIGHT / 2
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Lorenz attractor',
+    width: WIDTH, height: HEIGHT, background: '#06081a'
+set close_on_esc: true
+
+# === State ===
+
+lx = 0.0; ly = 0.0; lz = 0.0
+trail = []          # collected (lx, ly, lz) tuples in integration order
+spin = 0.0
+
+reset = lambda do
+  lx = 0.1
+  ly = 0.0
+  lz = 0.0
+  trail.clear
+end
+
+reset.call
+
+# === Input ===
+
+on key_down: :r do
+  reset.call
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  spin += SPIN_RATE * dt
+
+  STEPS_PER_FRAME.times do
+    dxv = SIGMA * (ly - lx)
+    dyv = lx * (RHO - lz) - ly
+    dzv = lx * ly - BETA * lz
+    lx += DT * dxv
+    ly += DT * dyv
+    lz += DT * dzv
+    trail << [lx, ly, lz]
+  end
+
+  trail.shift(trail.length - TRAIL_LEN) if trail.length > TRAIL_LEN
+end
+
+# === Render ===
+
+# Lorenz `z` becomes screen-vertical (the convection variable is
+# naturally the "up" axis); Lorenz `y` becomes screen-depth. Each trail
+# point is rotated around the vertical axis by `spin`, tilted by a
+# fixed amount around the horizontal axis, then perspective-projected.
+# Per-vertex color encodes depth so the trail dims as it wraps behind.
+render do
+  cs = Math.cos(spin); ss = Math.sin(spin)
+  ct = Math.cos(TILT); st = Math.sin(TILT)
+
+  pts = []
+  colors = []
+  trail.each do |px, py, pz|
+    wx = px
+    wy = pz - 25     # center the attractor vertically
+    wz = py
+
+    wy2 =  wy * ct - wz * st
+    wz2 =  wy * st + wz * ct
+
+    wx3 =  wx * cs + wz2 * ss
+    wz3 = -wx * ss + wz2 * cs
+
+    f = CAMERA / (CAMERA - wz3)
+    pts << [CX + wx3 * SCALE * f, CY - wy2 * SCALE * f]
+
+    t = ((wz3 + 30) / 60.0).clamp(0.0, 1.0)
+    colors << [0.30 + 0.65 * t, 0.50 + 0.45 * t, 0.85 + 0.15 * t, 0.20 + 0.75 * t]
+  end
+
+  Polyline.render(points: pts, color: colors, stroke_width: 1.5) if pts.length >= 2
+end
+
+show

data/examples/mandelbrot.rb

@@ -0,0 +1,207 @@
+# Mandelbrot zoomer
+# Click to zoom into the Mandelbrot set, rendered fresh to a Canvas.
+#
+# Click anywhere to zoom in 4x at the cursor; right-click to zoom out.
+# Press `r` to reset to the home view. Each view is rendered in 2x2 blocks,
+# one horizontal band per frame, so the window stays responsive and a progress
+# bar can track the work; within a band, pixels are grouped by escape-time
+# bucket so each color is drawn in a single batched call.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+PIXEL = 2                # render block size (smaller = sharper, slower)
+BAND_ROWS = 16           # block-rows rendered per frame. The set is drawn one
+                         # band at a time so only a band's worth of rectangles is
+                         # ever live at once — without this bound a deep zoom's
+                         # arrays overflow the mruby/WebAssembly heap and abort
+                         # the tab. Larger = fewer frames, more peak memory.
+MAX_ITER = 80            # iterations before declaring "in the set"
+ZOOM_FACTOR = 4.0        # multiplicative zoom per click
+COOLDOWN_FRAMES = 15     # frames that ignore input after a render finishes, so a
+                         # rapid double-click reads as one zoom, not two
+HOME_X = -0.5            # home view center (real)
+HOME_Y = 0.0             # home view center (imaginary)
+HOME_W = 3.5             # home view width in complex-plane units
+
+PIXELS_W = WIDTH / PIXEL
+PIXELS_H = HEIGHT / PIXEL
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Mandelbrot zoomer', width: WIDTH, height: HEIGHT
+set close_on_esc: true
+
+canvas = Canvas.new(x: 0, y: 0, width: WIDTH, height: HEIGHT, fill: [0, 0, 0, 1])
+status = Text.new('', x: 8, y: HEIGHT - 22, size: 13, color: [1.0, 1.0, 1.0, 0.7], z: 10)
+
+# === Rendering overlay ===
+#
+# A centered "busy" panel shown while a view streams in: a translucent black
+# backdrop (so the label reads over any part of the fractal), a prominent label,
+# and a progress bar that fills as bands complete. `x:/y: :center` re-resolve
+# against the live viewport each frame. The bar's track and fill share a fixed
+# left edge so the fill grows rightward instead of staying centered.
+
+PANEL_W = 320
+PANEL_H = 108
+BAR_W = 250
+BAR_H = 12
+PANEL_Y = (HEIGHT - PANEL_H) / 2
+BAR_X = (WIDTH - BAR_W) / 2
+
+overlay_panel = Rectangle.new(x: :center, y: :center, width: PANEL_W, height: PANEL_H,
+                              color: [0.0, 0.0, 0.0, 0.6], z: 20)
+overlay_label = Text.new('Rendering…', x: :center, y: PANEL_Y + 20, size: 30,
+                         color: 'white', z: 22)
+progress_track = Rectangle.new(x: BAR_X, y: PANEL_Y + 72, width: BAR_W, height: BAR_H,
+                               color: [1.0, 1.0, 1.0, 0.18], z: 21)
+progress_fill = Rectangle.new(x: BAR_X, y: PANEL_Y + 72, width: 0, height: BAR_H,
+                              color: '#fbbf24', z: 22)
+overlay = [overlay_panel, progress_track, progress_fill, overlay_label]
+
+# === Palette ===
+
+PALETTE = Array.new(MAX_ITER + 1) do |n|
+  if n >= MAX_ITER
+    [0.02, 0.02, 0.04, 1]
+  else
+    h = (n.to_f / 32 + 0.6) % 1.0
+    s = 0.7
+    v = 1.0
+    i = (h * 6).floor
+    f = h * 6 - i
+    p = v * (1 - s)
+    q = v * (1 - f * s)
+    tt = v * (1 - (1 - f) * s)
+    rgb = case i % 6
+          when 0 then [v, tt, p]
+          when 1 then [q, v, p]
+          when 2 then [p, v, tt]
+          when 3 then [p, q, v]
+          when 4 then [tt, p, v]
+          else        [v, p, q]
+          end
+    rgb + [1.0]
+  end
+end
+
+# === Rendering ===
+
+# Render a single horizontal band, block-rows [py_start, py_end), into the
+# canvas. Pixels are sorted into escape-time buckets and each non-empty bucket
+# is drawn in one batched call. One band's worth of rectangles is all that is
+# ever live, so peak memory stays bounded no matter how deep the zoom — the
+# whole-image bucket set would otherwise overflow the mruby/web heap.
+def render_band(canvas, cx, cy, vw, py_start, py_end)
+  view_h = vw * HEIGHT.to_f / WIDTH
+  inv_w = vw / PIXELS_W
+  inv_h = view_h / PIXELS_H
+  origin_x = cx - vw / 2.0
+  origin_y = cy - view_h / 2.0
+  buckets = Array.new(MAX_ITER + 1) { [] }
+  py = py_start
+  while py < py_end
+    cy_p = origin_y + py * inv_h
+    PIXELS_W.times do |px|
+      cx_p = origin_x + px * inv_w
+      zr = 0.0
+      zi = 0.0
+      n = 0
+      while n < MAX_ITER && zr * zr + zi * zi < 4.0
+        zr_new = zr * zr - zi * zi + cx_p
+        zi = 2 * zr * zi + cy_p
+        zr = zr_new
+        n += 1
+      end
+      buckets[n] << [px * PIXEL, py * PIXEL, PIXEL, PIXEL]
+    end
+    py += 1
+  end
+  buckets.each_with_index do |rects, n|
+    next if rects.empty?
+    canvas.fill_rectangles(rectangles: rects, color: PALETTE[n])
+  end
+end
+
+def update_status(status, cx, cy, vw)
+  zoom = HOME_W / vw
+  status.content = format('center: (%.5f, %.5f)   zoom: %.1fx', cx, cy, zoom)
+end
+
+# === State ===
+
+center_x  = HOME_X
+center_y  = HOME_Y
+view_w    = HOME_W
+rendering = false        # true while a view is streaming in across frames
+band_py   = 0            # next block-row to render this pass
+cooldown  = 0            # frames left before input is accepted again
+
+# Begin streaming the current view. The `update` loop renders one band per
+# frame from here; the overlay stays up until the last band lands.
+start_render = lambda do
+  rendering = true
+  band_py = 0
+  progress_fill.width = 0
+  overlay.each { |element| element.show }
+end
+
+# Kick off the first render so the window can appear immediately and fill in,
+# rather than blocking on a full render before it is even visible.
+start_render.call
+
+# === Input ===
+#
+# Clicks are ignored while a render is streaming or during the brief cooldown
+# after one, so mashing the mouse can't queue up a stack of zooms.
+
+on :mouse_down do |event|
+  next if rendering || cooldown > 0
+  view_h = view_w * HEIGHT.to_f / WIDTH
+  target_x = center_x + (event.x.to_f / WIDTH - 0.5) * view_w
+  target_y = center_y + (event.y.to_f / HEIGHT - 0.5) * view_h
+  if event.button? :right
+    view_w *= ZOOM_FACTOR
+  else
+    view_w /= ZOOM_FACTOR
+  end
+  center_x = target_x
+  center_y = target_y
+  start_render.call
+end
+
+on key_down: :r do
+  next if rendering || cooldown > 0
+  center_x = HOME_X
+  center_y = HOME_Y
+  view_w   = HOME_W
+  start_render.call
+end
+
+# === Per-frame update ===
+#
+# Render the next band, advance the progress bar, and — on the final band —
+# refresh the status line, drop the overlay, and start the input cooldown.
+
+update do
+  cooldown -= 1 if cooldown > 0
+  next unless rendering
+
+  band_end = [band_py + BAND_ROWS, PIXELS_H].min
+  render_band(canvas, center_x, center_y, view_w, band_py, band_end)
+  band_py = band_end
+  progress_fill.width = (BAR_W * (band_py.to_f / PIXELS_H)).round
+
+  if band_py >= PIXELS_H
+    rendering = false
+    cooldown = COOLDOWN_FRAMES
+    update_status(status, center_x, center_y, view_w)
+    overlay.each { |element| element.hide }
+  end
+end
+
+show