added trenchbroom and BSP tools

engine/core/src/utils/gameObjectList.zig

@@ -14,6 +14,7 @@ pub const GameObjectInterfaceVTable = struct {
     destroy: *const fn (*anyopaque) void,
     tick: ?*const fn (*anyopaque, f64) void,
     getEntity: ?*const fn (*anyopaque) core.Entity,
+    objectName: []const u8 = "UnknownObject",
 };
 
 pub const GameObjectData = struct {
@@ -40,6 +41,7 @@ pub const GameObjectInterface = struct {
 pub const GameObjectList = struct {
     allocator: std.mem.Allocator,
 
+    // slots might be better? allow for stable indexes?
     objects: std.ArrayListUnmanaged(GameObjectInterface) = .{},
 
     pub fn create(allocator: std.mem.Allocator) !*@This() {
@@ -83,6 +85,7 @@ pub const GameObjectList = struct {
             pub const VTable = GameObjectInterfaceVTable{
                 .tick = if (@hasDecl(T, "tick")) w_tick else null,
                 .getEntity = if (@hasDecl(T, "getEntity")) w_getEntity else null,
+                .objectName = @typeName(T),
                 .destroy = w_destroy,
             };
         };

engine/imgui/src/sgpu/backend_impl.zig

@@ -5,8 +5,6 @@ pub const Impl = struct {
     drawData: [*c]ig.DrawData = undefined,
     rendererDebug: bool = true,
 
-    dtAverage: f64 = 0.0,
-
     pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This());
 
     pub const Settings = struct {
@@ -76,29 +74,8 @@ pub const Impl = struct {
     pub fn preTick(self: *@This(), dt: f64) core.EngineDataEventError!void {
         c.Imgui_SDL3_NewFrame();
         c.igNewFrame();
-
-        core.rollingAverage(&self.dtAverage, dt, 50);
-
-        if (ig.begin("renderer debug", &self.rendererDebug, .{})) {
-            _ = ig.sliderFloat("directional light yaw", &rend.context().directionalLightYaw, 0, 360, null, .{});
-            _ = ig.sliderFloat("skyboxLevel", &rend.context().skyboxSystem.brightnessFactor, 0, 10, null, .{});
-            _ = ig.sliderFloat("lightLevel", &rend.context().lightPower, 0, 100, null, .{});
-            _ = ig.sliderFloat("ortho near", &rend.context().shadowOrthoNear, 0, 200, null, .{});
-            _ = ig.sliderFloat("ortho far", &rend.context().shadowOrthoFar, 0, 6000, null, .{});
-            if (self.dtAverage > 0.000001) {
-                ig.textFmt("frameTime: {d:.2}ms ({d:.2}fps)", .{ self.dtAverage * 1000, @as(u32, @intFromFloat(1 / self.dtAverage)) }) catch return error.UnknownStatePanic;
-            }
-
-            ig.textFmt("SSAO settings: ", .{}) catch unreachable;
-
-            const ssao = rend.context().ssaoSystem;
-            _ = ig.sliderFloat("radius", &ssao.radius, 0.1, 1.0, null, .{});
-            _ = ig.sliderFloat("bias", &ssao.bias, 0.0025, 1.0, null, .{});
-
-            _ = ig.checkbox("enable SSAO", &ssao.enable);
-
-            ig.end();
-        }
+        _ = self;
+        _ = dt;
     }
 
     // renderer plugin

engine/physics/src/physicsCollider.zig

@@ -31,7 +31,7 @@ pub const PhysicsCollider = struct {
 
         settings.shape = shape.shape;
 
-        const scene = self.entity.get(core.Scene).?;
+        const scene = self.entity.fetch(core.Scene).?;
         const p = scene.getPosition();
         // core.engine_log("setting up collider shape {any}", .{p});
         settings.position = .{ p.x, p.y, p.z, 1.0 };

engine/rend/src/rend.zig

@@ -31,6 +31,7 @@ pub const createRendererObject = renderer.createRendererObject;
 pub const registerRendererObject = renderer.registerRendererObject;
 
 pub const getTexture = renderer.getTexture;
+pub const textureExists = renderer.textureExists;
 pub const texture = @import("texture/texture.zig");
 pub const Texture = texture.Texture;
 
@@ -62,3 +63,7 @@ pub fn shutdown_module(allocator: std.mem.Allocator) void {
     _ = allocator;
     renderer.shutdown();
 }
+
+pub fn getMeshPool() *MeshPool {
+    return context().meshPool;
+}

engine/rend/src/sgpu/DebugDrawSystem.zig

@@ -114,7 +114,7 @@ pub fn onUpload(p: *anyopaque, copyPass: *gpu.GPUCopyPass) void {
             .buffer = self.ssbo,
             .offset = 0,
             .size = @intCast(count * @sizeOf(debug_vert.Scene)),
-        }, true);
+        }, false);
     }
 }
 

engine/rend/src/sgpu/TextureList.zig

@@ -13,6 +13,7 @@ allocator: std.mem.Allocator,
 device: *gpu.GPUDevice = undefined,
 
 map: std.AutoHashMapUnmanaged(u32, *Texture) = .{},
+requestMap: std.AutoHashMapUnmanaged(u32, bool) = .{},
 
 pub fn create(allocator: std.mem.Allocator) !*@This() {
     const self = try allocator.create(@This());
@@ -33,6 +34,8 @@ pub fn loadAsset(self: *@This(), assetRef: assets.AssetRef, propertiesBag: ?asse
     var name = assetRef.name;
     core.engine_log("loading texture {s}", .{name.utf8()});
     if (propertiesBag) |bag| {
+        self.requestMap.put(self.allocator, name.handle(), true) catch return error.UnableToLoad; // its always true in here.
+
         var installed: *Texture = undefined;
         if (bag.textureCube) {
             const pathList = bag.textureList.?;
@@ -235,6 +238,7 @@ pub fn destroy(self: *@This()) void {
     while (iter.next()) |x| {
         self.allocator.destroy(x.*);
     }
+    self.requestMap.deinit(self.allocator);
     self.map.deinit(self.allocator);
     self.allocator.destroy(self);
 }

engine/rend/src/sgpu/mesh-pool.zig

@@ -2,6 +2,8 @@ pub const MeshPool = struct {
     allocator: std.mem.Allocator,
 
     meshMap: std.AutoHashMapUnmanaged(u32, rend.IndexedMesh) = .{},
+    invalidations: std.AutoHashMapUnmanaged(u32, rend.IndexedMesh) = .{},
+
     indexSpans: core.MergedSpans,
     vertexSpans: core.MergedSpans,
 
@@ -49,6 +51,22 @@ pub const MeshPool = struct {
         return self;
     }
 
+    pub fn clearInvalidations(self: *@This()) void {
+        var iter = self.invalidations.iterator();
+        while (iter.next()) |n| {
+            const invalidate = n.value_ptr;
+            _ = invalidate;
+            // self.indexSpans.removeSpan(invalidate.index);
+            // self.vertexSpans.removeSpan(invalidate.vertex);
+        }
+
+        self.invalidations.clearRetainingCapacity();
+    }
+
+    pub fn isMeshInvalidated(self: @This(), name: *core.Name) bool {
+        return self.invalidations.contains(name.handle());
+    }
+
     pub fn onUploadCleanup(p: *anyopaque) void {
         const self: *@This() = @ptrCast(@alignCast(p));
 
@@ -71,6 +89,10 @@ pub const MeshPool = struct {
                     var name = new.name;
                     core.engine_log("uploading mesh => {s}", .{name.utf8()});
 
+                    if (self.installedMeshes.get(name.handle())) |installed| {
+                        try self.invalidations.put(self.allocator, name.handle(), installed);
+                    }
+
                     const indexSpan = try self.addTransfer(copyPass, self.indexBuffer, u32, &self.indexSpans, new.indices);
                     const vertexSpan = try self.addTransfer(copyPass, self.vertexBuffer, meshes.MeshVertex, &self.vertexSpans, new.vertices);
 
@@ -143,6 +165,8 @@ pub const MeshPool = struct {
 
     pub fn destroy(p: *anyopaque) void {
         const self: *@This() = @ptrCast(@alignCast(p));
+        self.clearInvalidations();
+        self.invalidations.deinit(self.allocator);
 
         self.device.releaseGPUBuffer(self.indexBuffer);
         self.device.releaseGPUBuffer(self.vertexBuffer);

engine/rend/src/sgpu/renderer.zig

@@ -673,7 +673,7 @@ pub const Renderer = struct {
         for (0..uploadCount) |i| {
             const component = &container.dense.items[i].value;
 
-            if (component.mesh == null) {
+            if (component.mesh == null or self.meshPool.isMeshInvalidated(&component.meshName)) {
                 component.updateMesh();
             }
 
@@ -682,6 +682,8 @@ pub const Renderer = struct {
             }
         }
 
+        self.meshPool.clearInvalidations();
+
         for (self.preDraws.items) |interface| {
             interface.func(interface.ptr, self.state.cmd.?);
         }
@@ -1007,6 +1009,11 @@ pub const RendererState = struct {
     normalTarget: *gpu.GPUTexture = undefined,
 };
 
+pub fn textureExists(name: []const u8) bool {
+    var n = core.MakeName(name);
+    return gRenderer.textureList.requestMap.contains(n.handle());
+}
+
 pub const CustomMeshRenderFunc = *const fn (?*anyopaque) void;
 pub const GPUTextureType = gpu.GPUTexture;
 

extras/bsp/build.zig

@@ -0,0 +1,17 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const mod = b.addModule("bsp", .{
+        .target = target,
+        .optimize = optimize,
+        .root_source_file = b.path("src/bsp.zig"),
+    });
+
+    {
+        const dep = b.dependency("Backlog", .{ .target = target, .optimize = optimize });
+        mod.addImport("Backlog", dep.module("Backlog"));
+    }
+}

extras/bsp/build.zig.zon

@@ -0,0 +1,11 @@
+.{
+    .name = .bsp,
+    .version = "0.0.0",
+    .dependencies = .{
+        .Backlog = .{ .path = "../../" },
+    },
+    .paths = .{
+        "",
+    },
+    .fingerprint = 0xe0059d559d550fd0,
+}

extras/bsp/src/QuakeMap.zig

@@ -0,0 +1,417 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const TokenIterator = std.mem.TokenIterator;
+pub const za = @import("zalgebra/main.zig");
+pub const Vec3 = za.Vec3;
+pub const Vec3d = za.Vec3_f64;
+const core = @import("Backlog").core;
+const logger = std.log.scoped(.quakemap);
+
+const QuakeMap = @This();
+
+worldspawn: Entity,
+entities: std.ArrayList(Entity),
+// uniqueMaterials: std.StringHashMap(u32), // counts for the number
+// of times a material is used.
+
+pub const ErrorInfo = struct {
+    line_number: usize,
+};
+
+pub fn deinit(self: *@This()) void {
+    for (self.entities.items) |*entity| {
+        entity.deinit();
+    }
+    self.worldspawn.deinit();
+    self.entities.deinit();
+}
+
+pub fn read(allocator: Allocator, data: []const u8, error_info: *ErrorInfo) !QuakeMap {
+    var worldspawn: ?Entity = null;
+    var entities = std.ArrayList(Entity).init(allocator);
+    var iter = std.mem.tokenizeAny(u8, data, "\r\n");
+    error_info.line_number = 0;
+    while (iter.next()) |line| {
+        error_info.line_number += 1;
+        switch (line[0]) {
+            '/' => continue,
+            '{' => {
+                const entity = try readEntity(allocator, &iter, error_info);
+                if (std.mem.eql(u8, entity.classname, "worldspawn")) {
+                    worldspawn = entity;
+                } else {
+                    try entities.append(entity);
+                }
+            },
+            else => {
+                std.debug.print("error in line: {d} {s}\n", .{ error_info.line_number, line });
+                return error.UnexpectedToken;
+            },
+        }
+    }
+
+    return .{
+        .worldspawn = worldspawn orelse return error.WorldSpawnNotFound,
+        .entities = entities,
+    };
+}
+
+const Property = struct {
+    key: []const u8,
+    value: []const u8,
+};
+
+pub const Entity = struct {
+    classname: []const u8,
+    spawnflags: u32,
+    properties: std.ArrayList(Property),
+    solids: std.ArrayList(Solid),
+
+    pub fn deinit(self: *@This()) void {
+        for (self.solids.items) |*solid| {
+            solid.faces.deinit();
+        }
+        self.properties.deinit();
+    }
+
+    pub fn init(allocator: Allocator) Entity {
+        return .{
+            .classname = &.{},
+            .spawnflags = 0,
+            .properties = std.ArrayList(Property).init(allocator),
+            .solids = std.ArrayList(Solid).init(allocator),
+        };
+    }
+
+    fn indexOfProperty(self: Entity, key: []const u8) ?usize {
+        for (self.properties.items, 0..) |property, i| {
+            if (std.mem.eql(u8, property.key, key)) {
+                return i;
+            }
+        }
+        return null;
+    }
+
+    pub fn hasProperty(self: Entity, key: []const u8) bool {
+        return self.indexOfProperty(key) != null;
+    }
+
+    pub fn getStringProperty(self: Entity, key: []const u8) ![]const u8 {
+        const i = self.indexOfProperty(key) orelse return error.NotFound;
+        return self.properties.items[i].value;
+    }
+
+    pub fn getIntProperty(self: Entity, key: []const u8) !i32 {
+        const string = try self.getStringProperty(key);
+        return try parseInt(string);
+    }
+
+    pub fn getFloatProperty(self: Entity, key: []const u8) !f32 {
+        const string = try self.getStringProperty(key);
+        return try parseFloat(string);
+    }
+
+    pub fn getVec3Property(self: Entity, key: []const u8) !Vec3 {
+        const string = try self.getStringProperty(key);
+        var it = std.mem.tokenizeScalar(u8, string, ' ');
+        var vec3: Vec3 = undefined;
+        for (0..3) |i| {
+            vec3.data[i] = try parseFloat(it.next() orelse return error.ExpectedFloat);
+        }
+        return vec3;
+    }
+};
+
+pub const Solid = struct {
+    faces: std.ArrayList(Face),
+
+    fn init(allocator: Allocator) Solid {
+        return .{ .faces = std.ArrayList(Face).init(allocator) };
+    }
+
+    fn computeVertices(self: *Solid) !void {
+        const allocator = self.faces.allocator;
+        var buffer: [64]Vec3d = undefined;
+        var vertices = std.ArrayListUnmanaged(Vec3d).initBuffer(buffer[0..32]);
+        var clipped = std.ArrayListUnmanaged(Vec3d).initBuffer(buffer[32..64]);
+        for (self.faces.items, 0..) |*face, i| {
+            const quad = face.plane.makeQuadWithRadius(1000000.0);
+            vertices.clearRetainingCapacity();
+            vertices.appendSliceAssumeCapacity(&quad);
+            // clip with other planes
+            for (self.faces.items, 0..) |clip_face, j| {
+                if (j == i) continue;
+                clipped.clearRetainingCapacity();
+                try clip(vertices, clip_face.plane, &clipped);
+                if (clipped.items.len < 3) return error.DegenerateFace;
+                std.mem.swap(std.ArrayListUnmanaged(Vec3d), &vertices, &clipped);
+            }
+            face.vertices = try allocator.dupe(Vec3d, vertices.items);
+        }
+    }
+
+    fn clip(vertices: std.ArrayListUnmanaged(Vec3d), clip_plane: Plane, clipped: *std.ArrayListUnmanaged(Vec3d)) !void {
+        const epsilon = 0.0001;
+
+        var buffer: [32]f64 = undefined;
+        var distances = std.ArrayListUnmanaged(f64).initBuffer(&buffer);
+        var cb: usize = 0;
+        var cf: usize = 0;
+        for (vertices.items) |vertex| {
+            var distance = clip_plane.normal.dot(vertex) + clip_plane.d;
+            if (distance < -epsilon) {
+                cb += 1;
+            } else if (distance > epsilon) {
+                cf += 1;
+            } else {
+                distance = 0;
+            }
+            distances.appendAssumeCapacity(distance);
+        }
+
+        if (cb == 0 and cf == 0) {
+            // co-planar
+            return;
+        } else if (cb == 0) {
+            // all vertices in front
+            return;
+        } else if (cf == 0) {
+            // all vertices in back;
+            // keep
+            clipped.appendSliceAssumeCapacity(vertices.items);
+            return;
+        }
+
+        for (vertices.items, 0..) |s, i| {
+            const j = (i + 1) % vertices.items.len;
+
+            const e = vertices.items[j];
+            const sd = distances.items[i];
+            const ed = distances.items[j];
+            if (sd <= 0) clipped.appendAssumeCapacity(s); // back
+
+            if ((sd < 0 and ed > 0) or (ed < 0 and sd > 0)) {
+                const t = sd / (sd - ed);
+                var intersect = Vec3d.lerp(s, e, t);
+                // use plane's distance from origin, if plane's normal is a unit vector
+                if (clip_plane.normal.x() == 1) intersect.data[0] = -clip_plane.d;
+                if (clip_plane.normal.x() == -1) intersect.data[0] = clip_plane.d;
+                if (clip_plane.normal.y() == 1) intersect.data[1] = -clip_plane.d;
+                if (clip_plane.normal.y() == -1) intersect.data[1] = clip_plane.d;
+                if (clip_plane.normal.z() == 1) intersect.data[2] = -clip_plane.d;
+                if (clip_plane.normal.z() == -1) intersect.data[2] = clip_plane.d;
+                clipped.appendAssumeCapacity(intersect);
+            }
+        }
+    }
+};
+
+fn closestAxis(v: Vec3d) Vec3d {
+    if (@abs(v.x()) >= @abs(v.y()) and @abs(v.x()) >= @abs(v.z())) return Vec3d.right(); // 1 0 0
+    if (@abs(v.y()) >= @abs(v.z())) return Vec3d.up(); // 0 1 0
+    return Vec3d.forward(); // 0 0 1
+}
+
+pub const Face = struct {
+    plane: Plane,
+    texture_name: []const u8,
+    u_axis: Vec3,
+    v_axis: Vec3,
+    shift_x: f32,
+    shift_y: f32,
+    rotation: f32,
+    scale_x: f32,
+    scale_y: f32,
+    uv_direction: Vec3,
+
+    vertices: []Vec3d,
+};
+
+const Plane = struct {
+    normal: Vec3d,
+    d: f64,
+
+    fn initFromVertices(v0: Vec3d, v1: Vec3d, v2: Vec3d) Plane {
+        const v0v1 = v1.sub(v0);
+        const v0v2 = v2.sub(v0);
+        const normal = Vec3d.cross(v0v1, v0v2).norm();
+        const length = normal.dot(v0);
+        return .{ .normal = normal, .d = -length };
+    }
+
+    fn makeQuadWithRadius(self: Plane, radius: f32) [4]Vec3d {
+        const direction = closestAxis(self.normal);
+        var up = if (direction.z() == 1) Vec3d.right() else Vec3d.new(0, 0, -1);
+        const upv = up.dot(self.normal);
+        up = up.sub(self.normal.scale(upv)).norm();
+        var right = up.cross(self.normal);
+
+        up = up.scale(radius);
+        right = right.scale(radius);
+
+        const origin = self.normal.scale(-self.d);
+        return .{
+            origin.sub(right).sub(up),
+            origin.add(right).sub(up),
+            origin.add(right).add(up),
+            origin.sub(right).add(up),
+        };
+    }
+};
+
+fn readEntity(allocator: Allocator, iter: *TokenIterator(u8, .any), error_info: *ErrorInfo) !Entity {
+    var entity = Entity.init(allocator);
+    while (iter.next()) |line| {
+        error_info.line_number += 1;
+        switch (line[0]) {
+            '/' => continue,
+            '"' => {
+                const property = try readProperty(line);
+                if (std.mem.eql(u8, property.key, "classname")) {
+                    entity.classname = property.value;
+                } else if (std.mem.eql(u8, property.key, "spawnflags")) {
+                    entity.spawnflags = try std.fmt.parseInt(u32, property.value, 10);
+                } else {
+                    try entity.properties.append(property);
+                }
+            },
+            '{' => try entity.solids.append(try readSolid(allocator, iter, error_info)),
+            '}' => break,
+            else => {
+                std.debug.print("error in line: {s}\n", .{line});
+                return error.UnexpectedToken;
+            },
+        }
+    }
+    return entity;
+}
+
+fn readProperty(line: []const u8) !Property {
+    var property: Property = undefined;
+    var iter = std.mem.tokenizeScalar(u8, line, '"');
+    property.key = try readSymbol(&iter);
+    if (!std.mem.eql(u8, iter.next() orelse return error.UnexpectedEof, " ")) return error.ExpectedSpace;
+    property.value = try readSymbol(&iter);
+    return property;
+}
+
+fn readSolid(allocator: Allocator, iter: *TokenIterator(u8, .any), error_info: *ErrorInfo) !Solid {
+    var solid = Solid.init(allocator);
+    while (iter.next()) |line| {
+        error_info.line_number += 1;
+        switch (line[0]) {
+            '/' => continue,
+            '(' => try solid.faces.append(try readFace(line)),
+            '}' => break,
+
+            else => {
+                std.debug.print("error in line: {s}\n", .{line});
+                return error.UnexpectedToken;
+            },
+        }
+    }
+    try solid.computeVertices();
+    return solid;
+}
+
+pub fn calculateRotatedUV(face: Face, u_axis: *Vec3, v_axis: *Vec3) void {
+    const scaled_u_axis = face.u_axis.scale(1.0 / face.scale_x);
+    const scaled_v_axis = face.v_axis.scale(1.0 / face.scale_y);
+
+    const u_mat = za.Mat4.fromTranslate(scaled_u_axis);
+    const v_mat = za.Mat4.fromTranslate(scaled_v_axis);
+
+    const rotation = za.Mat4.fromRotation(face.rotation, face.uv_direction);
+    u_axis.* = rotation.mul(u_mat).extractTranslation();
+    v_axis.* = rotation.mul(v_mat).extractTranslation();
+}
+
+fn readFace(line: []const u8) !Face {
+    var face: Face = undefined;
+    var iter = std.mem.tokenizeScalar(u8, line, ' ');
+    const v0 = try readPoint(&iter);
+    const v1 = try readPoint(&iter);
+    const v2 = try readPoint(&iter);
+    // map planes are clockwise, flip them around when computing the plane to get a counter-clockwise plane
+    face.plane = Plane.initFromVertices(v2, v1, v0);
+    const closestNormal = closestAxis(face.plane.normal);
+
+    face.uv_direction.data = .{
+        @floatCast(closestNormal.data[0]),
+        @floatCast(closestNormal.data[1]),
+        @floatCast(closestNormal.data[2]),
+    };
+
+    face.u_axis = if (closestNormal.x() == 1) Vec3.new(0, 1, 0) else Vec3.new(1, 0, 0);
+    face.v_axis = if (closestNormal.z() == 1) Vec3.new(0, -1, 0) else Vec3.new(0, 0, -1);
+    face.texture_name = try readSymbol(&iter);
+    face.shift_x = try readDecimal(&iter);
+    face.shift_y = try readDecimal(&iter);
+    face.rotation = core.radians(try readDecimal(&iter));
+    face.scale_x = try readDecimal(&iter);
+    face.scale_y = try readDecimal(&iter);
+    return face;
+}
+
+fn readPoint(iter: *TokenIterator(u8, .scalar)) !Vec3d {
+    var point: Vec3d = undefined;
+    if (!std.mem.eql(u8, iter.next() orelse return error.UnexpectedEof, "(")) return error.ExpectedOpenParanthesis;
+    point.data[0] = try readDecimal(iter);
+    point.data[1] = try readDecimal(iter);
+    point.data[2] = try readDecimal(iter);
+    if (!std.mem.eql(u8, iter.next() orelse return error.UnexpectedEof, ")")) return error.ExpectedCloseParanthesis;
+    return point;
+}
+
+fn readDecimal(iter: *TokenIterator(u8, .scalar)) !f32 {
+    const string = iter.next() orelse return error.UnexpectedEof;
+    return try parseFloat(string);
+}
+
+fn readSymbol(iter: *TokenIterator(u8, .scalar)) ![]const u8 {
+    return iter.next() orelse return &.{};
+}
+
+// simpler float parsing function that runs quicker in debug
+fn parseFloat(string: []const u8) !f32 {
+    var signed: bool = false;
+    var decimal_point: usize = string.len - 1;
+    var decimal: f64 = 0;
+    for (string, 0..) |c, i| {
+        switch (c) {
+            '-' => {
+                if (i == 0) signed = true else return error.UnexpectedCharacter;
+            },
+            '0'...'9' => {
+                const digit: f64 = @floatFromInt(c - '0');
+                decimal = 10 * decimal + digit;
+            },
+            '.' => decimal_point = i,
+            else => return error.UnexpectedCharacter,
+        }
+    }
+    if (signed) decimal *= -1;
+    if (decimal_point < string.len - 1) {
+        const denom = std.math.pow(f64, 10, @floatFromInt(string.len - 1 - decimal_point));
+        decimal /= denom;
+    }
+    return @floatCast(decimal);
+}
+
+fn parseInt(string: []const u8) !i32 {
+    var signed: bool = false;
+    var decimal: i32 = 0;
+    for (string, 0..) |c, i| {
+        switch (c) {
+            '-' => {
+                if (i == 0) signed = true else return error.UnexpectedCharacter;
+            },
+            '0'...'9' => {
+                const digit: i32 = @intCast(c - '0');
+                decimal = 10 * decimal + digit;
+            },
+            else => return error.UnexpectedCharacter,
+        }
+    }
+    return decimal;
+}

extras/bsp/src/bsp.zig

@@ -0,0 +1,4 @@
+// top level exporter
+
+pub const QuakeMap = @import("QuakeMap.zig");
+pub const maploader = @import("maploader.zig");

extras/bsp/src/maploader.zig

@@ -0,0 +1,310 @@
+pub const Settings = struct {
+    mapName: []const u8 = "map_",
+    vertexScale: f32 = 1.0 / 32.0,
+    rotation: core.Rotation = .{},
+};
+
+pub const ColliderSpec = struct {
+    name: core.Name,
+};
+
+pub const TBMap = struct {
+    root: core.Entity,
+    meshes: std.ArrayListUnmanaged(core.Entity) = .{}, // each material has its own entity
+    colliders: std.ArrayListUnmanaged(core.Entity) = .{}, // each solid in worldspawn has it's own convex collider
+    colliderSpecs: std.ArrayListUnmanaged(ColliderSpec) = .{},
+    allocator: std.mem.Allocator,
+
+    pub fn create(allocator: std.mem.Allocator) !*@This() {
+        const self = try allocator.create(@This());
+
+        self.* = .{
+            .allocator = allocator,
+            .root = try core.createEntity(),
+        };
+
+        _ = self.root.addComponent(core.Scene).?;
+
+        return self;
+    }
+
+    var fmtBuf: [256]u8 = undefined;
+    var fmtBuf2: [256]u8 = undefined;
+    pub fn addMeshScene(self: *@This(), builder: *MeshBuilder) !void {
+        const newEntity = try core.createEntity();
+        const scene = newEntity.addComponent(core.Scene).?;
+        scene.setParent(self.root);
+
+        const mesh = newEntity.addComponent(rend.MeshComponent).?;
+        mesh.setMesh(builder.meshName.utf8());
+
+        const textureName = try std.fmt.bufPrint(&fmtBuf, "t_map/{s}", .{builder.materialName.utf8()});
+        mesh.setTexture(textureName);
+
+        if (!rend.textureExists(textureName)) {
+            try assets.load(
+                assets.MakeImportRefOptions(
+                    "Texture",
+                    textureName,
+                    // TODO don't hardcode the root path
+                    .{ .path = try std.fmt.bufPrint(&fmtBuf2, "textures/{s}.png", .{builder.materialName.utf8()}) },
+                ),
+            );
+        }
+        // if the texture Does not exist issue an asset load request
+
+        try self.meshes.append(self.allocator, newEntity);
+    }
+
+    pub fn addPhysicsShape(self: *@This(), solid: QuakeMap.Solid, buildSettings: Settings) !void {
+        var floatList: std.ArrayListUnmanaged(f32) = .{};
+        defer floatList.deinit(self.allocator);
+        var vertexCount: u32 = 0;
+        for (solid.faces.items) |face| {
+            for (face.vertices) |vert| {
+                // core.engine_log("adding vertex {any}", .{vert});
+                const position =
+                    core.Vectorf{
+                        .x = @floatCast(vert.data[0]),
+                        .y = @floatCast(vert.data[1]),
+                        .z = @floatCast(vert.data[2]),
+                    };
+                const final = buildSettings.rotation.rotateVector(
+                    position.fmul(buildSettings.vertexScale),
+                );
+
+                try floatList.append(self.allocator, @floatCast(final.x));
+                try floatList.append(self.allocator, @floatCast(final.y));
+                try floatList.append(self.allocator, @floatCast(final.z));
+                vertexCount += 1;
+            }
+        }
+
+        const settings = try physics.ConvexHullShapeSettings.create(
+            @ptrCast(floatList.items.ptr),
+            vertexCount,
+            12,
+        );
+        defer settings.release();
+
+        // settings.setMaxConvexRadius(0.1);
+        var nameBuffer: [256]u8 = undefined;
+
+        const shapeName = try std.fmt.bufPrint(&nameBuffer, "t_map/worldspawn_shape_{d}", .{self.colliderSpecs.items.len});
+
+        try physics.addShape(shapeName, .{ .convexHull = settings });
+
+        try self.colliderSpecs.append(self.allocator, .{
+            .name = core.MakeName(shapeName),
+        });
+
+        {
+            const entity = try core.createEntity();
+            const scene = entity.addComponent(core.Scene).?;
+            scene.setPosition(.{});
+            // scene.setParent(self.root);
+            const collider = entity.addComponent(physics.PhysicsCollider).?;
+            try collider.setupByShapeName(core.MakeName(shapeName), .{
+                .motion_type = .static,
+                .object_layer = physics.ObjectLayers.non_moving,
+                .friction = 0.8,
+            });
+            try self.colliders.append(self.allocator, entity);
+        }
+    }
+
+    pub fn destroy(self: *@This()) void {
+        for (self.meshes.items) |*m| {
+            m.destroy();
+        }
+
+        self.meshes.deinit(self.allocator);
+
+        for (self.colliders.items) |*c| {
+            c.destroy();
+        }
+
+        self.colliders.deinit(self.allocator);
+        for (self.colliderSpecs.items) |spec| {
+            _ = spec;
+            // var name = spec.name;
+            // physics.gPhysicsRuntime.shapes.get(name.handle()).?.shape.release();
+        }
+        self.colliderSpecs.deinit(self.allocator);
+        self.allocator.destroy(self);
+        self.root.destroy();
+    }
+};
+
+// assumed to be consumed by submitMesh(). no deinit provided
+pub const MeshBuilder = struct {
+    materialName: core.Name,
+    meshName: core.Name,
+    vertexOffset: u32 = 0,
+
+    // these three use MeshAlloc
+    meshAlloc: std.mem.Allocator,
+    vertexList: std.ArrayListUnmanaged(rend.MeshVertex) = .{},
+    indexList: std.ArrayListUnmanaged(u32) = .{},
+    jointNames: std.ArrayListUnmanaged(JointNameEntry) = .{},
+    // jointNames intentionally left empty, needed for the vk_meshpool interface.
+    // if i refactor it, this doesnt need to exist anymore, but that takes work...
+
+    pub fn submitMesh(self: *@This()) !void {
+        const newMesh: MeshUpdate = .{
+            .new = .{
+                .vertices = try self.vertexList.toOwnedSlice(self.meshAlloc),
+                .indices = try self.indexList.toOwnedSlice(self.meshAlloc),
+                .name = self.meshName,
+                .jointNames = try self.jointNames.toOwnedSlice(self.meshAlloc),
+                .skeletonName = null,
+            },
+        };
+
+        try rend.renderer.pushMeshUpdate(newMesh);
+    }
+
+    pub fn addFace(self: *@This(), face: QuakeMap.Face, settings: Settings) !void {
+        const indexStart = self.vertexOffset;
+
+        const count = face.vertices.len;
+        const uAxis: Vec3 = face.u_axis;
+        const vAxis: Vec3 = face.v_axis;
+
+        const texSizeX: f32 = 64;
+        const texSizeY: f32 = 64;
+
+        const d10 = face.vertices[1].sub(face.vertices[0]);
+        const d21 = face.vertices[2].sub(face.vertices[1]);
+
+        const n = d10.cross(d21);
+
+        var normal =
+            core.Vectorf{
+                .x = @floatCast(n.data[0]),
+                .y = @floatCast(n.data[1]),
+                .z = @floatCast(n.data[2]),
+            };
+
+        normal = settings.rotation.rotateVector(normal);
+        if (normal.dot(.{ .y = 1.0 }) < 0.5) {
+            // return;
+        }
+
+        // append all vertices to the vertex list
+        for (face.vertices) |vert| {
+            // uv_up axis
+
+            const position =
+                core.Vectorf{
+                    .x = @floatCast(vert.data[0]),
+                    .y = @floatCast(vert.data[1]),
+                    .z = @floatCast(vert.data[2]),
+                };
+
+            const uAxisV = core.Vectorf.fromArray(uAxis.data);
+            const vAxisV = core.Vectorf.fromArray(vAxis.data);
+
+            try self.vertexList.append(self.meshAlloc, .{
+                .position = settings.rotation.rotateVector(
+                    position.fmul(settings.vertexScale),
+                ),
+                // .normal: Vectorf = .{},
+                .normal = normal,
+                .uv = .{
+                    .x = (uAxisV.dot(position) + face.shift_x) / texSizeX,
+                    .y = (vAxisV.dot(position) + face.shift_y) / texSizeY,
+                },
+            });
+
+            self.vertexOffset += 1;
+        }
+
+        // generate ngons
+        try self.indexList.append(self.meshAlloc, indexStart);
+        try self.indexList.append(self.meshAlloc, indexStart + 1);
+        try self.indexList.append(self.meshAlloc, indexStart + 2);
+
+        for (3..count) |j| {
+            const i: u32 = @intCast(j);
+            try self.indexList.append(self.meshAlloc, indexStart);
+            try self.indexList.append(self.meshAlloc, indexStart + i - 1);
+            try self.indexList.append(self.meshAlloc, indexStart + i);
+        }
+    }
+};
+
+pub fn LoadTrenchbroomMap(baseAllocator: std.mem.Allocator, settings: Settings) !*TBMap {
+    var err: QuakeMap.ErrorInfo = undefined;
+    const fileMapping = try core.fs().loadFile(settings.mapName);
+    defer core.fs().unmap(fileMapping);
+
+    var arena = std.heap.ArenaAllocator.init(baseAllocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    const map = try QuakeMap.read(arena.allocator(), fileMapping.bytesNoEnd(), &err);
+
+    var builders: std.AutoHashMapUnmanaged(u32, MeshBuilder) = .{};
+
+    core.engine_log("worldspawn solids count: {d}", .{map.worldspawn.solids.items.len});
+
+    const meshAlloc = rend.getAllocator();
+
+    for (map.worldspawn.solids.items) |solid| {
+        for (solid.faces.items) |face| {
+            var name = core.MakeName(face.texture_name);
+
+            if (!builders.contains(name.handle())) {
+                const meshName = try std.fmt.allocPrint(alloc, "map/m_{s}", .{face.texture_name});
+                try builders.put(alloc, name.handle(), .{
+                    .materialName = name,
+                    .meshName = core.MakeName(meshName),
+                    .meshAlloc = meshAlloc,
+                });
+                core.engine_log("new material found, {s}", .{face.texture_name});
+            }
+        }
+    }
+
+    // loop over all solids and list all materials.
+    // creating a unique mesh for each one
+    for (map.worldspawn.solids.items) |solid| {
+        for (solid.faces.items) |face| {
+            var name = core.MakeName(face.texture_name);
+            const builder = builders.getPtr(name.handle()).?;
+            try builder.addFace(face, settings);
+        }
+    }
+
+    // loop over every vertex in quakeMap and push vertices and indices.
+    const tbMap = try TBMap.create(baseAllocator);
+
+    var iterator = builders.valueIterator();
+    while (iterator.next()) |builder| {
+        try tbMap.addMeshScene(builder);
+        try builder.submitMesh();
+    }
+
+    //
+    //for (map.worldspawn.solids.items) |solid| {
+    //try tbMap.addPhysicsShape(solid, settings);
+    // }
+
+    // loop over all point entities look for info_player_start
+    return tbMap;
+}
+
+const MeshUpdate = rend.MeshUpdate;
+const JointNameEntry = rend.JointNameEntry;
+
+const za = QuakeMap.za;
+const Vec3 = za.Vec3;
+const Vec3d = za.Vec3_f64;
+const QuakeMap = @import("QuakeMap.zig");
+const std = @import("std");
+const backlog = @import("Backlog");
+const rend = backlog.rend;
+const physics = backlog.physics;
+const core = backlog.core;
+const assets = backlog.assets;

extras/bsp/src/zalgebra/generic_vector.zig

@@ -0,0 +1,935 @@
+const std = @import("std");
+const root = @import("main.zig");
+const math = std.math;
+const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
+const panic = std.debug.panic;
+
+pub const Vec2 = GenericVector(2, f32);
+pub const Vec2_f64 = GenericVector(2, f64);
+pub const Vec2_i32 = GenericVector(2, i32);
+pub const Vec2_usize = GenericVector(2, usize);
+
+pub const Vec3 = GenericVector(3, f32);
+pub const Vec3_f64 = GenericVector(3, f64);
+pub const Vec3_i32 = GenericVector(3, i32);
+pub const Vec3_usize = GenericVector(3, usize);
+
+pub const Vec4 = GenericVector(4, f32);
+pub const Vec4_f64 = GenericVector(4, f64);
+pub const Vec4_i32 = GenericVector(4, i32);
+pub const Vec4_usize = GenericVector(4, usize);
+
+/// A generic vector.
+pub fn GenericVector(comptime dimensions: comptime_int, comptime T: type) type {
+    if (@typeInfo(T) != .float and @typeInfo(T) != .int) {
+        @compileError("Vectors not implemented for " ++ @typeName(T));
+    }
+
+    if (dimensions < 2 or dimensions > 4) {
+        @compileError("Dimensions must be 2, 3 or 4!");
+    }
+
+    return extern struct {
+        const Self = @This();
+        const Data = @Vector(dimensions, T);
+
+        data: Data,
+
+        pub const Component = switch (dimensions) {
+            2 => enum { x, y },
+            3 => enum { x, y, z },
+            4 => enum { x, y, z, w },
+            else => unreachable,
+        };
+
+        pub usingnamespace switch (dimensions) {
+            2 => extern struct {
+                /// Construct new vector.
+                pub inline fn new(vx: T, vy: T) Self {
+                    return .{ .data = [2]T{ vx, vy } };
+                }
+
+                /// Rotate vector by angle (in degrees)
+                pub fn rotate(self: Self, angle_in_degrees: T) Self {
+                    const sin_theta = @sin(root.toRadians(angle_in_degrees));
+                    const cos_theta = @cos(root.toRadians(angle_in_degrees));
+                    return .{ .data = [2]T{
+                        cos_theta * self.x() - sin_theta * self.y(),
+                        sin_theta * self.x() + cos_theta * self.y(),
+                    } };
+                }
+
+                pub inline fn toVec3(self: Self, vz: T) GenericVector(3, T) {
+                    return GenericVector(3, T).fromVec2(self, vz);
+                }
+
+                pub inline fn toVec4(self: Self, vz: T, vw: T) GenericVector(4, T) {
+                    return GenericVector(4, T).fromVec2(self, vz, vw);
+                }
+
+                pub inline fn fromVec3(vec3: GenericVector(3, T)) Self {
+                    return Self.new(vec3.x(), vec3.y());
+                }
+
+                pub inline fn fromVec4(vec4: GenericVector(4, T)) Self {
+                    return Self.new(vec4.x(), vec4.y());
+                }
+            },
+            3 => extern struct {
+                /// Construct new vector.
+                pub inline fn new(vx: T, vy: T, vz: T) Self {
+                    return .{ .data = [3]T{ vx, vy, vz } };
+                }
+
+                pub inline fn z(self: Self) T {
+                    return self.data[2];
+                }
+
+                pub inline fn zMut(self: *Self) *T {
+                    return &self.data[2];
+                }
+
+                /// Shorthand for (0, 0, 1).
+                pub fn forward() Self {
+                    return new(0, 0, 1);
+                }
+
+                /// Shorthand for (0, 0, -1).
+                pub fn back() Self {
+                    return forward().negate();
+                }
+
+                /// Construct the cross product (as vector) from two vectors.
+                pub fn cross(first_vector: Self, second_vector: Self) Self {
+                    const x1 = first_vector.x();
+                    const y1 = first_vector.y();
+                    const z1 = first_vector.z();
+
+                    const x2 = second_vector.x();
+                    const y2 = second_vector.y();
+                    const z2 = second_vector.z();
+
+                    const result_x = (y1 * z2) - (z1 * y2);
+                    const result_y = (z1 * x2) - (x1 * z2);
+                    const result_z = (x1 * y2) - (y1 * x2);
+                    return new(result_x, result_y, result_z);
+                }
+
+                pub inline fn toVec2(self: Self) GenericVector(2, T) {
+                    return GenericVector(2, T).fromVec3(self);
+                }
+
+                pub inline fn toVec4(self: Self, vw: T) GenericVector(4, T) {
+                    return GenericVector(4, T).fromVec3(self, vw);
+                }
+
+                pub inline fn fromVec2(vec2: GenericVector(2, T), vz: T) Self {
+                    return Self.new(vec2.x(), vec2.y(), vz);
+                }
+
+                pub inline fn fromVec4(vec4: GenericVector(4, T)) Self {
+                    return Self.new(vec4.x(), vec4.y(), vec4.z());
+                }
+            },
+            4 => extern struct {
+                /// Construct new vector.
+                pub inline fn new(vx: T, vy: T, vz: T, vw: T) Self {
+                    return .{ .data = [4]T{ vx, vy, vz, vw } };
+                }
+
+                /// Shorthand for (0, 0, 1, 0).
+                pub fn forward() Self {
+                    return new(0, 0, 1, 0);
+                }
+
+                /// Shorthand for (0, 0, -1, 0).
+                pub fn back() Self {
+                    return forward().negate();
+                }
+
+                pub inline fn z(self: Self) T {
+                    return self.data[2];
+                }
+
+                pub inline fn w(self: Self) T {
+                    return self.data[3];
+                }
+
+                pub inline fn zMut(self: *Self) *T {
+                    return &self.data[2];
+                }
+
+                pub inline fn wMut(self: *Self) *T {
+                    return &self.data[3];
+                }
+
+                pub inline fn toVec2(self: Self) GenericVector(2, T) {
+                    return GenericVector(2, T).fromVec4(self);
+                }
+
+                pub inline fn toVec3(self: Self) GenericVector(3, T) {
+                    return GenericVector(3, T).fromVec4(self);
+                }
+
+                pub inline fn fromVec2(vec2: GenericVector(2, T), vz: T, vw: T) Self {
+                    return Self.new(vec2.x(), vec2.y(), vz, vw);
+                }
+
+                pub inline fn fromVec3(vec3: GenericVector(3, T), vw: T) Self {
+                    return Self.new(vec3.x(), vec3.y(), vec3.z(), vw);
+                }
+            },
+            else => unreachable,
+        };
+
+        pub inline fn x(self: Self) T {
+            return self.data[0];
+        }
+
+        pub inline fn y(self: Self) T {
+            return self.data[1];
+        }
+
+        pub inline fn xMut(self: *Self) *T {
+            return &self.data[0];
+        }
+
+        pub inline fn yMut(self: *Self) *T {
+            return &self.data[1];
+        }
+
+        /// Set all components to the same given value.
+        pub fn set(val: T) Self {
+            const result: Data = @splat(val);
+            return .{ .data = result };
+        }
+
+        /// Shorthand for (0..).
+        pub fn zero() Self {
+            return set(0);
+        }
+
+        /// Shorthand for (1..).
+        pub fn one() Self {
+            return set(1);
+        }
+
+        /// Shorthand for (0, 1).
+        pub fn up() Self {
+            return switch (dimensions) {
+                2 => Self.new(0, 1),
+                3 => Self.new(0, 1, 0),
+                4 => Self.new(0, 1, 0, 0),
+                else => unreachable,
+            };
+        }
+
+        /// Shorthand for (0, -1).
+        pub fn down() Self {
+            return up().negate();
+        }
+
+        /// Shorthand for (1, 0).
+        pub fn right() Self {
+            return switch (dimensions) {
+                2 => Self.new(1, 0),
+                3 => Self.new(1, 0, 0),
+                4 => Self.new(1, 0, 0, 0),
+                else => unreachable,
+            };
+        }
+
+        /// Shorthand for (-1, 0).
+        pub fn left() Self {
+            return right().negate();
+        }
+
+        /// Negate the given vector.
+        pub fn negate(self: Self) Self {
+            return self.scale(-1);
+        }
+
+        /// Cast a type to another type.
+        /// It's like builtins: @intCast, @floatCast, @floatFromInt, @intFromFloat.
+        pub fn cast(self: Self, comptime dest_type: type) GenericVector(dimensions, dest_type) {
+            const dest_info = @typeInfo(dest_type);
+
+            if (dest_info != .Float and dest_info != .Int) {
+                panic("Error, dest type should be integer or float.\n", .{});
+            }
+
+            var result: [dimensions]dest_type = undefined;
+
+            for (result, 0..) |_, i| {
+                result[i] = math.lossyCast(dest_type, self.data[i]);
+            }
+            return .{ .data = result };
+        }
+
+        /// Construct new vector from slice.
+        pub fn fromSlice(slice: []const T) Self {
+            const result = slice[0..dimensions].*;
+            return .{ .data = result };
+        }
+
+        /// Transform vector to array.
+        pub fn toArray(self: Self) [dimensions]T {
+            return self.data;
+        }
+
+        /// Return the angle (in degrees) between two vectors.
+        pub fn getAngle(first_vector: Self, second_vector: Self) T {
+            const dot_product = dot(norm(first_vector), norm(second_vector));
+            return root.toDegrees(math.acos(dot_product));
+        }
+
+        /// Return the length (magnitude) of given vector.
+        /// √[x^2 + y^2 + z^2 ...]
+        pub fn length(self: Self) T {
+            return @sqrt(self.dot(self));
+        }
+
+        /// Return the distance between two points.
+        /// √[(x1 - x2)^2 + (y1 - y2)^2 + (z1 - z2)^2 ...]
+        pub fn distance(first_vector: Self, second_vector: Self) T {
+            return length(first_vector.sub(second_vector));
+        }
+
+        /// Construct new normalized vector from a given one.
+        pub fn norm(self: Self) Self {
+            const l = self.length();
+            if (l == 0) {
+                return self;
+            }
+            const result = self.data / @as(Data, @splat(l));
+            return .{ .data = result };
+        }
+
+        /// Return true if two vectors are equals.
+        pub fn eql(first_vector: Self, second_vector: Self) bool {
+            return @reduce(.And, first_vector.data == second_vector.data);
+        }
+
+        /// Substraction between two given vector.
+        pub fn sub(first_vector: Self, second_vector: Self) Self {
+            const result = first_vector.data - second_vector.data;
+            return .{ .data = result };
+        }
+
+        /// Addition betwen two given vector.
+        pub fn add(first_vector: Self, second_vector: Self) Self {
+            const result = first_vector.data + second_vector.data;
+            return .{ .data = result };
+        }
+
+        /// Component wise multiplication betwen two given vector.
+        pub fn mul(first_vector: Self, second_vector: Self) Self {
+            const result = first_vector.data * second_vector.data;
+            return .{ .data = result };
+        }
+
+        /// Construct vector from the max components in two vectors
+        pub fn max(first_vector: Self, second_vector: Self) Self {
+            const result = @max(first_vector.data, second_vector.data);
+            return .{ .data = result };
+        }
+
+        /// Construct vector from the min components in two vectors
+        pub fn min(first_vector: Self, second_vector: Self) Self {
+            const result = @min(first_vector.data, second_vector.data);
+            return .{ .data = result };
+        }
+
+        /// Construct new vector after multiplying each components by a given scalar
+        pub fn scale(self: Self, scalar: T) Self {
+            const result = self.data * @as(Data, @splat(scalar));
+            return .{ .data = result };
+        }
+
+        /// Return the dot product between two given vector.
+        /// (x1 * x2) + (y1 * y2) + (z1 * z2) ...
+        pub fn dot(first_vector: Self, second_vector: Self) T {
+            return @reduce(.Add, first_vector.data * second_vector.data);
+        }
+
+        /// Linear interpolation between two vectors
+        pub fn lerp(first_vector: Self, second_vector: Self, t: T) Self {
+            const from = first_vector.data;
+            const to = second_vector.data;
+
+            const result = from + (to - from) * @as(Data, @splat(t));
+            return .{ .data = result };
+        }
+
+        pub inline fn swizzle2(self: Self, comptime vx: Component, comptime vy: Component) GenericVector(2, T) {
+            return GenericVector(2, T).new(self.data[@intFromEnum(vx)], self.data[@intFromEnum(vy)]);
+        }
+
+        pub inline fn swizzle3(self: Self, comptime vx: Component, comptime vy: Component, comptime vz: Component) GenericVector(3, T) {
+            return GenericVector(3, T).new(self.data[@intFromEnum(vx)], self.data[@intFromEnum(vy)], self.data[@intFromEnum(vz)]);
+        }
+
+        pub inline fn swizzle4(self: Self, comptime vx: Component, comptime vy: Component, comptime vz: Component, comptime vw: Component) GenericVector(4, T) {
+            return GenericVector(4, T).new(self.data[@intFromEnum(vx)], self.data[@intFromEnum(vy)], self.data[@intFromEnum(vz)], self.data[@intFromEnum(vw)]);
+        }
+    };
+}
+
+test "zalgebra.Vectors.eql" {
+    // Vec2
+    {
+        const a = Vec2.new(1, 2);
+        const b = Vec2.new(1, 2);
+        const c = Vec2.new(1.5, 2);
+
+        try expectEqual(Vec2.eql(a, b), true);
+        try expectEqual(Vec2.eql(a, c), false);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(1, 2, 3);
+        const b = Vec3.new(1, 2, 3);
+        const c = Vec3.new(1.5, 2, 3);
+
+        try expectEqual(Vec3.eql(a, b), true);
+        try expectEqual(Vec3.eql(a, c), false);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(1, 2, 3, 4);
+        const b = Vec4.new(1, 2, 3, 4);
+        const c = Vec4.new(1.5, 2, 3, 4);
+
+        try expectEqual(Vec4.eql(a, b), true);
+        try expectEqual(Vec4.eql(a, c), false);
+    }
+}
+
+test "zalgebra.Vectors.set" {
+    // Vec2
+    {
+        const a = Vec2.new(2.5, 2.5);
+        const b = Vec2.set(2.5);
+        try expectEqual(a, b);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(2.5, 2.5, 2.5);
+        const b = Vec3.set(2.5);
+        try expectEqual(a, b);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(2.5, 2.5, 2.5, 2.5);
+        const b = Vec4.set(2.5);
+        try expectEqual(a, b);
+    }
+}
+
+test "zalgebra.Vectors.add" {
+    // Vec2
+    {
+        const a = Vec2.one();
+        const b = Vec2.one();
+        try expectEqual(a.add(b), Vec2.set(2));
+    }
+
+    // Vec3
+    {
+        const a = Vec3.one();
+        const b = Vec3.one();
+        try expectEqual(a.add(b), Vec3.set(2));
+    }
+
+    // Vec4
+    {
+        const a = Vec4.one();
+        const b = Vec4.one();
+        try expectEqual(a.add(b), Vec4.set(2));
+    }
+}
+
+test "zalgebra.Vectors.negate" {
+    // Vec2
+    {
+        const a = Vec2.set(5);
+        const a_negated = Vec2.set(-5);
+        try expectEqual(a.negate(), a_negated);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.set(5);
+        const a_negated = Vec3.set(-5);
+        try expectEqual(a.negate(), a_negated);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.set(5);
+        const a_negated = Vec4.set(-5);
+        try expectEqual(a.negate(), a_negated);
+    }
+}
+
+test "zalgebra.Vectors.getAngle" {
+    // Vec2
+    {
+        const a = Vec2.right();
+        const b = Vec2.up();
+        const c = Vec2.left();
+        const d = Vec2.one();
+
+        try expectEqual(a.getAngle(a), 0);
+        try expectEqual(a.getAngle(b), 90);
+        try expectEqual(a.getAngle(c), 180);
+        try expectEqual(a.getAngle(d), 45);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.right();
+        const b = Vec3.up();
+        const c = Vec3.left();
+        const d = Vec3.new(1, 1, 0);
+
+        try expectEqual(a.getAngle(a), 0);
+        try expectEqual(a.getAngle(b), 90);
+        try expectEqual(a.getAngle(c), 180);
+        try expectEqual(a.getAngle(d), 45);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.right();
+        const b = Vec4.up();
+        const c = Vec4.left();
+        const d = Vec4.new(1, 1, 0, 0);
+
+        try expectEqual(a.getAngle(a), 0);
+        try expectEqual(a.getAngle(b), 90);
+        try expectEqual(a.getAngle(c), 180);
+        try expectEqual(a.getAngle(d), 45);
+    }
+}
+
+test "zalgebra.Vectors.toArray" {
+    //Vec2
+    {
+        const a = Vec2.up().toArray();
+        const b = [_]f32{ 0, 1 };
+
+        try std.testing.expectEqualSlices(f32, &a, &b);
+    }
+
+    //Vec3
+    {
+        const a = Vec3.up().toArray();
+        const b = [_]f32{ 0, 1, 0 };
+
+        try std.testing.expectEqualSlices(f32, &a, &b);
+    }
+
+    //Vec4
+    {
+        const a = Vec4.up().toArray();
+        const b = [_]f32{ 0, 1, 0, 0 };
+
+        try std.testing.expectEqualSlices(f32, &a, &b);
+    }
+}
+
+test "zalgebra.Vectors.length" {
+    // Vec2
+    {
+        const a = Vec2.new(1.5, 2.6);
+        try expectEqual(a.length(), 3.00166606);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(1.5, 2.6, 3.7);
+        try expectEqual(a.length(), 4.7644519);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(1.5, 2.6, 3.7, 4.7);
+        try expectEqual(a.length(), 6.69253301);
+    }
+}
+
+test "zalgebra.Vectors.distance" {
+    // Vec2
+    {
+        const a = Vec2.zero();
+        const b = Vec2.left();
+        const c = Vec2.new(0, 5);
+
+        try expectEqual(a.distance(b), 1);
+        try expectEqual(a.distance(c), 5);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.zero();
+        const b = Vec3.left();
+        const c = Vec3.new(0, 5, 0);
+
+        try expectEqual(a.distance(b), 1);
+        try expectEqual(a.distance(c), 5);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.zero();
+        const b = Vec4.left();
+        const c = Vec4.new(0, 5, 0, 0);
+
+        try expectEqual(a.distance(b), 1);
+        try expectEqual(a.distance(c), 5);
+    }
+}
+
+test "zalgebra.Vectors.normalize" {
+    // Vec2
+    {
+        const a = Vec2.new(1.5, 2.6);
+        const a_normalized = Vec2.new(0.499722480, 0.866185605);
+        try expectEqual(a.norm(), a_normalized);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(1.5, 2.6, 3.7);
+        const a_normalized = Vec3.new(0.314831584, 0.545708060, 0.776584625);
+        try expectEqual(a.norm(), a_normalized);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(1.5, 2.6, 3.7, 4.0);
+        const a_normalized = Vec4.new(0.241121411, 0.417943745, 0.594766139, 0.642990410);
+        try expectEqual(a.norm(), a_normalized);
+    }
+}
+
+test "zalgebra.Vectors.scale" {
+    // Vec2
+    {
+        const a = Vec2.new(1, 2);
+        const a_scaled = Vec2.new(5, 10);
+        try expectEqual(a.scale(5), a_scaled);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(1, 2, 3);
+        const a_scaled = Vec3.new(5, 10, 15);
+        try expectEqual(a.scale(5), a_scaled);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(1, 2, 3, 4);
+        const a_scaled = Vec4.new(5, 10, 15, 20);
+        try expectEqual(a.scale(5), a_scaled);
+    }
+}
+
+test "zalgebra.Vectors.dot" {
+    // Vec2
+    {
+        const a = Vec2.new(1.5, 2.6);
+        const b = Vec2.new(2.5, 3.45);
+        try expectEqual(a.dot(b), 12.7200002);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(1.5, 2.6, 3.7);
+        const b = Vec3.new(2.5, 3.45, 1.0);
+        try expectEqual(a.dot(b), 16.42);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(1.5, 2.6, 3.7, 5);
+        const b = Vec4.new(2.5, 3.45, 1.0, 1);
+        try expectEqual(a.dot(b), 21.4200000);
+    }
+}
+
+test "zalgebra.Vectors.lerp" {
+    // Vec2
+    {
+        const a = Vec2.new(-10, 0);
+        const b = Vec2.set(10);
+        try expectEqual(Vec2.lerp(a, b, 0.5), Vec2.new(0, 5));
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(-10, 0, -10);
+        const b = Vec3.set(10);
+        try expectEqual(Vec3.lerp(a, b, 0.5), Vec3.new(0, 5, 0));
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(-10, 0, -10, -10);
+        const b = Vec4.set(10);
+        try expectEqual(Vec4.lerp(a, b, 0.5), Vec4.new(0, 5, 0, 0));
+    }
+}
+
+test "zalgebra.Vectors.min" {
+    // Vec2
+    {
+        const a = Vec2.new(10, -2);
+        const b = Vec2.new(-10, 5);
+        const minimum = Vec2.new(-10, -2);
+        try expectEqual(Vec2.min(a, b), minimum);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(10, -2, 0);
+        const b = Vec3.new(-10, 5, 0);
+        const minimum = Vec3.new(-10, -2, 0);
+        try expectEqual(Vec3.min(a, b), minimum);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(10, -2, 0, 1);
+        const b = Vec4.new(-10, 5, 0, 1.01);
+        const minimum = Vec4.new(-10, -2, 0, 1);
+        try expectEqual(Vec4.min(a, b), minimum);
+    }
+}
+
+test "zalgebra.Vectors.max" {
+    // Vec2
+    {
+        const a = Vec2.new(10, -2);
+        const b = Vec2.new(-10, 5);
+        const maximum = Vec2.new(10, 5);
+        try expectEqual(Vec2.max(a, b), maximum);
+    }
+
+    // Vec3
+    {
+        const a = Vec3.new(10, -2, 0);
+        const b = Vec3.new(-10, 5, 0);
+        const maximum = Vec3.new(10, 5, 0);
+        try expectEqual(Vec3.max(a, b), maximum);
+    }
+
+    // Vec4
+    {
+        const a = Vec4.new(10, -2, 0, 1);
+        const b = Vec4.new(-10, 5, 0, 1.01);
+        const maximum = Vec4.new(10, 5, 0, 1.01);
+        try expectEqual(Vec4.max(a, b), maximum);
+    }
+}
+
+test "zalgebra.Vectors.fromSlice" {
+    // Vec2
+    {
+        const slice = [_]f32{ 2, 4 };
+        try expectEqual(Vec2.fromSlice(&slice), Vec2.new(2, 4));
+    }
+
+    // Vec3
+    {
+        const slice = [_]f32{ 2, 4, 3 };
+        try expectEqual(Vec3.fromSlice(&slice), Vec3.new(2, 4, 3));
+    }
+
+    // Vec4
+    {
+        const slice = [_]f32{ 2, 4, 3, 6 };
+        try expectEqual(Vec4.fromSlice(&slice), Vec4.new(2, 4, 3, 6));
+    }
+}
+
+test "zalgebra.Vectors.cast" {
+    // Vec2
+    {
+        const a = Vec2_i32.new(3, 6);
+        const a_usize = Vec2_usize.new(3, 6);
+        try expectEqual(a.cast(usize), a_usize);
+
+        const b = Vec2.new(3.5, 6.5);
+        const b_f64 = Vec2_f64.new(3.5, 6.5);
+        try expectEqual(b.cast(f64), b_f64);
+
+        const c = Vec2_i32.new(3, 6);
+        const c_f32 = Vec2.new(3, 6);
+        try expectEqual(c.cast(f32), c_f32);
+
+        const d = Vec2.new(3, 6);
+        const d_i32 = Vec2_i32.new(3, 6);
+        try expectEqual(d.cast(i32), d_i32);
+    }
+
+    // Vec3
+    {
+        const a = Vec3_i32.new(3, 6, 2);
+        const a_usize = Vec3_usize.new(3, 6, 2);
+        try expectEqual(a.cast(usize), a_usize);
+
+        const b = Vec3.new(3.5, 6.5, 2);
+        const b_f64 = Vec3_f64.new(3.5, 6.5, 2);
+        try expectEqual(b.cast(f64), b_f64);
+
+        const c = Vec3_i32.new(3, 6, 2);
+        const c_f32 = Vec3.new(3, 6, 2);
+        try expectEqual(c.cast(f32), c_f32);
+
+        const d = Vec3.new(3, 6, 2);
+        const d_i32 = Vec3_i32.new(3, 6, 2);
+        try expectEqual(d.cast(i32), d_i32);
+    }
+
+    // Vec4
+    {
+        const a = Vec4_i32.new(3, 6, 2, 0);
+        const a_usize = Vec4_usize.new(3, 6, 2, 0);
+        try expectEqual(a.cast(usize), a_usize);
+
+        const b = Vec4.new(3.5, 6.5, 2, 0);
+        const b_f64 = Vec4_f64.new(3.5, 6.5, 2, 0);
+        try expectEqual(b.cast(f64), b_f64);
+
+        const c = Vec4_i32.new(3, 6, 2, 0);
+        const c_f32 = Vec4.new(3, 6, 2, 0);
+        try expectEqual(c.cast(f32), c_f32);
+
+        const d = Vec4.new(3, 6, 2, 0);
+        const d_i32 = Vec4_i32.new(3, 6, 2, 0);
+        try expectEqual(d.cast(i32), d_i32);
+    }
+}
+
+test "zalgebra.Vectors.cross" {
+    // Only for Vec3
+    const a = Vec3.new(1.5, 2.6, 3.7);
+    const b = Vec3.new(2.5, 3.45, 1.0);
+    const c = Vec3.new(1.5, 2.6, 3.7);
+
+    const result_1 = Vec3.cross(a, c);
+    const result_2 = Vec3.cross(a, b);
+
+    try expectEqual(result_1, Vec3.zero());
+    try expectEqual(result_2, Vec3.new(-10.1650009, 7.75, -1.32499980));
+}
+
+test "vector conversions 2 -> 3 -> 4" {
+    const v2 = Vec2.new(1, 2);
+    var v3 = Vec3.fromVec2(v2, 3);
+    var v4 = Vec4.fromVec3(v3, 4);
+
+    try expectEqual(v3, Vec3.new(1, 2, 3));
+    try expectEqual(v4, Vec4.new(1, 2, 3, 4));
+
+    v3 = v2.toVec3(3);
+    v4 = v2.toVec4(3, 4);
+
+    try expectEqual(v3, Vec3.new(1, 2, 3));
+    try expectEqual(v4, Vec4.new(1, 2, 3, 4));
+}
+
+test "vector conversions 4 -> 3 -> 2" {
+    const v4 = Vec4.new(1, 2, 3, 4);
+    var v3 = Vec3.fromVec4(v4);
+    var v2 = Vec2.fromVec3(v3);
+
+    try expectEqual(v3, Vec3.new(1, 2, 3));
+    try expectEqual(v2, Vec2.new(1, 2));
+
+    v3 = v4.toVec3();
+    v2 = v4.toVec2();
+
+    try expectEqual(v3, Vec3.new(1, 2, 3));
+    try expectEqual(v2, Vec2.new(1, 2));
+}
+
+test "vector conversions 2 -> 4" {
+    const v2 = Vec2.new(1, 2);
+    var v4 = Vec4.fromVec2(v2, 3, 4);
+
+    try expectEqual(v4, Vec4.new(1, 2, 3, 4));
+
+    v4 = v2.toVec4(3, 4);
+
+    try expectEqual(v4, Vec4.new(1, 2, 3, 4));
+}
+
+test "vector conversions 4 -> 2" {
+    const v4 = Vec4.new(1, 2, 3, 4);
+    var v2 = Vec2.fromVec4(v4);
+
+    try expectEqual(v2, Vec2.new(1, 2));
+
+    v2 = v4.toVec2();
+
+    try expectEqual(v2, Vec2.new(1, 2));
+}
+
+// Just touching every component
+// not testing every combination cause it's too many
+test "swizzle2" {
+    const v2 = Vec2.new(1, 2);
+    const yx = v2.swizzle2(.y, .x);
+    try expectEqual(Vec2.new(2, 1), yx);
+
+    const v3 = Vec3.new(1, 2, 3);
+    const zy = v3.swizzle2(.z, .y);
+    const xx = v3.swizzle2(.x, .x);
+    try expectEqual(Vec2.new(3, 2), zy);
+    try expectEqual(Vec2.new(1, 1), xx);
+
+    const v4 = Vec4.new(1, 2, 3, 4);
+    const wz = v4.swizzle2(.w, .z);
+    const xy = v4.swizzle2(.x, .y);
+    try expectEqual(Vec2.new(4, 3), wz);
+    try expectEqual(Vec2.new(1, 2), xy);
+}
+
+test "swizzle3" {
+    const v2 = Vec2.new(1, 2);
+    const yxy = v2.swizzle3(.y, .x, .y);
+    try expectEqual(Vec3.new(2, 1, 2), yxy);
+
+    const v3 = Vec3.new(1, 2, 3);
+    const zyx = v3.swizzle3(.z, .y, .x);
+    try expectEqual(Vec3.new(3, 2, 1), zyx);
+
+    const v4 = Vec4.new(1, 2, 3, 4);
+    const wzy = v4.swizzle3(.w, .z, .y);
+    const xxx = v4.swizzle3(.x, .x, .x);
+    try expectEqual(Vec3.new(4, 3, 2), wzy);
+    try expectEqual(Vec3.new(1, 1, 1), xxx);
+}
+
+test "swizzle4" {
+    const v2 = Vec2.new(1, 2);
+    const yxyx = v2.swizzle4(.y, .x, .y, .x);
+    try expectEqual(Vec4.new(2, 1, 2, 1), yxyx);
+
+    const v3 = Vec3.new(1, 2, 3);
+    const zyxz = v3.swizzle4(.z, .y, .x, .z);
+    try expectEqual(Vec4.new(3, 2, 1, 3), zyxz);
+
+    const v4 = Vec4.new(1, 2, 3, 4);
+    const wzyx = v4.swizzle4(.w, .z, .y, .x);
+    try expectEqual(Vec4.new(4, 3, 2, 1), wzyx);
+}

extras/bsp/src/zalgebra/main.zig

@@ -0,0 +1,72 @@
+//! Math utilities for graphics.
+//!
+const std = @import("std");
+const expectEqual = std.testing.expectEqual;
+const math = std.math;
+
+pub usingnamespace @import("generic_vector.zig");
+pub usingnamespace @import("mat3.zig");
+pub usingnamespace @import("mat4.zig");
+pub usingnamespace @import("quaternion.zig");
+
+/// Convert degrees to radians.
+pub fn toRadians(degrees: anytype) @TypeOf(degrees) {
+    const T = @TypeOf(degrees);
+
+    if (@typeInfo(T) != .Float) {
+        @compileError("Radians not implemented for " ++ @typeName(T));
+    }
+
+    return degrees * (math.pi / 180.0);
+}
+
+/// Convert radians to degrees.
+pub fn toDegrees(radians: anytype) @TypeOf(radians) {
+    const T = @TypeOf(radians);
+
+    if (@typeInfo(T) != .Float) {
+        @compileError("Radians not implemented for " ++ @typeName(T));
+    }
+
+    return radians * (180.0 / math.pi);
+}
+
+/// Linear interpolation between two floats.
+/// `t` is used to interpolate between `from` and `to`.
+pub fn lerp(comptime T: type, from: T, to: T, t: T) T {
+    if (@typeInfo(T) != .Float) {
+        @compileError("Lerp not implemented for " ++ @typeName(T));
+    }
+
+    return (1 - t) * from + t * to;
+}
+
+test "zalgebra.toRadians" {
+    try expectEqual(toRadians(@as(f32, 0)), 0);
+    try expectEqual(toRadians(@as(f32, 30)), 0.523598790);
+    try expectEqual(toRadians(@as(f32, 45)), 0.78539818);
+    try expectEqual(toRadians(@as(f32, 60)), 1.04719758);
+    try expectEqual(toRadians(@as(f32, 90)), 1.57079637); //math.pi / 2
+    try expectEqual(toRadians(@as(f32, 180)), 3.14159274); //math.pi
+    try expectEqual(toRadians(@as(f32, 270)), 4.71238899);
+    try expectEqual(toRadians(@as(f32, 360)), 6.28318548); //math.pi * 2
+}
+
+test "zalgebra.toDegrees" {
+    try expectEqual(toDegrees(@as(f32, 0)), 0);
+    try expectEqual(toDegrees(@as(f32, 0.5)), 28.6478900);
+    try expectEqual(toDegrees(@as(f32, 1)), 57.2957801);
+    try expectEqual(toDegrees(@as(f32, 1.57079637)), 90); //math.pi / 2
+    try expectEqual(toDegrees(@as(f32, 3.14159274)), 180); //math.pi
+    try expectEqual(toDegrees(@as(f32, 4.71238899)), 270);
+    try expectEqual(toDegrees(@as(f32, 6.28318548)), 360); //math.pi * 2
+}
+
+test "zalgebra.lerp" {
+    const from: f32 = 0;
+    const to: f32 = 10;
+
+    try expectEqual(lerp(f32, from, to, 0), 0);
+    try expectEqual(lerp(f32, from, to, 0.5), 5);
+    try expectEqual(lerp(f32, from, to, 1), 10);
+}

extras/bsp/src/zalgebra/mat3.zig

@@ -0,0 +1,452 @@
+const std = @import("std");
+const math = std.math;
+const meta = std.meta;
+const mem = std.mem;
+const expectEqual = std.testing.expectEqual;
+const root = @import("main.zig");
+const generic_vector = @import("generic_vector.zig");
+const quat = @import("quaternion.zig");
+
+const Vec3 = generic_vector.Vec3;
+const Vec3_f64 = generic_vector.Vec3_f64;
+const GenericVector = generic_vector.GenericVector;
+const Quaternion = quat.Quaternion;
+const Quat = quat.Quat;
+
+pub const Mat3 = Mat3x3(f32);
+pub const Mat3_f64 = Mat3x3(f64);
+
+/// A column-major 3x3 matrix
+/// Note: Column-major means accessing data like m.data[COLUMN][ROW].
+pub fn Mat3x3(comptime T: type) type {
+    if (@typeInfo(T) != .Float) {
+        @compileError("Mat3x3 not implemented for " ++ @typeName(T));
+    }
+
+    const Vector3 = GenericVector(3, T);
+
+    return extern struct {
+        data: [3][3]T,
+
+        const Self = @This();
+
+        /// Shorthand for identity matrix.
+        pub fn identity() Self {
+            return .{
+                .data = .{
+                    .{ 1, 0, 0 },
+                    .{ 0, 1, 0 },
+                    .{ 0, 0, 1 },
+                },
+            };
+        }
+
+        /// Shorthand for matrix with all zeros.
+        pub fn zero() Self {
+            return Self.set(0);
+        }
+
+        /// Set all mat3 values to given value.
+        pub fn set(value: T) Self {
+            const data: [9]T = .{value} ** 9;
+            return Self.fromSlice(&data);
+        }
+
+        /// Construct new 3x3 matrix from given slice.
+        pub fn fromSlice(data: *const [9]T) Self {
+            return .{
+                .data = .{
+                    data[0..3].*,
+                    data[3..6].*,
+                    data[6..9].*,
+                },
+            };
+        }
+
+        /// Negate the given matrix.
+        pub fn negate(self: Self) Self {
+            var result = self;
+            for (0..result.data.len) |column| {
+                for (0..result.data[column].len) |row| {
+                    result.data[column][row] = -result.data[column][row];
+                }
+            }
+            return result;
+        }
+
+        /// Transpose the given matrix.
+        pub fn transpose(self: Self) Self {
+            var result = self;
+            for (0..result.data.len) |column| {
+                for (column..result.data[column].len) |row| {
+                    std.mem.swap(T, &result.data[column][row], &result.data[row][column]);
+                }
+            }
+            return result;
+        }
+
+        /// Return a pointer to the inner data of the matrix.
+        pub fn getData(self: *const Self) *const T {
+            return @ptrCast(&self.data);
+        }
+
+        /// Return true if two matrices are equals.
+        pub fn eql(left: Self, right: Self) bool {
+            return meta.eql(left, right);
+        }
+
+        pub fn mulByVec3(self: Self, v: Vector3) Vector3 {
+            const x = (self.data[0][0] * v.x()) + (self.data[1][0] * v.y()) + (self.data[2][0] * v.z());
+            const y = (self.data[0][1] * v.x()) + (self.data[1][1] * v.y()) + (self.data[2][1] * v.z());
+            const z = (self.data[0][2] * v.x()) + (self.data[1][2] * v.y()) + (self.data[2][2] * v.z());
+
+            return Vector3.new(x, y, z);
+        }
+
+        /// Construct a 3x3 matrix from given axis and angle (in degrees).
+        pub fn fromRotation(angle_in_degrees: T, axis: Vector3) Self {
+            var result = Self.identity();
+
+            const norm_axis = axis.norm();
+
+            const sin_theta = @sin(root.toRadians(angle_in_degrees));
+            const cos_theta = @cos(root.toRadians(angle_in_degrees));
+            const cos_value = 1 - cos_theta;
+
+            const x = norm_axis.x();
+            const y = norm_axis.y();
+            const z = norm_axis.z();
+
+            result.data[0][0] = (x * x * cos_value) + cos_theta;
+            result.data[0][1] = (x * y * cos_value) + (z * sin_theta);
+            result.data[0][2] = (x * z * cos_value) - (y * sin_theta);
+
+            result.data[1][0] = (y * x * cos_value) - (z * sin_theta);
+            result.data[1][1] = (y * y * cos_value) + cos_theta;
+            result.data[1][2] = (y * z * cos_value) + (x * sin_theta);
+
+            result.data[2][0] = (z * x * cos_value) + (y * sin_theta);
+            result.data[2][1] = (z * y * cos_value) - (x * sin_theta);
+            result.data[2][2] = (z * z * cos_value) + cos_theta;
+
+            return result;
+        }
+
+        pub fn rotate(self: Self, angle_in_degrees: T, axis: Vector3) Self {
+            const rotation_mat = Self.fromRotation(angle_in_degrees, axis);
+            return Self.mul(self, rotation_mat);
+        }
+
+        /// Construct a rotation matrix from euler angles (X * Y * Z).
+        /// Order matters because matrix multiplication are NOT commutative.
+        pub fn fromEulerAngles(euler_angle: Vector3) Self {
+            const x = Self.fromRotation(euler_angle.x(), Vector3.right());
+            const y = Self.fromRotation(euler_angle.y(), Vector3.up());
+            const z = Self.fromRotation(euler_angle.z(), Vector3.forward());
+
+            return z.mul(y.mul(x));
+        }
+
+        /// Ortho normalize given matrix.
+        pub fn orthoNormalize(self: Self) Self {
+            const column_1 = Vector3.new(self.data[0][0], self.data[0][1], self.data[0][2]).norm();
+            const column_2 = Vector3.new(self.data[1][0], self.data[1][1], self.data[1][2]).norm();
+            const column_3 = Vector3.new(self.data[2][0], self.data[2][1], self.data[2][2]).norm();
+
+            var result = self;
+
+            result.data[0][0] = column_1.x();
+            result.data[0][1] = column_1.y();
+            result.data[0][2] = column_1.z();
+
+            result.data[1][0] = column_2.x();
+            result.data[1][1] = column_2.y();
+            result.data[1][2] = column_2.z();
+
+            result.data[2][0] = column_3.x();
+            result.data[2][1] = column_3.y();
+            result.data[2][2] = column_3.z();
+
+            return result;
+        }
+
+        /// Return the rotation as Euler angles in degrees.
+        /// Taken from Mike Day at Insomniac Games (and `glm` as the same function).
+        /// For more details: https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2012/07/euler-angles1.pdf
+        pub fn extractEulerAngles(self: Self) Vector3 {
+            const m = self.orthoNormalize();
+
+            const theta_x = math.atan2(m.data[1][2], m.data[2][2]);
+            const c2 = @sqrt(math.pow(T, m.data[0][0], 2) + math.pow(T, m.data[0][1], 2));
+            const theta_y = math.atan2(-m.data[0][2], @sqrt(c2));
+            const s1 = @sin(theta_x);
+            const c1 = @cos(theta_x);
+            const theta_z = math.atan2(s1 * m.data[2][0] - c1 * m.data[1][0], c1 * m.data[1][1] - s1 * m.data[2][1]);
+
+            return Vector3.new(root.toDegrees(theta_x), root.toDegrees(theta_y), root.toDegrees(theta_z));
+        }
+
+        pub fn fromScale(axis: Vector3) Self {
+            var result = Self.identity();
+
+            result.data[0][0] = axis.x();
+            result.data[1][1] = axis.y();
+            result.data[2][2] = axis.z();
+
+            return result;
+        }
+
+        pub fn scale(self: Self, axis: Vector3) Self {
+            const scale_mat = Self.fromScale(axis);
+            return Self.mul(scale_mat, self);
+        }
+
+        pub fn extractScale(self: Self) Vector3 {
+            const scale_x = Vector3.new(self.data[0][0], self.data[0][1], self.data[0][2]);
+            const scale_y = Vector3.new(self.data[1][0], self.data[1][1], self.data[1][2]);
+            const scale_z = Vector3.new(self.data[2][0], self.data[2][1], self.data[2][2]);
+
+            return Vector3.new(scale_x.length(), scale_y.length(), scale_z.length());
+        }
+
+        /// Matrices' multiplication.
+        /// Produce a new matrix from given two matrices.
+        pub fn mul(left: Self, right: Self) Self {
+            var result = Self.identity();
+            for (0..result.data.len) |column| {
+                for (0..result.data[column].len) |row| {
+                    var sum: T = 0;
+
+                    for (0..left.data.len) |left_column| {
+                        sum += left.data[left_column][row] * right.data[column][left_column];
+                    }
+
+                    result.data[column][row] = sum;
+                }
+            }
+            return result;
+        }
+
+        /// Calculate determinant of the given 3x3 matrix.
+        pub fn det(self: Self) T {
+            var s: [3]T = undefined;
+            s[0] = self.data[0][0] * (self.data[1][1] * self.data[2][2] - self.data[1][2] * self.data[2][1]);
+            s[1] = self.data[0][1] * (self.data[1][0] * self.data[2][2] - self.data[1][2] * self.data[2][0]);
+            s[2] = self.data[0][2] * (self.data[1][0] * self.data[2][1] - self.data[1][1] * self.data[2][0]);
+            return s[0] - s[1] + s[2];
+        }
+
+        /// Construct inverse 3x3 from given matrix.
+        /// Note: This is not the most efficient way to do this.
+        /// TODO: Make it more efficient.
+        pub fn inv(self: Self) Self {
+            var inv_mat: Self = undefined;
+
+            const determ = 1 / det(self);
+
+            inv_mat.data[0][0] = determ * (self.data[1][1] * self.data[2][2] - self.data[1][2] * self.data[2][1]);
+            inv_mat.data[0][1] = determ * -(self.data[0][1] * self.data[2][2] - self.data[0][2] * self.data[2][1]);
+            inv_mat.data[0][2] = determ * (self.data[0][1] * self.data[1][2] - self.data[0][2] * self.data[1][1]);
+
+            inv_mat.data[1][0] = determ * -(self.data[1][0] * self.data[2][2] - self.data[1][2] * self.data[2][0]);
+            inv_mat.data[1][1] = determ * (self.data[0][0] * self.data[2][2] - self.data[0][2] * self.data[2][0]);
+            inv_mat.data[1][2] = determ * -(self.data[0][0] * self.data[1][2] - self.data[0][2] * self.data[1][0]);
+
+            inv_mat.data[2][0] = determ * (self.data[1][0] * self.data[2][1] - self.data[1][1] * self.data[2][0]);
+            inv_mat.data[2][1] = determ * -(self.data[0][0] * self.data[2][1] - self.data[0][1] * self.data[2][0]);
+            inv_mat.data[2][2] = determ * (self.data[0][0] * self.data[1][1] - self.data[0][1] * self.data[1][0]);
+
+            return inv_mat;
+        }
+
+        /// Print the 3x3 to stderr.
+        pub fn debugPrint(self: Self) void {
+            const print = std.debug.print;
+
+            print("({d}, {d}, {d})\n", .{
+                self.data[0][0],
+                self.data[1][0],
+                self.data[2][0],
+            });
+
+            print("({d}, {d}, {d})\n", .{
+                self.data[0][1],
+                self.data[1][1],
+                self.data[2][1],
+            });
+
+            print("({d}, {d}, {d})\n", .{
+                self.data[0][2],
+                self.data[1][2],
+                self.data[2][2],
+            });
+        }
+
+        /// Cast a type to another type.
+        /// It's like builtins: @intCast, @floatCast, @floatFromInt, @intFromFloat.
+        pub fn cast(self: Self, comptime dest_type: type) Mat3x3(dest_type) {
+            const dest_info = @typeInfo(dest_type);
+
+            if (dest_info != .Float) {
+                std.debug.panic("Error, dest type should be float.\n", .{});
+            }
+
+            var result: Mat3x3(dest_type) = undefined;
+            for (0..result.data.len) |column| {
+                for (0..result.data[column].len) |row| {
+                    result.data[column][row] = @floatCast(self.data[column][row]);
+                }
+            }
+            return result;
+        }
+    };
+}
+
+test "zalgebra.Mat3.eql" {
+    const a = Mat3.identity();
+    const b = Mat3.identity();
+    const c = Mat3.zero();
+
+    try expectEqual(Mat3.eql(a, b), true);
+    try expectEqual(Mat3.eql(a, c), false);
+}
+
+test "zalgebra.Mat3.set" {
+    const a = Mat3.set(12);
+    const b = Mat3{
+        .data = .{
+            .{ 12, 12, 12 },
+            .{ 12, 12, 12 },
+            .{ 12, 12, 12 },
+        },
+    };
+
+    try expectEqual(a, b);
+}
+
+test "zalgebra.Mat3.negate" {
+    const a = Mat3{
+        .data = .{
+            .{ 1, 2, 3 },
+            .{ 5, -6, 7 },
+            .{ 9, 10, 11 },
+        },
+    };
+    const a_negated = Mat3{
+        .data = .{
+            .{ -1, -2, -3 },
+            .{ -5, 6, -7 },
+            .{ -9, -10, -11 },
+        },
+    };
+
+    try expectEqual(a.negate(), a_negated);
+}
+
+test "zalgebra.Mat3.transpose" {
+    const a = Mat3{
+        .data = .{
+            .{ 1, 2, 3 },
+            .{ 5, 6, 7 },
+            .{ 9, 10, 11 },
+        },
+    };
+    const b = Mat3{
+        .data = .{
+            .{ 1, 5, 9 },
+            .{ 2, 6, 10 },
+            .{ 3, 7, 11 },
+        },
+    };
+
+    try expectEqual(a.transpose(), b);
+}
+
+test "zalgebra.Mat3.fromSlice" {
+    const data = [_]f32{ 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+    const result = Mat3.fromSlice(&data);
+
+    try expectEqual(result, Mat3.identity());
+}
+
+test "zalgebra.Mat3.fromScale" {
+    const a = Mat3.fromScale(Vec3.new(2, 3, 4));
+
+    try expectEqual(a, Mat3{
+        .data = .{
+            .{ 2, 0, 0 },
+            .{ 0, 3, 0 },
+            .{ 0, 0, 4 },
+        },
+    });
+}
+
+test "zalgebra.Mat3.scale" {
+    const a = Mat3.fromScale(Vec3.new(2, 3, 4));
+    const result = Mat3.scale(a, Vec3.set(2));
+
+    try expectEqual(result, Mat3{
+        .data = .{
+            .{ 4, 0, 0 },
+            .{ 0, 6, 0 },
+            .{ 0, 0, 8 },
+        },
+    });
+}
+
+test "zalgebra.Mat3.det" {
+    const a: Mat3 = .{
+        .data = .{
+            .{ 2, 0, 4 },
+            .{ 0, 2, 0 },
+            .{ 4, 0, 2 },
+        },
+    };
+
+    try expectEqual(a.det(), -24);
+}
+
+test "zalgebra.Mat3.inv" {
+    const a: Mat3 = .{
+        .data = .{
+            .{ 2, 0, 4 },
+            .{ 0, 2, 0 },
+            .{ 4, 0, 2 },
+        },
+    };
+
+    try expectEqual(a.inv(), Mat3{
+        .data = .{
+            .{ -0.1666666716337204, 0, 0.3333333432674408 },
+            .{ 0, 0.5, 0 },
+            .{ 0.3333333432674408, 0, -0.1666666716337204 },
+        },
+    });
+}
+
+test "zalgebra.Mat3.extractEulerAngles" {
+    const a = Mat3.fromEulerAngles(Vec3.new(45, -5, 20));
+    try expectEqual(a.extractEulerAngles(), Vec3.new(45.000003814697266, -4.99052524, 19.999998092651367));
+}
+
+test "zalgebra.Mat3.extractScale" {
+    var a = Mat3.fromScale(Vec3.new(2, 4, 8));
+    a = a.scale(Vec3.new(2, 4, 8));
+
+    try expectEqual(a.extractScale(), Vec3.new(4, 16, 64));
+}
+
+test "zalgebra.Mat3.cast" {
+    const a = Mat3{ .data = .{
+        .{ 0.9961947202682495, 0, -0.08715573698282242 },
+        .{ 0.06162841245532036, 0.7071067690849304, 0.704416036605835 },
+        .{ 0.06162841245532036, -0.7071067690849304, 0.704416036605835 },
+    } };
+    const a_f64 = Mat3_f64{ .data = .{
+        .{ 0.9961947202682495, 0, -0.08715573698282242 },
+        .{ 0.06162841245532036, 0.7071067690849304, 0.704416036605835 },
+        .{ 0.06162841245532036, -0.7071067690849304, 0.704416036605835 },
+    } };
+    try expectEqual(a.cast(f64), a_f64);
+    try expectEqual(a_f64.cast(f32), a);
+}

extras/bsp/src/zalgebra/mat4.zig

@@ -0,0 +1,718 @@
+const std = @import("std");
+const math = std.math;
+const meta = std.meta;
+const mem = std.mem;
+const expectEqual = std.testing.expectEqual;
+const root = @import("main.zig");
+const generic_vector = @import("generic_vector.zig");
+const quat = @import("quaternion.zig");
+
+const Vec3 = generic_vector.Vec3;
+const Vec3_f64 = generic_vector.Vec3_f64;
+const GenericVector = generic_vector.GenericVector;
+const Quaternion = quat.Quaternion;
+const Quat = quat.Quat;
+
+pub const Mat4 = Mat4x4(f32);
+pub const Mat4_f64 = Mat4x4(f64);
+pub const perspective = Mat4.perspective;
+pub const perspectiveReversedZ = Mat4.perspectiveReversedZ;
+pub const orthographic = Mat4.orthographic;
+pub const lookAt = Mat4.lookAt;
+
+/// A column-major 4x4 matrix
+/// Note: Column-major means accessing data like m.data[COLUMN][ROW].
+pub fn Mat4x4(comptime T: type) type {
+    if (@typeInfo(T) != .Float) {
+        @compileError("Mat4x4 not implemented for " ++ @typeName(T));
+    }
+
+    const Vector3 = GenericVector(3, T);
+    const Vector4 = GenericVector(4, T);
+
+    return extern struct {
+        data: [4][4]T,
+
+        const Self = @This();
+
+        /// Shorthand for identity matrix.
+        pub fn identity() Self {
+            return .{
+                .data = .{
+                    .{ 1, 0, 0, 0 },
+                    .{ 0, 1, 0, 0 },
+                    .{ 0, 0, 1, 0 },
+                    .{ 0, 0, 0, 1 },
+                },
+            };
+        }
+
+        /// Shorthand for matrix with all zeros.
+        pub fn zero() Self {
+            return Self.set(0);
+        }
+
+        /// Set all mat4 values to given value.
+        pub fn set(value: T) Self {
+            const data: [16]T = .{value} ** 16;
+            return Self.fromSlice(&data);
+        }
+
+        /// Construct new 4x4 matrix from given slice.
+        pub fn fromSlice(data: *const [16]T) Self {
+            return .{
+                .data = .{
+                    data[0..4].*,
+                    data[4..8].*,
+                    data[8..12].*,
+                    data[12..16].*,
+                },
+            };
+        }
+
+        /// Negate the given matrix.
+        pub fn negate(self: Self) Self {
+            var result = self;
+            for (0..result.data.len) |column| {
+                for (0..result.data[column].len) |row| {
+                    result.data[column][row] = -result.data[column][row];
+                }
+            }
+            return result;
+        }
+
+        /// Transpose the given matrix.
+        pub fn transpose(self: Self) Self {
+            var result = self;
+            for (0..result.data.len) |column| {
+                for (column..4) |row| {
+                    std.mem.swap(T, &result.data[column][row], &result.data[row][column]);
+                }
+            }
+            return result;
+        }
+
+        /// Return a pointer to the inner data of the matrix.
+        pub fn getData(self: *const Self) *const T {
+            return @ptrCast(&self.data);
+        }
+
+        /// Return true if two matrices are equals.
+        pub fn eql(left: Self, right: Self) bool {
+            return meta.eql(left, right);
+        }
+
+        pub fn mulByVec4(self: Self, v: Vector4) Vector4 {
+            const x = (self.data[0][0] * v.x()) + (self.data[1][0] * v.y()) + (self.data[2][0] * v.z()) + (self.data[3][0] * v.w());
+            const y = (self.data[0][1] * v.x()) + (self.data[1][1] * v.y()) + (self.data[2][1] * v.z()) + (self.data[3][1] * v.w());
+            const z = (self.data[0][2] * v.x()) + (self.data[1][2] * v.y()) + (self.data[2][2] * v.z()) + (self.data[3][2] * v.w());
+            const w = (self.data[0][3] * v.x()) + (self.data[1][3] * v.y()) + (self.data[2][3] * v.z()) + (self.data[3][3] * v.w());
+
+            return Vector4.new(x, y, z, w);
+        }
+
+        /// Construct 4x4 translation matrix by multiplying identity matrix and
+        /// given translation vector.
+        pub fn fromTranslate(axis: Vector3) Self {
+            var result = Self.identity();
+            result.data[3][0] = axis.data[0];
+            result.data[3][1] = axis.data[1];
+            result.data[3][2] = axis.data[2];
+
+            return result;
+        }
+
+        /// Make a translation between the given matrix and the given axis.
+        pub fn translate(self: Self, axis: Vector3) Self {
+            const trans_mat = Self.fromTranslate(axis);
+            return Self.mul(trans_mat, self);
+        }
+
+        /// Get translation Vec3 from current matrix.
+        pub fn extractTranslation(self: Self) Vector3 {
+            return Vector3.new(self.data[3][0], self.data[3][1], self.data[3][2]);
+        }
+
+        /// Construct a 4x4 matrix from given axis and angle (in degrees).
+        pub fn fromRotation(angle_in_degrees: T, axis: Vector3) Self {
+            var result = Self.identity();
+
+            const norm_axis = axis.norm();
+
+            const sin_theta = @sin(root.toRadians(angle_in_degrees));
+            const cos_theta = @cos(root.toRadians(angle_in_degrees));
+            const cos_value = 1 - cos_theta;
+
+            const x = norm_axis.x();
+            const y = norm_axis.y();
+            const z = norm_axis.z();
+
+            result.data[0][0] = (x * x * cos_value) + cos_theta;
+            result.data[0][1] = (x * y * cos_value) + (z * sin_theta);
+            result.data[0][2] = (x * z * cos_value) - (y * sin_theta);
+
+            result.data[1][0] = (y * x * cos_value) - (z * sin_theta);
+            result.data[1][1] = (y * y * cos_value) + cos_theta;
+            result.data[1][2] = (y * z * cos_value) + (x * sin_theta);
+
+            result.data[2][0] = (z * x * cos_value) + (y * sin_theta);
+            result.data[2][1] = (z * y * cos_value) - (x * sin_theta);
+            result.data[2][2] = (z * z * cos_value) + cos_theta;
+
+            return result;
+        }
+
+        pub fn rotate(self: Self, angle_in_degrees: T, axis: Vector3) Self {
+            const rotation_mat = Self.fromRotation(angle_in_degrees, axis);
+            return Self.mul(self, rotation_mat);
+        }
+
+        /// Construct a rotation matrix from euler angles (X * Y * Z).
+        /// Order matters because matrix multiplication are NOT commutative.
+        pub fn fromEulerAngles(euler_angle: Vector3) Self {
+            const x = Self.fromRotation(euler_angle.x(), Vector3.right());
+            const y = Self.fromRotation(euler_angle.y(), Vector3.up());
+            const z = Self.fromRotation(euler_angle.z(), Vector3.forward());
+
+            return z.mul(y.mul(x));
+        }
+
+        /// Ortho normalize given matrix.
+        pub fn orthoNormalize(self: Self) Self {
+            const column_1 = Vector3.new(self.data[0][0], self.data[0][1], self.data[0][2]).norm();
+            const column_2 = Vector3.new(self.data[1][0], self.data[1][1], self.data[1][2]).norm();
+            const column_3 = Vector3.new(self.data[2][0], self.data[2][1], self.data[2][2]).norm();
+
+            var result = self;
+
+            result.data[0][0] = column_1.x();
+            result.data[0][1] = column_1.y();
+            result.data[0][2] = column_1.z();
+
+            result.data[1][0] = column_2.x();
+            result.data[1][1] = column_2.y();
+            result.data[1][2] = column_2.z();
+
+            result.data[2][0] = column_3.x();
+            result.data[2][1] = column_3.y();
+            result.data[2][2] = column_3.z();
+
+            return result;
+        }
+
+        /// Return the rotation as Euler angles in degrees.
+        /// Taken from Mike Day at Insomniac Games (and `glm` as the same function).
+        /// For more details: https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2012/07/euler-angles1.pdf
+        pub fn extractEulerAngles(self: Self) Vector3 {
+            const m = self.orthoNormalize();
+
+            const theta_x = math.atan2(m.data[1][2], m.data[2][2]);
+            const c2 = @sqrt(math.pow(T, m.data[0][0], 2) + math.pow(T, m.data[0][1], 2));
+            const theta_y = math.atan2(-m.data[0][2], @sqrt(c2));
+            const s1 = @sin(theta_x);
+            const c1 = @cos(theta_x);
+            const theta_z = math.atan2(s1 * m.data[2][0] - c1 * m.data[1][0], c1 * m.data[1][1] - s1 * m.data[2][1]);
+
+            return Vector3.new(root.toDegrees(theta_x), root.toDegrees(theta_y), root.toDegrees(theta_z));
+        }
+
+        pub fn fromScale(axis: Vector3) Self {
+            var result = Self.identity();
+
+            result.data[0][0] = axis.x();
+            result.data[1][1] = axis.y();
+            result.data[2][2] = axis.z();
+
+            return result;
+        }
+
+        pub fn scale(self: Self, axis: Vector3) Self {
+            const scale_mat = Self.fromScale(axis);
+            return Self.mul(scale_mat, self);
+        }
+
+        pub fn extractScale(self: Self) Vector3 {
+            const scale_x = Vector3.new(self.data[0][0], self.data[0][1], self.data[0][2]);
+            const scale_y = Vector3.new(self.data[1][0], self.data[1][1], self.data[1][2]);
+            const scale_z = Vector3.new(self.data[2][0], self.data[2][1], self.data[2][2]);
+
+            return Vector3.new(scale_x.length(), scale_y.length(), scale_z.length());
+        }
+
+        /// Construct a perspective 4x4 matrix.
+        /// Note: Field of view is given in degrees.
+        /// Also for more details https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml.
+        pub fn perspective(fovy_in_degrees: T, aspect_ratio: T, z_near: T, z_far: T) Self {
+            var result = Self.identity();
+
+            const f = 1 / @tan(root.toRadians(fovy_in_degrees) * 0.5);
+
+            result.data[0][0] = f / aspect_ratio;
+            result.data[1][1] = f;
+            result.data[2][2] = (z_near + z_far) / (z_near - z_far);
+            result.data[2][3] = -1;
+            result.data[3][2] = 2 * z_far * z_near / (z_near - z_far);
+            result.data[3][3] = 0;
+
+            return result;
+        }
+
+        /// Construct a perspective 4x4 matrix with reverse Z and infinite far plane.
+        /// Note: Field of view is given in degrees.
+        /// Also for more details https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml.
+        /// For Reversed-Z details https://nlguillemot.wordpress.com/2016/12/07/reversed-z-in-opengl/
+        pub fn perspectiveReversedZ(fovy_in_degrees: T, aspect_ratio: T, z_near: T) Self {
+            var result = Self.identity();
+
+            const f = 1 / @tan(root.toRadians(fovy_in_degrees) * 0.5);
+
+            result.data[0][0] = f / aspect_ratio;
+            result.data[1][1] = f;
+            result.data[2][2] = 0;
+            result.data[2][3] = -1;
+            result.data[3][2] = z_near;
+            result.data[3][3] = 0;
+
+            return result;
+        }
+
+        /// Construct an orthographic 4x4 matrix.
+        pub fn orthographic(left: T, right: T, bottom: T, top: T, z_near: T, z_far: T) Self {
+            var result = Self.zero();
+
+            result.data[0][0] = 2 / (right - left);
+            result.data[1][1] = 2 / (top - bottom);
+            result.data[2][2] = 2 / (z_near - z_far);
+            result.data[3][3] = 1;
+
+            result.data[3][0] = (left + right) / (left - right);
+            result.data[3][1] = (bottom + top) / (bottom - top);
+            result.data[3][2] = (z_far + z_near) / (z_near - z_far);
+
+            return result;
+        }
+
+        /// Right-handed lookAt function.
+        pub fn lookAt(eye: Vector3, target: Vector3, up: Vector3) Self {
+            const f = Vector3.sub(target, eye).norm();
+            const s = Vector3.cross(f, up).norm();
+            const u = Vector3.cross(s, f);
+
+            var result: Self = undefined;
+            result.data[0][0] = s.x();
+            result.data[0][1] = u.x();
+            result.data[0][2] = -f.x();
+            result.data[0][3] = 0;
+
+            result.data[1][0] = s.y();
+            result.data[1][1] = u.y();
+            result.data[1][2] = -f.y();
+            result.data[1][3] = 0;
+
+            result.data[2][0] = s.z();
+            result.data[2][1] = u.z();
+            result.data[2][2] = -f.z();
+            result.data[2][3] = 0;
+
+            result.data[3][0] = -Vector3.dot(s, eye);
+            result.data[3][1] = -Vector3.dot(u, eye);
+            result.data[3][2] = Vector3.dot(f, eye);
+            result.data[3][3] = 1;
+
+            return result;
+        }
+
+        /// Matrices' multiplication.
+        /// Produce a new matrix from given two matrices.
+        pub fn mul(left: Self, right: Self) Self {
+            var result = Self.identity();
+            for (0..result.data.len) |column| {
+                for (0..result.data[column].len) |row| {
+                    var sum: T = 0;
+
+                    for (0..left.data.len) |left_column| {
+                        sum += left.data[left_column][row] * right.data[column][left_column];
+                    }
+
+                    result.data[column][row] = sum;
+                }
+            }
+            return result;
+        }
+
+        fn detsubs(self: Self) [12]T {
+            return .{
+                self.data[0][0] * self.data[1][1] - self.data[1][0] * self.data[0][1],
+                self.data[0][0] * self.data[1][2] - self.data[1][0] * self.data[0][2],
+                self.data[0][0] * self.data[1][3] - self.data[1][0] * self.data[0][3],
+                self.data[0][1] * self.data[1][2] - self.data[1][1] * self.data[0][2],
+                self.data[0][1] * self.data[1][3] - self.data[1][1] * self.data[0][3],
+                self.data[0][2] * self.data[1][3] - self.data[1][2] * self.data[0][3],
+
+                self.data[2][0] * self.data[3][1] - self.data[3][0] * self.data[2][1],
+                self.data[2][0] * self.data[3][2] - self.data[3][0] * self.data[2][2],
+                self.data[2][0] * self.data[3][3] - self.data[3][0] * self.data[2][3],
+                self.data[2][1] * self.data[3][2] - self.data[3][1] * self.data[2][2],
+                self.data[2][1] * self.data[3][3] - self.data[3][1] * self.data[2][3],
+                self.data[2][2] * self.data[3][3] - self.data[3][2] * self.data[2][3],
+            };
+        }
+
+        /// Calculate determinant of the given 4x4 matrix.
+        pub fn det(self: Self) T {
+            const s = detsubs(self);
+            return s[0] * s[11] - s[1] * s[10] + s[2] * s[9] + s[3] * s[8] - s[4] * s[7] + s[5] * s[6];
+        }
+
+        /// Construct inverse 4x4 from given matrix.
+        /// Note: This is not the most efficient way to do this.
+        /// TODO: Make it more efficient.
+        pub fn inv(self: Self) Self {
+            var inv_mat: Self = undefined;
+
+            const s = detsubs(self);
+
+            const determ = 1 / (s[0] * s[11] - s[1] * s[10] + s[2] * s[9] + s[3] * s[8] - s[4] * s[7] + s[5] * s[6]);
+
+            inv_mat.data[0][0] = determ * (self.data[1][1] * s[11] - self.data[1][2] * s[10] + self.data[1][3] * s[9]);
+            inv_mat.data[0][1] = determ * -(self.data[0][1] * s[11] - self.data[0][2] * s[10] + self.data[0][3] * s[9]);
+            inv_mat.data[0][2] = determ * (self.data[3][1] * s[5] - self.data[3][2] * s[4] + self.data[3][3] * s[3]);
+            inv_mat.data[0][3] = determ * -(self.data[2][1] * s[5] - self.data[2][2] * s[4] + self.data[2][3] * s[3]);
+
+            inv_mat.data[1][0] = determ * -(self.data[1][0] * s[11] - self.data[1][2] * s[8] + self.data[1][3] * s[7]);
+            inv_mat.data[1][1] = determ * (self.data[0][0] * s[11] - self.data[0][2] * s[8] + self.data[0][3] * s[7]);
+            inv_mat.data[1][2] = determ * -(self.data[3][0] * s[5] - self.data[3][2] * s[2] + self.data[3][3] * s[1]);
+            inv_mat.data[1][3] = determ * (self.data[2][0] * s[5] - self.data[2][2] * s[2] + self.data[2][3] * s[1]);
+
+            inv_mat.data[2][0] = determ * (self.data[1][0] * s[10] - self.data[1][1] * s[8] + self.data[1][3] * s[6]);
+            inv_mat.data[2][1] = determ * -(self.data[0][0] * s[10] - self.data[0][1] * s[8] + self.data[0][3] * s[6]);
+            inv_mat.data[2][2] = determ * (self.data[3][0] * s[4] - self.data[3][1] * s[2] + self.data[3][3] * s[0]);
+            inv_mat.data[2][3] = determ * -(self.data[2][0] * s[4] - self.data[2][1] * s[2] + self.data[2][3] * s[0]);
+
+            inv_mat.data[3][0] = determ * -(self.data[1][0] * s[9] - self.data[1][1] * s[7] + self.data[1][2] * s[6]);
+            inv_mat.data[3][1] = determ * (self.data[0][0] * s[9] - self.data[0][1] * s[7] + self.data[0][2] * s[6]);
+            inv_mat.data[3][2] = determ * -(self.data[3][0] * s[3] - self.data[3][1] * s[1] + self.data[3][2] * s[0]);
+            inv_mat.data[3][3] = determ * (self.data[2][0] * s[3] - self.data[2][1] * s[1] + self.data[2][2] * s[0]);
+
+            return inv_mat;
+        }
+
+        /// Return 4x4 matrix from given all transform components; `translation`, `rotation` and `scale`.
+        /// The final order is T * R * S.
+        /// Note: `rotation` could be `Vec3` (Euler angles) or a `quat`.
+        pub fn recompose(translation: Vector3, rotation: anytype, scalar: Vector3) Self {
+            var r = switch (@TypeOf(rotation)) {
+                Quaternion(T) => Quaternion(T).toMat4(rotation),
+                Vector3 => Self.fromEulerAngles(rotation),
+                else => @compileError("Recompose not implemented for " ++ @typeName(@TypeOf(rotation))),
+            };
+
+            r.data[0][0] *= scalar.x();
+            r.data[0][1] *= scalar.x();
+            r.data[0][2] *= scalar.x();
+            r.data[1][0] *= scalar.y();
+            r.data[1][1] *= scalar.y();
+            r.data[1][2] *= scalar.y();
+            r.data[2][0] *= scalar.z();
+            r.data[2][1] *= scalar.z();
+            r.data[2][2] *= scalar.z();
+
+            r.data[3][0] = translation.x();
+            r.data[3][1] = translation.y();
+            r.data[3][2] = translation.z();
+
+            return r;
+        }
+
+        /// Return `translation`, `rotation` and `scale` components from given matrix.
+        /// For now, the rotation returned is a quaternion. If you want to get Euler angles
+        /// from it, just do: `returned_quat.extractEulerAngles()`.
+        /// Note: We ortho nornalize the given matrix before extracting the rotation.
+        pub fn decompose(self: Self) struct { t: Vector3, r: Quaternion(T), s: Vector3 } {
+            const t = self.extractTranslation();
+            const s = self.extractScale();
+            const r = Quaternion(T).fromMat4(self.orthoNormalize());
+
+            return .{
+                .t = t,
+                .r = r,
+                .s = s,
+            };
+        }
+
+        /// Print the 4x4 to stderr.
+        pub fn debugPrint(self: Self) void {
+            const print = std.debug.print;
+
+            print("({d}, {d}, {d}, {d})\n", .{
+                self.data[0][0],
+                self.data[1][0],
+                self.data[2][0],
+                self.data[3][0],
+            });
+
+            print("({d}, {d}, {d}, {d})\n", .{
+                self.data[0][1],
+                self.data[1][1],
+                self.data[2][1],
+                self.data[3][1],
+            });
+
+            print("({d}, {d}, {d}, {d})\n", .{
+                self.data[0][2],
+                self.data[1][2],
+                self.data[2][2],
+                self.data[3][2],
+            });
+
+            print("({d}, {d}, {d}, {d})\n", .{
+                self.data[0][3],
+                self.data[1][3],
+                self.data[2][3],
+                self.data[3][3],
+            });
+        }
+
+        /// Cast a type to another type.
+        /// It's like builtins: @intCast, @floatCast, @floatFromInt, @intFromFloat.
+        pub fn cast(self: Self, comptime dest_type: type) Mat4x4(dest_type) {
+            const dest_info = @typeInfo(dest_type);
+
+            if (dest_info != .Float) {
+                std.debug.panic("Error, dest type should be float.\n", .{});
+            }
+
+            var result: Mat4x4(dest_type) = undefined;
+            for (0..result.data.len) |column| {
+                for (0..result.data[column].len) |row| {
+                    result.data[column][row] = @floatCast(self.data[column][row]);
+                }
+            }
+            return result;
+        }
+    };
+}
+
+test "zalgebra.Mat4.eql" {
+    const a = Mat4.identity();
+    const b = Mat4.identity();
+    const c = Mat4.zero();
+
+    try expectEqual(Mat4.eql(a, b), true);
+    try expectEqual(Mat4.eql(a, c), false);
+}
+
+test "zalgebra.Mat4.set" {
+    const a = Mat4.set(12);
+    const b = Mat4{
+        .data = .{
+            .{ 12, 12, 12, 12 },
+            .{ 12, 12, 12, 12 },
+            .{ 12, 12, 12, 12 },
+            .{ 12, 12, 12, 12 },
+        },
+    };
+
+    try expectEqual(a, b);
+}
+
+test "zalgebra.Mat4.negate" {
+    const a = Mat4{
+        .data = .{
+            .{ 1, 2, 3, 4 },
+            .{ 5, -6, 7, 8 },
+            .{ 9, 10, 11, -12 },
+            .{ 13, 14, 15, 16 },
+        },
+    };
+    const a_negated = Mat4{
+        .data = .{
+            .{ -1, -2, -3, -4 },
+            .{ -5, 6, -7, -8 },
+            .{ -9, -10, -11, 12 },
+            .{ -13, -14, -15, -16 },
+        },
+    };
+
+    try expectEqual(a.negate(), a_negated);
+}
+
+test "zalgebra.Mat4.transpose" {
+    const a = Mat4{
+        .data = .{
+            .{ 1, 2, 3, 4 },
+            .{ 5, 6, 7, 8 },
+            .{ 9, 10, 11, 12 },
+            .{ 13, 14, 15, 16 },
+        },
+    };
+    const b = Mat4{
+        .data = .{
+            .{ 1, 5, 9, 13 },
+            .{ 2, 6, 10, 14 },
+            .{ 3, 7, 11, 15 },
+            .{ 4, 8, 12, 16 },
+        },
+    };
+
+    try expectEqual(a.transpose(), b);
+}
+
+test "zalgebra.Mat4.fromSlice" {
+    const data = [_]f32{ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
+    const result = Mat4.fromSlice(&data);
+
+    try expectEqual(result, Mat4.identity());
+}
+
+test "zalgebra.Mat4.fromTranslate" {
+    const a = Mat4.fromTranslate(Vec3.new(2, 3, 4));
+
+    try expectEqual(a, Mat4{
+        .data = .{
+            .{ 1, 0, 0, 0 },
+            .{ 0, 1, 0, 0 },
+            .{ 0, 0, 1, 0 },
+            .{ 2, 3, 4, 1 },
+        },
+    });
+}
+
+test "zalgebra.Mat4.translate" {
+    const a = Mat4.fromTranslate(Vec3.new(2, 3, 2));
+    const result = Mat4.translate(a, Vec3.new(2, 3, 4));
+
+    try expectEqual(result, Mat4{
+        .data = .{
+            .{ 1, 0, 0, 0 },
+            .{ 0, 1, 0, 0 },
+            .{ 0, 0, 1, 0 },
+            .{ 4, 6, 6, 1 },
+        },
+    });
+}
+
+test "zalgebra.Mat4.fromScale" {
+    const a = Mat4.fromScale(Vec3.new(2, 3, 4));
+
+    try expectEqual(a, Mat4{
+        .data = .{
+            .{ 2, 0, 0, 0 },
+            .{ 0, 3, 0, 0 },
+            .{ 0, 0, 4, 0 },
+            .{ 0, 0, 0, 1 },
+        },
+    });
+}
+
+test "zalgebra.Mat4.scale" {
+    const a = Mat4.fromScale(Vec3.new(2, 3, 4));
+    const result = Mat4.scale(a, Vec3.set(2));
+
+    try expectEqual(result, Mat4{
+        .data = .{
+            .{ 4, 0, 0, 0 },
+            .{ 0, 6, 0, 0 },
+            .{ 0, 0, 8, 0 },
+            .{ 0, 0, 0, 1 },
+        },
+    });
+}
+
+test "zalgebra.Mat4.det" {
+    const a: Mat4 = .{
+        .data = .{
+            .{ 2, 0, 0, 4 },
+            .{ 0, 2, 0, 0 },
+            .{ 0, 0, 2, 0 },
+            .{ 4, 0, 0, 2 },
+        },
+    };
+
+    try expectEqual(a.det(), -48);
+}
+
+test "zalgebra.Mat4.inv" {
+    const a: Mat4 = .{
+        .data = .{
+            .{ 2, 0, 0, 4 },
+            .{ 0, 2, 0, 0 },
+            .{ 0, 0, 2, 0 },
+            .{ 4, 0, 0, 2 },
+        },
+    };
+
+    try expectEqual(a.inv(), Mat4{
+        .data = .{
+            .{ -0.1666666716337204, 0, 0, 0.3333333432674408 },
+            .{ 0, 0.5, 0, 0 },
+            .{ 0, 0, 0.5, 0 },
+            .{ 0.3333333432674408, 0, 0, -0.1666666716337204 },
+        },
+    });
+}
+
+test "zalgebra.Mat4.extractTranslation" {
+    var a = Mat4.fromTranslate(Vec3.new(2, 3, 2));
+    a = a.translate(Vec3.new(2, 3, 2));
+
+    try expectEqual(a.extractTranslation(), Vec3.new(4, 6, 4));
+}
+
+test "zalgebra.Mat4.extractEulerAngles" {
+    const a = Mat4.fromEulerAngles(Vec3.new(45, -5, 20));
+    try expectEqual(a.extractEulerAngles(), Vec3.new(45.000003814697266, -4.99052524, 19.999998092651367));
+}
+
+test "zalgebra.Mat4.extractScale" {
+    var a = Mat4.fromScale(Vec3.new(2, 4, 8));
+    a = a.scale(Vec3.new(2, 4, 8));
+
+    try expectEqual(a.extractScale(), Vec3.new(4, 16, 64));
+}
+
+test "zalgebra.Mat4.recompose" {
+    const result = Mat4.recompose(
+        Vec3.set(2),
+        Vec3.new(45, 5, 0),
+        Vec3.one(),
+    );
+
+    try expectEqual(result, Mat4{ .data = .{
+        .{ 0.9961947202682495, 0, -0.08715573698282242, 0 },
+        .{ 0.06162841245532036, 0.7071067690849304, 0.704416036605835, 0 },
+        .{ 0.06162841245532036, -0.7071067690849304, 0.704416036605835, 0 },
+        .{ 2, 2, 2, 1 },
+    } });
+}
+
+test "zalgebra.Mat4.decompose" {
+    const a = Mat4.recompose(
+        Vec3.new(10, 5, 5),
+        Vec3.new(45, 5, 0),
+        Vec3.set(1),
+    );
+
+    const result = a.decompose();
+
+    try expectEqual(result.t, Vec3.new(10, 5, 5));
+    try expectEqual(result.s, Vec3.set(1));
+    try expectEqual(result.r.extractEulerAngles(), Vec3.new(45, 5, 0.00000010712935250012379));
+}
+
+test "zalgebra.Mat4.cast" {
+    const a = Mat4{ .data = .{
+        .{ 0.9961947202682495, 0, -0.08715573698282242, 0 },
+        .{ 0.06162841245532036, 0.7071067690849304, 0.704416036605835, 0 },
+        .{ 0.06162841245532036, -0.7071067690849304, 0.704416036605835, 0 },
+        .{ 2, 2, 2, 1 },
+    } };
+    const a_f64 = Mat4_f64{ .data = .{
+        .{ 0.9961947202682495, 0, -0.08715573698282242, 0 },
+        .{ 0.06162841245532036, 0.7071067690849304, 0.704416036605835, 0 },
+        .{ 0.06162841245532036, -0.7071067690849304, 0.704416036605835, 0 },
+        .{ 2, 2, 2, 1 },
+    } };
+    try expectEqual(a.cast(f64), a_f64);
+    try expectEqual(a_f64.cast(f32), a);
+}

extras/bsp/src/zalgebra/quaternion.zig

@@ -0,0 +1,539 @@
+const std = @import("std");
+const root = @import("main.zig");
+const meta = std.meta;
+const generic_vector = @import("generic_vector.zig");
+const mat3 = @import("mat3.zig");
+const mat4 = @import("mat4.zig");
+const math = std.math;
+const eps_value = math.floatEps(f32);
+const expectApproxEqAbs = std.testing.expectApproxEqAbs;
+const expectApproxEqRel = std.testing.expectApproxEqRel;
+const expectEqual = std.testing.expectEqual;
+const expect = std.testing.expect;
+const assert = std.debug.assert;
+
+const GenericVector = generic_vector.GenericVector;
+
+const Vec3 = generic_vector.Vec3;
+const Vec4 = generic_vector.Vec4;
+const Mat3x3 = mat3.Mat3x3;
+const Mat4x4 = mat4.Mat4x4;
+
+pub const Quat = Quaternion(f32);
+pub const Quat_f64 = Quaternion(f64);
+
+/// A Quaternion for 3D rotations.
+pub fn Quaternion(comptime T: type) type {
+    if (@typeInfo(T) != .Float) {
+        @compileError("Quaternion not implemented for " ++ @typeName(T));
+    }
+
+    const Vector3 = GenericVector(3, T);
+
+    return extern struct {
+        w: T,
+        x: T,
+        y: T,
+        z: T,
+
+        const Self = @This();
+
+        /// Construct new quaternion from floats.
+        pub fn new(w: T, x: T, y: T, z: T) Self {
+            return .{
+                .w = w,
+                .x = x,
+                .y = y,
+                .z = z,
+            };
+        }
+
+        /// Shorthand for (1, 0, 0, 0).
+        pub fn identity() Self {
+            return Self.new(1, 0, 0, 0);
+        }
+
+        /// Set all components to the same given value.
+        pub fn set(val: T) Self {
+            return Self.new(val, val, val, val);
+        }
+
+        /// Construct new quaternion from slice.
+        /// Note: Careful, the latest component `slice[3]` is the `W` component.
+        pub fn fromSlice(slice: []const T) Self {
+            return Self.new(slice[3], slice[0], slice[1], slice[2]);
+        }
+
+        // Construct new quaternion from given `W` component and Vector3.
+        pub fn fromVec3(w: T, axis: Vector3) Self {
+            return Self.new(w, axis.x(), axis.y(), axis.z());
+        }
+
+        /// Return true if two quaternions are equal.
+        pub fn eql(left: Self, right: Self) bool {
+            return meta.eql(left, right);
+        }
+
+        /// Construct new normalized quaternion from a given one.
+        pub fn norm(self: Self) Self {
+            const l = length(self);
+            if (l == 0) {
+                return self;
+            }
+            return Self.new(
+                self.w / l,
+                self.x / l,
+                self.y / l,
+                self.z / l,
+            );
+        }
+
+        /// Return the length (magnitude) of quaternion.
+        pub fn length(self: Self) T {
+            return @sqrt(self.dot(self));
+        }
+
+        /// Substraction between two quaternions.
+        pub fn sub(left: Self, right: Self) Self {
+            return Self.new(
+                left.w - right.w,
+                left.x - right.x,
+                left.y - right.y,
+                left.z - right.z,
+            );
+        }
+
+        /// Addition between two quaternions.
+        pub fn add(left: Self, right: Self) Self {
+            return Self.new(
+                left.w + right.w,
+                left.x + right.x,
+                left.y + right.y,
+                left.z + right.z,
+            );
+        }
+
+        /// Quaternions' multiplication.
+        /// Produce a new quaternion from given two quaternions.
+        pub fn mul(left: Self, right: Self) Self {
+            const x = (left.x * right.w) + (left.y * right.z) - (left.z * right.y) + (left.w * right.x);
+            const y = (-left.x * right.z) + (left.y * right.w) + (left.z * right.x) + (left.w * right.y);
+            const z = (left.x * right.y) - (left.y * right.x) + (left.z * right.w) + (left.w * right.z);
+            const w = (-left.x * right.x) - (left.y * right.y) - (left.z * right.z) + (left.w * right.w);
+
+            return Self.new(w, x, y, z);
+        }
+
+        /// Multiply each component by the given scalar.
+        pub fn scale(mat: Self, scalar: T) Self {
+            const w = mat.w * scalar;
+            const x = mat.x * scalar;
+            const y = mat.y * scalar;
+            const z = mat.z * scalar;
+
+            return Self.new(w, x, y, z);
+        }
+
+        /// Negate the given quaternion
+        pub fn negate(self: Self) Self {
+            return self.scale(-1);
+        }
+
+        /// Return the dot product between two quaternion.
+        pub fn dot(left: Self, right: Self) T {
+            return (left.x * right.x) + (left.y * right.y) + (left.z * right.z) + (left.w * right.w);
+        }
+
+        /// Convert given quaternion to rotation 3x3 matrix.
+        fn toMat3(self: Self) Mat3x3(T) {
+            var result: Mat3x3(T) = undefined;
+
+            const normalized = self.norm();
+            const xx = normalized.x * normalized.x;
+            const yy = normalized.y * normalized.y;
+            const zz = normalized.z * normalized.z;
+            const xy = normalized.x * normalized.y;
+            const xz = normalized.x * normalized.z;
+            const yz = normalized.y * normalized.z;
+            const wx = normalized.w * normalized.x;
+            const wy = normalized.w * normalized.y;
+            const wz = normalized.w * normalized.z;
+
+            result.data[0][0] = 1 - 2 * (yy + zz);
+            result.data[0][1] = 2 * (xy + wz);
+            result.data[0][2] = 2 * (xz - wy);
+
+            result.data[1][0] = 2 * (xy - wz);
+            result.data[1][1] = 1 - 2 * (xx + zz);
+            result.data[1][2] = 2 * (yz + wx);
+
+            result.data[2][0] = 2 * (xz + wy);
+            result.data[2][1] = 2 * (yz - wx);
+            result.data[2][2] = 1 - 2 * (xx + yy);
+
+            return result;
+        }
+
+        /// Convert given quaternion to rotation 4x4 matrix.
+        /// Mostly taken from https://github.com/HandmadeMath/Handmade-Math.
+        pub fn toMat4(self: Self) Mat4x4(T) {
+            var result: Mat4x4(T) = undefined;
+
+            const normalized = self.norm();
+            const xx = normalized.x * normalized.x;
+            const yy = normalized.y * normalized.y;
+            const zz = normalized.z * normalized.z;
+            const xy = normalized.x * normalized.y;
+            const xz = normalized.x * normalized.z;
+            const yz = normalized.y * normalized.z;
+            const wx = normalized.w * normalized.x;
+            const wy = normalized.w * normalized.y;
+            const wz = normalized.w * normalized.z;
+
+            result.data[0][0] = 1 - 2 * (yy + zz);
+            result.data[0][1] = 2 * (xy + wz);
+            result.data[0][2] = 2 * (xz - wy);
+            result.data[0][3] = 0;
+
+            result.data[1][0] = 2 * (xy - wz);
+            result.data[1][1] = 1 - 2 * (xx + zz);
+            result.data[1][2] = 2 * (yz + wx);
+            result.data[1][3] = 0;
+
+            result.data[2][0] = 2 * (xz + wy);
+            result.data[2][1] = 2 * (yz - wx);
+            result.data[2][2] = 1 - 2 * (xx + yy);
+            result.data[2][3] = 0;
+
+            result.data[3][0] = 0;
+            result.data[3][1] = 0;
+            result.data[3][2] = 0;
+            result.data[3][3] = 1;
+
+            return result;
+        }
+
+        /// From Mike Day at Insomniac Games.
+        /// For more details: https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2015/01/matrix-to-quat.pdf
+        pub fn fromMat4(mat: Mat4x4(T)) Self {
+            var t: T = undefined;
+            var result: Self = undefined;
+
+            if (mat.data[2][2] < 0) {
+                if (mat.data[0][0] > mat.data[1][1]) {
+                    t = 1 + mat.data[0][0] - mat.data[1][1] - mat.data[2][2];
+                    result = Self.new(
+                        mat.data[1][2] - mat.data[2][1],
+                        t,
+                        mat.data[0][1] + mat.data[1][0],
+                        mat.data[2][0] + mat.data[0][2],
+                    );
+                } else {
+                    t = 1 - mat.data[0][0] + mat.data[1][1] - mat.data[2][2];
+                    result = Self.new(
+                        mat.data[2][0] - mat.data[0][2],
+                        mat.data[0][1] + mat.data[1][0],
+                        t,
+                        mat.data[1][2] + mat.data[2][1],
+                    );
+                }
+            } else {
+                if (mat.data[0][0] < -mat.data[1][1]) {
+                    t = 1 - mat.data[0][0] - mat.data[1][1] + mat.data[2][2];
+                    result = Self.new(
+                        mat.data[0][1] - mat.data[1][0],
+                        mat.data[2][0] + mat.data[0][2],
+                        mat.data[1][2] + mat.data[2][1],
+                        t,
+                    );
+                } else {
+                    t = 1 + mat.data[0][0] + mat.data[1][1] + mat.data[2][2];
+                    result = Self.new(
+                        t,
+                        mat.data[1][2] - mat.data[2][1],
+                        mat.data[2][0] - mat.data[0][2],
+                        mat.data[0][1] - mat.data[1][0],
+                    );
+                }
+            }
+
+            return result.scale(0.5 / @sqrt(t));
+        }
+
+        /// Convert all Euler angles (in degrees) to quaternion.
+        pub fn fromEulerAngles(axis_in_degrees: Vector3) Self {
+            const x = Self.fromAxis(axis_in_degrees.x(), Vector3.right());
+            const y = Self.fromAxis(axis_in_degrees.y(), Vector3.up());
+            const z = Self.fromAxis(axis_in_degrees.z(), Vector3.forward());
+
+            return z.mul(y.mul(x));
+        }
+
+        /// Convert Euler angle around specified axis to quaternion.
+        pub fn fromAxis(degrees: T, axis: Vector3) Self {
+            const radians = root.toRadians(degrees);
+
+            const rot_sin = @sin(radians / 2);
+            const quat_axis = axis.norm().data * @as(@TypeOf(axis.data), @splat(rot_sin));
+            const w = @cos(radians / 2);
+
+            return Self.fromVec3(w, .{ .data = quat_axis });
+        }
+
+        /// Extract euler angles (degrees) from quaternion.
+        pub fn extractEulerAngles(self: Self) Vector3 {
+            const yaw = math.atan2(
+                2 * (self.y * self.z + self.w * self.x),
+                self.w * self.w - self.x * self.x - self.y * self.y + self.z * self.z,
+            );
+            const pitch = math.asin(
+                -2 * (self.x * self.z - self.w * self.y),
+            );
+            const roll = math.atan2(
+                2 * (self.x * self.y + self.w * self.z),
+                self.w * self.w + self.x * self.x - self.y * self.y - self.z * self.z,
+            );
+
+            return Vector3.new(root.toDegrees(yaw), root.toDegrees(pitch), root.toDegrees(roll));
+        }
+
+        /// Get the rotation angle (degrees) and axis for a given quaternion.
+        // Taken from https://github.com/raysan5/raylib/blob/master/src/raymath.h#L1755
+        pub fn extractAxisAngle(self: Self) struct { axis: Vector3, angle: T } {
+            var copy = self;
+            if (@abs(copy.w) > 1) copy = copy.norm();
+
+            var res_axis = Vector3.zero();
+            const res_angle: T = 2 * math.acos(copy.w);
+            const den: T = @sqrt(1 - copy.w * copy.w);
+
+            if (den > 0.0001) {
+                res_axis.data[0] = copy.x / den;
+                res_axis.data[1] = copy.y / den;
+                res_axis.data[2] = copy.z / den;
+            } else {
+                // This occurs when the angle is zero.
+                // Not a problem: just set an arbitrary normalized axis.
+                res_axis.data[0] = 1;
+            }
+
+            return .{
+                .axis = res_axis,
+                .angle = root.toDegrees(res_angle),
+            };
+        }
+
+        /// Construct inverse quaternion
+        pub fn inv(self: Self) Self {
+            const res = Self.new(self.w, -self.x, -self.y, -self.z);
+            return res.scale(1 / self.dot(self));
+        }
+
+        /// Linear interpolation between two quaternions.
+        pub fn lerp(left: Self, right: Self, t: T) Self {
+            const w = root.lerp(T, left.w, right.w, t);
+            const x = root.lerp(T, left.x, right.x, t);
+            const y = root.lerp(T, left.y, right.y, t);
+            const z = root.lerp(T, left.z, right.z, t);
+            return Self.new(w, x, y, z);
+        }
+
+        // Shortest path slerp between two quaternions.
+        // Taken from "Physically Based Rendering, 3rd Edition, Chapter 2.9.2"
+        // https://pbr-book.org/3ed-2018/Geometry_and_Transformations/Animating_Transformations#QuaternionInterpolation
+        pub fn slerp(left: Self, right: Self, t: T) Self {
+            const ParallelThreshold = 0.9995;
+            var cos_theta = dot(left, right);
+            var right1 = right;
+
+            // We need the absolute value of the dot product to take the shortest path
+            if (cos_theta < 0) {
+                cos_theta *= -1;
+                right1 = right.negate();
+            }
+
+            if (cos_theta > ParallelThreshold) {
+                // Use regular old lerp to avoid numerical instability
+                return lerp(left, right1, t);
+            } else {
+                const theta = math.acos(math.clamp(cos_theta, -1, 1));
+                const thetap = theta * t;
+                var qperp = right1.sub(left.scale(cos_theta)).norm();
+                return left.scale(@cos(thetap)).add(qperp.scale(@sin(thetap)));
+            }
+        }
+
+        /// Rotate the Vector3 v using the sandwich product.
+        /// Taken from "Foundations of Game Engine Development Vol. 1 Mathematics".
+        pub fn rotateVec(self: Self, v: Vector3) Vector3 {
+            const q = self.norm();
+            const b = Vector3.new(q.x, q.y, q.z);
+            const b2 = b.dot(b);
+
+            return v.scale(q.w * q.w - b2).add(b.scale(v.dot(b) * 2)).add(b.cross(v).scale(q.w * 2));
+        }
+
+        /// Cast a type to another type.
+        /// It's like builtins: @intCast, @floatCast, @floatFromInt, @intFromFloat.
+        pub fn cast(self: Self, comptime dest_type: type) Quaternion(dest_type) {
+            const dest_info = @typeInfo(dest_type);
+
+            if (dest_info != .Float) {
+                std.debug.panic("Error, dest type should be float.\n", .{});
+            }
+
+            const w: dest_type = @floatCast(self.w);
+            const x: dest_type = @floatCast(self.x);
+            const y: dest_type = @floatCast(self.y);
+            const z: dest_type = @floatCast(self.z);
+            return Quaternion(dest_type).new(w, x, y, z);
+        }
+    };
+}
+
+test "zalgebra.Quaternion.new" {
+    const q = Quat.new(1.5, 2.6, 3.7, 4.7);
+
+    try expectEqual(q.w, 1.5);
+    try expectEqual(q.x, 2.6);
+    try expectEqual(q.y, 3.7);
+    try expectEqual(q.z, 4.7);
+}
+
+test "zalgebra.Quaternion.set" {
+    const a = Quat.set(12);
+    const b = Quat.new(12, 12, 12, 12);
+
+    try expectEqual(a, b);
+}
+
+test "zalgebra.Quaternion.eql" {
+    const a = Quat.new(1.5, 2.6, 3.7, 4.7);
+    const b = Quat.new(1.5, 2.6, 3.7, 4.7);
+    const c = Quat.new(2.6, 3.7, 4.8, 5.9);
+
+    try expectEqual(Quat.eql(a, b), true);
+    try expectEqual(Quat.eql(a, c), false);
+}
+
+test "zalgebra.Quaternion.fromSlice" {
+    const array = [4]f32{ 2, 3, 4, 1 };
+    try expectEqual(Quat.fromSlice(&array), Quat.new(1, 2, 3, 4));
+}
+
+test "zalgebra.Quaternion.fromVec3" {
+    const q = Quat.fromVec3(1.5, Vec3.new(2.6, 3.7, 4.7));
+
+    try expectEqual(q.w, 1.5);
+    try expectEqual(q.x, 2.6);
+    try expectEqual(q.y, 3.7);
+    try expectEqual(q.z, 4.7);
+
+    const a = Quat.fromVec3(1.5, Vec3.new(2.6, 3.7, 4.7));
+    const b = Quat.fromVec3(1.5, Vec3.new(2.6, 3.7, 4.7));
+    const c = Quat.fromVec3(1, Vec3.new(2.6, 3.7, 4.7));
+
+    try expectEqual(a, b);
+    try expectEqual(Quat.eql(a, c), false);
+}
+
+test "zalgebra.Quaternion.norm" {
+    const a = Quat.fromVec3(1, Vec3.new(2, 2, 2));
+    const b = Quat.fromVec3(0.2773500978946686, Vec3.new(0.5547001957893372, 0.5547001957893372, 0.5547001957893372));
+
+    try expectEqual(a.norm(), b);
+}
+
+test "zalgebra.Quaternion.fromEulerAngles" {
+    const a = Quat.fromEulerAngles(Vec3.new(10, 5, 45));
+    const a_res = a.extractEulerAngles();
+
+    const b = Quat.fromEulerAngles(Vec3.new(0, 55, 22));
+    const b_res = b.toMat4().extractEulerAngles();
+
+    try expectEqual(a_res, Vec3.new(9.999999046325684, 5.000000476837158, 45));
+    try expectEqual(b_res, Vec3.new(0, 47.2450294, 22));
+}
+
+test "zalgebra.Quaternion.fromAxis" {
+    const q = Quat.fromAxis(45, Vec3.up());
+    const res_q = q.extractEulerAngles();
+
+    try expectEqual(res_q, Vec3.new(0, 45.0000076, 0));
+}
+
+test "zalgebra.Quaternion.extractAxisAngle" {
+    const axis = Vec3.new(44, 120, 8).norm();
+    const q = Quat.fromAxis(45, axis);
+    const res = q.extractAxisAngle();
+
+    try expectApproxEqRel(axis.x(), res.axis.x(), eps_value);
+    try expectApproxEqRel(axis.y(), res.axis.y(), eps_value);
+    try expectApproxEqRel(axis.z(), res.axis.z(), eps_value);
+
+    try expectApproxEqRel(res.angle, 45.0000076, eps_value);
+}
+
+test "zalgebra.Quaternion.extractEulerAngles" {
+    const q = Quat.fromVec3(0.5, Vec3.new(0.5, 1, 0.3));
+    const res_q = q.extractEulerAngles();
+
+    try expectEqual(res_q, Vec3.new(129.6000213623047, 44.427005767822266, 114.4107360839843));
+}
+
+test "zalgebra.Quaternion.rotateVec" {
+    const q = Quat.fromEulerAngles(Vec3.set(45));
+    const m = q.toMat4();
+
+    const v = Vec3.up();
+    const v1 = q.rotateVec(v);
+    const v2 = m.mulByVec4(Vec4.new(v.x(), v.y(), v.z(), 1));
+
+    try expectApproxEqAbs(v1.x(), -1.46446585e-01, eps_value);
+    try expectApproxEqAbs(v1.y(), 8.53553473e-01, eps_value);
+    try expectApproxEqAbs(v1.z(), 0.5, eps_value);
+
+    try expectApproxEqAbs(v1.x(), v2.data[0], eps_value);
+    try expectApproxEqAbs(v1.y(), v2.data[1], eps_value);
+    try expectApproxEqAbs(v1.z(), v2.data[2], eps_value);
+}
+
+test "zalgebra.Quaternion.lerp" {
+    const a = Quat.identity();
+    const b = Quat.fromAxis(180, Vec3.up());
+    try expectEqual(Quat.lerp(a, b, 1), b);
+    const c = Quat.lerp(a, b, 0.5);
+    const d = Quat.new(0.5, 0, 0.5, 0);
+    try expectApproxEqAbs(c.w, d.w, eps_value);
+    try expectApproxEqAbs(c.x, d.x, eps_value);
+    try expectApproxEqAbs(c.y, d.y, eps_value);
+    try expectApproxEqAbs(c.z, d.z, eps_value);
+}
+
+test "zalgebra.Quaternion.slerp" {
+    const a = Quat.identity();
+    const b = Quat.fromAxis(180, Vec3.up());
+    try expectEqual(Quat.slerp(a, b, 1), Quat.new(7.54979012e-08, 0, -1, 0));
+    const c = Quat.slerp(a, b, 0.5);
+    const d = Quat.new(1, 0, -1, 0).norm();
+    try expectApproxEqAbs(c.w, d.w, eps_value);
+    try expectApproxEqAbs(c.x, d.x, eps_value);
+    try expectApproxEqAbs(c.y, d.y, eps_value);
+    try expectApproxEqAbs(c.z, d.z, eps_value);
+}
+
+test "zalgebra.Quaternion.cast" {
+    const a = Quat.new(3.5, 4.5, 5.5, 6.5);
+    const a_f64 = Quat_f64.new(3.5, 4.5, 5.5, 6.5);
+    try expectEqual(a.cast(f64), a_f64);
+    try expectEqual(a_f64.cast(f32), a);
+}
+
+test "zalgebra.Quaternion.inv" {
+    const out = Quat.new(7, 4, 5, 9).inv();
+    const answ = Quat.new(0.0409357, -0.0233918, -0.0292398, -0.0526316);
+    try expectApproxEqAbs(out.w, answ.w, eps_value);
+    try expectApproxEqAbs(out.x, answ.x, eps_value);
+    try expectApproxEqAbs(out.y, answ.y, eps_value);
+    try expectApproxEqAbs(out.z, answ.z, eps_value);
+}

extras/doomplayer/src/doom.zig

@@ -20,6 +20,12 @@ pub const DoomCanvas = struct {
     entity: core.Entity,
     first: bool = false,
 
+    pub fn cleanupDoom() void {
+        if (gDoom) |doom| {
+            doom.destroy();
+        }
+    }
+
     pub fn create(alloc: std.mem.Allocator) !*@This() {
         var first: bool = false;
         if (gDoom == null) {
@@ -57,9 +63,8 @@ pub const DoomCanvas = struct {
     }
 
     pub fn tick(self: *@This(), dt: f64) void {
-        if (self.first) {
-            gDoom.?.tick(dt);
-        }
+        _ = self;
+        _ = dt;
     }
 
     pub fn getEntity(self: *@This()) core.Entity {
@@ -68,9 +73,6 @@ pub const DoomCanvas = struct {
 
     pub fn destroy(self: *@This()) void {
         self.entity.destroy();
-        if (self.first) {
-            gDoom.?.destroy();
-        }
         self.data.release(self);
     }
 };
@@ -440,6 +442,12 @@ pub fn createTextures(self: *@This()) !void {
     });
 }
 
+pub fn maybeTick(dt: f64) void {
+    if (gDoom) |doom| {
+        doom.tick(dt);
+    }
+}
+
 pub fn tick(self: *@This(), dt: f64) void {
     _ = dt;
     c.doom_update();
@@ -462,8 +470,8 @@ pub fn tick(self: *@This(), dt: f64) void {
     if (self.inputEnabled) {
         if (ig.begin("doom settings", null, .{})) {
             _ = ig.sliderFloat("sensitivity", &self.sensitivity, 0.1, 20, null, .{});
-            ig.end();
         }
+        ig.end();
     }
 }
 
@@ -479,7 +487,7 @@ fn bindVideoTextures(p: ?*anyopaque) void {
 // creates a video player entity
 
 pub fn destroy(self: *@This()) void {
-    core.engine_logs("[Videoplayer] destroying player");
+    core.engine_logs("[Doom] destroying doom instance");
 
     self.allocator.destroy(self);
 }

extras/gameExtras/src/RendererDebug.zig

@@ -0,0 +1,46 @@
+dtAverage: f64 = 0.0,
+allocator: std.mem.Allocator,
+
+pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This());
+
+pub fn create(allocator: std.mem.Allocator) !*@This() {
+    const self = try allocator.create(@This());
+
+    self.* = .{ .allocator = allocator };
+
+    return self;
+}
+
+pub fn tick(self: *@This(), dt: f64) void {
+    core.rollingAverage(&self.dtAverage, dt, 50);
+
+    if (ig.begin("renderer debug", null, .{})) {
+        _ = ig.sliderFloat("directional light yaw", &rend.context().directionalLightYaw, 0, 360, null, .{});
+        _ = ig.sliderFloat("skyboxLevel", &rend.context().skyboxSystem.brightnessFactor, 0, 10, null, .{});
+        _ = ig.sliderFloat("lightLevel", &rend.context().lightPower, 0, 100, null, .{});
+        _ = ig.sliderFloat("ortho near", &rend.context().shadowOrthoNear, 0, 200, null, .{});
+        _ = ig.sliderFloat("ortho far", &rend.context().shadowOrthoFar, 0, 6000, null, .{});
+        if (self.dtAverage > 0.000001) {
+            ig.textFmt("frameTime: {d:.2}ms ({d:.2}fps)", .{ self.dtAverage * 1000, @as(u32, @intFromFloat(1 / self.dtAverage)) }) catch unreachable;
+        }
+
+        ig.textFmt("SSAO settings: ", .{}) catch unreachable;
+
+        const ssao = rend.context().ssaoSystem;
+        _ = ig.sliderFloat("radius", &ssao.radius, 0.1, 1.0, null, .{});
+        _ = ig.sliderFloat("bias", &ssao.bias, 0.0025, 1.0, null, .{});
+
+        _ = ig.checkbox("enable SSAO", &ssao.enable);
+    }
+    ig.end();
+}
+
+pub fn destroy(self: *@This()) void {
+    self.allocator.destroy(self);
+}
+
+const backlog = @import("Backlog");
+const core = backlog.core;
+const rend = backlog.rend;
+const ig = backlog.imgui.api;
+const std = @import("std");

extras/gameExtras/src/gameExtras.zig

@@ -1,5 +1,4 @@
 pub const FpCamera = @import("FpCamera.zig");
-
 pub const inputDebugger = @import("inputDebugger.zig");
-
 pub const ObjectSpawner = @import("objectSpawner.zig");
+pub const RendererDebug = @import("RendererDebug.zig");

extras/gameExtras/src/inputDebugger.zig

@@ -24,8 +24,8 @@ pub fn tick() void {
                 },
             }
         }
-        ig.end();
     }
+    ig.end();
 }
 
 const std = @import("std");

extras/gameExtras/src/objectSpawner.zig

@@ -25,23 +25,44 @@ pub fn create(allocator: std.mem.Allocator) !*@This() {
     return self;
 }
 
+pub fn objectSpawnOptions(self: *@This()) void {
+    for (self.spawnFuncs.items) |entry| {
+        if (ig.smallButton(entry.typeName.ptr)) {
+            if (entry.spawnFunc(self.objectList)) |new| {
+                const entity = new.vtable.getEntity.?(new.ptr);
+                if (!entry.opts.absoluteSpawnposition) {
+                    self.prepareEntity(entity);
+                }
+            }
+        }
+    }
+}
+
+fn spawnedObjectsList(self: *@This()) void {
+    for (self.objectList.objects.items, 0..) |interface, i| {
+        ig.textFmt("{s}", .{interface.vtable.objectName}) catch {};
+        ig.sameLine(0.0, 2.0);
+
+        ig.pushID_Int(@intCast(i));
+        if (ig.smallButton("delete me")) {
+            interface.vtable.destroy(interface.ptr);
+        }
+        ig.popID();
+    }
+}
+
 pub fn tick(self: *@This(), dt: f64) void {
     self.objectList.tick(dt);
 
     if (self.windowOpen) {
         if (ig.begin("object Spawner", null, .{})) {
-            for (self.spawnFuncs.items) |entry| {
-                if (ig.smallButton(entry.typeName.ptr)) {
-                    if (entry.spawnFunc(self.objectList)) |new| {
-                        const entity = new.vtable.getEntity.?(new.ptr);
-                        if (!entry.opts.absoluteSpawnposition) {
-                            self.prepareEntity(entity);
-                        }
-                    }
-                }
-            }
-            ig.end();
+            self.objectSpawnOptions();
         }
+        ig.end();
+        if (ig.begin("objects in scene", null, .{})) {
+            self.spawnedObjectsList();
+        }
+        ig.end();
     }
 }
 

extras/videoplayer/src/videoplayer.zig

@@ -226,11 +226,6 @@ pub fn tick(self: *@This(), dt: f64) void {
 
         self.currentFrame = thisFrame;
     }
-
-    if (ig.begin("videoPlayer", &self.showDebug, .{})) {
-        ig.textFmt("video frame: {d}", .{self.currentFrame}) catch unreachable;
-        ig.end();
-    }
 }
 
 fn bindVideoTextures(p: ?*anyopaque) void {

lib/cimgui/src/cimgui.zig

@@ -345,12 +345,13 @@ pub const HoveredFlags = packed struct(c_int) {
 };
 pub const DockNodeFlags = packed struct(c_int) {
     keep_alive_only: bool = false, // ImGuiDockNodeFlags_KeepAliveOnly = 1 << 0,
+    pad0: bool = false,
     no_docking_in_central_node: bool = false, // ImGuiDockNodeFlags_NoDockingInCentralNode = 1 << 2,
     passthru_central_node: bool = false, // ImGuiDockNodeFlags_PassthruCentralNode = 1 << 3,
     no_split: bool = false, // ImGuiDockNodeFlags_NoSplit = 1 << 4,
     no_resize: bool = false, // ImGuiDockNodeFlags_NoResize = 1 << 5,
     auto_hide_tab_bar: bool = false, // ImGuiDockNodeFlags_AutoHideTabBar = 1 << 6
-    reserved: u26 = 0, // reserved, don't use
+    reserved: u25 = 0, // reserved, don't use
 };
 pub const DragDropFlags = packed struct(c_int) {
     source_no_preview_tooltip: bool = false, // ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0,
@@ -3002,7 +3003,7 @@ pub inline fn dockSpace(id: ID, size: Vec2, flags: DockNodeFlags, window_class:
     return c.igDockSpace(id, @bitCast(size), @bitCast(flags), @ptrCast(window_class));
 }
 pub inline fn dockSpaceOverViewport(viewport: [*c]const Viewport, flags: DockNodeFlags, window_class: [*c]const WindowClass) ID { //igDockSpaceOverViewport
-    return c.igDockSpaceOverViewport(viewport, @bitCast(flags), @ptrCast(window_class));
+    return c.igDockSpaceOverViewport(getWindowDockID(), @ptrCast(viewport), @bitCast(flags), @ptrCast(window_class));
 }
 pub inline fn setNextWindowDockID(dock_id: ID, cond: Cond) void { //igSetNextWindowDockID
     c.igSetNextWindowDockID(dock_id, @bitCast(cond));

projects/build.zig

@@ -20,4 +20,5 @@ pub fn build(b: *std.Build) void {
     blbuild.addExtraModule(sampleGame, "gameExtras");
     blbuild.addExtraModule(sampleGame, "videoplayer");
     blbuild.addExtraModule(sampleGame, "doomplayer");
+    blbuild.addExtraModule(sampleGame, "bsp");
 }

projects/build.zig.zon

@@ -17,6 +17,7 @@
         .gameExtras = .{.path = "../extras/gameExtras"},
         .videoplayer = .{.path = "../extras/videoplayer"},
         .doomplayer = .{.path = "../extras/doomplayer"},
+        .bsp = .{.path = "../extras/bsp"},
     },
     .paths = .{
         "",

projects/content/bsp/autosave/testmap.1.map

@@ -0,0 +1,115 @@
+// Game: Deathwish
+// Format: Standard
+// entity 0
+{
+"classname" "worldspawn"
+// brush 0
+{
+( -288 -144 -16 ) ( -288 -143 -16 ) ( -288 -144 -15 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+( -128 -240 -16 ) ( -128 -240 -15 ) ( -127 -240 -16 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( -128 -144 -16 ) ( -127 -144 -16 ) ( -128 -143 -16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 -16 16 ) ( 0 -15 16 ) ( 1 -16 16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 352 16 ) ( 1 352 16 ) ( 0 352 17 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( 384 -16 16 ) ( 384 -16 17 ) ( 384 -15 16 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+}
+// brush 1
+{
+( 80 -80 16 ) ( 80 -79 16 ) ( 80 -80 17 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+( 80 -80 16 ) ( 80 -80 17 ) ( 81 -80 16 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 80 -80 16 ) ( 81 -80 16 ) ( 80 -79 16 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 96 ) ( 176 -63 96 ) ( 177 -64 96 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 32 ) ( 177 -64 32 ) ( 176 -64 33 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 176 -64 32 ) ( 176 -64 33 ) ( 176 -63 32 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+}
+// brush 2
+{
+( 80 -32 16 ) ( 80 -31 16 ) ( 80 -32 17 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+( 80 -32 16 ) ( 80 -32 17 ) ( 81 -32 16 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 80 -32 16 ) ( 81 -32 16 ) ( 80 -31 16 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 80 ) ( 96 81 80 ) ( 97 80 80 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 32 ) ( 97 80 32 ) ( 96 80 33 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 96 80 32 ) ( 96 80 33 ) ( 96 81 32 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+}
+// brush 3
+{
+( -160 -128 16 ) ( -160 -127 16 ) ( -160 -128 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -160 -128 16 ) ( -160 -128 17 ) ( -159 -128 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 -128 16 ) ( -159 -128 16 ) ( -160 -127 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 96 ) ( -128 1 96 ) ( -127 0 96 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 32 ) ( -127 0 32 ) ( -128 0 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -128 0 32 ) ( -128 0 33 ) ( -128 1 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 4
+{
+( -224 48 16 ) ( -224 49 16 ) ( -224 48 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -224 48 16 ) ( -224 48 17 ) ( -223 48 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -224 48 16 ) ( -223 48 16 ) ( -224 49 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 112 ) ( -160 129 112 ) ( -159 128 112 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 32 ) ( -159 128 32 ) ( -160 128 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 128 32 ) ( -160 128 33 ) ( -160 129 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 5
+{
+( -112 224 16 ) ( -112 225 16 ) ( -112 224 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -112 224 16 ) ( -112 224 17 ) ( -111 224 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -112 224 16 ) ( -111 224 16 ) ( -112 225 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 192 ) ( -64 305 192 ) ( -63 304 192 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 32 ) ( -63 304 32 ) ( -64 304 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -64 304 32 ) ( -64 304 33 ) ( -64 305 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 6
+{
+( 0 176 16 ) ( 0 177 16 ) ( 0 176 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 0 176 16 ) ( 0 176 17 ) ( 1 176 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 0 176 16 ) ( 1 176 16 ) ( 0 177 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 336 208 ) ( 176 337 208 ) ( 177 336 208 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 336 32 ) ( 177 336 32 ) ( 176 336 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 336 32 ) ( 176 336 33 ) ( 176 337 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 7
+{
+( 288 -32 16 ) ( 288 -31 16 ) ( 288 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 289 -32 16 ) ( 288 -31 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 176 ) ( 336 113 176 ) ( 337 112 176 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 337 112 32 ) ( 336 112 33 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 8
+{
+( 208 -192 16 ) ( 208 -191 16 ) ( 208 -192 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 208 -192 17 ) ( 209 -192 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 209 -192 16 ) ( 208 -191 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 144 ) ( 288 -127 144 ) ( 289 -128 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 289 -128 32 ) ( 288 -128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 288 -128 33 ) ( 288 -127 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 9
+{
+( 416 -112 16 ) ( 416 -111 16 ) ( 416 -112 17 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+( 416 -112 16 ) ( 416 -112 17 ) ( 417 -112 16 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 416 -112 16 ) ( 417 -112 16 ) ( 416 -111 16 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 240 ) ( 560 1 240 ) ( 561 0 240 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 32 ) ( 561 0 32 ) ( 560 0 33 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 560 0 32 ) ( 560 0 33 ) ( 560 1 32 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+}
+// brush 10
+{
+( 352 224 16 ) ( 352 225 16 ) ( 352 224 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 352 224 17 ) ( 353 224 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 353 224 16 ) ( 352 225 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 208 ) ( 512 289 208 ) ( 513 288 208 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 513 288 32 ) ( 512 288 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 512 288 33 ) ( 512 289 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+}
+// entity 1
+{
+"classname" "enemy_spawn"
+"origin" "-64 -48 40"
+}
+// entity 2
+{
+"classname" "info_player_start"
+"origin" "-96 128 40"
+}

projects/content/bsp/autosave/testmap.2.map

@@ -0,0 +1,187 @@
+// Game: Deathwish
+// Format: Standard
+// entity 0
+{
+"classname" "worldspawn"
+// brush 0
+{
+( -288 -144 -16 ) ( -288 -143 -16 ) ( -288 -144 -15 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+( -128 -240 -16 ) ( -128 -240 -15 ) ( -127 -240 -16 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( -128 -144 -16 ) ( -127 -144 -16 ) ( -128 -143 -16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 -16 16 ) ( 0 -15 16 ) ( 1 -16 16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 352 16 ) ( 1 352 16 ) ( 0 352 17 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( 384 -16 16 ) ( 384 -16 17 ) ( 384 -15 16 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+}
+// brush 1
+{
+( 80 -80 16 ) ( 80 -79 16 ) ( 80 -80 17 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+( 80 -80 16 ) ( 80 -80 17 ) ( 81 -80 16 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 80 -80 16 ) ( 81 -80 16 ) ( 80 -79 16 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 96 ) ( 176 -63 96 ) ( 177 -64 96 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 32 ) ( 177 -64 32 ) ( 176 -64 33 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 176 -64 32 ) ( 176 -64 33 ) ( 176 -63 32 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+}
+// brush 2
+{
+( 80 -32 16 ) ( 80 -31 16 ) ( 80 -32 17 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+( 80 -32 16 ) ( 80 -32 17 ) ( 81 -32 16 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 80 -32 16 ) ( 81 -32 16 ) ( 80 -31 16 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 80 ) ( 96 81 80 ) ( 97 80 80 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 32 ) ( 97 80 32 ) ( 96 80 33 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 96 80 32 ) ( 96 80 33 ) ( 96 81 32 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+}
+// brush 3
+{
+( -160 -128 16 ) ( -160 -127 16 ) ( -160 -128 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -160 -128 16 ) ( -160 -128 17 ) ( -159 -128 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 -128 16 ) ( -159 -128 16 ) ( -160 -127 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 96 ) ( -128 1 96 ) ( -127 0 96 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 32 ) ( -127 0 32 ) ( -128 0 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -128 0 32 ) ( -128 0 33 ) ( -128 1 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 4
+{
+( -224 48 16 ) ( -224 49 16 ) ( -224 48 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -224 48 16 ) ( -224 48 17 ) ( -223 48 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -224 48 16 ) ( -223 48 16 ) ( -224 49 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 112 ) ( -160 129 112 ) ( -159 128 112 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 32 ) ( -159 128 32 ) ( -160 128 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 128 32 ) ( -160 128 33 ) ( -160 129 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 5
+{
+( -112 224 16 ) ( -112 225 16 ) ( -112 224 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -112 224 16 ) ( -112 224 17 ) ( -111 224 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -112 224 16 ) ( -111 224 16 ) ( -112 225 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 192 ) ( -64 305 192 ) ( -63 304 192 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 32 ) ( -63 304 32 ) ( -64 304 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -64 304 32 ) ( -64 304 33 ) ( -64 305 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 6
+{
+( 0 176 16 ) ( 0 177 16 ) ( 0 176 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 0 176 16 ) ( 0 176 17 ) ( 1 176 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 0 176 16 ) ( 1 176 16 ) ( 0 177 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 336 208 ) ( 176 337 208 ) ( 177 336 208 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 336 32 ) ( 177 336 32 ) ( 176 336 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 336 32 ) ( 176 336 33 ) ( 176 337 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 7
+{
+( 208 -192 16 ) ( 208 -191 16 ) ( 208 -192 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 208 -192 17 ) ( 209 -192 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 209 -192 16 ) ( 208 -191 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 144 ) ( 288 -127 144 ) ( 289 -128 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 289 -128 32 ) ( 288 -128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 288 -128 33 ) ( 288 -127 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 8
+{
+( 416 -112 16 ) ( 416 -111 16 ) ( 416 -112 17 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+( 416 -112 16 ) ( 416 -112 17 ) ( 417 -112 16 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 416 -112 16 ) ( 417 -112 16 ) ( 416 -111 16 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 240 ) ( 560 1 240 ) ( 561 0 240 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 32 ) ( 561 0 32 ) ( 560 0 33 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 560 0 32 ) ( 560 0 33 ) ( 560 1 32 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+}
+// brush 9
+{
+( 352 224 16 ) ( 352 225 16 ) ( 352 224 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 352 224 17 ) ( 353 224 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 353 224 16 ) ( 352 225 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 208 ) ( 512 289 208 ) ( 513 288 208 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 513 288 32 ) ( 512 288 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 512 288 33 ) ( 512 289 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 10
+{
+( -16 -304 16 ) ( -16 -303 16 ) ( -16 -304 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -16 -304 16 ) ( -16 -304 17 ) ( -15 -304 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -16 -304 16 ) ( -15 -304 16 ) ( -16 -303 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 16 -128 240 ) ( 16 -127 240 ) ( 17 -128 240 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 16 -128 32 ) ( 17 -128 32 ) ( 16 -128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 16 -128 32 ) ( 16 -128 33 ) ( 16 -127 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 11
+{
+( -272 -288 16 ) ( -272 -287 16 ) ( -272 -288 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -272 -288 16 ) ( -272 -288 17 ) ( -271 -288 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -272 -288 16 ) ( -271 -288 16 ) ( -272 -287 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -176 -79 32 ) ( -175 -80 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -175 -80 32 ) ( -176 -80 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -176 -80 33 ) ( -176 -79 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 12
+{
+( -96 -432 16 ) ( -96 -431 16 ) ( -96 -432 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -96 -432 16 ) ( -96 -432 17 ) ( -95 -432 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -96 -432 16 ) ( -95 -432 16 ) ( -96 -431 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -64 -192 432 ) ( -64 -191 432 ) ( -63 -192 432 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -64 -192 32 ) ( -63 -192 32 ) ( -64 -192 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -64 -192 32 ) ( -64 -192 33 ) ( -64 -191 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 13
+{
+( 304 16 96 ) ( 304 17 96 ) ( 304 16 97 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 16 96 ) ( 304 16 97 ) ( 305 16 96 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 304 16 96 ) ( 305 16 96 ) ( 304 17 96 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 320 49 112 ) ( 321 48 112 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 321 48 112 ) ( 320 48 113 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 320 48 113 ) ( 320 49 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 14
+{
+( 256 -48 128 ) ( 256 -47 128 ) ( 256 -48 129 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -48 128 ) ( 288 -48 129 ) ( 289 -48 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -48 128 ) ( 289 -48 128 ) ( 288 -47 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 0 144 ) ( 304 1 144 ) ( 305 0 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 64 144 ) ( 305 64 144 ) ( 304 64 145 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 0 144 ) ( 304 0 145 ) ( 304 1 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 15
+{
+( 288 -32 16 ) ( 288 -31 16 ) ( 288 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 16 96 ) ( 288 0 112 ) ( 416 0 112 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 176 ) ( 336 113 176 ) ( 337 112 176 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 80 128 ) ( 288 32 96 ) ( 416 32 96 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 337 112 32 ) ( 336 112 33 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 16
+{
+( 272 -32 16 ) ( 272 -31 16 ) ( 272 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 80 128 ) ( 288 32 96 ) ( 416 32 96 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 16 96 ) ( 416 0 112 ) ( 288 0 112 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 17
+{
+( 160 32 16 ) ( 160 33 16 ) ( 160 32 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 160 32 16 ) ( 160 32 17 ) ( 161 32 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 160 32 16 ) ( 161 32 16 ) ( 160 33 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 112 ) ( 176 129 112 ) ( 177 128 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 32 ) ( 177 128 32 ) ( 176 128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 32 ) ( 176 128 33 ) ( 176 129 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 18
+{
+( 256 16 16 ) ( 256 17 16 ) ( 256 16 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 256 16 16 ) ( 256 16 17 ) ( 257 16 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 256 16 16 ) ( 257 16 16 ) ( 256 17 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 112 ) ( 272 129 112 ) ( 273 128 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 32 ) ( 273 128 32 ) ( 272 128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 32 ) ( 272 128 33 ) ( 272 129 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+}
+// entity 1
+{
+"classname" "enemy_spawn"
+"origin" "-64 -48 40"
+}
+// entity 2
+{
+"classname" "info_player_start"
+"origin" "-96 128 40"
+}

projects/content/bsp/autosave/testmap.3.map

@@ -0,0 +1,821 @@
+// Game: Deathwish
+// Format: Standard
+// entity 0
+{
+"classname" "worldspawn"
+// brush 0
+{
+( -288 -144 -16 ) ( -288 -143 -16 ) ( -288 -144 -15 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+( -128 -240 -16 ) ( -128 -240 -15 ) ( -127 -240 -16 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( -128 -144 -16 ) ( -127 -144 -16 ) ( -128 -143 -16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 -16 16 ) ( 0 -15 16 ) ( 1 -16 16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 1456 16 ) ( 1 1456 16 ) ( 0 1456 17 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( 1328 -16 16 ) ( 1328 -16 17 ) ( 1328 -15 16 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+}
+// brush 1
+{
+( 80 -80 16 ) ( 80 -79 16 ) ( 80 -80 17 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+( 80 -80 16 ) ( 80 -80 17 ) ( 81 -80 16 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 80 -80 16 ) ( 81 -80 16 ) ( 80 -79 16 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 96 ) ( 176 -63 96 ) ( 177 -64 96 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 32 ) ( 177 -64 32 ) ( 176 -64 33 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 176 -64 32 ) ( 176 -64 33 ) ( 176 -63 32 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+}
+// brush 2
+{
+( 80 -32 16 ) ( 80 -31 16 ) ( 80 -32 17 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+( 80 -32 16 ) ( 80 -32 17 ) ( 81 -32 16 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 80 -32 16 ) ( 81 -32 16 ) ( 80 -31 16 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 80 ) ( 96 81 80 ) ( 97 80 80 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 32 ) ( 97 80 32 ) ( 96 80 33 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 96 80 32 ) ( 96 80 33 ) ( 96 81 32 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+}
+// brush 3
+{
+( -160 -128 16 ) ( -160 -127 16 ) ( -160 -128 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -160 -128 16 ) ( -160 -128 17 ) ( -159 -128 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 -128 16 ) ( -159 -128 16 ) ( -160 -127 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 96 ) ( -128 1 96 ) ( -127 0 96 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 32 ) ( -127 0 32 ) ( -128 0 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -128 0 32 ) ( -128 0 33 ) ( -128 1 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 4
+{
+( -224 48 16 ) ( -224 49 16 ) ( -224 48 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -224 48 16 ) ( -224 48 17 ) ( -223 48 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -224 48 16 ) ( -223 48 16 ) ( -224 49 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 112 ) ( -160 129 112 ) ( -159 128 112 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 32 ) ( -159 128 32 ) ( -160 128 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 128 32 ) ( -160 128 33 ) ( -160 129 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 5
+{
+( -112 224 16 ) ( -112 225 16 ) ( -112 224 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -112 224 16 ) ( -112 224 17 ) ( -111 224 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -112 224 16 ) ( -111 224 16 ) ( -112 225 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 192 ) ( -64 305 192 ) ( -63 304 192 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 32 ) ( -63 304 32 ) ( -64 304 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -64 304 32 ) ( -64 304 33 ) ( -64 305 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 6
+{
+( 208 -192 16 ) ( 208 -191 16 ) ( 208 -192 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 208 -192 17 ) ( 209 -192 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 209 -192 16 ) ( 208 -191 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 144 ) ( 288 -127 144 ) ( 289 -128 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 289 -128 32 ) ( 288 -128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 288 -128 33 ) ( 288 -127 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 7
+{
+( 416 -112 16 ) ( 416 -111 16 ) ( 416 -112 17 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+( 416 -112 16 ) ( 416 -112 17 ) ( 417 -112 16 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 416 -112 16 ) ( 417 -112 16 ) ( 416 -111 16 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 144 ) ( 560 1 144 ) ( 561 0 144 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 32 ) ( 561 0 32 ) ( 560 0 33 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 560 0 32 ) ( 560 0 33 ) ( 560 1 32 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+}
+// brush 8
+{
+( 352 224 16 ) ( 352 225 16 ) ( 352 224 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 352 224 17 ) ( 353 224 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 353 224 16 ) ( 352 225 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 208 ) ( 512 289 208 ) ( 513 288 208 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 513 288 32 ) ( 512 288 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 512 288 33 ) ( 512 289 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 9
+{
+( -272 -288 16 ) ( -272 -287 16 ) ( -272 -288 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -272 -288 16 ) ( -272 -288 17 ) ( -271 -288 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -272 -288 16 ) ( -271 -288 16 ) ( -272 -287 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -176 -79 32 ) ( -175 -80 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -175 -80 32 ) ( -176 -80 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -176 -80 33 ) ( -176 -79 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 10
+{
+( 304 16 96 ) ( 304 17 96 ) ( 304 16 97 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 16 96 ) ( 304 16 97 ) ( 305 16 96 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 304 16 96 ) ( 305 16 96 ) ( 304 17 96 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 320 49 112 ) ( 321 48 112 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 321 48 112 ) ( 320 48 113 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 320 48 113 ) ( 320 49 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 11
+{
+( 256 -48 128 ) ( 256 -47 128 ) ( 256 -48 129 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -48 128 ) ( 288 -48 129 ) ( 289 -48 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -48 128 ) ( 289 -48 128 ) ( 288 -47 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 0 144 ) ( 304 1 144 ) ( 305 0 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 64 144 ) ( 305 64 144 ) ( 304 64 145 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 0 144 ) ( 304 0 145 ) ( 304 1 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 12
+{
+( 288 -32 16 ) ( 288 -31 16 ) ( 288 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 16 96 ) ( 288 0 112 ) ( 416 0 112 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 416 ) ( 336 113 416 ) ( 337 112 416 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 80 128 ) ( 288 32 96 ) ( 416 32 96 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 337 112 32 ) ( 336 112 33 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 13
+{
+( 272 -32 16 ) ( 272 -31 16 ) ( 272 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 80 128 ) ( 288 32 96 ) ( 416 32 96 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 16 96 ) ( 416 0 112 ) ( 288 0 112 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 14
+{
+( 160 32 16 ) ( 160 33 16 ) ( 160 32 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 160 32 16 ) ( 160 32 17 ) ( 161 32 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 160 32 16 ) ( 161 32 16 ) ( 160 33 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 112 ) ( 176 129 112 ) ( 177 128 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 32 ) ( 177 128 32 ) ( 176 128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 32 ) ( 176 128 33 ) ( 176 129 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 15
+{
+( 256 16 16 ) ( 256 17 16 ) ( 256 16 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 256 16 16 ) ( 256 16 17 ) ( 257 16 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 256 16 16 ) ( 257 16 16 ) ( 256 17 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 112 ) ( 272 129 112 ) ( 273 128 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 32 ) ( 273 128 32 ) ( 272 128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 32 ) ( 272 128 33 ) ( 272 129 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 16
+{
+( 112 -176 80 ) ( 112 -176 64 ) ( 112 -48 64 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 96 -208 17 ) ( 97 -208 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 97 -208 16 ) ( 96 -207 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 176 -176 64 ) ( 176 -175 64 ) ( 177 -176 64 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 177 -176 32 ) ( 176 -176 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 144 -176 48 ) ( 144 -176 80 ) ( 144 -48 80 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 17
+{
+( 144 -176 48 ) ( 144 -48 80 ) ( 144 -176 80 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 96 -208 17 ) ( 97 -208 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 97 -208 16 ) ( 96 -207 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 128 ) ( 176 -175 128 ) ( 177 -176 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 177 -176 32 ) ( 176 -176 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 176 -176 33 ) ( 176 -175 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 18
+{
+( 96 -208 16 ) ( 96 -207 16 ) ( 96 -208 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 96 -208 17 ) ( 97 -208 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 97 -208 16 ) ( 96 -207 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 128 ) ( 176 -175 128 ) ( 177 -176 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 177 -176 32 ) ( 176 -176 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 112 -176 80 ) ( 112 -48 64 ) ( 112 -176 64 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 19
+{
+( 96 272 16 ) ( 96 273 16 ) ( 96 272 17 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 272 16 ) ( 96 272 17 ) ( 97 272 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 272 16 ) ( 97 272 16 ) ( 96 273 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 224 336 384 ) ( 224 337 384 ) ( 225 336 384 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 224 336 32 ) ( 225 336 32 ) ( 224 336 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 224 336 32 ) ( 224 336 33 ) ( 224 337 32 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 20
+{
+( 336 112 16 ) ( 336 113 16 ) ( 336 112 17 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 112 16 ) ( 336 112 17 ) ( 337 112 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 112 16 ) ( 337 112 16 ) ( 336 113 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 416 208 112 ) ( 416 209 112 ) ( 417 208 112 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 416 208 32 ) ( 417 208 32 ) ( 416 208 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 416 208 32 ) ( 416 208 33 ) ( 416 209 32 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 21
+{
+( 144 160 16 ) ( 144 161 16 ) ( 144 160 17 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 144 160 16 ) ( 144 160 17 ) ( 145 160 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 144 160 16 ) ( 145 160 16 ) ( 144 161 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 192 272 224 ) ( 192 273 224 ) ( 193 272 224 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 192 272 32 ) ( 193 272 32 ) ( 192 272 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 192 272 32 ) ( 192 272 33 ) ( 192 273 32 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 22
+{
+( 320 -224 128 ) ( 320 -223 128 ) ( 320 -224 129 ) mapping_defaults/ProtoGrey 128 0 0 0.25 0.25
+( 320 -224 128 ) ( 320 -224 129 ) ( 321 -224 128 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 320 -224 128 ) ( 321 -224 128 ) ( 320 -223 128 ) mapping_defaults/ProtoGrey 0 -128 0 0.25 0.25
+( 368 -160 144 ) ( 368 -159 144 ) ( 369 -160 144 ) mapping_defaults/ProtoGrey 0 -128 0 0.25 0.25
+( 368 -160 144 ) ( 369 -160 144 ) ( 368 -160 145 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 368 -160 144 ) ( 368 -160 145 ) ( 368 -159 144 ) mapping_defaults/ProtoGrey 128 0 0 0.25 0.25
+}
+// brush 23
+{
+( 336 0 304 ) ( 336 1 304 ) ( 336 0 305 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 0 304 ) ( 336 0 305 ) ( 337 0 304 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 0 304 ) ( 337 0 304 ) ( 336 1 304 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 384 96 320 ) ( 384 97 320 ) ( 385 96 320 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 384 96 320 ) ( 385 96 320 ) ( 384 96 321 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 560 96 320 ) ( 560 96 321 ) ( 560 97 320 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 24
+{
+( 17.071796769724585 1215.7128129211023 96 ) ( 49.07179676972447 1160.2871870788977 96 ) ( 49.07179676972447 1160.2871870788977 16 ) mapping_defaults/ProtoDark -222.7843 -48 0 0.8660254 1
+( 24 1219.7128129211023 16 ) ( 24 1219.7128129211023 96 ) ( 17.071796769724585 1215.7128129211023 96 ) mapping_defaults/ProtoDark -171.7128 -48 0 0.8660254 1
+( 56 1164.2871870788977 16 ) ( 24 1219.7128129211023 16 ) ( 17.071796769724585 1215.7128129211023 16 ) mapping_defaults/ProtoDark -113.64099 255.30194 30 1 1
+( 17.071796769724585 1215.7128129211023 96 ) ( 24 1219.7128129211023 96 ) ( 56 1164.2871870788977 96 ) mapping_defaults/ProtoDark -113.64099 255.30194 30 1 1
+( 49.07179676972447 1160.2871870788977 96 ) ( 56 1164.2871870788977 96 ) ( 56 1164.2871870788977 16 ) mapping_defaults/ProtoDark -171.66324 -48 0 0.8660254 1
+( 56 1164.2871870788977 96 ) ( 24 1219.7128129211023 96 ) ( 24 1219.7128129211023 16 ) mapping_defaults/ProtoDark -222.40308 -48 0 0.8660254 1
+}
+// brush 25
+{
+( 1.3725830020305807 1241.3725830020303 96 ) ( 7.029437251522893 1235.7157287525379 96 ) ( 7.029437251522893 1235.7157287525379 16 ) mapping_defaults/ProtoDark 53.565918 -48 180 0.70710677 -1
+( 46.62741699796953 1286.6274169979697 96 ) ( 1.3725830020305807 1241.3725830020303 96 ) ( 1.3725830020305807 1241.3725830020303 16 ) mapping_defaults/ProtoDark -53.565918 -48 0 0.70710677 1
+( 7.029437251522893 1235.7157287525379 16 ) ( 52.28427124746196 1280.9705627484773 16 ) ( 46.62741699796953 1286.6274169979697 16 ) mapping_defaults/ProtoDark 120.81244 189.75354 315 1 1
+( 46.62741699796953 1286.6274169979697 96 ) ( 52.28427124746196 1280.9705627484773 96 ) ( 7.029437251522893 1235.7157287525379 96 ) mapping_defaults/ProtoDark 120.81244 189.75354 315 1 1
+( 52.28427124746196 1280.9705627484773 16 ) ( 52.28427124746196 1280.9705627484773 96 ) ( 46.62741699796953 1286.6274169979697 96 ) mapping_defaults/ProtoDark 53.565918 -48 180 0.70710677 -1
+( 7.029437251522893 1235.7157287525379 96 ) ( 52.28427124746196 1280.9705627484773 96 ) ( 52.28427124746196 1280.9705627484773 16 ) mapping_defaults/ProtoDark -53.565918 -48 0 0.70710677 1
+}
+// brush 26
+{
+( 48 1280 16 ) ( 48 1281 16 ) ( 48 1280 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1280 16 ) ( 48 1280 17 ) ( 49 1280 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1280 16 ) ( 49 1280 16 ) ( 48 1281 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 200 1288 120 ) ( 200 1289 120 ) ( 201 1288 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 200 1288 24 ) ( 201 1288 24 ) ( 200 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 200 1288 24 ) ( 200 1288 25 ) ( 200 1289 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 27
+{
+( 48 1264 96 ) ( 48 1265 96 ) ( 48 1264 97 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1144 96 ) ( 48 1144 97 ) ( 49 1144 96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1264 96 ) ( 49 1264 96 ) ( 48 1265 96 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1280 120 ) ( 56 1281 120 ) ( 57 1280 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1280 104 ) ( 57 1280 104 ) ( 56 1280 105 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1280 104 ) ( 56 1280 105 ) ( 56 1281 104 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 28
+{
+( 48 1144 16 ) ( 48 1145 16 ) ( 48 1144 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1144 16 ) ( 48 1144 17 ) ( 49 1144 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1144 16 ) ( 49 1144 16 ) ( 48 1145 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1160 96 ) ( 56 1161 96 ) ( 57 1160 96 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1160 24 ) ( 57 1160 24 ) ( 56 1160 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1160 24 ) ( 56 1160 25 ) ( 56 1161 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 29
+{
+( 48 1112 16 ) ( 48 1113 16 ) ( 48 1112 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1112 16 ) ( 48 1112 17 ) ( 49 1112 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1112 16 ) ( 49 1112 16 ) ( 48 1113 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 64 1144 120 ) ( 64 1145 120 ) ( 65 1144 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 64 1144 24 ) ( 65 1144 24 ) ( 64 1144 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1144 24 ) ( 56 1144 25 ) ( 56 1145 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 30
+{
+( 248 1208 64 ) ( 200 1288 64 ) ( 200 1288 120 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 248 1208 120 ) ( 256 1202.6666666666606 120 ) ( 256 1202.6666666666579 64 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1202.6666666666579 64 ) ( 256 1288 64 ) ( 200 1288 64 ) mapping_defaults/ProtoDark -80 223.99988 0 1 1
+( 200 1288 120 ) ( 256 1288 120 ) ( 256 1202.6666666666606 120 ) mapping_defaults/ProtoDark -80 223.99988 0 1 1
+( 256 1288 64 ) ( 256 1288 120 ) ( 200 1288 120 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1202.6666666666606 120 ) ( 256 1288 120 ) ( 256 1288 64 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 31
+{
+( 200 1200 16 ) ( 200 1201 16 ) ( 200 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 200 1240 96 ) ( 224 1224 224 ) ( 224 1224 96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 200 1200 16 ) ( 201 1200 16 ) ( 200 1201 16 ) mapping_defaults/ProtoDark -80 224.99988 0 1 1
+( 200 1240 64 ) ( 224 1352 64 ) ( 224 1224 64 ) mapping_defaults/ProtoDark -80 224.99988 0 1 1
+( 360 1288 24 ) ( 361 1288 24 ) ( 360 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1288 24 ) ( 256 1288 25 ) ( 256 1289 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 32
+{
+( 256 1200 16 ) ( 256 1201 16 ) ( 256 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 256 1200 16 ) ( 256 1200 17 ) ( 257 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1200 16 ) ( 257 1200 16 ) ( 256 1201 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 264 1296 120 ) ( 264 1297 120 ) ( 265 1296 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 264 1288 24 ) ( 265 1288 24 ) ( 264 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1296 24 ) ( 272 1296 25 ) ( 272 1297 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 33
+{
+( 448 1200 16 ) ( 448 1201 16 ) ( 448 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 440 1200 16 ) ( 440 1200 17 ) ( 441 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 440 1200 16 ) ( 441 1200 16 ) ( 440 1201 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1296 120 ) ( 448 1297 120 ) ( 449 1296 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1288 24 ) ( 449 1288 24 ) ( 448 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1296 24 ) ( 456 1296 25 ) ( 456 1297 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 34
+{
+( 272 1200 112 ) ( 272 1201 112 ) ( 272 1200 113 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 112 ) ( 272 1200 113 ) ( 273 1200 112 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1200 112 ) ( 273 1200 112 ) ( 272 1201 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1288 120 ) ( 280 1289 120 ) ( 281 1288 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1288 120 ) ( 281 1288 120 ) ( 280 1288 121 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1288 120 ) ( 448 1288 121 ) ( 448 1289 120 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 35
+{
+( 272 1200 96 ) ( 272 1201 96 ) ( 272 1200 97 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 96 ) ( 272 1200 97 ) ( 273 1200 96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1200 96 ) ( 273 1200 96 ) ( 272 1201 96 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 312 1208 112 ) ( 312 1209 112 ) ( 313 1208 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 312 1208 104 ) ( 313 1208 104 ) ( 312 1208 105 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1208 104 ) ( 448 1208 105 ) ( 448 1209 104 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 36
+{
+( 264 1288 16 ) ( 264 1289 16 ) ( 264 1288 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 264 1288 16 ) ( 264 1288 17 ) ( 265 1288 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 1288 16 ) ( 265 1288 16 ) ( 264 1289 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 272 1344 120 ) ( 272 1345 120 ) ( 273 1344 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 272 1344 24 ) ( 273 1344 24 ) ( 272 1344 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1344 24 ) ( 272 1344 25 ) ( 272 1345 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 37
+{
+( 272 1288 112 ) ( 272 1289 112 ) ( 272 1288 113 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1288 112 ) ( 272 1288 113 ) ( 273 1288 112 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1288 112 ) ( 273 1288 112 ) ( 272 1289 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1344 120 ) ( 280 1345 120 ) ( 281 1344 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1344 120 ) ( 281 1344 120 ) ( 280 1344 121 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1344 120 ) ( 456 1344 121 ) ( 456 1345 120 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 38
+{
+( 272 1336 16 ) ( 272 1337 16 ) ( 272 1336 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1336 16 ) ( 272 1336 17 ) ( 273 1336 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1336 16 ) ( 273 1336 16 ) ( 272 1337 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 392 1344 112 ) ( 392 1345 112 ) ( 393 1344 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 392 1344 24 ) ( 393 1344 24 ) ( 392 1344 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1344 24 ) ( 456 1344 25 ) ( 456 1345 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 39
+{
+( 56 1112 16 ) ( 56 1113 16 ) ( 56 1112 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 56 1112 16 ) ( 56 1112 17 ) ( 57 1112 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1112 16 ) ( 57 1112 16 ) ( 56 1113 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 120 ) ( 504 1121 120 ) ( 505 1120 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 24 ) ( 505 1120 24 ) ( 504 1120 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 1112 80 ) ( 176 1112 88 ) ( 176 1240 88 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 40
+{
+( 176 1112 120 ) ( 176 1240 128 ) ( 176 1112 128 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 56 1112 56 ) ( 56 1112 57 ) ( 57 1112 56 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1112 88 ) ( 57 1112 88 ) ( 56 1113 88 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 128 ) ( 504 1121 128 ) ( 505 1120 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 64 ) ( 505 1120 64 ) ( 504 1120 65 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1112 104 ) ( 240 1112 112 ) ( 240 1240 112 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 41
+{
+( 240 1112 64 ) ( 240 1240 72 ) ( 240 1112 72 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 56 1112 16 ) ( 56 1112 17 ) ( 57 1112 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 56 1112 16 ) ( 57 1112 16 ) ( 56 1113 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1120 128 ) ( 504 1121 128 ) ( 505 1120 128 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1120 24 ) ( 505 1120 24 ) ( 504 1120 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 1120 24 ) ( 504 1120 25 ) ( 504 1121 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 42
+{
+( 496 904 16 ) ( 496 905 16 ) ( 496 904 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 496 896 16 ) ( 496 896 17 ) ( 497 896 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 496 904 16 ) ( 497 904 16 ) ( 496 905 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1112 272 ) ( 504 1113 272 ) ( 505 1112 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1120 24 ) ( 505 1120 24 ) ( 504 1120 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 1112 24 ) ( 504 1112 25 ) ( 504 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 43
+{
+( 240 1120 120 ) ( 240 1121 120 ) ( 240 1120 121 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 240 1120 120 ) ( 240 1120 121 ) ( 241 1120 120 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1120 120 ) ( 241 1120 120 ) ( 240 1121 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 456 1288 128 ) ( 456 1289 128 ) ( 457 1288 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 456 1288 128 ) ( 457 1288 128 ) ( 456 1288 129 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1288 128 ) ( 456 1288 129 ) ( 456 1289 128 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 44
+{
+( 176 1008 224 ) ( 176 1009 224 ) ( 176 1008 225 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 184 1008 224 ) ( 184 1008 225 ) ( 185 1008 224 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 184 1008 224 ) ( 185 1008 224 ) ( 184 1009 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 496 1088 272 ) ( 496 1089 272 ) ( 497 1088 272 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 496 1116 232 ) ( 497 1116 232 ) ( 496 1116 233 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1088 232 ) ( 496 1088 233 ) ( 496 1089 232 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 45
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 248 ) ( 304 936 248 ) ( 176 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1112 272 ) ( 176 1113 272 ) ( 177 1112 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1116 24 ) ( 177 1116 24 ) ( 176 1116 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 46
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 952 216 ) ( 176 952 232 ) ( 304 952 232 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1116 24 ) ( 177 1116 24 ) ( 176 1116 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 47
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 872 216 ) ( 176 872 224 ) ( 304 872 224 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 216 ) ( 304 912 224 ) ( 176 912 224 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 48
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 784 216 ) ( 176 784 224 ) ( 304 784 224 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 832 216 ) ( 304 832 232 ) ( 176 832 232 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 49
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 744 224 ) ( 304 744 232 ) ( 176 744 232 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 50
+{
+( 176 912 264 ) ( 176 913 264 ) ( 176 912 265 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 176 656 264 ) ( 176 656 265 ) ( 177 656 264 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 912 264 ) ( 177 912 264 ) ( 176 913 264 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 496 1008 272 ) ( 496 1009 272 ) ( 497 1008 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 496 1008 272 ) ( 497 1008 272 ) ( 496 1008 273 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 368 1008 272 ) ( 368 1008 273 ) ( 368 1009 272 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 51
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 720 112 ) ( 304 784 112 ) ( 176 784 112 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 208 ) ( 176 936 208 ) ( 304 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1116 24 ) ( 177 1116 24 ) ( 176 1116 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 52
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 168 1056 16 ) ( 169 1056 16 ) ( 168 1057 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 720 112 ) ( 176 784 112 ) ( 304 784 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 728 32 ) ( 304 728 40 ) ( 176 728 40 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 53
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 816 40 ) ( 176 816 56 ) ( 304 816 56 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 168 1056 16 ) ( 169 1056 16 ) ( 168 1057 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 720 112 ) ( 176 784 112 ) ( 304 784 112 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1112 24 ) ( 177 1112 24 ) ( 176 1112 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 54
+{
+( 168 656 16 ) ( 168 657 16 ) ( 168 656 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 656 16 ) ( 168 656 17 ) ( 169 656 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 168 656 16 ) ( 169 656 16 ) ( 168 657 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 696 272 ) ( 176 697 272 ) ( 177 696 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 696 24 ) ( 177 696 24 ) ( 176 696 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 696 24 ) ( 176 696 25 ) ( 176 697 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 55
+{
+( 496 656 264 ) ( 496 657 264 ) ( 496 656 265 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 496 656 264 ) ( 496 656 265 ) ( 497 656 264 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 496 656 184 ) ( 497 656 184 ) ( 496 657 184 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 896 272 ) ( 504 897 272 ) ( 505 896 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 896 272 ) ( 505 896 272 ) ( 504 896 273 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 896 272 ) ( 504 896 273 ) ( 504 897 272 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 56
+{
+( 168 640 16 ) ( 168 641 16 ) ( 168 640 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 648 16 ) ( 168 648 17 ) ( 169 648 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 168 640 16 ) ( 169 640 16 ) ( 168 641 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 536 656 272 ) ( 536 657 272 ) ( 537 656 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 536 656 24 ) ( 537 656 24 ) ( 536 656 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 536 656 24 ) ( 536 656 25 ) ( 536 657 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 57
+{
+( 496 656 176 ) ( 496 657 176 ) ( 496 656 177 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 496 656 176 ) ( 496 656 177 ) ( 497 656 176 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 496 656 16 ) ( 497 656 16 ) ( 496 657 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 664 184 ) ( 504 665 184 ) ( 505 664 184 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 728 184 ) ( 505 728 184 ) ( 504 728 185 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 664 184 ) ( 504 664 185 ) ( 504 665 184 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 58
+{
+( 176 688 128 ) ( 176 689 128 ) ( 176 688 129 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 176 656 128 ) ( 176 656 129 ) ( 177 656 128 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 688 128 ) ( 177 688 128 ) ( 176 689 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 872 136 ) ( 240 873 136 ) ( 241 872 136 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 944 136 ) ( 241 944 136 ) ( 240 944 137 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 872 136 ) ( 264 872 137 ) ( 264 873 136 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 59
+{
+( 260 860 136 ) ( 260 861 136 ) ( 260 860 137.85714285714275 ) mapping_defaults/ProtoDark -224 -110.769226 0 1 1.8571428
+( 260 704 136 ) ( 260 704 137.85714285714275 ) ( 261.8571428571426 704 136 ) mapping_defaults/ProtoDark 40 -110.769226 0 1.8571428 1.8571428
+( 260 860 136 ) ( 261.8571428571426 860 136 ) ( 260 861 136 ) mapping_defaults/ProtoDark 40 224 0 1.8571428 1
+( 267.42857142857144 992 188 ) ( 267.42857142857144 993 188 ) ( 269.2857142857146 992 188 ) mapping_defaults/ProtoDark 40 224 0 1.8571428 1
+( 267.42857142857144 944 143.42857142857122 ) ( 269.2857142857146 944 143.42857142857122 ) ( 267.42857142857144 944 145.28571428571453 ) mapping_defaults/ProtoDark 40 -110.769226 0 1.8571428 1.8571428
+( 267.42857142857144 992 143.42857142857122 ) ( 267.42857142857144 992 145.28571428571453 ) ( 267.42857142857144 993 143.42857142857122 ) mapping_defaults/ProtoDark -224 -110.769226 0 1 1.8571428
+}
+// brush 60
+{
+( 240 1040 192 ) ( 240 1048 184 ) ( 240 1048 312 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 200 1028 204 ) ( 204 1028 332 ) ( 204 1028 204 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 224 ) ( 296 1121 224 ) ( 297 1120 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 192 1060 172 ) ( 212 1060 172 ) ( 212 1060 300 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1120 136 ) ( 496 1120 137 ) ( 496 1121 136 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 61
+{
+( 176 960 128 ) ( 176 961 128 ) ( 176 960 129 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 192 1060 172 ) ( 212 1060 300 ) ( 212 1060 172 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 176 960 128 ) ( 177 960 128 ) ( 176 961 128 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 176 ) ( 296 1121 176 ) ( 297 1120 176 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 136 ) ( 297 1120 136 ) ( 296 1120 137 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 236 1060 172 ) ( 236 1060 176 ) ( 236 1188 176 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 62
+{
+( 240 1024 208 ) ( 240 1020 340 ) ( 240 1020 212 ) mapping_defaults/ProtoBrightBlue -223.99994 -48.000015 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 224 ) ( 296 1121 224 ) ( 297 1120 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 200 1028 204 ) ( 204 1028 204 ) ( 204 1028 332 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1120 136 ) ( 496 1120 137 ) ( 496 1121 136 ) mapping_defaults/ProtoBrightBlue -223.99994 -48.000015 0 1 1
+}
+// brush 63
+{
+( 176 960 128 ) ( 176 961 128 ) ( 176 960 129 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 224 ) ( 296 1121 224 ) ( 297 1120 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 176 1020 212 ) ( 184 1020 212 ) ( 184 1020 340 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 240 1024 208 ) ( 240 1020 212 ) ( 240 1020 340 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 64
+{
+( 236 1060 172 ) ( 236 1188 176 ) ( 236 1060 176 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 192 1060 172 ) ( 212 1060 300 ) ( 212 1060 172 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 176 960 128 ) ( 177 960 128 ) ( 176 961 128 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 240 1120 176 ) ( 248 1248 176 ) ( 248 1120 176 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 136 ) ( 297 1120 136 ) ( 296 1120 137 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1120 136 ) ( 496 1120 137 ) ( 496 1121 136 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 65
+{
+( 304 656 16 ) ( 292 656 8 ) ( 292 784 8 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 88 656 20 ) ( 88 656 21 ) ( 89 656 20 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 88 688 -169.33333333333326 ) ( 89 688 -169.33333333333326 ) ( 88 689 -169.33333333333326 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 208 704 24 ) ( 209 704 24 ) ( 208 704 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 160 656 -92 ) ( 172 656 -84 ) ( 172 784 -84 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 304 704 24 ) ( 304 704 25 ) ( 304 705 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 66
+{
+( -108 656 -172 ) ( -108 657 -172 ) ( -108 656 -171 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 108 656 -172 ) ( 108 656 -171 ) ( 109 656 -172 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 108 656 -172 ) ( 109 656 -172 ) ( 108 657 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 120 700 -168 ) ( 120 701 -168 ) ( 121 700 -168 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 120 984 -168 ) ( 121 984 -168 ) ( 120 984 -167 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 700 -168 ) ( 320 700 -167 ) ( 320 701 -168 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 67
+{
+( -112 984 -96 ) ( -112 985 -96 ) ( -112 984 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( -96 984 -96 ) ( -96 984 -95 ) ( -95 984 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -96 984 -172 ) ( -95 984 -172 ) ( -96 985 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -20 988 4 ) ( -20 989 4 ) ( -19 988 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -20 988 -92 ) ( -19 988 -92 ) ( -20 988 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 988 -92 ) ( 320 988 -91 ) ( 320 989 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 68
+{
+( 316 956 -96 ) ( 316 957 -96 ) ( 316 956 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 316 640 -96 ) ( 316 640 -95 ) ( 317 640 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 316 956 -172 ) ( 317 956 -172 ) ( 316 957 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 320 972 4 ) ( 320 973 4 ) ( 321 972 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 320 992 -92 ) ( 321 992 -92 ) ( 320 992 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 972 -92 ) ( 320 972 -91 ) ( 320 973 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 69
+{
+( -112 980 -96 ) ( -112 981 -96 ) ( -112 980 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( -112 656 -96 ) ( -112 656 -95 ) ( -111 656 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -112 980 -172 ) ( -111 980 -172 ) ( -112 981 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -108 984 4 ) ( -108 985 4 ) ( -107 984 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -108 984 -92 ) ( -107 984 -92 ) ( -108 984 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -108 984 -92 ) ( -108 984 -91 ) ( -108 985 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 70
+{
+( -168 700 4 ) ( -168 701 4 ) ( -168 700 5 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 160 656 4 ) ( 160 656 5 ) ( 161 656 4 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 160 700 4 ) ( 161 700 4 ) ( 160 701 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 704 8 ) ( 176 705 8 ) ( 177 704 8 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 704 8 ) ( 177 704 8 ) ( 176 704 9 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 124 704 8 ) ( 124 704 9 ) ( 124 705 8 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 71
+{
+( -112 652 -96 ) ( -112 653 -96 ) ( -112 652 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( -112 652 -96 ) ( -112 652 -95 ) ( -111 652 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -112 652 -172 ) ( -111 652 -172 ) ( -112 653 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 656 4 ) ( 176 657 4 ) ( 177 656 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 656 -92 ) ( 177 656 -92 ) ( 176 656 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 656 -92 ) ( 320 656 -91 ) ( 320 657 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 72
+{
+( 264 656 16 ) ( 264 657 16 ) ( 264 656 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 276 704 120 ) ( 288 704 112 ) ( 288 832 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 360 656 16 ) ( 360 656 17 ) ( 361 656 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 360 656 16 ) ( 361 656 16 ) ( 360 657 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 488 704 20 ) ( 489 704 20 ) ( 488 704 21 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 676 136 ) ( 276 804 128 ) ( 276 676 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+}
+// brush 73
+{
+( 272 1200 16 ) ( 272 1201 16 ) ( 272 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 16 ) ( 272 1200 17 ) ( 273 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1200 16 ) ( 273 1200 16 ) ( 272 1201 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 444 1232 44 ) ( 428 1232 44 ) ( 428 1360 44 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1216 24 ) ( 281 1216 24 ) ( 280 1216 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1232 24 ) ( 448 1232 25 ) ( 448 1233 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 74
+{
+( 272 1200 16 ) ( 272 1201 16 ) ( 272 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 16 ) ( 272 1200 17 ) ( 273 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 444 1232 44 ) ( 428 1360 44 ) ( 428 1232 44 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1232 56 ) ( 280 1233 56 ) ( 281 1232 56 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1232 24 ) ( 281 1232 24 ) ( 280 1232 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1232 24 ) ( 448 1232 25 ) ( 448 1233 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 75
+{
+( 272 1216 28 ) ( 272 1217 28 ) ( 272 1216 29 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1216 28 ) ( 272 1216 29 ) ( 273 1216 28 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1216 28 ) ( 273 1216 28 ) ( 272 1217 28 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1236 32 ) ( 448 1237 32 ) ( 449 1236 32 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1232 32 ) ( 449 1232 32 ) ( 448 1232 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1236 32 ) ( 448 1236 33 ) ( 448 1237 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 76
+{
+( 236 1172 120 ) ( 236 1173 120 ) ( 236 1172 121 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 228 1120 120 ) ( 228 1120 121 ) ( 229 1120 120 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 228 1172 120 ) ( 229 1172 120 ) ( 228 1173 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 1284 272 ) ( 240 1285 272 ) ( 241 1284 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 1288 124 ) ( 241 1288 124 ) ( 240 1288 125 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1284 124 ) ( 240 1284 125 ) ( 240 1285 124 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 77
+{
+( 240 1284 128 ) ( 240 1285 128 ) ( 240 1284 129 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 240 1284 128 ) ( 240 1284 129 ) ( 241 1284 128 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1284 128 ) ( 241 1284 128 ) ( 240 1285 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 452 1288 216 ) ( 452 1289 216 ) ( 453 1288 216 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 452 1288 132 ) ( 453 1288 132 ) ( 452 1288 133 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1288 132 ) ( 456 1288 133 ) ( 456 1289 132 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 78
+{
+( 168 1120 176 ) ( 168 1121 176 ) ( 168 1120 177 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 244 1116 176 ) ( 244 1116 177 ) ( 245 1116 176 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 244 1120 176 ) ( 245 1120 176 ) ( 244 1121 176 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 348 1124 272 ) ( 348 1125 272 ) ( 349 1124 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 348 1124 180 ) ( 349 1124 180 ) ( 348 1124 181 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 496 1124 180 ) ( 496 1124 181 ) ( 496 1125 180 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 79
+{
+( 688 912 16 ) ( 688 913 16 ) ( 688 912 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 688 912 16 ) ( 688 912 17 ) ( 689 912 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 688 912 16 ) ( 689 912 16 ) ( 688 913 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 704 1136 272 ) ( 704 1137 272 ) ( 705 1136 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 704 1136 32 ) ( 705 1136 32 ) ( 704 1136 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 704 1136 32 ) ( 704 1136 33 ) ( 704 1137 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 80
+{
+( 592 1216 16 ) ( 592 1217 16 ) ( 592 1216 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 592 1216 16 ) ( 592 1216 17 ) ( 593 1216 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 592 1216 16 ) ( 593 1216 16 ) ( 592 1217 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 800 1232 288 ) ( 800 1233 288 ) ( 801 1232 288 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 800 1232 32 ) ( 801 1232 32 ) ( 800 1232 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 800 1232 32 ) ( 800 1232 33 ) ( 800 1233 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 81
+{
+( 1024 896 176 ) ( 1008 896 160 ) ( 1008 1024 160 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 832 896 16 ) ( 832 896 17 ) ( 833 896 16 ) mapping_defaults/ProtoDark -80 -47.999992 0 1 1
+( 832 896 16 ) ( 833 896 16 ) ( 832 897 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1040 976 32 ) ( 1041 976 32 ) ( 1040 976 33 ) mapping_defaults/ProtoDark -80 -47.999992 0 1 1
+( 1072 944 32 ) ( 1072 944 33 ) ( 1072 945 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 82
+{
+( 1072 896 48 ) ( 1072 897 48 ) ( 1072 896 49 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 1040 896 48 ) ( 1040 896 49 ) ( 1041 896 48 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 896 176 ) ( 1088 896 176 ) ( 1088 1024 176 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 976 224 ) ( 1136 977 224 ) ( 1137 976 224 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 976 64 ) ( 1137 976 64 ) ( 1136 976 65 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 976 64 ) ( 1136 976 65 ) ( 1136 977 64 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 83
+{
+( 1056 976 112 ) ( 1056 976 96 ) ( 1056 1104 96 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 864 976 16 ) ( 864 976 17 ) ( 865 976 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 976 112 ) ( 1088 976 112 ) ( 1088 1104 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 496 ) ( 1136 1057 496 ) ( 1137 1056 496 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 32 ) ( 1137 1056 32 ) ( 1136 1056 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 1056 32 ) ( 1136 1056 33 ) ( 1136 1057 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 84
+{
+( 864 976 16 ) ( 864 977 16 ) ( 864 976 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 864 976 16 ) ( 864 976 17 ) ( 865 976 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 864 976 16 ) ( 865 976 16 ) ( 864 977 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1056 976 112 ) ( 1040 976 112 ) ( 1040 1104 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 32 ) ( 1137 1056 32 ) ( 1136 1056 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 960 976 112 ) ( 960 1104 96 ) ( 960 976 96 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 85
+{
+( 864 976 16 ) ( 864 977 16 ) ( 864 976 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 864 976 16 ) ( 864 976 17 ) ( 865 976 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 976 112 ) ( 1040 1104 112 ) ( 1040 976 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 496 ) ( 1136 1057 496 ) ( 1137 1056 496 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 32 ) ( 1137 1056 32 ) ( 1136 1056 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 976 112 ) ( 1056 1104 96 ) ( 1056 976 96 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 86
+{
+( 1136 896 208 ) ( 1136 897 208 ) ( 1136 896 209 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 1136 896 208 ) ( 1136 896 209 ) ( 1137 896 208 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 896 208 ) ( 1137 896 208 ) ( 1136 897 208 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1152 928 224 ) ( 1152 929 224 ) ( 1153 928 224 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1152 1136 224 ) ( 1153 1136 224 ) ( 1152 1136 225 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1200 928 224 ) ( 1200 928 225 ) ( 1200 929 224 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 87
+{
+( 880 1056 208 ) ( 880 1057 208 ) ( 880 1056 209 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 1120 1056 208 ) ( 1120 1056 209 ) ( 1121 1056 208 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1120 1056 208 ) ( 1121 1056 208 ) ( 1120 1057 208 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1136 224 ) ( 1137 1136 224 ) ( 1136 1136 225 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 1136 224 ) ( 1072 1136 240 ) ( 1072 1264 240 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1120 224 ) ( 1136 1120 225 ) ( 1136 1121 224 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 88
+{
+( 784 1056 208 ) ( 784 1057 208 ) ( 784 1056 209 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 784 1056 208 ) ( 784 1056 209 ) ( 785 1056 208 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 784 1056 208 ) ( 785 1056 208 ) ( 784 1057 208 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 864 1136 288 ) ( 864 1137 288 ) ( 865 1136 288 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 864 1136 224 ) ( 865 1136 224 ) ( 864 1136 225 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 880 1136 224 ) ( 880 1136 225 ) ( 880 1137 224 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+}
+// entity 1
+{
+"classname" "enemy_spawn"
+"origin" "-64 -48 40"
+}
+// entity 2
+{
+"classname" "info_player_start"
+"origin" "-96 128 40"
+}
+// entity 3
+{
+"classname" "enemy_spawn"
+"origin" "120 1216 40"
+}

projects/content/bsp/testmap.map

@@ -0,0 +1,857 @@
+// Game: Deathwish
+// Format: Standard
+// entity 0
+{
+"classname" "worldspawn"
+// brush 0
+{
+( -288 -144 -16 ) ( -288 -143 -16 ) ( -288 -144 -15 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+( -128 -240 -16 ) ( -128 -240 -15 ) ( -127 -240 -16 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( -128 -144 -16 ) ( -127 -144 -16 ) ( -128 -143 -16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 -16 16 ) ( 0 -15 16 ) ( 1 -16 16 ) mapping_defaults/ProtoDark 0 -64 0 0.25 0.25
+( 0 1456 16 ) ( 1 1456 16 ) ( 0 1456 17 ) mapping_defaults/ProtoDark 0 0 0 0.25 0.25
+( 1328 -16 16 ) ( 1328 -16 17 ) ( 1328 -15 16 ) mapping_defaults/ProtoDark 64 0 0 0.25 0.25
+}
+// brush 1
+{
+( 80 -80 16 ) ( 80 -79 16 ) ( 80 -80 17 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+( 80 -80 16 ) ( 80 -80 17 ) ( 81 -80 16 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 80 -80 16 ) ( 81 -80 16 ) ( 80 -79 16 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 96 ) ( 176 -63 96 ) ( 177 -64 96 ) mapping_defaults/ProtoOrange 0 -64 0 0.25 0.25
+( 176 -64 32 ) ( 177 -64 32 ) ( 176 -64 33 ) mapping_defaults/ProtoOrange 0 0 0 0.25 0.25
+( 176 -64 32 ) ( 176 -64 33 ) ( 176 -63 32 ) mapping_defaults/ProtoOrange 64 0 0 0.25 0.25
+}
+// brush 2
+{
+( 80 -32 16 ) ( 80 -31 16 ) ( 80 -32 17 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+( 80 -32 16 ) ( 80 -32 17 ) ( 81 -32 16 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 80 -32 16 ) ( 81 -32 16 ) ( 80 -31 16 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 80 ) ( 96 81 80 ) ( 97 80 80 ) mapping_defaults/ProtoDarkBlue 64 -80 0 1 1
+( 96 80 32 ) ( 97 80 32 ) ( 96 80 33 ) mapping_defaults/ProtoDarkBlue 64 0 0 1 1
+( 96 80 32 ) ( 96 80 33 ) ( 96 81 32 ) mapping_defaults/ProtoDarkBlue 80 0 0 1 1
+}
+// brush 3
+{
+( -160 -128 16 ) ( -160 -127 16 ) ( -160 -128 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -160 -128 16 ) ( -160 -128 17 ) ( -159 -128 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 -128 16 ) ( -159 -128 16 ) ( -160 -127 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 96 ) ( -128 1 96 ) ( -127 0 96 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -128 0 32 ) ( -127 0 32 ) ( -128 0 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -128 0 32 ) ( -128 0 33 ) ( -128 1 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 4
+{
+( -224 48 16 ) ( -224 49 16 ) ( -224 48 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -224 48 16 ) ( -224 48 17 ) ( -223 48 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -224 48 16 ) ( -223 48 16 ) ( -224 49 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 112 ) ( -160 129 112 ) ( -159 128 112 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -160 128 32 ) ( -159 128 32 ) ( -160 128 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -160 128 32 ) ( -160 128 33 ) ( -160 129 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 5
+{
+( -112 224 16 ) ( -112 225 16 ) ( -112 224 17 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+( -112 224 16 ) ( -112 224 17 ) ( -111 224 16 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -112 224 16 ) ( -111 224 16 ) ( -112 225 16 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 192 ) ( -64 305 192 ) ( -63 304 192 ) mapping_defaults/ProtoMaroon 0 -64 0 0.25 0.25
+( -64 304 32 ) ( -63 304 32 ) ( -64 304 33 ) mapping_defaults/ProtoMaroon 0 0 0 0.25 0.25
+( -64 304 32 ) ( -64 304 33 ) ( -64 305 32 ) mapping_defaults/ProtoMaroon 64 0 0 0.25 0.25
+}
+// brush 6
+{
+( 208 -192 16 ) ( 208 -191 16 ) ( 208 -192 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 208 -192 17 ) ( 209 -192 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 208 -192 16 ) ( 209 -192 16 ) ( 208 -191 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 144 ) ( 288 -127 144 ) ( 289 -128 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 289 -128 32 ) ( 288 -128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -128 32 ) ( 288 -128 33 ) ( 288 -127 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 7
+{
+( 416 -112 16 ) ( 416 -111 16 ) ( 416 -112 17 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+( 416 -112 16 ) ( 416 -112 17 ) ( 417 -112 16 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 416 -112 16 ) ( 417 -112 16 ) ( 416 -111 16 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 144 ) ( 560 1 144 ) ( 561 0 144 ) mapping_defaults/ProtoDarkGreen -64 -128 0 0.25 0.25
+( 560 0 32 ) ( 561 0 32 ) ( 560 0 33 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 560 0 32 ) ( 560 0 33 ) ( 560 1 32 ) mapping_defaults/ProtoDarkGreen 128 0 0 0.25 0.25
+}
+// brush 8
+{
+( 352 224 16 ) ( 352 225 16 ) ( 352 224 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 352 224 17 ) ( 353 224 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 352 224 16 ) ( 353 224 16 ) ( 352 225 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 208 ) ( 512 289 208 ) ( 513 288 208 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 513 288 32 ) ( 512 288 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 512 288 32 ) ( 512 288 33 ) ( 512 289 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 9
+{
+( -272 -288 16 ) ( -272 -287 16 ) ( -272 -288 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -272 -288 16 ) ( -272 -288 17 ) ( -271 -288 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -272 -288 16 ) ( -271 -288 16 ) ( -272 -287 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -176 -79 32 ) ( -175 -80 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -175 -80 32 ) ( -176 -80 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( -176 -80 32 ) ( -176 -80 33 ) ( -176 -79 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 10
+{
+( 304 16 96 ) ( 304 17 96 ) ( 304 16 97 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 16 96 ) ( 304 16 97 ) ( 305 16 96 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 304 16 96 ) ( 305 16 96 ) ( 304 17 96 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 320 49 112 ) ( 321 48 112 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 321 48 112 ) ( 320 48 113 ) mapping_defaults/ProtoDarkGreen -64 0 0 0.25 0.25
+( 320 48 112 ) ( 320 48 113 ) ( 320 49 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 11
+{
+( 256 -48 128 ) ( 256 -47 128 ) ( 256 -48 129 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -48 128 ) ( 288 -48 129 ) ( 289 -48 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 288 -48 128 ) ( 289 -48 128 ) ( 288 -47 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 0 144 ) ( 304 1 144 ) ( 305 0 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 64 144 ) ( 305 64 144 ) ( 304 64 145 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 304 0 144 ) ( 304 0 145 ) ( 304 1 144 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 12
+{
+( 288 -32 16 ) ( 288 -31 16 ) ( 288 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 16 96 ) ( 288 0 112 ) ( 416 0 112 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 416 ) ( 336 113 416 ) ( 337 112 416 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 80 128 ) ( 288 32 96 ) ( 416 32 96 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 337 112 32 ) ( 336 112 33 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 13
+{
+( 272 -32 16 ) ( 272 -31 16 ) ( 272 -32 17 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 -32 16 ) ( 288 -32 17 ) ( 289 -32 16 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 80 128 ) ( 288 32 96 ) ( 416 32 96 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 288 16 96 ) ( 416 0 112 ) ( 288 0 112 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+( 336 112 32 ) ( 336 112 33 ) ( 336 113 32 ) mapping_defaults/ProtoGreen 0 0 0 0.25 0.25
+}
+// brush 14
+{
+( 160 32 16 ) ( 160 33 16 ) ( 160 32 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 160 32 16 ) ( 160 32 17 ) ( 161 32 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 160 32 16 ) ( 161 32 16 ) ( 160 33 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 112 ) ( 176 129 112 ) ( 177 128 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 32 ) ( 177 128 32 ) ( 176 128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 128 32 ) ( 176 128 33 ) ( 176 129 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 15
+{
+( 256 16 16 ) ( 256 17 16 ) ( 256 16 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 256 16 16 ) ( 256 16 17 ) ( 257 16 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 256 16 16 ) ( 257 16 16 ) ( 256 17 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 112 ) ( 272 129 112 ) ( 273 128 112 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 32 ) ( 273 128 32 ) ( 272 128 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 272 128 32 ) ( 272 128 33 ) ( 272 129 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 16
+{
+( 112 -176 80 ) ( 112 -176 64 ) ( 112 -48 64 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 96 -208 17 ) ( 97 -208 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 97 -208 16 ) ( 96 -207 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 176 -176 64 ) ( 176 -175 64 ) ( 177 -176 64 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 177 -176 32 ) ( 176 -176 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 144 -176 48 ) ( 144 -176 80 ) ( 144 -48 80 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 17
+{
+( 144 -176 48 ) ( 144 -48 80 ) ( 144 -176 80 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 96 -208 17 ) ( 97 -208 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 97 -208 16 ) ( 96 -207 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 128 ) ( 176 -175 128 ) ( 177 -176 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 177 -176 32 ) ( 176 -176 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 176 -176 33 ) ( 176 -175 32 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 18
+{
+( 96 -208 16 ) ( 96 -207 16 ) ( 96 -208 17 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 96 -208 17 ) ( 97 -208 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 96 -208 16 ) ( 97 -208 16 ) ( 96 -207 16 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 128 ) ( 176 -175 128 ) ( 177 -176 128 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 176 -176 32 ) ( 177 -176 32 ) ( 176 -176 33 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+( 112 -176 80 ) ( 112 -48 64 ) ( 112 -176 64 ) mapping_defaults/ProtoDarkGreen 0 0 0 0.25 0.25
+}
+// brush 19
+{
+( 96 272 16 ) ( 96 273 16 ) ( 96 272 17 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 272 16 ) ( 96 272 17 ) ( 97 272 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 96 272 16 ) ( 97 272 16 ) ( 96 273 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 224 336 384 ) ( 224 337 384 ) ( 225 336 384 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 224 336 32 ) ( 225 336 32 ) ( 224 336 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 224 336 32 ) ( 224 336 33 ) ( 224 337 32 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 20
+{
+( 336 112 16 ) ( 336 113 16 ) ( 336 112 17 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 112 16 ) ( 336 112 17 ) ( 337 112 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 112 16 ) ( 337 112 16 ) ( 336 113 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 416 208 112 ) ( 416 209 112 ) ( 417 208 112 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 416 208 32 ) ( 417 208 32 ) ( 416 208 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 416 208 32 ) ( 416 208 33 ) ( 416 209 32 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 21
+{
+( 144 160 16 ) ( 144 161 16 ) ( 144 160 17 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 144 160 16 ) ( 144 160 17 ) ( 145 160 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 144 160 16 ) ( 145 160 16 ) ( 144 161 16 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 192 272 224 ) ( 192 273 224 ) ( 193 272 224 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 192 272 32 ) ( 193 272 32 ) ( 192 272 33 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 192 272 32 ) ( 192 272 33 ) ( 192 273 32 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 22
+{
+( 320 -224 128 ) ( 320 -223 128 ) ( 320 -224 129 ) mapping_defaults/ProtoGrey 128 0 0 0.25 0.25
+( 320 -224 128 ) ( 320 -224 129 ) ( 321 -224 128 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 320 -224 128 ) ( 321 -224 128 ) ( 320 -223 128 ) mapping_defaults/ProtoGrey 0 -128 0 0.25 0.25
+( 368 -160 144 ) ( 368 -159 144 ) ( 369 -160 144 ) mapping_defaults/ProtoGrey 0 -128 0 0.25 0.25
+( 368 -160 144 ) ( 369 -160 144 ) ( 368 -160 145 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 368 -160 144 ) ( 368 -160 145 ) ( 368 -159 144 ) mapping_defaults/ProtoGrey 128 0 0 0.25 0.25
+}
+// brush 23
+{
+( 336 0 304 ) ( 336 1 304 ) ( 336 0 305 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 0 304 ) ( 336 0 305 ) ( 337 0 304 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 336 0 304 ) ( 337 0 304 ) ( 336 1 304 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 384 96 320 ) ( 384 97 320 ) ( 385 96 320 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 384 96 320 ) ( 385 96 320 ) ( 384 96 321 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+( 560 96 320 ) ( 560 96 321 ) ( 560 97 320 ) mapping_defaults/ProtoGrey 0 0 0 0.25 0.25
+}
+// brush 24
+{
+( 17.071796769724585 1215.7128129211023 96 ) ( 49.07179676972447 1160.2871870788977 96 ) ( 49.07179676972447 1160.2871870788977 16 ) mapping_defaults/ProtoDark -222.7843 -48 0 0.8660254 1
+( 24 1219.7128129211023 16 ) ( 24 1219.7128129211023 96 ) ( 17.071796769724585 1215.7128129211023 96 ) mapping_defaults/ProtoDark -171.7128 -48 0 0.8660254 1
+( 56 1164.2871870788977 16 ) ( 24 1219.7128129211023 16 ) ( 17.071796769724585 1215.7128129211023 16 ) mapping_defaults/ProtoDark -113.64099 255.30194 30 1 1
+( 17.071796769724585 1215.7128129211023 96 ) ( 24 1219.7128129211023 96 ) ( 56 1164.2871870788977 96 ) mapping_defaults/ProtoDark -113.64099 255.30194 30 1 1
+( 49.07179676972447 1160.2871870788977 96 ) ( 56 1164.2871870788977 96 ) ( 56 1164.2871870788977 16 ) mapping_defaults/ProtoDark -171.66324 -48 0 0.8660254 1
+( 56 1164.2871870788977 96 ) ( 24 1219.7128129211023 96 ) ( 24 1219.7128129211023 16 ) mapping_defaults/ProtoDark -222.40308 -48 0 0.8660254 1
+}
+// brush 25
+{
+( 1.3725830020305807 1241.3725830020303 96 ) ( 7.029437251522893 1235.7157287525379 96 ) ( 7.029437251522893 1235.7157287525379 16 ) mapping_defaults/ProtoDark 53.565918 -48 180 0.70710677 -1
+( 46.62741699796953 1286.6274169979697 96 ) ( 1.3725830020305807 1241.3725830020303 96 ) ( 1.3725830020305807 1241.3725830020303 16 ) mapping_defaults/ProtoDark -53.565918 -48 0 0.70710677 1
+( 7.029437251522893 1235.7157287525379 16 ) ( 52.28427124746196 1280.9705627484773 16 ) ( 46.62741699796953 1286.6274169979697 16 ) mapping_defaults/ProtoDark 120.81244 189.75354 315 1 1
+( 46.62741699796953 1286.6274169979697 96 ) ( 52.28427124746196 1280.9705627484773 96 ) ( 7.029437251522893 1235.7157287525379 96 ) mapping_defaults/ProtoDark 120.81244 189.75354 315 1 1
+( 52.28427124746196 1280.9705627484773 16 ) ( 52.28427124746196 1280.9705627484773 96 ) ( 46.62741699796953 1286.6274169979697 96 ) mapping_defaults/ProtoDark 53.565918 -48 180 0.70710677 -1
+( 7.029437251522893 1235.7157287525379 96 ) ( 52.28427124746196 1280.9705627484773 96 ) ( 52.28427124746196 1280.9705627484773 16 ) mapping_defaults/ProtoDark -53.565918 -48 0 0.70710677 1
+}
+// brush 26
+{
+( 48 1280 16 ) ( 48 1281 16 ) ( 48 1280 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1280 16 ) ( 48 1280 17 ) ( 49 1280 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1280 16 ) ( 49 1280 16 ) ( 48 1281 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 200 1288 120 ) ( 200 1289 120 ) ( 201 1288 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 200 1288 24 ) ( 201 1288 24 ) ( 200 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 200 1288 24 ) ( 200 1288 25 ) ( 200 1289 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 27
+{
+( 48 1264 96 ) ( 48 1265 96 ) ( 48 1264 97 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1144 96 ) ( 48 1144 97 ) ( 49 1144 96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1264 96 ) ( 49 1264 96 ) ( 48 1265 96 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1280 120 ) ( 56 1281 120 ) ( 57 1280 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1280 104 ) ( 57 1280 104 ) ( 56 1280 105 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1280 104 ) ( 56 1280 105 ) ( 56 1281 104 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 28
+{
+( 48 1144 16 ) ( 48 1145 16 ) ( 48 1144 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1144 16 ) ( 48 1144 17 ) ( 49 1144 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1144 16 ) ( 49 1144 16 ) ( 48 1145 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1160 96 ) ( 56 1161 96 ) ( 57 1160 96 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 56 1160 24 ) ( 57 1160 24 ) ( 56 1160 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1160 24 ) ( 56 1160 25 ) ( 56 1161 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 29
+{
+( 48 1112 16 ) ( 48 1113 16 ) ( 48 1112 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 48 1112 16 ) ( 48 1112 17 ) ( 49 1112 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 48 1112 16 ) ( 49 1112 16 ) ( 48 1113 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 64 1144 120 ) ( 64 1145 120 ) ( 65 1144 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 64 1144 24 ) ( 65 1144 24 ) ( 64 1144 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1144 24 ) ( 56 1144 25 ) ( 56 1145 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 30
+{
+( 248 1208 64 ) ( 200 1288 64 ) ( 200 1288 120 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 248 1208 120 ) ( 256 1202.6666666666606 120 ) ( 256 1202.6666666666579 64 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1202.6666666666579 64 ) ( 256 1288 64 ) ( 200 1288 64 ) mapping_defaults/ProtoDark -80 223.99988 0 1 1
+( 200 1288 120 ) ( 256 1288 120 ) ( 256 1202.6666666666606 120 ) mapping_defaults/ProtoDark -80 223.99988 0 1 1
+( 256 1288 64 ) ( 256 1288 120 ) ( 200 1288 120 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1202.6666666666606 120 ) ( 256 1288 120 ) ( 256 1288 64 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 31
+{
+( 200 1200 16 ) ( 200 1201 16 ) ( 200 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 200 1240 96 ) ( 224 1224 224 ) ( 224 1224 96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 200 1200 16 ) ( 201 1200 16 ) ( 200 1201 16 ) mapping_defaults/ProtoDark -80 224.99988 0 1 1
+( 200 1240 64 ) ( 224 1352 64 ) ( 224 1224 64 ) mapping_defaults/ProtoDark -80 224.99988 0 1 1
+( 360 1288 24 ) ( 361 1288 24 ) ( 360 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1288 24 ) ( 256 1288 25 ) ( 256 1289 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 32
+{
+( 256 1200 16 ) ( 256 1201 16 ) ( 256 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 256 1200 16 ) ( 256 1200 17 ) ( 257 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 256 1200 16 ) ( 257 1200 16 ) ( 256 1201 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 264 1296 120 ) ( 264 1297 120 ) ( 265 1296 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 264 1288 24 ) ( 265 1288 24 ) ( 264 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1296 24 ) ( 272 1296 25 ) ( 272 1297 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 33
+{
+( 448 1200 16 ) ( 448 1201 16 ) ( 448 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 440 1200 16 ) ( 440 1200 17 ) ( 441 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 440 1200 16 ) ( 441 1200 16 ) ( 440 1201 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1296 120 ) ( 448 1297 120 ) ( 449 1296 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1288 24 ) ( 449 1288 24 ) ( 448 1288 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1296 24 ) ( 456 1296 25 ) ( 456 1297 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 34
+{
+( 272 1200 112 ) ( 272 1201 112 ) ( 272 1200 113 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 112 ) ( 272 1200 113 ) ( 273 1200 112 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1200 112 ) ( 273 1200 112 ) ( 272 1201 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1288 120 ) ( 280 1289 120 ) ( 281 1288 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1288 120 ) ( 281 1288 120 ) ( 280 1288 121 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1288 120 ) ( 448 1288 121 ) ( 448 1289 120 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 35
+{
+( 272 1200 96 ) ( 272 1201 96 ) ( 272 1200 97 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 96 ) ( 272 1200 97 ) ( 273 1200 96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1200 96 ) ( 273 1200 96 ) ( 272 1201 96 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 312 1208 112 ) ( 312 1209 112 ) ( 313 1208 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 312 1208 104 ) ( 313 1208 104 ) ( 312 1208 105 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1208 104 ) ( 448 1208 105 ) ( 448 1209 104 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 36
+{
+( 264 1288 16 ) ( 264 1289 16 ) ( 264 1288 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 264 1288 16 ) ( 264 1288 17 ) ( 265 1288 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 1288 16 ) ( 265 1288 16 ) ( 264 1289 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 272 1344 120 ) ( 272 1345 120 ) ( 273 1344 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 272 1344 24 ) ( 273 1344 24 ) ( 272 1344 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1344 24 ) ( 272 1344 25 ) ( 272 1345 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 37
+{
+( 272 1288 112 ) ( 272 1289 112 ) ( 272 1288 113 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1288 112 ) ( 272 1288 113 ) ( 273 1288 112 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1288 112 ) ( 273 1288 112 ) ( 272 1289 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1344 120 ) ( 280 1345 120 ) ( 281 1344 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1344 120 ) ( 281 1344 120 ) ( 280 1344 121 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1344 120 ) ( 456 1344 121 ) ( 456 1345 120 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 38
+{
+( 272 1336 16 ) ( 272 1337 16 ) ( 272 1336 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1336 16 ) ( 272 1336 17 ) ( 273 1336 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1336 16 ) ( 273 1336 16 ) ( 272 1337 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 392 1344 112 ) ( 392 1345 112 ) ( 393 1344 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 392 1344 24 ) ( 393 1344 24 ) ( 392 1344 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1344 24 ) ( 456 1344 25 ) ( 456 1345 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 39
+{
+( 56 1112 16 ) ( 56 1113 16 ) ( 56 1112 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 56 1112 16 ) ( 56 1112 17 ) ( 57 1112 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1112 16 ) ( 57 1112 16 ) ( 56 1113 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 120 ) ( 504 1121 120 ) ( 505 1120 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 24 ) ( 505 1120 24 ) ( 504 1120 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 1112 80 ) ( 176 1112 88 ) ( 176 1240 88 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 40
+{
+( 176 1112 120 ) ( 176 1240 128 ) ( 176 1112 128 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 56 1112 56 ) ( 56 1112 57 ) ( 57 1112 56 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 56 1112 88 ) ( 57 1112 88 ) ( 56 1113 88 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 128 ) ( 504 1121 128 ) ( 505 1120 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 504 1120 64 ) ( 505 1120 64 ) ( 504 1120 65 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1112 104 ) ( 240 1112 112 ) ( 240 1240 112 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 41
+{
+( 240 1112 64 ) ( 240 1240 72 ) ( 240 1112 72 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 56 1112 16 ) ( 56 1112 17 ) ( 57 1112 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 56 1112 16 ) ( 57 1112 16 ) ( 56 1113 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1120 128 ) ( 504 1121 128 ) ( 505 1120 128 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1120 24 ) ( 505 1120 24 ) ( 504 1120 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 1120 24 ) ( 504 1120 25 ) ( 504 1121 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 42
+{
+( 496 904 16 ) ( 496 905 16 ) ( 496 904 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 496 896 16 ) ( 496 896 17 ) ( 497 896 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 496 904 16 ) ( 497 904 16 ) ( 496 905 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1112 272 ) ( 504 1113 272 ) ( 505 1112 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 1120 24 ) ( 505 1120 24 ) ( 504 1120 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 1112 24 ) ( 504 1112 25 ) ( 504 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 43
+{
+( 240 1120 120 ) ( 240 1121 120 ) ( 240 1120 121 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 240 1120 120 ) ( 240 1120 121 ) ( 241 1120 120 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1120 120 ) ( 241 1120 120 ) ( 240 1121 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 456 1288 128 ) ( 456 1289 128 ) ( 457 1288 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 456 1288 128 ) ( 457 1288 128 ) ( 456 1288 129 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1288 128 ) ( 456 1288 129 ) ( 456 1289 128 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 44
+{
+( 176 1008 224 ) ( 176 1009 224 ) ( 176 1008 225 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 184 1008 224 ) ( 184 1008 225 ) ( 185 1008 224 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 184 1008 224 ) ( 185 1008 224 ) ( 184 1009 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 496 1088 272 ) ( 496 1089 272 ) ( 497 1088 272 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 496 1116 232 ) ( 497 1116 232 ) ( 496 1116 233 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1088 232 ) ( 496 1088 233 ) ( 496 1089 232 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 45
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 248 ) ( 304 936 248 ) ( 176 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1112 272 ) ( 176 1113 272 ) ( 177 1112 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1116 24 ) ( 177 1116 24 ) ( 176 1116 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 46
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 952 216 ) ( 176 952 232 ) ( 304 952 232 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1116 24 ) ( 177 1116 24 ) ( 176 1116 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 47
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 872 216 ) ( 176 872 224 ) ( 304 872 224 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 216 ) ( 304 912 224 ) ( 176 912 224 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 48
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 784 216 ) ( 176 784 224 ) ( 304 784 224 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 832 216 ) ( 304 832 232 ) ( 176 832 232 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 49
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 912 208 ) ( 304 936 208 ) ( 176 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 248 ) ( 176 936 248 ) ( 304 936 248 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 744 224 ) ( 304 744 232 ) ( 176 744 232 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 50
+{
+( 176 912 264 ) ( 176 913 264 ) ( 176 912 265 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 176 656 264 ) ( 176 656 265 ) ( 177 656 264 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 912 264 ) ( 177 912 264 ) ( 176 913 264 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 496 1008 272 ) ( 496 1009 272 ) ( 497 1008 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 496 1008 272 ) ( 497 1008 272 ) ( 496 1008 273 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 368 1008 272 ) ( 368 1008 273 ) ( 368 1009 272 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 51
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 720 112 ) ( 304 784 112 ) ( 176 784 112 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 912 208 ) ( 176 936 208 ) ( 304 936 208 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1116 24 ) ( 177 1116 24 ) ( 176 1116 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 52
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 168 696 16 ) ( 168 696 17 ) ( 169 696 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 168 1056 16 ) ( 169 1056 16 ) ( 168 1057 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 720 112 ) ( 176 784 112 ) ( 304 784 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 728 32 ) ( 304 728 40 ) ( 176 728 40 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 53
+{
+( 168 1056 16 ) ( 168 1057 16 ) ( 168 1056 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 176 816 40 ) ( 176 816 56 ) ( 304 816 56 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 168 1056 16 ) ( 169 1056 16 ) ( 168 1057 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 720 112 ) ( 176 784 112 ) ( 304 784 112 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 1112 24 ) ( 177 1112 24 ) ( 176 1112 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 1112 24 ) ( 176 1112 25 ) ( 176 1113 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 54
+{
+( 168 656 16 ) ( 168 657 16 ) ( 168 656 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 656 16 ) ( 168 656 17 ) ( 169 656 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 168 656 16 ) ( 169 656 16 ) ( 168 657 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 696 272 ) ( 176 697 272 ) ( 177 696 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 176 696 24 ) ( 177 696 24 ) ( 176 696 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 176 696 24 ) ( 176 696 25 ) ( 176 697 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 55
+{
+( 496 656 264 ) ( 496 657 264 ) ( 496 656 265 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 496 656 264 ) ( 496 656 265 ) ( 497 656 264 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 496 656 184 ) ( 497 656 184 ) ( 496 657 184 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 896 272 ) ( 504 897 272 ) ( 505 896 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 896 272 ) ( 505 896 272 ) ( 504 896 273 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 896 272 ) ( 504 896 273 ) ( 504 897 272 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 56
+{
+( 168 640 16 ) ( 168 641 16 ) ( 168 640 17 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 168 648 16 ) ( 168 648 17 ) ( 169 648 16 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 168 640 16 ) ( 169 640 16 ) ( 168 641 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 536 656 272 ) ( 536 657 272 ) ( 537 656 272 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 536 656 24 ) ( 537 656 24 ) ( 536 656 25 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 536 656 24 ) ( 536 656 25 ) ( 536 657 24 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 57
+{
+( 496 656 176 ) ( 496 657 176 ) ( 496 656 177 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+( 496 656 176 ) ( 496 656 177 ) ( 497 656 176 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 496 656 16 ) ( 497 656 16 ) ( 496 657 16 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 664 184 ) ( 504 665 184 ) ( 505 664 184 ) mapping_defaults/ProtoOrange -80 224 0 1 1
+( 504 728 184 ) ( 505 728 184 ) ( 504 728 185 ) mapping_defaults/ProtoOrange -80 -48 0 1 1
+( 504 664 184 ) ( 504 664 185 ) ( 504 665 184 ) mapping_defaults/ProtoOrange -224 -48 0 1 1
+}
+// brush 58
+{
+( 176 688 128 ) ( 176 689 128 ) ( 176 688 129 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 176 656 128 ) ( 176 656 129 ) ( 177 656 128 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 176 688 128 ) ( 177 688 128 ) ( 176 689 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 872 136 ) ( 240 873 136 ) ( 241 872 136 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 944 136 ) ( 241 944 136 ) ( 240 944 137 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 872 136 ) ( 264 872 137 ) ( 264 873 136 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 59
+{
+( 260 860 136 ) ( 260 861 136 ) ( 260 860 137 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 260 704 136 ) ( 260 704 137 ) ( 261 704 136 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 260 860 136 ) ( 261 860 136 ) ( 260 861 136 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 264 992 164 ) ( 264 993 164 ) ( 265 992 164 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 264 944 140 ) ( 265 944 140 ) ( 264 944 141 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 992 140 ) ( 264 992 141 ) ( 264 993 140 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 60
+{
+( 240 1040 192 ) ( 240 1048 184 ) ( 240 1048 312 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 200 1028 204 ) ( 204 1028 332 ) ( 204 1028 204 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 224 ) ( 296 1121 224 ) ( 297 1120 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 192 1060 172 ) ( 212 1060 172 ) ( 212 1060 300 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1120 136 ) ( 496 1120 137 ) ( 496 1121 136 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 61
+{
+( 176 960 128 ) ( 176 961 128 ) ( 176 960 129 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 192 1060 172 ) ( 212 1060 300 ) ( 212 1060 172 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 176 960 128 ) ( 177 960 128 ) ( 176 961 128 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 176 ) ( 296 1121 176 ) ( 297 1120 176 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 136 ) ( 297 1120 136 ) ( 296 1120 137 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 236 1060 172 ) ( 236 1060 176 ) ( 236 1188 176 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 62
+{
+( 240 1024 208 ) ( 240 1020 340 ) ( 240 1020 212 ) mapping_defaults/ProtoBrightBlue -223.99994 -48.000015 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 224 ) ( 296 1121 224 ) ( 297 1120 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 200 1028 204 ) ( 204 1028 204 ) ( 204 1028 332 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1120 136 ) ( 496 1120 137 ) ( 496 1121 136 ) mapping_defaults/ProtoBrightBlue -223.99994 -48.000015 0 1 1
+}
+// brush 63
+{
+( 176 960 128 ) ( 176 961 128 ) ( 176 960 129 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 224 ) ( 296 1121 224 ) ( 297 1120 224 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 176 1020 212 ) ( 184 1020 212 ) ( 184 1020 340 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 240 1024 208 ) ( 240 1020 212 ) ( 240 1020 340 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 64
+{
+( 236 1060 172 ) ( 236 1188 176 ) ( 236 1060 176 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+( 192 1060 172 ) ( 212 1060 300 ) ( 212 1060 172 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 168 1088 144 ) ( 168 1080 152 ) ( 296 1080 152 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 176 960 128 ) ( 177 960 128 ) ( 176 961 128 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 240 1120 176 ) ( 248 1248 176 ) ( 248 1120 176 ) mapping_defaults/ProtoBrightBlue -80 224 0 1 1
+( 296 1120 136 ) ( 297 1120 136 ) ( 296 1120 137 ) mapping_defaults/ProtoBrightBlue -80 -48 0 1 1
+( 496 1120 136 ) ( 496 1120 137 ) ( 496 1121 136 ) mapping_defaults/ProtoBrightBlue -224 -48 0 1 1
+}
+// brush 65
+{
+( 304 656 16 ) ( 292 656 8 ) ( 292 784 8 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 88 656 20 ) ( 88 656 21 ) ( 89 656 20 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 88 688 -169.33333333333326 ) ( 89 688 -169.33333333333326 ) ( 88 689 -169.33333333333326 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 208 704 24 ) ( 209 704 24 ) ( 208 704 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 160 656 -92 ) ( 172 656 -84 ) ( 172 784 -84 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 304 704 24 ) ( 304 704 25 ) ( 304 705 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 66
+{
+( -108 656 -172 ) ( -108 657 -172 ) ( -108 656 -171 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 108 656 -172 ) ( 108 656 -171 ) ( 109 656 -172 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 108 656 -172 ) ( 109 656 -172 ) ( 108 657 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 120 700 -168 ) ( 120 701 -168 ) ( 121 700 -168 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 120 984 -168 ) ( 121 984 -168 ) ( 120 984 -167 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 700 -168 ) ( 320 700 -167 ) ( 320 701 -168 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 67
+{
+( -112 984 -96 ) ( -112 985 -96 ) ( -112 984 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( -96 984 -96 ) ( -96 984 -95 ) ( -95 984 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -96 984 -172 ) ( -95 984 -172 ) ( -96 985 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -20 988 4 ) ( -20 989 4 ) ( -19 988 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -20 988 -92 ) ( -19 988 -92 ) ( -20 988 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 988 -92 ) ( 320 988 -91 ) ( 320 989 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 68
+{
+( 316 956 -96 ) ( 316 957 -96 ) ( 316 956 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 316 640 -96 ) ( 316 640 -95 ) ( 317 640 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 316 956 -172 ) ( 317 956 -172 ) ( 316 957 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 320 972 4 ) ( 320 973 4 ) ( 321 972 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 320 992 -92 ) ( 321 992 -92 ) ( 320 992 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 972 -92 ) ( 320 972 -91 ) ( 320 973 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 69
+{
+( -112 980 -96 ) ( -112 981 -96 ) ( -112 980 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( -112 656 -96 ) ( -112 656 -95 ) ( -111 656 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -112 980 -172 ) ( -111 980 -172 ) ( -112 981 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -108 984 4 ) ( -108 985 4 ) ( -107 984 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( -108 984 -92 ) ( -107 984 -92 ) ( -108 984 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -108 984 -92 ) ( -108 984 -91 ) ( -108 985 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 70
+{
+( -168 700 4 ) ( -168 701 4 ) ( -168 700 5 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 160 656 4 ) ( 160 656 5 ) ( 161 656 4 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 160 700 4 ) ( 161 700 4 ) ( 160 701 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 704 8 ) ( 176 705 8 ) ( 177 704 8 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 704 8 ) ( 177 704 8 ) ( 176 704 9 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 124 704 8 ) ( 124 704 9 ) ( 124 705 8 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 71
+{
+( -112 652 -96 ) ( -112 653 -96 ) ( -112 652 -95 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( -112 652 -96 ) ( -112 652 -95 ) ( -111 652 -96 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( -112 652 -172 ) ( -111 652 -172 ) ( -112 653 -172 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 656 4 ) ( 176 657 4 ) ( 177 656 4 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 176 656 -92 ) ( 177 656 -92 ) ( 176 656 -91 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 320 656 -92 ) ( 320 656 -91 ) ( 320 657 -92 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 72
+{
+( 264 656 16 ) ( 264 657 16 ) ( 264 656 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 276 704 120 ) ( 288 704 112 ) ( 288 832 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 360 656 16 ) ( 360 656 17 ) ( 361 656 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 360 656 16 ) ( 361 656 16 ) ( 360 657 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 488 704 20 ) ( 489 704 20 ) ( 488 704 21 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 264 676 136 ) ( 276 804 128 ) ( 276 676 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+}
+// brush 73
+{
+( 272 1200 16 ) ( 272 1201 16 ) ( 272 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 16 ) ( 272 1200 17 ) ( 273 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1200 16 ) ( 273 1200 16 ) ( 272 1201 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 444 1232 44 ) ( 428 1232 44 ) ( 428 1360 44 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1216 24 ) ( 281 1216 24 ) ( 280 1216 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1232 24 ) ( 448 1232 25 ) ( 448 1233 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 74
+{
+( 272 1200 16 ) ( 272 1201 16 ) ( 272 1200 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1200 16 ) ( 272 1200 17 ) ( 273 1200 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 444 1232 44 ) ( 428 1360 44 ) ( 428 1232 44 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1232 56 ) ( 280 1233 56 ) ( 281 1232 56 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 280 1232 24 ) ( 281 1232 24 ) ( 280 1232 25 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1232 24 ) ( 448 1232 25 ) ( 448 1233 24 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 75
+{
+( 272 1216 28 ) ( 272 1217 28 ) ( 272 1216 29 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 272 1216 28 ) ( 272 1216 29 ) ( 273 1216 28 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 272 1216 28 ) ( 273 1216 28 ) ( 272 1217 28 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1236 32 ) ( 448 1237 32 ) ( 449 1236 32 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 448 1232 32 ) ( 449 1232 32 ) ( 448 1232 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 448 1236 32 ) ( 448 1236 33 ) ( 448 1237 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 76
+{
+( 236 1172 120 ) ( 236 1173 120 ) ( 236 1172 121 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 228 1120 120 ) ( 228 1120 121 ) ( 229 1120 120 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 228 1172 120 ) ( 229 1172 120 ) ( 228 1173 120 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 1284 272 ) ( 240 1285 272 ) ( 241 1284 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 240 1288 124 ) ( 241 1288 124 ) ( 240 1288 125 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1284 124 ) ( 240 1284 125 ) ( 240 1285 124 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 77
+{
+( 240 1284 128 ) ( 240 1285 128 ) ( 240 1284 129 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 240 1284 128 ) ( 240 1284 129 ) ( 241 1284 128 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 240 1284 128 ) ( 241 1284 128 ) ( 240 1285 128 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 452 1288 216 ) ( 452 1289 216 ) ( 453 1288 216 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 452 1288 132 ) ( 453 1288 132 ) ( 452 1288 133 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 456 1288 132 ) ( 456 1288 133 ) ( 456 1289 132 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 78
+{
+( 168 1120 176 ) ( 168 1121 176 ) ( 168 1120 177 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 244 1116 176 ) ( 244 1116 177 ) ( 245 1116 176 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 244 1120 176 ) ( 245 1120 176 ) ( 244 1121 176 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 348 1124 272 ) ( 348 1125 272 ) ( 349 1124 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 348 1124 180 ) ( 349 1124 180 ) ( 348 1124 181 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 496 1124 180 ) ( 496 1124 181 ) ( 496 1125 180 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 79
+{
+( 688 912 16 ) ( 688 913 16 ) ( 688 912 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 688 912 16 ) ( 688 912 17 ) ( 689 912 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 688 912 16 ) ( 689 912 16 ) ( 688 913 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 704 1136 272 ) ( 704 1137 272 ) ( 705 1136 272 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 704 1136 32 ) ( 705 1136 32 ) ( 704 1136 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 704 1136 32 ) ( 704 1136 33 ) ( 704 1137 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 80
+{
+( 592 1216 16 ) ( 592 1217 16 ) ( 592 1216 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 592 1216 16 ) ( 592 1216 17 ) ( 593 1216 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 592 1216 16 ) ( 593 1216 16 ) ( 592 1217 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 800 1232 288 ) ( 800 1233 288 ) ( 801 1232 288 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 800 1232 32 ) ( 801 1232 32 ) ( 800 1232 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 800 1232 32 ) ( 800 1232 33 ) ( 800 1233 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 81
+{
+( 1024 896 176 ) ( 1008 896 160 ) ( 1008 1024 160 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 832 896 16 ) ( 832 896 17 ) ( 833 896 16 ) mapping_defaults/ProtoDark -80 -47.999992 0 1 1
+( 832 896 16 ) ( 833 896 16 ) ( 832 897 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1040 976 32 ) ( 1041 976 32 ) ( 1040 976 33 ) mapping_defaults/ProtoDark -80 -47.999992 0 1 1
+( 1072 944 32 ) ( 1072 944 33 ) ( 1072 945 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 82
+{
+( 1072 896 48 ) ( 1072 897 48 ) ( 1072 896 49 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 1040 896 48 ) ( 1040 896 49 ) ( 1041 896 48 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 896 176 ) ( 1088 896 176 ) ( 1088 1024 176 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 976 224 ) ( 1136 977 224 ) ( 1137 976 224 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 976 64 ) ( 1137 976 64 ) ( 1136 976 65 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 976 64 ) ( 1136 976 65 ) ( 1136 977 64 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 83
+{
+( 1056 976 112 ) ( 1056 976 96 ) ( 1056 1104 96 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 864 976 16 ) ( 864 976 17 ) ( 865 976 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 976 112 ) ( 1088 976 112 ) ( 1088 1104 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 496 ) ( 1136 1057 496 ) ( 1137 1056 496 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 32 ) ( 1137 1056 32 ) ( 1136 1056 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 1056 32 ) ( 1136 1056 33 ) ( 1136 1057 32 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 84
+{
+( 864 976 16 ) ( 864 977 16 ) ( 864 976 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 864 976 16 ) ( 864 976 17 ) ( 865 976 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 864 976 16 ) ( 865 976 16 ) ( 864 977 16 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1056 976 112 ) ( 1040 976 112 ) ( 1040 1104 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 32 ) ( 1137 1056 32 ) ( 1136 1056 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 960 976 112 ) ( 960 1104 96 ) ( 960 976 96 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 85
+{
+( 864 976 16 ) ( 864 977 16 ) ( 864 976 17 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 864 976 16 ) ( 864 976 17 ) ( 865 976 16 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 976 112 ) ( 1040 1104 112 ) ( 1040 976 112 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 496 ) ( 1136 1057 496 ) ( 1137 1056 496 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1056 32 ) ( 1137 1056 32 ) ( 1136 1056 33 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1056 976 112 ) ( 1056 1104 96 ) ( 1056 976 96 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 86
+{
+( 1136 896 208 ) ( 1136 897 208 ) ( 1136 896 209 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 1136 896 208 ) ( 1136 896 209 ) ( 1137 896 208 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 896 208 ) ( 1137 896 208 ) ( 1136 897 208 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1152 928 224 ) ( 1152 929 224 ) ( 1153 928 224 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1152 1136 224 ) ( 1153 1136 224 ) ( 1152 1136 225 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1200 928 224 ) ( 1200 928 225 ) ( 1200 929 224 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 87
+{
+( 880 1056 208 ) ( 880 1057 208 ) ( 880 1056 209 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 1120 1056 208 ) ( 1120 1056 209 ) ( 1121 1056 208 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1120 1056 208 ) ( 1121 1056 208 ) ( 1120 1057 208 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1136 224 ) ( 1137 1136 224 ) ( 1136 1136 225 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 1136 1136 224 ) ( 1072 1136 240 ) ( 1072 1264 240 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 1136 1120 224 ) ( 1136 1120 225 ) ( 1136 1121 224 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 88
+{
+( 784 1056 208 ) ( 784 1057 208 ) ( 784 1056 209 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+( 784 1056 208 ) ( 784 1056 209 ) ( 785 1056 208 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 784 1056 208 ) ( 785 1056 208 ) ( 784 1057 208 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 864 1136 288 ) ( 864 1137 288 ) ( 865 1136 288 ) mapping_defaults/ProtoDark -80 224 0 1 1
+( 864 1136 224 ) ( 865 1136 224 ) ( 864 1136 225 ) mapping_defaults/ProtoDark -80 -48 0 1 1
+( 880 1136 224 ) ( 880 1136 225 ) ( 880 1137 224 ) mapping_defaults/ProtoDark -224 -48 0 1 1
+}
+// brush 89
+{
+( -32 640 16 ) ( -32 641 16 ) ( -32 640 17 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -32 640 16 ) ( -32 640 17 ) ( -31 640 16 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -32 640 16 ) ( -31 640 16 ) ( -32 641 16 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 16 784 208 ) ( 16 785 208 ) ( 17 784 208 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 16 784 32 ) ( 17 784 32 ) ( 16 784 33 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 16 784 32 ) ( 16 784 33 ) ( 16 785 32 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+}
+// brush 90
+{
+( -48 864 16 ) ( -48 865 16 ) ( -48 864 17 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -48 864 16 ) ( -48 864 17 ) ( -47 864 16 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -48 864 16 ) ( -47 864 16 ) ( -48 865 16 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 16 1008 304 ) ( 16 1009 304 ) ( 17 1008 304 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 16 1008 32 ) ( 17 1008 32 ) ( 16 1008 33 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 16 1008 32 ) ( 16 1008 33 ) ( 16 1009 32 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+}
+// brush 91
+{
+( -224 496 16 ) ( -224 497 16 ) ( -224 496 17 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -224 496 16 ) ( -224 496 17 ) ( -223 496 16 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -224 496 16 ) ( -223 496 16 ) ( -224 497 16 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 32 544 224 ) ( 32 545 224 ) ( 33 544 224 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 32 544 32 ) ( 33 544 32 ) ( 32 544 33 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( 32 544 32 ) ( 32 544 33 ) ( 32 545 32 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+}
+// brush 92
+{
+( -160 528 144 ) ( -160 529 144 ) ( -160 528 145 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -160 528 144 ) ( -160 528 145 ) ( -159 528 144 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -160 528 144 ) ( -159 528 144 ) ( -160 529 144 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -32 544 160 ) ( -32 545 160 ) ( -31 544 160 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -32 992 160 ) ( -31 992 160 ) ( -32 992 161 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+( -32 544 160 ) ( -32 544 161 ) ( -32 545 160 ) mapping_defaults/ProtoEmerald 0 0 0 0.25 0.25
+}
+}
+// entity 1
+{
+"classname" "enemy_spawn"
+"origin" "-64 -48 40"
+}
+// entity 2
+{
+"classname" "info_player_start"
+"origin" "-96 128 40"
+}
+// entity 3
+{
+"classname" "enemy_spawn"
+"origin" "120 1216 40"
+}

projects/sampleGame/empire.zig

@@ -31,6 +31,7 @@ pub fn create(alloc: std.mem.Allocator) !*@This() {
     const lostEmpire = try core.createEntity();
     const scene = lostEmpire.addComponent(core.Scene).?;
     scene.setPosition(.{ .y = -20 });
+    _ = scene.getAndResolveTransform();
     const empireMesh = lostEmpire.addComponent(rend.MeshComponent).?;
     empireMesh.setMesh("m_empire");
     empireMesh.setTexture("t_empire");

projects/sampleGame/main.zig

@@ -24,6 +24,12 @@ videoFullbright: bool = false,
 
 moveLight: bool = true,
 
+rendererDebugger: *extras.RendererDebug = undefined,
+
+tbMap: ?*bsp.maploader.TBMap = null,
+
+fileWatch: f64 = 3.0,
+
 pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This());
 
 pub fn init(allocator: std.mem.Allocator) !*@This() {
@@ -140,6 +146,32 @@ pub const DamagedHelmet = struct {
     }
 };
 
+pub fn loadMap2(self: *@This()) !void {
+    if (self.tbMap) |tbMap| {
+        core.engine_log("killing the map", .{});
+        tbMap.destroy();
+    }
+
+    self.tbMap = try bsp.maploader.LoadTrenchbroomMap(self.allocator, .{
+        .rotation = core.Rotation.eulerX(core.radians(-90.0)),
+        .mapName = "bsp/testmap.map",
+    });
+
+    core.engine_log("map loaded", .{});
+}
+
+pub fn loadMap(self: *@This()) void {
+    self.tbMap = bsp.maploader.LoadTrenchbroomMap(self.allocator, .{
+        .rotation = core.Rotation.eulerX(core.radians(-90.0)),
+        .mapName = "bsp/testmap.map",
+    }) catch |err| {
+        core.engine_log("unable to load map, error: {any}", .{err});
+        self.tbMap = null;
+        return;
+    };
+    core.engine_log("map loaded", .{});
+}
+
 pub fn prepare(self: *@This()) !void {
     core.engine_log(">>>>>>> game prepare", .{});
     var z = core.tracy.ZoneN(@src(), "PREPARING GAME");
@@ -148,6 +180,8 @@ pub fn prepare(self: *@This()) !void {
     try script.loadTypes("scripts");
     try script.runScriptFile("scripts/prepare.lua");
 
+    self.rendererDebugger = try extras.RendererDebug.create(self.allocator); //try core.createObject(extras.RendererDebug, .{});
+
     self.objectSpawner = try extras.ObjectSpawner.create(self.allocator);
     try self.objectSpawner.addSpawnFunction("fox", FoxObject);
     try self.objectSpawner.addSpawnFunction("doomplayer", DoomPlayer.DoomCanvas);
@@ -330,14 +364,21 @@ pub fn getMouseMovement(self: *@This()) core.Vector2f {
 pub fn tick(self: *@This(), dt: f64) void {
     const fdt: f32 = @floatCast(dt);
 
-    const z = tracy.ZoneN(@src(), "tick sampleGameMain");
-    defer z.End();
+    _ = ig.dockSpaceOverViewport(ig.getMainViewport(), .{ .passthru_central_node = true }, null);
+
+    self.fileWatch -= dt;
+    if (self.fileWatch < 0) {
+        self.fileWatch = 3.0;
+    }
 
     const z1 = tracy.ZoneN(@src(), "inputDebugger");
-    extras.inputDebugger.tick();
+    if (!self.mouseLook) {
+        extras.inputDebugger.tick();
+    }
     z1.End();
 
     const z2 = tracy.ZoneN(@src(), "inputDebugger");
+    self.objectSpawner.windowOpen = !self.mouseLook;
     self.objectSpawner.tick(dt);
     z2.End();
 
@@ -349,6 +390,10 @@ pub fn tick(self: *@This(), dt: f64) void {
     self.fpcamera.tick(dt);
     z4.End();
 
+    const z5 = tracy.ZoneN(@src(), "");
+    DoomPlayer.maybeTick(dt);
+    z5.End();
+
     var movement = self.fpcamera.getForwardXZ().fmul(self.moveVector.z * fdt * self.cameraSpeed);
     movement = movement.add(self.fpcamera.getRightXZ().fmul(self.moveVector.x * fdt * self.cameraSpeed));
     movement = movement.add(.{ .y = self.verticalMove * fdt * self.cameraSpeed });
@@ -373,29 +418,60 @@ pub fn tick(self: *@This(), dt: f64) void {
         rend.context().lightPosition = debugCenter;
     }
 
+    // self.loadMap2() catch unreachable;
     // show a window with the current camera's position
 
-    if (ig.begin("meh", &self.showWindow, .{})) {
-        ig.textFmt("x:{d:.03} y:{d:.03} z:{d:.03}", .{ pos.x, pos.y, pos.z }) catch return;
-        if (ig.checkbox("video fullbright", &self.videoFullbright)) {
-            if (self.videoplayerObject.fetch(rend.MeshComponent)) |mesh| {
-                mesh.textureMode.fullbright = self.videoFullbright;
+    if (!self.mouseLook) {
+        self.rendererDebugger.tick(dt);
+        if (ig.begin("meh", null, .{})) {
+            ig.textFmt("x:{d:.03} y:{d:.03} z:{d:.03}", .{ pos.x, pos.y, pos.z }) catch return;
+            if (ig.checkbox("video fullbright", &self.videoFullbright)) {
+                if (self.videoplayerObject.fetch(rend.MeshComponent)) |mesh| {
+                    mesh.textureMode.fullbright = self.videoFullbright;
+                }
+            }
+
+            if (ig.checkbox("move lights ", &self.moveLight)) {}
+
+            ig.textFmt("info: - WASD to move, mouse to look,\n- Q and E to go up and down", .{}) catch return;
+            ig.textFmt("- shift to slow down camera speed", .{}) catch return;
+            ig.textFmt("- T to enable/disable mouse cursor", .{}) catch return;
+            ig.textFmt("- f2 to route all inputs to the doom player", .{}) catch return;
+            ig.textFmt("- movingLight checkbox makes the light stop moving with you", .{}) catch return;
+
+            if (ig.smallButton("reload map")) {
+                self.loadMap2() catch unreachable;
+            }
+
+            if (ig.smallButton("destroy map")) {
+                if (self.tbMap) |tbMap| {
+                    core.engine_log("killing the map", .{});
+                    tbMap.destroy();
+                    self.tbMap = null;
+                }
             }
         }
+        ig.end();
 
-        if (ig.checkbox("move lights ", &self.moveLight)) {}
+        if (ig.begin("mesh components", null, .{})) {
+            for (rend.MeshComponent.BaseContainer.dense.items) |*v| {
+                ig.textFmt("mesh: {s}", .{v.value.meshName.utf8()}) catch unreachable;
+            }
+        }
+        ig.end();
 
-        ig.textFmt("info: - WASD to move, mouse to look,\n- Q and E to go up and down", .{}) catch return;
-        ig.textFmt("- shift to slow down camera speed", .{}) catch return;
-        ig.textFmt("- T to enable/disable mouse cursor", .{}) catch return;
-        ig.textFmt("- f2 to route all inputs to the doom player", .{}) catch return;
-        ig.textFmt("- movingLight checkbox makes the light stop moving with you", .{}) catch return;
+        if (ig.begin("scene components", null, .{})) {
+            for (core.Scene.BaseContainer.dense.items) |*v| {
+                ig.textFmt("scene entity: {d}", .{v.value.handle.index}) catch unreachable;
+            }
+        }
         ig.end();
     }
 }
 
 pub fn deinit(self: *@This()) void {
-    // self.doomplayer.destroy();
+    self.rendererDebugger.destroy();
+    DoomPlayer.DoomCanvas.cleanupDoom();
     self.fpcamera.destroy();
 
     self.objectSpawner.destroy();
@@ -417,6 +493,8 @@ pub fn main() anyerror!void {
 const DoomPlayer = @import("doomplayer");
 const VideoPlayer = @import("videoplayer");
 const extras = @import("gameExtras");
+const bsp = @import("bsp");
+
 const FpCamera = extras.FpCamera;
 const std = @import("std");
 const backlog = @import("Backlog");

tools/trenchbroom/fonts/SIL Open Font License.txt

@@ -0,0 +1,43 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.

tools/trenchbroom/games/DDayNormandy/GameConfig.cfg

@@ -0,0 +1,202 @@
+{
+    "version": 9,
+    "name": "D-Day Normandy",
+    "icon": "Icon.png",
+    "fileformats": [
+        { "format": "Quake2" },
+        { "format": "Quake2 (Valve)"}
+    ],
+    "filesystem": {
+        "searchpath": "dday",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [".wal"],
+        "palette": "pics/colormap.pcx"
+    },
+    "entities": {
+        "definitions": [ "dday.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [
+            {
+                "name": "Trigger",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "trigger*",
+                "material": "trigger"
+            }
+        ],
+        "brushface": [
+            {
+                "name": "Clip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "clip"
+            },
+            {
+                "name": "Skip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "skip"
+            },
+            {
+                "name": "Hint",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "hint*"
+            },
+            {
+                "name": "Detail",
+                "match": "contentflag",
+                "flags": [ "detail" ]
+            },
+            {
+                "name": "Liquid",
+                "match": "contentflag",
+                "flags": [ "lava", "slime", "water" ]
+            }
+        ]
+    },
+    "faceattribs": {
+        "surfaceflags": [
+            {
+                "name": "light",
+                "description": "Emit light from the surface, brightness is specified in the 'value' field"
+            },
+            {
+                "name": "slick",
+                "description": "The surface is slippery"
+            },
+            {
+                "name": "sky",
+                "description": "The surface is sky, the texture will not be drawn, but the background sky box is used instead"
+            },
+            {
+                "name": "warp",
+                "description": "The surface warps (like water textures do)"
+            },
+            {
+                "name": "trans33",
+                "description": "The surface is 33% transparent"
+            },
+            {
+                "name": "trans66",
+                "description": "The surface is 66% transparent"
+            },
+            {
+                "name": "flowing",
+                "description": "The texture wraps in a downward 'flowing' pattern (warp must also be set)"
+            },
+            {
+                "name": "nodraw",
+                "description": "Used for non-fixed-size brush triggers and clip brushes"
+            },
+            {
+                "name": "hint",
+                "description": "Make a primary bsp splitter"
+            },
+            {
+                "name": "skip",
+                "description": "Completely ignore, allowing non-closed brushes"
+            }
+        ],
+        "contentflags": [
+            {
+                "name": "solid",
+                "description": "Default for all brushes"
+            }, // 1 << 0
+            {
+                "name": "window",
+                "description": "Brush is a window (not really used)"
+            }, // 1 << 1
+            {
+                "name": "aux",
+                "description": "Unused by the engine"
+            }, // 1 << 2
+            {
+                "name": "lava",
+                "description": "The brush is lava"
+            }, // 1 << 3
+            {
+                "name": "slime",
+                "description": "The brush is slime"
+            }, // 1 << 4
+            {
+                "name": "water",
+                "description": "The brush is water"
+            }, // 1 << 5
+            {
+                "name": "mist",
+                "description": "The brush is non-solid"
+            }, // 1 << 6
+            { "name": "true" }, // 1 << 7
+            { "name": "true" }, // 1 << 8
+            { "name": "true" }, // 1 << 9
+            { "name": "true" }, // 1 << 10
+            { "name": "true" }, // 1 << 11
+            { "name": "true" }, // 1 << 12
+            { "name": "true" }, // 1 << 13
+            { "name": "true" }, // 1 << 14
+            { "name": "true" }, // 1 << 15
+            {
+                "name": "playerclip",
+                "description": "Player cannot pass through the brush (other things can)"
+            }, // 1 << 16
+            {
+                "name": "mosterclip",
+                "description": "Monster cannot pass through the brush (player and other things can)"
+            }, // 1 << 17
+            {
+                "name": "current_0",
+                "description": "Brush has a current in direction of 0 degrees"
+            }, // 1 << 18
+            {
+                "name": "current_90",
+                "description": "Brush has a current in direction of 90 degrees"
+            }, // 1 << 19
+            {
+                "name": "current_180",
+                "description": "Brush has a current in direction of 180 degrees"
+            }, // 1 << 20
+            {
+                "name": "current_270",
+                "description": "Brush has a current in direction of 270 degrees"
+            }, // 1 << 21
+            {
+                "name": "current_up",
+                "description": "Brush has a current in the up direction"
+            }, // 1 << 22
+            {
+                "name": "current_dn",
+                "description": "Brush has a current in the down direction"
+            }, // 1 << 23
+            {
+                "name": "origin",
+                "description": "Special brush used for specifying origin of rotation for rotating brushes"
+            }, // 1 << 24
+            {
+                "name": "monster",
+                "description": "Purpose unknown"
+            }, // 1 << 25
+            {
+                "name": "corpse",
+                "description": "Purpose unknown"
+            }, // 1 << 26
+            {
+                "name": "detail",
+                "description": "Detail brush"
+            }, // 1 << 27
+            {
+                "name": "translucent",
+                "description": "Use for opaque water that does not block vis"
+            }, // 1 << 28
+            {
+                "name": "ladder",
+                "description": "Brushes with this flag allow a player to move up and down a vertical surface"
+            } // 1 << 29
+        ]
+    }
+}

tools/trenchbroom/games/DDayNormandy/dday.fgd

@@ -0,0 +1,636 @@
+//
+// D-Day Normandy game definition file (.fgd)
+//
+// Written by Christian aka Vio
+//	https://github.com/chow-land
+//
+// Original dday entity guide:
+// https://www.quakewiki.net/archives/dday.planetquake.gamespy.com/site/user_guides/manual/pages/mapmaking.htm
+//
+// Last updated:  July 15th, 2020
+//
+
+@SolidClass = worldspawn : "World entity"
+[
+	sky(string) : "Environment map name"
+	skyaxis(string) : "Vector axis for rotating sky"
+	skyrotate(string) : "Speed of rotation (degrees/second)"
+	gravity(integer) : "Gravity" : 800
+	message(string) : "Level name"
+]
+//xaGe: added missing superclasses Appearflags, Targetname, Target and then fixed all the case issues.
+@baseclass = Appearflags [
+	spawnflags(Flags) =
+	[
+		256 : "Not in Easy" : 0
+		512 : "Not in Normal" : 0
+		1024 : "Not in Hard" : 0
+		2048 : "Not in Deathmatch" : 0
+	]
+]
+
+@baseclass = Targetname [ targetname(target_source) : "Name" ]
+@baseclass = Target [ target(target_destination) : "Target" ]
+
+@baseclass base(Appearflags, Targetname) size(-16 -16 -24, 16 16 32) color(0 255 0) = PlayerClass []
+
+@PointClass = info_team_start : "Configures info for a team. There should be 2 of these on your map."
+[
+	obj_owner(integer) : "Owning team (0-allies or 10-axis)"
+	message(string) :"Team Name (required)"
+	dll(choices) : "Team DLL" = 
+	[
+		"usa" : "USA"
+		"usm" : "US Marines"
+		"grm" : "Germans"
+		"gbr" : "British"
+		"rus" : "Russians"
+		"jpn" : "Japanese"
+		"pol" : "Polish"
+	]
+	kills(integer) : "Kills to win"
+	points(integer) : "Points to win"
+	nextmap(string) : "Map to load if the team that owns this entity wins (obsolete)"
+]
+
+
+// PLAYER SPAWNS
+
+@PointClass base(PlayerClass) color(127 0 128) = info_player_start : "You wait here when you are dead" []
+
+@PointClass base(PlayerClass) color(0 255 0) = info_reinforcements_start : "All players on team will spawn here, unless there is a class-specific spawn for that player's current class. If there are multiple info_reinforcements_start entities for a given team the player will spawn at a random one."
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+
+// CLASS-SPECIFIC SPAWNS
+
+@PointClass base(PlayerClass) color(0 0 255) = info_infantry_start : "Infantry class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_officer_start : "Officer class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_lgunner_start : "Light Machinegun class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_hgunner_start : "Heavy Machinegun class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_sniper_start : "Sniper class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_special_start : "Special class spawns here (usually Airborne, but varies for different team dlls"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_engineer_start : "Engineer class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_medic_start : "Medic Class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+@PointClass base(PlayerClass) color(0 0 255) = info_flamethrower_start : "Flamethrower class spawns here"
+[
+	obj_owner(integer) : "Owning Team" : 0
+	angle(string) : "Direction the player will face when spawning" : "0 0 0"
+]
+
+
+// MAP PROPS
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path": ":models/ships/viper/tris.md2" }) = misc_viper : "The default viper ship entity from Quake2, but replaced with a P51 Mustang."
+[
+	target(string) : "Direction the P51 model will face"
+	speed(integer) : "How fast the P51 should fly"
+
+]
+//xaGe: added "path": model to entity so it renders md2s defined by model(string) in TB.
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : model }) = misc_md2 : "General purpose entity for adding an .md2 map model."
+[
+	model(string) : "Path to the model, example: models/mapmodels/tree/tris.md2"
+	angle(integer) : "Direction the model will face"
+]
+
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : ":models/objects/banner/tris.md2" }) = misc_banner : "German flag 1"
+[
+	angle(integer) : "Direction the banner will face"
+]
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : ":models/objects/banner1/tris.md2" }) = misc_banner_1 : "German flag 2"
+[
+	angle(integer) : "Direction the banner will face"
+]
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : ":models/objects/banner2/tris.md2" }) = misc_banner_2 : "German flag 3"
+[
+	angle(integer) : "Direction the banner will face"
+]
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : ":models/objects/banner3/tris.md2" }) = misc_banner_3 : "British flag"
+[
+	angle(integer) : "Direction the banner will face"
+]
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : ":models/objects/banner4/tris.md2" }) = misc_banner_4 : "US Flag"
+[
+	angle(integer) : "Direction the banner will face"
+]
+
+@PointClass base(Appearflags, Targetname) color(255 128 0) size(-16 -16 0, 16 16 32) model({ "path" : ":models/deadbods/dude/tris.md2" }) = misc_skeleton : "A skeleton lying on its back."
+[
+	angle(integer) : "Direction the skeleton model will face"
+]
+
+
+// OBJECTIVES
+
+@SolidClass base(Appearflags, Targetname, Target) color(0 0 255) = objective_touch : "Player touches this and is awarded points"
+[
+	obj_owner(integer) : "Assign a value (0, 1, 99); 0=Allies 1=Axis 99=Neutral (Anyone can claim it first)"
+	message(string) : "Name of the region the entity touches (Center Pill, Right Pill, Donut Room, etc.)"
+	health(integer) : "Enter a number value representing the number of points to be awarded to the other team when the entity is claimed"
+	dmg(integer) : "Enter a number value representing the number of points to be deducted when the entity owner loses the objective"
+]
+
+
+@SolidClass base(Appearflags, Targetname, Target) color(0 0 255) = func_explosive_objective : "Gives points when blown up"
+[
+	obj_owner(integer) : "Assign a value (0, 1, 99); 0=Allies 1=Axis 99=Neutral (Anyone can claim it first)"
+	obj_name(string) : "Name of the object to be displayed when destroyed"
+	obj_loss(integer) : "Amount of points taken away from the owner when destroyed"
+	obj_gain(integer) : "Amount of points given to the team that doesn’t own the objective when it is destroyed"
+	message(string) : "Name of the region the entity touches (Center Pill, Right Pill, Donut Room, etc.)"
+	health(integer) : "	Amount of damage it takes to blow the objective up"
+	dmg(integer) : "Radius damage to inflict on people surrounding the objective when it explodes"
+]
+
+
+// The quake2 turret entities can be used in dday to create Player-usable turrets. 
+// The process for creating turrets is the same as in regular quake2, with the addition of a new entity, "turret_range", which defines the area where the player must occupy to use the turret. To use a turret you need to switch to fists and then right click.
+// More info: http://ddaydev.com/forum/viewtopic.php?f=2&t=235
+
+
+@SolidClass base (Appearflags, Targetname, Target) color (128 0 128) = turret_range : "Turret Range. Use this to define the area the player must occupy to use the turret."
+[
+	team(string) : "Team"
+]
+
+@SolidClass base(Appearflags, Targetname, Target) color(128 255 128) = turret_breach : "Turret breach"
+[
+	// These first 6 values are dday specific.
+	rate(integer) : "firing rate, set to 0 for machineguns or higher for tanks"
+	count(integer) : "number of rounds, -1 is infinite"
+	ammo_type(string) : "shell, fire, bullet, tracer, rocket, or grenade"
+	fire_sound(string) : "the .wav file you want to play for firing"
+	ammo_speed(integer) : "how fast the ammo goes through the air"
+	model(string) : "if you want to use an md2 for the gun instead of bsp brushes in the map"
+
+	speed(integer) : "Speed" : 50
+	dmg(integer) : "Damage" : 10
+	minpitch(integer) : "Miminum pitch angle" : -30
+	maxpitch(integer) : "Maximum pitch angle" : 30
+	minyaw(integer) : "Minimum yaw angle" : 0
+	maxyaw(integer) : "Maximum yaw angle" : 360
+	team(string) : "Team"
+	_minlight(string) : "Minimum light (optional)"
+]
+@SolidClass base(Appearflags) color(128 255 128) = turret_base : "Turret base"
+[
+	team(string) : "Team"
+	_minlight(string) : "Minimum light (optional)"
+]
+
+
+// Vanilla Q2 Entities Supported by D-Day
+
+
+// Keep in mind when using func_areaportal that it must
+// *completely* separate two areas.  otherwise, you will
+// get an error message and the areaportal will not work
+//
+// 0221 - is there any point in a "style" key?
+@SolidClass base(Appearflags, Targetname) = func_areaportal : "Area portal (Vis blocker)" []
+
+// 0221 - added "pathtarget"
+// 0221 - changed "sounds" information
+@SolidClass base(Appearflags, Target, Targetname) color(0 128 204) = func_button : "Button"
+[
+	pathtarget(string) : "Elevator level target"
+	speed(integer) : "Speed" : 40
+	wait(choices) : "Wait before reset" : 1 =
+	[
+		-1 : "Never Return"
+	]
+	lip(integer) : "Lip remaining after move" : 4
+	health(integer) : "Health (shootable)"
+	sounds(choices) : "Sounds" : 0 =
+	[
+		0 : "Audible"
+		1 : "Silent"
+	]
+//	sounds(choices) : "Sounds" : 2 =
+//	[
+//		1 : "Silent"
+//		2 : "Steam Metal"
+//		3 : "Wodden Clunk"
+//		4 : "Metallic Click"
+//		5 : "In-Out"
+//	]
+	message(string) : "Activation message"
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+
+
+
+// 0221 - updated "sounds" information
+// 0221 - added "killtarget"
+@SolidClass base(Appearflags, Targetname, Target) color(0 128 204) = func_door : "Door"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start Open" : 0
+		4 : "Crusher" : 0
+		8 : "No Monsters" : 0
+		16 : "Animated" : 0
+		32 : "Toggle" : 0
+		64 : "Animated Fast" : 0
+	]
+	killtarget(string) : "Kill Target"
+	team(string) : "Team"
+	message(string) : "Trigger message"
+	health(integer) : "Health (shootable)"
+	speed(integer) : "Speed" : 100
+	wait(choices) : "Wait before close" : 3 =
+	[
+		-1 : "Stay open"
+	]
+	lip(integer) : "Lip remaining after move" : 8
+	dmg(integer) : "Damage when blocked" : 2
+	sounds(choices) : "Sounds" : 0 =
+	[
+		0 : "Audible"
+		1 : "Silent"
+	]
+//	sounds(choices) : "Sounds" : 3 =
+//	[
+//		1 : "Silent"
+//		2 : "Light"
+//		3 : "Medium"
+//		4 : "Heavy"
+//	]
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+// 0221 - added "killtarget" and "target" keys
+// 0221 - updated "sounds" info
+// 0221 - removed "lip" key
+@SolidClass base(Appearflags, Targetname, Target) color(0 128 204) = func_door_rotating : "Rotating Door"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start Open" : 0
+		2 : "Reverse" : 0
+		4 : "Crusher" : 0
+		8 : "No Monsters" : 0
+		16 : "Animated" : 0
+		32 : "Toggle" : 0
+		64 : "X Axis" : 0
+		128 : "Y Axis" : 0
+	]
+	killtarget(string) : "Kill Target"
+	team(string) : "Team"
+	distance(integer) : "Degrees of rotation" : 90
+	message(string) : "Trigger message"
+	health(integer) : "Health (shootable)"
+	speed(integer) : "Speed" : 100
+	wait(choices) : "Wait before close" : 3 =
+	[
+		-1 : "Stay open"
+	]
+	dmg(integer) : "Damage when blocked" : 2
+	sounds(choices) : "Sounds" : 0 =
+	[
+		0 : "Audible"
+		1 : "Silent"
+	]
+//	sounds(choices) : "Sounds" : 3 =
+//	[
+//		1 : "Silent"
+//		2 : "Light"
+//		3 : "Medium"
+//		4 : "Heavy"
+//	]
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+
+// not visible in DM mode
+//
+// 0221 - added "_minlight" key (even tho you dont want it to stand out)
+@SolidClass base(Appearflags, Targetname, Target) color(0 128 204) = func_explosive : "Exploding/Breakable brush"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Trigger Spawn" : 0
+		2 : "Animated" : 0
+		4 : "Animated Fast" : 0
+	]
+	health(integer) : "Health" : 100
+	mass(integer) : "Mass (debris)" : 75
+	dmg(integer) : "Damage" : 0
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+@SolidClass base(Appearflags, Targetname) color(255 0 0) = func_killbox : "Instant death" []
+
+// 0221 - added "_minlight" key
+@SolidClass base(Appearflags, Targetname) color (0 128 204) = func_object : "Solid bmodel, will fall if its support is removed"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Trigger Spawn" : 0
+		2 : "Animated" : 0
+		4 : "Animated Fast" : 0
+	]
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+// 0221 - removed "sounds" key
+@SolidClass base(Appearflags, Targetname) color(0 128 204) = func_plat : "Platform"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Plat Low Trigger" : 0
+	]
+	speed(integer) : "Speed" : 100
+	accel(integer) : "Acceleration" : 500
+	lip(integer) : "Lip remaining after move" : 8
+	height(integer) : "Movement distance"
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+// 0222 - added "team" key
+@SolidClass base(Appearflags, Targetname) color(0 128 204) = func_rotating : "Rotating brush"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start On" : 0
+		2 : "Reverse" : 0
+		4 : "X Axis" : 0
+		8 : "Y Axis" : 0
+		16 : "Pain on Touch" : 0
+		32 : "Block Stops" : 0
+		64 : "Animated" : 0
+		128 : "Animated Fast" : 0
+	]
+	team(string) : "Team"
+	speed(integer) : "Speed" : 100
+	dmg(integer) : "Damage when blocked" : 2
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+@PointClass base(Appearflags, Targetname, Target) color(76 25 153) size(-8 -8 -8, 8 8 8) = func_timer : "Timer"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start On" : 0
+	]
+	wait(integer) : "Base wait time" : 1
+	random(integer) : "Wait variance (+/-)"
+	delay(integer) : "Delay before first firing"
+	pausetime(integer) : "Additional delay"
+]
+
+// 0219 - added "team" key
+@SolidClass base(Appearflags, Targetname) color(0 128 204) = func_train : "Moving platform"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start On" : 0
+		2 : "Toggle" : 0
+		4 : "Block Stops" : 0
+	]
+	target(string) : "First stop target"
+	team(string) : "Team"
+	speed(integer) : "Speed" : 100
+	dmg(integer) : "Damage when blocked" : 2
+	noise(string) : "Sound (path/file.wav)"
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+// 0221 - added a "_minlight" key
+@SolidClass base(Appearflags, Targetname) color(0 128 204) = func_wall : "Solid Wall"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Trigger Spawn" : 0
+		2 : "Toggle" : 0
+		4 : "Start On" : 0
+		8 : "Animated" : 0
+		16 : "Animated Fast" : 0
+	]
+	_minlight(integer) : "Minimum light (optional)"
+]
+
+@PointClass base(Appearflags, Targetname) color(0 128 0) size(-4 -4 -4, 4 4 4) = info_null : "Spotlight target" []
+@PointClass base(info_null) = info_notnull : "Lightning target" []
+
+
+@PointClass base(Appearflags, Target, Targetname) color(0 255 0) size(-8 -8 -8, 8 8 8) = light : "Light"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start Off" : 0
+	]
+	light(integer) : "Brightness" : 300
+	style(Choices) : "Style" : 0 =
+	[
+		0 : "Normal"
+		1 : "Flicker #1"
+		6 : "Flicker #2"
+		2 : "Slow Strong Pulse"
+		3 : "Candle #1"
+		7 : "Candle #2"
+		8 : "Candle #3"
+		4 : "Fast Strobe"
+		5 : "Gentle Pulse #1"
+		9 : "Slow Strobe"
+		10 : "Fluorescent Flicker"
+		11 : "Slow pulse, no black"
+	]
+	_cone(integer) : "Size of light (spotlight)" : 10
+]
+
+// actor code is still broken...leaving this in because i know *someone* will fix
+// this because its pretty damn cool.
+@PointClass base(PlayerClass, Target) = misc_actor : "Actor"
+[
+	health(integer) : "Health" : 100
+]
+
+@PointClass base(Appearflags, Targetname) color(255 0 0) size(-32 -32 -24, 32 32 -16) model({ "path": ":models/objects/dmspot/tris.md2", "skin": 1 }) = misc_teleporter : "Teleporter: To hide the teleport pads, place them units 10 units into a brush."	[	target(string) : "Teleport Destination"	]
+@PointClass base(Appearflags, Targetname) color(255 0 0) size(-32 -32 -24, 32 32 -16) model({ "path": ":models/objects/dmspot/tris.md2", "skin": 0 }) = misc_teleporter_dest : "Teleport Destination: To hide the teleport pads, place them units 10 units into a brush." []
+
+
+// using a "wait" value of -1 on a path corner causes a func_train to go silent between
+// itself and the next path corner when the train is restarted. The train's sound will
+// resume as soon as it reaches a path corner with a "wait" value other than -1
+@PointClass base(Appearflags, Targetname) color(128 76 0) size(-8 -8 -8, 8 8 8) = path_corner : "Path marker"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Teleport" : 0
+	]
+	target(string) : "Next path target"
+	pathtarget(string) : "Event to trigger"
+	wait(choices) : "Wait" : 0 =
+	[
+		-1 : "Wait for retrigger"
+	]
+]
+
+@PointClass base(Appearflags, Targetname) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_explosion : "Explosion"
+[
+	delay(integer) : "Delay before explosion"
+	dmg(integer) : "Radius damage" : 0
+]
+
+// looped sounds are automatically volume 1, attenuation 3 :\
+@PointClass base(Appearflags, Targetname) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_speaker : "Sound player"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Looped On" : 0
+		2 : "Looped Off" : 0
+		4 : "Reliable" : 0
+	]
+	noise(string) : "Sound (path/file.wav)"
+	attenuation(Choices) : "Attenuation" : 1 =
+	[
+		-1 : "None, send to whole level"
+		1 : "Normal fighting sounds"
+		2 : "Idle sound level"
+		3 : "Ambient sound level"
+	]
+	volume(integer) : "Volume (0.0 - 1.0)" : 1
+]
+
+// "sounds" values other than 1 are silent.  leaving in the other
+// options for availability to mods/fixes
+//
+// 0221 - clarified "count" description
+@PointClass base(Appearflags, Targetname) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_splash : "Creates a splash when used"
+[
+	sounds(choices) : "Type of splash" : 2 =
+	[
+		1 : "Sparks"
+		2 : "Blue water"
+		3 : "Brown water"
+		4 : "Slime"
+		5 : "Lava"
+		6 : "Blood"
+	]
+	count(integer) : "Number of pixels in splash (1 - 255)"
+	dmg(integer) : "Radius damage"
+]
+
+
+// 0221 - added "delay" and "killtarget" keys
+@PointClass base(Appearflags, Target) color(128 128 128) size(-8 -8 -8, 8 8 8) = trigger_always : "Always triggers"
+[
+	killtarget(string) : "Kill Target"
+	delay(integer) : "Time before triggering"
+]
+
+@SolidClass base(Appearflags, Targetname, Target) color(128 128 128) = trigger_counter : "Counter"
+[
+	spawnflags(Flags) =
+	[
+		1 : "No Message" : 0
+	]
+	count(integer) : "Count before trigger" : 2
+]
+
+@PointClass base(Appearflags, Targetname, Target) color(76 25 153) = trigger_elevator : "Elevator trigger" []
+
+@SolidClass base(Appearflags) color(128 128 128) = trigger_gravity : "Change gravity"
+[
+	gravity(integer) : "Gravity (standard = 1.0)" : 1
+]
+
+@SolidClass base(Appearflags, Targetname) color(128 128 128) = trigger_hurt : "Hurts on touch"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Start Off" : 0
+		2 : "Toggle" : 0
+		4 : "Silent" : 0
+		8 : "No Protection" : 0
+		16 : "Slow hurt" : 0
+	]
+	dmg(integer) : "Damage" : 5
+]
+
+// 0221 - switched around _relay, _once, and _multiple
+@PointClass base(Appearflags, Targetname, Target) color(128 128 128) = trigger_relay : "Relay trigger"
+[
+	killtarget(string) : "Kill Target"
+	delay(integer) : "Time before triggering"
+	message(string) : "Trigger message"
+]
+
+// 0303 - removed "sounds" key
+@SolidClass base(trigger_relay) = trigger_once : "Single fire trigger"
+[
+	spawnflags(Flags) =
+	[
+		4 : "Triggered" : 0
+	]
+]
+
+@SolidClass base(trigger_once) = trigger_multiple : "Multiple fire trigger"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Monster" : 0
+		2 : "Not Player" : 0
+	]
+	wait(integer) : "Seconds between triggers" : 0
+]
+
+@SolidClass base(Appearflags) color(128 128 128) = trigger_push : "Push trigger"
+[
+	spawnflags(Flags) =
+	[
+		1 : "Push Once" : 0
+	]
+	speed(integer) : "Speed of push" : 1000
+]

tools/trenchbroom/games/Daikatana/Episode 1.fgd

@@ -0,0 +1,117 @@
+//
+// Daikatana game definition file (.fgd)
+// Episode 1 entities
+// for Trenchbroom
+// last update: 6 Oct, 2018
+// Version: 1
+//
+// written by Dekonega <dekonega(at)windowslive.com>
+// email me with improvements and suggestions
+//
+
+@include "Common.fgd"
+
+
+//
+// Items (Episode 1)
+//
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e1/a1_clcrd.dkm" }) = item_keycard_cell : "E1 prison cell key" []
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e1/a1_ar2.dkm" }) = item_chromatic_armor : "Chromatic armor" []
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e1/a1_ar1.dkm" }) = item_plasteel_armor : "Plasteel armor" []
+
+
+//
+// Monsters (Episode 1)
+//
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 8) model({ "path": "models/e1/m_croco.dkm" }) = monster_crox : "Crox" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 40) model({ "path": "models/e1/m_mwsurgeon.dkm" }) = monster_surgeon : "Surgeon" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 40) model({ "path": "models/e1/m_mwguard.dkm" }) = monster_mishimaguard : "Mishima guard" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e1/m_MWFaty.dkm" }) = monster_fatworker : "Fat worker" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 40) model({ "path": "models/e1/m_MWSkny.dkm" }) = monster_skinnyworker : "Skinny worker" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-12 -12 0, 12 12 24) model({ "path": "models/e1/m_proto.dkm" }) = monster_protopod : "Protopod" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-24 -24 -16, 24 24 32) model({ "path": "models/e1/m_dsphere.dkm" }) = monster_deathsphere : "Deathsphere" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-24 -24 -24, 24 24 24) model({ "path": "models/e1/m_cambot.dkm" }) = monster_cambot : "Cambot" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-40 -40 -40, 40 40 48) model({ "path": "models/e1/m_ragemaster.dkm" }) = monster_ragemaster : "Ragemaster" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-24 -24 -16, 24 24 24) model({ "path": "models/e1/m_bboar.dkm" }) = monster_battleboar : "Battle boar" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 36) model({ "path": "models/e1/m_cryotech.dkm" }) = monster_cryotech : "Cryotech" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-24 -24 -24, 24 24 32)  model({ "path": "models/e1/m_psyclaw.dkm" }) = monster_psyclaw : "Psyclaw" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -8, 16 16 8) model({ "path": "models/e1/m_trakatak.dkm" }) = monster_lasergat : "Lasergat" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-32 -32 -40, 32 32 48) model({ "path": "models/e1/m_inmater.dkm" }) = monster_inmater : "Inmater" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e1/m_prizb.dkm" }) = monster_prisonerb : "Prisoner B" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e1/m_priza.dkm" }) = monster_prisoner : "Prisoner" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-40 -40 -40, 40 40 56) model({ "path": "models/e1/m_sludgeminion.dkm" }) = monster_sludgeminion : "Sludgeminion" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -8, 16 16 16) model({ "path": "models/e1/m_vermin.dkm" }) = monster_venomvermin : "Venomvermin" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-40 -40 0, 40 40 96) model({ "path": "models/e1/m_tskeet.dkm" }) = monster_thunderskeet : "Thunderskeet" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -8, 16 16 8) model({ "path": "models/e1/m_skeeter.dkm" }) = monster_slaughterskeet : "Roboskeet" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-8 -8 -16, 8 8 16) model({ "path": "models/e1/m_frog.dkm" }) = monster_froginator : "Froginator" []
+
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -16, 16 16 16) model({ "path": "models/e1/a1_rockgun.dkm" }) = monster_rockgat : "Rockgat"
+[
+	fire_rate(float): "secs between firing default = 0.20" : 0.20
+	range(integer): "attack radius default = 512" : 512
+	basedmg(integer): "dmg done with a hit"
+	rnddmg(integer): "random damage amount added on"
+	health(integer): "health value"
+]
+
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-8 -8 -8, 8 8 8) model({ "path": "models/global/e_flare.sp2" }) = monster_firefly : "Firefly"
+[
+	spawnflags(Flags) =
+	[
+		1: "YELLOW" : 0
+		2: "GREEN" : 0
+		4: "BLUE" : 0
+		8: "WHITE" : 0
+		16: "RED" : 0
+	]
+
+	count(integer): "Number of fireflies(Max=10)"
+	distance(integer): "How far the fireflies will fly from point of placement(Max=200)"
+	velocity(integer): "How fast the fireflies will move(Max=200)"
+	scale(float): "How big the fireflies will be<float value>(1 = normal, 0.5 = half, 2 = twice as big)"
+	delta_alpha(float): "frequency of Alpha blending change. <scalar>"
+	alpha_level(float): "Initial Setting for Alpha blending change.<scalar>"
+]
+
+
+//
+// Decorations (Episode 1)
+//
+@PointClass base(Appearflags, DecorationFlags) color(1 0 0) size(-8 -8 -32, 8 8 32) = deco_e1 : "Episode 1 decoration"
+[
+	damage(integer): "damage applied when exploding. Default is 15." : 15
+	scale(float): "Scale of deco. Default 1.0." : 1.0
+	model(string): "choose model # -- see list."
+	mass(float): "*optional* - including this overrides the mass value in decoinfo.txt" 
+	frame(integer): "allows you to specify the starting frame for the model."
+	animseq(integer): "allows you to specify an animation sequence for the model"
+	x_speed(integer): "speed to rotate along x axis in degrees per second"
+	y_speed(integer): "speed to rotate along y axis in degrees per second"
+	z_speed(integer): "speed to rotate along z axis in degrees per second"
+	alpha(float): "range 0.0-1.0. Only used if TRANSLUCENT is flagged"
+	spawnname(string): "classname of entity to throw out upon death"
+    movetype(string): "none, toss, bounce, float, overrides value in e1decoinfo.csv" : "none"
+]
+
+
+//
+// Weapons (Episode 1)
+//
+@PointClass base(Weapons) model({ "path": ":models/e1/a_tazer.dkm" }) = weapon_disruptor : "Disruptor Glove" []
+@PointClass base(Weapons) model({ "path": ":models/e1/a_ion.dkm" }) = weapon_ionblaster : "Ion Blaster - ION blaster thingy" []
+@PointClass base(Weapons) model({ "path": ":models/e1/a_shot.dkm" }) = weapon_shotcycler : "Shotcycler-6" []
+@PointClass base(Weapons) model({ "path": ":models/e1/a_c4.dkm" }) = weapon_c4viz : "C4 Vizatergo" []
+@PointClass base(Weapons) model({ "path": ":models/e1/a_swindr.dkm" }) = weapon_sidewinder : "Sidewinder" []
+@PointClass base(Weapons) model({ "path": ":models/e1/a_shokwv.dkm" }) = weapon_shockwave : "Shockwave" []
+@PointClass base(Weapons) model({ "path": ":models/e1/a_gashand.dkm" }) = weapon_gashands : "Ultimate Gashands" []
+@PointClass base(Weapons) model({ "path": ":models/global/a_daikatana.dkm" }) = weapon_daikatana : "Daikatana" []
+
+
+//
+// Ammo (Episode 1)
+//
+@PointClass base(Ammo) model({ "path": ":models/e1/wa_ion.dkm" }) = ammo_ionpack : "50 ion cells." []
+@PointClass base(Ammo) model({ "path": ":models/e1/wa_c4.dkm" }) = ammo_c4 : "8 C4 Modules." []
+@PointClass base(Ammo) model({ "path": ":models/e1/wa_shot6.dkm" }) = ammo_shells : "24 shotcycler shells." []
+@PointClass base(Ammo) model({ "path": ":models/e1/wa_swindr.dkm" }) = ammo_rockets : "18 rockets." []
+@PointClass base(Ammo) model({ "path": ":models/e1/wa_shokwv.dkm" }) = ammo_shocksphere : "2 ShockSpheres." []

tools/trenchbroom/games/Daikatana/Episode 2.fgd

@@ -0,0 +1,84 @@
+//
+// Daikatana game definition file (.fgd)
+// Episode 2 entities
+// for Trenchbroom
+// last update: 6 Oct, 2018
+// Version: 1
+//
+// written by Dekonega <dekonega(at)windowslive.com>
+// email me with improvements and suggestions
+//
+
+@include "Common.fgd"
+
+
+//
+// Items (Episode 2)
+//
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/a2_ar2.dkm" }) = item_gold_armor : "Gold armor" []
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/a2_ar1.dkm" }) = item_silver_armor : "Silver armor" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/c_runes.dkm" }) = item_rune_s : "Rune S" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/c_runei.dkm" }) = item_rune_i : "Rune I" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/c_runeg.dkm" }) = item_rune_g : "Rune G" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/c_runee.dkm" }) = item_rune_e : "Rune E" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/c_runea.dkm" }) = item_rune_a : "Rune A" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/a2_horn.dkm" }) = item_horn : "Horn" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e2/a2_drachma.dkm" }) = item_drachma : "Drachma" []
+@PointClass base(Appearflags, AntidoteFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/global/a_antidote.dkm" }) = item_antidote : "Cures poisonous wound." []
+
+
+//
+// Monsters (Episode 2)
+//
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-32 -32 -24, 32 32 64) model({ "path": "models/e2/m_cyclops.dkm" }) = monster_cyclops : "Cyclops" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-32 -32 -24, 32 32 40) model({ "path": "models/e2/m_medusa.dkm" }) = monster_medusa : "Medusa" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e2/m_centurion.dkm" }) = monster_centurion : "Centurion" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e2/m_thief.dkm" }) = monster_thief : "Thief" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e2/m_cerberus.dkm" }) = monster_cerberus : "Cerberus" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-24 -24 -24, 24 24 56) model({ "path": "models/e2/m_column.dkm" }) = monster_column : "Column" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 40) model({ "path": "models/e2/m_satyr.dkm" }) = monster_satyr : "Satyr" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 32) model({ "path": "models/e2/m_ferryman.dkm" }) = monster_ferryman : "Ferryman" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 40) model({ "path": "models/e2/m_harpy.dkm" }) = monster_harpy : "Harpy" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-40 -40 -24, 40 40 64) model({ "path": "models/e2/m_griffon.dkm" }) = monster_griffon : "Griffon" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-8 -8 -8, 8 8 8) model({ "path": "models/e2/m_spider.dkm" }) = monster_smallspider : "Small spider" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-32 -32 -8, 32 32 24) model({ "path": "models/e2/m_spider.dkm" }) = monster_spider : "Spider" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e2/m_skeleton.dkm" }) = monster_skeleton : "Skeleton" []
+
+
+//
+// Decorations (Episode 2)
+//
+@PointClass base(Appearflags, DecorationFlags) color(1 0 0) size(-8 -8 -32, 8 8 32) = deco_e2 : "Episode 2 decoration"
+[
+	damage(integer): "damage applied when exploding. Default is 15." : 15
+	scale(float): "Scale of deco. Default 1.0." : 1.0
+	model(string): "choose model # -- see list."
+	mass(float): "*optional* - including this overrides the mass value in decoinfo.txt" 
+	frame(integer): "allows you to specify the starting frame for the model."
+	animseq(integer): "allows you to specify an animation sequence for the model"
+	x_speed(integer): "speed to rotate along x axis in degrees per second"
+	y_speed(integer): "speed to rotate along y axis in degrees per second"
+	z_speed(integer): "speed to rotate along z axis in degrees per second"
+	alpha(float): "range 0.0-1.0. Only used if TRANSLUCENT is flagged"
+	spawnname(string): "classname of entity to throw out upon death"
+    movetype(string): "none, toss, bounce, float, overrides value in e1decoinfo.csv" : "none"
+]
+
+
+//
+// Weapons (Episode 2)
+//
+@PointClass base(Weapons) model({ "path": ":models/e2/a_disk.dkm" }) = weapon_discus : "Discus" []
+@PointClass base(Weapons) model({ "path": ":models/e2/a_venom.dkm" }) = weapon_venomous : "Venomous" []
+@PointClass base(Weapons) model({ "path": ":models/e2/a_sflare.dkm" }) = weapon_sunflare : "Sunflare" []
+@PointClass base(Weapons) model({ "path": ":models/e2/a_hammer.dkm" }) = weapon_hammer : "Hades Hammer" []
+@PointClass base(Weapons) model({ "path": ":models/e2/a_tri.dkm" }) = weapon_trident : "Trident" []
+@PointClass base(Weapons) model({ "path": ":models/e2/a_zeus.dkm" }) = weapon_zeus : "Eye of Zeus" []
+
+
+//
+// Ammo (Episode 2)
+//
+@PointClass base(Ammo) model({ "path": ":models/e2/wa_trident.dkm" }) = ammo_tritips : "30 trident tips." []
+@PointClass base(Ammo) model({ "path": ":models/e2/wa_venom.dkm" }) = ammo_venomous : "25 cobra venom for Venomous." []
+@PointClass base(Ammo) model({ "path": ":models/e2/wa_zeus.dkm" }) = ammo_zeus : "1 mystic eye for Zeus." []

tools/trenchbroom/games/Daikatana/Episode 3.fgd

@@ -0,0 +1,106 @@
+//
+// Daikatana game definition file (.fgd)
+// Episode 3 entities
+// for Trenchbroom
+// last update: 6 Oct, 2018
+// Version: 1
+//
+// written by Dekonega <dekonega(at)windowslive.com>
+// email me with improvements and suggestions
+//
+
+@include "Common.fgd"
+
+
+//
+// Items (Episode 3)
+//
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a3_ar2.dkm" }) = item_black_adamant_armor : "Black adamant armor" []
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a3_ar1.dkm" }) = item_chainmail_armor : "Chainmail armor" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a_tri.dkm" }) = item_trigon_keystone : "Trigon keystone" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a_quad.dkm" }) = item_quad_keystone : "Quad keystone" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a_hex.dkm" }) = item_hex_keystone : "Hex keystone" []
+@PointClass base(Appearflags, Sidekickflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 0, 16 16 40) model({ "path": "models/e3/a3_bookw.dkm" }) = item_spellbook : "E3 Wyndrax spell book" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 0, 16 16 40) model({ "path": "models/e3/a3_ltkey.dkm" }) = item_wyndrax_key : "E3 wyndrax key" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 0, 16 16 40) model({ "path": "models/e3/a3_crkey.dkm" }) = item_crypt_key : "E3 crypt key" []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a_ringlig.dkm" }) = item_ring_of_lightning : "Ring of lightning" []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a_ringund.dkm" }) = item_ring_of_undead : "Ring of undead" []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/a_ring_fire.dkm" }) = item_ring_of_fire : "Ring of fire" []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 0, 16 16 32) model({ "path": "models/e3/a_chest.dkm" }) = item_wood_chest : "Wooden chest" []
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 0, 16 16 32) model({ "path": "models/e3/a_blackchest.dkm" }) = item_black_chest : "Black chest" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_3.dkm" }) = item_purifier_shard3 : "Purifier shard 3" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_2.dkm" }) = item_purifier_shard2_5 : "Purifier shard 2.5" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_2.dkm" }) = item_purifier_shard2_4 : "Purifier shard 2.4" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_2.dkm" }) = item_purifier_shard2_3 : "Purifier shard 2.3" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_2.dkm" }) = item_purifier_shard2_2 : "Purifier shard 2.2" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_2.dkm" }) = item_purifier_shard2_1 : "Purifier shard 2.1" []
+@PointClass base(Appearflags, PurifierShard) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e3/purifier_1.dkm" }) = item_purifier_shard1 : "Purifier shard 1" []
+
+
+//
+// Monsters (Episode 3)
+//
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 36) model({ "path": "models/e3/m_wyndrax.dkm" }) = monster_wyndrax : "Wyndrax" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 40) model({ "path": "models/e3/m_stavros.dkm" }) = monster_stavros : "Stavros" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 36) model({ "path": "models/e3/m_nharre.dkm" }) = monster_nharre : "Nharre" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e3/m_knight2.dkm" }) = monster_knight2 : "Blue Knight" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e3/m_knight1.dkm" }) = monster_knight1 : "Red Knight" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 40) model({ "path": "models/e3/m_gharroth.dkm" }) = monster_garroth : "King Gharroth" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-40 -40 -24, 40 40 96) model({ "path": "models/e3/m_dragon.dkm" }) = monster_dragon : "Dragon" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 16) model({ "path": "models/e3/m_dwarf.dkm" }) = monster_dwarf : "Dwarf" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 40) model({ "path": "models/e3/m_fletcher.dkm" }) = monster_fletcher : "Fletcher" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 32) model({ "path": "models/e3/m_lycanthir.dkm" }) = monster_lycanthir : "Lycanthir" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-12 -12 -8, 12 12 8) model({ "path": "models/e3/m_doombat.dkm" }) = monster_doombat : "Doombat" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 56) model({ "path": "models/e3/m_priest.dkm" }) = monster_priest : "Priest" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e3/m_buboid.dkm" }) = monster_buboid : "Buboid" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-12 -12 -8, 12 12 8) model({ "path": "models/e3/m_rotworm.dkm" }) = monster_rotworm : "Rotworm" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -16, 16 16 8) model({ "path": "models/e3/m_prat.dkm" }) = monster_plague_rat : "Plague Rat - I broke you!" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-8 -8 -8, 8 8 8) model({ "path": "models/global/e_sflblue.sp2" }) = monster_wisp : "Wisp"
+[
+	count(integer): "Number of wisps(Max=10)"
+	distance(integer): "How far the wisps will fly from point of placement(Max=200)"
+	velocity(integer): "How fast the wisps will move(Max=200)"
+	scale(float): "How big the wisps will be(1 = normal, 0.5 = half, 2 = twice as big)"
+	delta_alpha(integer): "frequency of Alpha blending change(0-100%) where 0% means no change"
+	alpha_level(integer): "Initial Setting for Alpha blending change(1-100%)"
+]
+
+
+//
+// Decorations (Episode 3)
+//
+@PointClass base(Appearflags, DecorationFlags) color(1 0 0) size(-8 -8 -32, 8 8 32) = deco_e3 : "Episode 3 decoration"
+[
+	damage(integer): "damage applied when exploding. Default is 15." : 15
+	scale(float): "Scale of deco. Default 1.0." : 1.0
+	model(string): "choose model # -- see list."
+	mass(float): "*optional* - including this overrides the mass value in decoinfo.txt" 
+	frame(integer): "allows you to specify the starting frame for the model."
+	animseq(integer): "allows you to specify an animation sequence for the model"
+	x_speed(integer): "speed to rotate along x axis in degrees per second"
+	y_speed(integer): "speed to rotate along y axis in degrees per second"
+	z_speed(integer): "speed to rotate along z axis in degrees per second"
+	alpha(float): "range 0.0-1.0. Only used if TRANSLUCENT is flagged"
+	spawnname(string): "classname of entity to throw out upon death"
+    movetype(string): "none, toss, bounce, float, overrides value in e1decoinfo.csv" : "none"
+]
+
+
+//
+// Weapons (Episode 3)
+//
+@PointClass base(Weapons) model({ "path": ":models/e3/a_claw.dkm" }) = weapon_silverclaw : "Silverclaw" []
+@PointClass base(Weapons) model({ "path": ":models/e3/a_bolter.dkm" }) = weapon_bolter : "Bolter" []
+@PointClass base(Weapons) model({ "path": ":models/e3/a_bal.dkm" }) = weapon_ballista : "Ballista" []
+@PointClass base(Weapons) model({ "path": ":models/e3/a_stav.dkm" }) = weapon_stavros : "Stave of Stavros" []
+@PointClass base(Weapons) model({ "path": ":models/e3/a_wyndrx.dkm" }) = weapon_wyndrax : "Wyndrax's Wisp" []
+@PointClass base(Weapons) model({ "path": ":models/e3/a_nmare.dkm" }) = weapon_nightmare : "Nharre's Nightmare" []
+
+
+//
+// Ammo (Episode 3)
+//
+@PointClass base(Ammo) model({ "path": ":models/e3/wa_bolt.dkm" }) = ammo_bolts : "50 crossbow bolts." []
+@PointClass base(Ammo) model({ "path": ":models/e3/wa_stav.dkm" }) = ammo_stavros : "2 lava rocks." []
+@PointClass base(Ammo) model({ "path": ":models/e3/wa_bal.dkm" }) = ammo_ballista : "10 Ballista logs." []
+@PointClass base(Ammo) model({ "path": ":models/e3/we_wisp.dkm" }) = ammo_wisp : "Wyndrax ammo." []

tools/trenchbroom/games/Daikatana/Episode 4.fgd

@@ -0,0 +1,86 @@
+//
+// Daikatana game definition file (.fgd)
+// Episode 4 entities
+// for Trenchbroom
+// last update: 6 Oct, 2018
+// Version: 1
+//
+// written by Dekonega <dekonega(at)windowslive.com>
+// email me with improvements and suggestions
+//
+
+@include "Common.fgd"
+
+
+//
+// Items (Episode 4)
+//
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e4/a4_ar2.dkm" }) = item_ebonite_armor : "Ebonite armor" []
+@PointClass base(Appearflags, Sidekickflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e4/a4_ar1.dkm" }) = item_kevlar_armor : "Kevlar armor" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e4/a4_clcgr.dkm" }) = item_control_card_green : "Green control card" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e4/a4_clcyl.dkm" }) = item_control_card_yellow : "Yellow control card" []
+@PointClass base(Appearflags, KeyFlags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e4/a4_clcbl.dkm" }) = item_control_card_blue : "Blue control card" []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -24, 16 16 8) model({ "path": "models/e4/a_saltp.dkm" }) = item_saltpeter : "Saltpeter for e4m1 explosives." []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -24, 16 16 8) model({ "path": "models/e4/a_charcoal.dkm" }) = item_charcoal : "Charcoal for e4m1 explosives." []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -24, 16 16 8) model({ "path": "models/e4/a_sulphur.dkm" }) = item_sulphur : "Sulphur pouch for e4m1 explosives." []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -24, 16 16 8) model({ "path": "models/e4/a_bottle.dkm" }) = item_bottle : "Bottle for e4m1 explosives." []
+@PointClass base(Appearflags) color(0 0.5 0.8) size(-16 -16 -16, 16 16 16) model({ "path": "models/e4/a_envsuit.dkm" }) = item_envirosuit : "60 seconds of air and protection from harmful liquids." []
+
+
+//
+// Monsters (Episode 4)
+//
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_kage.dkm" }) = monster_kage : "Kage Mishima" []
+@PointClass base(AppearFlags, MonsterFlags) color(1 0.5 0) size(-16 -16 -8, 16 16 16) model({ "path": "models/e4/m_shark.dkm" }) = monster_shark : "Shark" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_rocketmp.dkm" }) = monster_rocketmp : "Rocket MP" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_sgirl.dkm" }) = monster_sealgirl : "SEAL Girl" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_sealcap.dkm" }) = monster_sealcaptain : "SEAL Captain" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_scomndo.dkm" }) = monster_sealcommando : "SEAL Commando" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-24 -24 -24, 24 24 24) model({ "path": "models/e4/m_labmonkey.dkm" }) = monster_labmonkey : "Lab Monkey" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_uzi.dkm" }) = monster_uzigang : "Uzi Gang Member" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-20 -20 -24, 20 20 32) model({ "path": "models/e4/m_chgang.dkm" }) = monster_chaingang : "Chaingun Gang Member" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_rockgang.dkm" }) = monster_rocketdude : "Rocket Dude" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 32) model({ "path": "models/e4/m_femgang.dkm" }) = monster_femgang : "Female Gang Member" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 40) model({ "path": "models/e4/m_wpris.dkm" }) = monster_whiteprisoner : "White prisoner" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-16 -16 -24, 16 16 40) model({ "path": "models/e4/m_bpris.dkm" }) = monster_blackprisoner : "Black prisoner" []
+@PointClass base(Appearflags, MonsterFlags) color(1 0.5 0) size(-8 -8 -16, 8 8 8) model({ "path": "models/e4/m_piperat.dkm" }) = monster_piperat : "Pipe rat - I broke you!" []
+
+
+//
+// Decorations (Episode 4)
+//
+@PointClass base(Appearflags, DecorationFlags) color(1 0 0) size(-8 -8 -32, 8 8 32) = deco_e4 : "Episode 4 decoration"
+[
+	damage(integer): "damage applied when exploding. Default is 15." : 15
+	scale(float): "Scale of deco. Default 1.0." : 1.0
+	model(string): "choose model # -- see list."
+	mass(float): "*optional* - including this overrides the mass value in decoinfo.txt" 
+	frame(integer): "allows you to specify the starting frame for the model."
+	animseq(integer): "allows you to specify an animation sequence for the model"
+	x_speed(integer): "speed to rotate along x axis in degrees per second"
+	y_speed(integer): "speed to rotate along y axis in degrees per second"
+	z_speed(integer): "speed to rotate along z axis in degrees per second"
+	alpha(float): "range 0.0-1.0. Only used if TRANSLUCENT is flagged"
+	spawnname(string): "classname of entity to throw out upon death"
+    movetype(string): "none, toss, bounce, float, overrides value in e1decoinfo.csv" : "none"
+]
+
+//
+// Weapons (Episode 4)
+//
+@PointClass base(Weapons) model({ "path": ":models/e4/a_glock.dkm" }) = weapon_glock : "Glock - Glock Pistol of Love"[]
+@PointClass base(Weapons) model({ "path": ":models/e4/a_slugger.dkm" }) = weapon_slugger : "Slugger" []
+@PointClass base(Weapons) model({ "path": ":models/e4/a_kcore.dkm" }) = weapon_kineticore : "Kineticore" []
+@PointClass base(Weapons) model({ "path": ":models/e4/a_ripgun.dkm" }) = weapon_ripgun : "Ripgun - Pulse Rifle" []
+@PointClass base(Weapons) model({ "path": ":models/e4/a_nova.dkm" }) = weapon_novabeam : "Novabeam" []
+@PointClass base(Weapons) model({ "path": ":models/e4/a_mmaser.dkm" }) = weapon_metamaser : "Metamaser" []
+
+//
+// Ammo (Episode 4)
+//
+@PointClass base(Ammo) model({ "path": ":models/e4/wa_glock.dkm" }) = ammo_bullets : "A loaded magazine for the glock." []
+@PointClass base(Ammo) model({ "path": ":models/e4/wa_rip.dkm" }) = ammo_slugger : "15 slugs." []
+@PointClass base(Ammo) model({ "path": ":models/e4/wa_rip2.dkm" }) = ammo_cordite : "4 cordite grenades." []
+@PointClass base(Ammo) model({ "path": ":models/e4/wa_kcore.dkm" }) = ammo_kineticore : "50 freeze things." []
+@PointClass base(Ammo) model({ "path": ":models/e4/wa_slug.dkm" }) = ammo_ripgun : "50 Rip-Ups (tm)." []
+@PointClass base(Ammo) model({ "path": ":models/e4/wa_nova.dkm" }) = ammo_novabeam : "50 nova cell units." []

tools/trenchbroom/games/Daikatana/GameConfig.cfg

@@ -0,0 +1,332 @@
+{
+    "version": 9,
+    "name": "Daikatana",
+    "icon": "Icon.png",
+    "fileformats": [ { "format": "Daikatana" } ],
+    "filesystem": {
+        "searchpath": "data",
+        "packageformat": { "extension": ".pak", "format": "dkpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [".wal"]
+    },
+    "entities": {
+        "definitions": [ "Episode 1.fgd", "Episode 2.fgd", "Episode 3.fgd", "Episode 4.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [
+            {
+                "name": "Weather",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "effect*"
+            },
+            {
+                "name": "Trigger",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "trigger*",
+                "material": "trigger"
+            }
+        ],
+        "brushface": [
+            {
+                "name": "Clip",
+                "attribs": [ "transparent" ],
+                "match": "contentflag",
+                "flags": [ "playerclip", "monsterclip", "NPC clip" ]
+            },
+            {
+                "name": "Skip",
+                "attribs": [ "transparent" ],
+                "match": "surfaceflag",
+                "flags": [ "skip" ]
+            },
+            {
+                "name": "Hint",
+                "attribs": [ "transparent" ],
+                "match": "surfaceflag",
+                "flags": [ "hint" ]
+            },
+            {
+                "name": "Detail",
+                "match": "contentflag",
+                "flags": [ "detail" ]
+            },
+            {
+                "name": "Liquid",
+                "match": "contentflag",
+                "flags": [ "lava", "slime", "water" ]
+            },
+            {
+                "name": "Sound",
+                "match": "surfaceflag",
+                "flags": [ "wood", "metal", "stone", "glass", "ice", "snow", "puddle", "sand" ]
+            }
+        ]
+    },
+    "faceattribs": {
+        "surfaceflags": [
+            {
+                "name": "light",
+                "description": "1 - Emit light from the surface, brightness is specified in the 'value' field"
+            }, // 1
+            {
+                "name": "fullbright",
+                "description": "2 - Fullbright"
+            }, // 2
+            {
+                "name": "sky",
+                "description": "4 - The surface is sky, the texture will not be drawn, but the background sky box is used instead"
+            }, // 4
+            {
+                "name": "warp",
+                "description": "8 - The surface warps (like water textures do)"
+            }, // 8
+            {
+                "name": "trans33",
+                "description": "16 - The surface is 33% transparent"
+            }, // 16
+            {
+                "name": "trans66",
+                "description": "32 - The surface is 66% transparent"
+            }, // 32
+            {
+                "name": "flowing",
+                "description": "64 - The texture wraps in a downward 'flowing' pattern (warp must also be set)"
+            }, // 64
+            {
+                "name": "nodraw",
+                "description": "128 - Used for non-fixed-size brush triggers and clip brushes"
+            }, // 128
+            {
+                "name": "hint",
+                "description": "256 - Hint"
+            }, // 256
+            {
+                "name": "skip",
+                "description": "512 - Skip"
+            }, // 512
+            {
+                "name": "wood",
+                "description": "1024 - Wood"
+            }, // 1024
+            {
+                "name": "metal",
+                "description": "2048 - Metal"
+            }, // 2048
+            {
+                "name": "stone",
+                "description": "4096 - Stone"
+            }, // 4096
+            {
+                "name": "glass",
+                "description": "8192 - Glass"
+            }, // 8192
+            {
+                "name": "ice",
+                "description": "16384 - Ice"
+            }, // 16384
+            {
+                "name": "snow",
+                "description": "32768 - Snow"
+            }, // 32768
+            {
+                "name": "mirror",
+                "description": "65536 - Mirror"
+            }, // 65536
+            {
+                "name": "holy ground",
+                "description": "131072 - Holy Grond"
+            }, // 131072
+            {
+                "name": "alphachan",
+                "description": "262144 - Alphachan"
+            }, // 262144
+            {
+                "name": "midtexture",
+                "description": "524288 - Midtexture (Used together with Clear and Nodraw.)"
+            }, // 524288
+            {
+                "name": "puddle",
+                "description": "1048576 - Puddle"
+            }, // 1048576
+            {
+                "name": "water surge",
+                "description": "2097152 - Water Surge"
+            }, // 2097152
+            {
+                "name": "big water surge",
+                "description": "4194304 - Big Water Surge"
+            }, // 4194304
+            {
+                "name": "bullet light",
+                "description": "8388608 - Bullet Light"
+            }, // 8388608
+            {
+                "name": "fog",
+                "description": "16777216 - Fog"
+            }, // 16777216
+            {
+                "name": "sand",
+                "description": "33554432 - Sand"
+            }, // 33554432
+            {
+                "name": "4000000",
+                "description": "67108864 - 4000000"
+            }, // 67108864
+            {
+                "name": "8000000",
+                "description": "134217728 - 8000000"
+            }, // 134217728
+            {
+                "name": "10000000",
+                "description": "268435456 - 10000000"
+            }, // 268435456
+            {
+                "name": "20000000",
+                "description": "536870912 - 20000000"
+            }, // 536870912
+            {
+                "name": "40000000",
+                "description": "1073741824 - 40000000"
+            }, // 1073741824
+            {
+                "name": "80000000",
+                "description": "-2147483648 - 80000000 (Yes, this is a negative value)"
+            } // 2147483648
+        ],
+        "contentflags": [
+            {
+                "name": "solid",
+                "description": "1 - Default for all brushes"
+            }, // 1
+            {
+                "name": "window",
+                "description": "2 - Brush is a window (not really used)"
+            }, // 2
+            {
+                "name": "aux",
+                "description": "4 - Unused by the Dk's engine?"
+            }, // 4
+            {
+                "name": "lava",
+                "description": "8 - The brush is lava"
+            }, // 8
+            {
+                "name": "slime",
+                "description": "16 - The brush is slime"
+            }, // 16
+            {
+                "name": "water",
+                "description": "32 - The brush is water"
+            }, // 32
+            {
+                "name": "mist",
+                "description": "64 - The brush is non-solid"
+            }, // 64
+            {
+                "name": "clear",
+                "description": "128 - clear"
+            }, // 128
+            {
+                "name": "notsolid",
+                "description": "256 - notsolid"
+            }, // 256
+            {
+                "name": "noshoot",
+                "description": "512 - noshoot"
+            }, // 512
+            {
+                "name": "fog",
+                "description": "1024 - fog"
+            }, // 1024
+            {
+                "name": "nitro",
+                "description": "2048 - nitro"
+            }, // 2048
+            {
+                "name": "1000",
+                "description": "4096 - 1000"
+            }, // 4096
+            {
+                "name": "2000",
+                "description": "8192 - 2000"
+            }, // 8192
+            {
+                "name": "4000",
+                "description": "16384 - 4000"
+            }, // 16384
+            {
+                "name": "8000",
+                "description": "32768 - 8000"
+            }, // 32768
+            {
+                "name": "playerclip",
+                "description": "65536 - Player cannot pass through the brush (other things can)"
+            }, // 65536
+            {
+                "name": "monsterclip",
+                "description": "131072 - Monster cannot pass through the brush (player and other things can)"
+            }, // 131072
+            {
+                "name": "current_0",
+                "description": "262144 - Brush has a current in direction of 0 degrees"
+            }, // 262144
+            {
+                "name": "current_90",
+                "description": "524288 - Brush has a current in direction of 90 degrees"
+            }, // 524288
+            {
+                "name": "current_180",
+                "description": "1048576 - Brush has a current in direction of 180 degrees"
+            }, // 1048576
+            {
+                "name": "current_270",
+                "description": "2097152 - Brush has a current in direction of 270 degrees"
+            }, // 2097152
+            {
+                "name": "current_up",
+                "description": "4194304 - Brush has a current in the up direction"
+            }, // 4194304
+            {
+                "name": "current_dn",
+                "description": "8388608 - Brush has a current in the down direction"
+            }, // 8388608
+            {
+                "name": "origin",
+                "description": "16777216 - Special brush used for specifying origin of rotation for rotating brushes"
+            }, // 16777216
+            {
+                "name": "monster",
+                "description": "33554432 - Purpose unknown"
+            }, // 33554432
+            {
+                "name": "corpse",
+                "description": "67108864 - Purpose unknown"
+            }, // 67108864
+            {
+                "name": "detail",
+                "description": "134217728 - Detail"
+            }, // 134217728
+            {
+                "name": "translucent",
+                "description": "268435456 - Use for opaque water that does not block vis"
+            }, // 268435456
+            {
+                "name": "ladder",
+                "description": "536870912 - Brushes with this flag allow a player to move up and down a vertical surface"
+            }, // 536870912
+            {
+                "name": "NPC clip",
+                "description": "1073741824"
+            }, // 1073741824
+            {
+                "name": "80000000",
+                "description": "-2147483648 - (Yes, this is a negative value)"
+            } // 2147483648
+        ]
+    }
+}

tools/trenchbroom/games/Deathwish/Deathwish.fgd

@@ -0,0 +1,8 @@
+@SolidClass = worldspawn : "World entity" []
+
+@baseclass size(-16 -16 -24, 16 16 32) color(0 255 0) = PlayerClass []
+
+@PointClass base(PlayerClass) = info_player_start : "Player 1 start" []
+
+@PointClass base(PlayerClass) = enemy_spawn : "Enemy Spawn position" []
+

tools/trenchbroom/games/Deathwish/GameConfig.cfg

@@ -0,0 +1,34 @@
+{
+    version: 9,
+    name: "Deathwish",
+    icon: "Icon.png",
+    "fileformats": [
+        { "format": "Standard", "initialmap": "initial_standard.map" },
+        { "format": "Valve", "initialmap": "initial_valve.map" },
+        { "format": "Quake2", "initialmap": "initial_quake2.map" }
+    ],
+    "filesystem": {
+        "searchpath": ".",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "format": { "extensions": [".png"], "format": "image" }
+    },
+    "entities": {
+        "definitions": [ "Deathwish.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [],
+        "brushface": []
+    },
+    "faceattribs": {
+        "surfaceflags": [],
+        "contentflags": [],
+        "defaults": {
+            "scale": [0.25, 0.25]
+        }
+    }
+}
+

tools/trenchbroom/games/DigitalPaintball2/GameConfig.cfg

@@ -0,0 +1,232 @@
+{
+    "version": 9,
+    "name": "Digital Paint: Paintball 2",
+    "icon": "Icon.png",
+    "fileformats": [
+        { "format": "Quake2" },
+        { "format": "Quake2 (Valve)"}
+    ],
+    "filesystem": {
+        "searchpath": "pball",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [ ".wal", ".jpg", ".png", ".tga" ],
+        "palette": "pics/colormap.pcx"
+    },
+    "entities": {
+        "definitions": [ "pball2.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [
+            {
+                "name": "test2",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "trigger*",
+                "material": "trigger"
+            }
+        ],
+        "brushface": [
+            {
+                "name": "Trigger",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "trigger"
+            },
+            {
+                "name": "Clip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "clip"
+            },
+            {
+                "name": "Skip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "skip"
+            },
+            {
+                "name": "Hint",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "hint*"
+            },
+                        {
+                "name": "glass",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "*glass*"
+            },
+            {
+                "name": "window",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "*window*"
+            },
+            {
+                "name": "trans",
+                "attribs": [ "transparent" ],
+                "match": "surfaceflag",
+                "flags": [ "trans33", "trans66" ]
+            },
+            {
+                "name": "Detail",
+                "match": "contentflag",
+                "flags": [ "detail" ]
+            },
+            {
+                "name": "Liquid",
+                "match": "contentflag",
+                "flags": [ "lava", "slime", "water" ]
+            },
+            {
+              "name": "nodraw",
+              "attribs": [ "transparent" ],
+              "match": "material",
+              "pattern": "hint*"
+            }
+        ]
+    },
+    "faceattribs": {
+        "surfaceflags": [
+            {
+                "name": "light",
+                "description": "Emit light from the surface, brightness is specified in the 'value' field"
+            },
+            {
+                "name": "slick",
+                "description": "The surface is slippery"
+            },
+            {
+                "name": "sky",
+                "description": "The surface is sky, the texture will not be drawn, but the background sky box is used instead"
+            },
+            {
+                "name": "warp",
+                "description": "The surface warps (like water textures do)"
+            },
+            {
+                "name": "trans33",
+                "description": "The surface is 33% transparent"
+            },
+            {
+                "name": "trans66",
+                "description": "The surface is 66% transparent"
+            },
+            {
+                "name": "flowing",
+                "description": "The texture wraps in a downward 'flowing' pattern (warp must also be set)"
+            },
+            {
+                "name": "nodraw",
+                "description": "Used for non-fixed-size brush triggers and clip brushes"
+            },
+            {
+                "name": "hint",
+                "description": "Make a primary bsp splitter"
+            },
+            {
+                "name": "skip",
+                "description": "Completely ignore, allowing non-closed brushes"
+            }
+        ],
+        "contentflags": [
+            {
+                "name": "solid",
+                "description": "Default for all brushes"
+            }, // 1 << 0
+            {
+                "name": "window",
+                "description": "Brush is a window (not really used)"
+            }, // 1 << 1
+            {
+                "name": "aux",
+                "description": "Unused by the engine"
+            }, // 1 << 2
+            {
+                "name": "lava",
+                "description": "The brush is lava"
+            }, // 1 << 3
+            {
+                "name": "slime",
+                "description": "The brush is slime"
+            }, // 1 << 4
+            {
+                "name": "water",
+                "description": "The brush is water"
+            }, // 1 << 5
+            {
+                "name": "mist",
+                "description": "The brush is non-solid"
+            }, // 1 << 6
+            { "unused": true }, // 1 << 7
+            { "unused": true }, // 1 << 8
+            { "unused": true }, // 1 << 9
+            { "unused": true }, // 1 << 10
+            { "unused": true }, // 1 << 11
+            { "unused": true }, // 1 << 12
+            { "unused": true }, // 1 << 13
+            { "unused": true }, // 1 << 14
+            { "unused": true }, // 1 << 15
+            {
+                "name": "playerclip",
+                "description": "Player cannot pass through the brush (other things can)"
+            }, // 1 << 16
+            {
+                "name": "monsterclip",
+                "description": "Monster cannot pass through the brush (player and other things can)"
+            }, // 1 << 17
+            {
+                "name": "current_0",
+                "description": "Brush has a current in direction of 0 degrees"
+            }, // 1 << 18
+            {
+                "name": "current_90",
+                "description": "Brush has a current in direction of 90 degrees"
+            }, // 1 << 19
+            {
+                "name": "current_180",
+                "description": "Brush has a current in direction of 180 degrees"
+            }, // 1 << 20
+            {
+                "name": "current_270",
+                "description": "Brush has a current in direction of 270 degrees"
+            }, // 1 << 21
+            {
+                "name": "current_up",
+                "description": "Brush has a current in the up direction"
+            }, // 1 << 22
+            {
+                "name": "current_dn",
+                "description": "Brush has a current in the down direction"
+            }, // 1 << 23
+            {
+                "name": "origin",
+                "description": "Special brush used for specifying origin of rotation for rotating brushes"
+            }, // 1 << 24
+            {
+                "name": "monster",
+                "description": "Purpose unknown"
+            }, // 1 << 25
+            {
+                "name": "corpse",
+                "description": "Purpose unknown"
+            }, // 1 << 26
+            {
+                "name": "detail",
+                "description": "Detail brush"
+            }, // 1 << 27
+            {
+                "name": "translucent",
+                "description": "Use for opaque water that does not block vis"
+            }, // 1 << 28
+            {
+                "name": "ladder",
+                "description": "Brushes with this flag allow a player to move up and down a vertical surface"
+            } // 1 << 29
+        ]
+    }
+}

tools/trenchbroom/games/DigitalPaintball2/pball2.fgd

@@ -0,0 +1,805 @@
+// Paintball2 Entities - http://www.digitalpaint.org/
+// Ported from pb2ents_b41.c by sort 3/18/2019
+// Merged with original pball2.fgd and added spawnflags. 3/23/2019
+// TB addon changes 20190403 - xaGe
+
+@baseclass = AppearFlags [
+	spawnflags(Flags) =
+	[
+		256 : "Not in Easy" : 0
+		512 : "Not in Normal" : 0
+		1024 : "Not in Hard" : 0
+		2048 : "Not in Deathmatch" : 0
+	]
+]
+
+@BaseClass = Target
+[
+    target(string) : "sets the target to a func_areaportal or target_speaker with the same targetname"
+]
+@BaseClass = TargetName
+[
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target"
+]
+@BaseClass = TeamNumber
+[
+    teamnumber(integer) : "sets the team for the base."
+]
+@BaseClass = Angle
+[
+    angle(string) : "sets the direction the entity faces when spawning.  0 = right (East), 90 = up (North), 180 = left (West), 270 = down (South)."
+]
+@BaseClass base(AppearFlags) = Group
+[
+    group(string) : "sets a group where randomly spawned guns will be the same"
+]
+
+@SolidClass = worldspawn : "World entity"
+[
+	gamemode(Flags) =
+	[
+		1 : "Deathmatch" : 0
+		2 : "Single flag CTF" : 0
+		4 : "CTF" : 0
+		8 : "Siege" : 0
+		16 : "KOTH" : 0
+		64 : "Pong" : 0
+	]
+	maxteams(choices) : "sets the max number of teams supported in the map" =
+	[
+        2 : "for two teams"
+        3 : "for three teams"
+        4 : "for four teams"
+	]
+	team1(choices) : "sets the color for team 1." =
+	[
+        "red" : "red"
+        "blue" : "blue"
+        "yellow" : "yellow"
+        "purple" : "purple"
+	]
+	team2(choices) : "sets the color for team 2." =
+	[
+        "red" : "red"
+        "blue" : "blue"
+        "yellow" : "yellow"
+        "purple" : "purple"
+	]
+	team3(choices) : "sets the color for team 3." =
+	[
+        "red" : "red"
+        "blue" : "blue"
+        "yellow" : "yellow"
+        "purple" : "purple"
+	]
+	team4(choices) : "sets the color for team 4." =
+	[
+        "red" : "red"
+        "blue" : "blue"
+        "yellow" : "yellow"
+        "purple" : "purple"
+	]
+		message(string) : "sets a string while the map is loading."
+		sky(string) : "sets a sky to your sky brushes - <skyname> can be one of the following: unit1_, pbsky1, pbsky2, pbsky3, pbsky4, riverscape1, arctic1"
+    _sun_light(integer) : "arghrad - example: 250"
+    _sun_surface(integer) : "arghrad - brightness - A single brightness level. The color of the light is derived from the colors of all active suns, or the texture color if no suns are enabled. A value of 1 is special: it makes ArghRad use the surface`s own light value."
+    //_sun_surface(color255) : "arghrad - red green blue - Three separate brightness values for red, green, and blue lighting (normally not a standard RGB color). If all three values are 1 or less it has special meaning: it is treated like an RGB color:and the surface`s own light value is used."
+		_sun_color(string)	:	"arghrad - Sets the color of the sunlight to the specified rgb color value. If _sun_color is not specified, the color of the sky surface textures will be used instead."
+		_sun_diffuse(integer)	:	"arghrad - Sets the brightness of the diffused sunlight. This simulates the diffusion of light by atmospheric haze, creating a soft glow around the edges of sunlight shadows."
+		_sun_diffade(integer)	:	"arghrad - Scales how quickly the diffuse sunlight fades out over distance. The default distance is about 64 units. Values less than 1 fade slower, increasing the distance. Values greater than 1 fade faster, decreasing the distance. For example: a value of .5 fades half as fast, covering twice the distance, or about 128 units."
+
+// Worldspawn Sun Aiming
+// Like spotlights, there are several different methods available for setting the direction of suns in the Worldspawn. Choose any one of the methods that you prefer. Remember these point in the direction the sunlight is cast, not towards the sun. All suns points straight down by default.
+    _sun_angle(string) : "arghrad - Sets the sunlight direction by yaw and pitch angles. Yaw goes from 0-360 degrees around the z-axis, like the angle key. Pitch goes from -90 straight down, through 0 horizontal, to 90 straight up. def=0 -90"
+		_sun_target(string)	: "arghrad - targetname: targetname of spotlight`s info_null. Sets the sunlight direction with separate light & info_null entities. Create and aim a spotlight using the traditional qrad3 info_null method. Then set the _sun_target value to the same targetname as the info_null. The sun will now point in the same direction as that spotlight."
+		_sun_vector(string)	:	"arghrad - Sets the sunlight direction by direction vector. This is the direction defined by a ray pointing from the origin (0 0 0) to the specified x y z value."
+
+		requiredfiles(string) : "sets paths for additional files required by the map (such as scripts) that do not download by default - <path> is the path to your file. Always use the forward slash. Keep filenames lowercase. Separate different pathes with a space.Example: 'requiredfiles' 'scripts/maps/mymap1.txt scripts/maps/mymap2.txt' for two of your own files"
+    forcejail(choices) : "forces eliminated players into jail spawns (no observer/ghosts)." =
+    [
+        0 : "no force jail"
+        1 : "force jail"
+    ]
+    minclientbuild(integer) : "sets the minimum version a client must have to play the map (useful if you use advanced features)"
+    _ambient(integer) : "sets a general map ambient."
+
+]
+
+@SolidClass base(AppearFlags) = trigger_multiple : "Variable sized repeatable trigger.  Must be targeted at one or more entities."
+[
+	spawnflags(Flags) =
+	[
+		1 : "Monster" : 0
+		2 : "Not Player" : 0
+		4 : "Triggered" : 0
+	]
+    target(target_destination) : "sets the target to any other entities with the same targetname"
+    message(string) : "sets a string to be displayed when triggered"
+    delay(integer) : "sets a delay before first firing when turned on (0 default)."
+    wait(integer) : "sets the seconds between triggerings (2 default)."
+    sounds(choices) : "sets a sound to be played when triggered" =
+    [
+        1 : "secret"
+        2 : "beep beep"
+        3 : "large switch"
+    ]
+]
+
+@SolidClass base(AppearFlags, TeamNumber) = base : "Base trigger.  A player must touch this while holding the flag to get points."
+[
+    count(integer) : "sets a multiplier for the points scored when capturing. Default is 5, so if you want a flag captured at this base to only be worth 1 point, you can set 'count' '.2'"
+]
+
+@SolidClass base(AppearFlags) = hill : "Hill for gamemode KOTH.  When a player touches the hill, their team gets points. A flag with no teamnumber is also suggested, so that it's easy to tell if somebody is on the hill (players can also get points by touching the flag itself)."
+[
+    gamemode(integer) : "sets the gamemode (KOTH only, should always be 16)."
+]
+
+@SolidClass base(AppearFlags, TeamNumber) = func_teamwall : "Wall that exists only when the team has no players." []
+
+@SolidClass base(AppearFlags) = func_dsm : "Dynamically Sizing Map entity.  Apply this to brushes to seal off/open areas depending on the number of players present."
+[
+	spawnflags(Flags) =
+	[
+		1 : "invert_behavior" : 0 : "closes off areas instead of open up when more players are present."
+	]
+    open_pcount_all(integer) : "if # or more players are in the game, the entity will disappear, opening a new path."
+    close_pcount_all(integer) : "if # or fewer players are present, the entity will reappear and close off the path."
+]
+
+@baseclass base(AppearFlags, TargetName) size(-16 -16 -24, 16 16 32) color(0 255 0) = PlayerClass []
+
+@PointClass base(PlayerClass) = info_player_deathmatch : "Player deathmatch start"
+[
+    teamnumber(integer) : "sets which team's players will spawn at this point.  Setting to 0 means any team can spawn here."
+    givegun(choices) : "sets the type of the weapon the player starts with instead of the pgp" =
+    [
+        "trracer" : "for spawning a Trracer"
+        "stingray" : "for spawning a Stingray"
+        "vm68" : "for spawning a VM-68"
+        "carbine" : "for spawning a 68 Carbine"
+        "spyder" : "for spawning a Spyder SE"
+        "autococker" : "for spawning an Autococker"
+        "automag" : "for spawning an Automag"
+        "low" : "for randomly spawning a Trracer or Stingray"
+        "medium" : "for randomly spawning a VM-68, 68 Carbine or Spyder SE"
+        "high" : "for randomly spawning an Autococker or Automag"
+    ]
+    givehopper(choices) : "sets the type of the hopper the player starts with" =
+    [
+        100 : "for spawning a hopper of 100"
+        200 : "for spawning a hopper of 200"
+    ]
+    giveammo(choices) : "sets the type of the ammo pack the player starts with" =
+    [
+        "25" : "for spawning an ammo pack of 25"
+        "50" : "for spawning an ammo pack of 50"
+        "100" : "for spawning an ammo pack of 100"
+        "150" : "for spawning an ammo pack of 150"
+        "200" : "for spawning an ammo pack of 200"
+        "small" : "for randomly spawning an ammo pack of 25, 50 or 100"
+        "medium" : "for randomly spawning an ammo pack of 50, 100 or 150"
+        "large" : "for randomly spawning an ammo pack of 100, 150 or 200"
+    ]
+    givebarrel(choices) : "sets the type of the barrel the player starts with" =
+    [
+        "brass" : "for a brass barrel"
+        "chrome" : "for a chrome barrel"
+        "steel" : "for a steel barrel"
+    ]
+    giveco2(choices) : "sets the type of the co2 tank the player starts with" =
+    [
+        "12g" : "for spawning a co2 tank of 12g"
+        "7oz" : "for spawning a co2 tank of 7oz"
+        "12oz" : "for spawning a co2 tank of 12oz"
+        "20oz" : "for spawning a co2 tank of 20oz"
+        "small" : "for randomly spawning a co2 tank of 12g or 7oz"
+        "medium" : "for randomly spawning a co2 tank of 7oz or 12oz"
+        "large" : "for randomly spawning a co2 tank of 12oz or 20oz"
+    ]
+    loadedco2(choices) : "sets the type of the loaded co2 the player starts with" =
+    [
+        "12g" : "for spawning a co2 tank of 12g"
+        "7oz" : "for spawning a co2 tank of 7oz"
+        "12oz" : "for spawning a co2 tank of 12oz"
+        "20oz" : "for spawning a co2 tank of 20oz"
+        "small" : "for randomly spawning a co2 tank of 12g or 7oz"
+        "medium" : "for randomly spawning a co2 tank of 7oz or 12oz"
+        "large" : "for randomly spawning a co2 tank of 12oz or 20oz"
+    ]
+    jail(integer) : "set to 1 to make it a jail spawn for eliminated players."
+]
+@PointClass base(AppearFlags, Angle) size(-8 -8 -8, 8 8 8) studio({ "path" : model, "skin" : skin, "frame" : frame}) = func_model : "Places a model in the map.  Not affected by gravity.Example: 'model' 'models/items/ammo/tris.md2' for the plant model seen in several maps (Pay attention of additional files required by the model.)  Add 'requiredfiles' '<path>' to the worldspawn if necessary."
+[
+    model(string) : "sets what model to use - <modelpath> `models/items/ammo/tris.md2` can be the path of available or your added models"
+    //skin(string) : "sets what skin # to use - example `3` skin selection defaults to `0` of available or your added models"
+    //frame(string) : "sets what frame # to use - example `2` can be the frame of available or your added models"
+]
+
+@PointClass base(Group) size(-8 -8 6, 8 8 26) studio({{
+type == "paint" -> 	{"path":"models/items/grenades/paint/ground.md2", "skin": 0},
+type == "smoke" -> 	{"path":"models/items/grenades/smoke/ground.md2", "skin": 0},
+                        "models/items/grenades/paint/ground.md2"
+}}) = item_pballgrenade : "Spawning spot for grenades. If no type is specified, the grenade will be random."
+[
+    type(choices) : "set the type of the grenade" =
+    [
+        "paint" : "for a paint grenade"
+        "smoke" : "for a smoke grenade"
+    ]
+    angle(string) : "-1 sets that the grenade will spawn exactly where you placed the entity and not somewhere in the area."
+    count(integer) : "1 sets that grenades always spawn there in addition to the number of grenades set by the server."
+]
+
+// xaGe
+@PointClass base(Group) color(80 80 255) size(-32 -32 -4, 32 32 28) studio({{
+type == "autococker" -> 	{"path":"models/weapons/g_autoc/tris.md2"},
+type == "automag" -> 	{"path":"models/weapons/g_autom/tris.md2"},
+type == "carbine" -> 	{"path":"models/weapons/g_68carbine/tris.md2"},
+type == "high" -> 	{"path":"models/weapons/g_autoc/tris.md2"},
+type == "low" -> 	{"path":"models/weapons/g_trrac/tris.md2"},
+type == "medium" -> 	{"path":"models/weapons/g_vm68/tris.md2"},
+type == "spyder" -> 	{"path":"models/weapons/g_spyder/tris.md2"},
+type == "stingray" -> 	{"path":"models/weapons/g_sting/tris.md2"},
+type == "trracer" -> 	{"path":"models/weapons/g_trrac/tris.md2"},
+type == "vm68" -> 	{"path":"models/weapons/g_vm68/tris.md2"},
+                    "models/weapons/g_vm68/tris.md2"
+}}) = weapon_pballgun :
+
+	"Spawning spot for guns. If no type is specified, the gun will be random.
+
+    autococker : Spawns an Autococker
+    automag : Spawns an Automag
+    carbine : Spawns a 68 Carbine
+    high : Randomly spawns either an Autococker or Automag
+    low : Randomly spawns a Trracer or Stingray
+    medium : Randomly spawns a VM-68, 68 Carbine or Spyder SE
+    spyder : Spawns a Spyder SE
+    stingray : Spawns a Stingray
+    trracer : Spawns a Trracer
+    vm68 : Spawns a VM-68"
+    [
+    type(choices) : "sets the type of the weapon"  =
+    [
+    "autococker" : "for spawning an Autococker"
+    "automag" : "for spawning an Automag"
+    "carbine" : "for spawning a 68 Carbine"
+    "high" : "for randomly spawning an Autococker or Automag"
+    "low" : "for randomly spawning a Trracer or Stingray"
+    "medium" : "for randomly spawning a VM-68, 68 Carbine or Spyder SE"
+    "spyder" : "for spawning a Spyder SE"
+    "stingray" : "for spawning a Stingray"
+    "trracer" : "for spawning a Trracer"
+    "vm68" : "for spawning a VM-68"
+    ]
+]
+
+@PointClass base(Group) color(200 0 200) size(-8 -8 16, 8 8 32) studio({{
+type == 100 -> 	{"path":"models/items/hopper/tris.md2", "skin": 0},
+type == 200 -> 	{"path":"models/items/hopper/tris.md2", "skin": 1},
+                        "models/items/hopper/tris.md2"
+}}) = item_pballhopper :
+
+    "Spawning spot for hoppers. If no type is specified, the hopper will be random."
+    [
+    type(choices) : "sets the type of the hopper" =
+    [
+        100 : "for spawning a hopper of 100"
+        200 : "for spawning a hopper of 200"
+    ]
+]
+
+@PointClass base(AppearFlags) color(200 128 25) size(-12 -12 0, 12 12 8) studio({{
+type == "25" -> 	{"path":"models/items/ammo/tris.md2", "skin": 0,  "frame": 0},
+type == "50" -> 	{"path":"models/items/ammo/tris.md2", "skin": 1,  "frame": 1},
+type == "100" -> 	{"path":"models/items/ammo/tris.md2", "skin": 2,  "frame": 2},
+type == "150" -> 	{"path":"models/items/ammo/tris.md2", "skin": 3,  "frame": 3},
+type == "200" -> 	{"path":"models/items/ammo/tris.md2", "skin": 4,  "frame": 4},
+type == "small" -> 	{"path":"models/items/ammo/tris.md2", "skin": 0,  "frame": 0},
+type == "medium" -> {"path":"models/items/ammo/tris.md2", "skin": 2,  "frame": 2},
+type == "large" -> 	{"path":"models/items/ammo/tris.md2", "skin": 3,  "frame": 3},
+                        "models/items/ammo/tris.md2"
+}}) = item_pballammo : "Spawning spot for ammo. If no type is specified, the ammo will be random."
+[
+    type(choices) : "sets the type of the ammo pack" =
+    [
+        "25" : "for spawning an ammo pack of 25"
+        "50" : "for spawning an ammo pack of 50"
+        "100" : "for spawning an ammo pack of 100"
+        "150" : "for spawning an ammo pack of 150"
+        "200" : "for spawning an ammo pack of 200"
+        "small" : "for randomly spawning an ammo pack of 25, 50 or 100"
+        "medium" : "for randomly spawning an ammo pack of 50, 100 or 150"
+        "large" : "for randomly spawning an ammo pack of 100, 150 or 200"
+    ]
+]
+
+@PointClass base(Group) color(200 0 0) size(-4 -4 12, 4 4 32) studio({{
+type == "12g" -> 	{"path":"models/items/co2/12g/tris.md2", "skin": 0},
+type == "7oz" -> 	{"path":"models/items/co2/7oz/tris.md2", "skin": 0},
+type == "12oz" -> 	{"path":"models/items/co2/12oz/tris.md2", "skin": 0},
+type == "20oz" -> 	{"path":"models/items/co2/20oz/tris.md2", "skin": 0},
+type == "small" -> 	{"path":"models/items/co2/12g/tris.md2", "skin": 0},
+type == "medium" -> {"path":"models/items/co2/7oz/tris.md2", "skin": 0},
+type == "large" -> 	{"path":"models/items/co2/12oz/tris.md2", "skin": 0},
+                        "models/items/co2/7oz/tris.md2"
+}}) = item_pballco2 : "Spawning spot for co2. If no type is specified, the co2 will be random."
+[
+    type(choices) : "sets the type of the co2 tank" =
+    [
+        "12g" : "for spawning a co2 tank of 12g"
+        "7oz" : "for spawning a co2 tank of 7oz"
+        "12oz" : "for spawning a co2 tank of 12oz"
+        "20oz" : "for spawning a co2 tank of 20oz"
+        "small" : "for randomly spawning a co2 tank of 12g or 7oz"
+        "medium" : "for randomly spawning a co2 tank of 7oz or 12oz"
+        "large" : "for randomly spawning a co2 tank of 12oz or 20oz"
+    ]
+]
+
+@PointClass base(Group) color(200 200 0) size(-12 -12 24, 12 12 40) studio({{
+type == "brass" -> 	{"path":"models/items/barrel/tris.md2", "skin": 2},
+type == "chrome" -> 	{"path":"models/items/barrel/tris.md2", "skin": 1},
+type == "steel" -> 	{"path":"models/items/barrel/tris.md2", "skin": 0},
+                            "models/items/barrel/tris.md2"
+}}) = item_pballbarrel : "Spawning spot for barrels. If no type is specified, the barrel will be random."
+[
+    type(choices) : "sets the type of the barrel" =
+    [
+        "brass" : "for a brass barrel"
+        "chrome" : "for a chrome barrel"
+        "steel" : "for a steel barrel"
+    ]
+]
+
+
+
+@PointClass base(AppearFlags, TeamNumber) color(0 255 255) size(-8 -16 -16, 8 16 48) studio({"path": "models/items/flag/tris.md2"}) = flag : ""
+[
+    count(integer) : "
+    0.2 - for a flag with one point
+    0.4 - for a flag with two points
+    0.6 - for a flag with three points
+    0.8 - for a flag with four points
+    1.0 - for a flag with five points
+    1.2 - for a flag with six points
+    1.4 - for a flag with seven points
+    1.6 - for a flag with eight points
+    1.8 - for a flag with nine points
+    2.0 - for a flag with ten points"
+]
+
+
+
+@SolidClass = func_group : "Used to group brushes together just for editor convenience." []
+
+@SolidClass = func_areaportal : "This is a non-visible object that divides the world into areas that are seperated when this portal is not activated.  Usually enclosed in the middle of a door.  This can help performance by not rendering areas that are behind closed doors.Must be targeted." []
+
+@PointClass base(AppearFlags) color(128 80 0) size(-8 -8 -8, 8 8 8) = path_corner : "Set the direction of func_trains etc. Target it to the next path corner."
+[
+    targetname(string) : "sets the target from the previous path_corner entity with the same target"
+    target(string) : "sets the target to the next path_corner entity with the same targetname"
+]
+
+@PointClass base(AppearFlags) color(0 128 0) size(-4 -4 -4, 4 4 4) = info_null : "Used as a positional target for spotlights, etc."
+[
+    targetname(string) : "sets the target from the light source with the same target"
+]
+
+@PointClass base(AppearFlags) color(0 128 0) size(-4 -4 -4, 4 4 4) = info_notnull : "Used as a positional target jump pads, etc."
+[
+    targetname(string) : "sets the target from the trigger_push with the same target"
+]
+
+@PointClass base(AppearFlags) color(0 255 0) size(-8 -8 -8, 8 8 8) = light : "Point light with no visible source.  Only applies lighting to the world."
+[
+    light(integer) : "sets the light power (300 default)."
+    style(integer) : "sets the light style (0 default)."
+    _color(color255) : "sets the light color (0 default). Example 255 255 255"
+    target(string) : "sets the target for spotlights to the info_null entity with the same targetname."
+    _cone(integer) : "sets the size of light for spotlights (10 default)"
+//Light Attenuation
+		_angfade(integer)	: "arghrad - Scales how quickly the light fades as the angle-of-incidence decreases (from perpendicular to parallel). Values less than 1 fade slower, so the angle has less affect. Values greater than 1 fade faster, so the angle has more pronounced affect. def = 1 - This AKA _angwait"
+		_bounce(integer)	:	"arghrad - 0 (no bounce) or 1 (bounce)	default: 1. A value of 0 allows this light entity to be completely excluded from the bounced light calculations."
+		_cap(integer)	:	"arghrad - Caps the lighting cast from this light to the specified brightness level. The lighting is calculated normally, then any brighter points are capped off."
+		_distance(integer)	:	"arghrad - Sets the maximum distance that light shines from this entity. Behavior varies depending on the light`s _falloff setting:
+
+-Linear falloff - Smoothly fades out from the light to the specified distance. This overrides the _fade setting.
+
+-Inverse & inverse-square falloff - Sets a cutoff distance where the light abruptly stops shining."
+		_fade(integer)	:	"arghrad - Scales how quickly the light fades over distance. Values less than 1 fade slower, increasing the distance. Values greater than 1 fade faster, decreasing the distance. For example, a value of .5 fades half as fast, shining twice as far. PLEASE Note: This setting only works on lights with linear falloff."
+		_falloff(string)	:	"arghrad - Sets the falloff formula for this light entity. A value of 0 sets linear falloff, the default. A value of 2 sets inverse-square falloff, like surface lights.
+
+A value of 1 sets inverse falloff: lighting = brightness / distance. At 2 units away the light would be 1/2 as bright, at 3 units it's 1/3, etc. This can work very well for visible-sourced point-lights (mine-lights, torches, etc). It's more realistic than linear falloff, but not as `severe` as inverse-square.
+
+Note: Inverse and inverse-square falloff require much higher brightness values than linear."
+]
+
+@SolidClass base(AppearFlags) color(0 128 200) = func_wall : "This is just a solid wall if not inhibited."
+[
+	spawnflags(Flags) =
+	[
+		1 : "trigger_spawn" : 0 : "the wall will not be present until triggered, it will then blink in to existance; it will kill anything that was in it's way."
+		2 : "toggle" : 0 : "only valid for TRIGGER_SPAWN walls, this allows the wall to be turned on and off."
+		4 : "start_on" : 0 : "only valid for TRIGGER_SPAWN walls, the wall will initially be present."
+		8 : "animated" : 0
+		16 : "animated_fast" : 0
+	]
+]
+
+@SolidClass base(AppearFlags) = func_object : "This is solid bmodel that will fall if it's support is removed."
+[
+	spawnflags(Flags) =
+	[
+		1 : "trigger_spawn" : 0 : "the wall will not be present until triggered, it will then blink in to existance; it will kill anything that was in it's way."
+		2 : "animated" : 0
+		4 : "animated_fast" : 0
+	]
+]
+
+@SolidClass base(AppearFlags) color(0 0 255) = target_character : "Used with target_string (must be on same 'team')"
+[
+    count(integer) : "sets the position in the string (starts at 1)"
+]
+
+@PointClass base(AppearFlags) color(0 0 255) size(-8 -8 -8, 8 8 8) = target_string : "" []
+
+@PointClass base(AppearFlags) color(0 0 255) size(-8 -8 -8, 8 8 8) = func_clock : "Target a target_string with this. The default is to be a time of day clock.TIMER_UP and TIMER_DOWN run for 'count' '#' seconds and the fire 'pathtarget' '<targetto>'If START_OFF, this entity must be used before it starts."
+[
+	spawnflags(Flags) =
+	[
+		1 : "timer_up" : 0 : "run for 'count' '#' seconds and the fire 'pathtarget' '<targetto>' - <targetto> can be your own value."
+		2 : "timer_down" : 0 : "run for 'count' '#' seconds and the fire 'pathtarget' '<targetto>' - <targetto> can be your own value."
+		4 : "start_off" : 0 : "If START_OFF, this entity must be used before it starts."
+		8 : "multi_use" : 0
+	]
+    style(choices) : "clock style" =
+    [
+        0 : "for a style like xx"
+        1 : "for a style like xx:xx"
+        2 : "for a style like xx:xx:xx"
+    ]
+    pathtarget(string) : "see timer_up and timer_down spawnflags."
+]
+
+@PointClass base(AppearFlags) color(255 0 0) size(-32 -32 -24, 32 32 -16) = misc_teleporter : "Touching this will teleport players to the targeted misc_teleporter_dest object."
+[
+    target(string) : "sets the target to the misc_teleporter_dest entity with the same targetname"
+]
+
+@PointClass base(AppearFlags, Angle) color(255 0 0) size(-32 -32 -24, 32 32 -16) = misc_teleporter_dest : "Players who touched the 'misc_teleporter' will appear here."
+[
+    targetname(string) : "sets the target from the misc_teleporter entity with the same target"
+]
+
+@PointClass base(AppearFlags) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_temp_entity : "Fire an origin based temp entity event to the clients."
+[
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target."
+    style(integer) : "5 - for a yellow explosion\r21 - for a blue explosion\r45 - for a smoke puff\r48 - for a cyllindrical explosion\r51 - for a large and fast spherical explosion\r52 - for a slow and smaller spherical explosion\rOther values may also work, but can also crash the game, so be careful what you use."
+]
+
+@PointClass base(AppearFlags) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_speaker : "Normal sounds play each time the target is used."
+[
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target"
+    noise(string) : "sets the .wav file to play - <soundpath> is the path to your file. Example: 'noise' 'world/cricket.wav'"
+    volume(float) : "sets the volume power - # options can be 0.0 to 1.0."
+    attenuation(choices) : "volume falloffLooped sounds are allways atten 3 / vol 1, and the use function toggles it on/off.The reliable flag can be set for very important sounds like crucial voiceovers." =
+    [
+        -1 : "for no falloff, send to whole level"
+        1 : "for normal fighting sounds"
+        2 : "for idle sound level"
+        3 : "for ambient sound level (very rapid falloff)"
+    ]
+]
+
+@PointClass base(AppearFlags) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_changelevel : "Changes level when fired."
+[
+    map(string) : "sets the level to change to."
+]
+
+@PointClass base(AppearFlags) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_splash : "Creates a particle splash effect when used."
+[
+    dmg(integer) : "sets a radius damage to inflict at this location when it splashes (useful for lava/sparks)"
+    count(integer) : "sets how many pixels are in the splash."
+    sounds(choices) : "sets a style (not a sound)" =
+    [
+        1 : "for sparks"
+        2 : "for blue water"
+        3 : "for brown water"
+        4 : "for slime"
+        5 : "for lava"
+        6 : "for blood"
+    ]
+]
+
+@PointClass base(AppearFlags) color(255 0 0) size(-8 -8 -8, 8 8 8) = target_spawner : "Set target to the type of entity you want spawned.Useful for spawning monsters and gibs in the factory levels.For monsters:Set direction to the facing you want it to have.For gibs:Set direction if you want it moving and speed how fast it should be moving otherwise it will just be dropped." []
+
+@PointClass base(AppearFlags) color(0 128 200) size(-8 -8 -8, 8 8 8) = target_laser : "When triggered, fires a laser. You can either set a target or a direction."
+[
+	spawnflags(Flags) =
+	[
+		1 : "start_on" : 0
+		2 : "red" : 0
+		4 : "green" : 0
+		8 : "blue" : 0
+		16 : "yellow" : 0
+		32 : "orange" : 0
+		64 : "fat" : 0
+	]
+]
+
+@PointClass base(AppearFlags) color(0 128 200) size(-8 -8 -8, 8 8 8) = target_lightramp : "Makes a light fade in or fade out."
+[
+	spawnflags(Flags) =
+	[
+		1 : "toggle" : 0
+    ]
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target."
+    target(string) : "sets the target to the light source with the same targetname."
+    speed(integer) : "sets how many seconds the ramping will take."
+    message(choices) : "sets the starting lightlevel and the ending lightlevel in two letters" =
+    [
+        "az" : "for a light that fades in from dark to light"
+        "za" : "for a light that fades in from light to dark"
+    ]
+]
+
+@SolidClass base(AppearFlags) = trigger_once : "Triggers once, then removes itself. Target it with any entity."
+[
+	spawnflags(Flags) =
+	[
+		1 : "triggered" : 0 : "sets that this trigger must be triggered before it is live."
+    ]
+    target(string) : "sets the target to any other entities with the same targetname."
+    message(string) : "sets a string to be displayed when triggered."
+    delay(integer) : "sets a delay before first firing when turned on (0 default)."
+    sounds(choices) : "sets a sound to be played when triggered" =
+    [
+        1 : "secret"
+        2 : "beep beep"
+        3 : "large switch"
+    ]
+]
+
+@PointClass base(AppearFlags) color(128 128 128) size(-8 -8 -8, 8 8 8) = trigger_relay : "This fixed size trigger cannot be touched, it can only be fired by other events." []
+
+@SolidClass base(AppearFlags) = trigger_counter : "Acts as an intermediary for an action that takes multiple inputs.If nomessage is not set, it will print '1 more.. ' etc when triggered and 'sequence complete' when finished.After the counter has been triggered 'count' '#' times (default 2), it will fire all of it's targets and remove itself."
+[
+	spawnflags(Flags) =
+	[
+		1 : "nomessage" : 0 : "If nomessage is not set, it will print '1 more.. ' etc when triggered and 'sequence complete' when finished. After the counter has been triggered 'count' '#' times (default 2), it will fire all of it's targets and remove itself."
+    ]
+]
+
+@PointClass base(AppearFlags) color(128 128 128) size(-8 -8 -8, 8 8 8) = trigger_always : "This trigger will always fire.  It is activated by the world."
+[
+    target(string) : "sets the target to any other entities with the same targetname"
+]
+
+@SolidClass base(AppearFlags) = trigger_push : "Pushes players and grenades so they will hit the targeted info_notnull."
+[
+	spawnflags(Flags) =
+	[
+		1 : "push_once" : 0 : "affects all entities (paint, guns, etc)."
+		2 : "push_all" : 0 : "causes the trigger_push to be removed after the first touch."
+    ]
+    target(string) : "sets the target to the info_notnull entity with the same targetname"
+]
+
+@SolidClass base(AppearFlags) = trigger_hurt : "Any entity that touches this will be hurt."
+[
+	spawnflags(Flags) =
+	[
+		1 : "start_off" : 0 : "when the trigger_hurt must be triggered by a func_button, func_timer, etc."
+		2 : "toggle" : 0 : "toggles this trigger between enabled and disabled states."
+		4 : "silent" : 0 : "supresses playing the sound."
+		8 : "no_protection" : 0 : "makes that nothing can stop the damage."
+		16 : "slow" : 0 : "changes the damage rate to once per second."
+    ]
+    message(string) : "sets a string to be displayed when touched"
+    dmg(integer) : "sets a damage to inflict when touches (5 default)"
+]
+
+@SolidClass base(AppearFlags) = trigger_gravity : "Changes the touching entities gravity. Unfortunately, this does not work for players."
+[
+    gravity(integer) : "sets the gravity value (1 default)."
+]
+
+@SolidClass base(AppearFlags) = func_getoutofjail : "Turns an eleminated player into a living player when touched."
+[
+    noise(string) : "sets the .wav file to play"
+]
+
+@PointClass base(AppearFlags, Angle) color(255 0 0) size(-16 -16 -24, 16 16 40) = info_player_start : "Starting point for single player, which isn't really applicable here. Players will spawn here if there are no info_player_deathmatches." []
+
+
+@PointClass base(AppearFlags) color(255 0 255) size(-16 -16 -24, 16 16 40) = info_player_intermission : "This is where the camera will be placed at the end of the match when the scoreboard is shown."
+[
+    angles(string) : "# # # sets the direction (pitch-yaw-roll)"
+]
+
+@BaseClass base(AppearFlags) = Door
+[
+	spawnflags(Flags) =
+	[
+        1 : "start_open" : 0 : "the door to moves to its destination when spawned and operate in reverse. It is used to temporarily or permanently close off an area when triggered (not useful for touch or takedamage doors)."
+        2 : "x" : 0 : ""
+        4 : "crusher" : 0 : "door will not move back if blocked."
+        8 : "nomonster" : 0 : ""
+        16 : "animated" : 0 : ""
+        32 : "toggle" : 0 : "wait in both the start and end states for a trigger event."
+        64 : "animated_fast" : 0 : ""
+	]
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target."
+    target(string) : "sets the target to a func_areaportal or target_speaker with the same targetname."
+    message(string) : "sets a string to be displayed when triggered"
+    team(string) : "<teamtext> sets that all doors with the same team value will open if any door of them gets activated."
+    health(integer) : "1 sets that the door must be shoot open instead of touching it."
+    angle(string) : "sets the opening direction of the door (0 default; -1 = upwards; -2 = downwards)."
+    speed(integer) : "sets the movement speed (100 default)."
+    wait(integer) : "sets the seconds before returning (3 default, -1 = never return)."
+    lip(integer) : "sets the lip remaining at end of move (8 default)."
+    dmg(integer) : "sets a damage to inflict when blocked (2 default)."
+    _minlight(float) : "sets that the door glows - # options can be 0.0 to 1.0."
+    sounds(choices) : "sound type" =
+    [
+        1 : "for a silent sound"
+        2 : "for a light sound"
+        3 : "for a medium sound"
+        4 : "for a heavy sound"
+    ]
+]
+
+@SolidClass base(AppearFlags, Door) = func_door : "Used for a simple door."
+[
+]
+
+@SolidClass base(AppearFlags, Door) = func_door_rotating : "Used for a simple door."
+[
+	spawnflags(Flags) =
+	[
+	    2 : "reverse" : 0 : "will cause the door to rotate in the opposite direction."
+	    64 : "x_axis" : 0 : "rotate on the x axis."
+	    128 : "y_axis" : 0 : "rotate on the y axis."
+	]
+    distance(integer) : "sets the degrees the door will be rotated."
+]
+
+@SolidClass base(AppearFlags) = func_plat : "Plats are always drawn in the extended position, so they will light correctly.If the plat is the target of another trigger or button, it will start out disabled inthe extended position until it is trigger, when it will lower and become a normal plat."
+[
+	spawnflags(Flags) =
+	[
+	    1 : "plat_low_trigger" : 0 : ""
+    ]
+    height(integer) : "sets the height the platform will move up (positive value) or moves down (negative value)."
+    speed(integer) : "sets movement speed (150 default)."
+    accel(integer) : "sets the acceleration when the plat starts to move."
+    decel(integer) : "sets the deceleration when the plat ends to move."
+    dmg(integer) : "sets a damage to inflict when blocked (2 default)."
+    _minlight(float) : "sets that the plat glows - # options can be 0.0 to 1.0."
+    sounds(choices) : "sound type" =
+    [
+        1 : "for a base fast sound"
+        2 : "for a chain slow sound"
+    ]
+]
+
+@SolidClass base(AppearFlags) = func_rotating : "You need to have an origin brush as part of this entity. The center of that brush will be the point around which it is rotated. It will rotate around the Z axis by default."
+[
+	spawnflags(Flags) =
+	[
+        1 : "start_on" : 0 : "will activate the rotation by the world."
+        2 : "reverse" : 0 : "will cause the entity to rotate in the opposite direction."
+        4 : "x_axis" : 0 : "rotate on the x axis."
+        8 : "y_axis" : 0 : "rotate on the y axis."
+        16 : "touch_pain" : 0 : ""
+        32 : "stop" : 0 : "stop moving instead of pushing entities."
+        64 : "animated" : 0 : ""
+        128 : "animated_fast" : 0 : ""
+	]
+    speed(integer) : "sets movement speed (100 default)."
+    dmg(integer) : "sets a damage to inflict when blocked (2 default)."
+    _minlight(float) : "sets that the rotating brush glows - # options can be 0.0 to 1.0."
+]
+
+@SolidClass base(AppearFlags) = func_water : "Func_water is a moveable water brush. It must be targeted to operate. Use a non-water texture at your own risk."
+[
+	spawnflags(Flags) =
+	[
+        1 : "start_open" : 0 : "causes the water to move to its destination when spawned and operate in reverse."
+    ]
+    speed(integer) : "sets the movement speed (25 default)."
+    wait(integer) : "sets the seconds before returning (-1 default, -1 = TOGGLE)."
+    lip(integer) : "sets the lip remaining at end of move (0 default)."
+    angle(string) : "sets the opening direction of the water (0 default; -1 = upwards; -2 = downwards)."
+    sounds(choices) : "sound type" =
+    [
+        0 : "no sound"
+        1 : "for a water sound"
+        2 : "for a lava sound"
+    ]
+]
+
+@SolidClass base(AppearFlags) = func_train : "Trains are moving platforms that players can ride (if toggle is set).The targets origin specifies the min point of the train at each corner (path_corner).The train spawns at the first target it is pointing at.If the train is the target of a button or trigger, it will not begin moving until activated."
+[
+	spawnflags(Flags) =
+	[
+        1 : "start_on" : 0 : "will activate the rotation by the world."
+        2 : "toggle" : 0 : "will move the standing people with the train."
+        4 : "block_stops" : 0 : "will stop the train while blocking (only if no dmg is set)."
+    ]
+    target(string) : "sets the target to a path corner with the same targetname."
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target."
+    speed(integer) : "sets movement speed (100 default)."
+    dmg(integer) : "sets a damage to inflict when blocked (2 default)."
+    _minlight(float) : "sets that the platform glows - # options can be 0.0 to 1.0."
+]
+
+@PointClass base(AppearFlags) color(80 25 160) size(-8 -8 -8, 8 8 8) = trigger_elevator : "Entity to make a func_train behave like an elevator. Place path_corner's at each floor and set the func_button at that floor to target the trigger_elevator and pathtarget the path_corner."
+[
+    target(string) : "sets the target to the func_train elevator with the same targetname."
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target."
+]
+
+@PointClass base(AppearFlags) color(80 25 160) size(-8 -8 -8, 8 8 8) = func_timer : "Timer for trigger lots of stuff. Target it with any entity."
+[
+	spawnflags(Flags) =
+	[
+        1 : "start_on" : 0 : "will activate the timer by the world."
+    ]
+    target(string) : "sets the target to any other entities with the same targetname."
+    wait(integer) : "sets the base time between triggering all targets (1 default)."
+    random(integer) : "sets the wait variance, so the basic time between firing is a random time (0 default)."
+    delay(integer) : "sets a delay before first firing when turned on (0 default)."
+    pausetime(integer) : "sets an additional delay used only the very first time and only if spawned with START_ON."
+]
+
+@SolidClass base(AppearFlags) = func_conveyor : "Conveyors are stationary brushes that move what's on them.The brush should be have a surface with at least one current content enabled."
+[
+	spawnflags(Flags) =
+	[
+        1 : "start_on" : 0 : ""
+        2 : "toggle" : 0 : ""
+    ]
+    speed(integer) : "sets the movement speed (100 default)."
+]
+
+// TODO - should this have sounds/lip/etc from base(Door)?
+@SolidClass base(AppearFlags) = func_door_secret : "A secret door. Slide back and then to the side."
+[
+	spawnflags(Flags) =
+	[
+        1 : "always_shoot" : 0 : "the door is shootable even if targeted."
+        2 : "1st_left" : 0 : "the 1st move is left of arrow."
+        4 : "1st_down" : 0 : "the 1st move is down from arrow."
+    ]
+    targetname(string) : "sets the target from a func_button, func_timer, etc. with the same target."
+    target(string) : "sets the target to a func_areaportal or target_speaker with the same targetname."
+    message(string) : "sets a string to be displayed when triggered - <messagetext> can be your own value."
+    health(integer) : "1 sets that the door must be shoot open instead of touching it."
+    angle(string) : "sets the opening direction of the door (0 default; -1 = upwards; -2 = downwards)."
+    speed(integer) : "sets the movement speed (100 default)."
+    wait(integer) : "sets the seconds before returning (5 default, -1 = never return)."
+    dmg(integer) : "sets a damage to inflict when blocked (2 default)."
+    _minlight(float) : "sets that the door glows - # options can be 0.0 to 1.0."
+]
+
+@SolidClass base(AppearFlags) = func_button : "When a button is touched, it moves some distance in the direction of it's angle, triggers all of it's targets, waits some time, then returns to it's original position where it can be triggered again."
+[
+    target(string) : "sets the target to any other entities with the same targetname."
+    health(integer) : "sets that the button must be killed instead of touched."
+    angle(string) : "sets the moving direction."
+    speed(integer) : "sets the movement speed (40 default)."
+    wait(integer) : "sets the seconds before returning (1 default, -1 = never return)."
+    lip(integer) : "sets the lip remaining at end of move (4 default)."
+    delay(integer) : "sets a delay before first firing when turned on (0 default)."
+    _minlight(float) : "sets that the door glows - # options can be 0.0 to 1.0."
+    sounds(choices) : "sound type" =
+    [
+        1 : "for a silent sound"
+        2 : "for a steam metal sound"
+        3 : "for a wooden clunk sound"
+        4 : "for a metallic click sound"
+        5 : "for an in-out sound"
+    ]
+]

tools/trenchbroom/games/Generic/GameConfig.cfg

@@ -0,0 +1,30 @@
+{
+    version: 9,
+    name: "Generic",
+    icon: "Icon.png",
+    "fileformats": [
+        { "format": "Standard", "initialmap": "initial_standard.map" },
+        { "format": "Valve", "initialmap": "initial_valve.map" },
+        { "format": "Quake2", "initialmap": "initial_quake2.map" }
+    ],
+    "filesystem": {
+        "searchpath": ".",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "format": { "extensions": [".jpg", ".jpeg", ".tga", ".png"], "format": "image" }
+    },
+    "entities": {
+        "definitions": [ "Generic.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [],
+        "brushface": []
+    },
+    "faceattribs": {
+        "surfaceflags": [],
+        "contentflags": []
+    }
+}

tools/trenchbroom/games/Generic/Generic.fgd

@@ -0,0 +1,5 @@
+@SolidClass = worldspawn : "World entity" []
+
+@baseclass size(-16 -16 -24, 16 16 32) color(0 255 0) = PlayerClass []
+
+@PointClass base(PlayerClass) = info_player_start : "Player 1 start" []

tools/trenchbroom/games/Halflife/GameConfig.cfg

@@ -0,0 +1,79 @@
+{
+    "version": 9,
+    "name": "Half-Life",
+    "experimental": true,
+    "icon": "Icon.png",
+    "fileformats": [
+        { "format": "Valve" },
+        { "format": "Standard" }
+    ],
+    "filesystem": {
+        "searchpath": "valve",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [".C"],
+        "palette": "gfx/palette.lmp",
+        "attribute": "wad"
+    },
+    "entities": {
+        "definitions": [ "HalfLife.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0",
+        "setDefaultProperties": true
+    },
+    "tags": {
+        "brush": [
+            {
+                "name": "Trigger",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "trigger*"
+            }
+        ],
+        "brushface": [
+            {
+                "name": "Clip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "clip"
+            },
+            {
+                "name": "Skip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "skip"
+            },
+            {
+                "name": "Hint",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "hint*"
+            },
+            {
+                "name": "Origin",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "origin"
+            },
+            {
+                "name": "Null",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "null"
+            },
+            {
+                "name": "Liquid",
+                "match": "material",
+                "pattern": "\**"
+            }
+        ]
+    },
+    "softMapBounds":"-4096 -4096 -4096 4096 4096 4096",
+    "compilationTools": [
+        { "name": "csg", "description": "Path to your directory containing your CSG tool. ${csg}." },
+        { "name": "bsp", "description": "Path to your directory containing your BSP tool. ${bsp}." },
+        { "name": "vis", "description": "Path to your directory containing your VIS tool. ${vis}" },
+        { "name": "rad", "description": "Path to your directory containing your RAD tool. ${rad}" }
+    ]
+}

tools/trenchbroom/games/Heretic2/GameConfig.cfg

@@ -0,0 +1,252 @@
+{
+    "version": 9,
+    "name": "Heretic 2",
+    "icon": "Icon.png",
+    "fileformats": [
+        { "format": "Quake2" },
+        { "format": "Quake2 (Valve)"}
+    ],
+    "filesystem": {
+        "searchpath": "base",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [".m8"],
+        "palette": "pics/colormap.pcx"
+    },
+    "entities": {
+        "definitions": [ "heretic2.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [
+            {
+                "name": "Trigger",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "trigger*",
+                "material": "trigger"
+            }
+        ],
+        "brushface": [
+            {
+                "name": "Clip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "clip"
+            },
+            {
+                "name": "Skip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "skip"
+            },
+            {
+                "name": "Hint",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "hint*"
+            },
+            {
+                "name": "Detail",
+                "match": "contentflag",
+                "flags": [ "detail" ]
+            },
+            {
+                "name": "Liquid",
+                "match": "contentflag",
+                "flags": [ "lava", "slime", "water" ]
+            },
+            {
+                "name": "Transparent",
+                "attribs": [ "transparent" ],
+                "match": "surfaceflag",
+                "flags": [ "trans33", "trans66" ]
+            }
+        ]
+    },
+    "faceattribs": {
+        "surfaceflags": [
+            {
+                "name": "light",
+                "description": "Emit light from the surface, brightness is specified in the 'value' field"
+            }, // 1 << 0
+            {
+                "name": "slick",
+                "description": "The surface is slippery"
+            }, // 1 << 1
+            {
+                "name": "sky",
+                "description": "The surface is sky, the texture will not be drawn, but the background sky box is used instead"
+            }, // 1 << 2
+            {
+                "name": "warp",
+                "description": "The surface warps (like water textures do)"
+            }, // 1 << 3
+            {
+                "name": "trans33",
+                "description": "The surface is 33% transparent"
+            }, // 1 << 4
+            {
+                "name": "trans66",
+                "description": "The surface is 66% transparent"
+            }, // 1 << 5
+            {
+                "name": "flowing",
+                "description": "The texture wraps in a downward 'flowing' pattern (warp must also be set)"
+            }, // 1 << 6
+            {
+                "name": "nodraw",
+                "description": "Used for non-fixed-size brush triggers and clip brushes"
+            }, // 1 << 7
+            {
+                "name": "hint",
+                "description": "Make a primary bsp splitter"
+            }, // 1 << 8
+            {
+                "name": "skip",
+                "description": "Completely ignore, allowing non-closed brushes"
+            }, // 1 << 9
+            {
+                "name": "tall_wall",
+                "description": "Purpose unknown"
+            }, // 1 << 10
+            {
+                "name": "alpha_tex",
+                "description": "Purpose unknown"
+            }, // 1 << 11
+            {
+                "name": "animspeed",
+                "description": "Purpose unknown"
+            }, // 1 << 12
+            {
+                "name": "undulate",
+                "description": "Purpose unknown"
+            }, // 1 << 13
+            {
+                "name": "skyreflect",
+                "description": "Purpose unknown"
+            }, // 1 << 14
+            { "unused": true }, // 1 << 15
+            { "unused": true }, // 1 << 16
+            { "unused": true }, // 1 << 17
+            { "unused": true }, // 1 << 18
+            { "unused": true }, // 1 << 19
+            { "unused": true }, // 1 << 20
+            { "unused": true }, // 1 << 21
+            { "unused": true }, // 1 << 22
+            { "unused": true }, // 1 << 23            
+            {
+                "name": "metal",
+                "description": "Sound when walked on"
+            }, // 1 << 24
+            {
+                "name": "stone",
+                "description": "Sound when walked on"
+            } // 1 << 25
+        ],
+        "contentflags": [
+            {
+                "name": "solid",
+                "description": "Default for all brushes"
+            }, // 1 << 0
+            {
+                "name": "window",
+                "description": "Brush is a window (not really used)"
+            }, // 1 << 1
+            {
+                "name": "pushpull",
+                "description": "Purpose unknown"
+            }, // 1 << 2
+            {
+                "name": "lava",
+                "description": "The brush is lava"
+            }, // 1 << 3
+            {
+                "name": "slime",
+                "description": "The brush is slime"
+            }, // 1 << 4
+            {
+                "name": "water",
+                "description": "The brush is water"
+            }, // 1 << 5
+            {
+                "name": "mist",
+                "description": "The brush is non-solid"
+            }, // 1 << 6
+            { "unused": true }, // 1 << 7
+            { "unused": true }, // 1 << 8
+            { "unused": true }, // 1 << 9
+            { "unused": true }, // 1 << 10
+            { "unused": true }, // 1 << 11
+            { "unused": true }, // 1 << 12
+            { "unused": true }, // 1 << 13
+            { "unused": true }, // 1 << 14
+            {
+                "name": "areaportal",
+                "description": "Purpose unknown"
+            }, // 1 << 15
+            {
+                "name": "playerclip",
+                "description": "Player cannot pass through the brush (other things can)"
+            }, // 1 << 16
+            {
+                "name": "monsterclip",
+                "description": "Monster cannot pass through the brush (player and other things can)"
+            }, // 1 << 17
+            {
+                "name": "current_0",
+                "description": "Brush has a current in direction of 0 degrees"
+            }, // 1 << 18
+            {
+                "name": "current_90",
+                "description": "Brush has a current in direction of 90 degrees"
+            }, // 1 << 19
+            {
+                "name": "current_180",
+                "description": "Brush has a current in direction of 180 degrees"
+            }, // 1 << 20
+            {
+                "name": "current_270",
+                "description": "Brush has a current in direction of 270 degrees"
+            }, // 1 << 21
+            {
+                "name": "current_up",
+                "description": "Brush has a current in the up direction"
+            }, // 1 << 22
+            {
+                "name": "current_dn",
+                "description": "Brush has a current in the down direction"
+            }, // 1 << 23
+            {
+                "name": "origin",
+                "description": "Special brush used for specifying origin of rotation for rotating brushes"
+            }, // 1 << 24
+            {
+                "name": "monster",
+                "description": "Purpose unknown"
+            }, // 1 << 25
+            {
+                "name": "deadmonster",
+                "description": "Purpose unknown"
+            }, // 1 << 26
+            {
+                "name": "detail",
+                "description": "Detail brush"
+            }, // 1 << 27
+            {
+                "name": "translucent",
+                "description": "Use for opaque water that does not block vis"
+            }, // 1 << 28
+            {
+                "name": "ladder",
+                "description": "Brushes with this flag allow a player to move up and down a vertical surface"
+            }, // 1 << 29
+            {
+                "name": "camnoblock",
+                "description": "Doesn't block camera"
+            } // 1 << 30
+        ]
+    }
+}

tools/trenchbroom/games/Hexen2/GameConfig.cfg

@@ -0,0 +1,23 @@
+{
+    "version": 9,
+    "name": "Hexen 2",
+    "icon": "Icon.png",
+    "fileformats": [
+        { "format": "Hexen2" },
+        { "format": "Valve" }
+    ],
+    "filesystem": {
+        "searchpath": "data1",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [".D"],
+        "palette": "gfx/palette.lmp",
+        "attribute": "wad"
+    },
+    "entities": {
+        "definitions": [ "Hexen2.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    }
+}

tools/trenchbroom/games/Kingpin/GameConfig.cfg

@@ -0,0 +1,285 @@
+{
+    "version": 9,
+    "name": "Kingpin",
+    "icon": "Icon.png",
+    "fileformats": [ { "format": "Quake2" }, { "format": "Quake2 (Valve)"} ],
+    "filesystem": {
+        "searchpath": "main",
+        "packageformat": { "extension": ".pak", "format": "idpak" }
+    },
+    "materials": {
+        "root": "textures",
+        "extensions": [".tga"],
+        "palette": "pics/colormap.pcx"
+    },
+    "entities": {
+        "definitions": [ "kingpin.fgd" ],
+        "defaultcolor": "0.6 0.6 0.6 1.0"
+    },
+    "tags": {
+        "brush": [
+            {
+                "name": "Trigger",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "trigger*",
+                "material": "0_trigger"
+            },
+            {
+                "name": "Weather",
+                "attribs": [ "transparent" ],
+                "match": "classname",
+                "pattern": "elements*"
+            }
+        ],
+        "brushface": [
+            {
+                "name": "Clip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "0_clip"
+            },
+            {
+                "name": "Skip",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "0_skip"
+            },
+            {
+                "name": "Hint",
+                "attribs": [ "transparent" ],
+                "match": "material",
+                "pattern": "0_hint"
+            },
+            {
+                "name": "Detail",
+                "match": "contentflag",
+                "flags": [ "detail" ]
+            },
+            {
+                "name": "Liquid",
+                "match": "contentflag",
+                "flags": [ "lava", "slime", "water" ]
+            },
+            {
+                "name": "Sound",
+                "match": "surfaceflag",
+                "flags": [ "water", "concrete", "fabric", "gravel", "metal", "metal lite", "tin", "tile", "wood" ]
+            }
+        ]
+    },
+    "faceattribs": {
+        "surfaceflags": [
+            {
+                "name": "light",
+                "description": "Emit light from the surface, brightness is specified in the 'value' field"
+            },
+            {
+                "name": "slick",
+                "description": "The surface is slippery"
+            },
+            {
+                "name": "sky",
+                "description": "The surface is sky, the texture will not be drawn, but the background sky box is used instead"
+            },
+            {
+                "name": "warp",
+                "description": "The surface warps (like water textures do)"
+            },
+            {
+                "name": "trans33",
+                "description": "The surface is 33% transparent"
+            },
+            {
+                "name": "trans66",
+                "description": "The surface is 66% transparent"
+            },
+            {
+                "name": "flowing",
+                "description": "The texture wraps in a downward 'flowing' pattern (warp must also be set)"
+            },
+            {
+                "name": "nodraw",
+                "description": "Used for non-fixed-size brush triggers and clip brushes"
+            },
+            {
+                "name": "hint",
+                "description": "Make a primary bsp splitter"
+            },
+            {
+                "name": "skip",
+                "description": "Completely ignore, allowing non-closed brushes"
+            },
+            {
+                "name": "specular",
+                "description": " "
+            },
+            {
+                "name": "diffuse",
+                "description": " "
+            },
+            {
+                "name": "alpha",
+                "description": "alpha texture"
+            },
+            {
+                "name": "mirror",
+                "description": " "
+            },
+            {
+                "name": "wndw33",
+                "description": " "
+            },
+            {
+                "name": "wndw66",
+                "description": " "
+            },
+            { "unused": true },
+            { "unused": true },
+            { "unused": true },
+            {
+                "name": "water",
+                "description": "water sound"
+            },
+            {
+                "name": "concrete",
+                "description": "concrete sound"
+            },
+            {
+                "name": "fabric",
+                "description": "fabric sound"
+            },
+            {
+                "name": "gravel",
+                "description": "gravel sound"
+            },
+            {
+                "name": "metal",
+                "description": "metal sound"
+            },
+            {
+                "name": "metal lite",
+                "description": "metal light sound"
+            },
+            {
+                "name": "tin",
+                "description": "tin sound"
+            },
+            {
+                "name": "tile",
+                "description": "tile sound"
+            },
+            {
+                "name": "wood",
+                "description": "wood sound"
+            },
+            {
+                "name": "reflect fake",
+                "description": " "
+            },
+            {
+                "name": "reflect light",
+                "description": " "
+            }
+        ],
+        "contentflags": [
+            {
+                "name": "solid",
+                "description": "Default for all brushes"
+            }, // 1
+            {
+                "name": "window",
+                "description": "Brush is a window (not really used)"
+            }, // 2
+            {
+                "name": "aux",
+                "description": "Unused by the engine"
+            }, // 4
+            {
+                "name": "lava",
+                "description": "The brush is lava"
+            }, // 8
+            {
+                "name": "slime",
+                "description": "The brush is slime"
+            }, // 16
+            {
+                "name": "water",
+                "description": "The brush is water"
+            }, // 32
+            {
+                "name": "mist",
+                "description": "The brush is non-solid"
+            }, // 64
+           {
+                "name": "fence",
+                "description": "The brush is solid"
+            }, // 128
+            { "unused": true }, // 256
+            { "unused": true }, // 512
+            { "unused": true }, // 1024
+            { "unused": true }, // 2048
+            { "unused": true }, // 4096
+            { "unused": true }, // 8192
+            { "unused": true }, // 16384
+            { "unused": true }, // 32768
+            {
+                "name": "playerclip",
+                "description": "Player cannot pass through the brush (other things can)"
+            }, // 65536
+            {
+                "name": "monsterclip",
+                "description": "Monster cannot pass through the brush (player and other things can)"
+            }, // 131072
+            {
+                "name": "current_0",
+                "description": "Brush has a current in direction of 0 degrees"
+            },
+            {
+                "name": "current_90",
+                "description": "Brush has a current in direction of 90 degrees"
+            },
+            {
+                "name": "current_180",
+                "description": "Brush has a current in direction of 180 degrees"
+            },
+            {
+                "name": "current_270",
+                "description": "Brush has a current in direction of 270 degrees"
+            },
+            {
+                "name": "current_up",
+                "description": "Brush has a current in the up direction"
+            },
+            {
+                "name": "current_dn",
+                "description": "Brush has a current in the down direction"
+            },
+            {
+                "name": "origin",
+                "description": "Special brush used for specifying origin of rotation for rotating brushes"
+            },
+            {
+                "name": "monster",
+                "description": "Purpose unknown"
+            },
+            {
+                "name": "corpse",
+                "description": "Purpose unknown"
+            },
+            {
+                "name": "detail",
+                "description": "Detail brush"
+            },
+            {
+                "name": "translucent",
+                "description": "Use for opaque water that does not block vis"
+            },
+            {
+                "name": "ladder",
+                "description": "Brushes with this flag allow a player to move up and down a vertical surface"
+            }
+        ]
+    },
+    "softMapBounds":"-4096 -4096 -4096 4096 4096 4096"
+}