reflex2q3/ReflexToQ3/wip/oopless-parser.cpp

#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 <sstream>
#include <iostream>
using namespace std;



void write(const struct TBrush &object, const char * const fn) {
    ;
}


void write(const vector<string> &entity, const char * const fn) {
    ;
}

// 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)) {
        if (line.find(KEYWORD_ENTITY) != string::npos || 
            line.find(KEYWORD_BRUSH) != string::npos || 
            line.find(KEYWORD_PREFAB) != string::npos) {
                f.seekg(pos);
                return output;
        } else {
            output.push_back(line);
        }
    }
}

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) == '-') {
                    v[i] = stod(vdata);
                }
                i = (i + 1) % 3;
            }
        }
        pos = f.tellg();
    }
    return output;
}

vector<struct TFace> parse_face(ifstream & f) {
#define FIRSTCH(x) x[0]
    // 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) {
                f.seekg(pos);
                return output;
        } else {
                struct TFace x;
                float *f = &x.m_fXOffset;;
                stringstream ss(line);
                string fdata;
                unsigned int i = 0;
                while (ss >> fdata) {
                    if (i < 5) {
                        if (isdigit(FIRSTCH(fdata)) || FIRSTCH(fdata) == '-') {
                            double dvalue = stod(fdata);
                            *f = (float)dvalue;
                            f++;
                        }
                    } else if (i == 9) {
                        ;
                    } else {
                        if (isdigit(FIRSTCH(fdata)) || FIRSTCH(fdata) == '-') {
                            x.m_Indices.push_back(stoi(fdata));
                        } else {
                            x.m_Material = fdata;
                        }
                    }
                    i++;
                } // end, per field iteration
                output.push_back(x);
        } 
        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);
    cout << l << endl;
    // wip: note must return the entire brush, adjust control flow
    if (l.find(KEYWORD_VERTICES) != string::npos) {
        output.m_Vertices = parse_vertices(f);        
    } else if (l.find(KEYWORD_FACES) != string::npos) {
        output.m_Faces = parse_face(f);
    }
    return output;
}

void parse_prefab(ifstream & f, const char * const out) {
    string l;
    getline(f, l);
    if (l.find(KEYWORD_BRUSH) != string::npos) {
        write(parse_brush(f), out);
    } else if (l.find(KEYWORD_ENTITY) != string::npos) {
        write(get_entity(f), out);
    }
}

bool loadmap(const char* infile, const char * const outfile) {
    ifstream fin;
    fin.open(infile);
    if (!fin.good()){
        return false;
    }
    // reflex maps start with a line saying which version it is,
    string line;
    while (getline(fin, line)) {
        if (line.find(KEYWORD_PREFAB) != string::npos ||
            line.find(KEYWORD_GLOBAL) != string::npos) {
                parse_prefab(fin, outfile);
        } else if (line.find(KEYWORD_ENTITY) != string::npos) {
                write(get_entity(fin), outfile);
        } else if (line.find(KEYWORD_BRUSH) != string::npos) {
                write(parse_brush(fin), outfile);
        }
    }
    fin.close();
    return true;
}