quake-rb 0.1.0

data/lib/quake/renderer/gl_sky.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Renders Quake sky using the two-layer scrolling technique.
+    # Sky textures are 256x128, split into:
+    #   - Left half (128x128): solid background layer
+    #   - Right half (128x128): alpha foreground layer (index 0 = transparent)
+    class GLSky
+      def initialize(level, palette, texture_manager)
+        @level = level
+        @palette = palette
+        @texture_manager = texture_manager
+        @sky_surfaces = []
+        @solid_tex = nil
+        @alpha_tex = nil
+        @time = 0.0
+
+        find_sky_texture
+        precompute_sky_surfaces
+      end
+
+      def update(dt)
+        @time += dt
+      end
+
+      def render(camera, visible_face_set: nil)
+        return if @sky_surfaces.empty? || @solid_tex.nil?
+
+        # Filter to PVS-visible sky surfaces only. Without this, distant
+        # sky polys (e.g. the level's outdoor exit area) draw even when the
+        # camera is enclosed in a cave - and underwater they alpha-blend
+        # through translucent water as bright cloud shapes.
+        visible_surfaces = if visible_face_set
+                             @sky_surfaces.select { |s| visible_face_set.include?(s[:face_index]) }
+                           else
+                             @sky_surfaces
+                           end
+        return if visible_surfaces.empty?
+
+        # Render solid background layer
+        GL.BindTexture(GL::TEXTURE_2D, @solid_tex)
+        speed_scale = @time * 8.0
+        speed_scale -= speed_scale.floor & ~127
+
+        visible_surfaces.each do |surf|
+          GL.Begin(GL::TRIANGLE_FAN)
+          surf[:vertices].each do |v|
+            s, t = sky_texcoord(v, camera.position, speed_scale)
+            GL.TexCoord2f(s, t)
+            GL.Vertex3f(v.x, v.y, v.z)
+          end
+          GL.End
+        end
+
+        # Render alpha foreground layer with blending
+        GL.Enable(GL::BLEND)
+        GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+        GL.BindTexture(GL::TEXTURE_2D, @alpha_tex)
+        speed_scale2 = @time * 16.0
+        speed_scale2 -= speed_scale2.floor & ~127
+
+        visible_surfaces.each do |surf|
+          GL.Begin(GL::TRIANGLE_FAN)
+          surf[:vertices].each do |v|
+            s, t = sky_texcoord(v, camera.position, speed_scale2)
+            GL.TexCoord2f(s, t)
+            GL.Vertex3f(v.x, v.y, v.z)
+          end
+          GL.End
+        end
+
+        GL.Disable(GL::BLEND)
+      end
+
+      private
+
+      def sky_texcoord(vertex, origin, speed_scale)
+        # Direction from camera to vertex
+        dx = vertex.x - origin.x
+        dy = vertex.y - origin.y
+        dz = (vertex.z - origin.z) * 3.0 # flatten sphere
+
+        len = ::Math.sqrt(dx * dx + dy * dy + dz * dz)
+        len = 6.0 * 63.0 / len # 378 / len
+
+        s = (speed_scale + dx * len) / 128.0
+        t = (speed_scale + dy * len) / 128.0
+        [s, t]
+      end
+
+      def find_sky_texture
+        @level.textures.each_with_index do |tex, idx|
+          next if tex.nil?
+          next unless tex.name.start_with?("sky")
+
+          # Split 256x128 texture into two 128x128 halves
+          upload_sky_halves(tex)
+          break
+        end
+      end
+
+      def upload_sky_halves(miptex)
+        w = miptex.width   # 256
+        h = miptex.height  # 128
+        half_w = w / 2     # 128
+
+        # Extract left half (solid background)
+        solid_pixels = String.new(capacity: half_w * h)
+        h.times do |row|
+          src_offset = row * w
+          solid_pixels << miptex.pixels[src_offset, half_w]
+        end
+
+        # Extract right half (alpha foreground)
+        alpha_pixels = String.new(capacity: half_w * h)
+        h.times do |row|
+          src_offset = row * w + half_w
+          alpha_pixels << miptex.pixels[src_offset, half_w]
+        end
+
+        @solid_tex = upload_texture(solid_pixels, half_w, h, transparent: false)
+        @alpha_tex = upload_texture(alpha_pixels, half_w, h, transparent: true)
+      end
+
+      def upload_texture(pixels, width, height, transparent:)
+        rgba = String.new(capacity: width * height * 4)
+        pixels.each_byte do |idx|
+          r, g, b = @palette.rgb(idx)
+          a = (transparent && idx == 0) ? 0 : 255
+          rgba << r << g << b << a
+        end
+
+        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, width, height, 0,
+                      GL::RGBA, GL::UNSIGNED_BYTE, rgba)
+        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::REPEAT)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::REPEAT)
+        tex_id
+      end
+
+      def precompute_sky_surfaces
+        @level.faces.each_with_index do |face, face_index|
+          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?("sky")
+
+          verts = Bsp::FaceVertices.extract(@level, face)
+          @sky_surfaces << { vertices: verts, face_index: face_index }
+        end
+        puts "Found #{@sky_surfaces.size} sky surfaces"
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_texture_manager.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    class GLTextureManager
+      TEX_SPECIAL = 1
+
+      attr_reader :gl_textures
+
+      def initialize(level, palette)
+        @level = level
+        @palette = palette
+        @gl_textures = {} # miptex_index -> GL texture id
+      end
+
+      def upload_all
+        @level.textures.each_with_index do |miptex, index|
+          next if miptex.nil? || miptex.pixels.nil?
+          @gl_textures[index] = upload_texture(miptex)
+        end
+        puts "Uploaded #{@gl_textures.size} textures to GL"
+      end
+
+      def bind(miptex_index)
+        tex_id = @gl_textures[miptex_index]
+        GL.BindTexture(GL::TEXTURE_2D, tex_id || 0)
+      end
+
+      private
+
+      def upload_texture(miptex)
+        rgba = @palette.indexed_to_rgba(miptex.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,
+                      miptex.width, miptex.height, 0,
+                      GL::RGBA, GL::UNSIGNED_BYTE, rgba)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::REPEAT)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::REPEAT)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::LINEAR_MIPMAP_LINEAR)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+        GL.GenerateMipmap(GL::TEXTURE_2D)
+
+        tex_id
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_textured.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    class GLTextured
+      TEX_SPECIAL = 1
+
+      def initialize(level, texture_manager, lightmap: nil, sky: nil, water: nil)
+        @level = level
+        @texture_manager = texture_manager
+        @lightmap = lightmap
+        @sky = sky
+        @water = water
+        @last_leaf = -1
+        @visible_surface_cache = nil
+
+        # Precompute ALL surfaces grouped by texture (for non-VIS fallback
+        # and as source data for VIS filtering)
+        @all_surfaces_by_texture = precompute_surfaces
+        @face_to_surface = build_face_index
+
+        puts "Precomputed #{@all_surfaces_by_texture.values.sum(&:size)} surfaces across #{@all_surfaces_by_texture.size} textures"
+      end
+
+      def render(camera, aspect)
+        GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+
+        camera.apply_projection_gl(aspect)
+        camera.apply_gl
+
+        # Determine visible surfaces via PVS
+        surfaces_by_texture = visible_surfaces(camera)
+
+        # Render opaque world geometry
+        GL.Enable(GL::TEXTURE_2D)
+
+        if @lightmap
+          render_with_lightmaps(surfaces_by_texture)
+        else
+          render_without_lightmaps(surfaces_by_texture)
+        end
+
+        # Sky drawn before translucent water so translucent water can
+        # alpha-blend over sky-tinted background. PVS-cull keeps distant
+        # outdoor sky polys out, and TEXTURE_2D must stay enabled or sky
+        # polys render as untextured white shapes.
+        @sky&.render(camera, visible_face_set: @last_visible_face_set)
+
+        # Translucent water last so it alpha-blends over everything else.
+        @water&.render(alpha: 0.5)
+
+        GL.Disable(GL::TEXTURE_2D)
+      end
+
+      def update(dt)
+        @sky&.update(dt)
+        @water&.update(dt)
+      end
+
+      private
+
+      def visible_surfaces(camera)
+        leaf_index = Bsp::Vis.point_in_leaf(@level, camera.position)
+        leaf = @level.leafs[leaf_index]
+        # FatPVS depends on point position, so recompute every frame when
+        # the camera leaf touches a liquid surface. Otherwise the cheap
+        # leaf-keyed cache is fine.
+        near_liquid = Bsp::Vis.near_liquid_portal?(@level, leaf)
+
+        if near_liquid
+          compute_visible_surfaces(leaf_index, point: camera.position)
+        else
+          if leaf_index != @last_leaf
+            @last_leaf = leaf_index
+            @visible_surface_cache = compute_visible_surfaces(leaf_index)
+          end
+          @visible_surface_cache || @all_surfaces_by_texture
+        end
+      end
+
+      def compute_visible_surfaces(leaf_index, point: nil)
+        visible_face_set = Bsp::Vis.visible_faces(@level, leaf_index, point: point)
+        # Stash so the sky pass can cull against the same set.
+        @last_visible_face_set = visible_face_set
+
+        filtered = Hash.new { |h, k| h[k] = [] }
+
+        visible_face_set.each do |face_idx|
+          entry = @face_to_surface[face_idx]
+          next unless entry
+
+          miptex_index, surf_data = entry
+          filtered[miptex_index] << surf_data
+        end
+
+        filtered
+      end
+
+      def render_without_lightmaps(surfaces_by_texture)
+        GL.Color3f(1.0, 1.0, 1.0)
+
+        surfaces_by_texture.each do |miptex_index, surfaces|
+          @texture_manager.bind(miptex_index)
+
+          surfaces.each do |surf|
+            GL.Begin(GL::TRIANGLE_FAN)
+            surf[:vertices].each_with_index do |v, i|
+              u, t = surf[:texcoords][i]
+              GL.TexCoord2f(u, t)
+              GL.Vertex3f(v.x, v.y, v.z)
+            end
+            GL.End
+          end
+        end
+      end
+
+      def render_with_lightmaps(surfaces_by_texture)
+        # Two-pass approach: diffuse modulated by lightmap
+        # Pass 1: render diffuse texture
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
+        GL.Color3f(1.0, 1.0, 1.0)
+
+        surfaces_by_texture.each do |miptex_index, surfaces|
+          @texture_manager.bind(miptex_index)
+
+          surfaces.each do |surf|
+            GL.Begin(GL::TRIANGLE_FAN)
+            surf[:vertices].each_with_index do |v, i|
+              u, t = surf[:texcoords][i]
+              GL.TexCoord2f(u, t)
+              GL.Vertex3f(v.x, v.y, v.z)
+            end
+            GL.End
+          end
+        end
+
+        # Pass 2: multiply lightmap on top
+        GL.Enable(GL::BLEND)
+        GL.BlendFunc(GL::ZERO, GL::SRC_COLOR) # dst = dst * src (multiply)
+        GL.DepthFunc(GL::EQUAL) # only write where geometry already drawn
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
+
+        last_lm_tex = -1
+        surfaces_by_texture.each do |_miptex_index, surfaces|
+          surfaces.each do |surf|
+            face_idx = surf[:face_index]
+            next unless face_idx && @lightmap.face_lightmaps[face_idx]
+
+            lm_info = @lightmap.face_lightmaps[face_idx]
+            if lm_info.gl_texture != last_lm_tex
+              GL.BindTexture(GL::TEXTURE_2D, lm_info.gl_texture)
+              last_lm_tex = lm_info.gl_texture
+            end
+
+            texinfo = @level.texinfo[surf[:texinfo_index]]
+            GL.Begin(GL::TRIANGLE_FAN)
+            surf[:vertices].each_with_index do |v, i|
+              ls, lt = @lightmap.lightmap_texcoords(face_idx, v, texinfo)
+              GL.TexCoord2f(ls, lt)
+              GL.Vertex3f(v.x, v.y, v.z)
+            end
+            GL.End
+          end
+        end
+
+        GL.DepthFunc(GL::LESS)
+        GL.Disable(GL::BLEND)
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
+      end
+
+      def precompute_surfaces
+        grouped = Hash.new { |h, k| h[k] = [] }
+
+        # Only render faces belonging to model 0 (the worldmodel).
+        # Sub-model faces (doors, buttons, lifts) are rendered separately
+        # by GLBrushModel with entity transforms applied.
+        world = @level.models[0]
+        world_first = world.first_face
+        world_last = world_first + world.num_faces - 1
+
+        @level.faces.each_with_index do |face, face_index|
+          next if face_index < world_first || face_index > world_last
+
+          texinfo = @level.texinfo[face.texinfo_index]
+          next if texinfo.nil?
+          next if texinfo.flags & TEX_SPECIAL != 0
+
+          miptex_index = texinfo.miptex_index
+          tex = @level.textures[miptex_index]
+          next if tex.nil?
+          # Skip sky and water (handled by dedicated renderers)
+          next if tex.name.start_with?("sky")
+          next if tex.name.start_with?("*")
+          # Trigger volumes are invisible collision brushes
+          next if tex.name == "trigger"
+          next if tex.name == "clip"
+
+          surf = Bsp::FaceVertices.extract_surface(@level, face)
+          surf_data = {
+            vertices: surf.vertices,
+            texcoords: surf.texcoords,
+            texinfo_index: surf.texinfo_index,
+            face_index: face_index
+          }
+          grouped[miptex_index] << surf_data
+        end
+
+        grouped
+      end
+
+      def build_face_index
+        index = {}
+        @all_surfaces_by_texture.each do |miptex_index, surfaces|
+          surfaces.each do |surf_data|
+            index[surf_data[:face_index]] = [miptex_index, surf_data]
+          end
+        end
+        index
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_viewmodel.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Renders the first-person weapon view model.
+    # Uses the same projection as the world camera. Depth range is compressed
+    # to [0, 0.3] so the weapon always draws in front of world geometry
+    # without z-fighting (matches GLQuake's R_DrawViewModel).
+    class GLViewmodel
+      # Quake bob cvars (from view.c)
+      CL_BOB      = 0.02   # cl_bob: amplitude multiplier
+      CL_BOBCYCLE = 0.6    # cl_bobcycle: seconds per full bob cycle
+      CL_BOBUP    = 0.5    # cl_bobup: fraction of cycle spent going up
+
+      # Current bob value (applied to camera Z by the game loop)
+      attr_reader :bob
+
+      def initialize(pak, palette)
+        @pak = pak
+        @palette = palette
+        @weapon_renderers = {} # model_path -> GLAliasModel
+        @time = 0.0
+        @bob_speed = 0.0
+        @bob = 0.0
+        @current_model_path = nil
+      end
+
+      def set_weapon(model_path)
+        return if model_path == @current_model_path
+        @current_model_path = model_path
+        load_weapon(model_path) unless @weapon_renderers.key?(model_path)
+      end
+
+      def update(dt, speed)
+        @time += dt
+        @bob_speed = speed
+        @bob = calc_bob
+      end
+
+      def render(camera, aspect)
+        return unless @current_model_path
+
+        gl_model = @weapon_renderers[@current_model_path]
+        return unless gl_model
+
+        # Compress depth range so weapon always appears in front of world
+        GL.DepthRange(0.0, 0.3)
+        GL.DepthFunc(GL::LEQUAL)
+
+        # Weapon origin = camera position + forward*bob*0.4
+        # Camera already has the vertical bob applied (in the game loop),
+        # so only the forward push is needed here.
+        pos = camera.position + camera.forward * (@bob * 0.4)
+
+        GL.Enable(GL::TEXTURE_2D)
+
+        gl_model.render(
+          frame_index: 0,
+          lerp: 0.0,
+          position: pos,
+          yaw: camera.yaw,
+          pitch: camera.pitch
+        )
+
+        GL.DepthRange(0.0, 1.0)
+        GL.DepthFunc(GL::LESS)
+      end
+
+      private
+
+      # Exact V_CalcBob from Quake's view.c
+      def calc_bob
+        speed = @bob_speed
+        return 0.0 if speed < 1.0
+
+        # Asymmetric cycle: spend cl_bobup fraction going up, rest going down
+        cycle = @time - (@time / CL_BOBCYCLE).floor * CL_BOBCYCLE
+        cycle /= CL_BOBCYCLE
+
+        if cycle < CL_BOBUP
+          cycle = ::Math::PI * cycle / CL_BOBUP
+        else
+          cycle = ::Math::PI + ::Math::PI * (cycle - CL_BOBUP) / (1.0 - CL_BOBUP)
+        end
+
+        # 30% constant offset + 70% oscillation, proportional to speed
+        bob = speed * CL_BOB
+        bob = bob * 0.3 + bob * 0.7 * ::Math.sin(cycle)
+        bob.clamp(-7.0, 4.0)
+      end
+
+      def load_weapon(model_path)
+        begin
+          data = @pak.read(model_path)
+          return unless data
+
+          mdl = Mdl::Reader.new(data).parse
+          @weapon_renderers[model_path] = GLAliasModel.new(mdl, @palette)
+          puts "  Loaded weapon model: #{model_path}"
+        rescue => e
+          puts "  Failed to load weapon #{model_path}: #{e.message}"
+          @weapon_renderers[model_path] = nil
+        end
+      end
+    end
+  end
+end