quake-rb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76a4b7671e6182b04a0257b7ad6a229cefc9e5dc2e3c763529327e376b910f80
-  data.tar.gz: d855437be72bfaec56741b68bfd0497c578d21e67501c8383164f3c8ebd9abd6
+  metadata.gz: cc20d9efbfef9cb809f874ff1b00448ba06e58e0fec05d756ed98b9a1104a5e7
+  data.tar.gz: 63a4aa60adb6ec8d5ab243195afdf22de9a405c6050d7a1997d50d6def884b6d
 SHA512:
-  metadata.gz: 83f646634ab2dafd538fa3ab73814218871e01f0e09c2a10108f5a487e4d70476cfba4cccd15269887ee8f9ce05720b0c65739dd76f793b959f419b4bd1ce5ea
-  data.tar.gz: 877663d022ddfedb05cd9c0b3b630d04dcfdef084345f0e4183ea22733d351f87968105e062567efa090ca3d147ad8df8d9c46dbfdb65f3f8a71ec60761cfa61
+  metadata.gz: e3d20548d6671537bd2f22dd78bbbd09d6b6c6527ff0ea36a12450afbfcf02f73df3bd9b122cf4fc6aaffd893039e9a1516b21c0813fd7787fcdbdcff0f727ab
+  data.tar.gz: 7ab39626446b4998f5f8df44ae5945e497496651030d922828841bff5bdc908a325f189a4cd7a8ad19db90f47a45789a60b66401c5667ff4ff8ca09210b10df0

data/README.md

@@ -0,0 +1,136 @@
+# quake-rb
+
+A port of the [Quake (1996)](https://en.wikipedia.org/wiki/Quake_(video_game)) engine to Ruby. Reads original `.pak`/`.bsp`/`.mdl` assets and renders them via OpenGL + SDL2.
+
+![quake-rb running e1m1](docs/screenshot.png)
+
+## Why
+
+Mostly as a counterpart to [doom](https://github.com/khasinski/doom) — to see how far you can take id Software's classic engines in plain Ruby, and to learn the BSP/PVS/lightmap pipeline by writing it from the spec rather than reading the C.
+
+## Quick start
+
+```sh
+bundle install
+bundle exec bin/quake
+```
+
+On first run, with no `data/id1/pak0.pak` present, you'll be asked to download the freely-redistributable shareware Quake (Episode 1, ~17 MB). It's pulled from `archive.org/quakeshareware/QUAKE_SW.zip` and extracted into `./data/id1/pak0.pak`. You can also drop your own registered `pak0.pak` (and `pak1.pak`) in there manually.
+
+System requirements:
+
+- Ruby 3.1+
+- SDL2 (`brew install sdl2` / `apt install libsdl2-dev`)
+- OpenGL 2.1
+- `unzip` (used by the shareware fetcher)
+
+## Controls
+
+| Key            | Action |
+|----------------|--------|
+| WASD           | Move |
+| Mouse          | Look |
+| Space          | Jump |
+| C              | Crouch |
+| 1–8 / scroll   | Weapon select |
+| N              | Toggle noclip |
+| L              | Dump player pose + save a screenshot to `debug/shots/` (debug aid) |
+| Esc            | Quit |
+
+## What works
+
+- BSP loading + face extraction with texture coordinates
+- Texture mapping with the original 256-colour palette
+- Static lightmaps from the lighting lump
+- PVS culling, including:
+    - leaf 0 fallback (treat solid leaf as all-visible, à la TyrQuake)
+    - FatPVS expansion when the camera leaf touches a liquid surface
+    - **vis-through-water**: liquid faces in PVS bring the leaves on the other side of their plane into view, so translucent water shows the cave bed instead of clear-color void
+- Sky rendering: two-layer scrolling cloud + back layer, PVS-culled
+- Water/slime/lava: turbsin-warped texture, alpha-blended translucency, backface culling for the duplicate front/back face pairs Quake's BSP compiler emits
+- Brush entities (doors, plats, buttons, triggers) with their own transforms
+- MDL alias models with frame interpolation
+- Particle effects + viewmodel + HUD
+- Player physics: walk, crouch, jump, friction, water levels, platform riding
+- Item pickups, weapon switching, Quake-style player weapon firing, shareware audio mixer
+- Common QuakeC trigger behavior at engine level, including target firing,
+  killtarget, counters, hurt/push/teleport triggers, and changelevel requests
+
+## What doesn't (yet)
+
+- Multiplayer / netcode
+- QuakeC server program — game logic is faked at engine level
+- Full savegame/spawn parameter preservation across episode/level transitions
+- Mirrors, particle warp, dynamic lights
+- Sky cube / skybox replacement
+- Demo playback
+
+## Maps
+
+The shareware PAK ships:
+
+`start`, `e1m1`, `e1m2`, `e1m3`, `e1m4`, `e1m5`, `e1m6`, `e1m7`, `e1m8`
+
+Pass `-map maps/e1m3.bsp` to load a different one.
+
+## Architecture
+
+```
+lib/quake/
+  bsp/             reader, types, face vertices, PVS / FatPVS / vis-through-water
+  pak/             pak0.pak reader
+  mdl/             alias model reader
+  wad/             gfx.wad (HUD/menu graphics) reader
+  palette.rb       256-colour palette → RGBA
+  math/vec3.rb     plain Ruby vector
+  physics/         hull trace + Player (walk/swim/jump/noclip)
+  game/
+    engine.rb      orchestrates renderers + physics + entity simulation
+    brush_entities entity-driven door/plat/button state machines
+    item_pickups   touchable items
+    player_state   weapons, ammo, health, armor
+  renderer/
+    gl_textured       opaque world brushes (with lightmap pass)
+    gl_brush_model    sub-model brushes (doors etc.) at entity transforms
+    gl_alias_model    .mdl monsters + items
+    gl_water          *water0/*slime0/*lava0/*teleport with turbsin warp
+    gl_sky            two-layer scrolling sky
+    gl_lightmap       lightmap atlas builder
+    gl_texture_manager mipmapped diffuse texture cache
+    gl_particles      explosion/spark sprites
+    gl_viewmodel      first-person weapon
+    gl_hud            statusbar + numbers
+  sound/           SDL_mixer-backed sound effects
+  pak_downloader.rb shareware fetcher
+  version.rb        VERSION = "0.1.0"
+bin/
+  quake             interactive game
+  quake-debug       headless DSL runner (`teleport`, `screenshot`, `dump` etc.)
+test/              minitest suite
+debug/scripts/     ad-hoc investigation scripts (gitignored)
+```
+
+The headless runner is genuinely useful for working on the engine without a window — see `debug/scripts/*` for examples (water visibility traces, leaf inspection, BSP dumps).
+
+## Development
+
+```sh
+# Run the tests
+bundle exec ruby -Itest -Ilib -e 'Dir["test/**/*_test.rb"].each { |f| require File.expand_path(f) }'
+
+# Run a headless debug script (renders to a hidden window)
+bundle exec bin/quake-debug debug/scripts/water_real.rb
+
+# Run the game with YJIT
+bundle exec bin/quake --yjit
+```
+
+## Status
+
+This is a hobby project. It can comfortably walk you through `e1m1`, fire Quake-style player weapons, pick up items, and use a growing subset of QuakeC brush/trigger behavior. The QuakeC server program is still not implemented, so game logic is ported incrementally at engine level and monsters don't fight back yet.
+
+## License
+
+GPL-2.0-only, matching the original Quake source release.
+
+The shareware Quake data is © 1996 id Software, freely redistributable. The registered Quake data (if you supply your own `pak0.pak` + `pak1.pak`) is not redistributable; you must own a copy.

data/bin/quake

@@ -65,9 +65,12 @@ keys = {}
 running = true
 last_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-puts "Controls: WASD = move, Mouse = look, Space = jump, C = crouch, N = noclip, 1-8/scroll = weapons, ESC = quit"
+puts "Controls: WASD = move, Mouse = look, LMB/Ctrl = fire, Space = jump, C = crouch, N = noclip, 1-8/scroll = weapons, +/- = HUD size, ESC = quit"
 puts "Movement mode: #{noclip ? 'noclip' : 'normal'}"
 
+mouse_attack = false
+key_attack = false
+
 while running
   now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   dt = [now - last_time, 0.05].min
@@ -106,6 +109,12 @@ while running
              "shot=#{shot}"
       end
 
+      if scancode == SDL::SCANCODE_EQUALS
+        engine.adjust_viewsize(10) # sizeup: less HUD
+      elsif scancode == SDL::SCANCODE_MINUS
+        engine.adjust_viewsize(-10) # sizedown: more HUD
+      end
+
       weapon_slot = case scancode
                     when SDL::SCANCODE_1 then 1
                     when SDL::SCANCODE_2 then 2
@@ -132,9 +141,17 @@ while running
       engine.viewmodel&.set_weapon(engine.player_state.current_weapon_model)
     when SDL::MOUSEMOTION
       engine.player.rotate(event[:motion][:xrel], event[:motion][:yrel])
+    when SDL::MOUSEBUTTONDOWN
+      mouse_attack = true if event[:button][:button] == SDL::BUTTON_LEFT
+    when SDL::MOUSEBUTTONUP
+      mouse_attack = false if event[:button][:button] == SDL::BUTTON_LEFT
     end
   end
 
+  # Ctrl is Quake's classic +attack; combine with the mouse button
+  key_attack = keys[SDL::SCANCODE_LCTRL] || keys[SDL::SCANCODE_RCTRL] || false
+  engine.set_attack(mouse_attack || key_attack)
+
   engine.set_keys(keys)
   engine.tick(dt)
   engine.swap_buffers

data/lib/quake/bsp/reader.rb

@@ -30,23 +30,39 @@ module Quake
 
       def parse
         parse_header
+        @textures = parse_textures
+        vertices = parse_vertices
+        edges = parse_edges
+        faces = parse_faces
+        surfedges = parse_surfedges
+        planes = parse_planes
+        nodes = parse_nodes
+        leafs = parse_leafs
+        clipnodes = parse_clipnodes
+        texinfo = parse_texinfo
+        faces = build_surface_data(vertices, edges, faces, surfedges, texinfo)
+        models = parse_models
+        marksurfaces = parse_marksurfaces
+        entities = parse_entities
+        visibility = parse_visibility
+        lighting = parse_lighting
 
         Level.new(
-          vertices:     parse_vertices,
-          edges:        parse_edges,
-          faces:        parse_faces,
-          surfedges:    parse_surfedges,
-          planes:       parse_planes,
-          nodes:        parse_nodes,
-          leafs:        parse_leafs,
-          clipnodes:    parse_clipnodes,
-          texinfo:      parse_texinfo,
-          models:       parse_models,
-          marksurfaces: parse_marksurfaces,
-          entities:     parse_entities,
-          visibility:   parse_visibility,
-          lighting:     parse_lighting,
-          textures:     parse_textures
+          vertices:     vertices,
+          edges:        edges,
+          faces:        faces,
+          surfedges:    surfedges,
+          planes:       planes,
+          nodes:        nodes,
+          leafs:        leafs,
+          clipnodes:    clipnodes,
+          texinfo:      texinfo,
+          models:       models,
+          marksurfaces: marksurfaces,
+          entities:     entities,
+          visibility:   visibility,
+          lighting:     lighting,
+          textures:     @textures
         )
       end
 
@@ -54,7 +70,9 @@ module Quake
 
       def parse_header
         version = @data[0, 4].unpack1("l<")
-        raise "Unsupported BSP version: #{version} (expected #{BSP_VERSION})" unless version == BSP_VERSION
+        unless version == BSP_VERSION
+          raise "Mod_LoadBrushModel: wrong version number (#{version} should be #{BSP_VERSION})"
+        end
 
         NUM_LUMPS.times do |i|
           offset = 4 + i * 8
@@ -63,13 +81,16 @@ module Quake
         end
       end
 
-      def lump_data(index)
+      def lump_data(index, record_size: nil)
         offset, length = @lumps[index]
+        if record_size && (length % record_size) != 0
+          raise "MOD_LoadBmodel: funny lump size"
+        end
         @data[offset, length]
       end
 
       def parse_vertices
-        data = lump_data(LUMP_VERTICES)
+        data = lump_data(LUMP_VERTICES, record_size: 12)
         count = data.bytesize / 12
         result = Array.new(count)
         count.times do |i|
@@ -80,7 +101,7 @@ module Quake
       end
 
       def parse_edges
-        data = lump_data(LUMP_EDGES)
+        data = lump_data(LUMP_EDGES, record_size: 4)
         count = data.bytesize / 4
         result = Array.new(count)
         count.times do |i|
@@ -91,8 +112,9 @@ module Quake
       end
 
       def parse_faces
-        data = lump_data(LUMP_FACES)
+        data = lump_data(LUMP_FACES, record_size: 20)
         count = data.bytesize / 20
+        @face_count = count
         result = Array.new(count)
         count.times do |i|
           raw = data[i * 20, 20]
@@ -102,19 +124,78 @@ module Quake
             plane_index: plane_idx, side: side,
             first_edge: first_edge, num_edges: num_edges,
             texinfo_index: texinfo_idx, styles: [s0, s1, s2, s3],
-            light_offset: light_ofs
+            light_offset: light_ofs, flags: 0, texture_mins: [0, 0],
+            extents: [0, 0]
           )
         end
         result
       end
 
+      def build_surface_data(vertices, edges, faces, surfedges, texinfo)
+        faces.map do |face|
+          info = texinfo[face.texinfo_index]
+          next face unless info
+
+          texture_mins, extents = surface_extents(
+            vertices, edges, face, surfedges, info
+          )
+          if (info.flags & 1) == 0 && extents.any? { |extent| extent > 256 }
+            raise "Bad surface extents"
+          end
+
+          flags = face.side.zero? ? 0 : Face::SURF_PLANEBACK
+          texture = @textures[info.miptex_index] if @textures
+          name = texture&.name.to_s
+          if name.start_with?("sky")
+            flags |= Face::SURF_DRAWSKY | Face::SURF_DRAWTILED
+          elsif name.start_with?("*")
+            flags |= Face::SURF_DRAWTURB | Face::SURF_DRAWTILED
+            texture_mins = [-8192, -8192]
+            extents = [16384, 16384]
+          end
+
+          face.with(flags: flags, texture_mins: texture_mins, extents: extents)
+        end
+      end
+
+      def surface_extents(vertices, edges, face, surfedges, texinfo)
+        mins = [999999.0, 999999.0]
+        maxs = [-99999.0, -99999.0]
+
+        face.num_edges.times do |i|
+          surfedge = surfedges[face.first_edge + i]
+          edge = edges[surfedge.abs]
+          vertex_index = surfedge >= 0 ? edge.v0 : edge.v1
+          vertex = vertices[vertex_index]
+
+          values = [
+            vertex.dot(texinfo.s_vec) + texinfo.s_offset,
+            vertex.dot(texinfo.t_vec) + texinfo.t_offset
+          ]
+          2.times do |axis|
+            mins[axis] = values[axis] if values[axis] < mins[axis]
+            maxs[axis] = values[axis] if values[axis] > maxs[axis]
+          end
+        end
+
+        texture_mins = Array.new(2)
+        extents = Array.new(2)
+        2.times do |axis|
+          bmin = (mins[axis] / 16.0).floor
+          bmax = (maxs[axis] / 16.0).ceil
+          texture_mins[axis] = bmin * 16
+          extents[axis] = (bmax - bmin) * 16
+        end
+        [texture_mins, extents]
+      end
+
       def parse_surfedges
-        data = lump_data(LUMP_SURFEDGES)
+        data = lump_data(LUMP_SURFEDGES, record_size: 4)
         data.unpack("l<*")
       end
 
       def parse_planes
-        data = lump_data(LUMP_PLANES)
+        data = lump_data(LUMP_PLANES, record_size: 20)
         count = data.bytesize / 20
         result = Array.new(count)
         count.times do |i|
@@ -127,7 +208,7 @@ module Quake
       end
 
       def parse_nodes
-        data = lump_data(LUMP_NODES)
+        data = lump_data(LUMP_NODES, record_size: 24)
         count = data.bytesize / 24
         result = Array.new(count)
         count.times do |i|
@@ -147,7 +228,7 @@ module Quake
       end
 
       def parse_leafs
-        data = lump_data(LUMP_LEAFS)
+        data = lump_data(LUMP_LEAFS, record_size: 28)
         count = data.bytesize / 28
         result = Array.new(count)
         count.times do |i|
@@ -168,7 +249,7 @@ module Quake
       end
 
       def parse_clipnodes
-        data = lump_data(LUMP_CLIPNODES)
+        data = lump_data(LUMP_CLIPNODES, record_size: 8)
         count = data.bytesize / 8
         result = Array.new(count)
         count.times do |i|
@@ -179,13 +260,19 @@ module Quake
       end
 
       def parse_texinfo
-        data = lump_data(LUMP_TEXINFO)
+        data = lump_data(LUMP_TEXINFO, record_size: 40)
         count = data.bytesize / 40
         result = Array.new(count)
         count.times do |i|
           raw = data[i * 40, 40]
           floats = raw[0, 32].unpack("e8")
           miptex, flags = raw[32, 8].unpack("l<2")
+          if @texture_count && miptex >= @texture_count
+            raise "miptex >= loadmodel->numtextures"
+          end
+          if @texture_count.nil? || @textures[miptex].nil?
+            flags = 0
+          end
           result[i] = TexInfo.new(
             s_vec: Math::Vec3.new(floats[0], floats[1], floats[2]),
             s_offset: floats[3],
@@ -198,7 +285,7 @@ module Quake
       end
 
       def parse_models
-        data = lump_data(LUMP_MODELS)
+        data = lump_data(LUMP_MODELS, record_size: 64)
         count = data.bytesize / 64
         result = Array.new(count)
         count.times do |i|
@@ -206,8 +293,12 @@ module Quake
           floats = raw[0, 36].unpack("e9")
           ints = raw[36, 28].unpack("l<7")
           result[i] = Model.new(
-            mins: Math::Vec3.new(floats[0], floats[1], floats[2]),
-            maxs: Math::Vec3.new(floats[3], floats[4], floats[5]),
+            mins: Math::Vec3.new(
+              floats[0] - 1.0, floats[1] - 1.0, floats[2] - 1.0
+            ),
+            maxs: Math::Vec3.new(
+              floats[3] + 1.0, floats[4] + 1.0, floats[5] + 1.0
+            ),
             origin: Math::Vec3.new(floats[6], floats[7], floats[8]),
             head_nodes: ints[0..3],
             vis_leafs: ints[4],
@@ -218,30 +309,41 @@ module Quake
       end
 
       def parse_marksurfaces
-        data = lump_data(LUMP_MARKSURFACES)
-        data.unpack("v*")
+        data = lump_data(LUMP_MARKSURFACES, record_size: 2)
+        data.unpack("v*").each do |face_index|
+          if face_index >= @face_count
+            raise "Mod_ParseMarksurfaces: bad surface number"
+          end
+        end
       end
 
       def parse_entities
-        lump_data(LUMP_ENTITIES)&.force_encoding("ASCII")&.delete("\0") || ""
+        data = lump_data(LUMP_ENTITIES)
+        data&.empty? ? nil : data&.force_encoding("ASCII")
       end
 
       def parse_visibility
-        lump_data(LUMP_VISIBILITY) || ""
+        data = lump_data(LUMP_VISIBILITY)
+        data&.empty? ? nil : data
       end
 
       def parse_lighting
-        lump_data(LUMP_LIGHTING) || ""
+        data = lump_data(LUMP_LIGHTING)
+        data&.empty? ? nil : data
       end
 
       def parse_textures
         data = lump_data(LUMP_TEXTURES)
-        return [] if data.nil? || data.bytesize < 4
+        if data.nil? || data.bytesize < 4
+          @texture_count = nil
+          return []
+        end
 
         num_miptex = data[0, 4].unpack1("l<")
+        @texture_count = num_miptex
         offsets = data[4, num_miptex * 4].unpack("l<#{num_miptex}")
 
-        offsets.map do |ofs|
+        textures = offsets.map do |ofs|
           if ofs < 0
             nil
           else
@@ -249,15 +351,116 @@ module Quake
             next nil if raw.nil? || raw.bytesize < 40
             name = raw[0, 16].unpack1("Z16")
             width, height = raw[16, 8].unpack("V2")
+            if (width & 15) != 0 || (height & 15) != 0
+              raise "Texture #{name} is not 16 aligned"
+            end
             mip_offsets = raw[24, 16].unpack("V4")
             # Extract mip level 0 pixel data (8-bit indexed)
             pixel_offset = ofs + mip_offsets[0]
             pixel_count = width * height
             pixels = data[pixel_offset, pixel_count]
             MipTex.new(name: name, width: width, height: height,
-                       offsets: mip_offsets, pixels: pixels)
+                       offsets: mip_offsets, pixels: pixels,
+                       anim_total: 0, anim_min: 0, anim_max: 0,
+                       anim_next: nil, alternate_anims: nil)
           end
         end
+        sequence_texture_animations(textures)
+        textures
+      end
+
+      def sequence_texture_animations(textures)
+        sequenced = {}
+        textures.each_with_index do |texture, index|
+          next unless texture&.name&.start_with?("+")
+
+          suffix = texture.name[2..]
+          next if sequenced[suffix]
+
+          anims = Array.new(10)
+          alt_anims = Array.new(10)
+          max = add_texture_animation_frame(anims, alt_anims, texture, texture.name)
+          altmax = texture_animation_alt_frame?(texture.name[1]) ? max : 0
+          max = 0 if altmax.positive?
+
+          textures[(index + 1)..]&.each do |other|
+            next unless other&.name&.start_with?("+")
+            next unless other.name[2..] == suffix
+
+            frame = add_texture_animation_frame(anims, alt_anims, other, texture.name)
+            if texture_animation_alt_frame?(other.name[1])
+              altmax = frame if frame > altmax
+            elsif frame > max
+              max = frame
+            end
+          end
+
+          max.times do |frame|
+            raise "Missing frame #{frame} of #{texture.name}" unless anims[frame]
+          end
+          altmax.times do |frame|
+            raise "Missing frame #{frame} of #{texture.name}" unless alt_anims[frame]
+          end
+
+          link_texture_animation_frames(textures, anims, max, alt_anims, altmax)
+          sequenced[suffix] = true
+        end
+      end
+
+      ANIM_CYCLE = 2
+
+      def link_texture_animation_frames(textures, anims, max, alt_anims, altmax)
+        anim_indices = anims.map { |texture| textures.index(texture) }
+        alt_anim_indices = alt_anims.map { |texture| textures.index(texture) }
+
+        max.times do |frame|
+          texture = anims[frame]
+          index = anim_indices[frame]
+          textures[index] = texture.with(
+            anim_total: max * ANIM_CYCLE,
+            anim_min: frame * ANIM_CYCLE,
+            anim_max: (frame + 1) * ANIM_CYCLE,
+            anim_next: anim_indices[(frame + 1) % max],
+            alternate_anims: altmax.positive? ? alt_anim_indices[0] : nil
+          )
+        end
+
+        altmax.times do |frame|
+          texture = alt_anims[frame]
+          index = alt_anim_indices[frame]
+          textures[index] = texture.with(
+            anim_total: altmax * ANIM_CYCLE,
+            anim_min: frame * ANIM_CYCLE,
+            anim_max: (frame + 1) * ANIM_CYCLE,
+            anim_next: alt_anim_indices[(frame + 1) % altmax],
+            alternate_anims: max.positive? ? anim_indices[0] : nil
+          )
+        end
+      end
+
+      def add_texture_animation_frame(anims, alt_anims, texture, error_name)
+        frame = texture_animation_frame(texture.name[1], error_name)
+        if texture_animation_alt_frame?(texture.name[1])
+          alt_anims[frame] = texture
+        else
+          anims[frame] = texture
+        end
+        frame + 1
+      end
+
+      def texture_animation_frame(char, name)
+        normalized = char&.upcase
+        if normalized&.between?("0", "9")
+          normalized.ord - "0".ord
+        elsif normalized&.between?("A", "J")
+          normalized.ord - "A".ord
+        else
+          raise "Bad animating texture #{name}"
+        end
+      end
+
+      def texture_animation_alt_frame?(char)
+        char&.upcase&.between?("A", "J")
       end
     end
   end

data/lib/quake/bsp/types.rb

@@ -4,18 +4,44 @@ module Quake
   module Bsp
     Edge      = Data.define(:v0, :v1)
     Face      = Data.define(:plane_index, :side, :first_edge, :num_edges,
-                            :texinfo_index, :styles, :light_offset)
-    Plane     = Data.define(:normal, :dist, :type)
+                            :texinfo_index, :styles, :light_offset,
+                            :flags, :texture_mins, :extents)
+    Face.const_set(:SURF_PLANEBACK, 2)
+    Face.const_set(:SURF_DRAWSKY, 4)
+    Face.const_set(:SURF_DRAWTURB, 0x10)
+    Face.const_set(:SURF_DRAWTILED, 0x20)
+    Plane     = Data.define(:normal, :dist, :type) do
+      def signbits
+        bits = 0
+        bits |= 1 if normal.x.negative?
+        bits |= 2 if normal.y.negative?
+        bits |= 4 if normal.z.negative?
+        bits
+      end
+    end
     Node      = Data.define(:plane_index, :children, :mins, :maxs,
                             :first_face, :num_faces)
     Leaf      = Data.define(:contents, :vis_offset, :mins, :maxs,
                             :first_marksurface, :num_marksurfaces, :ambient_levels)
     ClipNode  = Data.define(:plane_index, :children)
+    Hull      = Data.define(:first_clipnode, :last_clipnode,
+                            :clip_mins, :clip_maxs)
     TexInfo   = Data.define(:s_vec, :s_offset, :t_vec, :t_offset,
-                            :miptex_index, :flags)
+                            :miptex_index, :flags) do
+      def mipadjust
+        scale = (s_vec.length + t_vec.length) / 2.0
+        return 4 if scale < 0.32
+        return 3 if scale < 0.49
+        return 2 if scale < 0.99
+
+        1
+      end
+    end
     Model     = Data.define(:mins, :maxs, :origin, :head_nodes,
                             :vis_leafs, :first_face, :num_faces)
-    MipTex    = Data.define(:name, :width, :height, :offsets, :pixels)
+    MipTex    = Data.define(:name, :width, :height, :offsets, :pixels,
+                            :anim_total, :anim_min, :anim_max, :anim_next,
+                            :alternate_anims)
 
     # Pre-computed surface data for rendering
     Surface = Data.define(:vertices, :texcoords, :texinfo_index)
@@ -25,6 +51,24 @@ module Quake
       :planes, :nodes, :leafs, :clipnodes,
       :texinfo, :models, :marksurfaces,
       :entities, :visibility, :lighting, :textures
-    )
+    ) do
+      def hulls
+        [
+          nil,
+          Hull.new(
+            first_clipnode: 0,
+            last_clipnode: clipnodes.size - 1,
+            clip_mins: Math::Vec3.new(-16.0, -16.0, -24.0),
+            clip_maxs: Math::Vec3.new(16.0, 16.0, 32.0)
+          ),
+          Hull.new(
+            first_clipnode: 0,
+            last_clipnode: clipnodes.size - 1,
+            clip_mins: Math::Vec3.new(-32.0, -32.0, -24.0),
+            clip_maxs: Math::Vec3.new(32.0, 32.0, 64.0)
+          )
+        ]
+      end
+    end
   end
 end