Auxillary VMF Map Editor

// ==========
// object.h
// ==========

// Vector and Plane may not even be necessary anymore since I'm
// using Armadillo libraries. I may get rid of all these classes later.

#ifndef OBJECTS_H_INCLUDED
#define OBJECTS_H_INCLUDED

#include <iostream>
using namespace std;

class Vector
{
public:
    float x, y, z, d;
    Vector (const float& = 0, const float& = 0, const float& = 0);
    bool operator == (const Vector&);
    Vector operator + (const Vector&);
    Vector operator - (const Vector&);
    Vector operator * (const float&);
    Vector operator / (const float&);
    Vector operator ^ (const Vector&);
    float operator * (const Vector&);
};

class Plane
{
public:
    Vector a, b, c, n;
    Plane (const Vector&, const Vector&, const Vector&);

private:
    void getNormal ();
};

ostream& operator << (ostream&, const Vector&);
bool operator < (const Vector&, const Vector&);
Vector norm (Vector&);

#endif // OBJECTS_H_INCLUDED





// =============
// objects.cpp
// =============

#include <cmath>
#include "objects.h"
using namespace std;

// With a Vector type, you can initialize, compare, add and subtract
// other Vectors, multiply and divide by scalars, do a cross product (^)
// and dot product (*) between two Vectors, normalize a Vector, and
// print out a Vector directly to the console.

Vector::Vector (const float& a, const float& b, const float& c) {
    x = a; y = b; z = c; }

bool Vector::operator == (const Vector& param) {
    return (x == param.x) && (y == param.y) && (z == param.z); }

ostream& operator << (ostream& out, const Vector& param) {
    return out << "(" << param.x << ", " << param.y << ", " << param.z << ")"; }

Vector Vector::operator + (const Vector& param) {
    return Vector (x + param.x, y + param.y, z + param.z); }

Vector Vector::operator - (const Vector& param) {
    return Vector (x - param.x, y - param.y, z - param.z); }

Vector Vector::operator * (const float& param) {
    return Vector (x * param, y * param, z * param); }

Vector Vector::operator / (const float& param) {
    return Vector (x / param, y / param, z / param); }

float Vector::operator * (const Vector& param) {
    return (x * param.x) + (y * param.y) + (z * param.z); }

Vector Vector::operator ^ (const Vector& param)
{
    Vector temp;
    temp.x = (y * param.z) - (z * param.y);
    temp.y = (z * param.x) - (x * param.z);
    temp.z = (x * param.y) - (y * param.x);
    return temp;
}

bool operator < (const Vector& a, const Vector& b)
{
    if (a.x != b.x) return (a.x < b.x);
    else if (a.y != b.y) return (a.y < b.y);
    else return (a.z < b.z);
}

Vector norm (Vector& param) {
    return param / sqrt (param * param); }

// A Plane type holds the Vectors of three points that make up
// the Plane. It then calculates its normal and assigns that to d.

Plane::Plane (const Vector& d, const Vector& e, const Vector& f)
{
    a = d; b = e; c = f;
    getNormal ();
}

void Plane::getNormal ()
{
    Vector temp (
    Vector (b.x - a.x, b.y - a.y, b.z - a.z) ^
    Vector (c.x - b.x, c.y - b.y, c.z - b.z));

    n = norm (temp);
    n.d = n * a;
}





// ===========
// vmfdata.h
// ===========

#ifndef DATA_H_INCLUDED
#define DATA_H_INCLUDED

#include <map>
#include <tuple>
#include <string>
#include <vector>
#include "objects.h"

using namespace std;

// This block holds reused sections of the VMF structure.
// They will be part of what's below this block.

struct Editor
{
    Vector color;
    int visgroupid;
    int group;
    bool visgroupshown;
    bool visgroupautoshown;
    string comments;
};

struct Solid
{
    struct Side
    {
        Vector plane[3];
        string material;
        Vector uaxis[2];
        Vector vaxis[2];
        float rotation;
        int lightmapscale;
        int smoothing_groups;

        struct Dispinfo
        {
            int power;
            Vector startposition;
            float elevation;
            bool subdiv;
            vector<vector<Vector>> normals;
            vector<vector<float>> distances;
            vector<vector<Vector>> offsets;
            vector<vector<Vector>> offset_normals;
            vector<vector<float>> alphas;
            vector<vector<int>> triangle_tags;
            vector<vector<int>> allowed_verts;
        }
        dispinfo;
    };
    map<int, Side> side;

    Editor editor;
};

struct Hidden
{
    map<int, Solid> solid;
};

// A struct that holds the VMF file.
// https://developer.valvesoftware.com/wiki/VMF_documentation

struct Data
{
    struct Versioninfo
    {
        int editorversion;
        int editorbuild;
        int mapversion;
        int formatversion;
        bool prefab;
    }
    versioninfo;

    struct Visgroups
    {
        int visgroupid;
        Vector rgb;
        map<string, Visgroups> branch;
    };
    map<string, Visgroups> visgroups;

    struct Viewsettings
    {
        bool bSnapToGrid;
        bool bShowGrid;
        bool bShowLogicalGrid;
        int nGridSpacing;
        bool bShow3DGrid;
    }
    viewsettings;

    struct World
    {
        string mapversion;
        string classname;
        string skyname;
        Hidden hidden;
        map<int, Solid> solid;

        struct Group
        {
            Editor editor;
        };
        map<int, Group> group;
    };
    map<int, World> world;

    struct Entity
    {
        string classname;
        int spawnflags;
        Vector origin;
        Solid solid;
        Editor editor;
        Hidden hidden;
        map<string, string> properties;

        struct Connections
        {
            map<string, tuple<string, string, string, float, bool>> output;
        }
        connections;
    };
    map<int, Entity> entity;

    struct Cameras
    {
        int activecamera;

        struct Camera
        {
            Vector position;
            Vector look;
        };
        vector<Camera> camera;
    }
    cameras;

    struct Cordon
    {
        Vector mins;
        Vector maxs;
        bool active;
    }
    cordon;
};

#endif // DATA_H_INCLUDED





// =======
// vmf.h
// =======

#ifndef VMFREAD_H_INCLUDED
#define VMFREAD_H_INCLUDED

#include <fstream>
#include "vmfdata.h"
using namespace std;

#define FILE_IS_OPEN   0
#define FILE_NOT_OPEN  1
#define FILE_NOT_VALID 2

class VMF
{
public:
    Data data;
    int open (const string&);
    void close ();
    void read ();

private:
    fstream file;
    string tokenize ();
};

#endif // VMFREAD_H_INCLUDED





// =========
// vmf.cpp
// =========

#include "vmf.h"
using namespace std;

void VMF::close () {
    file.close (); }

int VMF::open (const string& filename)
{
    file.open (filename, fstream::in | fstream::out);
    if (!file.is_open()) return FILE_NOT_OPEN;
    else if (filename.find(".vmf") == string::npos) return FILE_NOT_VALID;
    else return FILE_IS_OPEN;
}

string VMF::tokenize ()
{
    bool withinQuotes = false;
    string token;
    while (true)
    {
        char ch = file.get ();
        if (file.eof ()) return token;
        else if (withinQuotes == true && ch == '\"') return token;
        else if (withinQuotes == false)
        {
            if (token.length() == 0 && ch == '\"') { withinQuotes = true; continue; }
            if (ch == ' ' || ch == '\n' || ch == '\n' || ch == '\t') return token;
            if (token.length() == 0 && ch == '{' || ch == '}') { token = ch; return token; }
            if (ch == '{' || ch == '}') { file.unget(); return token; }
        }
        token.push_back(ch);
    }
}

void VMF::read ()
{
    while (!file.eof ())
    {
        string token;
        token = tokenize ();
        if (token != "") cout << token << endl;
    }
}





// ===============
// planeconv.cpp
// ===============

// Using the Armadillo library.
// http://arma.sourceforge.net/

#include <set>
#include <armadillo>
#include "vmf.h"
#include "objects.h"

#define SMALL_NUM 0.0001

using namespace std;
using namespace arma;

// Uncomment this code if you want to debug.
// A set of planes used for debugging. They come from a VMF file.

// Plane plane[] =
// {
//  Plane ({384, 128, 384}, {384, -128, 384}, {0, 0, 256}),
//  Plane ({384, -128, 128}, {384, 128, 128}, {0, 256, 0}),
//  Plane ({0, 0, 256}, {0, 0, 0}, {0, 256, 0}),
//  Plane ({384, -128, 128}, {384, -128, 384}, {384, 128, 384}),
//  Plane ({0, 256, 256}, {0, 256, 0}, {384, 128, 128}),
//  Plane ({0, 0, 0}, {0, 0, 256}, {384, -128, 384})
// };

// Get the intersection point of three planes if there is one.
// http://www.gamedev.net/topic/304411-three-plane-intersection-point/

void plane3Int (const Vector& i, const Vector& j, const Vector& k, mat& result, bool& success)
{
    success = false;
    static mat abc(3, 3);
    static vec d(3);

    abc(0, 0) = i.x; abc(0, 1) = i.y; abc(0, 2) = i.z;
    abc(1, 0) = j.x; abc(1, 1) = j.y; abc(1, 2) = j.z;
    abc(2, 0) = k.x; abc(2, 1) = k.y; abc(2, 2) = k.z;
    d[0] = i.d; d[1] = j.d; d[2] = k.d;

    if (det(abc) != 0) { success = true; result = solve(abc, d); }
}

int main()
{
    size_t planeSize = sizeof(plane) / sizeof(plane[0]);
    map<int, vector<Vector>> face;

    // If you want to find the speed, uncomment the following line
    // and its accompanying bracket at the bottom.

    // for (int run = 0; run < 10000; ++run) {

    for (int i = 0; i < planeSize; ++i) {
        for (int j = i + 1; j < planeSize; ++j) {
            for (int k = j + 1; k < planeSize; ++k)
            {
                // If all three planes are parallel, move to next plane.
                // This also prevents use from running unnecessary  matrix operations.
                // I may need to add more comparisons for optimization, either within K or J.

                if (fabs(plane[i].n * (plane[j].n ^ plane[k].n)) <= SMALL_NUM) continue;

                // Find the intersection of planes I, J, and K.
                // http://www.gamedev.net/topic/304411-three-plane-intersection-point/

                bool success;
                static vec temp(3);

                plane3Int(plane[i].n, plane[j].n, plane[k].n, temp, success);
                if (!success) continue;
                Vector result (temp(0), temp(1), temp(2));

                // Figure out if each vertex is part of the solid. Run a line from
                // plane I to our vertex. If there is an intersection, discard the vertex.
                // Algorithm for plane/line segment intersection from
                // http://math.stackexchange.com/questions/47594/plane-intersecting-line-segment

                for (int l = 0; l < planeSize; ++l)
                {
                    success = true;
                    if (l == i || l == j || l == k) continue;

                    Vector midpoint = (((plane[i].a + plane[i].b) / 2) + plane[i].c) / 2;
                    float distV1 = plane[l].n * (midpoint - plane[l].b);
                    float distV2 = plane[l].n * (result - plane[l].b);

                    if (distV1 * distV2 <= -SMALL_NUM) { success = false; break; }
                }

                // If our vertex is not discarded, we put it in faces I, J, and K.

                if (success)
                {
                    face[i].push_back(result);
                    face[j].push_back(result);
                    face[k].push_back(result);
                }
            }
        }
    }

    // Finally, we remove the duplicate points from each face. Thanks Jag!
    // Source: http://stackoverflow.com/questions/12200486/

    for (auto& vertices : face)
    {
        set<Vector> verticesCopy(vertices.second.begin(), vertices.second.end());
        vertices.second.assign(verticesCopy.begin(), verticesCopy.end());

        // Uncomment this code to find out if right vertices are being found.

        // cout << "=== FACE " << vertices.first << " ===\n";
        // for (auto& vertex: vertices.second) cout << vertex << endl;
        // cout << endl;
    }

    // }

    return 0;
}