doom 0.8.0 → 0.11.0

data/lib/doom/render/spinel_native_renderer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "spinel_native/kernel"
+
+module Doom
+  module Render
+    # Runs the classic software renderer's hot path (BSP -> textured walls ->
+    # floors/ceilings -> sky) through spinel_native. The pixel-producing code
+    # lives in Doom::Render::SpinelNative::Kernel as native methods that mirror
+    # lib/doom/render/renderer.rb one-to-one; this class only flattens the map,
+    # textures and flats into the plain Integer/Float arrays the kernel boundary
+    # accepts, then calls it once per frame and hands back the framebuffer.
+    #
+    # The same kernel methods run as plain Ruby when SPINEL_NATIVE=off, so the
+    # port can be verified against the reference renderer before compiling.
+    class SpinelNativeRenderer
+      SCREEN_WIDTH = 320
+      SCREEN_HEIGHT = 240
+      EYE_HEIGHT = 41
+
+      attr_reader :palette
+
+      def initialize(map, palette, colormap, textures, flats)
+        @map = map
+        @palette = palette
+        flatten_all(map, colormap, textures, flats)
+        upload
+      end
+
+      # Upload the flattened map/textures into the kernel's state once.
+      def upload
+        SpinelNative::Kernel.load_map(
+          @nodes_f, @verts, @segs, @subs, @lines, @sides, @secs,
+          @wpx, @wtab, @fpx, @cmap, @node_count, @sky_tex
+        )
+      end
+
+      # Render one frame from the given eye pose. Returns a 76800-int framebuffer
+      # of palette indices (row-major, 320x240).
+      def render(px, py, angle_rad)
+        pz = floor_height_at(px, py) + EYE_HEIGHT
+        SpinelNative::Kernel.render(px.round, py.round, pz, angle_rad)
+      end
+
+      # Render with an explicit eye height (the game supplies player_z), for
+      # integration into the real Renderer.
+      def render_at(px, py, pz, angle_rad)
+        SpinelNative::Kernel.render(px.round, py.round, pz.round, angle_rad)
+      end
+
+      # Wall-pass outputs from the last render, for the Ruby sprite pass.
+      def ceiling_clip = SpinelNative::Kernel.get_cclip
+      def floor_clip = SpinelNative::Kernel.get_fclip
+      def wall_depth = SpinelNative::Kernel.get_wdepth
+
+      # Eye height follows the floor under the player (classic pz = floorz + 41).
+      def floor_height_at(x, y)
+        ni = @node_count - 1
+        while (ni & 0x8000).zero?
+          b = ni * 6
+          side = (x.to_f - @nodes_f[b]) * @nodes_f[b + 3] >= (y.to_f - @nodes_f[b + 1]) * @nodes_f[b + 2] ? 0 : 1
+          ni = (side.zero? ? @nodes_f[b + 4] : @nodes_f[b + 5]).to_i
+        end
+        first = @subs[(ni & 0x7FFF) * 2]
+        sdi = @lines[@segs[first * 5 + 2] * 3 + (@segs[first * 5 + 3].zero? ? 0 : 1)]
+        @secs[@sides[sdi * 6] * 6]
+      end
+
+      private
+
+      def flatten_all(map, colormap, textures, flats)
+        # --- wall textures (composited, column-major) + name->index ------------
+        @wall_index = {}
+        @wall_names = []
+        map.sidedefs.each do |sd|
+          add_wall(sd.upper_texture); add_wall(sd.lower_texture); add_wall(sd.middle_texture)
+        end
+        @sky_tex = add_wall("SKY1")
+
+        @wpx = []
+        @wtab = []
+        @wall_names.each do |name|
+          comp = textures[name]
+          if comp.nil?
+            @wtab.push(@wpx.length, 1, 1); @wpx.push(-1); next
+          end
+          @wtab.push(@wpx.length, comp.width, comp.height)
+          tx = 0
+          while tx < comp.width
+            col = comp.column_pixels(tx)
+            ty = 0
+            while ty < comp.height
+              c = col[ty]
+              @wpx.push(c.nil? ? -1 : c) # -1 = transparent texel (skipped)
+              ty += 1
+            end
+            tx += 1
+          end
+        end
+
+        # --- flats (64x64 row-major) + name->index ----------------------------
+        @flat_index = {}
+        @fpx = []
+        idx = 0
+        flats.each do |fl|
+          @flat_index[fl.name] = idx
+          @fpx.concat(fl.pixels)
+          idx += 1
+        end
+
+        # --- colormap (flat 34*256) ------------------------------------------
+        @cmap = colormap.respond_to?(:maps) ? flatten_colormap(colormap.maps) : colormap
+
+        # --- geometry ---------------------------------------------------------
+        @nodes_f = []
+        map.nodes.each { |n| @nodes_f.push(n.x.to_f, n.y.to_f, n.dx.to_f, n.dy.to_f, n.child_right.to_f, n.child_left.to_f) }
+        @verts = []
+        map.vertices.each { |v| @verts.push(v.x, v.y) }
+        @segs = []
+        map.segs.each { |s| @segs.push(s.v1, s.v2, s.linedef, s.direction, s.offset) }
+        @subs = []
+        map.subsectors.each { |s| @subs.push(s.first_seg, s.seg_count) }
+        @lines = []
+        map.linedefs.each { |l| @lines.push(l.sidedef_right, l.sidedef_left, l.flags) }
+        @sides = []
+        map.sidedefs.each do |sd|
+          @sides.push(sd.sector, wall_idx(sd.upper_texture), wall_idx(sd.lower_texture),
+                      wall_idx(sd.middle_texture), sd.x_offset, sd.y_offset)
+        end
+        @secs = []
+        map.sectors.each do |s|
+          @secs.push(s.floor_height, s.ceiling_height, s.light_level,
+                     flat_idx(s.floor_texture), flat_idx(s.ceiling_texture),
+                     s.ceiling_texture == "F_SKY1" ? 1 : 0,
+                     s.floor_texture == "F_SKY1" ? 1 : 0)
+        end
+        @node_count = map.nodes.length
+      end
+
+      def flatten_colormap(maps)
+        return maps if maps.first.is_a?(Integer) # already flat
+
+        maps.flatten
+      end
+
+      def add_wall(name)
+        return -1 if name.nil? || name.empty? || name == "-"
+
+        key = name.upcase
+        @wall_index[key] ||= begin
+          @wall_names << key
+          @wall_names.length - 1
+        end
+      end
+      alias wall_idx add_wall
+
+      def flat_idx(name)
+        @flat_index[name] || @flat_index[name.to_s.upcase] || 0
+      end
+    end
+  end
+end

data/lib/doom/render/status_bar.rb

@@ -28,11 +28,14 @@ module Doom
       # Small ammo counts (right side of status bar)
       SMALL_AMMO_X = 288     # Current ammo X
       SMALL_MAX_X = 314      # Max ammo X
-      SMALL_AMMO_Y = [5, 11, 23, 17]  # Bullets, Shells, Cells, Rockets (relative to bar)
+      SMALL_AMMO_Y = [5, 11, 23, 17] # Bullets, Shells, Cells, Rockets (relative to bar)
 
       NUM_WIDTH = 14          # Width of large digit
       SMALL_NUM_WIDTH = 4     # Width of small digit
 
+      attr_reader :gfx
+      attr_writer :player # Re-pointed on world rebind (map change, netgame resync)
+
       def initialize(hud_graphics, player_state)
         @gfx = hud_graphics
         @player = player_state
@@ -77,10 +80,10 @@ module Doom
       def update
         # Cycle face animation
         @face_timer += 1
-        if @face_timer > 15  # Change face every ~0.5 seconds
-          @face_timer = 0
-          @face_index = (@face_index + 1) % 3
-        end
+        return unless @face_timer > 15 # Change face every ~0.5 seconds
+
+        @face_timer = 0
+        @face_index = (@face_index + 1) % 3
       end
 
       private
@@ -101,7 +104,7 @@ module Doom
             draw_y = y + sy
             next if draw_y < 0 || draw_y >= SCREEN_HEIGHT
 
-            framebuffer[draw_y * SCREEN_WIDTH + draw_x] = color
+            framebuffer[(draw_y * SCREEN_WIDTH) + draw_x] = color
           end
         end
       end
@@ -137,13 +140,13 @@ module Doom
       def draw_arms(framebuffer)
         # Weapon numbers 2-7 in a 3x2 grid
         6.times do |i|
-          weapon_num = i + 2  # weapons 2-7
+          weapon_num = i + 2 # weapons 2-7
           owned = @player.has_weapons[weapon_num]
           digit = owned ? @gfx.yellow_numbers[weapon_num] : @gfx.grey_numbers[weapon_num]
           next unless digit
 
-          x = ARMS_X + (i % 3) * ARMS_XSPACE
-          y = STATUS_BAR_Y + ARMS_Y + (i / 3) * ARMS_YSPACE
+          x = ARMS_X + ((i % 3) * ARMS_XSPACE)
+          y = STATUS_BAR_Y + ARMS_Y + ((i / 3) * ARMS_YSPACE)
           draw_sprite(framebuffer, digit, x, y)
         end
       end
@@ -161,6 +164,7 @@ module Doom
                end
 
         return unless face
+
         draw_sprite(framebuffer, face, FACE_X, STATUS_BAR_Y + FACE_Y)
       end
 
@@ -177,6 +181,7 @@ module Doom
 
       def draw_small_number_right(framebuffer, value, right_x, y)
         return unless value
+
         str = value.to_i.to_s
         current_x = right_x
         str.reverse.each_char do |char|
@@ -190,7 +195,6 @@ module Doom
 
       def draw_keys(framebuffer)
         key_x = KEYS_X
-        key_spacing = 10
 
         # Blue keys (top row)
         if @player.keys[:blue_card]

data/lib/doom/render/weapon_renderer.rb

@@ -7,12 +7,11 @@ module Doom
       # Weapon is rendered above the status bar
       WEAPON_AREA_HEIGHT = SCREEN_HEIGHT - StatusBar::STATUS_BAR_HEIGHT
 
-      # Chocolate Doom R_DrawPSprite weapon positioning:
-      # centery = viewheight/2 (view area excluding status bar)
-      # texturemid = centery - (WEAPONTOP - spritetopoffset)
-      # dc_yl = centery - texturemid (first visible row)
+      # Chocolate Doom R_DrawPSprite weapon top: dc_yl = WEAPONTOP - spritetopoffset
       WEAPONTOP = 32
-      VIEW_CENTERY = (SCREEN_HEIGHT - StatusBar::STATUS_BAR_HEIGHT) / 2  # 104
+
+      attr_reader :gfx
+      attr_writer :player # Re-pointed on world rebind (map change, netgame resync)
 
       def initialize(hud_graphics, player_state)
         @gfx = hud_graphics
@@ -47,9 +46,9 @@ module Doom
         draw_weapon_sprite(framebuffer, sprite, x, y)
 
         # Draw muzzle flash only on the first fire frame (the actual shot)
-        if @player.attacking && @player.attack_frame == 0
-          draw_muzzle_flash(framebuffer, weapon_name)
-        end
+        return unless @player.attacking && @player.attack_frame == 0
+
+        draw_muzzle_flash(framebuffer, weapon_name)
       end
 
       private
@@ -68,12 +67,12 @@ module Doom
           next if draw_x < 0 || draw_x >= SCREEN_WIDTH
 
           column.each_with_index do |color, sy|
-            next unless color  # Skip transparent pixels
+            next unless color # Skip transparent pixels
 
             draw_y = base_y + sy
             next if draw_y < 0 || draw_y > max_y
 
-            framebuffer[draw_y * SCREEN_WIDTH + draw_x] = color
+            framebuffer[(draw_y * SCREEN_WIDTH) + draw_x] = color
           end
         end
       end

data/lib/doom/render/world_mesh.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # Converts Doom's sector/subsector representation into ordinary triangles.
+    # Subsector polygons are convex by construction, so a fan is sufficient.
+    class WorldMesh
+      Triangle = Struct.new(:vertices, :uvs, :normal, :light, :material, :masked)
+
+      attr_reader :triangles
+
+      def initialize(map, textures = nil)
+        @map = map
+        @textures = textures
+        @triangles = []
+        build_planes
+        build_walls
+      end
+
+      private
+
+      def build_planes
+        bsp_leaf_polygons.each do |subsector_index, points|
+          subsector = @map.subsectors[subsector_index]
+          segs = @map.segs[subsector.first_seg, subsector.seg_count]
+          next if segs.nil? || segs.empty?
+
+          # BSP leaves partition the entire map bounding box, including solid
+          # void behind one-sided walls. Segs are directed with their front
+          # sector on the right; clipping by each one trims the leaf to the
+          # actual playable subsector surface.
+          points = clip_to_segs(points, segs)
+
+          sector = segs.lazy.map { |seg| sector_for_seg(seg) }.find(&:itself)
+          next unless sector
+
+          next if points.size < 3
+
+          (1...(points.size - 1)).each do |i|
+            add_triangle(points[0], points[i], points[i + 1], sector.floor_height,
+                         [0.0, 0.0, 1.0], sector.light_level, sector.floor_texture)
+            unless sector.ceiling_texture == 'F_SKY1'
+              add_triangle(points[0], points[i + 1], points[i], sector.ceiling_height,
+                           [0.0, 0.0, -1.0], sector.light_level, sector.ceiling_texture)
+            end
+          end
+        end
+      end
+
+      def clip_to_segs(points, segs)
+        segs.reduce(points) do |polygon, seg|
+          break [] if polygon.size < 3
+
+          a = @map.vertices[seg.v1]
+          b = @map.vertices[seg.v2]
+          dx = b.x - a.x
+          dy = b.y - a.y
+          clip_by_values(polygon) { |point| ((point.x - a.x) * dy) - ((point.y - a.y) * dx) }
+        end
+      end
+
+      def clip_by_values(polygon)
+        output = []
+        polygon.each_with_index do |current, index|
+          previous = polygon[index - 1]
+          current_value = yield(current)
+          previous_value = yield(previous)
+          current_inside = current_value >= -1e-7
+          previous_inside = previous_value >= -1e-7
+          if current_inside != previous_inside
+            t = previous_value / (previous_value - current_value).to_f
+            output << Map::Vertex.new(
+              previous.x + ((current.x - previous.x) * t),
+              previous.y + ((current.y - previous.y) * t)
+            )
+          end
+          output << current if current_inside
+        end
+        output
+      end
+
+      # Reconstruct exact convex subsector cells by carrying the map bounding
+      # polygon through the BSP and clipping it at every partition. Seg
+      # endpoints alone do not contain the artificial BSP split edges.
+      def bsp_leaf_polygons
+        xs = @map.vertices.map(&:x)
+        ys = @map.vertices.map(&:y)
+        padding = 1.0
+        root_polygon = [
+          [xs.min - padding, ys.min - padding],
+          [xs.max + padding, ys.min - padding],
+          [xs.max + padding, ys.max + padding],
+          [xs.min - padding, ys.max + padding]
+        ]
+        leaves = {}
+        visit_bsp(@map.nodes.size - 1, root_polygon, leaves)
+        leaves
+      end
+
+      def visit_bsp(index, polygon, leaves)
+        return if polygon.size < 3
+
+        if (index & Map::Node::SUBSECTOR_FLAG) != 0
+          leaves[index & ~Map::Node::SUBSECTOR_FLAG] = polygon.map { |x, y| Map::Vertex.new(x, y) }
+          return
+        end
+
+        node = @map.nodes[index]
+        visit_bsp(node.child_right, clip_polygon(polygon, node, true), leaves)
+        visit_bsp(node.child_left, clip_polygon(polygon, node, false), leaves)
+      end
+
+      def clip_polygon(polygon, node, keep_right)
+        output = []
+        polygon.each_with_index do |current, index|
+          previous = polygon[index - 1]
+          current_side = partition_value(current, node)
+          previous_side = partition_value(previous, node)
+          current_inside = keep_right ? current_side >= -1e-7 : current_side <= 1e-7
+          previous_inside = keep_right ? previous_side >= -1e-7 : previous_side <= 1e-7
+
+          if current_inside != previous_inside
+            t = previous_side / (previous_side - current_side).to_f
+            output << [previous[0] + ((current[0] - previous[0]) * t),
+                       previous[1] + ((current[1] - previous[1]) * t)]
+          end
+          output << current if current_inside
+        end
+        output
+      end
+
+      def partition_value(point, node)
+        ((point[0] - node.x) * node.dy) - ((point[1] - node.y) * node.dx)
+      end
+
+      def build_walls
+        @map.linedefs.each do |line|
+          right = sidedef(line.sidedef_right)
+          left = sidedef(line.sidedef_left)
+          next unless right || left
+
+          front = right && @map.sectors[right.sector]
+          back = left && @map.sectors[left.sector]
+          a = @map.vertices[line.v1]
+          b = @map.vertices[line.v2]
+
+          if front && back
+            # Doom's sky hack: adjacent sky ceilings are one continuous
+            # infinite sky even when their numeric heights differ. Emitting an
+            # upper wall here creates the conspicuous tower at outdoor edges.
+            both_sky = front.ceiling_texture == 'F_SKY1' && back.ceiling_texture == 'F_SKY1'
+            if !both_sky && front.ceiling_height > back.ceiling_height
+              v_top = right.y_offset
+              v_top += back.ceiling_height - front.ceiling_height unless line.upper_unpegged?
+              wall_quad(a, b, back.ceiling_height, front.ceiling_height,
+                        front.light_level, right.upper_texture,
+                        u_offset: right.x_offset, v_top: v_top)
+            elsif !both_sky && back.ceiling_height > front.ceiling_height
+              v_top = left.y_offset
+              v_top += front.ceiling_height - back.ceiling_height unless line.upper_unpegged?
+              wall_quad(a, b, front.ceiling_height, back.ceiling_height,
+                        back.light_level, left.upper_texture, flip: true,
+                                                              u_offset: left.x_offset, v_top: v_top)
+            end
+            if back.floor_height > front.floor_height
+              v_top = right.y_offset
+              v_top += front.ceiling_height - back.floor_height if line.lower_unpegged?
+              wall_quad(a, b, front.floor_height, back.floor_height,
+                        front.light_level, right.lower_texture,
+                        u_offset: right.x_offset, v_top: v_top)
+            elsif front.floor_height > back.floor_height
+              v_top = left.y_offset
+              v_top += back.ceiling_height - front.floor_height if line.lower_unpegged?
+              wall_quad(a, b, back.floor_height, front.floor_height,
+                        back.light_level, left.lower_texture, flip: true,
+                                                              u_offset: left.x_offset, v_top: v_top)
+            end
+            opening_bottom = [front.floor_height, back.floor_height].max
+            opening_top = [front.ceiling_height, back.ceiling_height].min
+            if middle_material?(right)
+              masked_middle(a, b, opening_bottom, opening_top, front, right, line)
+            elsif middle_material?(left)
+              masked_middle(a, b, opening_bottom, opening_top, back, left, line, flip: true)
+            end
+          else
+            sector = front || back
+            side = right || left
+            v_top = side.y_offset
+            v_top -= sector.ceiling_height - sector.floor_height if line.lower_unpegged?
+            wall_quad(a, b, sector.floor_height, sector.ceiling_height,
+                      sector.light_level, side.middle_texture, flip: !right,
+                                                               u_offset: side.x_offset, v_top: v_top)
+          end
+        end
+      end
+
+      def middle_material?(side)
+        side && !side.middle_texture.nil? && !side.middle_texture.empty? && side.middle_texture != '-'
+      end
+
+      def masked_middle(a, b, opening_bottom, opening_top, sector, side, line, flip: false)
+        material = side.middle_texture
+        return if material.nil? || material.empty? || material == '-'
+
+        texture = @textures&.[](material)
+        texture_height = texture&.height || (opening_top - opening_bottom)
+        texture_top = if line.lower_unpegged?
+                        opening_bottom + texture_height + side.y_offset
+                      else
+                        opening_top + side.y_offset
+                      end
+        bottom = [opening_bottom, texture_top - texture_height].max
+        top = [opening_top, texture_top].min
+        return unless top > bottom
+
+        wall_quad(a, b, bottom, top, sector.light_level, material, flip: flip,
+                                                                   u_offset: side.x_offset, v_top: texture_top - top, masked: true)
+      end
+
+      def wall_quad(a, b, bottom, top, light, material, flip: false, u_offset: 0, v_top: 0, masked: false)
+        return unless top > bottom
+
+        a, b = b, a if flip
+
+        dx = b.x - a.x
+        dy = b.y - a.y
+        length = Math.hypot(dx, dy)
+        return if length.zero?
+
+        normal = [dy / length, -dx / length, 0.0]
+        v0 = [a.x.to_f, a.y.to_f, bottom.to_f]
+        v1 = [b.x.to_f, b.y.to_f, bottom.to_f]
+        v2 = [b.x.to_f, b.y.to_f, top.to_f]
+        v3 = [a.x.to_f, a.y.to_f, top.to_f]
+        # UVs remain in Doom world/texel units. The GPU renderer normalizes
+        # them by the actual material dimensions (not every wall is 64 px).
+        u0 = u_offset.to_f
+        u1 = u0 + length
+        v0_tex = v_top.to_f + (top - bottom)
+        v1_tex = v_top.to_f
+        @triangles << Triangle.new([v0, v1, v2], [[u0, v0_tex], [u1, v0_tex], [u1, v1_tex]], normal, light, material,
+                                   masked)
+        @triangles << Triangle.new([v0, v2, v3], [[u0, v0_tex], [u1, v1_tex], [u0, v1_tex]], normal, light, material,
+                                   masked)
+      end
+
+      def add_triangle(a, b, c, z, normal, light, material)
+        area = ((b.x - a.x) * (c.y - a.y)) - ((b.y - a.y) * (c.x - a.x))
+        return if area.abs < 1e-6
+
+        vertices = [a, b, c].map { |point| [point.x.to_f, point.y.to_f, z.to_f] }
+        uvs = [a, b, c].map { |point| [point.x.to_f, -point.y.to_f] }
+        @triangles << Triangle.new(vertices, uvs, normal, light, material)
+      end
+
+      def sector_for_seg(seg)
+        line = @map.linedefs[seg.linedef]
+        index = seg.direction.zero? ? line.sidedef_right : line.sidedef_left
+        side = sidedef(index)
+        side && @map.sectors[side.sector]
+      end
+
+      def sidedef(index)
+        return nil unless index && index >= 0 && index < @map.sidedefs.size
+
+        @map.sidedefs[index]
+      end
+    end
+  end
+end