3rb 0.1.0

data/examples/06_custom_shader.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Custom Shaders using ShaderMaterial
+
+require_relative "../lib/3rb"
+
+VERTEX_SHADER = <<~GLSL
+  #version 330 core
+
+  layout(location = 0) in vec3 position;
+  layout(location = 1) in vec3 normal;
+  layout(location = 2) in vec2 uv;
+
+  uniform mat4 modelViewMatrix;
+  uniform mat4 projectionMatrix;
+  uniform float time;
+
+  out vec2 vUv;
+  out vec3 vNormal;
+  out float vDisplacement;
+
+  void main() {
+    vUv = uv;
+    vNormal = normal;
+
+    float displacement = sin(position.x * 5.0 + time) *
+                         sin(position.y * 5.0 + time) * 0.2;
+    vDisplacement = displacement;
+
+    vec3 newPosition = position + normal * displacement;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);
+  }
+GLSL
+
+FRAGMENT_SHADER = <<~GLSL
+  #version 330 core
+
+  in vec2 vUv;
+  in vec3 vNormal;
+  in float vDisplacement;
+
+  uniform float time;
+  uniform vec3 color1;
+  uniform vec3 color2;
+
+  out vec4 fragColor;
+
+  void main() {
+    float mixFactor = (vDisplacement + 0.2) * 2.5;
+    vec3 color = mix(color1, color2, mixFactor);
+
+    float fresnel = pow(1.0 - abs(dot(vNormal, vec3(0.0, 0.0, 1.0))), 2.0);
+    color += fresnel * 0.3;
+
+    fragColor = vec4(color, 1.0);
+  }
+GLSL
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x000011)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 75, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(0, 0, 3)
+
+geometry = Sunrb::SphereGeometry.new(radius: 1, width_segments: 64, height_segments: 64)
+
+shader_material = Sunrb::ShaderMaterial.new(
+  vertex_shader: VERTEX_SHADER,
+  fragment_shader: FRAGMENT_SHADER,
+  uniforms: {
+    time: 0.0,
+    color1: Sunrb::Color.new(0x00ff88),
+    color2: Sunrb::Color.new(0xff0088)
+  }
+)
+
+sphere = Sunrb::Mesh.new(geometry, shader_material)
+scene.add(sphere)
+
+puts "Custom shader material created"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "Custom Shader Example")
+
+time = 0.0
+renderer.run do |delta|
+  time += delta
+  shader_material.uniforms[:time] = time
+  sphere.rotation.y += delta * 0.5
+  renderer.render(scene, camera)
+end

data/examples/07_scene_graph.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Scene Graph - Parent-child relationships (Solar System)
+
+require_relative "../lib/3rb"
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x000022)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 60, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(0, 10, 20)
+camera.look_at(Sunrb::Vector3.new(0, 0, 0))
+
+ambient = Sunrb::AmbientLight.new(color: 0x404040)
+scene.add(ambient)
+
+solar_system = Sunrb::Group.new
+solar_system.name = "solar_system"
+scene.add(solar_system)
+
+sun_geometry = Sunrb::SphereGeometry.new(radius: 1.5)
+sun_material = Sunrb::MeshBasicMaterial.new(color: 0xffff00)
+sun = Sunrb::Mesh.new(sun_geometry, sun_material)
+sun.name = "sun"
+solar_system.add(sun)
+
+earth_orbit = Sunrb::Group.new
+earth_orbit.name = "earth_orbit"
+solar_system.add(earth_orbit)
+
+earth_geometry = Sunrb::SphereGeometry.new(radius: 0.5)
+earth_material = Sunrb::MeshBasicMaterial.new(color: 0x3498db)
+earth = Sunrb::Mesh.new(earth_geometry, earth_material)
+earth.name = "earth"
+earth.position.set(5, 0, 0)
+earth_orbit.add(earth)
+
+moon_orbit = Sunrb::Group.new
+moon_orbit.name = "moon_orbit"
+moon_orbit.position.copy(earth.position)
+earth_orbit.add(moon_orbit)
+
+moon_geometry = Sunrb::SphereGeometry.new(radius: 0.15)
+moon_material = Sunrb::MeshBasicMaterial.new(color: 0xbdc3c7)
+moon = Sunrb::Mesh.new(moon_geometry, moon_material)
+moon.name = "moon"
+moon.position.set(1, 0, 0)
+moon_orbit.add(moon)
+
+mars_orbit = Sunrb::Group.new
+mars_orbit.name = "mars_orbit"
+solar_system.add(mars_orbit)
+
+mars_geometry = Sunrb::SphereGeometry.new(radius: 0.4)
+mars_material = Sunrb::MeshBasicMaterial.new(color: 0xe74c3c)
+mars = Sunrb::Mesh.new(mars_geometry, mars_material)
+mars.name = "mars"
+mars.position.set(8, 0, 0)
+mars_orbit.add(mars)
+
+puts "=== Solar System Demo ==="
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "Scene Graph - Solar System")
+
+renderer.run do |delta|
+  sun.rotation.y += delta * 0.5
+  earth_orbit.rotation.y += delta * 0.8
+  moon_orbit.rotation.y += delta * 2.0
+  mars_orbit.rotation.y += delta * 0.5
+
+  renderer.render(scene, camera)
+end

data/examples/08_orbit_controls.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# OrbitControls - Automatic camera orbit around target
+
+require_relative "../lib/3rb"
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x1a1a2e)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 60, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(5, 5, 5)
+
+controls = Sunrb::OrbitControls.new(camera)
+controls.enable_damping = true
+controls.damping_factor = 0.05
+controls.min_distance = 3
+controls.max_distance = 20
+controls.auto_rotate = true
+controls.auto_rotate_speed = 2.0
+
+ambient = Sunrb::AmbientLight.new(color: 0x404040)
+scene.add(ambient)
+
+directional = Sunrb::DirectionalLight.new(color: 0xffffff, intensity: 0.8)
+directional.position.set(5, 10, 5)
+scene.add(directional)
+
+geometry = Sunrb::BoxGeometry.new(width: 2, height: 2, depth: 2)
+material = Sunrb::MeshBasicMaterial.new(color: 0x00ff88)
+cube = Sunrb::Mesh.new(geometry, material)
+scene.add(cube)
+
+floor_geo = Sunrb::PlaneGeometry.new(width: 20, height: 20)
+floor_mat = Sunrb::MeshBasicMaterial.new(color: 0x333333)
+floor = Sunrb::Mesh.new(floor_geo, floor_mat)
+floor.rotation.x = -Math::PI / 2
+floor.position.y = -1.5
+scene.add(floor)
+
+puts "=== OrbitControls Demo ==="
+puts "Camera auto-rotating around the cube"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "OrbitControls Example")
+
+renderer.run do |delta|
+  controls.update(delta)
+  renderer.render(scene, camera)
+end

data/examples/09_3d_chart.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# 3D Bar Chart - Data visualization
+
+require_relative "../lib/3rb"
+
+DATA = {
+  "Ruby" => 85,
+  "Python" => 92,
+  "JavaScript" => 78,
+  "Go" => 65,
+  "Rust" => 45
+}.freeze
+
+COLORS = [0xe74c3c, 0x3498db, 0xf1c40f, 0x2ecc71, 0x9b59b6].freeze
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0xffffff)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 50, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(8, 8, 12)
+camera.look_at(Sunrb::Vector3.new(0, 2, 0))
+
+ambient = Sunrb::AmbientLight.new(color: 0x606060)
+scene.add(ambient)
+
+directional = Sunrb::DirectionalLight.new(color: 0xffffff, intensity: 0.8)
+directional.position.set(10, 15, 10)
+scene.add(directional)
+
+floor_geo = Sunrb::PlaneGeometry.new(width: 15, height: 10)
+floor_mat = Sunrb::MeshBasicMaterial.new(color: 0xeeeeee)
+floor = Sunrb::Mesh.new(floor_geo, floor_mat)
+floor.rotation.x = -Math::PI / 2
+scene.add(floor)
+
+chart_group = Sunrb::Group.new
+chart_group.name = "chart"
+scene.add(chart_group)
+
+max_value = DATA.values.max.to_f
+bar_width = 1.5
+spacing = 2.5
+
+DATA.each_with_index do |(label, value), index|
+  height = (value / max_value) * 6
+  x_pos = (index - DATA.size / 2.0) * spacing
+
+  bar_geo = Sunrb::BoxGeometry.new(width: bar_width, height: height, depth: bar_width)
+  bar_mat = Sunrb::MeshBasicMaterial.new(color: COLORS[index])
+  bar = Sunrb::Mesh.new(bar_geo, bar_mat)
+  bar.position.set(x_pos, height / 2, 0)
+  bar.name = label
+  chart_group.add(bar)
+end
+
+puts "=== 3D Bar Chart ==="
+puts "Data: #{DATA.map { |k, v| "#{k}: #{v}" }.join(', ')}"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "3D Bar Chart")
+
+time = 0.0
+renderer.run do |delta|
+  time += delta
+  chart_group.children.each_with_index do |bar, i|
+    bar.rotation.y = Math.sin(time + i * 0.5) * 0.1
+  end
+  renderer.render(scene, camera)
+end

data/examples/10_procedural_terrain.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Procedural Terrain Generation using noise functions
+
+require_relative "../lib/3rb"
+
+class SimplexNoise
+  def initialize(seed = 0)
+    @perm = (0...256).to_a.shuffle(random: Random.new(seed))
+    @perm += @perm
+  end
+
+  def noise2d(x, y)
+    xi = x.floor & 255
+    yi = y.floor & 255
+    xf = x - x.floor
+    yf = y - y.floor
+
+    u = fade(xf)
+    v = fade(yf)
+
+    aa = @perm[@perm[xi] + yi]
+    ab = @perm[@perm[xi] + yi + 1]
+    ba = @perm[@perm[xi + 1] + yi]
+    bb = @perm[@perm[xi + 1] + yi + 1]
+
+    lerp(v,
+         lerp(u, grad(aa, xf, yf), grad(ba, xf - 1, yf)),
+         lerp(u, grad(ab, xf, yf - 1), grad(bb, xf - 1, yf - 1)))
+  end
+
+  def octave_noise(x, y, octaves: 4, persistence: 0.5)
+    total = 0.0
+    frequency = 1.0
+    amplitude = 1.0
+    max_value = 0.0
+
+    octaves.times do
+      total += noise2d(x * frequency, y * frequency) * amplitude
+      max_value += amplitude
+      amplitude *= persistence
+      frequency *= 2
+    end
+
+    total / max_value
+  end
+
+  private
+
+  def fade(t)
+    t * t * t * (t * (t * 6 - 15) + 10)
+  end
+
+  def lerp(t, a, b)
+    a + t * (b - a)
+  end
+
+  def grad(hash, x, y)
+    case hash & 3
+    when 0 then x + y
+    when 1 then -x + y
+    when 2 then x - y
+    else -x - y
+    end
+  end
+end
+
+WIDTH = 50
+HEIGHT = 50
+SCALE = 0.1
+HEIGHT_SCALE = 5.0
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x87ceeb)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 60, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(30, 25, 30)
+camera.look_at(Sunrb::Vector3.new(0, 0, 0))
+
+ambient = Sunrb::AmbientLight.new(color: 0x404040)
+scene.add(ambient)
+
+sun = Sunrb::DirectionalLight.new(color: 0xffffcc, intensity: 1.0)
+sun.position.set(50, 50, 50)
+scene.add(sun)
+
+noise = SimplexNoise.new(42)
+
+positions = []
+indices = []
+
+(0...HEIGHT).each do |z|
+  (0...WIDTH).each do |x|
+    height = noise.octave_noise(x * SCALE, z * SCALE, octaves: 6) * HEIGHT_SCALE
+    height = [height, 0].max
+
+    world_x = x - WIDTH / 2.0
+    world_z = z - HEIGHT / 2.0
+    positions.push(world_x, height, world_z)
+  end
+end
+
+(0...(HEIGHT - 1)).each do |z|
+  (0...(WIDTH - 1)).each do |x|
+    a = z * WIDTH + x
+    b = z * WIDTH + x + 1
+    c = (z + 1) * WIDTH + x
+    d = (z + 1) * WIDTH + x + 1
+
+    indices.push(a, b, c)
+    indices.push(b, d, c)
+  end
+end
+
+geometry = Sunrb::BufferGeometry.new
+geometry.set_attribute(:position, Sunrb::Float32BufferAttribute.new(positions, 3))
+geometry.set_index(indices)
+geometry.compute_vertex_normals
+
+material = Sunrb::MeshBasicMaterial.new(color: 0x27ae60)
+
+terrain = Sunrb::Mesh.new(geometry, material)
+terrain.name = "terrain"
+scene.add(terrain)
+
+puts "=== Procedural Terrain Generator ==="
+puts "Grid size: #{WIDTH}x#{HEIGHT}, Vertices: #{positions.length / 3}"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "Procedural Terrain")
+
+angle = 0.0
+renderer.run do |delta|
+  angle += delta * 0.2
+  camera.position.x = Math.cos(angle) * 40
+  camera.position.z = Math.sin(angle) * 40
+  camera.look_at(Sunrb::Vector3.new(0, 0, 0))
+  renderer.render(scene, camera)
+end

data/examples/11_particle_system.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Particle System using Points
+
+require_relative "../lib/3rb"
+
+PARTICLE_COUNT = 200
+SPREAD = 15.0
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x000022)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 75, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(0, 5, 25)
+camera.look_at(Sunrb::Vector3.new(0, 0, 0))
+
+particles_group = Sunrb::Group.new
+particles_group.name = "particles"
+scene.add(particles_group)
+
+particles = []
+PARTICLE_COUNT.times do
+  geo = Sunrb::SphereGeometry.new(radius: 0.1)
+  mat = Sunrb::MeshBasicMaterial.new(
+    color: (0xff0000 + rand(0xffff))
+  )
+  mesh = Sunrb::Mesh.new(geo, mat)
+  mesh.position.set(
+    (rand - 0.5) * SPREAD,
+    (rand - 0.5) * SPREAD,
+    (rand - 0.5) * SPREAD
+  )
+  particles_group.add(mesh)
+  particles << {
+    mesh: mesh,
+    velocity: Sunrb::Vector3.new(
+      (rand - 0.5) * 0.5,
+      rand * 0.5 + 0.2,
+      (rand - 0.5) * 0.5
+    )
+  }
+end
+
+puts "=== Particle System ==="
+puts "Particle count: #{PARTICLE_COUNT}"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "Particle System")
+
+renderer.run do |delta|
+  particles.each do |p|
+    p[:mesh].position.x += p[:velocity].x * delta * 5
+    p[:mesh].position.y += p[:velocity].y * delta * 5
+    p[:mesh].position.z += p[:velocity].z * delta * 5
+
+    if p[:mesh].position.y > SPREAD / 2
+      p[:mesh].position.set(
+        (rand - 0.5) * SPREAD,
+        -SPREAD / 2,
+        (rand - 0.5) * SPREAD
+      )
+    end
+  end
+
+  particles_group.rotation.y += delta * 0.1
+  renderer.render(scene, camera)
+end

data/examples/12_model_loader.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Simple House - Building from basic geometries
+
+require_relative "../lib/3rb"
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x87ceeb)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 60, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(8, 6, 8)
+camera.look_at(Sunrb::Vector3.new(0, 1.5, 0))
+
+ambient = Sunrb::AmbientLight.new(color: 0x606060)
+scene.add(ambient)
+
+sun = Sunrb::DirectionalLight.new(color: 0xffffff, intensity: 0.8)
+sun.position.set(10, 10, 5)
+scene.add(sun)
+
+house = Sunrb::Group.new
+house.name = "house"
+
+body_geo = Sunrb::BoxGeometry.new(width: 4, height: 3, depth: 4)
+body_mat = Sunrb::MeshBasicMaterial.new(color: 0xd35400)
+body = Sunrb::Mesh.new(body_geo, body_mat)
+body.position.y = 1.5
+house.add(body)
+
+roof_geo = Sunrb::ConeGeometry.new(radius: 3.5, height: 2, radial_segments: 4)
+roof_mat = Sunrb::MeshBasicMaterial.new(color: 0x8b4513)
+roof = Sunrb::Mesh.new(roof_geo, roof_mat)
+roof.position.y = 4
+roof.rotation.y = Math::PI / 4
+house.add(roof)
+
+door_geo = Sunrb::BoxGeometry.new(width: 0.8, height: 1.5, depth: 0.1)
+door_mat = Sunrb::MeshBasicMaterial.new(color: 0x5d4037)
+door = Sunrb::Mesh.new(door_geo, door_mat)
+door.position.set(0, 0.75, 2.05)
+house.add(door)
+
+[-1, 1].each do |x|
+  window_geo = Sunrb::BoxGeometry.new(width: 0.6, height: 0.6, depth: 0.1)
+  window_mat = Sunrb::MeshBasicMaterial.new(color: 0x87ceeb)
+  window = Sunrb::Mesh.new(window_geo, window_mat)
+  window.position.set(x * 1.2, 2, 2.05)
+  house.add(window)
+end
+
+scene.add(house)
+
+ground_geo = Sunrb::PlaneGeometry.new(width: 20, height: 20)
+ground_mat = Sunrb::MeshBasicMaterial.new(color: 0x27ae60)
+ground = Sunrb::Mesh.new(ground_geo, ground_mat)
+ground.rotation.x = -Math::PI / 2
+scene.add(ground)
+
+puts "=== Simple House Model ==="
+puts "House parts: #{house.children.length}"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "House Model")
+
+angle = 0.0
+renderer.run do |delta|
+  angle += delta * 0.3
+  camera.position.x = Math.cos(angle) * 10
+  camera.position.z = Math.sin(angle) * 10
+  camera.look_at(Sunrb::Vector3.new(0, 1.5, 0))
+  renderer.render(scene, camera)
+end

data/examples/13_game_prototype.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Simple Game Prototype - Player, enemies, and collision detection
+
+require_relative "../lib/3rb"
+
+class GameObject
+  attr_accessor :mesh, :velocity, :radius
+
+  def initialize(mesh:, radius: 0.5)
+    @mesh = mesh
+    @velocity = Sunrb::Vector3.new
+    @radius = radius
+  end
+
+  def position
+    @mesh.position
+  end
+
+  def update(delta)
+    position.x += velocity.x * delta
+    position.z += velocity.z * delta
+  end
+
+  def collides_with?(other)
+    dx = position.x - other.position.x
+    dz = position.z - other.position.z
+    distance = Math.sqrt(dx * dx + dz * dz)
+    distance < (@radius + other.radius)
+  end
+end
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x1a1a2e)
+
+camera = Sunrb::PerspectiveCamera.new(fov: 60, aspect: 800.0 / 600.0, near: 0.1, far: 1000)
+camera.position.set(0, 15, 15)
+camera.look_at(Sunrb::Vector3.new(0, 0, 0))
+
+ambient = Sunrb::AmbientLight.new(color: 0x404040)
+scene.add(ambient)
+
+sun = Sunrb::DirectionalLight.new(color: 0xffffff, intensity: 0.8)
+sun.position.set(10, 20, 10)
+scene.add(sun)
+
+floor_geo = Sunrb::PlaneGeometry.new(width: 20, height: 20)
+floor_mat = Sunrb::MeshBasicMaterial.new(color: 0x2c3e50)
+floor = Sunrb::Mesh.new(floor_geo, floor_mat)
+floor.rotation.x = -Math::PI / 2
+scene.add(floor)
+
+player_geo = Sunrb::BoxGeometry.new(width: 1, height: 1, depth: 1)
+player_mat = Sunrb::MeshBasicMaterial.new(color: 0x3498db)
+player_mesh = Sunrb::Mesh.new(player_geo, player_mat)
+player_mesh.position.set(0, 0.5, 0)
+scene.add(player_mesh)
+player = GameObject.new(mesh: player_mesh, radius: 0.7)
+
+enemies = []
+5.times do |i|
+  enemy_geo = Sunrb::SphereGeometry.new(radius: 0.5)
+  enemy_mat = Sunrb::MeshBasicMaterial.new(color: 0xe74c3c)
+  enemy_mesh = Sunrb::Mesh.new(enemy_geo, enemy_mat)
+
+  angle = (i.to_f / 5) * Math::PI * 2
+  radius = 5 + rand * 3
+  enemy_mesh.position.set(Math.cos(angle) * radius, 0.5, Math.sin(angle) * radius)
+  scene.add(enemy_mesh)
+
+  enemy = GameObject.new(mesh: enemy_mesh, radius: 0.5)
+  enemy.velocity.set((rand - 0.5) * 4, 0, (rand - 0.5) * 4)
+  enemies << enemy
+end
+
+collectibles = []
+8.times do
+  gem_geo = Sunrb::BoxGeometry.new(width: 0.4, height: 0.4, depth: 0.4)
+  gem_mat = Sunrb::MeshBasicMaterial.new(color: 0xf1c40f)
+  gem_mesh = Sunrb::Mesh.new(gem_geo, gem_mat)
+  gem_mesh.position.set((rand - 0.5) * 16, 0.5, (rand - 0.5) * 16)
+  scene.add(gem_mesh)
+  collectibles << GameObject.new(mesh: gem_mesh, radius: 0.3)
+end
+
+score = 0
+game_over = false
+
+puts "=== Simple Game Prototype ==="
+puts "Enemies: #{enemies.length}, Collectibles: #{collectibles.length}"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "Game Prototype")
+
+time = 0.0
+renderer.run do |delta|
+  time += delta
+
+  unless game_over
+    player.mesh.position.x = Math.sin(time) * 3
+    player.mesh.position.z = Math.cos(time * 0.7) * 3
+
+    enemies.each do |enemy|
+      enemy.update(delta)
+
+      if enemy.position.x.abs > 9
+        enemy.velocity.x *= -1
+        enemy.position.x = enemy.position.x.positive? ? 9 : -9
+      end
+      if enemy.position.z.abs > 9
+        enemy.velocity.z *= -1
+        enemy.position.z = enemy.position.z.positive? ? 9 : -9
+      end
+
+      enemy.mesh.rotation.y += delta * 2
+
+      if player.collides_with?(enemy)
+        game_over = true
+        puts "GAME OVER! Final score: #{score}"
+      end
+    end
+
+    collectibles.reject! do |gem|
+      gem.mesh.rotation.y += delta * 3
+      gem.mesh.rotation.x += delta * 2
+
+      if player.collides_with?(gem)
+        scene.remove(gem.mesh)
+        score += 100
+        puts "Collected! Score: #{score}"
+        true
+      else
+        false
+      end
+    end
+
+    if collectibles.empty? && !game_over
+      puts "YOU WIN! Final score: #{score}"
+      game_over = true
+    end
+  end
+
+  renderer.render(scene, camera)
+end