quake-rb 0.1.0 → 0.2.0

data/lib/quake/renderer/gl_lightmap.rb

@@ -11,28 +11,115 @@ module Quake
     class GLLightmap
       LIGHTMAP_BLOCK_WIDTH  = 128
       LIGHTMAP_BLOCK_HEIGHT = 128
-
-      LightmapInfo = Data.define(:gl_texture, :s_offset, :t_offset, :width, :height)
-
-      attr_reader :face_lightmaps # face_index -> LightmapInfo
-
-      def initialize(level, palette)
+      MAX_LIGHTSTYLES = 64
+      DEFAULT_LIGHTSTYLES = {
+        0 => "m",
+        1 => "mmnmmommommnonmmonqnmmo",
+        2 => "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba",
+        3 => "mmmmmaaaaammmmmaaaaaabcdefgabcdefg",
+        4 => "mamamamamama",
+        5 => "jklmnopqrstuvwxyzyxwvutsrqponmlkj",
+        6 => "nmonqnmomnmomomno",
+        7 => "mmmaaaabcdefgmmmmaaaammmaamm",
+        8 => "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa",
+        9 => "aaaaaaaazzzzzzzz",
+        10 => "mmamammmmammamamaaamammma",
+        11 => "abcdefghijklmnopqrrqponmlkjihgfedcba",
+        63 => "a"
+      }.freeze
+
+      LightmapInfo = Data.define(:gl_texture, :block_index, :s_offset, :t_offset, :width, :height)
+
+      attr_reader :face_lightmaps, :lightstyle_values # face_index -> LightmapInfo
+
+      def initialize(level, palette, lightstyles: nil)
         @level = level
         @palette = palette
         @face_lightmaps = {}
         @block_textures = []    # GL texture ids for each block
         @block_allocated = []   # row allocation per block column
         @block_pixels = []      # RGBA pixel data per block
+        @face_lightmap_faces = {}
+        @uploaded = false
+        @lightstyles = self.class.default_lightstyles
+        Array(lightstyles).each_with_index { |map, style| @lightstyles[style] = map if map }
+        animate_lightstyles(0.0)
+      end
+
+      def self.default_lightstyles
+        Array.new(MAX_LIGHTSTYLES) { |style| DEFAULT_LIGHTSTYLES[style] }
+      end
+
+      def self.lightstyle_values_for(time, lightstyles)
+        frame = (time.to_f * 10.0).to_i
+        values = Array.new(MAX_LIGHTSTYLES, 256)
+        MAX_LIGHTSTYLES.times do |style|
+          map = lightstyles[style]
+          next if map.nil? || map.empty?
+
+          values[style] = (map.getbyte(frame % map.length) - "a".ord) * 22
+        end
+        values
+      end
+
+      def lightstyles=(lightstyles)
+        Array(lightstyles).each_with_index { |map, style| @lightstyles[style] = map if style < MAX_LIGHTSTYLES }
+      end
+
+      def set_lightstyle(style, map)
+        return if style.negative? || style >= MAX_LIGHTSTYLES
+
+        @lightstyles[style] = map
+      end
+
+      def animate_lightstyles(time)
+        @lightstyle_values = self.class.lightstyle_values_for(time, @lightstyles)
+        @lightstyle_values
+      end
+
+      def update(time, lightstyles: nil, dynamic_lights: nil)
+        self.lightstyles = lightstyles if lightstyles
+        old_values = @lightstyle_values || Array.new(MAX_LIGHTSTYLES, 256)
+        new_values = animate_lightstyles(time)
+        changed_styles = (0...MAX_LIGHTSTYLES).select { |style| old_values[style] != new_values[style] }
+
+        # R_MarkLights: faces touched by dynamic lights this frame, plus faces
+        # lit last frame (which must be re-baked back to their static light).
+        dlit_faces = mark_dynamic_faces(Array(dynamic_lights))
+        previously_dlit = @dlit_faces || {}
+        @dlit_faces = dlit_faces
+        return false if changed_styles.empty? && dlit_faces.empty? && previously_dlit.empty?
+
+        changed_blocks = {}
+        @face_lightmap_faces.each do |face_index, face|
+          lights = dlit_faces[face_index]
+          needs_rebake = lights ||
+                         previously_dlit.key?(face_index) ||
+                         (!changed_styles.empty? && face_uses_styles?(face, changed_styles))
+          next unless needs_rebake
+
+          info = @face_lightmaps[face_index]
+          next unless info
+
+          write_face_lightmap(face, info, face_index: face_index, dlights: lights)
+          changed_blocks[info.block_index] = true
+        end
+        upload_changed_blocks(changed_blocks.keys) if @uploaded
+        !changed_blocks.empty?
       end
 
       def build_all
+        animate_lightstyles(0.0) unless @lightstyle_values
         allocate_block
 
         @level.faces.each_with_index do |face, face_index|
           texinfo = @level.texinfo[face.texinfo_index]
           next if texinfo.nil?
           next if texinfo.flags & 1 != 0 # TEX_SPECIAL (sky/turb)
-          next if face.light_offset < 0
+          # Faces with no samples (light_offset < 0) still get a lightmap: all
+          # zeros renders them black, matching R_BuildLightMap. Only a missing
+          # lighting lump means fullbright.
+          next if @level.lighting.nil? || @level.lighting.empty?
 
           build_face_lightmap(face, face_index)
         end
@@ -57,15 +144,16 @@ module Quake
         s = vertex.dot(texinfo.s_vec) + texinfo.s_offset
         t = vertex.dot(texinfo.t_vec) + texinfo.t_offset
 
-        # Convert to lightmap UV: subtract texture mins, scale by 1/16, offset by 0.5
-        # Then convert to atlas UV
+        # Convert to lightmap UV: subtract texture mins, scale by 1/16.
+        # The half-luxel centering is applied once, as the +0.5 texel below
+        # (C adds +8 texture units before the /16 -- same thing).
         extents = face_extents(face_index)
         return [0.0, 0.0] unless extents
 
         tex_mins_s, tex_mins_t, _, _ = extents
 
-        ls = (s - tex_mins_s + 8.0) / (info.width * 16.0)
-        lt = (t - tex_mins_t + 8.0) / (info.height * 16.0)
+        ls = (s - tex_mins_s) / (info.width * 16.0)
+        lt = (t - tex_mins_t) / (info.height * 16.0)
 
         # Map into atlas block coordinates
         atlas_s = (info.s_offset + ls * info.width + 0.5) / LIGHTMAP_BLOCK_WIDTH
@@ -168,7 +256,7 @@ module Quake
         extents = calc_extents(face)
         return unless extents
 
-        tex_min_s, tex_min_t, extent_s, extent_t = extents
+        _tex_min_s, _tex_min_t, extent_s, extent_t = extents
         lm_width = (extent_s / 16) + 1
         lm_height = (extent_t / 16) + 1
 
@@ -178,55 +266,141 @@ module Quake
         @extents_cache ||= {}
         @extents_cache[face_index] = extents
 
-        # Read lightmap data from lighting lump
-        lm_size = lm_width * lm_height
+        block_idx, s_off, t_off = find_space(lm_width, lm_height)
+        info = LightmapInfo.new(
+          gl_texture: nil,
+          block_index: block_idx,
+          s_offset: s_off, t_offset: t_off,
+          width: lm_width, height: lm_height
+        )
+
+        @face_lightmaps[face_index] = info
+        @face_lightmap_faces[face_index] = face
+        write_face_lightmap(face, info, face_index: face_index)
+      end
+
+      def write_face_lightmap(face, info, face_index: nil, dlights: nil)
+        lm_size = info.width * info.height
         lighting = @level.lighting
         offset = face.light_offset
-
-        # Accumulate light from all styles
         blocklights = Array.new(lm_size, 0)
 
-        4.times do |style_idx|
-          style = face.styles[style_idx]
-          break if style == 255 # end of styles
-
-          # Scale factor: normal light (style 0) = 264 (Quake default)
-          # Other styles animated, but default to full brightness
-          scale = 256
+        if offset >= 0
+          4.times do |style_idx|
+            style = face.styles[style_idx]
+            break if style == 255 # end of styles
 
-          lm_size.times do |j|
-            byte = lighting.getbyte(offset + j)
-            blocklights[j] += byte * scale if byte
+            scale = @lightstyle_values.fetch(style, 256)
+            lm_size.times do |j|
+              byte = lighting.getbyte(offset + j)
+              blocklights[j] += byte * scale if byte
+            end
+            offset += lm_size
           end
-          offset += lm_size
         end
 
-        # Find space in lightmap atlas
-        block_idx, s_off, t_off = find_space(lm_width, lm_height)
+        add_dynamic_lights(face, face_index, info, blocklights, dlights) if dlights && face_index
 
-        # Write pixels into atlas block
-        pixels = @block_pixels[block_idx]
-        lm_height.times do |row|
-          lm_width.times do |col|
-            src_idx = row * lm_width + col
-            # Shift right 7 (overbright by 2x) to match Quake's gamma
-            val = (blocklights[src_idx] >> 7).clamp(0, 255)
+        pixels = @block_pixels[info.block_index]
+        info.height.times do |row|
+          info.width.times do |col|
+            src_idx = row * info.width + col
+            val = 255 - (blocklights[src_idx] >> 7).clamp(0, 255)
 
-            dst_x = s_off + col
-            dst_y = t_off + row
+            dst_x = info.s_offset + col
+            dst_y = info.t_offset + row
             dst_idx = (dst_y * LIGHTMAP_BLOCK_WIDTH + dst_x) * 4
-            pixels.setbyte(dst_idx, val)
-            pixels.setbyte(dst_idx + 1, val)
-            pixels.setbyte(dst_idx + 2, val)
-            pixels.setbyte(dst_idx + 3, 255)
+            pixels.setbyte(dst_idx + 3, val)
           end
         end
+      end
 
-        @face_lightmaps[face_index] = LightmapInfo.new(
-          gl_texture: block_idx, # Will be replaced with actual GL id after upload
-          s_offset: s_off, t_offset: t_off,
-          width: lm_width, height: lm_height
-        )
+      # R_MarkLights: walk the BSP tree per light, collecting faces on nodes
+      # the light sphere straddles. Returns face_index -> [lights].
+      def mark_dynamic_faces(dlights)
+        return {} if dlights.empty? || @level.nodes.empty? || @level.planes.empty?
+
+        marked = {}
+        dlights.each { |light| mark_light(light, 0, marked) }
+        marked
+      end
+
+      def mark_light(light, node_index, marked)
+        return if node_index.negative? # leaf
+
+        node = @level.nodes[node_index]
+        return unless node
+
+        plane = @level.planes[node.plane_index]
+        return unless plane
+
+        radius = light.radius.to_f
+        dist = light.origin.dot(plane.normal) - plane.dist
+        return mark_light(light, node.children[0], marked) if dist > radius
+        return mark_light(light, node.children[1], marked) if dist < -radius
+
+        node.num_faces.times do |i|
+          face_index = node.first_face + i
+          (marked[face_index] ||= []) << light
+        end
+
+        mark_light(light, node.children[0], marked)
+        mark_light(light, node.children[1], marked)
+      end
+
+      # R_AddDynamicLights: project each light onto the face plane and add
+      # (rad - dist) * 256 per luxel inside the light's falloff.
+      def add_dynamic_lights(face, face_index, info, blocklights, dlights)
+        extents = @extents_cache&.[](face_index)
+        return unless extents
+
+        tex_mins_s, tex_mins_t, = extents
+        texinfo = @level.texinfo[face.texinfo_index]
+        plane = @level.planes[face.plane_index]
+        return unless texinfo && plane
+
+        smax = info.width
+        tmax = info.height
+
+        dlights.each do |light|
+          rad = light.radius.to_f
+          dist = light.origin.dot(plane.normal) - plane.dist
+          rad -= dist.abs
+          minlight = light.minlight.to_f
+          next if rad < minlight
+
+          minlight = rad - minlight
+          impact = light.origin - plane.normal * dist
+          local_s = impact.dot(texinfo.s_vec) + texinfo.s_offset - tex_mins_s
+          local_t = impact.dot(texinfo.t_vec) + texinfo.t_offset - tex_mins_t
+
+          tmax.times do |t|
+            td = (local_t - t * 16).abs
+            smax.times do |s|
+              sd = (local_s - s * 16).abs
+              d = sd > td ? sd + td / 2 : td + sd / 2
+              blocklights[t * smax + s] += ((rad - d) * 256).to_i if d < minlight
+            end
+          end
+        end
+      end
+
+      def face_uses_styles?(face, changed_styles)
+        face.styles.any? { |style| style != 255 && changed_styles.include?(style) }
+      end
+
+      def upload_changed_blocks(block_indices)
+        block_indices.each do |block_index|
+          info = @face_lightmaps.values.find { |face_info| face_info.block_index == block_index }
+          next unless info&.gl_texture
+
+          GL.BindTexture(GL::TEXTURE_2D, info.gl_texture)
+          GL.TexSubImage2D(
+            GL::TEXTURE_2D, 0, 0, 0,
+            LIGHTMAP_BLOCK_WIDTH, LIGHTMAP_BLOCK_HEIGHT,
+            GL::RGBA, GL::UNSIGNED_BYTE, @block_pixels[block_index]
+          )
+        end
       end
 
       def upload_blocks
@@ -250,11 +424,13 @@ module Quake
         # Update face lightmap infos with actual GL texture ids
         @face_lightmaps.each do |face_index, info|
           @face_lightmaps[face_index] = LightmapInfo.new(
-            gl_texture: gl_ids[info.gl_texture],
+            gl_texture: gl_ids[info.block_index],
+            block_index: info.block_index,
             s_offset: info.s_offset, t_offset: info.t_offset,
             width: info.width, height: info.height
           )
         end
+        @uploaded = true
       end
     end
   end