olegpz
/
ericw-tools
mirror of https://github.com/ericwa/ericw-tools.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ericw-tools/include/qbsp/qbsp.hh

427 lines
18 KiB
C++
Raw Blame History

/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 1997 Greg Lewis
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 the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
See file, 'COPYING', for details.
*/
// qbsp.h
#pragma once
#include <list>
#include <vector>
#include <map>
#include <memory>
#include <unordered_map>
#include <array>
#include <optional>
#include <string>
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <cmath>
#include <cstdint>
//#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <qbsp/winding.hh>
#include <common/bspfile.hh>
#include <common/aabb.hh>
#include <common/settings.hh>
#include <common/fs.hh>
enum texcoord_style_t
{
TX_QUAKED = 0,
TX_QUARK_TYPE1 = 1,
TX_QUARK_TYPE2 = 2,
TX_VALVE_220 = 3,
TX_BRUSHPRIM = 4
};
enum class conversion_t
{
none,
quake,
quake2,
valve,
bp
};
// data representation of only extended flags
// used by Q2 format; used by various systems.
struct extended_texinfo_t
{
contentflags_t contents = {0};
surfflags_t flags = {0};
int value = 0;
std::string animation;
};
namespace settings
{
struct wadpath
{
fs::path path;
bool external; // wads from this path are not to be embedded into the bsp, but will instead require the engine
// to load them from elsewhere. strongly recommended for eg halflife.wad
inline bool operator<(const wadpath &other) const { return path < other.path; }
};
struct setting_wadpathset : public setting_base
{
private:
std::set<wadpath> _paths;
public:
inline setting_wadpathset(setting_container *dictionary, const nameset &names, const setting_group *group = nullptr,
const char *description = "")
: setting_base(dictionary, names, group, description)
{
}
inline void addPath(const wadpath &path) { _paths.insert(path); }
constexpr const std::set<wadpath> &pathsValue() const { return _paths; }
inline bool copyFrom(const setting_base& other) override {
if (auto *casted = dynamic_cast<const setting_wadpathset *>(&other)) {
_paths = casted->_paths;
_source = casted->_source;
return true;
}
return false;
}
inline void reset() override {
_paths = {};
_source = source::DEFAULT;
}
bool parse(const std::string &settingName, parser_base_t &parser, source source) override
{
if (!parser.parse_token()) {
return false;
}
if (changeSource(source)) {
_paths.insert(wadpath{fs::path(parser.token), settingName[0] == 'x'});
}
return true;
}
std::string stringValue() const override
{
std::string paths;
for (auto &path : _paths) {
if (!paths.empty()) {
paths += " ; ";
}
paths += path.path.string();
if (path.external) {
paths += " (external)";
}
}
return paths;
}
std::string format() const override { return "path/to/wads"; }
};
extern setting_group game_target_group;
extern setting_group map_development_group;
extern setting_group common_format_group;
extern setting_group debugging_group;
enum class filltype_t
{
AUTO,
OUTSIDE,
INSIDE
};
enum class tjunclevel_t
{
NONE, // don't attempt to adjust faces at all - pass them through unchanged
ROTATE, // allow faces' vertices to be rotated to prevent zero-area triangles
RETOPOLOGIZE, // if a face still has zero-area triangles, allow it to be re-topologized
// by splitting it into multiple fans
DELAUNAY // attempt a delaunay triangulation first, only falling back to the prior two steps if it fails.
};
struct setting_tjunc : public setting_enum<tjunclevel_t>
{
public:
using setting_enum<tjunclevel_t>::setting_enum;
bool parse(const std::string &settingName, parser_base_t &parser, source source) override
{
if (settingName == "notjunc") {
this->setValue(tjunclevel_t::NONE, source);
return true;
}
return this->setting_enum<tjunclevel_t>::parse(settingName, parser, source);
}
};
class qbsp_settings : public common_settings
{
public:
setting_bool hexen2{this, "hexen2", false, &game_target_group, "target Hexen II's BSP format"};
setting_bool hlbsp{this, "hlbsp", false, &game_target_group, "target Half Life's BSP format"};
setting_bool q2bsp{this, "q2bsp", false, &game_target_group, "target Quake II's BSP format"};
setting_bool qbism{this, "qbism", false, &game_target_group, "target Qbism's extended Quake II BSP format"};
setting_bool bsp2{this, "bsp2", false, &game_target_group, "target Quake's extended BSP2 format"};
setting_bool bsp2rmq{
this, "2psb", false, &game_target_group, "target Quake's extended 2PSB format (RMQ compatible)"};
setting_int32 subdivide{this, "subdivide", 240, &common_format_group,
"change the subdivide threshold, in luxels. 0 will disable subdivision entirely"};
setting_bool nofill{this, "nofill", false, &debugging_group, "don't perform outside filling"};
setting_bool nomerge{this, "nomerge", false, &debugging_group, "don't perform face merging"};
setting_bool noclip{this, "noclip", false, &common_format_group, "don't write clip nodes (Q1-like BSP formats)"};
setting_bool noskip{this, "noskip", false, &debugging_group, "don't remove faces with the 'skip' texture"};
setting_bool nodetail{this, "nodetail", false, &debugging_group, "treat all detail brushes to structural"};
setting_bool onlyents{this, "onlyents", false, &map_development_group, "only updates .MAP entities"};
setting_bool splitsky{this, "splitsky", false, &debugging_group, "doesn't combine sky faces into one large face"};
setting_bool splitturb{this, {"litwater", "splitturb"}, true, &common_format_group,
"doesn't combine water faces into one large face"};
setting_redirect splitspecial{this, "splitspecial", {&splitsky, &splitturb}, &debugging_group,
"doesn't combine sky and water faces into one large face (splitturb + splitsky)"};
setting_invertible_bool transwater{
this, "transwater", true, &common_format_group, "compute portal information for transparent water"};
setting_bool transsky{
this, "transsky", false, &map_development_group, "compute portal information for transparent sky"};
setting_bool notextures{this, "notex", false, &common_format_group,
"write only placeholder textures to depend upon replacements, keep file sizes down, or to skirt copyrights"};
setting_enum<conversion_t> convertmapformat{this, "convert", conversion_t::none,
{{"quake", conversion_t::quake}, {"quake2", conversion_t::quake2}, {"valve", conversion_t::valve},
{"bp", conversion_t::bp}},
&common_format_group, "convert a .MAP to a different .MAP format"};
setting_invertible_bool oldaxis{this, "oldaxis", true, &debugging_group,
"uses alternate texture alignment which was default in tyrutils-ericw v0.15.1 and older"};
setting_bool forcegoodtree{
this, "forcegoodtree", false, &debugging_group, "force use of expensive processing for SolidBSP stage"};
setting_scalar midsplitsurffraction{this, "midsplitsurffraction", 0.f, 0.f, 1.f, &debugging_group,
"if 0 (default), use `maxnodesize` for deciding when to switch to midsplit bsp heuristic.\nif 0 < midsplitSurfFraction <= 1, switch to midsplit if the node contains more than this fraction of the model's\ntotal surfaces. Try 0.15 to 0.5. Works better than maxNodeSize for maps with a 3D skybox (e.g. +-128K unit maps)"};
setting_int32 maxnodesize{this, "maxnodesize", 1024, &debugging_group,
"triggers simpler BSP Splitting when node exceeds size (default 1024, 0 to disable)"};
setting_bool oldrottex{
this, "oldrottex", false, &debugging_group, "use old rotate_ brush texturing aligned at (0 0 0)"};
setting_scalar epsilon{
this, "epsilon", 0.0001, 0.0, 1.0, &debugging_group, "customize epsilon value for point-on-plane checks"};
setting_scalar microvolume{
this, "microvolume", 1.0, 0.0, 1000.0, &debugging_group, "microbrush volume"};
setting_bool contenthack{this, "contenthack", false, &debugging_group,
"hack to fix leaks through solids. causes missing faces in some cases so disabled by default"};
setting_bool leaktest{this, "leaktest", false, &map_development_group, "make compilation fail if the map leaks"};
setting_bool outsidedebug{this, "outsidedebug", false, &debugging_group, "write a .map after outside filling showing non-visible brush sides"};
setting_bool debugchop{this, "debugchop", false, &debugging_group,
"write a .map after ChopBrushes"};
setting_bool keepprt{this, "keepprt", false, &debugging_group,
"avoid deleting the .prt file on leaking maps"};
setting_bool includeskip{this, "includeskip", false, &common_format_group,
"don't cull skip faces from the list of renderable surfaces (Q2RTX)"};
setting_scalar worldextent{
this, "worldextent", 0.0, &debugging_group, "explicitly provide world extents; 0 will auto-detect"};
setting_int32 leakdist{this, "leakdist", 2, &debugging_group, "space between leakfile points"};
setting_bool forceprt1{
this, "forceprt1", false, &debugging_group, "force a PRT1 output file even if PRT2 is required for vis"};
setting_tjunc tjunc{this, { "tjunc", "notjunc" }, tjunclevel_t::DELAUNAY,
{ { "none", tjunclevel_t::NONE }, { "rotate", tjunclevel_t::ROTATE }, { "retopologize", tjunclevel_t::RETOPOLOGIZE }, { "delaunay", tjunclevel_t::DELAUNAY } },
&debugging_group, "T-junction fix level"};
setting_bool objexport{
this, "objexport", false, &debugging_group, "export the map file as .OBJ models during various CSG phases"};
setting_bool wrbrushes{this, {"wrbrushes", "bspx"}, false, &common_format_group,
"includes a list of brushes for brush-based collision"};
setting_redirect wrbrushesonly{this, {"wrbrushesonly", "bspxonly"}, {&wrbrushes, &noclip}, &common_format_group,
"includes BSPX brushes and does not output clipping hulls (wrbrushes + noclip)"};
setting_bool omitdetail{
this, "omitdetail", false, &map_development_group, "omit *all* detail brushes from the compile"};
setting_bool omitdetailwall{
this, "omitdetailwall", false, &map_development_group, "func_detail_wall brushes are omitted from the compile"};
setting_bool omitdetailillusionary{this, "omitdetailillusionary", false, &map_development_group,
"func_detail_illusionary brushes are omitted from the compile"};
setting_bool omitdetailfence{this, "omitdetailfence", false, &map_development_group,
"func_detail_fence brushes are omitted from the compile"};
setting_bool expand{
this, "expand", false, &common_format_group, "write hull 1 expanded brushes to expanded.map for debugging"};
setting_wadpathset wadpaths{this, {"wadpath", "xwadpath"}, &map_development_group,
"add a path to the wad search paths; wads found in xwadpath's will not be embedded, otherwise they will be embedded (if not -notex)"};
setting_bool notriggermodels{this, "notriggermodels", false, &common_format_group, "for supported game code only: triggers will not write a model\nout, and will instead just write out their mins/maxs."};
setting_set aliasdefs{this, "aliasdef", "\"path/to/file.def\" <multiple allowed>", &map_development_group, "path to an alias definition file, which can transform entities in the .map into other entities."};
setting_set texturedefs{this, "texturedefs", "\"path/to/file.def\" <multiple allowed>", &map_development_group, "path to a texture definition file, which can transform textures in the .map into other textures."};
setting_numeric<vec_t> lmscale{this, "lmscale", 1.0, &common_format_group, "change global lmscale (force _lmscale key on all entities). outputs the LMSCALE BSPX lump." };
setting_enum<filltype_t> filltype{this, "filltype", filltype_t::AUTO, { { "auto", filltype_t::AUTO }, { "inside", filltype_t::INSIDE }, { "outside", filltype_t::OUTSIDE } }, &common_format_group,
"whether to fill the map from the outside in (lenient), from the inside out (aggressive), or to automatically decide based on the hull being used."};
setting_invertible_bool allow_upgrade{this, "allowupgrade", true, &common_format_group, "allow formats to \"upgrade\" to compatible extended formats when a limit is exceeded (ie Quake BSP to BSP2)"};
setting_validator<setting_int32> maxedges{
[](setting_int32 &setting) {
return setting.value() == 0 || setting.value() >= 3;
}, this, "maxedges", 64, &map_development_group, "the max number of edges/vertices on a single face before it is split into another face"};
void setParameters(int argc, const char **argv) override
{
common_settings::setParameters(argc, argv);
programDescription = "qbsp performs geometric level processing of Quake .MAP files to create\nQuake .BSP files.\n\n";
remainderName = "sourcefile.map [destfile.bsp]";
}
void initialize(int argc, const char **argv) override;
void postinitialize(int argc, const char **argv) override;
bool fVerbose = true;
bool fAllverbose = false;
bool fNoverbose = false;
const bspversion_t *target_version = nullptr;
const gamedef_t *target_game = nullptr;
fs::path map_path;
fs::path bsp_path;
std::unordered_map<std::string, std::tuple<std::string, std::optional<extended_texinfo_t>>> loaded_texture_defs;
std::unordered_map<std::string, entdict_t> loaded_entity_defs;
private:
void load_texture_def(const std::string &pathname);
void load_entity_def(const std::string &pathname);
};
}; // namespace settings
extern settings::qbsp_settings qbsp_options;
// planenum for a leaf
constexpr int32_t PLANENUM_LEAF = -1;
/*
* The quality of the bsp output is highly sensitive to these epsilon values.
* Notes:
* - some calculations are sensitive to errors and need the various
* epsilons to be such that EQUAL_EPSILON < CONTINUOUS_EPSILON.
* ( TODO: re-check if CONTINUOUS_EPSILON is still directly related )
*/
constexpr vec_t ANGLEEPSILON = 0.000001;
constexpr vec_t ZERO_EPSILON = 0.0001;
constexpr vec_t EQUAL_EPSILON = 0.0001;
constexpr vec_t CONTINUOUS_EPSILON = 0.0005;
// the exact bounding box of the brushes is expanded some for the headnode
// volume. this is done to avoid a zero-bounded node/leaf, the particular
// value doesn't matter but it shows up in the .bsp output.
constexpr double SIDESPACE = 24.0;
#include <common/cmdlib.hh>
#include <common/mathlib.hh>
struct maptexinfo_t
{
texvecf vecs; /* [s/t][xyz offset] */
int32_t miptex = 0;
surfflags_t flags = {};
int32_t value = 0; // Q2-specific
int32_t next = -1; // Q2-specific
std::optional<size_t> outputnum = std::nullopt; // nullopt until added to bsp
constexpr auto as_tuple() const { return std::tie(vecs, miptex, flags, value, next); }
constexpr bool operator<(const maptexinfo_t &other) const { return as_tuple() < other.as_tuple(); }
constexpr bool operator>(const maptexinfo_t &other) const { return as_tuple() > other.as_tuple(); }
};
class mapentity_t;
struct face_fragment_t
{
std::vector<size_t> output_vertices; // filled in by TJunc
std::vector<int64_t> edges; // only filled in MakeFaceEdges
std::optional<size_t> outputnumber; // only valid for original faces after
// write surfaces
};
struct portal_t;
struct face_t
{
int planenum;
planeside_t planeside; // which side is the front of the face
int texinfo;
contentflags_t contents; // contents on the front of the face
int16_t lmshift;
winding_t w;
std::vector<size_t> original_vertices; // the vertices of this face before fragmentation; filled in by EmitVertices
std::vector<face_fragment_t> fragments; // the vertices of this face post-fragmentation; filled in by TJunc
qvec3d origin;
vec_t radius;
portal_t *portal;
};
// there is a node_t structure for every node and leaf in the bsp tree
struct bspbrush_t;
struct side_t;
struct node_t
{
// both leafs and nodes
aabb3d bounds; // bounding volume, not just points inside
node_t *parent;
// this is also a bounding volume like `bounds`
std::unique_ptr<bspbrush_t> volume; // one for each leaf/node
// information for decision nodes
int planenum; // -1 = leaf node
int firstface; // decision node only
int numfaces; // decision node only
twosided<std::unique_ptr<node_t>> children; // children[0] = front side, children[1] = back side of plane. only valid for decision nodes
std::list<std::unique_ptr<face_t>> facelist; // decision nodes only, list for both sides
side_t *side; // the side that created the node
// information for leafs
contentflags_t contents; // leaf nodes (0 for decision nodes)
std::vector<bspbrush_t *> original_brushes;
std::vector<face_t *> markfaces; // leaf nodes only, point to node faces
portal_t *portals;
int visleafnum; // -1 = solid
int viscluster; // detail cluster for faster vis
int outside_distance; // -1 = can't reach outside, 0 = first void node, >0 = distance from void, in number of
// portals used to write leak lines that take the shortest path to the void
int occupied; // 0=can't reach entity, 1 = has entity, >1 = distance from leaf with entity
mapentity_t *occupant; // example occupant, for leak hunting
bool detail_separator; // for vis portal generation. true if ALL faces on node, and on all descendant nodes/leafs,
// are detail.
uint32_t firstleafbrush; // Q2
uint32_t numleafbrushes;
int32_t area;
};
void InitQBSP(int argc, const char **argv);
void InitQBSP(const std::vector<std::string>& args);
void ProcessFile();
int qbsp_main(int argc, const char **argv);
Reference in New Issue View Git Blame Copy Permalink