quake-rb 0.1.0

data/lib/quake/physics/player.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+module Quake
+  module Physics
+    # Full Quake player physics: gravity, friction, acceleration, jumping,
+    # ground detection, stair stepping, and swimming.
+    class Player
+      attr_accessor :position, :velocity, :on_ground, :water_level, :noclip
+      attr_reader :yaw, :pitch
+
+      # Quake constants
+      GRAVITY       = 800.0    # units/sec^2
+      FRICTION      = 4.0
+      STOP_SPEED    = 100.0
+      MAX_SPEED     = 320.0
+      ACCELERATE    = 10.0
+      AIR_ACCELERATE = 0.7
+      JUMP_SPEED    = 270.0
+      STEP_SIZE     = 18.0
+      WATER_FRICTION = 1.0
+      WATER_ACCELERATE = 10.0
+
+      # Camera
+      SENSITIVITY   = 0.15
+      MAX_MOUSE_DELTA = 50
+      VIEW_HEIGHT   = 22.0 # eye offset from origin (origin is at player feet center)
+
+      # Ground: surface normal Z must be > 0.7 (roughly < 45 degrees from horizontal)
+      MIN_GROUND_NORMAL_Z = 0.7
+
+      def initialize(position:, yaw: 0.0)
+        @position = position
+        @velocity = Math::Vec3::ORIGIN
+        @yaw = yaw
+        @pitch = 0.0
+        @on_ground = false
+        @water_level = 0 # 0=dry, 1=feet, 2=waist, 3=head
+        @jump_held = false
+        @noclip = false
+        @ignore_mouse = 2
+      end
+
+      # Camera eye position (origin + view height)
+      def eye_position
+        Math::Vec3.new(@position.x, @position.y, @position.z + VIEW_HEIGHT)
+      end
+
+      def rotate(dx, dy)
+        if @ignore_mouse > 0
+          @ignore_mouse -= 1
+          return
+        end
+        dx = dx.clamp(-MAX_MOUSE_DELTA, MAX_MOUSE_DELTA)
+        dy = dy.clamp(-MAX_MOUSE_DELTA, MAX_MOUSE_DELTA)
+        @yaw -= dx * SENSITIVITY
+        @pitch += dy * SENSITIVITY
+        @pitch = @pitch.clamp(-89.0, 89.0)
+      end
+
+      def update(dt, level, keys, brush_entities: nil)
+        if @noclip
+          noclip_move(dt, keys)
+          return
+        end
+
+        @brush_entities = brush_entities
+        categorize_position(level)
+
+        # Calculate wish direction from input
+        wish_dir, wish_speed = compute_wish_velocity(keys)
+
+        if @water_level >= 2
+          water_move(dt, wish_dir, wish_speed, keys, level)
+        else
+          # Apply gravity if not on ground and not in water
+          unless @on_ground
+            @velocity = Math::Vec3.new(@velocity.x, @velocity.y,
+                                       @velocity.z - GRAVITY * dt)
+          end
+
+          # Handle jumping (SET vz, don't add - matches Quake's PM_AirMove)
+          if @on_ground && keys[SDL::SCANCODE_SPACE] && !@jump_held
+            @velocity = Math::Vec3.new(@velocity.x, @velocity.y, JUMP_SPEED)
+            @on_ground = false
+            @jump_held = true
+          end
+          @jump_held = false unless keys[SDL::SCANCODE_SPACE]
+
+          if @on_ground
+            apply_friction(dt, level)
+            accelerate(wish_dir, wish_speed, ACCELERATE, dt)
+          else
+            air_accelerate(wish_dir, wish_speed, dt)
+          end
+        end
+
+        # Move with collision
+        walk_move(dt, level)
+      end
+
+      # Forward direction (horizontal only, for movement)
+      def forward_flat
+        ry = deg2rad(@yaw)
+        Math::Vec3.new(::Math.cos(ry), ::Math.sin(ry), 0.0)
+      end
+
+      def right_flat
+        ry = deg2rad(@yaw - 90.0)
+        Math::Vec3.new(::Math.cos(ry), ::Math.sin(ry), 0.0)
+      end
+
+      # Full forward including pitch (for camera)
+      def forward
+        ry = deg2rad(@yaw)
+        rp = deg2rad(@pitch)
+        cp = ::Math.cos(rp)
+        Math::Vec3.new(::Math.cos(ry) * cp, ::Math.sin(ry) * cp, -::Math.sin(rp))
+      end
+
+      def right
+        ry = deg2rad(@yaw - 90.0)
+        Math::Vec3.new(::Math.cos(ry), ::Math.sin(ry), 0.0)
+      end
+
+      private
+
+      def deg2rad(deg)
+        deg * ::Math::PI / 180.0
+      end
+
+      def compute_wish_velocity(keys)
+        wish = Math::Vec3::ORIGIN
+        wish = wish + forward_flat if keys[SDL::SCANCODE_W]
+        wish = wish - forward_flat if keys[SDL::SCANCODE_S]
+        wish = wish + right_flat if keys[SDL::SCANCODE_D]
+        wish = wish - right_flat if keys[SDL::SCANCODE_A]
+
+        len = wish.length
+        return [Math::Vec3::ORIGIN, 0.0] if len < 0.001
+
+        [wish.normalize, MAX_SPEED]
+      end
+
+      def apply_friction(dt, level)
+        speed = ::Math.sqrt(@velocity.x**2 + @velocity.y**2)
+        return if speed < 1.0
+
+        control = [speed, STOP_SPEED].max
+        drop = control * FRICTION * dt
+
+        new_speed = [speed - drop, 0.0].max / speed
+        @velocity = Math::Vec3.new(
+          @velocity.x * new_speed,
+          @velocity.y * new_speed,
+          @velocity.z
+        )
+      end
+
+      def accelerate(wish_dir, wish_speed, accel, dt)
+        current_speed = @velocity.dot(wish_dir)
+        add_speed = wish_speed - current_speed
+        return if add_speed <= 0
+
+        accel_speed = [accel * dt * wish_speed, add_speed].min
+        @velocity = @velocity + wish_dir * accel_speed
+      end
+
+      def air_accelerate(wish_dir, wish_speed, dt)
+        current_speed = @velocity.dot(wish_dir)
+        wish_spd = [wish_speed, 30.0].min # air strafe cap
+        add_speed = wish_spd - current_speed
+        return if add_speed <= 0
+
+        accel_speed = [AIR_ACCELERATE * wish_speed * dt, add_speed].min
+        @velocity = @velocity + wish_dir * accel_speed
+      end
+
+      def water_move(dt, wish_dir, wish_speed, keys, level)
+        # Water friction
+        speed = @velocity.length
+        if speed > 0
+          new_speed = [speed - dt * speed * WATER_FRICTION * @water_level, 0.0].max
+          @velocity = @velocity * (new_speed / speed)
+        end
+
+        # Build wish velocity from horizontal input + vertical keys
+        has_horizontal = wish_speed > 0.001
+        has_up = keys[SDL::SCANCODE_SPACE]
+        has_down = keys[SDL::SCANCODE_C]
+
+        # Use forward direction including pitch when swimming
+        swim_wish = Math::Vec3::ORIGIN
+        if keys[SDL::SCANCODE_W]
+          swim_wish = swim_wish + forward
+        end
+        if keys[SDL::SCANCODE_S]
+          swim_wish = swim_wish - forward
+        end
+        if keys[SDL::SCANCODE_D]
+          swim_wish = swim_wish + right
+        end
+        if keys[SDL::SCANCODE_A]
+          swim_wish = swim_wish - right
+        end
+
+        # Vertical movement
+        if has_up
+          swim_wish = Math::Vec3.new(swim_wish.x, swim_wish.y, swim_wish.z + 1.0)
+        elsif has_down
+          swim_wish = Math::Vec3.new(swim_wish.x, swim_wish.y, swim_wish.z - 1.0)
+        end
+
+        swim_len = swim_wish.length
+        if swim_len < 0.001
+          # No input at all: drift down slowly
+          @velocity = Math::Vec3.new(@velocity.x, @velocity.y, @velocity.z - 60.0 * dt)
+          return
+        end
+
+        wish_dir2 = swim_wish.normalize
+        wish_spd = MAX_SPEED * 0.7 # water reduces max speed to 70%
+        accelerate(wish_dir2, wish_spd, WATER_ACCELERATE, dt)
+      end
+
+      def categorize_position(level)
+        # Check ground: trace 1 unit down against world + brush entities
+        if @velocity.z > 180
+          @on_ground = false
+        else
+          trace_start = @position
+          trace_end = Math::Vec3.new(@position.x, @position.y, @position.z - 1.0)
+          result = HullTrace.trace_world_and_entities(
+            level, trace_start, trace_end, @brush_entities
+          )
+
+          if result.fraction < 1.0 && result.plane_normal &&
+             result.plane_normal.z >= MIN_GROUND_NORMAL_Z
+            @on_ground = true
+            @position = result.end_pos if !result.start_solid && !result.all_solid
+            # Zero out negative z velocity when grounded (matches Quake's
+            # PM_CategorizePosition: pmove.velocity[2] = 0)
+            if @velocity.z < 0
+              @velocity = Math::Vec3.new(@velocity.x, @velocity.y, 0.0)
+            end
+          else
+            @on_ground = false
+          end
+        end
+
+        # Check water level using BSP leaf contents (not clipnodes).
+        # Hull 1 clipnodes only track solid/empty; water content is in the
+        # BSP node/leaf tree which point_in_leaf walks.
+        @water_level = 0
+        @water_type = CONTENTS_EMPTY
+
+        # Feet check (player mins z = -24)
+        feet_pos = Math::Vec3.new(@position.x, @position.y, @position.z - 23)
+        contents = leaf_contents(level, feet_pos)
+        if contents <= CONTENTS_WATER
+          @water_type = contents
+          @water_level = 1
+          # Waist check
+          mid_pos = Math::Vec3.new(@position.x, @position.y, @position.z + 4)
+          if leaf_contents(level, mid_pos) <= CONTENTS_WATER
+            @water_level = 2
+            # Head check
+            head_pos = Math::Vec3.new(@position.x, @position.y, @position.z + VIEW_HEIGHT)
+            @water_level = 3 if leaf_contents(level, head_pos) <= CONTENTS_WATER
+          end
+        end
+      end
+
+      # Get the content type at a point using the BSP node/leaf tree.
+      # This correctly detects water, slime, lava (unlike clipnodes).
+      def leaf_contents(level, point)
+        leaf_idx = Bsp::Vis.point_in_leaf(level, point)
+        leaf = level.leafs[leaf_idx]
+        leaf ? leaf.contents : CONTENTS_EMPTY
+      end
+
+      def walk_move(dt, level)
+        # Desired new position
+        desired = @position + @velocity * dt
+
+        # Trace against world + brush entities
+        result = trace_move(level, @position, desired)
+
+        return if result.all_solid # stuck
+
+        if result.fraction == 1.0
+          @position = desired
+          return
+        end
+
+        # Hit something. Try stair stepping.
+        contact = result.end_pos
+
+        # Step up
+        step_up = Math::Vec3.new(contact.x, contact.y, contact.z + STEP_SIZE)
+        up_trace = trace_move(level, contact, step_up)
+        raised = up_trace.end_pos
+
+        # Move forward from raised position
+        step_forward = Math::Vec3.new(desired.x, desired.y, raised.z)
+        forward_trace = trace_move(level, raised, step_forward)
+        forward_pos = forward_trace.end_pos
+
+        # Step back down
+        step_down = Math::Vec3.new(forward_pos.x, forward_pos.y, forward_pos.z - STEP_SIZE)
+        down_trace = trace_move(level, forward_pos, step_down)
+
+        if down_trace.fraction < 1.0 && down_trace.plane_normal &&
+           down_trace.plane_normal.z >= MIN_GROUND_NORMAL_Z
+          @position = down_trace.end_pos
+          return
+        end
+
+        # Step didn't work - slide along the wall
+        @position = contact
+        slide_along_wall(result, dt, level)
+      end
+
+      def trace_move(level, from, to)
+        HullTrace.trace_world_and_entities(level, from, to, @brush_entities)
+      end
+
+      def slide_along_wall(trace_result, dt, level)
+        normal = trace_result.plane_normal
+        return unless normal
+
+        backoff = @velocity.dot(normal)
+        @velocity = Math::Vec3.new(
+          @velocity.x - normal.x * backoff,
+          @velocity.y - normal.y * backoff,
+          @velocity.z - normal.z * backoff
+        )
+
+        remaining = @velocity * (dt * (1.0 - trace_result.fraction))
+        desired = @position + remaining
+        result = trace_move(level, @position, desired)
+        @position = result.end_pos
+      end
+
+      def noclip_move(dt, keys)
+        wish = Math::Vec3::ORIGIN
+        wish = wish + forward if keys[SDL::SCANCODE_W]
+        wish = wish - forward if keys[SDL::SCANCODE_S]
+        wish = wish + right if keys[SDL::SCANCODE_D]
+        wish = wish - right if keys[SDL::SCANCODE_A]
+        wish = wish + Math::Vec3.new(0.0, 0.0, 1.0) if keys[SDL::SCANCODE_SPACE]
+        wish = wish - Math::Vec3.new(0.0, 0.0, 1.0) if keys[SDL::SCANCODE_C]
+
+        @position = @position + wish * (MAX_SPEED * dt)
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_alias_model.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Renders Quake MDL (alias) models with texture mapping and frame animation.
+    class GLAliasModel
+      # Quake's pre-computed normal table (162 normals for lighting)
+      # Simplified to just the first few key directions for now
+      ANORMS = nil # Full table would be loaded from anorms.h
+
+      def initialize(model, palette)
+        @model = model
+        @palette = palette
+        @skin_textures = []
+        upload_skins
+      end
+
+      # Render the model at a given frame (interpolation between two frames).
+      # frame_index: current frame number
+      # lerp: 0.0-1.0 interpolation factor to next frame
+      # position: Vec3 world position
+      # yaw: rotation angle in degrees
+      def render(frame_index:, lerp: 0.0, position: Math::Vec3::ORIGIN, yaw: 0.0, pitch: 0.0, scale: 1.0)
+        frame = resolve_frame(frame_index)
+        next_frame = resolve_frame(frame_index + 1)
+
+        GL.PushMatrix
+        GL.Translatef(position.x, position.y, position.z)
+        GL.Rotatef(yaw, 0.0, 0.0, 1.0)
+        GL.Rotatef(pitch, 0.0, 1.0, 0.0)
+
+        GL.Enable(GL::TEXTURE_2D)
+        GL.BindTexture(GL::TEXTURE_2D, @skin_textures[0]) if @skin_textures.any?
+
+        GL.Begin(GL::TRIANGLES)
+        @model.triangles.each do |tri|
+          tri.vertex_indices.each_with_index do |vi, _ti|
+            # Texture coordinates
+            stvert = @model.stverts[vi]
+            s = stvert.s.to_f
+            t = stvert.t.to_f
+
+            # Adjust seam UVs for back-facing triangles
+            if stvert.on_seam != 0 && tri.faces_front == 0
+              s += @model.skin_width * 0.5
+            end
+
+            s = (s + 0.5) / @model.skin_width
+            t = (t + 0.5) / @model.skin_height
+            GL.TexCoord2f(s, t)
+
+            # Decompress vertex position
+            v1 = frame.vertices[vi]
+            x1 = v1.x * @model.scale.x + @model.scale_origin.x
+            y1 = v1.y * @model.scale.y + @model.scale_origin.y
+            z1 = v1.z * @model.scale.z + @model.scale_origin.z
+
+            if lerp > 0.0 && next_frame
+              v2 = next_frame.vertices[vi]
+              x2 = v2.x * @model.scale.x + @model.scale_origin.x
+              y2 = v2.y * @model.scale.y + @model.scale_origin.y
+              z2 = v2.z * @model.scale.z + @model.scale_origin.z
+
+              x = x1 + (x2 - x1) * lerp
+              y = y1 + (y2 - y1) * lerp
+              z = z1 + (z2 - z1) * lerp
+            else
+              x = x1
+              y = y1
+              z = z1
+            end
+
+            GL.Vertex3f(x * scale, y * scale, z * scale)
+          end
+        end
+        GL.End
+
+        GL.PopMatrix
+      end
+
+      def frame_count
+        @model.frames.size
+      end
+
+      private
+
+      def resolve_frame(index)
+        return nil if @model.frames.empty?
+        entry = @model.frames[index % @model.frames.size]
+        case entry
+        when Mdl::Frame then entry
+        when Mdl::FrameGroup then entry.frames[0] # first frame of group
+        end
+      end
+
+      def upload_skins
+        @model.skins.each do |skin_variants|
+          pixels = skin_variants[0] # use first variant
+          next if pixels.nil?
+
+          rgba = @palette.indexed_to_rgba(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,
+                        @model.skin_width, @model.skin_height, 0,
+                        GL::RGBA, GL::UNSIGNED_BYTE, rgba)
+          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)
+
+          @skin_textures << tex_id
+        end
+      end
+    end
+  end
+end

data/lib/quake/renderer/gl_brush_model.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "opengl"
+
+module Quake
+  module Renderer
+    # Renders BSP sub-models (brush entities like doors, buttons, platforms).
+    # 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
+      def initialize(level, texture_manager, lightmap)
+        @level = level
+        @texture_manager = texture_manager
+        @lightmap = lightmap
+
+        # Precompute surfaces for each sub-model (model index 1+)
+        @model_surfaces = {}
+        precompute_all_submodels
+      end
+
+      # Render all brush entities at their current positions.
+      # entities: array of Entity objects that have model_index set
+      def render(entities)
+        GL.Enable(GL::TEXTURE_2D)
+        GL.Color3f(1.0, 1.0, 1.0)
+
+        entities.each do |ent|
+          next unless ent.brush_entity?
+          surfaces = @model_surfaces[ent.model_index]
+          next unless surfaces
+
+          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)
+          end
+
+          render_model_surfaces(surfaces)
+
+          GL.PopMatrix
+        end
+      end
+
+      private
+
+      def precompute_all_submodels
+        @level.models.each_with_index do |model, model_idx|
+          next if model_idx == 0 # skip worldmodel, rendered by GLTextured
+
+          surfaces = []
+          model.num_faces.times do |i|
+            face_index = model.first_face + i
+            face = @level.faces[face_index]
+            next unless face
+
+            texinfo = @level.texinfo[face.texinfo_index]
+            next if texinfo.nil?
+
+            tex = @level.textures[texinfo.miptex_index]
+            next if tex.nil?
+            next if tex.name == "trigger" || tex.name == "clip"
+            next if tex.name.start_with?("sky")
+
+            surf = Bsp::FaceVertices.extract_surface(@level, face)
+            surfaces << {
+              vertices: surf.vertices,
+              texcoords: surf.texcoords,
+              miptex_index: texinfo.miptex_index,
+              face_index: face_index,
+              texinfo_index: face.texinfo_index
+            }
+          end
+
+          @model_surfaces[model_idx] = surfaces unless surfaces.empty?
+        end
+
+        total = @model_surfaces.values.sum(&:size)
+        puts "Precomputed #{total} brush model surfaces across #{@model_surfaces.size} sub-models"
+      end
+
+      def render_model_surfaces(surfaces)
+        # Group by texture for fewer bind calls
+        current_miptex = -1
+
+        if @lightmap
+          render_surfaces_with_lightmaps(surfaces)
+        else
+          surfaces.each do |surf|
+            if surf[:miptex_index] != current_miptex
+              @texture_manager.bind(surf[:miptex_index])
+              current_miptex = surf[:miptex_index]
+            end
+
+            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_surfaces_with_lightmaps(surfaces)
+        # Pass 1: diffuse textures
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
+        current_miptex = -1
+
+        surfaces.each do |surf|
+          if surf[:miptex_index] != current_miptex
+            @texture_manager.bind(surf[:miptex_index])
+            current_miptex = surf[:miptex_index]
+          end
+
+          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
+
+        # Pass 2: lightmap multiply
+        GL.Enable(GL::BLEND)
+        GL.BlendFunc(GL::ZERO, GL::SRC_COLOR)
+        GL.DepthMask(GL::FALSE)
+        GL.DepthFunc(GL::LEQUAL)
+
+        last_lm_tex = -1
+        surfaces.each do |surf|
+          face_idx = surf[:face_index]
+          next unless @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
+
+        GL.DepthMask(GL::TRUE)
+        GL.DepthFunc(GL::LESS)
+        GL.Disable(GL::BLEND)
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
+      end
+    end
+  end
+end