reflex2q3/ReflexToQ3/includes/v6mapparser.cpp

//
//	Author:	Michael Cameron
//	Email:	chronokun@hotmail.com
//

#include "libraries.h"
#include "v6mapparser.hpp"
using namespace std;

#ifndef _MSC_VER
/*
    str*_s functions are microsoft only extensions of C string manip.
    mingw is ok with strtok_r, but is not ok with strcpy_r
    additionally, old versions of mingw may not be ok with strtok_r at all.
*/
inline char *strtok_s(char* s, const char* delm, char** context) {
    return strtok_r(s, delm, context);
}

inline char *strcpy_s(char *dest, const char *src) {
    return strcpy(dest, src);
}
#endif

const bool V6MapParser::LoadMap(const char* _kpcFileName)
{
	std::ifstream InFile;
	EParserState eState = PARSERSTATE_UNKNOWN;

	InFile.open(_kpcFileName, std::ios::in);
	if(InFile.is_open())
	{
		std::string Line;
		bool bAdvance = true;
		bool bGoing = true;
		while(bGoing)
		{
			if(bAdvance)
			{
				if(!std::getline(InFile, Line))
				{
					bGoing = false;
				}
			}
			bAdvance = true;
			if(eState == PARSERSTATE_UNKNOWN)
			{
				if(Line.find(KEYWORD_ENTITY) != string::npos)
				{
					eState = PARSERSTATE_ENTITY;
					continue;
				} else {
                    cout << "Warning: PARSERSTATE_UNKNOWN and no cases met." << endl;
                }
			}
			else if(eState == PARSERSTATE_ENTITY)
			{
				eState = this->ParseEntity(Line);
			}
			else if(eState == PARSERSTATE_WORLDSPAWN)
			{
				eState = this->ParseWorldSpawn(Line);
			}
			else if(eState == PARSERSTATE_BRUSH)
			{
				eState = this->ParseBrush(Line);
				//bAdvance = false;
			}
			else if(eState == PARSERSTATE_VERTEX)
			{
				eState = this->ParseVertex(Line);
				if(eState != PARSERSTATE_VERTEX)
				{
					bAdvance = false;
				}
			}
			else if(eState == PARSERSTATE_FACE)
			{
				eState = this->ParseFace(Line);
				if(eState != PARSERSTATE_FACE)
				{
					bAdvance = false;
				}
			}
		}
		InFile.close();
	}
	else
	{
		return(false);
	}

	return(true);
}

EParserState V6MapParser::ParseEntity(const std::string _Line)
{
	const size_t kszLineSize = 256;
	char pcLine[kszLineSize];
	const char* kpcDelim  = " ";
	char* pcToken;
	char* pcContext;

	strcpy_s(pcLine, _Line.c_str());
	pcToken = strtok_s(pcLine, kpcDelim, &pcContext);

    if (_Line.find(KEYWORD_BRUSH) != string::npos) {
        m_WorldSpawn.m_Brushes.push_back(TBrush());
        return PARSERSTATE_BRUSH;
    }
	while(pcToken != nullptr)
	{
		if(strcmp(pcToken, "\ttype") == 0)
		{
			pcToken = strtok_s(nullptr, kpcDelim, &pcContext);
			if(strcmp(pcToken, "WorldSpawn") == 0)
			{
				return(PARSERSTATE_WORLDSPAWN);
			}
			else
			{
				return(PARSERSTATE_UNKNOWN);
			}
		}
		else
		{
			return(PARSERSTATE_ENTITY);
		}
	}
	return(PARSERSTATE_UNKNOWN);
}

EParserState V6MapParser::ParseWorldSpawn(const std::string _Line)
{
	if(_Line.find(KEYWORD_BRUSH) != string::npos)
	{
		m_WorldSpawn.m_Brushes.push_back(TBrush());
		return(PARSERSTATE_BRUSH);
	}
	return(PARSERSTATE_WORLDSPAWN);
}

EParserState V6MapParser::ParseBrush(const std::string _Line)
{
	if(_Line.find(KEYWORD_BRUSH) != string::npos)
	{
		m_WorldSpawn.m_Brushes.push_back(TBrush());
		return(PARSERSTATE_BRUSH);
	}
	if(_Line.find(KEYWORD_VERTICES) != string::npos)
	{
		return(PARSERSTATE_VERTEX);
	}
	else if(_Line.find(KEYWORD_FACES) != string::npos)
	{
		return(PARSERSTATE_FACE);
	}
	return(PARSERSTATE_BRUSH);
}

EParserState V6MapParser::ParseVertex(const std::string _Line)
{
	const size_t kszLineSize = 2048;
	char pcLine[kszLineSize];
	const char* kpcDelim  = " \t";
	char* pcToken;
	char* pcContext;

	strcpy_s(pcLine, _Line.c_str());
	pcToken = strtok_s(pcLine, kpcDelim, &pcContext);
	Eigen::Vector3f Vert;
	int iTokenNum = 0;
	while(pcToken != NULL)
	{
		if(std::isdigit(pcToken[0], std::locale()) || pcToken[0] == '-')
		{
			double dValue = std::stod(pcToken);
			if(iTokenNum == 0)
			{
				Vert[X] = (float)dValue;
			}
			else if(iTokenNum == 1)
			{
				Vert[Y] = (float)dValue;
			}
			else if(iTokenNum == 2)
			{
				Vert[Z] = (float)dValue;
			}
			iTokenNum++;
		}
		else
		{
			return(PARSERSTATE_BRUSH);
		}

		pcToken = strtok_s(NULL, kpcDelim, &pcContext);
	}
	m_WorldSpawn.m_Brushes[m_WorldSpawn.m_Brushes.size()-1].m_Vertices.push_back(Vert);
	return(PARSERSTATE_VERTEX);
}

EParserState V6MapParser::ParseFace(const std::string _Line) {
    stringstream ss(_Line);
	string material;
	vector<int> Indices;
    TFace Face;
    float *f = &Face.m_fXOffset;
    string data;
    unsigned int i = 0;
    // For a primitive in Reflex, there is at least 9 and at most 10 fields.
    while (ss >> data) {
        if (i < 5) {
            if (isdigit(data[0], std::locale()) || data[0] == '-') {
                double dvalue = stod(data);
                *f = (float)dvalue;
                f++;
            } else {
                return PARSERSTATE_BRUSH;
            }
        } else if (i == 9) {
            ;
        } else {
            if (isdigit(data[0], std::locale()) || data[0] == '-') {
                Indices.push_back(stoi(data));
            } else {
                material = data;
            }
        }
        i++;
    }
	Face.m_Indices = Indices;
	Face.m_Material = material;
	m_WorldSpawn.m_Brushes[m_WorldSpawn.m_Brushes.size()-1].m_Faces.push_back(Face);
	return(PARSERSTATE_FACE);
}