l-proger/FirstStrike.Unity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
FirstStrike.Unity/Assets/Editor/SourceBSPStructs.cs
T

1302 lines
43 KiB
C#
Raw Permalink Normal View History

*
2025-05-13 03:08:33 +03:00
using SourceFormatParser.Common;
using System;
using System.Collections.Generic;
namespace SourceFormatParser.BSP
{
/// <summary>
/// source2013: public/bspfile.h
/// dheader_t
/// lump_t
/// </summary>
public class SourceBSPStructs
{
public const byte HEADER_LUMPS = 64;
public const int IDBSPHEADER = ('P' << 24) + ('S' << 16) + ('B' << 8) + 'V';
public const ushort OVERLAY_BSP_FACE_COUNT = 64;
public const int OVERLAY_NUM_RENDER_ORDERS = (1 << OVERLAY_RENDER_ORDER_NUM_BITS);
public const byte OVERLAY_RENDER_ORDER_NUM_BITS = 2;
public const int OVERLAY_RENDER_ORDER_MASK = 0xC000; // top 2 bits set
public const ushort WATEROVERLAY_BSP_FACE_COUNT = 256;
public const byte WATEROVERLAY_RENDER_ORDER_NUM_BITS = 2;
public const int WATEROVERLAY_NUM_RENDER_ORDERS = (1 << WATEROVERLAY_RENDER_ORDER_NUM_BITS);
public const int WATEROVERLAY_RENDER_ORDER_MASK = 0xC000; // top 2 bits set
public const int MAX_LIGHTMAPPAGE_WIDTH = 256;
public const int MAX_LIGHTMAPPAGE_HEIGHT = 128;
public struct SurfaceFlags
{
public const int SURF_LIGHT = 0x0001; // value will hold the light strength
public const int SURF_SKY2D = 0x0002; // don't draw, indicates we should skylight + draw 2d sky but not draw the 3D skybox
public const int SURF_SKY = 0x0004; // don't draw, but add to skybox
public const int SURF_WARP = 0x0008; // turbulent water warp
public const int SURF_TRANS = 0x0010;
public const int SURF_NOPORTAL = 0x0020; // the surface can not have a portal placed on it
public const int SURF_TRIGGER = 0x0040; // FIXME: This is an xbox hack to work around elimination of trigger surfaces, which breaks occluders
public const int SURF_NODRAW = 0x0080; // don't bother referencing the texture
public const int SURF_HINT = 0x0100; // make a primary bsp splitter
public const int SURF_SKIP = 0x0200; // completely ignore, allowing non-closed brushes
public const int SURF_NOLIGHT = 0x0400; // Don't calculate light
public const int SURF_BUMPLIGHT = 0x0800; // calculate three lightmaps for the surface for bumpmapping
public const int SURF_NOSHADOWS = 0x1000; // Don't receive shadows
public const int SURF_NODECALS = 0x2000; // Don't receive decals
public const int SURF_NOCHOP = 0x4000; // Don't subdivide patches on this surface
public const int SURF_HITBOX = 0x8000; // surface is part of a hitbox
}
#region enums
[Flags]
public enum MAP_FLAGS
{
/// <summary>Map was processed by vrad with -staticproplighting, no hdr data</summary>
LVLFLAGS_BAKED_STATIC_PROP_LIGHTING_NONHDR = 0x00000001,
/// <summary>Map was processed by vrad with -staticproplighting, in hdr</summary>
LVLFLAGS_BAKED_STATIC_PROP_LIGHTING_HDR = 0x00000002
}
[Flags]
public enum LEAF_FLAGS
{
// NOTE: Only 7-bits stored!!!
/// <summary>This leaf has 3D sky in its PVS</summary>
LEAF_FLAGS_SKY = 0x01,
/// <summary>This leaf culled away some portals due to radial vis</summary>
LEAF_FLAGS_RADIAL = 0x02,
/// <summary>This leaf has 2D sky in its PVS</summary>
LEAF_FLAGS_SKY2D = 0x04
}
[Flags]
public enum WORLDLIGHT_FLAGS
{
/// <summary>This says that the light was put into the per-leaf ambient cubes.</summary>
DWL_FLAGS_INAMBIENTCUBE = 0x0001,
/// <summary>This says that the light will cast shadows from entities.</summary>
DWL_FLAGS_CASTENTITYSHADOWS = 0x0002
}
[Flags]
public enum emittype_t
{
// lights that were used to illuminate the world
/// <summary>90 degree spotlight</summary>
emit_surface,
/// <summary>simple point light source</summary>
emit_point,
/// <summary>spotlight with penumbra</summary>
emit_spotlight,
/// <summary>directional light with no falloff (surface must trace to SKY texture)</summary>
emit_skylight,
/// <summary>linear falloff, non-lambertian</summary>
emit_quakelight,
/// <summary>spherical light source with no falloff (surface must trace to SKY texture)</summary>
emit_skyambient,
}
[Flags]
public enum Contents
{
// contents flags are seperate bits
// a given brush can contribute multiple content bits
// multiple brushes can be in a single leaf
/// <summary>No contents</summary>
CONTENTS_EMPTY = 0,
/// <summary>an eye is never valid in a solid</summary>
CONTENTS_SOLID = 0x1,
/// <summary>translucent, but not watery (glass)</summary>
CONTENTS_WINDOW = 0x2,
CONTENTS_AUX = 0x4,
/// <summary>alpha-tested "grate" textures. Bullets/sight pass through, but solids don't</summary>
CONTENTS_GRATE = 0x8,
CONTENTS_SLIME = 0x10,
CONTENTS_WATER = 0x20,
/// <summary>block AI line of sight</summary>
CONTENTS_BLOCKLOS = 0x40,
/// <summary>things that cannot be seen through (may be non-solid though)</summary>
CONTENTS_OPAQUE = 0x80,
CONTENTS_TESTFOGVOLUME = 0x100,
CONTENTS_UNUSED = 0x200,
CONTENTS_UNUSED6 = 0x400,
/// <summary>per team contents used to differentiate collisions between players and objects on different teams</summary>
CONTENTS_TEAM1 = 0x800,
/// <summary>per team contents used to differentiate collisions between players and objects on different teams</summary>
CONTENTS_TEAM2 = 0x1000,
/// <summary>ignore CONTENTS_OPAQUE on surfaces that have SURF_NODRAW</summary>
CONTENTS_IGNORE_NODRAW_OPAQUE = 0x2000,
/// <summary>hits entities which are MOVETYPE_PUSH (doors, plats, etc.)</summary>
CONTENTS_MOVEABLE = 0x4000,
/// <summary>remaining contents are non-visible, and don't eat brushes</summary>
CONTENTS_AREAPORTAL = 0x8000,
CONTENTS_PLAYERCLIP = 0x10000,
CONTENTS_MONSTERCLIP = 0x20000,
/// <summary>can be added to any other contents, and may be mixed</summary>
CONTENTS_CURRENT_0 = 0x40000,
/// <summary>can be added to any other contents, and may be mixed</summary>
CONTENTS_CURRENT_90 = 0x80000,
/// <summary>can be added to any other contents, and may be mixed</summary>
CONTENTS_CURRENT_180 = 0x100000,
/// <summary>can be added to any other contents, and may be mixed</summary>
CONTENTS_CURRENT_270 = 0x200000,
/// <summary>can be added to any other contents, and may be mixed</summary>
CONTENTS_CURRENT_UP = 0x400000,
/// <summary>can be added to any other contents, and may be mixed</summary>
CONTENTS_CURRENT_DOWN = 0x800000,
/// <summary>removed before bsping an entity</summary>
CONTENTS_ORIGIN = 0x1000000,
/// <summary>should never be on a brush, only in game</summary>
CONTENTS_MONSTER = 0x2000000,
CONTENTS_DEBRIS = 0x4000000,
/// <summary>brushes to be added after vis leafs</summary>
CONTENTS_DETAIL = 0x8000000,
/// <summary>auto set if any surface has trans</summary>
CONTENTS_TRANSLUCENT = 0x10000000,
CONTENTS_LADDER = 0x20000000,
/// <summary>use accurate hitboxes on trace</summary>
CONTENTS_HITBOX = 0x40000000
}
[Flags]
public enum Surfaces
{
// NOTE: These are stored in a short in the engine now. Don't use more than 16 bits
/// <summary>value will hold the light strength</summary>
SURF_LIGHT = 0x0001,
/// <summary>don't draw, indicates we should skylight + draw 2d sky but not draw the 3D skybox</summary>
SURF_SKY2D = 0x0002,
/// <summary>don't draw, but add to skybox</summary>
SURF_SKY = 0x0004,
/// <summary>turbulent water warp</summary>
SURF_WARP = 0x0008,
SURF_TRANS = 0x0010,
/// <summary>the surface can not have a portal placed on it</summary>
SURF_NOPORTAL = 0x0020,
/// <summary>FIXME: This is an xbox hack to work around elimination of trigger surfaces, which breaks occluders</summary>
SURF_TRIGGER = 0x0040,
/// <summary>don't bother referencing the texture</summary>
SURF_NODRAW = 0x0080,
/// <summary>make a primary bsp splitter</summary>
SURF_HINT = 0x0100,
/// <summary>completely ignore, allowing non-closed brushes</summary>
SURF_SKIP = 0x0200,
/// <summary>Don't calculate light</summary>
SURF_NOLIGHT = 0x0400,
/// <summary>calculate three lightmaps for the surface for bumpmapping</summary>
SURF_BUMPLIGHT = 0x0800,
/// <summary>Don't receive shadows</summary>
SURF_NOSHADOWS = 0x1000,
/// <summary>Don't receive decals</summary>
SURF_NODECALS = 0x2000,
/// <summary>Don't subdivide patches on this surface</summary>
SURF_NOCHOP = 0x4000,
/// <summary>surface is part of a hitbox</summary>
SURF_HITBOX = 0x8000
}
[Flags]
public enum NeighborSpan
{
// These denote where one dispinfo fits on another.
// Note: tables are generated based on these indices so make sure to update
// them if these indices are changed.
CORNER_TO_CORNER = 0,
CORNER_TO_MIDPOINT = 1,
MIDPOINT_TO_CORNER = 2
}
[Flags]
public enum NeighborOrientation
{
// These define relative orientations of displacement neighbors.
ORIENTATION_CCW_0 = 0,
ORIENTATION_CCW_90 = 1,
ORIENTATION_CCW_180 = 2,
ORIENTATION_CCW_270 = 3
}
public enum GAMELUMP_CODES
{
GAMELUMP_DETAIL_PROPS = ('d') << 24 | ('p') << 16 | ('r') << 8 | ('p') << 0,
GAMELUMP_DETAIL_PROP_LIGHTING = ('d') << 24 | ('p') << 16 | ('l') << 8 | ('t') << 0,
GAMELUMP_STATIC_PROPS = ('s') << 24 | ('p') << 16 | ('r') << 8 | ('p') << 0,
GAMELUMP_DETAIL_PROP_LIGHTING_HDR = ('d') << 24 | ('p') << 16 | ('l') << 8 | ('h') << 0,
Unknown
}
[Flags]
public enum STATICPROP_FLAGS
{
/// <summary>automatically computed</summary>
STATIC_PROP_FLAG_FADES = 0x1,
/// <summary>automatically computed</summary>
STATIC_PROP_USE_LIGHTING_ORIGIN = 0x2,
/// <summary>automatically computed; computed at run time based on dx level</summary>
STATIC_PROP_NO_DRAW = 0x4,
/// <summary>set in WC</summary>
STATIC_PROP_IGNORE_NORMALS = 0x8,
/// <summary>set in WC</summary>
STATIC_PROP_NO_SHADOW = 0x10,
/// <summary>set in WC</summary>
STATIC_PROP_UNUSED = 0x20,
/// <summary>in vrad, compute lighting at lighting origin, not for each vertex</summary>
STATIC_PROP_NO_PER_VERTEX_LIGHTING = 0x40,
/// <summary>disable self shadowing in vrad</summary>
STATIC_PROP_NO_SELF_SHADOWING = 0x80
}
[Flags]
public enum DetailPropType_t
{
DETAIL_PROP_TYPE_MODEL = 0,
DETAIL_PROP_TYPE_SPRITE,
DETAIL_PROP_TYPE_SHAPE_CROSS,
DETAIL_PROP_TYPE_SHAPE_TRI,
}
[Flags]
public enum dprimitive_type
{
PRIM_TRILIST = 0,
PRIM_TRISTRIP = 1,
}
[Flags]
public enum DISPTRI_TAGS
{
DISPTRI_TAG_SURFACE = 1 << 0,
DISPTRI_TAG_WALKABLE = 1 << 1,
DISPTRI_TAG_BUILDABLE = 1 << 2,
DISPTRI_FLAG_SURFPROP1 = 1 << 3,
DISPTRI_FLAG_SURFPROP2 = 1 << 4,
DISPTRI_TAG_REMOVE = 1 << 5
}
#endregion
#region structs
/// <summary>Header. Size: 780 bytes</summary>
public struct dheader_t
{
public int ident;
public int version;
public lump_t[] lumps;//[HEADER_LUMPS];
public int mapRevision; // the map's revision (iteration, version) number (added BSPVERSION 6)
}
/// <summary>Lump info. Size: 12 bytes</summary>
public struct lump_t
{
public int fileofs, filelen;
public int version; // default to zero
// this field was char fourCC[4] previously, but was unused, favoring the LUMP IDs above instead. It has been
// repurposed for compression. 0 implies the lump is not compressed.
public int uncompressedSize; // default to zero
//additional
public int lumpNum;
}
/// <summary>Plane. Size: 20 bytes</summary>
public struct dplane_t
{
// planes (x) and (x)+1 are always opposites
public SourceVector normal;
public float dist;
public int type; // PLANE_X - PLANE_ANYZ ?remove? trivial to regenerate
#if UNITY
public Plane toPlane() => new Plane(?, ?, ?);
#endif
}
/// <summary>Texture data. Size: 32 bytes</summary>
public struct dtexdata_t
{
public SourceVector reflectivity;
public int nameStringTableID; // index into g_StringTable for the texture name
public int width, height; // source image
public int view_width, view_height; //
}
/// <summary>Visibility. Size: ? bytes</summary>
public struct dvis_t
{
public int numclusters;
public int[][] bitofs;// bitofs[numclusters=8][2]
public HashSet<byte>[] pvs; //potentially visible set
public HashSet<byte>[] pas; //potentially audible set
}
/// <summary>Node. Size: 30 bytes</summary>
public struct dnode_t
{
public int planenum;
public int[] children;//[2]; // negative numbers are -(leafs+1), not nodes
public SourceVectorShort mins;//short[3]; // for frustom culling
public SourceVectorShort maxs;//short[3];
public ushort firstface;
public ushort numfaces; // counting both sides
public short area; // If all leaves below this node are in the same area, then
// this is the area index. If not, this is -1.
//additional
//public short unused; //is always 0
}
/// <summary>Texture info. v0. Size: 72 bytes</summary>
public struct texinfo_t
{
public SourceVector4[] textureVecsTexelsPerWorldUnits;//[2]; // [s/t][xyz offset]
public SourceVector4[] lightmapVecsLuxelsPerWorldUnits;//[2]; // [s/t][xyz offset] - length is in units of texels/area
public int flags; // miptex flags + overrides
public int texdata; // Pointer to texture name, size, etc.
}
/// <summary>Face. Size: 56 bytes</summary>
public struct dface_t
{
public ushort planenum;
public byte side; // faces opposite to the node's plane direction
public byte onNode; // 1 of on node, 0 if in leaf
public int firstedge; // we must support > 64k edges
public short numedges;
public short texinfo;
// This is a union under the assumption that a fog volume boundary (ie. water surface)
// isn't a displacement map.
// FIXME: These should be made a union with a flags or type field for which one it is
// if we can add more to this.
// union
// {
public short dispinfo;
// This is only for surfaces that are the boundaries of fog volumes
// (ie. water surfaces)
// All of the rest of the surfaces can look at their leaf to find out
// what fog volume they are in.
public short surfaceFogVolumeID;
// };
// lighting info
public byte[] styles;//[MAXLIGHTMAPS=4];
public int lightofs; // start of [numstyles*surfsize] samples
public float area;
// TODO: make these unsigned chars?
public SourceVector2Int m_LightmapTextureMinsInLuxels;
public SourceVector2Int m_LightmapTextureSizeInLuxels;
public int origFace; // reference the original face this face was derived from
// non-polygon primitives (strips and lists)
public ushort m_NumPrims; // Top bit, if set, disables shadows on this surface (this is why there are accessors).
public ushort firstPrimID;
public uint smoothingGroups;
public ushort GetNumPrims => (ushort)(m_NumPrims & 0x7FFF);
public void SetNumPrims(ushort nPrims)
{
//Assert((nPrims & 0x8000) == 0);
if ((nPrims & 0x8000) == 0) return;
m_NumPrims = (ushort)(m_NumPrims & ~0x7FFF);
m_NumPrims = (ushort)(m_NumPrims | (nPrims & 0x7FFF));
}
public bool AreDynamicShadowsEnabled => (m_NumPrims & 0x8000) == 0;
public void SetDynamicShadowsEnabled(bool bEnabled)
{
if (bEnabled)
m_NumPrims = (ushort)(m_NumPrims & ~0x8000);
else
m_NumPrims |= 0x8000;
}
}
/// <summary>Map flags. Size: 4 bytes</summary>
public struct dflagslump_t
{
/// <summary>
/// use enum MAP_FLAGS
/// </summary>
public uint m_LevelFlags; // LVLFLAGS_xxx
//additional
public MAP_FLAGS[] getFlags => FlagsUtils.getFlags<MAP_FLAGS>(m_LevelFlags);
public override string ToString()
{
string s = string.Empty;
foreach (MAP_FLAGS f in getFlags) s += f.ToString() + " | ";
if (s.Length > 3)
s = s.Substring(0, s.Length - 3);
return s;
}
}
/// <summary>Occluder. Size: ? bytes</summary>
public struct doccluder_t
{
//struct from valve dev wiki, can't find in source sdk 2013
public int count;
public object data; //[count]; //"doccluderdataV1_t[]" or "doccluderdataV2_t[]"
public int polyDataCount;
public doccluderpolydata_t[] polyData;//[polyDataCount];
public int vertexIndexCount;
public int[] vertexIndices;//[vertexIndexCount];
}
/// <summary>Occluder data. V1. Size: 36 bytes</summary>
public struct doccluderdataV1_t
{
public int flags;
public int firstpoly; // index into doccluderpolys
public int polycount;
public SourceVector mins;
public SourceVector maxs;
}
/// <summary>Occluder data. V2. Size: 40 bytes</summary>
public struct doccluderdataV2_t
{
public int flags;
public int firstpoly; // index into doccluderpolys
public int polycount;
public SourceVector mins;
public SourceVector maxs;
public int area;
}
/// <summary>Occluder polygons. Size: 12 bytes</summary>
public struct doccluderpolydata_t
{
public int firstvertexindex; // index into doccludervertindices
public int vertexcount;
public int planenum;
}
/// <summary>Leaf. V0. Size: 56 bytes</summary>
public struct dleafV0_t
{
public int contents; // OR of all brushes (not needed?)
public short cluster;
//BEGIN_BITFIELD(bf );
public short area;//:9;
public short flags;//:7; // Per leaf flags.
//END_BITFIELD();
public SourceVectorShort mins;//short[3]; // for frustum culling
public SourceVectorShort maxs;//short[3];
public ushort firstleafface;
public ushort numleaffaces;
public ushort firstleafbrush;
public ushort numleafbrushes;
public short leafWaterDataID; // -1 for not in water
// Precaculated light info for entities.
public CompressedLightCube m_AmbientLighting;
//additional
public LEAF_FLAGS[] getFlags => FlagsUtils.getFlags<LEAF_FLAGS>(flags);
}
/// <summary>Leaf. V1. Size: 32 bytes</summary>
public struct dleafV1_t
{
public int contents; // OR of all brushes (not needed?)
public short cluster;
//BEGIN_BITFIELD(bf );
public short area;//:9;
public short flags;//:7; // Per leaf flags.
//END_BITFIELD();
public SourceVectorShort mins;//short[3]; // for frustum culling
public SourceVectorShort maxs;//short[3];
public ushort firstleafface;
public ushort numleaffaces;
public ushort firstleafbrush;
public ushort numleafbrushes;
public short leafWaterDataID; // -1 for not in water
// NOTE: removed this for version 1 and moved into separate lump "LUMP_LEAF_AMBIENT_LIGHTING" or "LUMP_LEAF_AMBIENT_LIGHTING_HDR"
// Precaculated light info for entities.
// CompressedLightCube m_AmbientLighting;
//additional
public LEAF_FLAGS[] getFlags => FlagsUtils.getFlags<LEAF_FLAGS>(flags);
}
/// <summary>Face ID. Size: 2 bytes</summary>
public struct dfaceid_t
{
public ushort hammerfaceid;
}
/// <summary>Edge. Size: 4 bytes</summary>
public struct dedge_t
{
// note that edge 0 is never used, because negative edge nums are used for
// counterclockwise use of the edge in a face
public SourceVector2Short v;//short[2]; // vertex numbers
}
/// <summary>Model. Size: 48 bytes</summary>
public struct dmodel_t
{
public SourceVector mins, maxs;
public SourceVector origin; // for sounds or lights
public int headnode;
public int firstface, numfaces; // submodels just draw faces without walking the bsp tree
}
/// <summary>World light. V0. Size: 88 bytes</summary>
public struct dworldlightV0_t
{
public SourceVector origin;
public SourceVector intensity;
public SourceVector normal; // for surfaces and spotlights
public int cluster;
public emittype_t type; // is ushort?
public int style;
public float stopdot; // start of penumbra for emit_spotlight
public float stopdot2; // end of penumbra for emit_spotlight
public float exponent; //
public float radius; // cutoff distance
// falloff for emit_spotlight + emit_point:
// 1 / (constant_attn + linear_attn * dist + quadratic_attn * dist^2)
public float constant_attn;
public float linear_attn;
public float quadratic_attn;
public int flags; // Uses a combination of the DWL_FLAGS_ defines.
public int texinfo; //
public int owner; // entity that this light it relative to
//additional
public WORLDLIGHT_FLAGS[] getFlags => FlagsUtils.getFlags<WORLDLIGHT_FLAGS>(flags);
}
/// <summary>World light. V1. Size: 100 bytes</summary>
public struct dworldlightV1_t
{
public SourceVector origin;
public SourceVector intensity;
public SourceVector normal; // for surfaces and spotlights
public SourceVector shadow_cast_offset; // gets added to the light origin when this light is used as a shadow caster (only if DWL_FLAGS_CASTENTITYSHADOWS flag is set)
public int cluster;
public emittype_t type;
public int style;
public float stopdot; // start of penumbra for emit_spotlight
public float stopdot2; // end of penumbra for emit_spotlight
public float exponent; //
public float radius; // cutoff distance
// falloff for emit_spotlight + emit_point:
// 1 / (constant_attn + linear_attn * dist + quadratic_attn * dist^2)
public float constant_attn;
public float linear_attn;
public float quadratic_attn;
public int flags; // Uses a combination of the DWL_FLAGS_ defines.
public int texinfo; //
public int owner; // entity that this light it relative to
//additional
public WORLDLIGHT_FLAGS[] getFlags => FlagsUtils.getFlags<WORLDLIGHT_FLAGS>(flags);
}
/// <summary>Brush. Size: 12 bytes</summary>
public struct dbrush_t
{
public int firstside;
public int numsides;
public int contents;
//additional
public Contents[] getContents => FlagsUtils.getFlags<Contents>(contents);
}
/// <summary>Brush side. Size: 8 bytes</summary>
public struct dbrushside_t
{
public ushort planenum; // facing out of the leaf
public short texinfo;
public short dispinfo; // displacement info (BSPVERSION 7)
public short bevel; // is the side a bevel plane? (BSPVERSION 7)
}
/// <summary>Area. Size: 8 bytes</summary>
public struct darea_t
{
public int numareaportals, firstareaportal;
}
/// <summary>Areaportal. Size: 12 bytes</summary>
public struct dareaportal_t
{
// each area has a list of portals that lead into other areas
// when portals are closed, other areas may not be visible or
// hearable even if the vis info says that it should be
public ushort m_PortalKey; // Entities have a key called portalnumber (and in vbsp a variable
// called areaportalnum) which is used
// to bind them to the area portals by comparing with this value.
public ushort otherarea; // The area this portal looks into.
public ushort m_FirstClipPortalVert; // Portal geometry.
public ushort m_nClipPortalVerts;
public int planenum;
}
/// <summary>Portal. Size: 16 bytes</summary>
public struct dportal_t
{
public int firstportalvert;
public int numportalverts;
public int planenum;
public ushort[] cluster;//[2];
}
/// <summary>Prop collision. Size: 8 bytes</summary>
public struct dpropcollision_t
{
public int m_nHullCount, m_nHullStart;
}
/// <summary>Cluster. Size: 8 bytes</summary>
public struct dcluster_t
{
public int firstportal, numportals;
}
/// <summary>Prop hull. Size: 16 bytes</summary>
public struct dprophull_t
{
public int m_nVertCount, m_nVertStart;
public int m_nSurfaceProp;
public uint m_nContents;
};
/// <summary>Prop hull triangle. Size: 8 bytes</summary>
public struct dprophulltris_t
{
public int m_nIndexStart, m_nIndexCount;
}
/// <summary>Displacement. Size: 176 bytes</summary>
public struct ddispinfo_t
{
public SourceVector startPosition; // start position used for orientation -- (added BSPVERSION 6)
public int m_iDispVertStart; // Index into LUMP_DISP_VERTS.
public int m_iDispTriStart; // Index into LUMP_DISP_TRIS.
public int power; // power - indicates size of map (2^power + 1)
public int minTess; // minimum tesselation allowed
public float smoothingAngle; // lighting smoothing angle
public int contents; // surface contents
public ushort m_iMapFace; // Which map face this displacement comes from.
public int m_iLightmapAlphaStart; // Index into ddisplightmapalpha.
// The count is m_pParent->lightmapTextureSizeInLuxels[0]*m_pParent->lightmapTextureSizeInLuxels[1].
public int m_iLightmapSamplePositionStart; // Index into LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS.
//=^=46 bytes=^=
public CDispNeighbor[] m_EdgeNeighbors;//[4]; // Indexed by NEIGHBOREDGE_ defines.
public CDispCornerNeighbors[] m_CornerNeighbors;//[4]; // Indexed by CORNER_ defines.
//ALLOWEDVERTS_SIZE = PAD_NUMBER(MAX_DISPVERTS, 32) / 32
public ulong[] m_AllowedVerts;//[ALLOWEDVERTS_SIZE=10];// This is built based on the layout and sizes of our neighbors
// and tells us which vertices are allowed to be active.
//additional methods
public int NumVerts => ((1 << (power)) + 1) * ((1 << (power)) + 1);
public int NumTris => ((1 << (power)) * (1 << (power)) * 2);
}
/// <summary>Displacement Subneighbor. Size: 5 bytes</summary>
public struct CDispSubNeighbor
{
public ushort m_iNeighbor; // This indexes into ddispinfos.
// 0xFFFF if there is no neighbor here.
public byte m_NeighborOrientation; // (CCW) rotation of the neighbor wrt this displacement.
// These use the NeighborSpan type.
public byte m_Span; // Where the neighbor fits onto this side of our displacement.
public byte m_NeighborSpan; // Where we fit onto our neighbor.
//additional
public ushort GetNeighborIndex => m_iNeighbor;
public NeighborSpan GetSpan => (NeighborSpan)m_Span;
public NeighborSpan GetNeighborSpan => (NeighborSpan)m_NeighborSpan;
public NeighborOrientation GetNeighborOrientation => (NeighborOrientation)m_NeighborOrientation;
public bool IsValid => m_iNeighbor != 0xFFFF;
public void SetInvalid() { m_iNeighbor = 0xFFFF; }
}
/// <summary>Displacement Neighbor. Size: 10 bytes</summary>
public struct CDispNeighbor
{
// Note: if there is a neighbor that fills the whole side (CORNER_TO_CORNER),
// then it will always be in CDispNeighbor::m_Neighbors[0]
public CDispSubNeighbor[] m_SubNeighbors;//[2];
//additional methods
public void SetInvalid() { m_SubNeighbors[0].SetInvalid(); m_SubNeighbors[1].SetInvalid(); }
// Returns false if there isn't anything touching this edge.
public bool IsValid => m_SubNeighbors[0].IsValid || m_SubNeighbors[1].IsValid;
}
/// <summary>Displacement Corner Neighbors. Size: 9 bytes</summary>
public struct CDispCornerNeighbors
{
public ushort[] m_Neighbors;//[MAX_DISP_CORNER_NEIGHBORS=4]; // indices of neighbors.
public byte m_nNeighbors;
//additional methods
public void SetInvalid() { m_nNeighbors = 0; }
}
/// <summary>Displacement Physics. Size: 2 bytes</summary>
public struct dphysdisp_t
{
// contains the binary blob for each displacement surface's virtual hull
public ushort numDisplacements;
public ushort[] dataSize;//[numDisplacements];
}
/// <summary>Displacement Physics. Size: 8 bytes</summary>
public struct dphysmodel_t
{
public int modelIndex;
public int dataSize;
public int keydataSize;
public int solidCount;
//additional
//public phy solid;
public string keydata;
}
/// <summary>Displacement vertex. Size: 20 bytes</summary>
public class CDispVert
{
public SourceVector m_vVector; // Vector field defining displacement volume.
public float m_flDist; // Displacement distances.
public float m_flAlpha; // "per vertex" alpha values.
}
/// <summary>Game lump header. Size: 4 bytes</summary>
public struct dgamelumpheader_t
{
public int lumpCount;
//additional
public dgamelump_t[] lumps;
//static props
public StaticPropDictLump_t[] staticPropNames;
public StaticPropLeafLump_t[] staticPropLeafs;
/// <summary>Usage (depending on lump version): (StaticPropLumpV?_t[])staticProps</summary>
public object staticProps;
//detail props
public DetailObjectDictLump_t[] detailPropNames;
public DetailSpriteDictLump_t[] detailPropSprites;
public DetailObjectLump_t[] detailProps;
public DetailPropLightstylesLump_t[] detailPropLighting, detailPropLightingHDR;
}
/// <summary>Game lump info. Size: 20 bytes</summary>
public struct dgamelump_t
{
public int id; // This is expected to be a four-CC code ('lump')
public ushort flags;
public ushort version;
public int fileofs;
public int filelen;
//additional
public GAMELUMP_CODES id_code => (GAMELUMP_CODES)(id);
}
/// <summary>Game lump: Static prop dictionary. Size: 128 bytes</summary>
public struct StaticPropDictLump_t
{
public string m_Name;//char[STATIC_PROP_NAME_LENGTH=128]; // model name
}
/// <summary>Game lump: Static prop leaf. Size: 2 bytes</summary>
public struct StaticPropLeafLump_t
{
public ushort m_Leaf;
}
/// <summary>Game lump: Static prop. V4. Size: 56 bytes</summary>
public struct StaticPropLumpV4_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
}
/// <summary>Game lump: Static prop. V5. Size: 60 bytes</summary>
public struct StaticPropLumpV5_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
}
/// <summary>Game lump: Static prop. V6. Size: 64 bytes</summary>
public struct StaticPropLumpV6_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
public ushort m_nMinDXLevel;
public ushort m_nMaxDXLevel;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
}
/// <summary>Game lump: Static prop. V7. Size: 68 bytes</summary>
public struct StaticPropLumpV7_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
public ushort m_nMinDXLevel;
public ushort m_nMaxDXLevel;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
public SourceColor32 m_DiffuseModulation; // per instance color and alpha modulation
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
}
/// <summary>Game lump: Static prop. V8. Size: 68 bytes</summary>
public struct StaticPropLumpV8_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
public byte m_nMinCPULevel;
public byte m_nMaxCPULevel;
public byte m_nMinGPULevel;
public byte m_nMaxGPULevel;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
public SourceColor32 m_DiffuseModulation; // per instance color and alpha modulation
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
}
/// <summary>Game lump: Static prop. V9. Size: 72 bytes</summary>
public struct StaticPropLumpV9_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
public byte m_nMinCPULevel;
public byte m_nMaxCPULevel;
public byte m_nMinGPULevel;
public byte m_nMaxGPULevel;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
public SourceColor32 m_DiffuseModulation; // per instance color and alpha modulation
public int m_bDisableX360;
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
}
/// <summary>Game lump: Static prop. V10. Size: 76 bytes</summary>
public struct StaticPropLumpV10_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
public byte m_nMinCPULevel;
public byte m_nMaxCPULevel;
public byte m_nMinGPULevel;
public byte m_nMaxGPULevel;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
public SourceColor32 m_DiffuseModulation; // per instance color and alpha modulation
public int m_bDisableX360; //???
public uint m_FlagsEx; //???
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
//public STATICPROP_FLAGSEX[] getFlagsEx => FlagsUtils.getFlags<STATICPROP_FLAGSEX>(FlagsEx);
}
/// <summary>Game lump: Static prop. V11. Size: 76 bytes</summary>
public struct StaticPropLumpV11_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_PropType;
public ushort m_FirstLeaf;
public ushort m_LeafCount;
public byte m_Solid;
public byte m_Flags;
public int m_Skin;
public float m_FadeMinDist;
public float m_FadeMaxDist;
public SourceVector m_LightingOrigin;
public float m_flForcedFadeScale;
public byte m_nMinCPULevel;
public byte m_nMaxCPULevel;
public byte m_nMinGPULevel;
public byte m_nMaxGPULevel;
// int m_Lighting; // index into the GAMELUMP_STATIC_PROP_LIGHTING lump
public SourceColor32 m_DiffuseModulation; // per instance color and alpha modulation
public int m_bDisableX360; //???
public uint m_FlagsEx; //???
public float m_UniformScale;
//additional
public STATICPROP_FLAGS[] getFlags => FlagsUtils.getFlags<STATICPROP_FLAGS>(m_Flags);
//public STATICPROP_FLAGSEX[] getFlagsEx => FlagsUtils.getFlags<STATICPROP_FLAGSEX>(FlagsEx);
}
/// <summary>Game lump: Detail prop dictionary. Size: 128 bytes</summary>
public struct DetailObjectDictLump_t
{
// Model index when using studiomdls for detail props
public string m_Name; //char[DETAIL_NAME_LENGTH=128]; // model name
}
/// <summary>Game lump: Detail prop sprite info. Size: 8 bytes</summary>
public struct DetailSpriteDictLump_t
{
// Information about the sprite to render
// NOTE: All detail prop sprites must lie in the material detail/detailsprites
public SourceVector2 m_UL; // Coordinate of upper left
public SourceVector2 m_LR; // Coordinate of lower right
public SourceVector2 m_TexUL; // Texcoords of upper left
public SourceVector2 m_TexLR; // Texcoords of lower left
}
/// <summary>Game lump: Detail prop. Size: 52 bytes</summary>
public struct DetailObjectLump_t
{
public SourceVector m_Origin;
public SourceQAngle m_Angles;
public ushort m_DetailModel; // either index into DetailObjectDictLump_t or DetailPropSpriteLump_t
public ushort m_Leaf;
public ColorRGBExp32 m_Lighting;
public uint m_LightStyles;
public byte m_LightStyleCount;
public byte m_SwayAmount; // how much do the details sway
public byte m_ShapeAngle; // angle param for shaped sprites
public byte m_ShapeSize; // size param for shaped sprites
public byte m_Orientation; // See DetailPropOrientation_t
public byte[] m_Padding2;//[3]; // FIXME: Remove when we rev the detail lump again..
public byte m_Type; // See DetailPropType_t
public byte[] m_Padding3;//[3]; // FIXME: Remove when we rev the detail lump again..
public float m_flScale; // For sprites only currently
//additional
public DetailPropType_t[] getDetailPropType => FlagsUtils.getFlags<DetailPropType_t>(m_Type);
}
/// <summary>Game lump: Detail prop lighting info. Size: 5 bytes</summary>
public struct DetailPropLightstylesLump_t
{
public ColorRGBExp32 m_Lighting;
public byte m_Style;
}
/// <summary>Water leaf. Size: 10 bytes</summary>
public struct dleafwaterdata_t
{
public float surfaceZ, minZ;
public short surfaceTexInfoID;
public short unknown; // is always zero?
// mb is a part of surfaceTexInfoID (that means it can be int32)
}
/// <summary>Primitive. Size: 9 bytes</summary>
public struct dprimitive_t
{
public byte type;
public ushort firstIndex;
public ushort indexCount;
public ushort firstVert;
public ushort vertCount;
//additional
public dprimitive_type[] getPrimType => FlagsUtils.getFlags<dprimitive_type>(type);
}
/// <summary>Cubemap. Size: 16 bytes</summary>
public struct dcubemapsample_t
{
public int[] origin;//[3] // position of light snapped to the nearest integer
// the filename for the vtf file is derived from the position
public byte size; // 0 - default
// otherwise, 1<<(size-1)
}
/// <summary>Overlay. Size: 352 bytes</summary>
public struct doverlay_t
{
public int nId;
public short nTexInfo;
public ushort m_nFaceCountAndRenderOrder;
public int[] aFaces;//[OVERLAY_BSP_FACE_COUNT=64];
public float[] flU;//[2];
public float[] flV;//[2];
public SourceVector[] vecUVPoints;//[4];
public SourceVector vecOrigin;
public SourceVector vecBasisNormal;
// Accessors..
public void SetFaceCount(ushort count)
{
m_nFaceCountAndRenderOrder &= OVERLAY_RENDER_ORDER_MASK;
m_nFaceCountAndRenderOrder |= (ushort)(count & ~OVERLAY_RENDER_ORDER_MASK);
}
public ushort GetFaceCount() => (ushort)(m_nFaceCountAndRenderOrder & ~OVERLAY_RENDER_ORDER_MASK);
public void SetRenderOrder(ushort order)
{
//m_nFaceCountAndRenderOrder &= ~OVERLAY_RENDER_ORDER_MASK;
//m_nFaceCountAndRenderOrder |= (ushort)(order << (16 - OVERLAY_RENDER_ORDER_NUM_BITS)); // leave 2 bits for render order.
throw new NotImplementedException();
}
public ushort GetRenderOrder() => (ushort)(m_nFaceCountAndRenderOrder >> (16 - OVERLAY_RENDER_ORDER_NUM_BITS));
}
/// <summary>Displacement triangle. Size: 2 bytes</summary>
public struct CDispTri
{
public ushort m_uiTags; // Displacement triangle tags.
//additional
public DISPTRI_TAGS[] getFlags => FlagsUtils.getFlags<DISPTRI_TAGS>(m_uiTags);
}
/// <summary>Water overlay. Size: 1120 bytes</summary>
public struct dwateroverlay_t
{
//i know its similar to doverlay_t, but it has different limitations. from antim.
public int nId;
public short nTexInfo;
public ushort m_nFaceCountAndRenderOrder;
public int[] aFaces;//[WATEROVERLAY_BSP_FACE_COUNT=256];
public float[] flU;//[2];
public float[] flV;//[2];
public SourceVector[] vecUVPoints;//[4];
public SourceVector vecOrigin;
public SourceVector vecBasisNormal;
// Accessors..
public void SetFaceCount(ushort count)
{
m_nFaceCountAndRenderOrder &= WATEROVERLAY_RENDER_ORDER_MASK;
m_nFaceCountAndRenderOrder |= (ushort)(count & ~WATEROVERLAY_RENDER_ORDER_MASK);
}
public ushort GetFaceCount() => (ushort)(m_nFaceCountAndRenderOrder & ~WATEROVERLAY_RENDER_ORDER_MASK);
public void SetRenderOrder(ushort order)
{
//m_nFaceCountAndRenderOrder &= ~WATEROVERLAY_RENDER_ORDER_MASK;
//m_nFaceCountAndRenderOrder |= (order << (16 - WATEROVERLAY_RENDER_ORDER_NUM_BITS)); // leave 2 bits for render order.
throw new NotImplementedException();
}
public ushort GetRenderOrder() => (ushort)(m_nFaceCountAndRenderOrder >> (16 - WATEROVERLAY_RENDER_ORDER_NUM_BITS));
}
/// <summary>Lightmap page. Size: 33792 bytes</summary>
public struct dlightmappage_t
{
public byte[] data; //[MAX_LIGHTMAPPAGE_WIDTH * MAX_LIGHTMAPPAGE_HEIGHT]
public ColorRGBExp32[] palette; //[256]
//originally 'palette' was an byte array and had [256*4] len
}
/// <summary>Ambient lighting samples. Size: 4 bytes</summary>
public struct dleafambientindex_t
{
public ushort ambientSampleCount;
public ushort firstAmbientSample;
}
/// <summary>Lightmap page info. Size: 8 bytes</summary>
public struct dlightmappageinfo_t
{
public byte page; // lightmap page [0..?]
public byte[] offset;//[2]; // offset into page (s,t)
public byte pad; // unused
public ColorRGBExp32 avgColor; // average used for runtime lighting calcs
}
/// <summary>Ambient lighting sample. Size: 28 bytes</summary>
public struct dleafambientlighting_t
{
// each leaf contains N samples of the ambient lighting
// each sample contains a cube of ambient light projected on to each axis
// and a sampling position encoded as a 0.8 fraction (mins=0,maxs=255) of the leaf's bounding box
public CompressedLightCube cube;
public byte x; // fixed point fraction of leaf bounds
public byte y; // fixed point fraction of leaf bounds
public byte z; // fixed point fraction of leaf bounds
public byte pad; // unused
}
/// <summary>Overlay fade. Size: 8 bytes</summary>
public struct doverlayfade_t
{
public float flFadeDistMinSq, flFadeDistMaxSq;
}
#endregion
}
}
Reference in New Issue Copy Permalink