quake-rb 0.1.0 → 0.2.0

data/lib/quake/renderer/gl_texture_manager.rb

@@ -23,15 +23,49 @@ module Quake
         puts "Uploaded #{@gl_textures.size} textures to GL"
       end
 
-      def bind(miptex_index)
-        tex_id = @gl_textures[miptex_index]
+      def bind(miptex_index, time: 0.0, alternate: false)
+        tex_id = @gl_textures[animated_miptex_index(miptex_index, time: time, alternate: alternate)]
         GL.BindTexture(GL::TEXTURE_2D, tex_id || 0)
       end
 
+      # Fence/grate textures ('{' prefix) have palette index 255 cut out
+      # and are drawn with alpha test (Quakespasm SURF_DRAWFENCE).
+      def fence?(miptex_index)
+        @level&.textures&.[](miptex_index)&.name&.start_with?("{") || false
+      end
+
       private
 
+      def animated_miptex_index(miptex_index, time:, alternate:)
+        base_index = miptex_index
+        base = @level&.textures&.[](base_index)
+        return base_index unless base
+
+        if alternate && base.alternate_anims
+          base_index = base.alternate_anims
+          base = @level.textures[base_index]
+          return miptex_index unless base
+        end
+
+        return base_index if base.anim_total.to_i.zero?
+
+        relative = (time.to_f * 10).to_i % base.anim_total
+        count = 0
+        while base.anim_min > relative || base.anim_max <= relative
+          base_index = base.anim_next
+          raise "R_TextureAnimation: broken cycle" if base_index.nil?
+
+          base = @level.textures[base_index]
+          raise "R_TextureAnimation: broken cycle" unless base
+          raise "R_TextureAnimation: infinite cycle" if (count += 1) > 100
+        end
+
+        base_index
+      end
+
       def upload_texture(miptex)
-        rgba = @palette.indexed_to_rgba(miptex.pixels)
+        transparent = miptex.name.start_with?("{") ? 255 : nil
+        rgba = @palette.indexed_to_rgba(miptex.pixels, transparent_index: transparent)
 
         buf = "\0" * 4
         GL.GenTextures(1, buf)
@@ -43,7 +77,7 @@ module Quake
                       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_MIN_FILTER, GL::LINEAR_MIPMAP_NEAREST)
         GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
         GL.GenerateMipmap(GL::TEXTURE_2D)
 

data/lib/quake/renderer/gl_textured.rb

@@ -15,6 +15,7 @@ module Quake
         @water = water
         @last_leaf = -1
         @visible_surface_cache = nil
+        @time = 0.0
 
         # Precompute ALL surfaces grouped by texture (for non-VIS fallback
         # and as source data for VIS filtering)
@@ -24,12 +25,17 @@ module Quake
         puts "Precomputed #{@all_surfaces_by_texture.values.sum(&:size)} surfaces across #{@all_surfaces_by_texture.size} textures"
       end
 
-      def render(camera, aspect)
+      def render(camera, aspect, time: @time || 0.0)
+        @time = time.to_f
+
         GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
 
         camera.apply_projection_gl(aspect)
         camera.apply_gl
 
+        # 3D scene culls front faces (Quake winding); 2D passes disable this
+        GL.Enable(GL::CULL_FACE)
+
         # Determine visible surfaces via PVS
         surfaces_by_texture = visible_surfaces(camera)
 
@@ -42,15 +48,21 @@ module Quake
           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.
+        # 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
+
+      # Water is drawn after entities/viewmodel like R_DrawWaterSurfaces so
+      # translucent water blends over everything behind it.
+      # GLQuake's default r_wateralpha is 1.0.
+      def render_water(alpha: 1.0)
+        return unless @water
 
+        GL.Enable(GL::TEXTURE_2D)
+        @water.render(alpha: alpha)
         GL.Disable(GL::TEXTURE_2D)
       end
 
@@ -63,25 +75,15 @@ module Quake
 
       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
+        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
 
-      def compute_visible_surfaces(leaf_index, point: nil)
-        visible_face_set = Bsp::Vis.visible_faces(@level, leaf_index, point: point)
+      def compute_visible_surfaces(leaf_index)
+        visible_face_set = Bsp::Vis.visible_faces(@level, leaf_index)
         # Stash so the sky pass can cull against the same set.
         @last_visible_face_set = visible_face_set
 
@@ -102,7 +104,9 @@ module Quake
         GL.Color3f(1.0, 1.0, 1.0)
 
         surfaces_by_texture.each do |miptex_index, surfaces|
-          @texture_manager.bind(miptex_index)
+          @texture_manager.bind(miptex_index, time: (@time || 0.0).to_f)
+          fence = @texture_manager.fence?(miptex_index)
+          enable_fence_alpha_test if fence
 
           surfaces.each do |surf|
             GL.Begin(GL::TRIANGLE_FAN)
@@ -113,6 +117,8 @@ module Quake
             end
             GL.End
           end
+
+          GL.Disable(GL::ALPHA_TEST) if fence
         end
       end
 
@@ -123,7 +129,9 @@ module Quake
         GL.Color3f(1.0, 1.0, 1.0)
 
         surfaces_by_texture.each do |miptex_index, surfaces|
-          @texture_manager.bind(miptex_index)
+          @texture_manager.bind(miptex_index, time: (@time || 0.0).to_f)
+          fence = @texture_manager.fence?(miptex_index)
+          enable_fence_alpha_test if fence
 
           surfaces.each do |surf|
             GL.Begin(GL::TRIANGLE_FAN)
@@ -134,16 +142,22 @@ module Quake
             end
             GL.End
           end
+
+          GL.Disable(GL::ALPHA_TEST) if fence
         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.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+        GL.DepthMask(GL::FALSE)
         GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
 
         last_lm_tex = -1
-        surfaces_by_texture.each do |_miptex_index, surfaces|
+        surfaces_by_texture.each do |miptex_index, surfaces|
+          # Fence holes carry no diffuse/depth from pass 1; the lightmap quad
+          # would darken whatever shows through, so fences skip the light pass.
+          next if @texture_manager.fence?(miptex_index)
+
           surfaces.each do |surf|
             face_idx = surf[:face_index]
             next unless face_idx && @lightmap.face_lightmaps[face_idx]
@@ -154,10 +168,13 @@ module Quake
               last_lm_tex = lm_info.gl_texture
             end
 
-            texinfo = @level.texinfo[surf[:texinfo_index]]
+            lm_coords = surf[:lm_texcoords] ||= begin
+              texinfo = @level.texinfo[surf[:texinfo_index]]
+              surf[:vertices].map { |v| @lightmap.lightmap_texcoords(face_idx, v, texinfo) }
+            end
             GL.Begin(GL::TRIANGLE_FAN)
             surf[:vertices].each_with_index do |v, i|
-              ls, lt = @lightmap.lightmap_texcoords(face_idx, v, texinfo)
+              ls, lt = lm_coords[i]
               GL.TexCoord2f(ls, lt)
               GL.Vertex3f(v.x, v.y, v.z)
             end
@@ -165,7 +182,7 @@ module Quake
           end
         end
 
-        GL.DepthFunc(GL::LESS)
+        GL.DepthMask(GL::TRUE)
         GL.Disable(GL::BLEND)
         GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
       end
@@ -210,6 +227,11 @@ module Quake
         grouped
       end
 
+      def enable_fence_alpha_test
+        GL.AlphaFunc(GL::GREATER, 0.666)
+        GL.Enable(GL::ALPHA_TEST)
+      end
+
       def build_face_index
         index = {}
         @all_surfaces_by_texture.each do |miptex_index, surfaces|

data/lib/quake/renderer/gl_view_blend.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "opengl"
+require_relative "../physics/hull_trace"
+
+module Quake
+  module Renderer
+    # Renders Quake GL polyblend overlays from view.c color shifts.
+    class GLViewBlend
+      CShift = Data.define(:color, :percent)
+
+      EMPTY_CSHIFT = CShift.new(color: [130, 80, 50], percent: 0)
+      WATER_CSHIFT = CShift.new(color: [130, 80, 50], percent: 128)
+      SLIME_CSHIFT = CShift.new(color: [0, 25, 5], percent: 150)
+      LAVA_CSHIFT = CShift.new(color: [255, 80, 0], percent: 150)
+      BONUS_COLOR = [215, 186, 69].freeze
+      DAMAGE_ARMOR_COLOR = [200, 100, 100].freeze
+      DAMAGE_MIXED_COLOR = [220, 50, 50].freeze
+      DAMAGE_BLOOD_COLOR = [255, 0, 0].freeze
+
+      def self.contents_cshift(contents)
+        case contents
+        when Physics::CONTENTS_EMPTY, Physics::CONTENTS_SOLID
+          EMPTY_CSHIFT
+        when Physics::CONTENTS_LAVA
+          LAVA_CSHIFT
+        when Physics::CONTENTS_SLIME
+          SLIME_CSHIFT
+        else
+          WATER_CSHIFT
+        end
+      end
+
+      def self.powerup_cshift(player_state, game_time:)
+        if powerup_item_active?(player_state, :quad, game_time)
+          CShift.new(color: [0, 0, 255], percent: 30)
+        elsif powerup_item_active?(player_state, :biosuit, game_time)
+          CShift.new(color: [0, 255, 0], percent: 20)
+        elsif powerup_item_active?(player_state, :ring, game_time)
+          CShift.new(color: [100, 100, 100], percent: 100)
+        elsif powerup_item_active?(player_state, :pentagram, game_time)
+          CShift.new(color: [255, 255, 0], percent: 30)
+        else
+          CShift.new(color: [0, 0, 0], percent: 0)
+        end
+      end
+
+      def self.powerup_item_active?(player_state, powerup, game_time)
+        player_state&.powerup_item_active?(powerup, game_time: game_time)
+      end
+
+      def self.bonus_cshift(percent)
+        CShift.new(color: BONUS_COLOR, percent: percent.to_f.clamp(0.0, 50.0))
+      end
+
+      def self.damage_cshift(armor:, blood:, current_percent: 0.0)
+        armor = armor.to_f
+        blood = blood.to_f
+        count = blood * 0.5 + armor * 0.5
+        count = 10.0 if count < 10.0
+        percent = (current_percent.to_f + 3.0 * count).clamp(0.0, 150.0)
+        color = if armor > blood
+                  DAMAGE_ARMOR_COLOR
+                elsif armor.positive?
+                  DAMAGE_MIXED_COLOR
+                else
+                  DAMAGE_BLOOD_COLOR
+                end
+        CShift.new(color: color, percent: percent)
+      end
+
+      def self.calc_blend(cshifts, cshift_percent: 100.0)
+        r = 0.0
+        g = 0.0
+        b = 0.0
+        a = 0.0
+
+        cshifts.each do |shift|
+          next if cshift_percent.zero?
+
+          a2 = ((shift.percent.to_f * cshift_percent.to_f) / 100.0) / 255.0
+          next if a2.zero?
+
+          a += a2 * (1.0 - a)
+          a2 /= a
+          r = r * (1.0 - a2) + shift.color[0] * a2
+          g = g * (1.0 - a2) + shift.color[1] * a2
+          b = b * (1.0 - a2) + shift.color[2] * a2
+        end
+
+        [r / 255.0, g / 255.0, b / 255.0, a.clamp(0.0, 1.0)]
+      end
+
+      def render(blend)
+        return if blend[3].to_f <= 0.0
+
+        GL.MatrixMode(GL::PROJECTION)
+        GL.PushMatrix
+        GL.LoadIdentity
+        GL.Ortho(0, 1, 0, 1, -1, 1)
+        GL.MatrixMode(GL::MODELVIEW)
+        GL.PushMatrix
+        GL.LoadIdentity
+
+        GL.Disable(GL::DEPTH_TEST)
+        GL.Disable(GL::CULL_FACE) # 2D pass; scene re-enables culling next frame
+        GL.Disable(GL::TEXTURE_2D)
+        GL.Enable(GL::BLEND)
+        GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+        GL.Color4f(*blend)
+        GL.Begin(GL::QUADS)
+        GL.Vertex2f(0.0, 0.0)
+        GL.Vertex2f(1.0, 0.0)
+        GL.Vertex2f(1.0, 1.0)
+        GL.Vertex2f(0.0, 1.0)
+        GL.End
+
+        GL.Color4f(1.0, 1.0, 1.0, 1.0)
+        GL.Disable(GL::BLEND)
+        GL.Enable(GL::TEXTURE_2D)
+        GL.Enable(GL::DEPTH_TEST)
+        GL.MatrixMode(GL::MODELVIEW)
+        GL.PopMatrix
+        GL.MatrixMode(GL::PROJECTION)
+        GL.PopMatrix
+        GL.MatrixMode(GL::MODELVIEW)
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_viewmodel.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "opengl"
+require_relative "../math/vec3"
 
 module Quake
   module Renderer
@@ -13,6 +14,7 @@ module Quake
       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
+      VIEWMODEL_Z_FUDGE = 2.0 # scr_viewsize 100 in Quake's V_CalcRefdef
 
       # Current bob value (applied to camera Z by the game loop)
       attr_reader :bob
@@ -25,11 +27,15 @@ module Quake
         @bob_speed = 0.0
         @bob = 0.0
         @current_model_path = nil
+        @animation_frames = []
+        @animation_time = 0.0
       end
 
       def set_weapon(model_path)
         return if model_path == @current_model_path
         @current_model_path = model_path
+        @animation_frames = []
+        @animation_time = 0.0
         load_weapon(model_path) unless @weapon_renderers.key?(model_path)
       end
 
@@ -37,9 +43,16 @@ module Quake
         @time += dt
         @bob_speed = speed
         @bob = calc_bob
+        @animation_time += dt if @animation_frames.any?
       end
 
-      def render(camera, aspect)
+      def play_attack(frames)
+        @animation_frames = frames.to_a
+        @animation_time = 0.0
+      end
+
+      def render(camera, aspect, visible: true, ambient_light: 200.0, shade_light: 200.0)
+        return unless visible
         return unless @current_model_path
 
         gl_model = @weapon_renderers[@current_model_path]
@@ -47,25 +60,35 @@ module Quake
 
         # 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)
+        # Weapon origin = view origin + forward*bob*0.4 plus the default
+        # scr_viewsize 100 fudge from Quake's V_CalcRefdef. The camera
+        # position already carries the vertical bob, and in C the gun's
+        # own +bob cancels against the camera's, so none is added here.
+        # The fudge is applied along the view's up axis (not world Z as in
+        # the C source): a world-Z offset swings the gun down/away as the
+        # view pitches, while the reference's gun stays glued to the view.
+        pos = camera.position +
+              camera.forward * (@bob * 0.4) +
+              camera.up * VIEWMODEL_Z_FUDGE
 
         GL.Enable(GL::TEXTURE_2D)
 
         gl_model.render(
-          frame_index: 0,
+          frame_index: current_frame,
           lerp: 0.0,
           position: pos,
+          # CalcGunAngle sets viewent pitch to -viewpitch and
+          # R_RotateForEntity negates it again, so the gun's world rotation
+          # is +viewpitch -- it pitches with the view.
           yaw: camera.yaw,
-          pitch: camera.pitch
+          pitch: camera.pitch,
+          roll: camera.roll,
+          ambient_light: ambient_light,
+          shade_light: shade_light,
+          view_model: true
         )
 
         GL.DepthRange(0.0, 1.0)
-        GL.DepthFunc(GL::LESS)
       end
 
       private
@@ -73,7 +96,6 @@ module Quake
       # 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
@@ -91,6 +113,19 @@ module Quake
         bob.clamp(-7.0, 4.0)
       end
 
+      def current_frame
+        return 0 if @animation_frames.empty?
+
+        idx = (@animation_time * 10.0).to_i
+        if idx >= @animation_frames.size
+          @animation_frames = []
+          @animation_time = 0.0
+          return 0
+        end
+
+        @animation_frames[idx]
+      end
+
       def load_weapon(model_path)
         begin
           data = @pak.read(model_path)

data/lib/quake/renderer/gl_warp_subdivision.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Quake
+  module Renderer
+    module GLWarpSubdivision
+      SUBDIVIDE_SIZE = 128.0
+
+      private
+
+      # Matches GLQuake's SubdividePolygon using default gl_subdivide_size.
+      def subdivide_polygon(verts)
+        result = []
+        subdivide_polygon_recursive(verts, result)
+        result
+      end
+
+      def subdivide_polygon_recursive(verts, result)
+        3.times do |axis|
+          mins, maxs = polygon_axis_bounds(verts, axis)
+          mid = (mins + maxs) * 0.5
+          mid = SUBDIVIDE_SIZE * (mid / SUBDIVIDE_SIZE + 0.5).floor
+          next if maxs - mid < 8.0
+          next if mid - mins < 8.0
+
+          front, back = split_polygon_at_axis(verts, axis, mid)
+          subdivide_polygon_recursive(front, result)
+          subdivide_polygon_recursive(back, result)
+          return
+        end
+
+        result << verts
+      end
+
+      def polygon_axis_bounds(verts, 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
+        [mins, maxs]
+      end
+
+      def split_polygon_at_axis(verts, axis, mid)
+        front = []
+        back = []
+        distances = verts.map { |v| v.to_a[axis] - mid }
+
+        verts.each_with_index do |v, i|
+          v_next = verts[(i + 1) % verts.size]
+          d1 = distances[i]
+          d2 = distances[(i + 1) % verts.size]
+
+          front << v if d1 >= 0.0
+          back << v if d1 <= 0.0
+          next if d1.zero? || d2.zero?
+          next if d1.positive? == d2.positive?
+
+          frac = d1 / (d1 - d2)
+          mid_vertex = 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_vertex
+          back << mid_vertex
+        end
+
+        [front, back]
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_water.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
 require "opengl"
+require_relative "gl_warp_subdivision"
 
 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
+      include GLWarpSubdivision
 
-      SUBDIVIDE_SIZE = 64.0
+      TURBSCALE = 256.0 / (2.0 * ::Math::PI) # ~40.74
 
       def initialize(level, texture_manager)
         @level = level
@@ -36,13 +37,6 @@ module Quake
         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)
@@ -75,8 +69,6 @@ module Quake
           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)
@@ -115,7 +107,7 @@ module Quake
 
           subdivided.each do |poly_verts|
             texcoords = poly_verts.map do |v|
-              # Raw dot product only, no offset (matches TyrQuake SubdividePolygon)
+              # Raw dot product only, no offset (matches Quake SubdividePolygon)
               s = v.dot(texinfo.s_vec)
               t = v.dot(texinfo.t_vec)
               [s, t]
@@ -131,70 +123,6 @@ module Quake
         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