NavGenProj.h

Go to the documentation of this file.

/*
* Copyright 2015 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/


// primary contact: MAMU - secondary contact: GUAL
#ifndef GwNavGen_NavGenProj_H
#define GwNavGen_NavGenProj_H

#include "NavGenProjConfig.h"
#include "NavGenProjSeedPoint.h"

#include "gwnavgeneration/generator/generator.h"
#include "gwnavruntime/base/kyguid.h"
#include "LabEngine/base/filesystem.h"

#include "tinyxml.h"

#include <string>
#include <vector>


namespace Kaim
{
class OBJProducer;
}

namespace LabEngine
{
class MirroredOBJProducer;
}

namespace Kaim
{

class NavGenProjGeometry;
class NavGenProjPdgInput;
class NavGenProjTagVolume;
class NavGenProjClientInput;
class NavGenProjSector;
class NavGenProjMirrorOptions;
class NavGenProjExclusiveSectors;


class NavGenProj
{
public:
    NavGenProj();
    ~NavGenProj();

    void Clear();

    KyResult Load(const char* fileName);

    KyResult Save(const char* fileName);

    KyResult Generate(const char* forcedOutputBaseDir = KY_NULL, const char* forcedRelativeOutputDir = KY_NULL);

    void AddSector(NavGenProjSector* sector) { m_sectors.push_back(sector); }

    KyResult AddTagVolume(const Vec3f* polylinePoints, int pointArraySize, const DynamicNavTag& navTag, float minAltitude, float maxAltitude);

    void AddSeedPoint(float x, float y, float z);

    //KyResult AddTerrainTypeMaterial(const char* materialName, unsigned int terrainTypeMask, const char* objFileName);

    void AddExclusiveGuids(const Kaim::KyGuid* guids, KyUInt32 guidsCount);

    void AddSpecificCellToGenerate(int posx, int posy);

    void SetOutputDir(const char* outputBaseDir, const char* relativeOutputDir);
    std::string GetRelativeOutputDir() { return m_relativeOutputDir; }
    std::string GetOutputBaseDir() { return m_outputBaseDir; }

    void     SetDatabaseIndex(KyUInt32 dabaseIndex);
    KyUInt32 GetDatabaseIndex() const;

    void SetConfig(const GeneratorParameters& params, const GeneratorRunOptions& runOptions, const CoordSystem& coordSystem);

    void SetAbstractGraphConfig(const GeneratorAbstractGraphParameters& abstractGraphParams);

    // MirrorOptions is not an SDK feature, this is an option of the NavGenProj to ease demoing/testing of large scale terrains.
    // It emulates large scale terrain by mirroring either one sector and its geometry or only the geometry into this sector.
    // SeedPoint and TagVolume are mirrored as well.
    void AddMirrorOptions(const NavGenProjMirrorOptions& mirrorOptions);
    NavGenProjMirrorOptions* GetMirrorOptions() { return m_mirrorOptions; }

    std::string GetGeometryFileName   (NavGenProjSector* sector, int index);
    std::string GetClientInputFileName(NavGenProjSector* sector, int index);

    int GetSectorCount() const;
    NavGenProjSector* GetSector(int index);

    int GetSeedPointCount() const;
    const NavGenProjSeedPoint& GetSeedPoint(int index) const;

    void SetNavGenProjAbsoluteFileName(const char* navGenProjAbsoluteFileName);

    // if path is relative then returns m_navGenProjDirectory/path or return path
    std::string GetAbsolutePath(const char* path);

    std::string GetGeneratorInputOutputFilename()
    {
        if (m_navGenProjConfig.m_genIOFilename.IsEmpty())
        {
            std::string genIOFileName = m_navGenProjFileNameWithoutDirOrExtension;
            genIOFileName += ".GenIO";
            return genIOFileName;
        }

        return m_navGenProjConfig.m_genIOFilename.ToCStr();
    }

public: // internal

    void ClearAllSpecificCellsToGenerate();

    // Indicates if the NavGenProj is ready for mirroring the geometry which has to be a .obj file,
    // the NavGenProj must contain one and only one sector which contains a NavGenProjMirrorOptions
    bool CanUseMirrorOptions();
    void RemoveMirrorOptions();

    void ParseNavGenProjDoc(TiXmlNode* root);
    void ParseNavGenProjChildNode(TiXmlNode* pChild);

    //KyResult CheckProjectVersion(TiXmlNode* pParent);

    static TiXmlNode* GetOrCreateFolderNode(TiXmlNode* node, const char* folderName);

    static bool GetParam(TiXmlNode* node, const char *elementName, float& value);
    static bool GetParam(TiXmlNode* node, const char *elementName, int& value);
    static bool GetParam(TiXmlNode* node, const char *elementName, unsigned int& value);
    static bool GetParam(TiXmlNode* node, const char *elementName, unsigned int& value, const KyArray<String>& enumNames);
    static bool GetParam(TiXmlNode* node, const char *elementName, bool& value);
    static bool GetParam(TiXmlNode* node, const char *paramName, std::string& param);
    static bool GetParam(TiXmlNode* node, const char *paramName, Kaim::CellPos& pos);
    static bool GetParam(TiXmlNode* node, const char *paramName,  Kaim::Vec3f& pos);

    static void SetParam(TiXmlNode* folder, const char* paramName, float param);
    static void SetParam(TiXmlNode* folder, const char* paramName, int param);
    static void SetParam(TiXmlNode* folder, const char* paramName, unsigned int param);
    static void SetParam(TiXmlNode* folder, const char* paramName, unsigned int param, const KyArray<String>& enumNames);
    static void SetParam(TiXmlNode* folder, const char* paramName, bool param);
    static void SetParam(TiXmlNode* folder, const char *paramName, const std::string& param);
    static void SetParam(TiXmlNode* folder, const char *paramName, const Kaim::CellPos& pos);
    static void SetParam(TiXmlNode* folder, const char *paramName, const Kaim::Vec3f& pos);

    static void ReadNavTag(TiXmlNode* node, DynamicNavTag& navTag);
    static void ReadBlindData(TiXmlNode* node, Kaim::KyArrayPOD<KyUInt32>& blindDataArray);
    static void ReadColor(TiXmlNode* node, VisualColor& color);
    static void ReadPoints(TiXmlNode* node, Kaim::KyArrayPOD<Vec3f>& points);

    static void WriteNavTag(TiXmlNode* node, const DynamicNavTag& navTag, bool writeOnlyBlindData = false);
    static void WriteBlindData(TiXmlNode* node, const Kaim::KyArrayPOD<KyUInt32>& blindDataArray);
    static void WriteColor(TiXmlNode* node, const KyUInt32* color);
    static void WritePoints(TiXmlNode* node, const Kaim::KyArrayPOD<Vec3f>& points);

private:
    void ParseOutputDir(TiXmlNode* node);
    void ParseSectors(TiXmlNode* sectorsNode);
    void CreateSector(TiXmlNode* sectorNode);
    void ParseTagVolumes(TiXmlNode* tagVolumesNode);
    void CreateTagVolume(TiXmlNode* tagVolumeNode);
    void ParseSeedPoints(TiXmlNode* seedpointsNode);
    void CreateSeedPoint(TiXmlNode* seedpointNode);
    void CreateMirrorOptions(TiXmlNode* node);

    KyResult GenerateMirroredObj(const char* absoluteOutputBaseDir, const char* relativeOutputDir);
    KyResult GenerateObj(const char* absoluteOutputBaseDir, const char* relativeOutputDir);
    KyResult DoGenerate(Kaim::GeneratorInputProducer* producer, const char* absoluteOutputBaseDir, const char* relativeOutputDir);
    Kaim::Ptr<Kaim::Generator> CreateGenerator(Kaim::Ptr<Kaim::GeneratorInputProducer> producer);
    void InitInputGeometry(Kaim::Ptr<Kaim::GeneratorSector> sector, NavGenProjSector* navGenProjSector);
    void InitSeedAndTag(Kaim::Ptr<Kaim::GeneratorSector> sector, NavGenProjSector* navGenProjSector);
    void InitSeedAndTagForMirroredOBJ(NavGenProjSector* navGenProjSector, LabEngine::MirroredOBJProducer* producer);
    void GetValidGuid(Kaim::KyGuid& sectorGuid);
    void ConfigGeneratorSector(Kaim::Ptr<Kaim::GeneratorSector> sector, NavGenProjSector* navGenProjSector);
    void InitGeneratorInputOutput(Kaim::GeneratorInputOutput& generatorInputOutput, const char* absoluteOutputBaseDir, const char* relativeOutputDir);
    KyResult RunGenerator(Kaim::Ptr<Kaim::Generator> generator, Kaim::GeneratorInputOutput& generatorInputOutput, const char* absoluteOutputBaseDir, const char* relativeOutputDir);

public:
    // sectors, tagVolumes, arrayOfExclusiveSectors, seedPoints
    // are maintained in these vectors instead of the m_navGenProjConfig.m_generatorInputOutput
    std::vector<NavGenProjSector*>           m_sectors;
    std::vector<NavGenProjTagVolume*>        m_tagVolumes;
    std::vector<NavGenProjExclusiveSectors*> m_arrayOfExclusiveSectors;
    std::vector<NavGenProjSeedPoint>         m_seedPoints;

    NavGenProjConfig m_navGenProjConfig; //< Content of <config>...</config>
    NavGenProjMirrorOptions* m_mirrorOptions;

    KyUInt32 m_databaseIndex;

    char m_outputBaseDir[LabEngine::Paths::PathMax];
    char m_relativeOutputDir[LabEngine::Paths::PathMax];

    char m_navGenProjDirectory[LabEngine::Paths::PathMax];

    // FileName of the .NavGenProj file without the directory and without the extension
    char m_navGenProjFileNameWithoutDirOrExtension[LabEngine::Paths::PathMax];
};

}


#endif