229 lines
7.7 KiB
C++
229 lines
7.7 KiB
C++
#define KEYWORD_ENTITY "entity"
|
|
#define KEYWORD_BRUSH "brush"
|
|
#define KEYWORD_VERTICES "vertices"
|
|
#define KEYWORD_FACES "faces"
|
|
#define KEYWORD_GLOBAL "global"
|
|
#define KEYWORD_PREFAB "prefab"
|
|
|
|
#include "oopless-parser.hpp"
|
|
#include "brushdef.hpp"
|
|
#include "EntityConverter.hpp"
|
|
#include <sstream>
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
bool is_ebrush(std::vector<std::string> input) {
|
|
// defines are only used in this function.
|
|
#define KEYWORD_ENTBRUSH1 "type Teleporter"
|
|
#define KEYWORD_ENTBRUSH2 "type JumpPad"
|
|
for (const string &str : input) {
|
|
if (str.compare(KEYWORD_ENTBRUSH1) == 0 ||
|
|
str.compare(KEYWORD_ENTBRUSH2) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// place holding functions to test proper control flow.
|
|
bool write(const struct TBrush &geometry,
|
|
ofstream &fout,
|
|
void (*b) (stringstream &, const vector<TPlanePoints> &)) {
|
|
bool ok = true;
|
|
if (geometry.m_Vertices.size() < 1) {
|
|
cerr << "error: geometry has no vertices" << endl;
|
|
ok = false;
|
|
}
|
|
if (geometry.m_Faces.size() < 1) {
|
|
cerr << "error: geometry has no faces"<< endl;
|
|
ok = false;
|
|
}
|
|
if (ok) {
|
|
fout << GetBrushString(geometry, b);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
void write(const vector<string> &entity, ofstream &fo) {
|
|
;
|
|
}
|
|
|
|
// entities will vary widely depending on their type and available flags.
|
|
// for now, acquire entity data, and handle their conversion in the write methods.
|
|
vector<string> get_entity(ifstream &f) {
|
|
vector<string> output;
|
|
string line;
|
|
unsigned int pos = f.tellg();
|
|
while (getline(f, line)) {
|
|
// stop when
|
|
// entity or a prefab keyword
|
|
// brush keyword and the entity is not of the type teleporter or jumppad.
|
|
if ((line.find(KEYWORD_ENTITY) != string::npos ||
|
|
line.find(KEYWORD_PREFAB) != string::npos) || (
|
|
line.find(KEYWORD_BRUSH) != string::npos && !is_ebrush(output))) {
|
|
f.seekg(pos);
|
|
return output;
|
|
} else {
|
|
output.push_back(line);
|
|
}
|
|
pos = f.tellg();
|
|
}
|
|
}
|
|
|
|
vector<Eigen::Vector3f> parse_vertices(ifstream &f) {
|
|
#define FIRSTCH(x) x[0]
|
|
vector<Eigen::Vector3f> output;
|
|
string line;
|
|
unsigned int pos = f.tellg();
|
|
while(getline(f, line)) {
|
|
if (line.find(KEYWORD_FACES) != string::npos ||
|
|
line.find(KEYWORD_BRUSH) != string::npos ||
|
|
line.find(KEYWORD_ENTITY) != string::npos ||
|
|
line.find(KEYWORD_PREFAB) != string::npos) {
|
|
f.seekg(pos);
|
|
return output;
|
|
} else {
|
|
Eigen::Vector3f v;
|
|
stringstream ss(line);
|
|
string vdata;
|
|
unsigned int i = 0;
|
|
while (ss >> vdata) {
|
|
if (isdigit(FIRSTCH(vdata)) || FIRSTCH(vdata) == '-') {
|
|
double dvalue = stod(vdata);
|
|
v[i] = (float)dvalue;
|
|
}
|
|
// note: this prevents the index growing out of vector capacity
|
|
// alternatively can throw an exception when that happens instead
|
|
// to make it clear that an illegal line has been hit.
|
|
i = (i + 1) % 3;
|
|
}
|
|
output.push_back(v);
|
|
}
|
|
pos = f.tellg();
|
|
}
|
|
return output;
|
|
}
|
|
|
|
vector<struct TFace> parse_face(ifstream &f) {
|
|
#define FIRSTCH(x) x[0]
|
|
#define SECONDCH(x) x[1]
|
|
// it is possible for the next line to be unrelated to faces
|
|
// so it is needed to reset the stream prior to reading
|
|
// the new label, e.g '\tbrush'.
|
|
vector<struct TFace> output;
|
|
string line;
|
|
unsigned int pos = f.tellg();
|
|
while(getline(f, line)) {
|
|
if (line.find(KEYWORD_VERTICES) != string::npos ||
|
|
line.find(KEYWORD_BRUSH) != string::npos ||
|
|
line.find(KEYWORD_ENTITY) != string::npos ||
|
|
line.find(KEYWORD_PREFAB) != string::npos ||
|
|
line.find(KEYWORD_GLOBAL) != string::npos) {
|
|
f.seekg(pos);
|
|
return output;
|
|
} else {
|
|
struct TFace x;
|
|
float *f = &x.m_fXOffset;;
|
|
stringstream ss(line);
|
|
string fdata;
|
|
bool hex = false;
|
|
unsigned int i = 0;
|
|
while (ss >> fdata) {
|
|
if (i < 5) {
|
|
if (isdigit(FIRSTCH(fdata)) || FIRSTCH(fdata) == '-') {
|
|
double dvalue = stod(fdata);
|
|
*f = (float)dvalue;
|
|
f++;
|
|
}
|
|
// note: if there is a non-digit in the first 5 fields
|
|
// then it qualifies as an illegal line.
|
|
} else if (4 < i && i < 8) {
|
|
x.m_Indices.push_back(stoi(fdata));
|
|
} else if (8 <= i) {
|
|
if (!hex && fdata.length() > 1) {
|
|
if (SECONDCH(fdata) == 'x') {
|
|
// this is the unidentified hex digit.
|
|
// out of range for stoi
|
|
x.hex = strtoul(fdata.c_str(), NULL, 16);
|
|
hex = true;
|
|
}
|
|
} else if (!hex) {
|
|
x.m_Indices.push_back(stoi(fdata));
|
|
} else if (hex) {
|
|
x.m_Material = fdata;
|
|
} else {
|
|
;
|
|
}
|
|
}
|
|
i++;
|
|
} // end, per field iteration
|
|
output.push_back(x);
|
|
} // end else case, if line did not contain other keywords
|
|
pos = f.tellg();
|
|
} // end, per line iteration
|
|
// the odd case when the map file ends with a face indent.
|
|
return output;
|
|
}
|
|
|
|
struct TBrush parse_brush(ifstream &f) {
|
|
struct TBrush output;
|
|
string l;
|
|
getline(f, l);
|
|
// wip: note must return the entire brush, adjust control flow
|
|
if (l.find(KEYWORD_VERTICES) != string::npos) {
|
|
output.m_Vertices = parse_vertices(f);
|
|
}
|
|
getline(f, l);
|
|
if (l.find(KEYWORD_FACES) != string::npos) {
|
|
output.m_Faces = parse_face(f);
|
|
}
|
|
return output;
|
|
}
|
|
|
|
void parse_prefab(ifstream &f,
|
|
ofstream &out,
|
|
void (*b) (stringstream &, const vector<TPlanePoints> &)) {
|
|
string l;
|
|
getline(f, l);
|
|
if (l.find(KEYWORD_BRUSH) != string::npos) {
|
|
write(parse_brush(f), out, b);
|
|
} else if (l.find(KEYWORD_ENTITY) != string::npos) {
|
|
write(get_entity(f), out);
|
|
}
|
|
}
|
|
|
|
// note: can't use a single function pointer for variadic overloaded write function?
|
|
bool convertmap(const char * const infile,
|
|
const char * const outfile,
|
|
void (*brushdef) (stringstream &, const vector<TPlanePoints> &)) {
|
|
ifstream fin;
|
|
fin.open(infile);
|
|
if (!fin.good()){
|
|
cerr << "error: failed to open input file" << endl;
|
|
return false;
|
|
}
|
|
ofstream fout;
|
|
fout.open(outfile);
|
|
if (!fout.good()) {
|
|
cerr << "error: failed to open output file" << endl;
|
|
return false;
|
|
}
|
|
fout << "{\n"
|
|
<< "\"classname\" \"worldspawn\"" << endl;
|
|
string line;
|
|
while (getline(fin, line)) {
|
|
if (line.find(KEYWORD_PREFAB) != string::npos ||
|
|
line.find(KEYWORD_GLOBAL) != string::npos) {
|
|
parse_prefab(fin, fout, brushdef);
|
|
} else if (line.find(KEYWORD_ENTITY) != string::npos) {
|
|
write(get_entity(fin), fout);
|
|
} else if (line.find(KEYWORD_BRUSH) != string::npos) {
|
|
write(parse_brush(fin), fout, brushdef);
|
|
}
|
|
}
|
|
fout << "}" << endl;
|
|
fin.close();
|
|
fout.close();
|
|
return true;
|
|
}
|