diff --git a/SabreTools.Data.Extensions/WiseScriptExtensions.cs b/SabreTools.Data.Extensions/WiseScriptExtensions.cs index bd315058..ac71fc61 100644 --- a/SabreTools.Data.Extensions/WiseScriptExtensions.cs +++ b/SabreTools.Data.Extensions/WiseScriptExtensions.cs @@ -1,6 +1,5 @@ using System.Text.RegularExpressions; -#pragma warning disable SYSLIB1045 // Convert to 'GeneratedRegexAttribute' namespace SabreTools.Data.Extensions { public static class WiseScriptExtensions @@ -58,7 +57,9 @@ namespace SabreTools.Data.Extensions // External DLL null => null, +#pragma warning disable SYSLIB1045 // Convert to 'GeneratedRegexAttribute' _ => Regex.IsMatch(functionId, @"^f[0-9]{1,2}$") ? $"UNDEFINED {functionId}" : $"External: {functionId}", +#pragma warning restore SYSLIB1045 }; } } diff --git a/SabreTools.Data.Models/BSP/Enums.cs b/SabreTools.Data.Models/BSP/Enums.cs index 8d40c10a..91fcb957 100644 --- a/SabreTools.Data.Models/BSP/Enums.cs +++ b/SabreTools.Data.Models/BSP/Enums.cs @@ -269,11 +269,8 @@ namespace SabreTools.Data.Models.BSP } /// - /// - public enum LumpType : int + public enum BspLumpType : int { - #region BSP and VBSP - /// /// The entity lump is basically a pure ASCII text section. /// It consists of the string representations of all entities, @@ -385,10 +382,122 @@ namespace SabreTools.Data.Models.BSP /// bounding box spaned by the first to members of this struct. /// LUMP_MODELS = 14, + } - #endregion + /// + public enum VbspLumpType : int + { + /// + /// The entity lump is basically a pure ASCII text section. + /// It consists of the string representations of all entities, + /// which are copied directly from the input file to the output + /// BSP file by the compiler. + /// + LUMP_ENTITIES = 0, - #region VBSP Only + /// + /// This lump is a simple array of binary data structures. + /// Each of this structures defines a plane in 3-dimensional + /// space by using the Hesse normal form + /// + LUMP_PLANES = 1, + + /// + /// The texture lump is somehow a bit more complex then the + /// other lumps, because it is possible to save textures + /// directly within the BSP file instead of storing them in + /// external WAD files. + /// + /// LUMP_TEXDATA in VBSP + LUMP_TEXTURES = 2, + + /// + /// This lump simply consists of all vertices of the BSP tree. + /// They are stored as a primitve array of triples of floats. + /// + /// LUMP_VERTEXES in VBSP + LUMP_VERTICES = 3, + + /// + /// The VIS lump contains data, which is irrelevant to the actual + /// BSP tree, but offers a way to boost up the speed of the + /// renderer significantly. Especially complex maps profit from + /// the use if this data. This lump contains the so-called + /// Potentially Visible Sets (PVS) (also called VIS lists) in the + /// same amout of leaves of the tree, the user can enter (often + /// referred to as VisLeaves). The visiblilty lists are stored as + /// sequences of bitfields, which are run-length encoded. + /// + LUMP_VISIBILITY = 4, + + /// + /// This lump is simple again and contains an array of binary + /// structures, the nodes, which are a major part of the BSP tree. + /// + LUMP_NODES = 5, + + /// + /// The texinfo lump contains informations about how textures are + /// applied to surfaces. The lump itself is an array of binary data + /// structures. + /// + LUMP_TEXINFO = 6, + + /// + /// The face lump contains the surfaces of the scene. + /// + LUMP_FACES = 7, + + /// + /// This is one of the largest lumps in the BSP file. The lightmap + /// lump stores all lightmaps used in the entire map. The lightmaps + /// are arrays of triples of bytes (3 channel color, RGB) and stored + /// continuously. + /// + LUMP_LIGHTING = 8, + + /// + /// This lump contains the so-called clipnodes, which build a second + /// BSP tree used only for collision detection. + /// + /// LUMP_OCCLUSION in VBSP + LUMP_CLIPNODES = 9, + + /// + /// The leaves lump contains the leaves of the BSP tree. + /// + /// LUMP_LEAFS in VBSP + LUMP_LEAVES = 10, + + /// + /// The marksurfaces lump is a simple array of short integers. + /// + /// LUMP_FACEIDS in VBSP + LUMP_MARKSURFACES = 11, + + /// + /// The edges delimit the face and further refer to the vertices of the + /// face. Each edge is pointing to the start and end vertex of the edge. + /// + LUMP_EDGES = 12, + + /// + /// This lump represents pretty much the same mechanism as the marksurfaces. + /// A face can insert its surfedge indexes into this array to get the + /// corresponding edges delimitting the face and further pointing to the + /// vertexes, which are required for rendering. The index can be positive + /// or negative. If the value of the surfedge is positive, the first vertex + /// of the edge is used as vertex for rendering the face, otherwise, the + /// value is multiplied by -1 and the second vertex of the indexed edge is + /// used. + /// + LUMP_SURFEDGES = 13, + + /// + /// A model is kind of a mini BSP tree. Its size is determinded by the + /// bounding box spaned by the first to members of this struct. + /// + LUMP_MODELS = 14, /// /// Internal world lights converted from the entity lump @@ -708,8 +817,6 @@ namespace SabreTools.Data.Models.BSP /// Displacement multiblend info /// LUMP_DISP_MULTIBLEND = 63, - - #endregion } /// diff --git a/SabreTools.Serialization.Readers/BSP.cs b/SabreTools.Serialization.Readers/BSP.cs index f05986de..1ae9bab0 100644 --- a/SabreTools.Serialization.Readers/BSP.cs +++ b/SabreTools.Serialization.Readers/BSP.cs @@ -54,63 +54,61 @@ namespace SabreTools.Serialization.Readers data.SeekIfPossible(initialOffset + lumpEntry.Offset, SeekOrigin.Begin); // Read according to the lump type -#pragma warning disable IDE0010 - switch ((LumpType)l) + switch ((BspLumpType)l) { - case LumpType.LUMP_ENTITIES: + case BspLumpType.LUMP_ENTITIES: file.Entities = ParseEntitiesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_PLANES: + case BspLumpType.LUMP_PLANES: file.PlanesLump = ParsePlanesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_TEXTURES: + case BspLumpType.LUMP_TEXTURES: file.TextureLump = ParseTextureLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_VERTICES: + case BspLumpType.LUMP_VERTICES: file.VerticesLump = ParseVerticesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_VISIBILITY: + case BspLumpType.LUMP_VISIBILITY: var visiblityLump = ParseVisibilityLump(data, lumpEntry.Offset, lumpEntry.Length); if (visiblityLump is not null) file.VisibilityLump = visiblityLump; break; - case LumpType.LUMP_NODES: + case BspLumpType.LUMP_NODES: file.NodesLump = ParseNodesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_TEXINFO: + case BspLumpType.LUMP_TEXINFO: file.TexinfoLump = ParseTexinfoLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_FACES: + case BspLumpType.LUMP_FACES: file.FacesLump = ParseFacesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LIGHTING: + case BspLumpType.LUMP_LIGHTING: file.LightmapLump = ParseLightmapLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_CLIPNODES: + case BspLumpType.LUMP_CLIPNODES: file.ClipnodesLump = ParseClipnodesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAVES: + case BspLumpType.LUMP_LEAVES: file.LeavesLump = ParseLeavesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_MARKSURFACES: + case BspLumpType.LUMP_MARKSURFACES: file.MarksurfacesLump = ParseMarksurfacesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_EDGES: + case BspLumpType.LUMP_EDGES: file.EdgesLump = ParseEdgesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_SURFEDGES: + case BspLumpType.LUMP_SURFEDGES: file.SurfedgesLump = ParseSurfedgesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_MODELS: + case BspLumpType.LUMP_MODELS: file.ModelsLump = ParseModelsLump(data, lumpEntry.Offset, lumpEntry.Length); break; default: - // Unsupported LumpType value, ignore + // Unsupported BspLumpType value, ignore break; } -#pragma warning restore IDE0010 } #endregion diff --git a/SabreTools.Serialization.Readers/VBSP.cs b/SabreTools.Serialization.Readers/VBSP.cs index f9578ecf..a80cea45 100644 --- a/SabreTools.Serialization.Readers/VBSP.cs +++ b/SabreTools.Serialization.Readers/VBSP.cs @@ -61,203 +61,203 @@ namespace SabreTools.Serialization.Readers data.SeekIfPossible(initialOffset + lumpEntry.Offset, SeekOrigin.Begin); // Read according to the lump type - switch ((LumpType)l) + switch ((VbspLumpType)l) { - case LumpType.LUMP_ENTITIES: + case VbspLumpType.LUMP_ENTITIES: file.Entities = ParseEntitiesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_PLANES: + case VbspLumpType.LUMP_PLANES: file.PlanesLump = ParsePlanesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_TEXTURES: + case VbspLumpType.LUMP_TEXTURES: file.TexdataLump = ParseTexdataLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_VERTICES: + case VbspLumpType.LUMP_VERTICES: file.VerticesLump = ParseVerticesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_VISIBILITY: + case VbspLumpType.LUMP_VISIBILITY: file.VisibilityLump = ParseVisibilityLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_NODES: + case VbspLumpType.LUMP_NODES: file.NodesLump = ParseNodesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_TEXINFO: + case VbspLumpType.LUMP_TEXINFO: file.TexinfoLump = ParseTexinfoLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_FACES: + case VbspLumpType.LUMP_FACES: file.FacesLump = ParseFacesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LIGHTING: + case VbspLumpType.LUMP_LIGHTING: file.LightmapLump = ParseLightmapLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_CLIPNODES: + case VbspLumpType.LUMP_CLIPNODES: file.OcclusionLump = ParseOcclusionLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAVES: + case VbspLumpType.LUMP_LEAVES: file.LeavesLump = ParseLeavesLump(data, lumpEntry.Version, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_MARKSURFACES: + case VbspLumpType.LUMP_MARKSURFACES: file.MarksurfacesLump = ParseMarksurfacesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_EDGES: + case VbspLumpType.LUMP_EDGES: file.EdgesLump = ParseEdgesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_SURFEDGES: + case VbspLumpType.LUMP_SURFEDGES: file.SurfedgesLump = ParseSurfedgesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_MODELS: + case VbspLumpType.LUMP_MODELS: file.ModelsLump = ParseModelsLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_WORLDLIGHTS: + case VbspLumpType.LUMP_WORLDLIGHTS: file.LDRWorldLightsLump = ParseWorldLightsLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAFFACES: + case VbspLumpType.LUMP_LEAFFACES: file.LeafFacesLump = ParseLeafFacesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAFBRUSHES: + case VbspLumpType.LUMP_LEAFBRUSHES: file.LeafBrushesLump = ParseLeafBrushesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_BRUSHES: + case VbspLumpType.LUMP_BRUSHES: file.BrushesLump = ParseBrushesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_BRUSHSIDES: + case VbspLumpType.LUMP_BRUSHSIDES: file.BrushsidesLump = ParseBrushsidesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_AREAS: + case VbspLumpType.LUMP_AREAS: // TODO: Support LUMP_AREAS [20] when in Models break; - case LumpType.LUMP_AREAPORTALS: + case VbspLumpType.LUMP_AREAPORTALS: // TODO: Support LUMP_AREAPORTALS [21] when in Models break; - case LumpType.LUMP_PORTALS: + case VbspLumpType.LUMP_PORTALS: // TODO: Support LUMP_PORTALS / LUMP_UNUSED0 / LUMP_PROPCOLLISION [22] when in Models break; - case LumpType.LUMP_CLUSTERS: + case VbspLumpType.LUMP_CLUSTERS: // TODO: Support LUMP_CLUSTERS / LUMP_UNUSED1 / LUMP_PROPHULLS [23] when in Models break; - case LumpType.LUMP_PORTALVERTS: + case VbspLumpType.LUMP_PORTALVERTS: // TODO: Support LUMP_PORTALVERTS / LUMP_UNUSED2 / LUMP_FAKEENTITIES / LUMP_PROPHULLVERTS [24] when in Models break; - case LumpType.LUMP_CLUSTERPORTALS: + case VbspLumpType.LUMP_CLUSTERPORTALS: // TODO: Support LUMP_CLUSTERPORTALS / LUMP_UNUSED3 / LUMP_PROPTRIS [25] when in Models break; - case LumpType.LUMP_DISPINFO: + case VbspLumpType.LUMP_DISPINFO: file.DispInfosLump = ParseDispInfosLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_ORIGINALFACES: + case VbspLumpType.LUMP_ORIGINALFACES: file.OriginalFacesLump = ParseFacesLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_PHYSDISP: + case VbspLumpType.LUMP_PHYSDISP: // TODO: Support LUMP_PHYSDISP [28] when in Models break; - case LumpType.LUMP_PHYSCOLLIDE: + case VbspLumpType.LUMP_PHYSCOLLIDE: file.PhysCollideLump = ParsePhysCollideLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_VERTNORMALS: + case VbspLumpType.LUMP_VERTNORMALS: // TODO: Support LUMP_VERTNORMALS [30] when in Models break; - case LumpType.LUMP_VERTNORMALINDICES: + case VbspLumpType.LUMP_VERTNORMALINDICES: // TODO: Support LUMP_VERTNORMALINDICES [31] when in Models break; - case LumpType.LUMP_DISP_LIGHTMAP_ALPHAS: + case VbspLumpType.LUMP_DISP_LIGHTMAP_ALPHAS: // TODO: Support LUMP_DISP_LIGHTMAP_ALPHAS [32] when in Models break; - case LumpType.LUMP_DISP_VERTS: + case VbspLumpType.LUMP_DISP_VERTS: file.DispVertsLump = ParseDispVertsLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS: + case VbspLumpType.LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS: // TODO: Support LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS [34] when in Models break; - case LumpType.LUMP_GAME_LUMP: + case VbspLumpType.LUMP_GAME_LUMP: file.GameLump = ParseGameLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAFWATERDATA: + case VbspLumpType.LUMP_LEAFWATERDATA: // TODO: Support LUMP_LEAFWATERDATA [36] when in Models break; - case LumpType.LUMP_PRIMITIVES: + case VbspLumpType.LUMP_PRIMITIVES: // TODO: Support LUMP_PRIMITIVES [37] when in Models break; - case LumpType.LUMP_PRIMVERTS: + case VbspLumpType.LUMP_PRIMVERTS: // TODO: Support LUMP_PRIMVERTS [38] when in Models break; - case LumpType.LUMP_PRIMINDICES: + case VbspLumpType.LUMP_PRIMINDICES: // TODO: Support LUMP_PRIMINDICES [39] when in Models break; - case LumpType.LUMP_PAKFILE: + case VbspLumpType.LUMP_PAKFILE: file.PakfileLump = ParsePakfileLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_CLIPPORTALVERTS: + case VbspLumpType.LUMP_CLIPPORTALVERTS: // TODO: Support LUMP_CLIPPORTALVERTS [41] when in Models break; - case LumpType.LUMP_CUBEMAPS: + case VbspLumpType.LUMP_CUBEMAPS: file.CubemapsLump = ParseCubemapsLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_TEXDATA_STRING_DATA: + case VbspLumpType.LUMP_TEXDATA_STRING_DATA: file.TexdataStringData = ParseTexdataStringData(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_TEXDATA_STRING_TABLE: + case VbspLumpType.LUMP_TEXDATA_STRING_TABLE: file.TexdataStringTable = ParseTexdataStringTable(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_OVERLAYS: + case VbspLumpType.LUMP_OVERLAYS: file.OverlaysLump = ParseOverlaysLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAFMINDISTTOWATER: + case VbspLumpType.LUMP_LEAFMINDISTTOWATER: // TODO: Support LUMP_LEAFMINDISTTOWATER [46] when in Models break; - case LumpType.LUMP_FACE_MACRO_TEXTURE_INFO: + case VbspLumpType.LUMP_FACE_MACRO_TEXTURE_INFO: // TODO: Support LUMP_FACE_MACRO_TEXTURE_INFO [47] when in Models break; - case LumpType.LUMP_DISP_TRIS: + case VbspLumpType.LUMP_DISP_TRIS: file.DispTrisLump = ParseDispTrisLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_PHYSCOLLIDESURFACE: + case VbspLumpType.LUMP_PHYSCOLLIDESURFACE: // TODO: Support LUMP_PHYSCOLLIDESURFACE / LUMP_PROP_BLOB [49] when in Models break; - case LumpType.LUMP_WATEROVERLAYS: + case VbspLumpType.LUMP_WATEROVERLAYS: // TODO: Support LUMP_WATEROVERLAYS [50] when in Models break; - case LumpType.LUMP_LIGHTMAPPAGES: + case VbspLumpType.LUMP_LIGHTMAPPAGES: file.HDRAmbientIndexLump = ParseAmbientIndexLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LIGHTMAPPAGEINFOS: + case VbspLumpType.LUMP_LIGHTMAPPAGEINFOS: file.LDRAmbientIndexLump = ParseAmbientIndexLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LIGHTING_HDR: + case VbspLumpType.LUMP_LIGHTING_HDR: // TODO: Support LUMP_LIGHTING_HDR [53] when in Models break; - case LumpType.LUMP_WORLDLIGHTS_HDR: + case VbspLumpType.LUMP_WORLDLIGHTS_HDR: file.HDRWorldLightsLump = ParseWorldLightsLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAF_AMBIENT_LIGHTING_HDR: + case VbspLumpType.LUMP_LEAF_AMBIENT_LIGHTING_HDR: file.HDRAmbientLightingLump = ParseAmbientLightingLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_LEAF_AMBIENT_LIGHTING: + case VbspLumpType.LUMP_LEAF_AMBIENT_LIGHTING: file.LDRAmbientLightingLump = ParseAmbientLightingLump(data, lumpEntry.Offset, lumpEntry.Length); break; - case LumpType.LUMP_XZIPPAKFILE: + case VbspLumpType.LUMP_XZIPPAKFILE: // TODO: Support LUMP_XZIPPAKFILE [57] when in Models break; - case LumpType.LUMP_FACES_HDR: + case VbspLumpType.LUMP_FACES_HDR: // TODO: Support LUMP_FACES_HDR [58] when in Models break; - case LumpType.LUMP_MAP_FLAGS: + case VbspLumpType.LUMP_MAP_FLAGS: // TODO: Support LUMP_MAP_FLAGS [59] when in Models break; - case LumpType.LUMP_OVERLAY_FADES: + case VbspLumpType.LUMP_OVERLAY_FADES: // TODO: Support LUMP_OVERLAY_FADES [60] when in Models break; - case LumpType.LUMP_OVERLAY_SYSTEM_LEVELS: + case VbspLumpType.LUMP_OVERLAY_SYSTEM_LEVELS: // TODO: Support LUMP_OVERLAY_SYSTEM_LEVELS [61] when in Models break; - case LumpType.LUMP_PHYSLEVEL: + case VbspLumpType.LUMP_PHYSLEVEL: // TODO: Support LUMP_PHYSLEVEL [62] when in Models break; - case LumpType.LUMP_DISP_MULTIBLEND: + case VbspLumpType.LUMP_DISP_MULTIBLEND: // TODO: Support LUMP_DISP_MULTIBLEND [63] when in Models break; default: - // Unsupported LumpType value, ignore + // Unsupported VbspLumpType value, ignore break; } } diff --git a/SabreTools.Wrappers/BSP.Extraction.cs b/SabreTools.Wrappers/BSP.Extraction.cs index ad10f91f..696cbd5d 100644 --- a/SabreTools.Wrappers/BSP.Extraction.cs +++ b/SabreTools.Wrappers/BSP.Extraction.cs @@ -49,12 +49,12 @@ namespace SabreTools.Wrappers // Create the filename string filename = $"lump_{index}.bin"; #pragma warning disable IDE0010 - switch ((LumpType)index) + switch ((BspLumpType)index) { - case LumpType.LUMP_ENTITIES: + case BspLumpType.LUMP_ENTITIES: filename = "entities.ent"; break; - case LumpType.LUMP_TEXTURES: + case BspLumpType.LUMP_TEXTURES: filename = "texture_data.bin"; break; } diff --git a/SabreTools.Wrappers/BSP.Printing.cs b/SabreTools.Wrappers/BSP.Printing.cs index 796f0b3c..293a4470 100644 --- a/SabreTools.Wrappers/BSP.Printing.cs +++ b/SabreTools.Wrappers/BSP.Printing.cs @@ -57,59 +57,57 @@ namespace SabreTools.Wrappers builder.AppendLine(lump.Offset, " Offset"); builder.AppendLine(lump.Length, " Length"); -#pragma warning disable IDE0010 - switch ((LumpType)i) + switch ((BspLumpType)i) { - case LumpType.LUMP_ENTITIES: + case BspLumpType.LUMP_ENTITIES: Print(builder, model.Entities); break; - case LumpType.LUMP_PLANES: + case BspLumpType.LUMP_PLANES: Print(builder, model.PlanesLump); break; - case LumpType.LUMP_TEXTURES: + case BspLumpType.LUMP_TEXTURES: Print(builder, model.TextureLump); break; - case LumpType.LUMP_VERTICES: + case BspLumpType.LUMP_VERTICES: Print(builder, model.VerticesLump); break; - case LumpType.LUMP_VISIBILITY: + case BspLumpType.LUMP_VISIBILITY: Print(builder, model.VisibilityLump); break; - case LumpType.LUMP_NODES: + case BspLumpType.LUMP_NODES: Print(builder, model.NodesLump); break; - case LumpType.LUMP_TEXINFO: + case BspLumpType.LUMP_TEXINFO: Print(builder, model.TexinfoLump); break; - case LumpType.LUMP_FACES: + case BspLumpType.LUMP_FACES: Print(builder, model.FacesLump); break; - case LumpType.LUMP_LIGHTING: + case BspLumpType.LUMP_LIGHTING: Print(builder, model.LightmapLump); break; - case LumpType.LUMP_CLIPNODES: + case BspLumpType.LUMP_CLIPNODES: Print(builder, model.ClipnodesLump); break; - case LumpType.LUMP_LEAVES: + case BspLumpType.LUMP_LEAVES: Print(builder, model.LeavesLump); break; - case LumpType.LUMP_MARKSURFACES: + case BspLumpType.LUMP_MARKSURFACES: Print(builder, model.MarksurfacesLump); break; - case LumpType.LUMP_EDGES: + case BspLumpType.LUMP_EDGES: Print(builder, model.EdgesLump); break; - case LumpType.LUMP_SURFEDGES: + case BspLumpType.LUMP_SURFEDGES: Print(builder, model.SurfedgesLump); break; - case LumpType.LUMP_MODELS: + case BspLumpType.LUMP_MODELS: Print(builder, model.ModelsLump); break; default: - builder.AppendLine($" Unsupported lump type: {(LumpType)i} (0x{i:X4})"); + builder.AppendLine($" Unsupported lump type: {(BspLumpType)i} (0x{i:X4})"); break; } -#pragma warning restore IDE0010 } builder.AppendLine(); @@ -117,27 +115,25 @@ namespace SabreTools.Wrappers private static string GetLumpName(int i) { -#pragma warning disable IDE0072 - return (LumpType)i switch + return (BspLumpType)i switch { - LumpType.LUMP_ENTITIES => " - LUMP_ENTITIES", - LumpType.LUMP_PLANES => " - LUMP_PLANES", - LumpType.LUMP_TEXTURES => " - LUMP_TEXTURES", - LumpType.LUMP_VERTICES => " - LUMP_VERTICES", - LumpType.LUMP_VISIBILITY => " - LUMP_VISIBILITY", - LumpType.LUMP_NODES => " - LUMP_NODES", - LumpType.LUMP_TEXINFO => " - LUMP_TEXINFO", - LumpType.LUMP_FACES => " - LUMP_FACES", - LumpType.LUMP_LIGHTING => " - LUMP_LIGHTING", - LumpType.LUMP_CLIPNODES => " - LUMP_CLIPNODES", - LumpType.LUMP_LEAVES => " - LUMP_LEAVES", - LumpType.LUMP_MARKSURFACES => " - LUMP_MARKSURFACES", - LumpType.LUMP_EDGES => " - LUMP_EDGES", - LumpType.LUMP_SURFEDGES => " - LUMP_SURFEDGES", - LumpType.LUMP_MODELS => " - LUMP_MODELS", + BspLumpType.LUMP_ENTITIES => " - LUMP_ENTITIES", + BspLumpType.LUMP_PLANES => " - LUMP_PLANES", + BspLumpType.LUMP_TEXTURES => " - LUMP_TEXTURES", + BspLumpType.LUMP_VERTICES => " - LUMP_VERTICES", + BspLumpType.LUMP_VISIBILITY => " - LUMP_VISIBILITY", + BspLumpType.LUMP_NODES => " - LUMP_NODES", + BspLumpType.LUMP_TEXINFO => " - LUMP_TEXINFO", + BspLumpType.LUMP_FACES => " - LUMP_FACES", + BspLumpType.LUMP_LIGHTING => " - LUMP_LIGHTING", + BspLumpType.LUMP_CLIPNODES => " - LUMP_CLIPNODES", + BspLumpType.LUMP_LEAVES => " - LUMP_LEAVES", + BspLumpType.LUMP_MARKSURFACES => " - LUMP_MARKSURFACES", + BspLumpType.LUMP_EDGES => " - LUMP_EDGES", + BspLumpType.LUMP_SURFEDGES => " - LUMP_SURFEDGES", + BspLumpType.LUMP_MODELS => " - LUMP_MODELS", _ => string.Empty, }; -#pragma warning restore IDE0072 } private static void Print(StringBuilder builder, EntitiesLump lump) diff --git a/SabreTools.Wrappers/VBSP.Extraction.cs b/SabreTools.Wrappers/VBSP.Extraction.cs index a7296fd1..3710ee0f 100644 --- a/SabreTools.Wrappers/VBSP.Extraction.cs +++ b/SabreTools.Wrappers/VBSP.Extraction.cs @@ -53,12 +53,12 @@ namespace SabreTools.Wrappers // Create the filename string filename = $"lump_{index}.bin"; #pragma warning disable IDE0010 - switch ((LumpType)index) + switch ((VbspLumpType)index) { - case LumpType.LUMP_ENTITIES: + case VbspLumpType.LUMP_ENTITIES: filename = "entities.ent"; break; - case LumpType.LUMP_PAKFILE: + case VbspLumpType.LUMP_PAKFILE: filename = "pakfile.zip"; break; } diff --git a/SabreTools.Wrappers/VBSP.Printing.cs b/SabreTools.Wrappers/VBSP.Printing.cs index d08b6dd8..67e67f44 100644 --- a/SabreTools.Wrappers/VBSP.Printing.cs +++ b/SabreTools.Wrappers/VBSP.Printing.cs @@ -52,231 +52,231 @@ namespace SabreTools.Wrappers builder.AppendLine(lump.Offset, " Offset"); builder.AppendLine(lump.Length, " Length"); - switch ((LumpType)i) + switch ((VbspLumpType)i) { - case LumpType.LUMP_ENTITIES: + case VbspLumpType.LUMP_ENTITIES: Print(builder, model.Entities); break; - case LumpType.LUMP_PLANES: + case VbspLumpType.LUMP_PLANES: Print(builder, model.PlanesLump); break; - case LumpType.LUMP_TEXTURES: + case VbspLumpType.LUMP_TEXTURES: Print(builder, model.TexdataLump); break; - case LumpType.LUMP_VERTICES: + case VbspLumpType.LUMP_VERTICES: Print(builder, model.VerticesLump); break; - case LumpType.LUMP_VISIBILITY: + case VbspLumpType.LUMP_VISIBILITY: Print(builder, model.VisibilityLump); break; - case LumpType.LUMP_NODES: + case VbspLumpType.LUMP_NODES: Print(builder, model.NodesLump); break; - case LumpType.LUMP_TEXINFO: + case VbspLumpType.LUMP_TEXINFO: Print(builder, model.TexinfoLump); break; - case LumpType.LUMP_FACES: + case VbspLumpType.LUMP_FACES: Print(builder, model.FacesLump); break; - case LumpType.LUMP_LIGHTING: + case VbspLumpType.LUMP_LIGHTING: Print(builder, model.LightmapLump); break; - case LumpType.LUMP_CLIPNODES: + case VbspLumpType.LUMP_CLIPNODES: Print(builder, model.OcclusionLump); break; - case LumpType.LUMP_LEAVES: + case VbspLumpType.LUMP_LEAVES: Print(builder, model.LeavesLump, lump.Version); break; - case LumpType.LUMP_MARKSURFACES: + case VbspLumpType.LUMP_MARKSURFACES: Print(builder, model.MarksurfacesLump); break; - case LumpType.LUMP_EDGES: + case VbspLumpType.LUMP_EDGES: Print(builder, model.EdgesLump); break; - case LumpType.LUMP_SURFEDGES: + case VbspLumpType.LUMP_SURFEDGES: Print(builder, model.SurfedgesLump); break; - case LumpType.LUMP_MODELS: + case VbspLumpType.LUMP_MODELS: Print(builder, model.ModelsLump); break; - case LumpType.LUMP_WORLDLIGHTS: + case VbspLumpType.LUMP_WORLDLIGHTS: Print(builder, model.LDRWorldLightsLump); break; - case LumpType.LUMP_LEAFFACES: + case VbspLumpType.LUMP_LEAFFACES: Print(builder, model.LeafFacesLump); break; - case LumpType.LUMP_LEAFBRUSHES: + case VbspLumpType.LUMP_LEAFBRUSHES: Print(builder, model.LeafBrushesLump); break; - case LumpType.LUMP_BRUSHES: + case VbspLumpType.LUMP_BRUSHES: Print(builder, model.BrushesLump); break; - case LumpType.LUMP_BRUSHSIDES: + case VbspLumpType.LUMP_BRUSHSIDES: Print(builder, model.BrushsidesLump); break; - case LumpType.LUMP_AREAS: + case VbspLumpType.LUMP_AREAS: // TODO: Support LUMP_AREAS [20] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_AREAPORTALS: + case VbspLumpType.LUMP_AREAPORTALS: // TODO: Support LUMP_AREAPORTALS [21] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PORTALS: + case VbspLumpType.LUMP_PORTALS: // TODO: Support LUMP_PORTALS / LUMP_UNUSED0 / LUMP_PROPCOLLISION [22] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_CLUSTERS: + case VbspLumpType.LUMP_CLUSTERS: // TODO: Support LUMP_CLUSTERS / LUMP_UNUSED1 / LUMP_PROPHULLS [23] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PORTALVERTS: + case VbspLumpType.LUMP_PORTALVERTS: // TODO: Support LUMP_PORTALVERTS / LUMP_UNUSED2 / LUMP_FAKEENTITIES / LUMP_PROPHULLVERTS [24] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_CLUSTERPORTALS: + case VbspLumpType.LUMP_CLUSTERPORTALS: // TODO: Support LUMP_CLUSTERPORTALS / LUMP_UNUSED3 / LUMP_PROPTRIS [25] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_DISPINFO: + case VbspLumpType.LUMP_DISPINFO: Print(builder, model.DispInfosLump); break; - case LumpType.LUMP_ORIGINALFACES: + case VbspLumpType.LUMP_ORIGINALFACES: Print(builder, model.OriginalFacesLump); break; - case LumpType.LUMP_PHYSDISP: + case VbspLumpType.LUMP_PHYSDISP: // TODO: Support LUMP_PHYSDISP [28] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PHYSCOLLIDE: + case VbspLumpType.LUMP_PHYSCOLLIDE: Print(builder, model.PhysCollideLump); break; - case LumpType.LUMP_VERTNORMALS: + case VbspLumpType.LUMP_VERTNORMALS: // TODO: Support LUMP_VERTNORMALS [30] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_VERTNORMALINDICES: + case VbspLumpType.LUMP_VERTNORMALINDICES: // TODO: Support LUMP_VERTNORMALINDICES [31] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_DISP_LIGHTMAP_ALPHAS: + case VbspLumpType.LUMP_DISP_LIGHTMAP_ALPHAS: // TODO: Support LUMP_DISP_LIGHTMAP_ALPHAS [32] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_DISP_VERTS: + case VbspLumpType.LUMP_DISP_VERTS: Print(builder, model.DispVertsLump); break; - case LumpType.LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS: + case VbspLumpType.LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS: // TODO: Support LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS [34] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_GAME_LUMP: + case VbspLumpType.LUMP_GAME_LUMP: Print(builder, model.GameLump); break; - case LumpType.LUMP_LEAFWATERDATA: + case VbspLumpType.LUMP_LEAFWATERDATA: // TODO: Support LUMP_LEAFWATERDATA [36] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PRIMITIVES: + case VbspLumpType.LUMP_PRIMITIVES: // TODO: Support LUMP_PRIMITIVES [37] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PRIMVERTS: + case VbspLumpType.LUMP_PRIMVERTS: // TODO: Support LUMP_PRIMVERTS [38] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PRIMINDICES: + case VbspLumpType.LUMP_PRIMINDICES: // TODO: Support LUMP_PRIMINDICES [39] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PAKFILE: + case VbspLumpType.LUMP_PAKFILE: Print(builder, model.PakfileLump); break; - case LumpType.LUMP_CLIPPORTALVERTS: + case VbspLumpType.LUMP_CLIPPORTALVERTS: // TODO: Support LUMP_CLIPPORTALVERTS [41] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_CUBEMAPS: + case VbspLumpType.LUMP_CUBEMAPS: Print(builder, model.CubemapsLump); break; - case LumpType.LUMP_TEXDATA_STRING_DATA: + case VbspLumpType.LUMP_TEXDATA_STRING_DATA: Print(builder, model.TexdataStringData); break; - case LumpType.LUMP_TEXDATA_STRING_TABLE: + case VbspLumpType.LUMP_TEXDATA_STRING_TABLE: Print(builder, model.TexdataStringTable); break; - case LumpType.LUMP_OVERLAYS: + case VbspLumpType.LUMP_OVERLAYS: Print(builder, model.OverlaysLump); break; - case LumpType.LUMP_LEAFMINDISTTOWATER: + case VbspLumpType.LUMP_LEAFMINDISTTOWATER: // TODO: Support LUMP_LEAFMINDISTTOWATER [46] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_FACE_MACRO_TEXTURE_INFO: + case VbspLumpType.LUMP_FACE_MACRO_TEXTURE_INFO: // TODO: Support LUMP_FACE_MACRO_TEXTURE_INFO [47] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_DISP_TRIS: + case VbspLumpType.LUMP_DISP_TRIS: Print(builder, model.DispTrisLump); break; - case LumpType.LUMP_PHYSCOLLIDESURFACE: + case VbspLumpType.LUMP_PHYSCOLLIDESURFACE: // TODO: Support LUMP_PHYSCOLLIDESURFACE / LUMP_PROP_BLOB [49] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_WATEROVERLAYS: + case VbspLumpType.LUMP_WATEROVERLAYS: // TODO: Support LUMP_WATEROVERLAYS [50] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_LIGHTMAPPAGES: + case VbspLumpType.LUMP_LIGHTMAPPAGES: Print(builder, model.HDRAmbientIndexLump); break; - case LumpType.LUMP_LIGHTMAPPAGEINFOS: + case VbspLumpType.LUMP_LIGHTMAPPAGEINFOS: Print(builder, model.LDRAmbientIndexLump); break; - case LumpType.LUMP_LIGHTING_HDR: + case VbspLumpType.LUMP_LIGHTING_HDR: // TODO: Support LUMP_LIGHTING_HDR [53] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_WORLDLIGHTS_HDR: + case VbspLumpType.LUMP_WORLDLIGHTS_HDR: Print(builder, model.HDRWorldLightsLump); break; - case LumpType.LUMP_LEAF_AMBIENT_LIGHTING_HDR: + case VbspLumpType.LUMP_LEAF_AMBIENT_LIGHTING_HDR: Print(builder, model.HDRAmbientLightingLump); break; - case LumpType.LUMP_LEAF_AMBIENT_LIGHTING: + case VbspLumpType.LUMP_LEAF_AMBIENT_LIGHTING: Print(builder, model.LDRAmbientLightingLump); break; - case LumpType.LUMP_XZIPPAKFILE: + case VbspLumpType.LUMP_XZIPPAKFILE: // TODO: Support LUMP_XZIPPAKFILE [57] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_FACES_HDR: + case VbspLumpType.LUMP_FACES_HDR: // TODO: Support LUMP_FACES_HDR [58] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_MAP_FLAGS: + case VbspLumpType.LUMP_MAP_FLAGS: // TODO: Support LUMP_MAP_FLAGS [59] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_OVERLAY_FADES: + case VbspLumpType.LUMP_OVERLAY_FADES: // TODO: Support LUMP_OVERLAY_FADES [60] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_OVERLAY_SYSTEM_LEVELS: + case VbspLumpType.LUMP_OVERLAY_SYSTEM_LEVELS: // TODO: Support LUMP_OVERLAY_SYSTEM_LEVELS [61] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_PHYSLEVEL: + case VbspLumpType.LUMP_PHYSLEVEL: // TODO: Support LUMP_PHYSLEVEL [62] when in Models builder.AppendLine(" Data not parsed..."); break; - case LumpType.LUMP_DISP_MULTIBLEND: + case VbspLumpType.LUMP_DISP_MULTIBLEND: // TODO: Support LUMP_DISP_MULTIBLEND [63] when in Models builder.AppendLine(" Data not parsed..."); break; default: - builder.AppendLine($" Unsupported lump type: {(LumpType)i} (0x{i:X4})"); + builder.AppendLine($" Unsupported lump type: {(VbspLumpType)i} (0x{i:X4})"); break; } } @@ -286,72 +286,72 @@ namespace SabreTools.Wrappers private static string GetLumpName(int i) { - return (LumpType)i switch + return (VbspLumpType)i switch { - LumpType.LUMP_ENTITIES => " - LUMP_ENTITIES", - LumpType.LUMP_PLANES => " - LUMP_PLANES", - LumpType.LUMP_TEXTURES => " - LUMP_TEXDATA", - LumpType.LUMP_VERTICES => " - LUMP_VERTEXES", - LumpType.LUMP_VISIBILITY => " - LUMP_VISIBILITY", - LumpType.LUMP_NODES => " - LUMP_NODES", - LumpType.LUMP_TEXINFO => " - LUMP_TEXINFO", - LumpType.LUMP_FACES => " - LUMP_FACES", - LumpType.LUMP_LIGHTING => " - LUMP_LIGHTING", - LumpType.LUMP_CLIPNODES => " - LUMP_OCCLUSION", - LumpType.LUMP_LEAVES => " - LUMP_LEAVES", - LumpType.LUMP_MARKSURFACES => " - LUMP_FACEIDS", - LumpType.LUMP_EDGES => " - LUMP_EDGES", - LumpType.LUMP_SURFEDGES => " - LUMP_SURFEDGES", - LumpType.LUMP_MODELS => " - LUMP_MODELS", - LumpType.LUMP_WORLDLIGHTS => " - LUMP_WORLDLIGHTS", - LumpType.LUMP_LEAFFACES => " - LUMP_LEAFFACES", - LumpType.LUMP_LEAFBRUSHES => " - LUMP_LEAFBRUSHES", - LumpType.LUMP_BRUSHES => " - LUMP_BRUSHES", - LumpType.LUMP_BRUSHSIDES => " - LUMP_BRUSHSIDES", - LumpType.LUMP_AREAS => " - LUMP_AREAS", - LumpType.LUMP_AREAPORTALS => " - LUMP_AREAPORTALS", - LumpType.LUMP_PORTALS => " - LUMP_PORTALS / LUMP_UNUSED0 / LUMP_PROPCOLLISION", - LumpType.LUMP_CLUSTERS => " - LUMP_CLUSTERS / LUMP_UNUSED1 / LUMP_PROPHULLS", - LumpType.LUMP_PORTALVERTS => " - LUMP_PORTALVERTS / LUMP_UNUSED2 / LUMP_FAKEENTITIES / LUMP_PROPHULLVERTS", - LumpType.LUMP_CLUSTERPORTALS => " - LUMP_CLUSTERPORTALS / LUMP_UNUSED3 / LUMP_PROPTRIS", - LumpType.LUMP_DISPINFO => " - LUMP_DISPINFO", - LumpType.LUMP_ORIGINALFACES => " - LUMP_ORIGINALFACES", - LumpType.LUMP_PHYSDISP => " - LUMP_PHYSDISP", - LumpType.LUMP_PHYSCOLLIDE => " - LUMP_PHYSCOLLIDE", - LumpType.LUMP_VERTNORMALS => " - LUMP_VERTNORMALS", - LumpType.LUMP_VERTNORMALINDICES => " - LUMP_VERTNORMALINDICES", - LumpType.LUMP_DISP_LIGHTMAP_ALPHAS => " - LUMP_DISP_LIGHTMAP_ALPHAS", - LumpType.LUMP_DISP_VERTS => " - LUMP_DISP_VERTS", - LumpType.LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS => " - LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS", - LumpType.LUMP_GAME_LUMP => " - LUMP_GAME_LUMP", - LumpType.LUMP_LEAFWATERDATA => " - LUMP_LEAFWATERDATA", - LumpType.LUMP_PRIMITIVES => " - LUMP_PRIMITIVES", - LumpType.LUMP_PRIMVERTS => " - LUMP_PRIMVERTS", - LumpType.LUMP_PRIMINDICES => " - LUMP_PRIMINDICES", - LumpType.LUMP_PAKFILE => " - LUMP_PAKFILE", - LumpType.LUMP_CLIPPORTALVERTS => " - LUMP_CLIPPORTALVERTS", - LumpType.LUMP_CUBEMAPS => " - LUMP_CUBEMAPS", - LumpType.LUMP_TEXDATA_STRING_DATA => " - LUMP_TEXDATA_STRING_DATA", - LumpType.LUMP_TEXDATA_STRING_TABLE => " - LUMP_TEXDATA_STRING_TABLE", - LumpType.LUMP_OVERLAYS => " - LUMP_OVERLAYS", - LumpType.LUMP_LEAFMINDISTTOWATER => " - LUMP_LEAFMINDISTTOWATER", - LumpType.LUMP_FACE_MACRO_TEXTURE_INFO => " - LUMP_FACE_MACRO_TEXTURE_INFO", - LumpType.LUMP_DISP_TRIS => " - LUMP_DISP_TRIS", - LumpType.LUMP_PHYSCOLLIDESURFACE => " - LUMP_PHYSCOLLIDESURFACE / LUMP_PROP_BLOB", - LumpType.LUMP_WATEROVERLAYS => " - LUMP_WATEROVERLAYS", - LumpType.LUMP_LIGHTMAPPAGES => " - LUMP_LIGHTMAPPAGES / LUMP_LEAF_AMBIENT_INDEX_HDR", - LumpType.LUMP_LIGHTMAPPAGEINFOS => " - LUMP_LIGHTMAPPAGEINFOS / LUMP_LEAF_AMBIENT_INDEX", - LumpType.LUMP_LIGHTING_HDR => " - LUMP_LIGHTING_HDR", - LumpType.LUMP_WORLDLIGHTS_HDR => " - LUMP_WORLDLIGHTS_HDR", - LumpType.LUMP_LEAF_AMBIENT_LIGHTING_HDR => " - LUMP_LEAF_AMBIENT_LIGHTING_HDR", - LumpType.LUMP_LEAF_AMBIENT_LIGHTING => " - LUMP_LEAF_AMBIENT_LIGHTING", - LumpType.LUMP_XZIPPAKFILE => " - LUMP_XZIPPAKFILE", - LumpType.LUMP_FACES_HDR => " - LUMP_FACES_HDR", - LumpType.LUMP_MAP_FLAGS => " - LUMP_MAP_FLAGS", - LumpType.LUMP_OVERLAY_FADES => " - LUMP_OVERLAY_FADES", - LumpType.LUMP_OVERLAY_SYSTEM_LEVELS => " - LUMP_OVERLAY_SYSTEM_LEVELS", - LumpType.LUMP_PHYSLEVEL => " - LUMP_PHYSLEVEL", - LumpType.LUMP_DISP_MULTIBLEND => " - LUMP_DISP_MULTIBLEND", + VbspLumpType.LUMP_ENTITIES => " - LUMP_ENTITIES", + VbspLumpType.LUMP_PLANES => " - LUMP_PLANES", + VbspLumpType.LUMP_TEXTURES => " - LUMP_TEXDATA", + VbspLumpType.LUMP_VERTICES => " - LUMP_VERTEXES", + VbspLumpType.LUMP_VISIBILITY => " - LUMP_VISIBILITY", + VbspLumpType.LUMP_NODES => " - LUMP_NODES", + VbspLumpType.LUMP_TEXINFO => " - LUMP_TEXINFO", + VbspLumpType.LUMP_FACES => " - LUMP_FACES", + VbspLumpType.LUMP_LIGHTING => " - LUMP_LIGHTING", + VbspLumpType.LUMP_CLIPNODES => " - LUMP_OCCLUSION", + VbspLumpType.LUMP_LEAVES => " - LUMP_LEAVES", + VbspLumpType.LUMP_MARKSURFACES => " - LUMP_FACEIDS", + VbspLumpType.LUMP_EDGES => " - LUMP_EDGES", + VbspLumpType.LUMP_SURFEDGES => " - LUMP_SURFEDGES", + VbspLumpType.LUMP_MODELS => " - LUMP_MODELS", + VbspLumpType.LUMP_WORLDLIGHTS => " - LUMP_WORLDLIGHTS", + VbspLumpType.LUMP_LEAFFACES => " - LUMP_LEAFFACES", + VbspLumpType.LUMP_LEAFBRUSHES => " - LUMP_LEAFBRUSHES", + VbspLumpType.LUMP_BRUSHES => " - LUMP_BRUSHES", + VbspLumpType.LUMP_BRUSHSIDES => " - LUMP_BRUSHSIDES", + VbspLumpType.LUMP_AREAS => " - LUMP_AREAS", + VbspLumpType.LUMP_AREAPORTALS => " - LUMP_AREAPORTALS", + VbspLumpType.LUMP_PORTALS => " - LUMP_PORTALS / LUMP_UNUSED0 / LUMP_PROPCOLLISION", + VbspLumpType.LUMP_CLUSTERS => " - LUMP_CLUSTERS / LUMP_UNUSED1 / LUMP_PROPHULLS", + VbspLumpType.LUMP_PORTALVERTS => " - LUMP_PORTALVERTS / LUMP_UNUSED2 / LUMP_FAKEENTITIES / LUMP_PROPHULLVERTS", + VbspLumpType.LUMP_CLUSTERPORTALS => " - LUMP_CLUSTERPORTALS / LUMP_UNUSED3 / LUMP_PROPTRIS", + VbspLumpType.LUMP_DISPINFO => " - LUMP_DISPINFO", + VbspLumpType.LUMP_ORIGINALFACES => " - LUMP_ORIGINALFACES", + VbspLumpType.LUMP_PHYSDISP => " - LUMP_PHYSDISP", + VbspLumpType.LUMP_PHYSCOLLIDE => " - LUMP_PHYSCOLLIDE", + VbspLumpType.LUMP_VERTNORMALS => " - LUMP_VERTNORMALS", + VbspLumpType.LUMP_VERTNORMALINDICES => " - LUMP_VERTNORMALINDICES", + VbspLumpType.LUMP_DISP_LIGHTMAP_ALPHAS => " - LUMP_DISP_LIGHTMAP_ALPHAS", + VbspLumpType.LUMP_DISP_VERTS => " - LUMP_DISP_VERTS", + VbspLumpType.LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS => " - LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS", + VbspLumpType.LUMP_GAME_LUMP => " - LUMP_GAME_LUMP", + VbspLumpType.LUMP_LEAFWATERDATA => " - LUMP_LEAFWATERDATA", + VbspLumpType.LUMP_PRIMITIVES => " - LUMP_PRIMITIVES", + VbspLumpType.LUMP_PRIMVERTS => " - LUMP_PRIMVERTS", + VbspLumpType.LUMP_PRIMINDICES => " - LUMP_PRIMINDICES", + VbspLumpType.LUMP_PAKFILE => " - LUMP_PAKFILE", + VbspLumpType.LUMP_CLIPPORTALVERTS => " - LUMP_CLIPPORTALVERTS", + VbspLumpType.LUMP_CUBEMAPS => " - LUMP_CUBEMAPS", + VbspLumpType.LUMP_TEXDATA_STRING_DATA => " - LUMP_TEXDATA_STRING_DATA", + VbspLumpType.LUMP_TEXDATA_STRING_TABLE => " - LUMP_TEXDATA_STRING_TABLE", + VbspLumpType.LUMP_OVERLAYS => " - LUMP_OVERLAYS", + VbspLumpType.LUMP_LEAFMINDISTTOWATER => " - LUMP_LEAFMINDISTTOWATER", + VbspLumpType.LUMP_FACE_MACRO_TEXTURE_INFO => " - LUMP_FACE_MACRO_TEXTURE_INFO", + VbspLumpType.LUMP_DISP_TRIS => " - LUMP_DISP_TRIS", + VbspLumpType.LUMP_PHYSCOLLIDESURFACE => " - LUMP_PHYSCOLLIDESURFACE / LUMP_PROP_BLOB", + VbspLumpType.LUMP_WATEROVERLAYS => " - LUMP_WATEROVERLAYS", + VbspLumpType.LUMP_LIGHTMAPPAGES => " - LUMP_LIGHTMAPPAGES / LUMP_LEAF_AMBIENT_INDEX_HDR", + VbspLumpType.LUMP_LIGHTMAPPAGEINFOS => " - LUMP_LIGHTMAPPAGEINFOS / LUMP_LEAF_AMBIENT_INDEX", + VbspLumpType.LUMP_LIGHTING_HDR => " - LUMP_LIGHTING_HDR", + VbspLumpType.LUMP_WORLDLIGHTS_HDR => " - LUMP_WORLDLIGHTS_HDR", + VbspLumpType.LUMP_LEAF_AMBIENT_LIGHTING_HDR => " - LUMP_LEAF_AMBIENT_LIGHTING_HDR", + VbspLumpType.LUMP_LEAF_AMBIENT_LIGHTING => " - LUMP_LEAF_AMBIENT_LIGHTING", + VbspLumpType.LUMP_XZIPPAKFILE => " - LUMP_XZIPPAKFILE", + VbspLumpType.LUMP_FACES_HDR => " - LUMP_FACES_HDR", + VbspLumpType.LUMP_MAP_FLAGS => " - LUMP_MAP_FLAGS", + VbspLumpType.LUMP_OVERLAY_FADES => " - LUMP_OVERLAY_FADES", + VbspLumpType.LUMP_OVERLAY_SYSTEM_LEVELS => " - LUMP_OVERLAY_SYSTEM_LEVELS", + VbspLumpType.LUMP_PHYSLEVEL => " - LUMP_PHYSLEVEL", + VbspLumpType.LUMP_DISP_MULTIBLEND => " - LUMP_DISP_MULTIBLEND", _ => string.Empty, }; }