quake-rb 0.1.0 → 0.2.0

data/lib/quake/renderer/gl_particles.rb

@@ -1,20 +1,35 @@
 # frozen_string_literal: true
 
 require "opengl"
+require_relative "gl_alias_model"
 
 module Quake
   module Renderer
     # Simple particle system for visual effects.
-    # Particles are rendered as GL_POINTS with depth test enabled.
-    # Matches Quake's R_DrawParticles (gl_rpart.c).
+    # Matches Quake's GL R_DrawParticles (r_part.c).
     class GLParticles
       GRAVITY = 800.0
       MAX_PARTICLES = 2048
+      PARTICLE_TEXTURE_SIZE = 8
+      PARTICLE_BILLBOARD_SIZE = 1.5
+      PARTICLE_SCALE_DISTANCE = 20.0
+      PARTICLE_SCALE_FACTOR = 0.004
+
+      DOT_TEXTURE = [
+        [0, 1, 1, 0, 0, 0, 0, 0],
+        [1, 1, 1, 1, 0, 0, 0, 0],
+        [1, 1, 1, 1, 0, 0, 0, 0],
+        [0, 1, 1, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0]
+      ].freeze
 
       # Quake ramp tables for color animation (palette indices)
       RAMP1 = [0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61].freeze
       RAMP2 = [0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66].freeze
-      RAMP3 = [0x6d, 0x6b, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01].freeze # explosion
+      RAMP3 = [0x6d, 0x6b, 0x06, 0x05, 0x04, 0x03, 0x00, 0x00].freeze # explosion
 
       Particle = Struct.new(:x, :y, :z, :vx, :vy, :vz,
                             :r, :g, :b, :a,
@@ -35,20 +50,12 @@ module Quake
           p.y += p.vy * dt
           p.z += p.vz * dt
 
-          # Apply gravity
-          p.vz -= GRAVITY * p.gravity_scale * dt
-
           # Color ramp animation
-          if p.ramp_type
-            p.ramp += dt * 10.0
+          if p.ramp_type && (ramp = ramp_for_type(p.ramp_type))
+            p.ramp += dt * ramp_rate(p.ramp_type)
             idx = p.ramp.to_i
-            ramp = case p.ramp_type
-                   when :explosion then RAMP3
-                   when :fire then RAMP1
-                   else RAMP2
-                   end
 
-            if idx >= ramp.size
+            if idx >= ramp_expiry_size(p.ramp_type, ramp)
               next true # particle expired
             end
 
@@ -58,51 +65,163 @@ module Quake
             p.b = color[2] / 255.0
           end
 
-          # Fade alpha
-          p.a = (p.life * 2.0).clamp(0.0, 1.0)
+          update_velocity(p, dt)
 
           false
         end
       end
 
-      def render
+      def render(camera: nil)
         return if @particles.empty?
 
-        GL.Disable(GL::TEXTURE_2D)
+        upload_particle_texture unless @particle_texture
+        view_origin = camera&.position || Math::Vec3::ORIGIN
+        view_forward = camera&.forward || Math::Vec3.new(1.0, 0.0, 0.0)
+        up = (camera&.up || Math::Vec3.new(0.0, 0.0, 1.0)) * PARTICLE_BILLBOARD_SIZE
+        right = (camera&.right || Math::Vec3.new(0.0, -1.0, 0.0)) * PARTICLE_BILLBOARD_SIZE
+
+        GL.Enable(GL::TEXTURE_2D)
+        GL.BindTexture(GL::TEXTURE_2D, @particle_texture)
+        GL.Disable(GL::ALPHA_TEST)
         GL.Enable(GL::BLEND)
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::MODULATE)
         GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
-        GL.PointSize(2.0)
+        GL.DepthMask(GL::FALSE)
 
-        GL.Begin(GL::POINTS)
+        GL.Begin(GL::TRIANGLES)
         @particles.each do |p|
-          GL.Color4f(p.r, p.g, p.b, p.a)
+          scale = particle_scale(p, view_origin, view_forward)
+          GL.Color3f(p.r, p.g, p.b)
+          GL.TexCoord2f(0.0, 0.0)
           GL.Vertex3f(p.x, p.y, p.z)
+          GL.TexCoord2f(1.0, 0.0)
+          GL.Vertex3f(p.x + up.x * scale, p.y + up.y * scale, p.z + up.z * scale)
+          GL.TexCoord2f(0.0, 1.0)
+          GL.Vertex3f(p.x + right.x * scale, p.y + right.y * scale, p.z + right.z * scale)
         end
         GL.End
 
-        GL.PointSize(1.0)
+        GL.DepthMask(GL::TRUE)
         GL.Disable(GL::BLEND)
-        GL.Color4f(1.0, 1.0, 1.0, 1.0)
+        GL.TexEnvi(GL::TEXTURE_ENV, GL::TEXTURE_ENV_MODE, GL::REPLACE)
+        GL.Color3f(1.0, 1.0, 1.0)
       end
 
-      # Teleporter sparkle effect at a position
-      def teleport_splash(pos)
-        80.times do
-          dx = (rand * 64.0) - 32.0
-          dy = (rand * 64.0) - 32.0
-          dz = (rand * 64.0) - 32.0
-          color_idx = 7 + (rand * 8).to_i
-          color = @palette.rgb(color_idx)
+      # Quake R_EntityParticles: EF_BRIGHTFIELD particles orbit each alias normal.
+      def entity_particles(pos, time:)
+        entity_particle_avelocities.each_with_index do |velocities, index|
+          yaw = time.to_f * velocities[0]
+          pitch = time.to_f * velocities[1]
+          roll = time.to_f * velocities[2]
+          sy = ::Math.sin(yaw)
+          cy = ::Math.cos(yaw)
+          sp = ::Math.sin(pitch)
+          cp = ::Math.cos(pitch)
+          sr = ::Math.sin(roll)
+          cr = ::Math.cos(roll)
+          forward = [cp * cy, cp * sy, -sp]
+          normal = GLAliasModel::ANORMS[index]
+          color = @palette.rgb(0x6f)
+
           emit(
-            x: pos.x + dx, y: pos.y + dy, z: pos.z + dz,
-            vx: dx * 2.0, vy: dy * 2.0, vz: dz * 2.0 + 80.0,
+            x: pos.x + normal[0] * 64.0 + forward[0] * 16.0,
+            y: pos.y + normal[1] * 64.0 + forward[1] * 16.0,
+            z: pos.z + normal[2] * 64.0 + forward[2] * 16.0,
+            vx: 0.0, vy: 0.0, vz: 0.0,
             r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
-            life: 0.5 + rand * 0.3,
-            gravity_scale: 0.2
+            life: 0.01,
+            ramp_type: :explosion
           )
         end
       end
 
+      # Quake R_RocketTrail: projectile, blood, tracer, and voor trails.
+      def rocket_trail(start_pos, end_pos, type:)
+        dir_x = end_pos.x - start_pos.x
+        dir_y = end_pos.y - start_pos.y
+        dir_z = end_pos.z - start_pos.z
+        len = ::Math.sqrt(dir_x * dir_x + dir_y * dir_y + dir_z * dir_z)
+        return if len.zero?
+
+        dir_x /= len
+        dir_y /= len
+        dir_z /= len
+
+        dec = 3.0
+        if type >= 128
+          dec = 1.0
+          type -= 128
+        end
+
+        x = start_pos.x
+        y = start_pos.y
+        z = start_pos.z
+        while len.positive?
+          len -= dec
+          emit_rocket_trail_particle(x, y, z, dir_x, dir_y, dir_z, type)
+          len -= 3.0 if type == 4
+          x += dir_x
+          y += dir_y
+          z += dir_z
+        end
+      end
+
+      # Teleporter sparkle effect at a position
+      def teleport_splash(pos)
+        (-16...16).step(4) do |i|
+          (-16...16).step(4) do |j|
+            (-24...32).step(4) do |k|
+              color_idx = 7 + (rand * 8).to_i
+              color = @palette.rgb(color_idx)
+              dir_x = j * 8.0
+              dir_y = i * 8.0
+              dir_z = k * 8.0
+              length = ::Math.sqrt(dir_x * dir_x + dir_y * dir_y + dir_z * dir_z)
+              vel = 50.0 + (rand * 64).to_i
+              scale = length.zero? ? 0.0 : vel / length
+              emit(
+                x: pos.x + i + (rand * 4).to_i,
+                y: pos.y + j + (rand * 4).to_i,
+                z: pos.z + k + (rand * 4).to_i,
+                vx: dir_x * scale,
+                vy: dir_y * scale,
+                vz: dir_z * scale,
+                r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+                life: 0.2 + (rand * 8).to_i * 0.02,
+                gravity_scale: 1.0
+              )
+            end
+          end
+        end
+      end
+
+      # Quake temp entity TE_LAVASPLASH.
+      def lava_splash(pos)
+        (-16...16).each do |i|
+          (-16...16).each do |j|
+            color_idx = 224 + (rand * 8).to_i
+            color = @palette.rgb(color_idx)
+            dir_x = j * 8.0 + (rand * 8).to_i
+            dir_y = i * 8.0 + (rand * 8).to_i
+            dir_z = 256.0
+            length = ::Math.sqrt(dir_x * dir_x + dir_y * dir_y + dir_z * dir_z)
+            vel = 50.0 + (rand * 64).to_i
+            scale = vel / length
+            emit(
+              x: pos.x + dir_x,
+              y: pos.y + dir_y,
+              z: pos.z + (rand * 64).to_i,
+              vx: dir_x * scale,
+              vy: dir_y * scale,
+              vz: dir_z * scale,
+              r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+              life: 2.0 + (rand * 32).to_i * 0.02,
+              gravity_scale: 1.0
+            )
+          end
+        end
+      end
+
       # Item pickup sparkle
       def pickup_effect(pos)
         20.times do
@@ -124,48 +243,269 @@ module Quake
 
       # Explosion burst
       def explosion(pos)
-        128.times do
-          color = @palette.rgb(0x6d)
+        1024.times do |i|
+          emit_explosion_particle(pos, index: i)
+        end
+      end
+
+      # Quake temp entity TE_EXPLOSION2: color-mapped particle explosion.
+      def color_mapped_explosion(pos, color_start:, color_length:)
+        color_mod = 0
+        512.times do
+          color_idx = color_start + (color_mod % color_length)
+          color_mod += 1
+          color = @palette.rgb(color_idx)
           emit(
-            x: pos.x + rand * 16 - 8, y: pos.y + rand * 16 - 8, z: pos.z + rand * 16 - 8,
-            vx: (rand * 512) - 256, vy: (rand * 512) - 256, vz: (rand * 512) - 256,
+            x: pos.x + (rand * 32).to_i - 16,
+            y: pos.y + (rand * 32).to_i - 16,
+            z: pos.z + (rand * 32).to_i - 16,
+            vx: (rand * 512).to_i - 256,
+            vy: (rand * 512).to_i - 256,
+            vz: (rand * 512).to_i - 256,
             r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
-            life: 0.5 + rand * 0.5,
-            gravity_scale: 0.05,
-            ramp_type: :explosion
+            life: 0.3,
+            ramp_type: :blob
           )
         end
       end
 
-      # Blood spurt
+      # Quake temp entity TE_TAREXPLOSION: tarbaby blob explosion.
+      def blob_explosion(pos)
+        1024.times do |i|
+          color_idx = i.odd? ? 66 + (rand * 6).to_i : 150 + (rand * 6).to_i
+          color = @palette.rgb(color_idx)
+          emit(
+            x: pos.x + (rand * 32).to_i - 16,
+            y: pos.y + (rand * 32).to_i - 16,
+            z: pos.z + (rand * 32).to_i - 16,
+            vx: (rand * 512).to_i - 256,
+            vy: (rand * 512).to_i - 256,
+            vz: (rand * 512).to_i - 256,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 1.0 + (((rand * 256).to_i & 8) * 0.05),
+            ramp_type: i.odd? ? :blob : :blob2
+          )
+        end
+      end
+
+      # QuakeWorld TE_BLOOD uses R_RunParticleEffect with blood palette color 73.
       def blood(pos, count: 20)
+        run_particle_effect(pos, color: 73, count: count)
+      end
+
+      # QuakeWorld TE_LIGHTNINGBLOOD.
+      def lightning_blood(pos)
+        run_particle_effect(pos, color: 225, count: 50)
+      end
+
+      # Quake R_RunParticleEffect: used by gunshots and spike impact puffs.
+      def run_particle_effect(pos, color:, count:, dir: nil)
+        if count == 1024
+          count.times { |i| emit_explosion_particle(pos, index: i) }
+          return
+        end
+
+        color_base = color & ~7
+        dir_x = dir ? dir.x : 0.0
+        dir_y = dir ? dir.y : 0.0
+        dir_z = dir ? dir.z : 0.0
+
         count.times do
-          color_idx = 67 + (rand * 4).to_i # dark red palette range
-          color = @palette.rgb(color_idx)
+          color = @palette.rgb(color_base + (rand * 8).to_i)
           emit(
-            x: pos.x, y: pos.y, z: pos.z,
-            vx: (rand * 128) - 64, vy: (rand * 128) - 64, vz: (rand * 128) - 64,
+            x: pos.x + (rand * 16).to_i - 8,
+            y: pos.y + (rand * 16).to_i - 8,
+            z: pos.z + (rand * 16).to_i - 8,
+            vx: dir_x * 15.0, vy: dir_y * 15.0, vz: dir_z * 15.0,
             r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
-            life: 0.5 + rand * 0.3,
+            life: (rand * 5).to_i * 0.1,
             gravity_scale: 1.0
           )
         end
       end
 
+      # Quake temp entity TE_GUNSHOT: a small wall puff at bullet impact.
+      def gunshot(pos, count: 20)
+        run_particle_effect(pos, color: 0, count: count)
+      end
+
       def particle_count
         @particles.size
       end
 
       private
 
+      def upload_particle_texture
+        buf = "\0" * 4
+        GL.GenTextures(1, buf)
+        @particle_texture = buf.unpack1("V")
+
+        GL.BindTexture(GL::TEXTURE_2D, @particle_texture)
+        GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA,
+                      PARTICLE_TEXTURE_SIZE, PARTICLE_TEXTURE_SIZE, 0,
+                      GL::RGBA, GL::UNSIGNED_BYTE, particle_texture_rgba)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::LINEAR)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+      end
+
+      def particle_texture_rgba
+        DOT_TEXTURE.flat_map.with_index do |row, y|
+          row.flat_map.with_index do |_value, x|
+            [255, 255, 255, DOT_TEXTURE[x][y] * 255]
+          end
+        end.pack("C*")
+      end
+
+      def particle_scale(particle, view_origin, view_forward)
+        distance = (particle.x - view_origin.x) * view_forward.x +
+                   (particle.y - view_origin.y) * view_forward.y +
+                   (particle.z - view_origin.z) * view_forward.z
+        return 1.0 if distance < PARTICLE_SCALE_DISTANCE
+
+        1.0 + distance * PARTICLE_SCALE_FACTOR
+      end
+
+      def emit_explosion_particle(pos, index:)
+        ramp = (rand * 4).to_i
+        color = @palette.rgb(RAMP1[0])
+        emit(
+          x: pos.x + (rand * 32).to_i - 16,
+          y: pos.y + (rand * 32).to_i - 16,
+          z: pos.z + (rand * 32).to_i - 16,
+          vx: (rand * 512).to_i - 256,
+          vy: (rand * 512).to_i - 256,
+          vz: (rand * 512).to_i - 256,
+          r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+          life: 5.0,
+          ramp: ramp,
+          ramp_type: index.odd? ? :explosion : :explosion2
+        )
+      end
+
+      def update_velocity(p, dt)
+        grav = GRAVITY * 0.05 * dt
+        dvel = 4.0 * dt
+
+        case p.ramp_type
+        when :fire
+          p.vz += grav
+        when :explosion, :blob
+          p.vx += p.vx * dvel
+          p.vy += p.vy * dvel
+          p.vz += p.vz * dvel
+          p.vz -= grav
+        when :explosion2
+          p.vx -= p.vx * dt
+          p.vy -= p.vy * dt
+          p.vz -= p.vz * dt
+          p.vz -= grav
+        when :blob2
+          p.vx -= p.vx * dvel
+          p.vy -= p.vy * dvel
+          p.vz -= grav
+        else
+          p.vz -= grav * p.gravity_scale
+        end
+      end
+
+      def emit_rocket_trail_particle(x, y, z, dir_x, dir_y, dir_z, type)
+        case type
+        when 0, 1
+          ramp = (rand * 4).to_i + (type == 1 ? 2 : 0)
+          color = @palette.rgb(RAMP3[ramp])
+          emit(
+            x: x + (rand * 6).to_i - 3,
+            y: y + (rand * 6).to_i - 3,
+            z: z + (rand * 6).to_i - 3,
+            vx: 0.0, vy: 0.0, vz: 0.0,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 2.0,
+            ramp: ramp,
+            ramp_type: :fire
+          )
+        when 2, 4
+          color = @palette.rgb(67 + (rand * 4).to_i)
+          emit(
+            x: x + (rand * 6).to_i - 3,
+            y: y + (rand * 6).to_i - 3,
+            z: z + (rand * 6).to_i - 3,
+            vx: 0.0, vy: 0.0, vz: 0.0,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 2.0,
+            gravity_scale: 1.0
+          )
+        when 3, 5
+          @tracercount ||= 0
+          color_idx = type == 3 ? 52 + ((@tracercount & 4) << 1) : 230 + ((@tracercount & 4) << 1)
+          @tracercount += 1
+          vx = if (@tracercount & 1) == 1
+                 30.0 * dir_y
+               else
+                 -30.0 * dir_y
+               end
+          vy = if (@tracercount & 1) == 1
+                 30.0 * -dir_x
+               else
+                 30.0 * dir_x
+               end
+          color = @palette.rgb(color_idx)
+          emit(
+            x: x, y: y, z: z,
+            vx: vx, vy: vy, vz: 0.0,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 0.5
+          )
+        when 6
+          color = @palette.rgb((9 * 16) + 8 + (rand * 4).to_i)
+          emit(
+            x: x + (rand * 16).to_i - 8,
+            y: y + (rand * 16).to_i - 8,
+            z: z + (rand * 16).to_i - 8,
+            vx: 0.0, vy: 0.0, vz: 0.0,
+            r: color[0] / 255.0, g: color[1] / 255.0, b: color[2] / 255.0,
+            life: 0.3
+          )
+        end
+      end
+
+      def entity_particle_avelocities
+        @entity_particle_avelocities ||= GLAliasModel::ANORMS.map do
+          [
+            (rand * 256.0).to_i * 0.01,
+            (rand * 256.0).to_i * 0.01,
+            (rand * 256.0).to_i * 0.01
+          ]
+        end
+      end
+
+      def ramp_for_type(type)
+        case type
+        when :fire then RAMP3
+        when :explosion then RAMP1
+        when :explosion2 then RAMP2
+        end
+      end
+
+      def ramp_rate(type)
+        case type
+        when :fire then 5.0
+        when :explosion2 then 15.0
+        else 10.0
+        end
+      end
+
+      def ramp_expiry_size(type, ramp)
+        type == :fire ? 6 : ramp.size
+      end
+
       def emit(x:, y:, z:, vx:, vy:, vz:, r:, g:, b:, life:,
-               gravity_scale: 0.0, ramp_type: nil)
+               gravity_scale: 0.0, ramp: 0.0, ramp_type: nil)
         return if @particles.size >= MAX_PARTICLES
 
         @particles << Particle.new(
           x, y, z, vx, vy, vz,
           r, g, b, 1.0,
-          life, 0.0, ramp_type, gravity_scale
+          life, ramp.to_f, ramp_type, gravity_scale
         )
       end
     end

data/lib/quake/renderer/gl_sky.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
 require "opengl"
+require_relative "gl_warp_subdivision"
 
 module Quake
   module Renderer
     # Renders Quake sky using the two-layer scrolling technique.
     # Sky textures are 256x128, split into:
-    #   - Left half (128x128): solid background layer
-    #   - Right half (128x128): alpha foreground layer (index 0 = transparent)
+    #   - Right half (128x128): solid background layer
+    #   - Left half (128x128): alpha foreground layer (index 0 = transparent)
     class GLSky
+      include GLWarpSubdivision
+
       def initialize(level, palette, texture_manager)
         @level = level
         @palette = palette
@@ -107,17 +110,17 @@ module Quake
         h = miptex.height  # 128
         half_w = w / 2     # 128
 
-        # Extract left half (solid background)
+        # GLQuake uses the right half as the solid background layer.
         solid_pixels = String.new(capacity: half_w * h)
         h.times do |row|
-          src_offset = row * w
+          src_offset = row * w + half_w
           solid_pixels << miptex.pixels[src_offset, half_w]
         end
 
-        # Extract right half (alpha foreground)
+        # GLQuake uses the left half as the alpha foreground layer.
         alpha_pixels = String.new(capacity: half_w * h)
         h.times do |row|
-          src_offset = row * w + half_w
+          src_offset = row * w
           alpha_pixels << miptex.pixels[src_offset, half_w]
         end
 
@@ -125,13 +128,81 @@ module Quake
         @alpha_tex = upload_texture(alpha_pixels, half_w, h, transparent: true)
       end
 
+      # Ruby port of tyrquake's QPic32_AlphaFix (qpic.c). Gives each fully
+      # transparent texel the average RGB of its non-transparent neighbours
+      # (wrapping around at the texture edges) to avoid wrong-colored fringes
+      # from GL_LINEAR blending. Alpha stays 0; texels with no non-transparent
+      # neighbours keep RGB 0.
+      def alpha_fix(rgba, width, height)
+        height.times do |y|
+          width.times do |x|
+            current = y * width + x
+
+            # Only modify completely transparent texels
+            next unless rgba.getbyte(current * 4 + 3) == 0
+
+            # Neighbour texel indexes are left to right:
+            #   0 1 2
+            #   3 * 4
+            #   5 6 7
+            neighbours = [
+              current - width - 1, current - width, current - width + 1,
+              current - 1, current + 1,
+              current + width - 1, current + width, current + width + 1
+            ]
+
+            # Handle edge cases (wrap around)
+            if x == 0
+              neighbours[0] += width
+              neighbours[3] += width
+              neighbours[5] += width
+            elsif x == width - 1
+              neighbours[2] -= width
+              neighbours[4] -= width
+              neighbours[7] -= width
+            end
+            if y == 0
+              neighbours[0] += width * height
+              neighbours[1] += width * height
+              neighbours[2] += width * height
+            elsif y == height - 1
+              neighbours[5] -= width * height
+              neighbours[6] -= width * height
+              neighbours[7] -= width * height
+            end
+
+            # Find the average colour of non-transparent neighbours
+            r = g = b = count = 0
+            neighbours.each do |n|
+              next if rgba.getbyte(n * 4 + 3) == 0
+
+              r += rgba.getbyte(n * 4)
+              g += rgba.getbyte(n * 4 + 1)
+              b += rgba.getbyte(n * 4 + 2)
+              count += 1
+            end
+
+            # Skip if no non-transparent neighbours
+            next if count == 0
+
+            rgba.setbyte(current * 4, r / count)
+            rgba.setbyte(current * 4 + 1, g / count)
+            rgba.setbyte(current * 4 + 2, b / count)
+          end
+        end
+      end
+
       def upload_texture(pixels, width, height, transparent:)
         rgba = String.new(capacity: width * height * 4)
         pixels.each_byte do |idx|
-          r, g, b = @palette.rgb(idx)
-          a = (transparent && idx == 0) ? 0 : 255
-          rgba << r << g << b << a
+          if transparent && idx == 0
+            rgba << 0 << 0 << 0 << 0
+          else
+            r, g, b = @palette.rgb(idx)
+            rgba << r << g << b << 255
+          end
         end
+        alpha_fix(rgba, width, height) if transparent
 
         buf = "\0" * 4
         GL.GenTextures(1, buf)
@@ -157,7 +228,9 @@ module Quake
           next unless tex.name.start_with?("sky")
 
           verts = Bsp::FaceVertices.extract(@level, face)
-          @sky_surfaces << { vertices: verts, face_index: face_index }
+          subdivide_polygon(verts).each do |poly_verts|
+            @sky_surfaces << { vertices: poly_verts, face_index: face_index }
+          end
         end
         puts "Found #{@sky_surfaces.size} sky surfaces"
       end