quake-rb 0.1.0

data/lib/quake/renderer/gl_hud.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Renders Quake's status bar HUD using graphics from gfx.wad.
+    # Uses orthographic projection for 2D rendering on top of the 3D scene.
+    #
+    # Layout matches original Quake sbar.c (320x200 virtual resolution):
+    #   Bottom bar (sbar): [armor_icon][armor] [face] [health] [ammo_icon][ammo]
+    #   Above that (ibar): weapon slots and ammo counts
+    class GLHud
+      VIRTUAL_WIDTH  = 320
+      VIRTUAL_HEIGHT = 200
+      SBAR_HEIGHT    = 24  # status bar height
+      DIGIT_WIDTH    = 24  # big number digit width
+
+      def initialize(wad, palette, screen_width, screen_height)
+        @wad = wad
+        @palette = palette
+        @screen_width = screen_width
+        @screen_height = screen_height
+        @textures = {} # name -> { id:, width:, height: }
+
+        upload_hud_graphics
+      end
+
+      def render(player_state)
+        setup_ortho
+
+        GL.Enable(GL::TEXTURE_2D)
+        GL.Enable(GL::BLEND)
+        GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+        GL.Disable(GL::DEPTH_TEST)
+        GL.Color4f(1.0, 1.0, 1.0, 1.0)
+
+        draw_sbar(player_state)
+
+        GL.Enable(GL::DEPTH_TEST)
+        GL.Disable(GL::BLEND)
+
+        restore_projection
+      end
+
+      private
+
+      def setup_ortho
+        GL.MatrixMode(GL::PROJECTION)
+        GL.PushMatrix
+        GL.LoadIdentity
+        # Y=0 at bottom, Y=200 at top (standard GL orientation)
+        GL.Ortho(0, VIRTUAL_WIDTH, 0, VIRTUAL_HEIGHT, -1, 1)
+
+        GL.MatrixMode(GL::MODELVIEW)
+        GL.PushMatrix
+        GL.LoadIdentity
+      end
+
+      def restore_projection
+        GL.MatrixMode(GL::MODELVIEW)
+        GL.PopMatrix
+        GL.MatrixMode(GL::PROJECTION)
+        GL.PopMatrix
+        GL.MatrixMode(GL::MODELVIEW)
+      end
+
+      # Draw a QPic texture at position (x, y) where y is measured from
+      # the bottom of the screen (0 = bottom edge).
+      def draw_pic(x, y, name)
+        tex = @textures[name]
+        return unless tex
+
+        GL.BindTexture(GL::TEXTURE_2D, tex[:id])
+
+        w = tex[:width]
+        h = tex[:height]
+
+        GL.Begin(GL::QUADS)
+        GL.TexCoord2f(0.0, 0.0); GL.Vertex2f(x, y + h)
+        GL.TexCoord2f(1.0, 0.0); GL.Vertex2f(x + w, y + h)
+        GL.TexCoord2f(1.0, 1.0); GL.Vertex2f(x + w, y)
+        GL.TexCoord2f(0.0, 1.0); GL.Vertex2f(x, y)
+        GL.End
+      end
+
+      def draw_sbar(ps)
+        # Sbar sits at the very bottom of the screen
+        sbar_y = 0
+
+        # Status bar background (320x24)
+        draw_pic(0, sbar_y, "sbar")
+
+        # Armor number (x=24, 3 digits)
+        draw_num(24, sbar_y, ps.armor, 3, ps.armor <= 25)
+
+        # Armor type icon (x=0)
+        if ps.armor > 0
+          armor_icon = case ps.armor_type
+                       when 1 then "sb_armor1"
+                       when 2 then "sb_armor2"
+                       else "sb_armor3"
+                       end
+          draw_pic(0, sbar_y, armor_icon) if @textures[armor_icon]
+        end
+
+        # Face (x=112)
+        draw_pic(112, sbar_y, health_face(ps.health))
+
+        # Health (x=136, 3 digits)
+        draw_num(136, sbar_y, ps.health, 3, ps.health <= 25)
+
+        # Ammo icon (x=224)
+        ammo_icon = ammo_type_icon(ps.current_ammo_type)
+        draw_pic(224, sbar_y, ammo_icon) if ammo_icon && @textures[ammo_icon]
+
+        # Ammo count (x=248, 3 digits)
+        ammo = ps.current_ammo_count
+        draw_num(248, sbar_y, ammo, 3, ammo && ammo <= 10) if ammo
+      end
+
+      # Draw a right-justified number using big digit graphics.
+      # x is the LEFT edge of the digit field.
+      # Matches Quake's Sbar_DrawNum exactly.
+      def draw_num(x, y, value, digits, red = false)
+        return unless value
+
+        value = value.to_i
+        negative = value < 0
+        value = value.abs
+
+        str = value.to_s
+        str = "-#{str}" if negative
+
+        # Right-justify: pad left with empty space
+        if str.length < digits
+          x += (digits - str.length) * DIGIT_WIDTH
+        end
+
+        # Truncate from left if too many digits
+        ptr = str.length > digits ? str[str.length - digits..] : str
+
+        ptr.each_char do |ch|
+          if ch == "-"
+            draw_pic(x, y, "num_minus")
+          else
+            prefix = red ? "anum_" : "num_"
+            draw_pic(x, y, "#{prefix}#{ch}")
+          end
+          x += DIGIT_WIDTH
+        end
+      end
+
+      def health_face(health)
+        # Quake face mapping: face1 = best (health 100+), face5 = worst (near death)
+        # sb_faces[4] = face1, sb_faces[0] = face5
+        # f = health >= 100 ? 4 : health / 20
+        f = health >= 100 ? 4 : [health / 20, 0].max
+        "face#{5 - f}"
+      end
+
+      def ammo_type_icon(ammo_type)
+        case ammo_type
+        when :shells  then "sb_shells"
+        when :nails   then "sb_nails"
+        when :rockets then "sb_rocket"
+        when :cells   then "sb_cells"
+        end
+      end
+
+      def upload_hud_graphics
+        # Status bar background
+        upload_wad_pic("sbar")
+
+        # Big numbers (0-9) and alternate (red) numbers
+        10.times do |i|
+          upload_wad_pic("num_#{i}")
+          upload_wad_pic("anum_#{i}")
+        end
+        upload_wad_pic("num_minus")
+        upload_wad_pic("num_colon")
+        upload_wad_pic("num_slash")
+
+        # Face graphics
+        (1..5).each { |i| upload_wad_pic("face#{i}") }
+        (1..5).each { |i| upload_wad_pic("face_p#{i}") }
+
+        # Armor icons
+        upload_wad_pic("sb_armor1")
+        upload_wad_pic("sb_armor2")
+        upload_wad_pic("sb_armor3")
+
+        # Ammo type icons
+        upload_wad_pic("sb_shells")
+        upload_wad_pic("sb_nails")
+        upload_wad_pic("sb_rocket")
+        upload_wad_pic("sb_cells")
+
+        count = @textures.size
+        puts "Loaded #{count} HUD graphics from WAD"
+      end
+
+      def upload_wad_pic(name)
+        qpic = @wad.read_qpic(name)
+        return unless qpic
+
+        rgba = @palette.indexed_to_rgba(qpic.pixels)
+
+        buf = "\0" * 4
+        GL.GenTextures(1, buf)
+        tex_id = buf.unpack1("V")
+
+        GL.BindTexture(GL::TEXTURE_2D, tex_id)
+        GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA,
+                      qpic.width, qpic.height, 0,
+                      GL::RGBA, GL::UNSIGNED_BYTE, rgba)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::NEAREST)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::NEAREST)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::CLAMP_TO_EDGE)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::CLAMP_TO_EDGE)
+
+        @textures[name] = { id: tex_id, width: qpic.width, height: qpic.height }
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_lightmap.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Computes and uploads lightmaps for BSP faces.
+    # Each face's lightmap is a small texture (typically 4x4 to 18x18)
+    # derived from the lighting lump. Lightmap UVs are computed from
+    # the face's texture-space extents, quantized to a 16-unit grid.
+    class GLLightmap
+      LIGHTMAP_BLOCK_WIDTH  = 128
+      LIGHTMAP_BLOCK_HEIGHT = 128
+
+      LightmapInfo = Data.define(:gl_texture, :s_offset, :t_offset, :width, :height)
+
+      attr_reader :face_lightmaps # face_index -> LightmapInfo
+
+      def initialize(level, palette)
+        @level = level
+        @palette = palette
+        @face_lightmaps = {}
+        @block_textures = []    # GL texture ids for each block
+        @block_allocated = []   # row allocation per block column
+        @block_pixels = []      # RGBA pixel data per block
+      end
+
+      def build_all
+        allocate_block
+
+        @level.faces.each_with_index do |face, face_index|
+          texinfo = @level.texinfo[face.texinfo_index]
+          next if texinfo.nil?
+          next if texinfo.flags & 1 != 0 # TEX_SPECIAL (sky/turb)
+          next if face.light_offset < 0
+
+          build_face_lightmap(face, face_index)
+        end
+
+        upload_blocks
+        count = @face_lightmaps.size
+        puts "Built #{count} lightmaps in #{@block_textures.size} blocks"
+      end
+
+      def bind(face_index)
+        info = @face_lightmaps[face_index]
+        return unless info
+        GL.BindTexture(GL::TEXTURE_2D, info.gl_texture)
+      end
+
+      # Compute lightmap UVs for a vertex given the face's lightmap info.
+      def lightmap_texcoords(face_index, vertex, texinfo)
+        info = @face_lightmaps[face_index]
+        return [0.0, 0.0] unless info
+
+        # Compute texture-space coordinate
+        s = vertex.dot(texinfo.s_vec) + texinfo.s_offset
+        t = vertex.dot(texinfo.t_vec) + texinfo.t_offset
+
+        # Convert to lightmap UV: subtract texture mins, scale by 1/16, offset by 0.5
+        # Then convert to atlas UV
+        extents = face_extents(face_index)
+        return [0.0, 0.0] unless extents
+
+        tex_mins_s, tex_mins_t, _, _ = extents
+
+        ls = (s - tex_mins_s + 8.0) / (info.width * 16.0)
+        lt = (t - tex_mins_t + 8.0) / (info.height * 16.0)
+
+        # Map into atlas block coordinates
+        atlas_s = (info.s_offset + ls * info.width + 0.5) / LIGHTMAP_BLOCK_WIDTH
+        atlas_t = (info.t_offset + lt * info.height + 0.5) / LIGHTMAP_BLOCK_HEIGHT
+
+        [atlas_s, atlas_t]
+      end
+
+      private
+
+      def allocate_block
+        @block_allocated << Array.new(LIGHTMAP_BLOCK_WIDTH, 0)
+        @block_pixels << ("\0" * (LIGHTMAP_BLOCK_WIDTH * LIGHTMAP_BLOCK_HEIGHT * 4))
+      end
+
+      def find_space(width, height)
+        @block_allocated.each_with_index do |allocated, block_idx|
+          best_y = LIGHTMAP_BLOCK_HEIGHT
+
+          # Simple first-fit allocation: scan columns
+          x = 0
+          while x <= LIGHTMAP_BLOCK_WIDTH - width
+            max_y = 0
+            fits = true
+            width.times do |dx|
+              if allocated[x + dx] + height > LIGHTMAP_BLOCK_HEIGHT
+                # Skip ahead
+                x = x + dx + 1
+                fits = false
+                break
+              end
+              max_y = allocated[x + dx] if allocated[x + dx] > max_y
+            end
+            next unless fits
+
+            if max_y < best_y
+              best_y = max_y
+              best_x = x
+            end
+            x += 1
+          end
+
+          if best_y + height <= LIGHTMAP_BLOCK_HEIGHT
+            # Mark columns as used
+            width.times { |dx| allocated[best_x + dx] = best_y + height }
+            return [block_idx, best_x, best_y]
+          end
+        end
+
+        # No space in existing blocks, allocate a new one
+        allocate_block
+        block_idx = @block_allocated.size - 1
+        allocated = @block_allocated[block_idx]
+        width.times { |dx| allocated[dx] = height }
+        [block_idx, 0, 0]
+      end
+
+      def calc_extents(face)
+        texinfo = @level.texinfo[face.texinfo_index]
+        return nil unless texinfo
+
+        min_s = Float::INFINITY
+        max_s = -Float::INFINITY
+        min_t = Float::INFINITY
+        max_t = -Float::INFINITY
+
+        face.num_edges.times do |i|
+          surfedge = @level.surfedges[face.first_edge + i]
+          if surfedge >= 0
+            edge = @level.edges[surfedge]
+            v = @level.vertices[edge.v0]
+          else
+            edge = @level.edges[-surfedge]
+            v = @level.vertices[edge.v1]
+          end
+
+          s = v.dot(texinfo.s_vec) + texinfo.s_offset
+          t = v.dot(texinfo.t_vec) + texinfo.t_offset
+
+          min_s = s if s < min_s
+          max_s = s if s > max_s
+          min_t = t if t < min_t
+          max_t = t if t > max_t
+        end
+
+        tex_min_s = (min_s / 16.0).floor * 16
+        tex_min_t = (min_t / 16.0).floor * 16
+        extent_s = ((max_s / 16.0).ceil - (min_s / 16.0).floor) * 16
+        extent_t = ((max_t / 16.0).ceil - (min_t / 16.0).floor) * 16
+
+        [tex_min_s, tex_min_t, extent_s.to_i, extent_t.to_i]
+      end
+
+      def face_extents(face_index)
+        @extents_cache ||= {}
+        @extents_cache[face_index]
+      end
+
+      def build_face_lightmap(face, face_index)
+        extents = calc_extents(face)
+        return unless extents
+
+        tex_min_s, tex_min_t, extent_s, extent_t = extents
+        lm_width = (extent_s / 16) + 1
+        lm_height = (extent_t / 16) + 1
+
+        return if lm_width <= 0 || lm_height <= 0
+        return if lm_width > 18 || lm_height > 18
+
+        @extents_cache ||= {}
+        @extents_cache[face_index] = extents
+
+        # Read lightmap data from lighting lump
+        lm_size = lm_width * lm_height
+        lighting = @level.lighting
+        offset = face.light_offset
+
+        # Accumulate light from all styles
+        blocklights = Array.new(lm_size, 0)
+
+        4.times do |style_idx|
+          style = face.styles[style_idx]
+          break if style == 255 # end of styles
+
+          # Scale factor: normal light (style 0) = 264 (Quake default)
+          # Other styles animated, but default to full brightness
+          scale = 256
+
+          lm_size.times do |j|
+            byte = lighting.getbyte(offset + j)
+            blocklights[j] += byte * scale if byte
+          end
+          offset += lm_size
+        end
+
+        # Find space in lightmap atlas
+        block_idx, s_off, t_off = find_space(lm_width, lm_height)
+
+        # Write pixels into atlas block
+        pixels = @block_pixels[block_idx]
+        lm_height.times do |row|
+          lm_width.times do |col|
+            src_idx = row * lm_width + col
+            # Shift right 7 (overbright by 2x) to match Quake's gamma
+            val = (blocklights[src_idx] >> 7).clamp(0, 255)
+
+            dst_x = s_off + col
+            dst_y = t_off + row
+            dst_idx = (dst_y * LIGHTMAP_BLOCK_WIDTH + dst_x) * 4
+            pixels.setbyte(dst_idx, val)
+            pixels.setbyte(dst_idx + 1, val)
+            pixels.setbyte(dst_idx + 2, val)
+            pixels.setbyte(dst_idx + 3, 255)
+          end
+        end
+
+        @face_lightmaps[face_index] = LightmapInfo.new(
+          gl_texture: block_idx, # Will be replaced with actual GL id after upload
+          s_offset: s_off, t_offset: t_off,
+          width: lm_width, height: lm_height
+        )
+      end
+
+      def upload_blocks
+        gl_ids = []
+        @block_pixels.each_with_index do |pixels, idx|
+          buf = "\0" * 4
+          GL.GenTextures(1, buf)
+          tex_id = buf.unpack1("V")
+          gl_ids << tex_id
+
+          GL.BindTexture(GL::TEXTURE_2D, tex_id)
+          GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA,
+                        LIGHTMAP_BLOCK_WIDTH, LIGHTMAP_BLOCK_HEIGHT, 0,
+                        GL::RGBA, GL::UNSIGNED_BYTE, pixels)
+          GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::LINEAR)
+          GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+          GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::CLAMP_TO_EDGE)
+          GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::CLAMP_TO_EDGE)
+        end
+
+        # Update face lightmap infos with actual GL texture ids
+        @face_lightmaps.each do |face_index, info|
+          @face_lightmaps[face_index] = LightmapInfo.new(
+            gl_texture: gl_ids[info.gl_texture],
+            s_offset: info.s_offset, t_offset: info.t_offset,
+            width: info.width, height: info.height
+          )
+        end
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_particles.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Simple particle system for visual effects.
+    # Particles are rendered as GL_POINTS with depth test enabled.
+    # Matches Quake's R_DrawParticles (gl_rpart.c).
+    class GLParticles
+      GRAVITY = 800.0
+      MAX_PARTICLES = 2048
+
+      # Quake ramp tables for color animation (palette indices)
+      RAMP1 = [0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61].freeze
+      RAMP2 = [0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66].freeze
+      RAMP3 = [0x6d, 0x6b, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01].freeze # explosion
+
+      Particle = Struct.new(:x, :y, :z, :vx, :vy, :vz,
+                            :r, :g, :b, :a,
+                            :life, :ramp, :ramp_type, :gravity_scale)
+
+      def initialize(palette)
+        @palette = palette
+        @particles = []
+      end
+
+      def update(dt)
+        @particles.reject! do |p|
+          p.life -= dt
+          next true if p.life <= 0
+
+          # Apply velocity
+          p.x += p.vx * dt
+          p.y += p.vy * dt
+          p.z += p.vz * dt
+
+          # Apply gravity
+          p.vz -= GRAVITY * p.gravity_scale * dt
+
+          # Color ramp animation
+          if p.ramp_type
+            p.ramp += dt * 10.0
+            idx = p.ramp.to_i
+            ramp = case p.ramp_type
+                   when :explosion then RAMP3
+                   when :fire then RAMP1
+                   else RAMP2
+                   end
+
+            if idx >= ramp.size
+              next true # particle expired
+            end
+
+            color = @palette.rgb(ramp[idx])
+            p.r = color[0] / 255.0
+            p.g = color[1] / 255.0
+            p.b = color[2] / 255.0
+          end
+
+          # Fade alpha
+          p.a = (p.life * 2.0).clamp(0.0, 1.0)
+
+          false
+        end
+      end
+
+      def render
+        return if @particles.empty?
+
+        GL.Disable(GL::TEXTURE_2D)
+        GL.Enable(GL::BLEND)
+        GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+        GL.PointSize(2.0)
+
+        GL.Begin(GL::POINTS)
+        @particles.each do |p|
+          GL.Color4f(p.r, p.g, p.b, p.a)
+          GL.Vertex3f(p.x, p.y, p.z)
+        end
+        GL.End
+
+        GL.PointSize(1.0)
+        GL.Disable(GL::BLEND)
+        GL.Color4f(1.0, 1.0, 1.0, 1.0)
+      end
+
+      # Teleporter sparkle effect at a position
+      def teleport_splash(pos)
+        80.times do
+          dx = (rand * 64.0) - 32.0
+          dy = (rand * 64.0) - 32.0
+          dz = (rand * 64.0) - 32.0
+          color_idx = 7 + (rand * 8).to_i
+          color = @palette.rgb(color_idx)
+          emit(
+            x: pos.x + dx, y: pos.y + dy, z: pos.z + dz,
+            vx: dx * 2.0, vy: dy * 2.0, vz: dz * 2.0 + 80.0,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 0.5 + rand * 0.3,
+            gravity_scale: 0.2
+          )
+        end
+      end
+
+      # Item pickup sparkle
+      def pickup_effect(pos)
+        20.times do
+          angle = rand * ::Math::PI * 2.0
+          speed = 50.0 + rand * 50.0
+          color = @palette.rgb(0x6f) # orange/yellow
+          emit(
+            x: pos.x, y: pos.y, z: pos.z + 16.0,
+            vx: ::Math.cos(angle) * speed,
+            vy: ::Math.sin(angle) * speed,
+            vz: 80.0 + rand * 60.0,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 0.3 + rand * 0.3,
+            gravity_scale: 0.5,
+            ramp_type: :fire
+          )
+        end
+      end
+
+      # Explosion burst
+      def explosion(pos)
+        128.times do
+          color = @palette.rgb(0x6d)
+          emit(
+            x: pos.x + rand * 16 - 8, y: pos.y + rand * 16 - 8, z: pos.z + rand * 16 - 8,
+            vx: (rand * 512) - 256, vy: (rand * 512) - 256, vz: (rand * 512) - 256,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 0.5 + rand * 0.5,
+            gravity_scale: 0.05,
+            ramp_type: :explosion
+          )
+        end
+      end
+
+      # Blood spurt
+      def blood(pos, count: 20)
+        count.times do
+          color_idx = 67 + (rand * 4).to_i # dark red palette range
+          color = @palette.rgb(color_idx)
+          emit(
+            x: pos.x, y: pos.y, z: pos.z,
+            vx: (rand * 128) - 64, vy: (rand * 128) - 64, vz: (rand * 128) - 64,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 0.5 + rand * 0.3,
+            gravity_scale: 1.0
+          )
+        end
+      end
+
+      def particle_count
+        @particles.size
+      end
+
+      private
+
+      def emit(x:, y:, z:, vx:, vy:, vz:, r:, g:, b:, life:,
+               gravity_scale: 0.0, ramp_type: nil)
+        return if @particles.size >= MAX_PARTICLES
+
+        @particles << Particle.new(
+          x, y, z, vx, vy, vz,
+          r, g, b, 1.0,
+          life, 0.0, ramp_type, gravity_scale
+        )
+      end
+    end
+  end
+end