XMLLoader.cpp

#include "XMLLoader.h"

//used the following reference to understand xml parsing: https://www.setnode.com/blog/quick-notes-on-how-to-use-rapidxml/

void XMLLoader::InitCameras(std::vector<Camera*>& cameraList, int windowWidth, int windowHeight) {
    std::vector<rapidxml::xml_document<>*> documents = GetAllXMLDocumentsInDir("data/cameras");

    for (int i = 0; i < documents.size(); i++) {
        std::string cameraType;
        XMFLOAT3 eye;
        XMFLOAT3 at;
        XMFLOAT3 up;
        FLOAT nearPlane;
        FLOAT farPlane;

        //get all node data
        rapidxml::xml_node<>* currentNode = documents[i]->first_node("camera");
        rapidxml::xml_attribute<>* currentAttribute = currentNode->first_attribute("type");
        cameraType = currentAttribute->value();

        currentNode = currentNode->first_node("eye");
        eye = GetFloat3InXml(currentNode);

        currentNode = currentNode->next_sibling("at");
        at = GetFloat3InXml(currentNode);

        currentNode = currentNode->next_sibling("up");
        up = GetFloat3InXml(currentNode);

        currentNode = currentNode->next_sibling("clip");
        currentAttribute = currentNode->first_attribute("near");
        nearPlane = std::stof(currentAttribute->value());
        currentAttribute = currentAttribute->next_attribute("far");
        farPlane = std::stof(currentAttribute->value());

        //construct a camera based on the data
        Camera* newCamera = nullptr;
        if (cameraType == "to") {
            newCamera = new ToCam(eye, at, up, windowWidth, windowHeight, nearPlane, farPlane);
        }
        else if (cameraType == "at") {
            newCamera = new AtCam(eye, at, up, windowWidth, windowHeight, nearPlane, farPlane);
        }
        else if (cameraType == "path") {
            newCamera = new PathCam(eye, at, up, windowWidth, windowHeight, nearPlane, farPlane);
        }
        if (newCamera != nullptr) cameraList.push_back(newCamera);

        //destroy document data.
        documents[i]->clear();
    }

    documents.clear();
}

void XMLLoader::InitLights(std::vector<LightData>& lightList) {
    std::vector<rapidxml::xml_document<>*> documents = GetAllXMLDocumentsInDir("data/lights");

    for (int i = 0; i < documents.size(); i++) {
        std::string lightType;
        LightData light;
        rapidxml::xml_node<>* subNode;

        //type
        rapidxml::xml_node<>* currentNode = documents[i]->first_node("light");
        rapidxml::xml_attribute<>* currentAttribute = currentNode->first_attribute("type");
        lightType = currentAttribute->value();

        //ambient
        currentNode = currentNode->first_node("ambient");
        light.ambientMat = GetColorInXml(currentNode);
        subNode = currentNode->first_node("strength");
        light.ambientStr = GetColorInXml(subNode);

        //diffuse
        currentNode = currentNode->next_sibling("diffuse");
        light.diffuseMat = GetColorInXml(currentNode);
        subNode = currentNode->first_node("strength");
        light.diffuseStr = GetColorInXml(subNode);

        //specular
        currentNode = currentNode->next_sibling("specular");
        light.specularMat = GetColorInXml(currentNode);
        subNode = currentNode->first_node("strength");
        light.specularStr = GetColorInXml(subNode);
        subNode = subNode->next_sibling("power");
        currentAttribute = subNode->first_attribute("value");
        light.specularPow = std::stof(currentAttribute->value());

        //positioning
        currentNode = currentNode->next_sibling("direction");
        light.dir = GetFloat3InXml(currentNode);

        //generate light object.
        lightList.push_back(light);

        //destroy document data.
        documents[i]->clear();
    }

    documents.clear();
}

void XMLLoader::InitGameObjects(std::vector<GameObject*>& objectList, ID3D11Device* d3dDevice) {
    std::vector<rapidxml::xml_document<>*> documents = GetAllXMLDocumentsInDir("data/gameobjects");

    for (int i = 0; i < documents.size(); i++) {
        std::string meshLoc;
        std::string texLoc;
        Transform newTransform;

        rapidxml::xml_node<>* currentNode = documents[i]->first_node("gameobject");

        //mesh
        currentNode = currentNode->first_node("mesh");
        rapidxml::xml_attribute<>* currentAttribute = currentNode->first_attribute("path");
        meshLoc = currentAttribute->value();

        //color
        currentNode = currentNode->next_sibling("texture");
        currentAttribute = currentNode->first_attribute("path");
        texLoc = currentAttribute->value();

        //transform
        currentNode = currentNode->next_sibling("transform");
        currentNode = currentNode->first_node("position");
        newTransform.position = GetFloat3InXml(currentNode);
        currentNode = currentNode->next_sibling("rotation");
        newTransform.rotation = GetFloat3InXml(currentNode);
        currentNode = currentNode->next_sibling("scale");
        newTransform.scale = GetFloat3InXml(currentNode);

        //construct object
        //solution for wide string found at https://stackoverflow.com/questions/6691555/converting-narrow-string-to-wide-string
        //get file names
        std::wstring longName;
        longName.assign(texLoc.begin(), texLoc.end());

        GameObject* nextObject = new GameObject(d3dDevice, longName.c_str(), (char*)meshLoc.c_str());
        nextObject->transform = newTransform;

        objectList.push_back(nextObject);

        //destroy document data.
        documents[i]->clear();
    }

    documents.clear();
}

FogSettings XMLLoader::LoadFogSettings(std::string fileName) {
    FogSettings result;
    rapidxml::xml_document<>* doc = GetSingleXMLDocument(fileName);
    rapidxml::xml_node<>* node = doc->first_node("fog");
   
    //color
    node = node->first_node("color");
    result.fogColor = GetColorInXml(node);

    //density
    node = node->next_sibling("start");
    rapidxml::xml_attribute<>* attrib = node->first_attribute("value");
    result.fogStart = std::stof(attrib->value());
    
    node = node->next_sibling("range");
    attrib = node->first_attribute("value");
    result.fogRange = std::stof(attrib->value());

    doc->clear();

    return result;
}

std::vector<rapidxml::xml_document<>*> XMLLoader::GetAllXMLDocumentsInDir(std::string dirName) {
    std::vector<std::string> filenames;
    std::vector<rapidxml::xml_document<>*> documents;

    //utilize new c++17 features to find a list of files to ensure we process them all dynamically, without caring about how many.
    //reference to this technique: https://stackoverflow.com/questions/612097/how-can-i-get-the-list-of-files-in-a-directory-using-c-or-c
    for (const auto& entry : std::filesystem::directory_iterator(dirName))
        filenames.push_back(entry.path().string());

    //now for every file found, parse xml into heap.
    for (int i = 0; i < filenames.size(); i++) {
        documents.push_back(GetSingleXMLDocument(filenames[i]));
    }

    return documents;
}

rapidxml::xml_document<>* XMLLoader::GetSingleXMLDocument(std::string fileName) {
    //use pointer instead of stack so the string memory remains available when the loop scope is exited.
    //we don't care this pointer goes missing: doc has its own copies.
    rapidxml::file<>* docFile = new rapidxml::file<>(fileName.c_str());
    rapidxml::xml_document<>* doc = new rapidxml::xml_document<>();
    doc->parse<0>(docFile->data());

    return doc;
}

XMFLOAT3 XMLLoader::GetFloat3InXml(rapidxml::xml_node<>* node) {
    XMFLOAT3 result;
    rapidxml::xml_attribute<>* currentAttribute;

    currentAttribute = node->first_attribute("x");
    result.x = std::stof(currentAttribute->value());
    currentAttribute = currentAttribute->next_attribute("y");
    result.y = std::stof(currentAttribute->value());
    currentAttribute = currentAttribute->next_attribute("z");
    result.z = std::stof(currentAttribute->value());

    return result;
}

XMFLOAT4 XMLLoader::GetColorInXml(rapidxml::xml_node<>* node) {
    XMFLOAT4 result;
    rapidxml::xml_attribute<>* currentAttribute;

    currentAttribute = node->first_attribute("r");
    result.x = std::stof(currentAttribute->value());
    currentAttribute = currentAttribute->next_attribute("g");
    result.y = std::stof(currentAttribute->value());
    currentAttribute = currentAttribute->next_attribute("b");
    result.z = std::stof(currentAttribute->value());
    currentAttribute = currentAttribute->next_attribute("a");
    result.w = std::stof(currentAttribute->value());

    return result;
}