quake-rb 0.1.0

data/lib/quake/renderer/gl_water.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Renders turbulent water/lava/slime surfaces with sine-wave warping.
+    # Quake liquid textures have names starting with '*'.
+    class GLWater
+      TURBSCALE = 256.0 / (2.0 * ::Math::PI) # ~40.74
+
+      SUBDIVIDE_SIZE = 64.0
+
+      def initialize(level, texture_manager)
+        @level = level
+        @texture_manager = texture_manager
+        @water_surfaces = []
+        @time = 0.0
+
+        # Precompute 256-entry sine table matching Quake's turbsin
+        @turbsin = Array.new(256) do |i|
+          (::Math.sin(i * 2.0 * ::Math::PI / 256.0) * 8.0)
+        end
+
+        precompute_water_surfaces
+      end
+
+      def update(dt)
+        @time += dt
+      end
+
+      # Render water surfaces with turbulent sine-wave warp.
+      # alpha: 1.0 = fully opaque (GLQuake default r_wateralpha).
+      #        Values < 1.0 enable semi-transparent water.
+      def render(alpha: 1.0)
+        return if @water_surfaces.empty?
+
+        GL.Enable(GL::TEXTURE_2D)
+        # Quake BSP stores liquid surfaces as front/back face pairs on the
+        # same plane so the surface is visible from above and below. Without
+        # culling both copies rasterize at the same depth, z-fight, and (with
+        # alpha < 1) double-blend, producing flicker. Match TyrQuake:
+        # glCullFace(GL_FRONT) with default CCW front face.
+        GL.Enable(GL::CULL_FACE)
+        GL.CullFace(GL::FRONT)
+
+        if alpha < 1.0
+          GL.Enable(GL::BLEND)
+          GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+          GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
+          GL.Color4f(1.0, 1.0, 1.0, alpha)
+        else
+          GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
+        end
+
+        @water_surfaces.each do |ws|
+          @texture_manager.bind(ws[:miptex_index])
+
+          ws[:faces].each do |face_data|
+            GL.Begin(GL::TRIANGLE_FAN)
+            face_data[:verts].each_with_index do |v, i|
+              os, ot = face_data[:texcoords][i]
+
+              # Cross-modulated sine warp
+              s = os + @turbsin[((ot * 0.125 + @time) * TURBSCALE).to_i & 255]
+              s /= 64.0
+
+              t = ot + @turbsin[((os * 0.125 + @time) * TURBSCALE).to_i & 255]
+              t /= 64.0
+
+              GL.TexCoord2f(s, t)
+              GL.Vertex3f(v.x, v.y, v.z)
+            end
+            GL.End
+          end
+        end
+
+        GL.Disable(GL::CULL_FACE)
+
+        if alpha < 1.0
+          GL.Disable(GL::BLEND)
+          GL.Color4f(1.0, 1.0, 1.0, 1.0)
+        end
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
+      end
+
+      private
+
+      def precompute_water_surfaces
+        grouped = Hash.new { |h, k| h[k] = [] }
+
+        @level.faces.each do |face|
+          texinfo = @level.texinfo[face.texinfo_index]
+          next if texinfo.nil?
+
+          tex = @level.textures[texinfo.miptex_index]
+          next if tex.nil?
+          next unless tex.name.start_with?("*")
+
+          # Extract vertices
+          face_verts = []
+          face.num_edges.times do |i|
+            surfedge = @level.surfedges[face.first_edge + i]
+            if surfedge >= 0
+              edge = @level.edges[surfedge]
+              face_verts << @level.vertices[edge.v0]
+            else
+              edge = @level.edges[-surfedge]
+              face_verts << @level.vertices[edge.v1]
+            end
+          end
+
+          # Subdivide into smaller polygons for smoother warp effect
+          subdivided = subdivide_polygon(face_verts)
+
+          subdivided.each do |poly_verts|
+            texcoords = poly_verts.map do |v|
+              # Raw dot product only, no offset (matches TyrQuake SubdividePolygon)
+              s = v.dot(texinfo.s_vec)
+              t = v.dot(texinfo.t_vec)
+              [s, t]
+            end
+            grouped[texinfo.miptex_index] << { verts: poly_verts, texcoords: texcoords }
+          end
+        end
+
+        grouped.each do |miptex_index, faces|
+          @water_surfaces << { miptex_index: miptex_index, faces: faces }
+        end
+
+        puts "Found #{@water_surfaces.sum { |ws| ws[:faces].size }} water surfaces"
+      end
+
+      # Subdivide polygon along axial 64-unit boundaries for smoother warp.
+      # Matches TyrQuake's SubdividePolygon.
+      def subdivide_polygon(verts)
+        polys = [verts]
+
+        3.times do |axis|
+          next_polys = []
+          polys.each do |poly|
+            split_polygon_axis(poly, axis, next_polys)
+          end
+          polys = next_polys
+        end
+
+        polys
+      end
+
+      def split_polygon_axis(verts, axis, result)
+        # Find bounds on this axis
+        mins = Float::INFINITY
+        maxs = -Float::INFINITY
+        verts.each do |v|
+          val = v.to_a[axis]
+          mins = val if val < mins
+          maxs = val if val > maxs
+        end
+
+        # If small enough, no split needed
+        if maxs - mins <= SUBDIVIDE_SIZE
+          result << verts
+          return
+        end
+
+        # Find split plane (first 64-unit boundary)
+        dist = ((mins + SUBDIVIDE_SIZE) / SUBDIVIDE_SIZE).floor * SUBDIVIDE_SIZE
+        # Ensure we're actually splitting
+        dist = mins + SUBDIVIDE_SIZE if dist <= mins
+
+        front = []
+        back = []
+
+        verts.each_with_index do |v, i|
+          v_next = verts[(i + 1) % verts.size]
+          d1 = v.to_a[axis] - dist
+          d2 = v_next.to_a[axis] - dist
+
+          front << v if d1 >= 0
+          back << v if d1 < 0
+
+          # Edge crosses the split plane
+          if (d1 >= 0) != (d2 >= 0)
+            frac = d1 / (d1 - d2)
+            mid = Quake::Math::Vec3.new(
+              v.x + frac * (v_next.x - v.x),
+              v.y + frac * (v_next.y - v.y),
+              v.z + frac * (v_next.z - v.z)
+            )
+            front << mid
+            back << mid
+          end
+        end
+
+        split_polygon_axis(front, axis, result) if front.size >= 3
+        split_polygon_axis(back, axis, result) if back.size >= 3
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_wireframe.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    class GLWireframe
+      def initialize(level)
+        @level = level
+        @face_polygons = precompute_polygons
+        puts "Precomputed #{@face_polygons.size} face polygons"
+      end
+
+      def render(camera, aspect)
+        GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+
+        camera.apply_projection_gl(aspect)
+        camera.apply_gl
+
+        GL.Color3f(0.0, 1.0, 0.0)
+
+        @face_polygons.each do |verts|
+          GL.Begin(GL::LINE_LOOP)
+          verts.each { |v| GL.Vertex3f(v.x, v.y, v.z) }
+          GL.End
+        end
+      end
+
+      private
+
+      def precompute_polygons
+        @level.faces.map { |face| Bsp::FaceVertices.extract(@level, face) }
+      end
+    end
+  end
+end

data/lib/quake/sound/events.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Quake
+  module Sound
+    # Maps game events to sound file paths and plays them.
+    class Events
+      # Item pickup sounds
+      PICKUP_SOUNDS = {
+        health: "items/health1.wav",
+        armor: "items/armor1.wav",
+        ammo: "weapons/lock4.wav",
+        weapon: "weapons/pkup.wav",
+        powerup: "items/protect.wav"
+      }.freeze
+
+      # Door/platform sounds
+      DOOR_SOUNDS = {
+        open: "doors/medtry.wav",
+        close: "doors/medclose.wav"
+      }.freeze
+
+      PLAT_SOUNDS = {
+        move: "plats/medplat1.wav",
+        stop: "plats/medplat2.wav"
+      }.freeze
+
+      # Player sounds
+      PLAYER_SOUNDS = {
+        jump: "player/plyrjmp8.wav",
+        land: "player/land.wav",
+        water_enter: "player/inh2o.wav",
+        water_exit: "player/inlava.wav"
+      }.freeze
+
+      def initialize(mixer)
+        @mixer = mixer
+      end
+
+      def on_pickup(event)
+        return unless @mixer&.loaded?
+        sound = PICKUP_SOUNDS[event[:type]]
+        @mixer.play(sound) if sound
+      end
+
+      def on_door(action)
+        return unless @mixer&.loaded?
+        sound = DOOR_SOUNDS[action]
+        @mixer.play(sound) if sound
+      end
+
+      def on_player(action)
+        return unless @mixer&.loaded?
+        sound = PLAYER_SOUNDS[action]
+        @mixer.play(sound) if sound
+      end
+    end
+  end
+end

data/lib/quake/sound/mixer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Quake
+  module Sound
+    # Low-level FFI bindings to SDL2_mixer for WAV playback.
+    module MixerLib
+      extend FFI::Library
+      ffi_lib "/opt/homebrew/lib/libSDL2_mixer.dylib"
+
+      MIX_DEFAULT_FORMAT = 0x8010 # AUDIO_S16LSB
+
+      attach_function :Mix_OpenAudio, [:int, :uint16, :int, :int], :int
+      attach_function :Mix_CloseAudio, [], :void
+      attach_function :Mix_AllocateChannels, [:int], :int
+      attach_function :Mix_LoadWAV_RW, [:pointer, :int], :pointer
+      attach_function :Mix_FreeChunk, [:pointer], :void
+      attach_function :Mix_PlayChannelTimed, [:int, :pointer, :int, :int], :int
+      attach_function :Mix_Volume, [:int, :int], :int
+      attach_function :Mix_HaltChannel, [:int], :int
+    end
+
+    # High-level sound manager: loads WAVs from PAK, plays them by name.
+    class Mixer
+      MAX_CHANNELS = 16
+
+      def initialize(pak)
+        @pak = pak
+        @chunks = {} # sound_path -> FFI pointer
+        @open = false
+      end
+
+      def open
+        result = MixerLib.Mix_OpenAudio(22050, MixerLib::MIX_DEFAULT_FORMAT, 2, 1024)
+        if result < 0
+          puts "Warning: Could not open audio"
+          return
+        end
+        MixerLib.Mix_AllocateChannels(MAX_CHANNELS)
+        @open = true
+        puts "Audio initialized (#{MAX_CHANNELS} channels)"
+      end
+
+      def close
+        @chunks.each_value { |chunk| MixerLib.Mix_FreeChunk(chunk) }
+        @chunks.clear
+        MixerLib.Mix_CloseAudio if @open
+        @open = false
+      end
+
+      # Play a sound from the PAK. path is relative (e.g. "items/health1.wav").
+      # Returns channel number or -1 on failure.
+      def play(path, volume: 128, loop_count: 0)
+        return -1 unless @open
+
+        full_path = path.start_with?("sound/") ? path : "sound/#{path}"
+        chunk = load_chunk(full_path)
+        return -1 unless chunk
+
+        MixerLib.Mix_Volume(-1, volume)
+        MixerLib.Mix_PlayChannelTimed(-1, chunk, loop_count, -1)
+      end
+
+      def loaded?
+        @open
+      end
+
+      private
+
+      def load_chunk(path)
+        return @chunks[path] if @chunks.key?(path)
+
+        data = @pak.read(path)
+        unless data
+          @chunks[path] = nil
+          return nil
+        end
+
+        # Create SDL_RWops from memory and load as WAV
+        rw = sdl_rw_from_mem(data)
+        chunk = MixerLib.Mix_LoadWAV_RW(rw, 1) # 1 = free RW after load
+        if chunk.null?
+          @chunks[path] = nil
+          return nil
+        end
+
+        @chunks[path] = chunk
+        chunk
+      end
+
+      def sdl_rw_from_mem(data)
+        # Use SDL's RWFromMem
+        ptr = FFI::MemoryPointer.new(:uint8, data.bytesize)
+        ptr.put_bytes(0, data)
+
+        # Keep reference to prevent GC
+        @mem_refs ||= []
+        @mem_refs << ptr
+
+        SDL.RWFromMem(ptr, data.bytesize)
+      end
+    end
+  end
+end

data/lib/quake/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Quake
+  VERSION = "0.1.0"
+end

data/lib/quake/wad/reader.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Quake
+  module Wad
+    # Reads WAD2 archives (Quake's texture/picture format).
+    # Used primarily for gfx.wad which contains HUD graphics.
+    class Reader
+      MAGIC = "WAD2"
+
+      Entry = Data.define(:name, :offset, :size, :type)
+
+      # QPic: width(4) + height(4) + indexed pixels
+      QPic = Data.define(:width, :height, :pixels)
+
+      def initialize(data)
+        @data = data
+        @entries = {}
+        parse_directory
+      end
+
+      def list
+        @entries.keys
+      end
+
+      def read(name)
+        entry = @entries[name.downcase]
+        return nil unless entry
+        @data[entry.offset, entry.size]
+      end
+
+      # Read a QPic (status bar graphic): 4-byte width, 4-byte height, pixels
+      def read_qpic(name)
+        entry = @entries[name.downcase]
+        return nil unless entry
+
+        raw = @data[entry.offset, entry.size]
+        return nil unless raw && raw.bytesize >= 8
+
+        width, height = raw[0, 8].unpack("VV")
+        pixels = raw[8, width * height]
+        QPic.new(width: width, height: height, pixels: pixels)
+      end
+
+      private
+
+      def parse_directory
+        return if @data.bytesize < 12
+
+        magic = @data[0, 4]
+        return unless magic == MAGIC
+
+        numlumps, infotableofs = @data[4, 8].unpack("VV")
+
+        numlumps.times do |i|
+          offset = infotableofs + i * 32
+          break if offset + 32 > @data.bytesize
+
+          filepos, disksize, _size, type = @data[offset, 16].unpack("VVVC")
+          _compression = @data[offset + 13].unpack1("C")
+          name = @data[offset + 16, 16].unpack1("Z16").downcase
+
+          @entries[name] = Entry.new(
+            name: name, offset: filepos, size: disksize, type: type
+          )
+        end
+      end
+    end
+  end
+end

data/lib/quake/window.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "sdl2"
+require "opengl"
+require "glu"
+
+module Quake
+  class Window
+    DEFAULT_WIDTH  = 1280
+    DEFAULT_HEIGHT = 720
+    TITLE = "RubyQuake"
+
+    attr_reader :width, :height
+
+    def initialize(width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT, visible: true)
+      @width = width
+      @height = height
+      @visible = visible
+
+      SDL.load_lib("/opt/homebrew/lib/libSDL2.dylib")
+      SDL.Init(SDL::INIT_VIDEO)
+
+      SDL.GL_SetAttribute(SDL::GL_CONTEXT_MAJOR_VERSION, 2)
+      SDL.GL_SetAttribute(SDL::GL_CONTEXT_MINOR_VERSION, 1)
+      SDL.GL_SetAttribute(SDL::GL_DOUBLEBUFFER, 1)
+      SDL.GL_SetAttribute(SDL::GL_DEPTH_SIZE, 24)
+
+      window_flags = SDL::WINDOW_OPENGL
+      window_flags |= visible ? SDL::WINDOW_SHOWN : SDL::WINDOW_HIDDEN
+
+      @window = SDL.CreateWindow(
+        TITLE,
+        SDL::WINDOWPOS_CENTERED_MASK,
+        SDL::WINDOWPOS_CENTERED_MASK,
+        width, height,
+        window_flags
+      )
+
+      @context = SDL.GL_CreateContext(@window)
+      SDL.GL_MakeCurrent(@window, @context)
+      SDL.GL_SetSwapInterval(visible ? 1 : 0) # vsync only for visible
+
+      GL.load_lib
+      GLU.load_lib
+
+      GL.Viewport(0, 0, width, height)
+      GL.Enable(GL::DEPTH_TEST)
+      GL.ClearColor(0.0, 0.0, 0.0, 1.0)
+
+      SDL.SetRelativeMouseMode(SDL::TRUE) if visible
+    end
+
+    def swap
+      SDL.GL_SwapWindow(@window)
+    end
+
+    def poll_events
+      @event ||= SDL::Event.new
+      while SDL.PollEvent(@event.to_ptr) != 0
+        yield @event
+      end
+    end
+
+    def aspect_ratio
+      @width.to_f / @height
+    end
+
+    def close
+      SDL.GL_DeleteContext(@context)
+      SDL.DestroyWindow(@window)
+      SDL.Quit
+    end
+  end
+end

data/lib/quake.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quake
+end
+
+require_relative "quake/version"
+require_relative "quake/math/vec3"
+require_relative "quake/pak/reader"
+require_relative "quake/bsp/types"
+require_relative "quake/bsp/reader"
+require_relative "quake/bsp/face_vertices"
+require_relative "quake/bsp/vis"
+require_relative "quake/palette"
+require_relative "quake/entity"
+require_relative "quake/mdl/types"
+require_relative "quake/mdl/reader"
+require_relative "quake/physics/hull_trace"
+require_relative "quake/physics/player"
+require_relative "quake/game/brush_entities"

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: quake-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Hasinski
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opengl-bindings2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sdl2-bindings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A port of the Quake (1996) engine to Ruby. Reads original BSP/MDL/PAK
+  assets and renders them via OpenGL + SDL2.
+email:
+- krzysztof.hasinski@gmail.com
+executables:
+- quake
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/quake
+- bin/quake-debug
+- lib/quake.rb
+- lib/quake/bsp/face_vertices.rb
+- lib/quake/bsp/reader.rb
+- lib/quake/bsp/types.rb
+- lib/quake/bsp/vis.rb
+- lib/quake/camera.rb
+- lib/quake/debug/png_writer.rb
+- lib/quake/debug/screenshot.rb
+- lib/quake/debug/script.rb
+- lib/quake/entity.rb
+- lib/quake/game/brush_entities.rb
+- lib/quake/game/engine.rb
+- lib/quake/game/item_pickups.rb
+- lib/quake/game/player_state.rb
+- lib/quake/math/vec3.rb
+- lib/quake/mdl/reader.rb
+- lib/quake/mdl/types.rb
+- lib/quake/pak/reader.rb
+- lib/quake/pak_downloader.rb
+- lib/quake/palette.rb
+- lib/quake/physics/hull_trace.rb
+- lib/quake/physics/player.rb
+- lib/quake/renderer/gl_alias_model.rb
+- lib/quake/renderer/gl_brush_model.rb
+- lib/quake/renderer/gl_hud.rb
+- lib/quake/renderer/gl_lightmap.rb
+- lib/quake/renderer/gl_particles.rb
+- lib/quake/renderer/gl_sky.rb
+- lib/quake/renderer/gl_texture_manager.rb
+- lib/quake/renderer/gl_textured.rb
+- lib/quake/renderer/gl_viewmodel.rb
+- lib/quake/renderer/gl_water.rb
+- lib/quake/renderer/gl_wireframe.rb
+- lib/quake/sound/events.rb
+- lib/quake/sound/mixer.rb
+- lib/quake/version.rb
+- lib/quake/wad/reader.rb
+- lib/quake/window.rb
+homepage: https://github.com/khasinski/quake
+licenses:
+- GPL-2.0-only
+metadata:
+  source_code_uri: https://github.com/khasinski/quake
+  bug_tracker_uri: https://github.com/khasinski/quake/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Quake engine port in Ruby
+test_files: []