467 lines
14 KiB
C++
467 lines
14 KiB
C++
/*
|
|
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.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <qbsp/qbsp.hh>
|
|
|
|
#include <common/bspfile.hh>
|
|
#include <common/parser.hh>
|
|
#include "common/cmdlib.hh"
|
|
|
|
#include <optional>
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <unordered_map>
|
|
#include <list>
|
|
#include <mutex>
|
|
#include <shared_mutex>
|
|
#include <string_view>
|
|
|
|
struct bspbrush_t;
|
|
|
|
// kind of a parallel to std::source_location in C++20
|
|
// but this represents a location in a .map file where
|
|
// something happens.
|
|
struct map_source_location
|
|
{
|
|
// the source name of this location; may be a .map file path,
|
|
// or some other string that describes where this location came
|
|
// to be. note that because the locations only live for the lifetime
|
|
// of the object it is belonging to, whatever this string
|
|
// points to must out-live the object.
|
|
std::shared_ptr<std::string> source_name = nullptr;
|
|
|
|
// the line number that this location is associated to, if any. Synthetic
|
|
// locations may not necessarily have an associated line number.
|
|
std::optional<size_t> line_number = std::nullopt;
|
|
|
|
// reference to a location of the object that derived us. this is mainly
|
|
// for synthetic locations; ie a bspbrush_t's sides aren't themselves generated
|
|
// by a source or line, but they are derived from a mapbrush_t which does have
|
|
// a location. The object it points to must outlive this object. this is mainly
|
|
// for debugging.
|
|
std::optional<std::reference_wrapper<const map_source_location>> derivative = std::nullopt;
|
|
|
|
explicit operator bool() const { return source_name != nullptr; }
|
|
|
|
// return a modified source location with only the line changeed
|
|
inline map_source_location on_line(size_t new_line) const
|
|
{
|
|
return { source_name, new_line, derivative };
|
|
}
|
|
|
|
// if we update to C++20 we could use this to track where location objects come from:
|
|
// std::source_location created_location;
|
|
};
|
|
|
|
// FMT support
|
|
template<>
|
|
struct fmt::formatter<map_source_location>
|
|
{
|
|
constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) { return ctx.end(); }
|
|
|
|
template<typename FormatContext>
|
|
auto format(const map_source_location &v, FormatContext &ctx) -> decltype(ctx.out())
|
|
{
|
|
if (v.source_name) {
|
|
format_to(ctx.out(), "{}", *v.source_name.get());
|
|
} else {
|
|
format_to(ctx.out(), "unknown/unset location");
|
|
}
|
|
|
|
if (v.line_number.has_value()) {
|
|
format_to(ctx.out(), "[line {}]", v.line_number.value());
|
|
}
|
|
|
|
return ctx.out();
|
|
}
|
|
};
|
|
|
|
struct mapface_t
|
|
{
|
|
size_t planenum;
|
|
std::array<qvec3d, 3> planepts{};
|
|
std::string texname{};
|
|
int texinfo = 0;
|
|
map_source_location line;
|
|
bool bevel = false;
|
|
bool visible = false;
|
|
winding_t winding; // winding used to calculate bevels
|
|
|
|
surfflags_t flags{};
|
|
|
|
// Q2 stuff
|
|
contentflags_t contents{};
|
|
int value = 0;
|
|
|
|
// for convert
|
|
std::optional<extended_texinfo_t> raw_info;
|
|
|
|
bool set_planepts(const std::array<qvec3d, 3> &pts);
|
|
|
|
const texvecf &get_texvecs() const;
|
|
void set_texvecs(const texvecf &vecs);
|
|
|
|
const qbsp_plane_t &get_plane() const;
|
|
};
|
|
|
|
enum class brushformat_t
|
|
{
|
|
NORMAL,
|
|
BRUSH_PRIMITIVES
|
|
};
|
|
|
|
class mapbrush_t
|
|
{
|
|
public:
|
|
std::vector<mapface_t> faces;
|
|
brushformat_t format = brushformat_t::NORMAL;
|
|
aabb3d bounds {};
|
|
std::optional<uint32_t> outputnumber; /* only set for original brushes */
|
|
map_source_location line;
|
|
};
|
|
|
|
struct lumpdata
|
|
{
|
|
int count;
|
|
int index;
|
|
void *data;
|
|
};
|
|
|
|
enum class rotation_t
|
|
{
|
|
none,
|
|
hipnotic,
|
|
origin_brush
|
|
};
|
|
|
|
class mapentity_t
|
|
{
|
|
public:
|
|
#ifdef _MSC_VER
|
|
// FIXME: this is to allow MSVC to compile
|
|
mapentity_t() = default;
|
|
mapentity_t(mapentity_t &&) noexcept = default;
|
|
mapentity_t(const mapentity_t &) = delete;
|
|
mapentity_t &operator=(const mapentity_t &) = delete;
|
|
mapentity_t &operator=(mapentity_t &&) noexcept = default;
|
|
#endif
|
|
|
|
qvec3d origin{};
|
|
rotation_t rotation;
|
|
|
|
std::list<mapbrush_t> mapbrushes;
|
|
|
|
size_t numboxbevels = 0;
|
|
size_t numedgebevels = 0;
|
|
|
|
// key/value pairs in the order they were parsed
|
|
entdict_t epairs;
|
|
|
|
aabb3d bounds;
|
|
std::vector<std::unique_ptr<bspbrush_t>> brushes;
|
|
|
|
int firstoutputfacenumber = -1;
|
|
std::optional<size_t> outputmodelnumber = std::nullopt;
|
|
|
|
int32_t areaportalnum = 0;
|
|
std::array<int32_t, 2> portalareas = {};
|
|
};
|
|
|
|
struct maptexdata_t
|
|
{
|
|
std::string name;
|
|
surfflags_t flags;
|
|
int32_t value;
|
|
std::string animation;
|
|
int32_t animation_miptex = -1;
|
|
};
|
|
|
|
#include <common/imglib.hh>
|
|
|
|
extern std::shared_mutex map_planes_lock;
|
|
|
|
struct hashvert_t
|
|
{
|
|
qvec3d point;
|
|
size_t num;
|
|
};
|
|
|
|
struct mapplane_t : qbsp_plane_t
|
|
{
|
|
std::optional<size_t> outputnum;
|
|
|
|
inline mapplane_t(const qbsp_plane_t ©) : qbsp_plane_t(copy) { }
|
|
};
|
|
|
|
constexpr size_t hash_combine(size_t lhs, size_t rhs)
|
|
{
|
|
return lhs ^ rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
|
|
}
|
|
|
|
struct qbsp_plane_hash
|
|
{
|
|
size_t operator()(const qbsp_plane_t &plane) const
|
|
{
|
|
return hash_combine(
|
|
std::hash<vec_t>()((int32_t) (fabs(plane.get_dist()) / 2.0)),
|
|
std::hash<plane_type_t>()(plane.get_type())
|
|
);
|
|
}
|
|
};
|
|
|
|
struct qbsp_plane_eq
|
|
{
|
|
bool operator()(const qbsp_plane_t &a, const qbsp_plane_t &b) const
|
|
{
|
|
return qv::epsilonEqual(a, b);
|
|
}
|
|
};
|
|
|
|
struct mapdata_t
|
|
{
|
|
/* Arrays of actual items */
|
|
std::vector<mapentity_t> entities;
|
|
|
|
// total number of brushes in the map
|
|
size_t total_brushes;
|
|
|
|
// this vector stores all of the planes that can potentially be
|
|
// output in the BSP, from the map's own sides. The positive planes
|
|
// come first (are even-numbered, with 0 being even) and the negative
|
|
// planes are odd-numbered.
|
|
std::vector<mapplane_t> planes;
|
|
// planes hashed by dist
|
|
std::unordered_multimap<qbsp_plane_t, size_t, qbsp_plane_hash, qbsp_plane_eq> plane_hash;
|
|
|
|
// add the specified plane to the list
|
|
inline size_t add_plane(const qplane3d &plane)
|
|
{
|
|
planes.emplace_back(plane);
|
|
planes.emplace_back(-plane);
|
|
|
|
auto &positive = planes[planes.size() - 2];
|
|
auto &negative = planes[planes.size() - 1];
|
|
|
|
size_t result;
|
|
|
|
if (positive.get_normal()[static_cast<int32_t>(positive.get_type()) % 3] < 0.0) {
|
|
std::swap(positive, negative);
|
|
result = planes.size() - 1;
|
|
} else {
|
|
result = planes.size() - 2;
|
|
}
|
|
|
|
plane_hash.emplace(positive, planes.size() - 2);
|
|
plane_hash.emplace(negative, planes.size() - 1);
|
|
|
|
return result;
|
|
}
|
|
|
|
// find the specified plane in the list if it exists. throws
|
|
// if not.
|
|
inline size_t find_plane(const qplane3d &plane)
|
|
{
|
|
auto range = plane_hash.equal_range(plane);
|
|
for (auto it = range.first; it != range.second; ++it) {
|
|
if (qv::epsilonEqual(it->first, plane)) {
|
|
return it->second;
|
|
}
|
|
}
|
|
|
|
throw std::bad_function_call();
|
|
}
|
|
|
|
// find the specified plane in the list if it exists, or
|
|
// return a new one
|
|
inline size_t add_or_find_plane(const qplane3d &plane)
|
|
{
|
|
auto range = plane_hash.equal_range(plane);
|
|
for (auto it = range.first; it != range.second; ++it) {
|
|
if (qv::epsilonEqual(it->first, plane)) {
|
|
return it->second;
|
|
}
|
|
}
|
|
|
|
return add_plane(plane);
|
|
}
|
|
|
|
inline const qbsp_plane_t &get_plane(size_t pnum)
|
|
{
|
|
return planes[pnum];
|
|
}
|
|
|
|
std::vector<maptexdata_t> miptex;
|
|
std::vector<maptexinfo_t> mtexinfos;
|
|
|
|
/* quick lookup for texinfo */
|
|
std::map<maptexinfo_t, int> mtexinfo_lookup;
|
|
|
|
/* map from plane hash code to list of indicies in `planes` vector */
|
|
std::unordered_map<int, std::vector<int>> planehash;
|
|
|
|
// hashed vertices; generated by EmitVertices
|
|
std::map<qvec3i, std::list<hashvert_t>> hashverts;
|
|
|
|
// find vector of points in hash closest to vec
|
|
inline auto find_hash_vector(const qvec3d &vec)
|
|
{
|
|
return hashverts.find({floor(vec[0]), floor(vec[1]), floor(vec[2])});
|
|
}
|
|
|
|
// find output index for specified already-output vector.
|
|
inline std::optional<size_t> find_emitted_hash_vector(const qvec3d &vert)
|
|
{
|
|
if (auto it = find_hash_vector(vert); it != hashverts.end()) {
|
|
for (hashvert_t &hv : it->second) {
|
|
if (qv::epsilonEqual(hv.point, vert, POINT_EQUAL_EPSILON)) {
|
|
return hv.num;
|
|
}
|
|
}
|
|
}
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
// add vector to hash
|
|
inline void add_hash_vector(const qvec3d &point, const size_t &num)
|
|
{
|
|
// insert each vert at floor(pos[axis]) and floor(pos[axis]) + 1 (for each axis)
|
|
// so e.g. a vert at (0.99, 0.99, 0.99) shows up if we search at (1.01, 1.01, 1.01)
|
|
// this is a bit wasteful..
|
|
for (int32_t x = -1; x <= 1; x++) {
|
|
for (int32_t y = -1; y <= 1; y++) {
|
|
for (int32_t z = -1; z <= 1; z++) {
|
|
const qvec3i h{floor(point[0]) + x, floor(point[1]) + y, floor(point[2]) + z};
|
|
hashverts[h].push_front({point, num});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// hashed edges; generated by EmitEdges
|
|
std::map<std::pair<size_t, size_t>, int64_t> hashedges;
|
|
|
|
inline void add_hash_edge(size_t v1, size_t v2, int64_t i) { hashedges.emplace(std::make_pair(v1, v2), i); }
|
|
|
|
/* Misc other global state for the compile process */
|
|
bool leakfile = false; /* Flag once we've written a leak (.por/.pts) file */
|
|
|
|
// Final, exported BSP
|
|
mbsp_t bsp;
|
|
|
|
// bspx data
|
|
std::vector<uint8_t> exported_lmshifts;
|
|
bool needslmshifts = false;
|
|
std::vector<uint8_t> exported_bspxbrushes;
|
|
|
|
// Q2 stuff
|
|
int32_t c_areas = 0;
|
|
int32_t numareaportals = 0;
|
|
// running total
|
|
uint32_t brush_offset = 0;
|
|
// Small cache for image meta in the current map
|
|
std::unordered_map<std::string, std::optional<img::texture_meta>> meta_cache;
|
|
// load or fetch image meta associated with the specified name
|
|
const std::optional<img::texture_meta> &load_image_meta(const std::string_view &name);
|
|
// whether we had attempted loading texture stuff
|
|
bool textures_loaded = false;
|
|
|
|
// helpers
|
|
const std::string &miptexTextureName(int mt) const { return miptex.at(mt).name; }
|
|
|
|
const std::string &texinfoTextureName(int texinfo) const { return miptexTextureName(mtexinfos.at(texinfo).miptex); }
|
|
|
|
int skip_texinfo;
|
|
|
|
mapentity_t *world_entity();
|
|
|
|
void reset();
|
|
};
|
|
|
|
extern mapdata_t map;
|
|
|
|
void CalculateWorldExtent(void);
|
|
|
|
bool ParseEntity(parser_t &parser, mapentity_t *entity, const map_source_location &map_source);
|
|
|
|
void ProcessExternalMapEntity(mapentity_t *entity);
|
|
void ProcessAreaPortal(mapentity_t *entity);
|
|
bool IsWorldBrushEntity(const mapentity_t *entity);
|
|
bool IsNonRemoveWorldBrushEntity(const mapentity_t *entity);
|
|
void LoadMapFile(void);
|
|
void ConvertMapFile(void);
|
|
void ProcessMapBrushes();
|
|
|
|
struct quark_tx_info_t
|
|
{
|
|
bool quark_tx1 = false;
|
|
bool quark_tx2 = false;
|
|
|
|
std::optional<extended_texinfo_t> info;
|
|
};
|
|
|
|
int FindMiptex(
|
|
const char *name, std::optional<extended_texinfo_t> &extended_info, bool internal = false, bool recursive = true);
|
|
inline int FindMiptex(const char *name, bool internal = false, bool recursive = true)
|
|
{
|
|
std::optional<extended_texinfo_t> extended_info;
|
|
return FindMiptex(name, extended_info, internal, recursive);
|
|
}
|
|
int FindTexinfo(const maptexinfo_t &texinfo);
|
|
|
|
void PrintEntity(const mapentity_t *entity);
|
|
|
|
void WriteEntitiesToString();
|
|
|
|
qvec3d FixRotateOrigin(mapentity_t *entity);
|
|
|
|
/** Special ID for the collision-only hull; used for wrbrushes/Q2 */
|
|
constexpr int HULL_COLLISION = -1;
|
|
|
|
/* Create BSP brushes from map brushes */
|
|
void Brush_LoadEntity(mapentity_t *entity, const int hullnum);
|
|
|
|
std::list<face_t *> CSGFace(
|
|
face_t *srcface, const mapentity_t *srcentity, const bspbrush_t *srcbrush, const node_t *srcnode);
|
|
void TJunc(node_t *headnode);
|
|
int MakeFaceEdges(node_t *headnode);
|
|
void EmitVertices(node_t *headnode);
|
|
void ExportClipNodes(mapentity_t *entity, node_t *headnode, const int hullnum);
|
|
void ExportDrawNodes(mapentity_t *entity, node_t *headnode, int firstface);
|
|
|
|
struct bspxbrushes_s
|
|
{
|
|
std::vector<uint8_t> lumpdata;
|
|
};
|
|
void BSPX_Brushes_Finalize(struct bspxbrushes_s *ctx);
|
|
void BSPX_Brushes_Init(struct bspxbrushes_s *ctx);
|
|
|
|
void ExportObj_Faces(const std::string &filesuffix, const std::vector<const face_t *> &faces);
|
|
void ExportObj_Brushes(const std::string &filesuffix, const std::vector<const bspbrush_t *> &brushes);
|
|
void ExportObj_Nodes(const std::string &filesuffix, const node_t *nodes);
|
|
void ExportObj_Marksurfaces(const std::string &filesuffix, const node_t *nodes);
|
|
|
|
void WriteBspBrushMap(const fs::path &name, const std::vector<std::unique_ptr<bspbrush_t>> &list);
|
|
|
|
bool IsValidTextureProjection(const qvec3f &faceNormal, const qvec3f &s_vec, const qvec3f &t_vec);
|