quake-rb 0.1.0 → 0.2.0

data/lib/quake/renderer/gl_brush_model.rb

@@ -8,6 +8,8 @@ module Quake
     # Each brush entity references a model in the BSP models array (models[1], [2], etc.)
     # and has a position/angle from its entity definition.
     class GLBrushModel
+      BACKFACE_EPSILON = 0.01
+
       def initialize(level, texture_manager, lightmap)
         @level = level
         @texture_manager = texture_manager
@@ -20,25 +22,30 @@ module Quake
 
       # Render all brush entities at their current positions.
       # entities: array of Entity objects that have model_index set
-      def render(entities)
+      def render(entities, view_origin: Math::Vec3::ORIGIN, time: 0.0, frustum: nil)
         GL.Enable(GL::TEXTURE_2D)
         GL.Color3f(1.0, 1.0, 1.0)
 
         entities.each do |ent|
           next unless ent.brush_entity?
+          next if ent.removed?
           surfaces = @model_surfaces[ent.model_index]
           next unless surfaces
+          next if frustum && culled_by_frustum?(ent, frustum)
 
           GL.PushMatrix
           GL.Translatef(ent.position.x, ent.position.y, ent.position.z)
 
-          if ent.angle != 0.0 && ent.angles != Math::Vec3::ORIGIN
-            GL.Rotatef(ent.angles.x, 1.0, 0.0, 0.0)
-            GL.Rotatef(ent.angles.y, 0.0, 1.0, 0.0)
-            GL.Rotatef(ent.angles.z, 0.0, 0.0, 1.0)
+          if brush_model_rotated?(ent)
+            GL.Rotatef(ent.angles.y, 0.0, 0.0, 1.0)
+            # Net +pitch: R_DrawBrushModel negates pitch before
+            # R_RotateForEntity's -pitch rotation ("stupid quake bug")
+            GL.Rotatef(ent.angles.x, 0.0, 1.0, 0.0)
+            GL.Rotatef(ent.angles.z, 1.0, 0.0, 0.0)
           end
 
-          render_model_surfaces(surfaces)
+          modelorg = brush_model_modelorg(view_origin, ent)
+          render_model_surfaces(surfaces, modelorg, time: time, alternate: ent.frame.to_i.positive?)
 
           GL.PopMatrix
         end
@@ -70,7 +77,9 @@ module Quake
               texcoords: surf.texcoords,
               miptex_index: texinfo.miptex_index,
               face_index: face_index,
-              texinfo_index: face.texinfo_index
+              texinfo_index: face.texinfo_index,
+              plane_index: face.plane_index,
+              flags: face.flags
             }
           end
 
@@ -81,16 +90,18 @@ module Quake
         puts "Precomputed #{total} brush model surfaces across #{@model_surfaces.size} sub-models"
       end
 
-      def render_model_surfaces(surfaces)
+      def render_model_surfaces(surfaces, modelorg, time:, alternate:)
+        surfaces = surfaces.select { |surf| brush_surface_visible?(surf, modelorg) }
+
         # Group by texture for fewer bind calls
         current_miptex = -1
 
         if @lightmap
-          render_surfaces_with_lightmaps(surfaces)
+          render_surfaces_with_lightmaps(surfaces, time: time, alternate: alternate)
         else
           surfaces.each do |surf|
             if surf[:miptex_index] != current_miptex
-              @texture_manager.bind(surf[:miptex_index])
+              @texture_manager.bind(surf[:miptex_index], time: time, alternate: alternate)
               current_miptex = surf[:miptex_index]
             end
 
@@ -105,15 +116,26 @@ module Quake
         end
       end
 
-      def render_surfaces_with_lightmaps(surfaces)
+      def render_surfaces_with_lightmaps(surfaces, time:, alternate:)
         # Pass 1: diffuse textures
         GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
         current_miptex = -1
 
+        fence = false
         surfaces.each do |surf|
           if surf[:miptex_index] != current_miptex
-            @texture_manager.bind(surf[:miptex_index])
+            @texture_manager.bind(surf[:miptex_index], time: time, alternate: alternate)
             current_miptex = surf[:miptex_index]
+            surf_fence = @texture_manager.fence?(current_miptex)
+            if surf_fence != fence
+              fence = surf_fence
+              if fence
+                GL.AlphaFunc(GL::GREATER, 0.666)
+                GL.Enable(GL::ALPHA_TEST)
+              else
+                GL.Disable(GL::ALPHA_TEST)
+              end
+            end
           end
 
           GL.Begin(GL::TRIANGLE_FAN)
@@ -124,15 +146,18 @@ module Quake
           end
           GL.End
         end
+        GL.Disable(GL::ALPHA_TEST) if fence
 
         # Pass 2: lightmap multiply
         GL.Enable(GL::BLEND)
-        GL.BlendFunc(GL::ZERO, GL::SRC_COLOR)
+        GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
         GL.DepthMask(GL::FALSE)
-        GL.DepthFunc(GL::LEQUAL)
 
         last_lm_tex = -1
         surfaces.each do |surf|
+          # Fences skip the light pass -- holes carry no pass-1 depth/diffuse
+          next if @texture_manager.fence?(surf[:miptex_index])
+
           face_idx = surf[:face_index]
           next unless @lightmap.face_lightmaps[face_idx]
 
@@ -142,10 +167,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
@@ -153,10 +181,94 @@ module Quake
         end
 
         GL.DepthMask(GL::TRUE)
-        GL.DepthFunc(GL::LESS)
         GL.Disable(GL::BLEND)
         GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
       end
+
+      # R_CullBox against the view frustum (R_DrawBrushModel). Rotated
+      # entities use a conservative radius box like the C reference.
+      def culled_by_frustum?(ent, frustum)
+        model = @level.models[ent.model_index]
+        return false unless model&.mins && model.maxs
+
+        if brush_model_rotated?(ent)
+          radius = radius_from_bounds(model.mins, model.maxs)
+          extent = Math::Vec3.new(radius, radius, radius)
+          mins = ent.position - extent
+          maxs = ent.position + extent
+        else
+          mins = ent.position + model.mins
+          maxs = ent.position + model.maxs
+        end
+
+        cull_box?(mins, maxs, frustum)
+      end
+
+      def cull_box?(mins, maxs, frustum)
+        frustum.any? do |normal, dist|
+          px = normal.x >= 0 ? maxs.x : mins.x
+          py = normal.y >= 0 ? maxs.y : mins.y
+          pz = normal.z >= 0 ? maxs.z : mins.z
+          (normal.x * px) + (normal.y * py) + (normal.z * pz) - dist < 0
+        end
+      end
+
+      def radius_from_bounds(mins, maxs)
+        x = [mins.x.abs, maxs.x.abs].max
+        y = [mins.y.abs, maxs.y.abs].max
+        z = [mins.z.abs, maxs.z.abs].max
+        ::Math.sqrt((x * x) + (y * y) + (z * z))
+      end
+
+      def brush_surface_visible?(surf, modelorg)
+        plane = @level.planes[surf[:plane_index]]
+        return true unless plane
+
+        dot = modelorg.dot(plane.normal) - plane.dist
+        if (surf[:flags].to_i & Bsp::Face::SURF_PLANEBACK) != 0
+          dot < -BACKFACE_EPSILON
+        else
+          dot > BACKFACE_EPSILON
+        end
+      end
+
+      def brush_model_rotated?(ent)
+        ent.angles != Math::Vec3::ORIGIN
+      end
+
+      def brush_model_modelorg(view_origin, ent)
+        modelorg = view_origin - ent.position
+        return modelorg unless brush_model_rotated?(ent)
+
+        forward, right, up = quake_angle_vectors(ent.angles)
+        Math::Vec3.new(
+          modelorg.dot(forward),
+          -modelorg.dot(right),
+          modelorg.dot(up)
+        )
+      end
+
+      def quake_angle_vectors(angles)
+        sy = ::Math.sin(deg2rad(angles.y))
+        cy = ::Math.cos(deg2rad(angles.y))
+        sp = ::Math.sin(deg2rad(angles.x))
+        cp = ::Math.cos(deg2rad(angles.x))
+        sr = ::Math.sin(deg2rad(angles.z))
+        cr = ::Math.cos(deg2rad(angles.z))
+
+        forward = Math::Vec3.new(cp * cy, cp * sy, -sp)
+        right = Math::Vec3.new((-sr * sp * cy) + (cr * sy),
+                               (-sr * sp * sy) - (cr * cy),
+                               -sr * cp)
+        up = Math::Vec3.new((cr * sp * cy) + (sr * sy),
+                            (cr * sp * sy) - (sr * cy),
+                            cr * cp)
+        [forward, right, up]
+      end
+
+      def deg2rad(deg)
+        deg * ::Math::PI / 180.0
+      end
     end
   end
 end