quake-rb 0.1.0 → 0.2.0

data/lib/quake/bsp/vis.rb

@@ -71,119 +71,9 @@ module Quake
         end
       end
 
-      # Compute a "fat" PVS by unioning the PVS of every leaf within ~8 units
-      # of the given point. Used near translucent water surfaces so the
-      # underwater leaves (which standard PVS excludes from above-water
-      # leaves) are included; without this the cave bed isn't drawn and
-      # alpha-blended water shows the clear color through gaps.
-      # Port of quakespasm SV_FatPVS / SV_AddToFatPVS.
-      def self.fat_pvs(level, point)
-        num_leafs = level.leafs.size - 1
-        result = Set.new
-        add_to_fat_pvs(level, point, 0, num_leafs, result)
-        result
-      end
-
-      def self.add_to_fat_pvs(level, point, node_index, num_leafs, result)
-        loop do
-          if node_index < 0
-            leaf_index = ~node_index
-            return if leaf_index == 0 # skip the universal solid leaf
-            leaf = level.leafs[leaf_index]
-            return if leaf.nil?
-            result.merge(decompress_pvs(level.visibility, leaf.vis_offset, num_leafs))
-            return
-          end
-
-          node = level.nodes[node_index]
-          plane = level.planes[node.plane_index]
-          d = point.dot(plane.normal) - plane.dist
-
-          if d > 8.0
-            node_index = node.children[0]
-          elsif d < -8.0
-            node_index = node.children[1]
-          else
-            # Straddling the plane within the fat radius - descend both sides
-            add_to_fat_pvs(level, point, node.children[0], num_leafs, result)
-            node_index = node.children[1]
-          end
-        end
-      end
-
-      # True if any of the given leaf's marksurfaces is a turbulent (liquid)
-      # surface. Quakespasm's "near water portal" check.
-      def self.near_liquid_portal?(level, leaf)
-        return false if leaf.nil?
-        leaf.num_marksurfaces.times do |i|
-          face_idx = level.marksurfaces[leaf.first_marksurface + i]
-          face = level.faces[face_idx]
-          next if face.nil?
-          ti = level.texinfo[face.texinfo_index]
-          next if ti.nil?
-          tex = level.textures[ti.miptex_index]
-          return true if tex && tex.name.start_with?("*")
-        end
-        false
-      end
-
-      # Precompute, for each liquid (turb) face, the two leaves it physically
-      # separates (computed via BSP traversal of a point on either side of
-      # the face's plane). The standard Quake VIS compiler treats water as
-      # opaque, so above-water and underwater leaves never see each other in
-      # the PVS. Marksurface lists are also unreliable here - many water
-      # faces are marked in only one leaf - so we use geometry instead. We
-      # use this index at runtime to "vis-through" water surfaces: when a
-      # water face is in the visible set, also include the leaves on its
-      # other side. Without this, translucent water alpha-blends against
-      # the clear color where the cave bed should be.
-      def self.liquid_face_to_leaves(level)
-        @liquid_face_to_leaves_cache ||= {}
-        cached = @liquid_face_to_leaves_cache[level.object_id]
-        return cached if cached
-
-        index = {}
-        level.faces.each_with_index do |face, face_idx|
-          next if face.nil?
-          ti = level.texinfo[face.texinfo_index]
-          next if ti.nil?
-          tex = level.textures[ti.miptex_index]
-          next unless tex && tex.name.start_with?("*")
-
-          # Compute face center
-          cx = cy = cz = 0.0
-          n = face.num_edges
-          n.times do |i|
-            se = level.surfedges[face.first_edge + i]
-            edge = level.edges[se.abs]
-            v = se >= 0 ? level.vertices[edge.v0] : level.vertices[edge.v1]
-            cx += v.x; cy += v.y; cz += v.z
-          end
-          cx /= n; cy /= n; cz /= n
-
-          plane = level.planes[face.plane_index]
-          # Step a small distance along + and - the plane normal, find the
-          # leaf each point lands in.
-          offsets = [1.0, -1.0]
-          leaves = offsets.map do |o|
-            pt = Math::Vec3.new(
-              cx + plane.normal.x * o,
-              cy + plane.normal.y * o,
-              cz + plane.normal.z * o
-            )
-            point_in_leaf(level, pt)
-          end.uniq.reject { |l| l == 0 } # skip solid leaf
-
-          index[face_idx] = leaves
-        end
-
-        @liquid_face_to_leaves_cache[level.object_id] = index
-        index
-      end
-
       # Mark which faces are visible from the given leaf.
       # Returns a Set of face indices that should be rendered.
-      def self.visible_faces(level, leaf_index, point: nil)
+      def self.visible_faces(level, leaf_index)
         leaf = level.leafs[leaf_index]
         return Set.new if leaf.nil?
 
@@ -195,43 +85,18 @@ module Quake
         # solid space (noclip, edge cases) still sees the world.
         visible_leafs = if leaf_index == 0
                           all_visible(num_leafs)
-                        elsif point && near_liquid_portal?(level, leaf)
-                          # Camera leaf touches a liquid surface. Use FatPVS
-                          # so the underwater leaves are included and
-                          # translucent water doesn't reveal void where the
-                          # bed should be.
-                          fat_pvs(level, point)
                         else
                           decompress_pvs(level.visibility, leaf.vis_offset, num_leafs)
                         end
 
         face_set = Set.new
-        leafs_to_walk = visible_leafs.dup
-        leafs_to_walk << leaf_index # also include current leaf
-
-        # Vis-through water: any visible water face brings the leaves on its
-        # other side into view too. Standard Quake PVS treats water as
-        # opaque, so without this expansion translucent water from above
-        # blends against void instead of the underwater cave bed.
-        liquid_index = liquid_face_to_leaves(level)
-        seen_leafs = Set.new
-        worklist = leafs_to_walk.to_a
-
-        while (li = worklist.shift)
-          next unless seen_leafs.add?(li)
+        visible_leafs.each do |li|
           vl = level.leafs[li]
           next if vl.nil?
 
           vl.num_marksurfaces.times do |i|
             face_idx = level.marksurfaces[vl.first_marksurface + i]
             face_set << face_idx
-
-            # If this is a water face, queue the leaves on its other side.
-            other_leaves = liquid_index[face_idx]
-            next unless other_leaves
-            other_leaves.each do |other_leaf|
-              worklist << other_leaf unless seen_leafs.include?(other_leaf)
-            end
           end
         end
 

data/lib/quake/camera.rb

@@ -5,7 +5,7 @@ require "glu"
 
 module Quake
   class Camera
-    attr_accessor :position, :yaw, :pitch
+    attr_accessor :position, :yaw, :pitch, :roll
     attr_reader :fov, :near, :far
 
     SPEED = 320.0       # units per second (Quake run speed)
@@ -13,10 +13,11 @@ module Quake
     MAX_MOUSE_DELTA = 50 # clamp insane deltas (e.g. first frame warp)
 
     def initialize(position: Math::Vec3::ORIGIN, yaw: 0.0, pitch: 0.0,
-                   fov: 90.0, near: 4.0, far: 4096.0)
+                   fov: 90.0, near: 4.0, far: 6144.0)
       @position = position
       @yaw = yaw
       @pitch = pitch
+      @roll = 0.0
       @fov = fov
       @near = near
       @far = far
@@ -24,25 +25,15 @@ module Quake
     end
 
     def forward
-      # Quake: X = forward, Y = left, Z = up
-      # yaw rotates around Z, pitch rotates around Y
-      ry = deg2rad(@yaw)
-      rp = deg2rad(@pitch)
-      cp = ::Math.cos(rp)
-      Math::Vec3.new(
-        ::Math.cos(ry) * cp,
-        ::Math.sin(ry) * cp,
-        -::Math.sin(rp)
-      )
+      quake_angle_vectors.fetch(:forward)
     end
 
     def right
-      ry = deg2rad(@yaw - 90.0)
-      Math::Vec3.new(::Math.cos(ry), ::Math.sin(ry), 0.0)
+      quake_angle_vectors.fetch(:right)
     end
 
     def up
-      Math::Vec3.new(0.0, 0.0, 1.0)
+      quake_angle_vectors.fetch(:up)
     end
 
     def move_forward(dt)
@@ -72,7 +63,39 @@ module Quake
     def apply_projection_gl(aspect)
       GL.MatrixMode(GL::PROJECTION)
       GL.LoadIdentity
-      GLU.Perspective(@fov, aspect, @near, @far)
+      GLU.Perspective(fov_y(aspect), aspect, @near, @far)
+    end
+
+    # Quake's fov cvar is the horizontal FOV on a 4:3 screen. Like
+    # Quakespasm's fov_adapt (Hor+), the vertical FOV stays at its 4:3
+    # value on wide screens and the horizontal FOV widens instead --
+    # otherwise widescreen crops the view and the weapon model.
+    def fov_y(_aspect = nil)
+      2.0 * ::Math.atan(::Math.tan(deg2rad(@fov) / 2.0) * 0.75) * 180.0 / ::Math::PI
+    end
+
+    # Actual horizontal FOV for a given aspect (follows from fov_y)
+    def fov_x(aspect)
+      2.0 * ::Math.atan(::Math.tan(deg2rad(fov_y) / 2.0) * aspect) * 180.0 / ::Math::PI
+    end
+
+    # R_SetFrustum: 4 view-frustum planes as [normal, dist] pairs, where a
+    # point is inside when normal.dot(point) - dist >= 0.
+    def frustum_planes(aspect)
+      vecs = quake_angle_vectors
+      forward = vecs.fetch(:forward)
+      right = vecs.fetch(:right)
+      up = vecs.fetch(:up)
+
+      fx = fov_x(aspect)
+      fy = fov_y
+      normals = [
+        rotate_around_axis(forward, up, -(90.0 - fx / 2.0)),
+        rotate_around_axis(forward, up, 90.0 - fx / 2.0),
+        rotate_around_axis(forward, right, 90.0 - fy / 2.0),
+        rotate_around_axis(forward, right, -(90.0 - fy / 2.0))
+      ]
+      normals.map { |normal| [normal, normal.dot(@position)] }
     end
 
     def apply_gl
@@ -85,6 +108,7 @@ module Quake
       GL.Rotatef(-90.0, 1.0, 0.0, 0.0)  # Z-up -> Y-up
       GL.Rotatef(90.0, 0.0, 0.0, 1.0)   # X-forward -> GL
 
+      GL.Rotatef(-@roll, 1.0, 0.0, 0.0)
       GL.Rotatef(-@pitch, 0.0, 1.0, 0.0)
       GL.Rotatef(-@yaw, 0.0, 0.0, 1.0)
       GL.Translatef(-@position.x, -@position.y, -@position.z)
@@ -95,5 +119,38 @@ module Quake
     def deg2rad(deg)
       deg * ::Math::PI / 180.0
     end
+
+    # Rodrigues rotation of v around unit axis by degrees
+    def rotate_around_axis(v, axis, degrees)
+      rad = deg2rad(degrees)
+      cos = ::Math.cos(rad)
+      sin = ::Math.sin(rad)
+      cross = axis.cross(v)
+      dot = axis.dot(v)
+      Math::Vec3.new(
+        v.x * cos + cross.x * sin + axis.x * dot * (1.0 - cos),
+        v.y * cos + cross.y * sin + axis.y * dot * (1.0 - cos),
+        v.z * cos + cross.z * sin + axis.z * dot * (1.0 - cos)
+      )
+    end
+
+    def quake_angle_vectors
+      sy = ::Math.sin(deg2rad(@yaw))
+      cy = ::Math.cos(deg2rad(@yaw))
+      sp = ::Math.sin(deg2rad(@pitch))
+      cp = ::Math.cos(deg2rad(@pitch))
+      sr = ::Math.sin(deg2rad(@roll))
+      cr = ::Math.cos(deg2rad(@roll))
+
+      {
+        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)
+      }
+    end
   end
 end