doom 0.8.0 → 0.11.0

data/lib/doom/render/ray_tracing/material_state.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    module RayTracing
+      # Resolves animated WAD materials and packs per-surface flags into the
+      # float shared with sector light level in the GPU triangle texture.
+      class MaterialState
+        EMISSIVE_FLAG = 1_024.0
+        MASKED_FLAG = 2_048.0
+        REFLECTIVE_FLAG = 4_096.0
+        REFRACTIVE_FLAG = 8_192.0
+        EMISSIVE_PATTERN = /\A(?:NUKAGE|SLIME|LAVA)/
+        LIQUID_PATTERN = /\A(?:NUKAGE|SLIME|LAVA|FWATER|SWATER|BLOOD)/
+        REFLECTIVE_PATTERN = /#{LIQUID_PATTERN.source}|(?:METAL|SILVER|COMP|TEK|SUPPORT)/
+        REFRACTIVE_PATTERN = LIQUID_PATTERN
+
+        def initialize(flats, animations)
+          @flats = flats
+          @animations = animations
+        end
+
+        def animation_signature
+          return nil unless @animations
+
+          [@animations.flat_translation.values, @animations.texture_translation.values]
+        end
+
+        def animation_names
+          return [] unless @animations
+          return @animations.frame_names if @animations.respond_to?(:frame_names)
+
+          [@animations.flat_translation, @animations.texture_translation]
+            .flat_map { |translation| translation.keys + translation.values }
+        end
+
+        def resolve(name)
+          return name unless @animations
+
+          @flats.key?(name) ? @animations.translate_flat(name) : @animations.translate_texture(name)
+        end
+
+        def emissive?(name)
+          name&.match?(EMISSIVE_PATTERN) || false
+        end
+
+        def reflective?(name)
+          name&.match?(REFLECTIVE_PATTERN) || false
+        end
+
+        def refractive?(name)
+          name&.match?(REFRACTIVE_PATTERN) || false
+        end
+
+        def encoded_light(triangle)
+          value = triangle.light.to_f
+          value += EMISSIVE_FLAG if emissive?(triangle.material)
+          value += MASKED_FLAG if triangle.masked
+          value += REFLECTIVE_FLAG if reflective?(triangle.material)
+          value += REFRACTIVE_FLAG if refractive?(triangle.material)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/doom/render/ray_tracing/texture_atlas.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    module RayTracing
+      # Packs palette-indexed flats and composite wall textures into one RGBA
+      # texture. Rectangle entries are [x, y, width, height, texel_w, texel_h].
+      class TextureAtlas
+        attr_reader :size
+
+        def initialize(size:, textures:, flats:, palette:)
+          @size = size
+          @textures = textures
+          @flats = flats
+          @palette = palette
+        end
+
+        def build(material_names)
+          pixels = "\0" * (@size * @size * 4)
+          rectangles = {}
+          x = y = row_height = 0
+          material_names.uniq.each do |name|
+            source = source_for(name)
+            next unless source
+
+            width, height, rgba = source
+            if x + width > @size
+              x = 0
+              y += row_height
+              row_height = 0
+            end
+            raise ArgumentError, 'ray texture atlas overflow' if y + height > @size
+
+            height.times do |row|
+              destination = (((y + row) * @size) + x) * 4
+              pixels[destination, width * 4] = rgba.byteslice(row * width * 4, width * 4)
+            end
+            rectangles[name] = [x.to_f / @size, y.to_f / @size,
+                                width.to_f / @size, height.to_f / @size,
+                                width.to_f, height.to_f]
+            x += width
+            row_height = [row_height, height].max
+          end
+          [pixels, rectangles]
+        end
+
+        private
+
+        def source_for(name)
+          source = @flats[name] || @textures[name]
+          return unless source
+
+          width = source.width
+          height = source.height
+          indices = if source.respond_to?(:column_pixels)
+                      columns_to_rows(source, width, height)
+                    else
+                      source.pixels
+                    end
+          rgba = indices.map do |index|
+            index.nil? ? "\0\0\0\0" : [*@palette.colors[index], 255].pack('C4')
+          end.join
+          [width, height, rgba]
+        end
+
+        def columns_to_rows(source, width, height)
+          pixels = Array.new(width * height)
+          width.times do |column|
+            source.column_pixels(column).each_with_index do |value, row|
+              pixels[(row * width) + column] = value if row < height
+            end
+          end
+          pixels
+        end
+      end
+    end
+  end
+end