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
	}
}