quake-rb 0.1.0 → 0.2.0

data/lib/quake/renderer/gl_alias_model.rb

@@ -2,80 +2,378 @@
 
 require "opengl"
 
+require_relative "anorm_dots"
+
 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
+      SHADEDOT_QUANT = 16
+      TOP_RANGE = 16
+      BOTTOM_RANGE = 96
+      ANORMS = [
+        [-0.525731, 0.000000, 0.850651],
+        [-0.442863, 0.238856, 0.864188],
+        [-0.295242, 0.000000, 0.955423],
+        [-0.309017, 0.500000, 0.809017],
+        [-0.162460, 0.262866, 0.951056],
+        [0.000000, 0.000000, 1.000000],
+        [0.000000, 0.850651, 0.525731],
+        [-0.147621, 0.716567, 0.681718],
+        [0.147621, 0.716567, 0.681718],
+        [0.000000, 0.525731, 0.850651],
+        [0.309017, 0.500000, 0.809017],
+        [0.525731, 0.000000, 0.850651],
+        [0.295242, 0.000000, 0.955423],
+        [0.442863, 0.238856, 0.864188],
+        [0.162460, 0.262866, 0.951056],
+        [-0.681718, 0.147621, 0.716567],
+        [-0.809017, 0.309017, 0.500000],
+        [-0.587785, 0.425325, 0.688191],
+        [-0.850651, 0.525731, 0.000000],
+        [-0.864188, 0.442863, 0.238856],
+        [-0.716567, 0.681718, 0.147621],
+        [-0.688191, 0.587785, 0.425325],
+        [-0.500000, 0.809017, 0.309017],
+        [-0.238856, 0.864188, 0.442863],
+        [-0.425325, 0.688191, 0.587785],
+        [-0.716567, 0.681718, -0.147621],
+        [-0.500000, 0.809017, -0.309017],
+        [-0.525731, 0.850651, 0.000000],
+        [0.000000, 0.850651, -0.525731],
+        [-0.238856, 0.864188, -0.442863],
+        [0.000000, 0.955423, -0.295242],
+        [-0.262866, 0.951056, -0.162460],
+        [0.000000, 1.000000, 0.000000],
+        [0.000000, 0.955423, 0.295242],
+        [-0.262866, 0.951056, 0.162460],
+        [0.238856, 0.864188, 0.442863],
+        [0.262866, 0.951056, 0.162460],
+        [0.500000, 0.809017, 0.309017],
+        [0.238856, 0.864188, -0.442863],
+        [0.262866, 0.951056, -0.162460],
+        [0.500000, 0.809017, -0.309017],
+        [0.850651, 0.525731, 0.000000],
+        [0.716567, 0.681718, 0.147621],
+        [0.716567, 0.681718, -0.147621],
+        [0.525731, 0.850651, 0.000000],
+        [0.425325, 0.688191, 0.587785],
+        [0.864188, 0.442863, 0.238856],
+        [0.688191, 0.587785, 0.425325],
+        [0.809017, 0.309017, 0.500000],
+        [0.681718, 0.147621, 0.716567],
+        [0.587785, 0.425325, 0.688191],
+        [0.955423, 0.295242, 0.000000],
+        [1.000000, 0.000000, 0.000000],
+        [0.951056, 0.162460, 0.262866],
+        [0.850651, -0.525731, 0.000000],
+        [0.955423, -0.295242, 0.000000],
+        [0.864188, -0.442863, 0.238856],
+        [0.951056, -0.162460, 0.262866],
+        [0.809017, -0.309017, 0.500000],
+        [0.681718, -0.147621, 0.716567],
+        [0.850651, 0.000000, 0.525731],
+        [0.864188, 0.442863, -0.238856],
+        [0.809017, 0.309017, -0.500000],
+        [0.951056, 0.162460, -0.262866],
+        [0.525731, 0.000000, -0.850651],
+        [0.681718, 0.147621, -0.716567],
+        [0.681718, -0.147621, -0.716567],
+        [0.850651, 0.000000, -0.525731],
+        [0.809017, -0.309017, -0.500000],
+        [0.864188, -0.442863, -0.238856],
+        [0.951056, -0.162460, -0.262866],
+        [0.147621, 0.716567, -0.681718],
+        [0.309017, 0.500000, -0.809017],
+        [0.425325, 0.688191, -0.587785],
+        [0.442863, 0.238856, -0.864188],
+        [0.587785, 0.425325, -0.688191],
+        [0.688191, 0.587785, -0.425325],
+        [-0.147621, 0.716567, -0.681718],
+        [-0.309017, 0.500000, -0.809017],
+        [0.000000, 0.525731, -0.850651],
+        [-0.525731, 0.000000, -0.850651],
+        [-0.442863, 0.238856, -0.864188],
+        [-0.295242, 0.000000, -0.955423],
+        [-0.162460, 0.262866, -0.951056],
+        [0.000000, 0.000000, -1.000000],
+        [0.295242, 0.000000, -0.955423],
+        [0.162460, 0.262866, -0.951056],
+        [-0.442863, -0.238856, -0.864188],
+        [-0.309017, -0.500000, -0.809017],
+        [-0.162460, -0.262866, -0.951056],
+        [0.000000, -0.850651, -0.525731],
+        [-0.147621, -0.716567, -0.681718],
+        [0.147621, -0.716567, -0.681718],
+        [0.000000, -0.525731, -0.850651],
+        [0.309017, -0.500000, -0.809017],
+        [0.442863, -0.238856, -0.864188],
+        [0.162460, -0.262866, -0.951056],
+        [0.238856, -0.864188, -0.442863],
+        [0.500000, -0.809017, -0.309017],
+        [0.425325, -0.688191, -0.587785],
+        [0.716567, -0.681718, -0.147621],
+        [0.688191, -0.587785, -0.425325],
+        [0.587785, -0.425325, -0.688191],
+        [0.000000, -0.955423, -0.295242],
+        [0.000000, -1.000000, 0.000000],
+        [0.262866, -0.951056, -0.162460],
+        [0.000000, -0.850651, 0.525731],
+        [0.000000, -0.955423, 0.295242],
+        [0.238856, -0.864188, 0.442863],
+        [0.262866, -0.951056, 0.162460],
+        [0.500000, -0.809017, 0.309017],
+        [0.716567, -0.681718, 0.147621],
+        [0.525731, -0.850651, 0.000000],
+        [-0.238856, -0.864188, -0.442863],
+        [-0.500000, -0.809017, -0.309017],
+        [-0.262866, -0.951056, -0.162460],
+        [-0.850651, -0.525731, 0.000000],
+        [-0.716567, -0.681718, -0.147621],
+        [-0.716567, -0.681718, 0.147621],
+        [-0.525731, -0.850651, 0.000000],
+        [-0.500000, -0.809017, 0.309017],
+        [-0.238856, -0.864188, 0.442863],
+        [-0.262866, -0.951056, 0.162460],
+        [-0.864188, -0.442863, 0.238856],
+        [-0.809017, -0.309017, 0.500000],
+        [-0.688191, -0.587785, 0.425325],
+        [-0.681718, -0.147621, 0.716567],
+        [-0.442863, -0.238856, 0.864188],
+        [-0.587785, -0.425325, 0.688191],
+        [-0.309017, -0.500000, 0.809017],
+        [-0.147621, -0.716567, 0.681718],
+        [-0.425325, -0.688191, 0.587785],
+        [-0.162460, -0.262866, 0.951056],
+        [0.442863, -0.238856, 0.864188],
+        [0.162460, -0.262866, 0.951056],
+        [0.309017, -0.500000, 0.809017],
+        [0.147621, -0.716567, 0.681718],
+        [0.000000, -0.525731, 0.850651],
+        [0.425325, -0.688191, 0.587785],
+        [0.587785, -0.425325, 0.688191],
+        [0.688191, -0.587785, 0.425325],
+        [-0.955423, 0.295242, 0.000000],
+        [-0.951056, 0.162460, 0.262866],
+        [-1.000000, 0.000000, 0.000000],
+        [-0.850651, 0.000000, 0.525731],
+        [-0.955423, -0.295242, 0.000000],
+        [-0.951056, -0.162460, 0.262866],
+        [-0.864188, 0.442863, -0.238856],
+        [-0.951056, 0.162460, -0.262866],
+        [-0.809017, 0.309017, -0.500000],
+        [-0.864188, -0.442863, -0.238856],
+        [-0.951056, -0.162460, -0.262866],
+        [-0.809017, -0.309017, -0.500000],
+        [-0.681718, 0.147621, -0.716567],
+        [-0.681718, -0.147621, -0.716567],
+        [-0.850651, 0.000000, -0.525731],
+        [-0.688191, 0.587785, -0.425325],
+        [-0.587785, 0.425325, -0.688191],
+        [-0.425325, 0.688191, -0.587785],
+        [-0.425325, -0.688191, -0.587785],
+        [-0.587785, -0.425325, -0.688191],
+        [-0.688191, -0.587785, -0.425325]
+      ].freeze
+
+      ST_RAND = 1 # sync_type: entities get a random animation phase
 
-      def initialize(model, palette)
+      def initialize(model, palette, model_name: nil)
         @model = model
         @palette = palette
+        @model_name = model_name
         @skin_textures = []
+        @translated_skin_textures = {}
         upload_skins
       end
 
+      def random_sync?
+        @model.sync_type == ST_RAND
+      end
+
+      def self.alias_texcoord(stvert, triangle, skin_width:, skin_height:)
+        s = stvert.s.to_f
+        t = stvert.t.to_f
+
+        s += skin_width * 0.5 if stvert.on_seam != 0 && triangle.faces_front == 0
+
+        [(s + 0.5) / skin_width, (t + 0.5) / skin_height]
+      end
+
+      def self.resolve_frame_entry(entry, time: 0.0)
+        case entry
+        when Mdl::Frame
+          entry
+        when Mdl::FrameGroup
+          entry.frames[find_interval_index(entry.intervals, time)]
+        end
+      end
+
+      # Mod_FindInterval: intervals are cumulative timestamps, so groups may
+      # hold poses for different durations.
+      def self.find_interval_index(intervals, time)
+        return 0 if intervals.nil? || intervals.empty?
+
+        full = intervals.last.to_f
+        return 0 if full <= 0.0
+
+        target = time.to_f % full
+        intervals.each_with_index do |value, i|
+          return i if value.to_f > target
+        end
+        intervals.size - 1
+      end
+
+      def self.resolve_frame_index(num_frames, frame_index)
+        index = frame_index.to_i
+        return 0 if index.negative? || index >= num_frames
+
+        index
+      end
+
+      def self.resolve_skin_variant_index(variant_count, time: 0.0, intervals: nil)
+        return 0 if variant_count <= 1
+
+        if intervals && !intervals.empty?
+          find_interval_index(intervals, time).clamp(0, variant_count - 1)
+        else
+          ((time.to_f * 10.0).to_i & 3) % variant_count
+        end
+      end
+
+      def self.resolve_skin_index(num_skins, skin_index)
+        index = skin_index.to_i
+        return 0 if index.negative? || index >= num_skins
+
+        index
+      end
+
+      def self.translate_player_skin(pixels, colors:)
+        top = colors.to_i & 0xf0
+        bottom = (colors.to_i & 15) << 4
+        translate = (0..255).to_a
+
+        16.times do |i|
+          translate[TOP_RANGE + i] = top < 128 ? top + i : top + 15 - i
+          translate[BOTTOM_RANGE + i] = bottom < 128 ? bottom + i : bottom + 15 - i
+        end
+
+        pixels.each_byte.map { |idx| translate[idx] }.pack("C*")
+      end
+
+      def self.apply_alias_transform(position:, yaw:, pitch:, roll: 0.0)
+        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.Rotatef(roll, 1.0, 0.0, 0.0)
+      end
+
+      def self.quake_alias_lighting(ambient_light:, shade_light:, model_name: nil, view_model: false, client_index: nil)
+        ambient = ambient_light.to_f
+        shade = shade_light.to_f
+
+        ambient = shade = 24.0 if view_model && ambient < 24.0
+
+        ambient = 128.0 if ambient > 128.0
+        shade = 192.0 - ambient if ambient + shade > 192.0
+
+        if client_index && client_index.between?(1, 32) && ambient < 8.0
+          ambient = shade = 8.0
+        end
+
+        if %w[progs/flame2.mdl progs/flame.mdl].include?(model_name)
+          ambient = shade = 256.0
+        end
+
+        [ambient, shade / 200.0]
+      end
+
+      def self.alias_shade_color(vertex, shade_scale:, shadedot: 1.0)
+        light = shadedot.to_f * shade_scale.to_f
+        [light, light, light]
+      end
+
+      def self.alias_shadedot(yaw:, normal_index:)
+        quantized = ((yaw.to_f * (SHADEDOT_QUANT / 360.0)).to_i) & (SHADEDOT_QUANT - 1)
+        ANORM_DOTS[quantized].fetch(normal_index.to_i, 1.0)
+      end
+
+      def self.alias_vertex_position(model, vertex, model_name: nil)
+        if model_name == "progs/eyes.mdl"
+          return [
+            vertex.x * model.scale.x * 2.0 + model.scale_origin.x,
+            vertex.y * model.scale.y * 2.0 + model.scale_origin.y,
+            vertex.z * model.scale.z * 2.0 + model.scale_origin.z - 30.0
+          ]
+        end
+
+        [
+          vertex.x * model.scale.x + model.scale_origin.x,
+          vertex.y * model.scale.y + model.scale_origin.y,
+          vertex.z * model.scale.z + model.scale_origin.z
+        ]
+      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)
+      def render(frame_index:, lerp: 0.0, position: Math::Vec3::ORIGIN, yaw: 0.0, pitch: 0.0,
+                 roll: 0.0, scale: 1.0, skin_index: 0, time: 0.0, ambient_light: 200.0,
+                 shade_light: 200.0, view_model: false, client_index: nil, player_colors: nil)
+        frame = resolve_frame(frame_index, time: time)
+        next_frame = resolve_frame(frame_index + 1, time: time)
+        _ambient, shade_scale = self.class.quake_alias_lighting(
+          ambient_light: ambient_light,
+          shade_light: shade_light,
+          model_name: @model_name,
+          view_model: view_model,
+          client_index: client_index
+        )
 
         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)
+        self.class.apply_alias_transform(position: position, yaw: yaw, pitch: pitch, roll: roll)
 
         GL.Enable(GL::TEXTURE_2D)
-        GL.BindTexture(GL::TEXTURE_2D, @skin_textures[0]) if @skin_textures.any?
+        resolved_skin_index = self.class.resolve_skin_index(@skin_textures.size, skin_index)
+        skin_textures = @skin_textures[resolved_skin_index]
+        variant = self.class.resolve_skin_variant_index(
+          skin_textures.size, time: time, intervals: @model.skin_intervals[resolved_skin_index]
+        )
+        skin_texture = if player_colors
+                         translated_player_skin_texture(resolved_skin_index, variant, player_colors)
+                       else
+                         skin_textures&.fetch(variant, skin_textures&.first)
+                       end
+        GL.BindTexture(GL::TEXTURE_2D, skin_texture) if skin_texture
+        GL.ShadeModel(GL::SMOOTH)
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
+
+        quantized = ((yaw.to_f * (SHADEDOT_QUANT / 360.0)).to_i) & (SHADEDOT_QUANT - 1)
+        dots = ANORM_DOTS[quantized]
+        mesh = pose_mesh(frame)
+        next_mesh = pose_mesh(next_frame) if lerp > 0.0 && next_frame
 
         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)
+        i = 0
+        size = mesh.size
+        while i < size
+          GL.TexCoord2f(mesh[i], mesh[i + 1])
+          light = dots[mesh[i + 2]] * shade_scale
+          GL.Color3f(light, light, light)
+          if next_mesh
+            GL.Vertex3f((mesh[i + 3] + (next_mesh[i + 3] - mesh[i + 3]) * lerp) * scale,
+                        (mesh[i + 4] + (next_mesh[i + 4] - mesh[i + 4]) * lerp) * scale,
+                        (mesh[i + 5] + (next_mesh[i + 5] - mesh[i + 5]) * lerp) * scale)
+          else
+            GL.Vertex3f(mesh[i + 3] * scale, mesh[i + 4] * scale, mesh[i + 5] * scale)
           end
+          i += 6
         end
         GL.End
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
+        GL.ShadeModel(GL::FLAT)
 
         GL.PopMatrix
       end
@@ -84,39 +382,90 @@ module Quake
         @model.frames.size
       end
 
+      # Flat per-pose mesh [s, t, normal_index, x, y, z] per emitted vertex,
+      # precomputed once: texcoords and scale/scale_origin baking don't
+      # change between frames.
+      def pose_mesh(frame)
+        @pose_meshes ||= {}
+        @pose_meshes[frame.object_id] ||= build_pose_mesh(frame)
+      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
+      def build_pose_mesh(frame)
+        mesh = []
+        @model.triangles.each do |tri|
+          # Original MDL winding, like BuildTris' strip emission -- the
+          # visible side is GL-back-facing under Quake's axis flip, same
+          # as world polys, so glCullFace(GL_FRONT) keeps the outside.
+          tri.vertex_indices.each do |vi|
+            stvert = @model.stverts[vi]
+            s, t = self.class.alias_texcoord(
+              stvert, tri, skin_width: @model.skin_width, skin_height: @model.skin_height
+            )
+            vertex = frame.vertices[vi]
+            x, y, z = self.class.alias_vertex_position(@model, vertex, model_name: @model_name)
+            mesh << s << t << vertex.normal_index << x << y << z
+          end
         end
+        mesh
+      end
+
+      def resolve_frame(index, time: 0.0)
+        return nil if @model.frames.empty?
+        entry = @model.frames[self.class.resolve_frame_index(@model.frames.size, index)]
+        self.class.resolve_frame_entry(entry, time: time)
       end
 
       def upload_skins
         @model.skins.each do |skin_variants|
-          pixels = skin_variants[0] # use first variant
-          next if pixels.nil?
+          textures = skin_variants.filter_map do |pixels|
+            next if pixels.nil?
 
-          rgba = @palette.indexed_to_rgba(pixels)
+            rgba = @palette.indexed_to_rgba(pixels, transparent_index: nil)
 
-          buf = "\0" * 4
-          GL.GenTextures(1, buf)
-          tex_id = buf.unpack1("V")
+            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)
+            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_NEAREST)
+            GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+            GL.GenerateMipmap(GL::TEXTURE_2D)
 
-          @skin_textures << tex_id
+            tex_id
+          end
+
+          @skin_textures << textures
         end
       end
+
+      def translated_player_skin_texture(skin_index, variant, colors)
+        key = [skin_index, variant, colors.to_i]
+        return @translated_skin_textures[key] if @translated_skin_textures.key?(key)
+
+        pixels = @model.skins.dig(skin_index, variant) || @model.skins.dig(skin_index, 0)
+        return nil unless pixels
+
+        translated = self.class.translate_player_skin(pixels, colors: colors)
+        rgba = @palette.indexed_to_rgba(translated, transparent_index: nil)
+
+        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)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+
+        @translated_skin_textures[key] = tex_id
+      end
     end
   end
 end