/*
bspfile.h
BSP (Binary Space Partitioning) file definitions
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifndef __QF_bspfile_h
#define __QF_bspfile_h
#include "QF/qtypes.h"
#include "QF/quakeio.h"
/** \defgroup formats_bsp BSP Files
BSP files are used for quake's maps and some pick-up items (health and
ammo boxes in particular). The maps can be quite complicated, usually with
many sub-models, while the pick-up items are usually simple boxes.
QuakeForge supports two formats for BSP files "BSP 29", (the original
format, with many 16-bit fields), and "BSP 2", all fields 32 bits. Both
formats are little-endian.
BSP files use a right-handed coordinate system with +Z up but clockwise
winding for face normals.
The tools used to create a bsp file include qfbsp, qfvis and qflight (or
similar tools from other projects).
*/
/** \defgroup bsp_limits BSP File limits
\ingroup formats_bsp
Other than MAX_MAP_HULLS, these apply only to BSP 29 files as the fields
holding the values are all 16 bits.
*/
///@{
#define MAX_MAP_HULLS 4 ///< fixed length array
#define MAX_MAP_PLANES 32767
/** \name nodes and leafs (sic)
negative shorts are contents but contents "max" is -15, so -32768 to -17
are available
*/
///@{
#define MAX_MAP_NODES 65520
#define MAX_MAP_CLIPNODES 65520
#define MAX_MAP_LEAFS 65520
///@}
#define MAX_MAP_VERTS 65535
#define MAX_MAP_FACES 65535
#define MAX_MAP_MARKSURFACES 65535
#define MAP_PVS_BYTES (MAX_MAP_LEAFS / 8)
///@}
/** \defgroup bsp_lumps BSP File lumps
\ingroup formats_bsp
All data in a BSP file is separated into lumps. The lump structure gives
the file relative offset of the beginning of the data lump, and the size
of the lump in bytes.
*/
///@{
/** Individual data lump descriptor.
*/
typedef struct lump_s {
uint32_t fileofs; ///< File relative offset in bytes
uint32_t filelen; ///< Size of lump in bytes
} lump_t;
#define LUMP_ENTITIES 0 ///< \ref bsp_entities
#define LUMP_PLANES 1 ///< \ref bsp_planes
#define LUMP_TEXTURES 2 ///< \ref bsp_textures
#define LUMP_VERTEXES 3 ///< \ref bsp_vertices
#define LUMP_VISIBILITY 4 ///< \ref bsp_visibility
#define LUMP_NODES 5 ///< \ref bsp_nodes
#define LUMP_TEXINFO 6 ///< \ref bsp_texinfo
#define LUMP_FACES 7 ///< \ref bsp_face
#define LUMP_LIGHTING 8 ///< \ref bsp_lighting
#define LUMP_CLIPNODES 9 ///< \ref bsp_clipnodes
#define LUMP_LEAFS 10 ///< \ref bsp_leafs
#define LUMP_MARKSURFACES 11 ///< \ref bsp_marksurfaces
#define LUMP_EDGES 12 ///< \ref bsp_edges
#define LUMP_SURFEDGES 13 ///< \ref bsp_surfedges
#define LUMP_MODELS 14 ///< \ref bsp_model
#define HEADER_LUMPS 15 ///< Number of lumps
///@}
/** \defgroup bsp_header BSP File header
\ingroup formats_bsp
*/
///@{
/** Holds version and lump offset information.
Always at offset 0 of the BSP file.
*/
typedef struct dheader_s {
uint32_t version; ///< little-endian or 4-char string
lump_t lumps[HEADER_LUMPS];///< Identical between BSP 2 and BSP 29
} dheader_t;
#define BSPVERSION 29 ///< little-endian uint32_t
#define BSP2VERSION "BSP2" ///< 4-char unterminated string
#define Q2BSPVERSION 38 ///< Not supported
#define TOOLVERSION 2 ///< Not used
///@}
/** \defgroup bsp_model BSP File sub-model
\ingroup formats_bsp
The sub-model lump is an array of sub-model descriptors. Every BSP file
has at least one sub-model, with sub-model index 0 being the main model.
*/
///@{
typedef struct dmodel_s {
/// \name Bounding box for the model
///@{
float mins[3]; ///< minimum X, Y, Z
float maxs[3]; ///< maximum X, Y, Z
///@}
float origin[3]; ///< unclear
/// Index of the first node for each hull. The first headnode index
/// is for the draw nodes (\ref bsp_nodes), while subsequent headnodes
/// are for the clipnodes (\ref bsp_clipnodes).
/// The engine builds a clip node tree for headnods[0] from the draw
/// nodes at load time.
uint32_t headnode[MAX_MAP_HULLS];
/// The number of visible leafs in the model.
/// \note Does *not* include leaf 0 (the infinite solid leaf in most maps)
uint32_t visleafs;
/// \name Visible faces
/// A sub-model's visible faces are all in one contiguous block.
///@{
uint32_t firstface; ///< Index of first visible face in model
uint32_t numfaces; ///< Number of visible faces in model
///@}
} dmodel_t;
///@}
/** \defgroup bsp_textures BSP File texture data
\ingroup formats_bsp
The texture data in a BSP file forms a sub-file with its own structure.
*/
///@{
/** Header for the textures lump.
The size is variable as there is one dataofs element for each miptex
block.
*/
typedef struct dmiptexlump_s {
/// Number of miptex blocks in the textures lump.
uint32_t nummiptex;
/// Offsets are relative to the beginning of the dmiptexlump_t structure
/// (ie, the textures lump). One for each miptex block. \ref miptex_s
uint32_t dataofs[4];
} dmiptexlump_t;
#define MIPTEXNAME 16 ///< Names have a max length of 15 chars
#define MIPLEVELS 4 ///< Number of mip levels in all miptex
/** Header for individual mip-mapped texture.
The beginning of the name of the texture specifies some of the texture's
properties:
- sky The texture is used for the dual-layer skies. Expected
to be 256x128. Sky faces get special treatment by the
renderer.
- * "Water" face. Texture-warped by the renderer. Usually
unlit (ie, always full-bright).
- + Member of an animation group. The second character of
the texture's name determines to which animation sequence
the texture belongs and the texture's position in that
sequence. The rest of the name specifies the group name.
\ref bsp_texture_animation
- { Tranclucent surface (community extension).
The texture may be rectangular, but the size must be a multiple of 16
pixels in both directions.
*/
typedef struct miptex_s {
char name[MIPTEXNAME]; ///< Texture name. Nul-terminated.
uint32_t width; ///< Width of the full-size texture
uint32_t height; ///< Height of the full-size texture
/// Offsets are relative to the beginning of the individual miptex block.
uint32_t offsets[MIPLEVELS];
} miptex_t;
///@}
/** \defgroup bsp_vertices BSP File vertex lump
\ingroup formats_bsp
Array of unique vertices.
Vertices are shared between edges and faces.
*/
///@{
typedef struct dvertex_s {
float point[3]; ///< X, Y, Z
} dvertex_t;
///@}
/** \defgroup bsp_planes BSP File plane lump
\ingroup formats_bsp
Array of unique planes.
Planes are shared between nodes and faces.
*/
///@{
typedef struct dplane_s {
float normal[3]; ///< Plane normal
float dist; ///< Distance of the plane from the origin
int32_t type; ///< \ref bsp_plane_definition
} dplane_t;
///@}
/** \defgroup bsp_plane_definition Plane definitions
\ingroup bsp_planes
Planes are always canonical in that their normals always point along
a positive axis for axial planes ((1, 0, 0), (0, 1, 0), or (0, 0, 1)),
or the largest component is positive.
*/
///@{
/// \name Axial planes
///@{
#define PLANE_X 0 ///< Plane normal points along +X axis
#define PLANE_Y 1 ///< Plane normal points along +Y axis
#define PLANE_Z 2 ///< Plane normal points along +Z axis
///@}
/// \name Non-axial planes. Specifies the closest axis.
///@{
#define PLANE_ANYX 3 ///< Plane normal close to +X
#define PLANE_ANYY 4 ///< Plane normal close to +Y
#define PLANE_ANYZ 5 ///< Plane normal close to +Z
///@}
///@}
/** \defgroup bsp_nodes BSP nodes lump
\ingroup formats_bsp
These nodes form the visible BSP. While not all nodes will have faces,
most (or at least many) will, as the nodes are used for depth-sorting the
faces while traversing the BSP tree using front-depth-first-in-order
traversal.
They can also be used for collision detection as the leaf nodes indicate
the contents of the volume. The engine takes advantage of this to
construct hull 0 (disk space was still very precious in 1996)
*/
///@{
/** Spit a convex region of space into two convex regions.
The node's plane divides the space into a front side and a back side,
where a point is in front of the plane if its dot product with the plane
normal is positive or 0, and behind (in back of) the plane if the dot
product is negative.
*/
typedef struct dnode_s { //BSP2 version (bsp 29 version is in bspfile.c)
uint32_t planenum; ///< Index of plane defining this node
/// Indices of the child nodes on the front [0] and back [1] side of this
/// node. Negative indicies indicate leaf nodes, where the leaf index is
/// -(child + 1) (or child is -(leaf + 1)).
int32_t children[2];
/// \name Node bounding box
///@{
float mins[3]; ///< minimum X, Y, Z
float maxs[3]; ///< maximum X, Y, Z
///@}
/// \name Node plane faces
/// List of \ref bsp_face faces on the node's plane. Used for
/// depth-sorting the faces while traversing the visible BSP tree.
///@{
uint32_t firstface; ///< index of first face on nonde plane
uint32_t numfaces; ///< numer of faces on node plane (both sides)
///@}
} dnode_t;
///@}
/** \defgroup bsp_clipnodes BSP clipping nodes lump
\ingroup formats_bsp
Compact BSP tree for collision detection.
*/
///@{
typedef struct dclipnode_s { //BSP2 version (bsp 29 version is in bspfile.c)
uint32_t planenum; ///< Index of plane defining this node
/// Indices of the child nodes on the front [0] and back [1] side of this
/// node. Negative indicies indicate leaf contents.
/// \ref bsp_leaf_contents
int32_t children[2];
} dclipnode_t;
///@}
/** \defgroup bsp_texinfo BSP texture information lump
\ingroup formats_bsp
Texture mapping information for visible faces. An individual texinfo may
be shared by many faces.
*/
///@{
typedef struct texinfo_s {
/// The texture plane basis vectors, with the \a s basis vector in index
/// 0 and the \a t basis vector in index 1.
/// For each index, the first three elements are the X, Y, Z components
/// of the basis vector, and the fourth component is the offset. Can be
/// viewed as a 2 row x 4 column matrix (\a M) that is multiplied by
/// a homogeneous vector (\a v) for a face vertex to determine that
/// vertex's UV coordinates (ie, \a M \a v)
float vecs[2][4];
/// Index of the miptex block in the texture data lump
/// (\ref bsp_textures). If the referenced miptex is a member of
/// an animation group, then the entire group is used by this texinfo.
uint32_t miptex;
uint32_t flags; ///< \ref bsp_texinfo_flags
} texinfo_t;
///@}
/** \defgroup bsp_texinfo_flags BSP texture information flags
\ingroup bsp_texinfo
*/
///@{
#define TEX_SPECIAL 1 ///< sky or slime, no lightmap, 256 subdivision
#define TEX_MISSING 2 ///< this texinfo does not have a texture (N/U)
///@}
/** \defgroup bsp_edges BSP edges lump
\ingroup formats_bsp
\note Edge 0 is never used as negative edge indices indicate
counterclockwise use of the edge in a face.
*/
///@{
typedef struct dedge_s { //BSP2 version (bsp 29 version is in bspfile.c)
uint32_t v[2]; ///< vertex indices in winding order
} dedge_t;
///@}
/** \defgroup bsp_face BSP visible faces
\ingroup formats_bsp
*/
///@{
typedef struct dface_s { //BSP2 version (bsp 29 version is in bspfile.c)
uint32_t planenum; ///< Index of the plane containing this face
/// Indicates the side of the plane considered to be the front for this
/// face. 0 indicates the postive normal side, 1 indicates the negative
/// normal side (ie, the face is on the back side of the plane).
int32_t side;
/// \name List of edge indices in clockwise order
/// \ref bsp_surfedges
/// Negative edge indices indicate that the edge is being used in its
/// reverse direction (ie, \a v[1] to \a v[0] instead of \a v[0] to
/// \a v[1]).
/// \note This is a double-indirection.
///@{
uint32_t firstedge; ///< Index of first edge index
uint32_t numedges; ///< Number of edge indices
///@}
/// Index of texinfo block describing texture mapping and miptex reference
/// for this face.
uint32_t texinfo;
/// \name lighting info
///@{
#define MAXLIGHTMAPS 4
/// List of lighting styles affecting the lightmaps affecting this face.
/// 255 indicates both no style thus no lightmap and the end of the list.
byte styles[MAXLIGHTMAPS];
/// Offset into the lighting data (ref bsp_lighting) of the first lightmap
/// affecting this face. The number of lightmaps affecting this face is
/// inferred from the \a styles array. The size of each lightmap is
/// determined from the texture extents of the face as (E / 16 + 1)
/// (integer division). Thus the total lightmap data for this face is
/// given by (nummaps * (Es / 16 + 1) * (Et / 16 + 1)) bytes.
/// The lightmap data is 8-bit, ranging from 0 to 255.
///
/// -1 indicates no lightmap data.
uint32_t lightofs;
///@}
} dface_t;
///@}
/** \defgroup bsp_leafs BSP leafs lump
\ingroup formats_bsp
leaf 0 is the generic CONTENTS_SOLID leaf, used for all solid areas
all other leafs need visibility info
*/
///@{
/** A convex volume of space delimited by the surrounding node planes.
With the exception of the generic solid leaf at index 0, *ALL* leafs are
convex polyhedra. However, they will generally not be manifold as
otherwise it would not be possible to see into or out of a leaf, nor for
an entity to pass in or out of one.
*/
typedef struct dleaf_s { //BSP2 version (bsp 29 version is in bspfile.c)
/// The contents of the leaf. \ref bsp_leaf_contents
int32_t contents;
/// Offset into the \ref bsp_visibility data block for this leaf's
/// visibility data. -1 if the leaf has no visibility data.
int32_t visofs;
/// \name Bounding box for frustum culling
///@{
float mins[3]; ///< minimum X, Y, Z
float maxs[3]; ///< maximum X, Y, Z
///@}
/// \name Visible faces of the leaf
/// List of face indices that form the visible faces of the leaf.
/// \note This is a double-indirection.
///@{
uint32_t firstmarksurface; ///< index of first visible face index
uint32_t nummarksurfaces; ///< number of indices
///@}
#define NUM_AMBIENTS 4
/// automatic ambient sounds \ref bsp_leaf_ambient
byte ambient_level[NUM_AMBIENTS];
} dleaf_t;
///@}
/** \defgroup bsp_leaf_contents BSP leaf contents
\ingroup bsp_leafs
*/
///@{
#define CONTENTS_EMPTY -1 ///< Open, transparent, passable space
#define CONTENTS_SOLID -2 ///< Solid, opaque, impassible space
#define CONTENTS_WATER -3 ///< Buoyant, translucent, passable space
#define CONTENTS_SLIME -4 ///< Like water, but toxic
#define CONTENTS_LAVA -5 ///< Like water, but hot
#define CONTENTS_SKY -6 ///< FIXME sky, but...
#define CONTENTS_ORIGIN -7 ///< removed at csg time
#define CONTENTS_CLIP -8 ///< changed to CONTENTS_SOLID
#define CONTENTS_CURRENT_0 -9 ///< changed to CONTENTS_WATER
#define CONTENTS_CURRENT_90 -10 ///< changed to CONTENTS_WATER
#define CONTENTS_CURRENT_180 -11 ///< changed to CONTENTS_WATER
#define CONTENTS_CURRENT_270 -12 ///< changed to CONTENTS_WATER
#define CONTENTS_CURRENT_UP -13 ///< changed to CONTENTS_WATER
#define CONTENTS_CURRENT_DOWN -14 ///< changed to CONTENTS_WATER
///@}
/** \defgroup bsp_leaf_ambient BSP leaf ambient sounds
\ingroup bsp_leafs
*/
///@{
#define AMBIENT_WATER 0
#define AMBIENT_SKY 1
#define AMBIENT_SLIME 2
#define AMBIENT_LAVA 3
///@}
/** \defgroup bsp_entities Entity data string
\ingroup formats_bsp
Single string containing all the entity dictionaries (edicts).
The format is extremely simple in that is is a series of blocks delimited
by { and }. Blocks cannot be nested. A { after a { but before a } will be
treated as either a key or a value. A } after a } but before a { is not
valid. { must be the first non-whitespace character in the string. } must
be the last non-whitespace character in the string if there is a {.
The contents of a block consist of a series of key-value strinng pairs.
Unless the string contains spaces or punctuaiont (one of "{}()':") double
quote (") around the string are optional. Keys and values are separated
by whitespace (optional if quotes are used) but must be on the same line,
but it is best to use a space. Key-value pairs may be on separate lines
(prefered for readability).
Key strings are Quake-C entity field names. Value strings are interpreted
based on the type of the field.
Below is a sample edict
\verbatim
{
"origin" "-2528 -384 512"
"angle" "270"
"classname" "info_player_start"
}
\endverbatim
As an extention, QuakeForge supports \ref property-list entity string data
if the first non-whitespace character is a (. QuakeForge progs can register
a custom parser for the resulting property list, but the default parser
supports only a single array of dictionaries containing only simple
key-value string pairs.
*/
/** \defgroup bsp_lighting Lighting data
\ingroup formats_bsp
Pre-computed lightmap data. Each byte represents a single lightmap
pixel, thus a lightmap is luminance with values ranging from 0 for
full-dark to 255 for full-bright. The pixels for each lightmap (up
to four) for each visible face form a linear stream.
Computed using tools such as qflight.
*/
/** \defgroup bsp_marksurfaces BSP Leaf faces
\ingroup formats_bsp
Array of face indices representing the faces on the leafs. The face
indices are grouped by leaf. Because whether a face gets split depends
on how the nodes split space, a face may be shared by multiple leafs.
FIXME needs confirmation, but maps with more leaf face indices than
faces in the face array have observed.
*/
/** \defgroup bsp_surfedges BSP face edges
\ingroup formats_bsp
Array of edge indices specifying the edges used in face polyons.
The edges are grouped by face polygon, and are listed in clockwise order
from that face's perspective (when looking at the face from that face's
front side).
As actual edges are reused and thus shared by faces, negative edge
indices indicate that the edge is to be reversed. That is, instead of
going from \a v[0] to \a v[1] for edges referenced by positive indices,
go from \a v[1] to \a v[0] for edges referenced by negative indices.
\ref bsp_edges
*/
/** \defgroup bsp_visibility BSP visibility data
\ingroup formats_bsp
The primary culling data in a Quake BSP. Conceptually, it is just an
array of bit-sets representing the leafs visible from each leaf.
However, leaf 0 is not represented in the data at all: there is now row
for leaf 0 (first row is for leaf 1's visible leafs), and the first bit
in each row represents leaf 1.
As well, the data within a row is compressed: runs of 0-bytes
(representing eight non-visible leafs) are represented as a 0 followed
by a single count byte. For example, a run of eight 0-bytes will appear
as 0x00 0x08, and a single 0 byte will appear as 0x00 0x01.
Computed using tools such as \a qfvis.
*/
/** \defgroup bsp_texture_animation BSP Texture Animation
\ingroup formats_bsp
Textures in BSP files can be animated. Animated textures are those
with miptex names in a special format:
\verbatim
+Sname
\endverbatim
That is, the miptex name starts with a +, followed by a single sequence
id character (0-9 or A-J (or a-j, case-insensitive)) then the name of the
animation group is formed by the remaining characters. Thus an animation
group can have one or two sequences with one to ten frames per sequence.
The two sequences are the main sequence (0-9) and the alternate sequence
(A-J). Gaps in a sequence are not allowed: there must always be a +0 or +A
miptex in the sequence, and there must be a texture for every digit or
letter up to the highest used. However, the miptex blocks can be in any
order within the textures block: the engine searches for them and sorts
them.
Single-frame sequences are useful for simple static texture switchinng
based on game state (entity frame: 0 for main, non-zero for alternate).
Multi-frame sequences are played back at five frames per second.
For example, the folowing sets up an animitation with a 4-frame main
sequence and a 2-frame alternate sequence. Perhaps a roaring fire in
the main sequence and glowing coals in the alternate.
\verbatim
+0fire // main sequence
+1fire // main sequence
+2fire // main sequence
+3fire // main sequence
+Afire // alternate sequence
+Bfire // alternate sequence
\endverbatim
*/
/** \defgroup bspfile BSP file manipulation
\ingroup utils
*/
///@{
/** Memory representation of the BSP file.
All data is in native endian format.
*/
typedef struct bsp_s {
int own_header; ///< \a header is owned by the structure
dheader_t *header; ///< the bsp header block
int own_models; ///< \a models is owned by the structure
size_t nummodels; ///< number of models
dmodel_t *models; ///< Array of sub-models
int own_visdata; ///< \a visdata is owned by the structure
size_t visdatasize; ///< number of bytes in visdata
byte *visdata; ///< \ref bsp_visibility
int own_lightdata; ///< \a lightdata is owned by the structure
size_t lightdatasize; ///< number of bytes in lightdata
byte *lightdata; ///< \ref bsp_lighting
int own_texdata; ///< \a texdata is owned by the structure
size_t texdatasize; ///< number of bytes in texture data
byte *texdata; ///< \ref bsp_textures
int own_entdata; ///< \a entdata is owned by the structure
size_t entdatasize; ///< number of bytes in entdata string
char *entdata; ///< \ref bsp_entities
int own_leafs; ///< \a leafs is owned by the structure
size_t numleafs; ///< number of leafs
dleaf_t *leafs; ///< array of leafs
int own_planes; ///< \a planes is owned by the structure
size_t numplanes; ///< number of planes
dplane_t *planes; ///< array of planes
int own_vertexes; ///< \a vertexes is owned by the structure
size_t numvertexes; ///< number of vertices
dvertex_t *vertexes; ///< array of vertices
int own_nodes; ///< \a nodes is owned by the structure
size_t numnodes; ///< number of nodes
dnode_t *nodes; ///< array of nodes
int own_texinfo; ///< \a texinfo is owned by the structure
size_t numtexinfo; ///< number of texinfo blocks
texinfo_t *texinfo; ///< array of texinfo blocks
int own_faces; ///< \a faces is owned by the structure
size_t numfaces; ///< number of faces
dface_t *faces; ///< array of faces
int own_clipnodes; ///< \a clipnodes is owned by the structure
size_t numclipnodes; ///< number of clipnodes
dclipnode_t *clipnodes; ///< array of clipnodes
int own_edges; ///< \a edges is owned by the structure
size_t numedges; ///< number of edges
dedge_t *edges; ///< array of edges
int own_marksurfaces;///< \a marksurfaces is owned by the structure
size_t nummarksurfaces; ///< number of marksurface indices
uint32_t *marksurfaces; ///< array of marksurfaces indices
int own_surfedges; ///< \a surfedge is owned by the structure
size_t numsurfedges; ///< number of surfedge indices
int32_t *surfedges; ///< array of surfedge indices
} bsp_t;
/** Create a bsp structure from a memory buffer.
The returned structure will be setup to point into the supplied buffer.
All structures within the bsp will be byte-swapped. For this reason, if
a callback is provided, the callback be called after byteswapping the
header, but before byteswapping any data in the lumps.
\param mem The buffer holding the bsp data.
\param size The size of the buffer. This is used for sanity checking.
\param cb Pointer to the callback function.
\param cbdata Pointer to extra data for the callback.
\return Initialized bsp structure.
\note The caller maintains ownership of the memory buffer. BSP_Free will
free only the bsp structure itself. However, if the caller wishes to
relinquish ownership of the buffer, set bsp_t::own_header to true.
*/
bsp_t *LoadBSPMem (void *mem, size_t size, void (*cb) (const bsp_t *, void *),
void *cbdata);
/** Load a bsp file into memory.
The return structre is set up the same as for LoadBSPMem, with the
exception that the BSP data memory is owned by the structure and will be
freed by BSP_Free.
\param file The open file from which to read the BSP data.
\param size The number of bytes to read. The BSP data may be a section
in a larger file (eg, in a pak file).
\return Initialized bsp structure.
*/
bsp_t *LoadBSPFile (QFile *file, size_t size);
/** Write the bsp data to the given file.
Does any necessary byte-swapping to ensure the written data is in
little-endian format. Automatically selects BSP-2 or BSP-29 based on the
data: if any value is too large for BSP-29, BSP-2 will be written,
otherwise BSP-29 will be written.
\param bsp The bsp data to be written to the given file.
\param file The file to which the data will be written.
\note \a file is *not* closes. It is the caller's responsibility to close
\a file.
*/
void WriteBSPFile (const bsp_t *bsp, QFile *file);
/** Create a fresh BSP struct ready to be populated with data.
Initially, none of the data pointers (which start as null) are owned by
the bsp, but as data is added using the Add functions, the pointers will
become owned.
\return Pointer to a blank-slate BSP strucutre.
\note Mixing use of an Add function with a private pointer for the
same data will result in undefined behavior.
*/
bsp_t *BSP_New (void);
/** Free the BSP data.
Only memory blocks owned by the BSP structure (and the structure itselve)
will be freed.
\param bsp Pointer to the BSP structure to be freed.
*/
void BSP_Free (bsp_t *bsp);
/** Add a single plane to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param plane Pointer to the single plane to be added to the BSP
structure.
*/
void BSP_AddPlane (bsp_t *bsp, const dplane_t *plane);
/** Add a single leaf to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param leaf Pointer to the single leaf to be added to the BSP
structure.
*/
void BSP_AddLeaf (bsp_t *bsp, const dleaf_t *leaf);
/** Add a single vertex to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param vertex Pointer to the single vertex to be added to the BSP
structure.
*/
void BSP_AddVertex (bsp_t *bsp, const dvertex_t *vertex);
/** Add a single node to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param node Pointer to the single node to be added to the BSP
structure.
*/
void BSP_AddNode (bsp_t *bsp, const dnode_t *node);
/** Add a single texinfo to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param texinfo Pointer to the single texinfo to be added to the BSP
structure.
*/
void BSP_AddTexinfo (bsp_t *bsp, const texinfo_t *texinfo);
/** Add a single face to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param face Pointer to the single face to be added to the BSP
structure.
*/
void BSP_AddFace (bsp_t *bsp, const dface_t *face);
/** Add a single clipnode to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param clipnode Pointer to the single clipnode to be added to the BSP
structure.
*/
void BSP_AddClipnode (bsp_t *bsp, const dclipnode_t *clipnode);
/** Add a single marksurface to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param marksurface The single marksurface to be added to the BSP
structure.
*/
void BSP_AddMarkSurface (bsp_t *bsp, int marksurface);
/** Add a single surfedge to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param surfedge Pointer to the single surfedge to be added to the BSP
structure.
*/
void BSP_AddSurfEdge (bsp_t *bsp, int surfedge);
/** Add a single edge to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param edge Pointer to the single edge to be added to the BSP
structure.
*/
void BSP_AddEdge (bsp_t *bsp, const dedge_t *edge);
/** Add a single model to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param model Pointer to the single model to be added to the BSP
structure.
*/
void BSP_AddModel (bsp_t *bsp, const dmodel_t *model);
/** Add lighmap data to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param lightdata Pointer to the lightmap data to be added to the BSP
structure. ref bsp_lighting
\param lightdatasize The number of bytes in the lightmap data
\note Call only once!
*/
void BSP_AddLighting (bsp_t *bsp, const byte *lightdata, size_t lightdatasize);
/** Add visibilityd data to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param visdata Pointer to the visibility data to be added to the BSP
structure. \ref bsp_visibility
\param visdatasize The number of bytes in the visibility data
\note Call only once!
*/
void BSP_AddVisibility (bsp_t *bsp, const byte *visdata, size_t visdatasize);
/** Add an entity data string to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param entdata Pointer to the entity data string to be added to the BSP
structure. \ref bsp_entities
\param entdatasize The number of bytes in the entity data string
\note Call only once!
*/
void BSP_AddEntities (bsp_t *bsp, const char *entdata, size_t entdatasize);
/** Add texture data to the BSP data.
\param bsp Pointer to the BSP structure to be modified.
\param texdata Pointer to the texture data to be added to the BSP
structure. \ref bsp_textures
\param texdatasize The number of bytes in the texture data
\note Call only once!
*/
void BSP_AddTextures (bsp_t *bsp, const byte *texdata, size_t texdatasize);
///@}
#endif//__QF_bspfile_h