EncodePreparator.h

/*
  COPYRIGHT (c) 2012-2024 Esri R&D Center Zurich
  TRADE SECRETS: ESRI PROPRIETARY AND CONFIDENTIAL
  Unpublished material - all rights reserved under the
  Copyright Laws of the United States and applicable international
  laws, treaties, and conventions.

  For additional information, contact:
  Environmental Systems Research Institute, Inc.
  Attn: Contracts and Legal Services Department
  380 New York Street
  Redlands, California, 92373
  USA

  email: contracts@esri.com
*/

#ifndef PRTX_ENCODEPREPARATOR_H_
#define PRTX_ENCODEPREPARATOR_H_

#include "prt/Callbacks.h"

#include "prtx/NamePreparator.h"
#include "prtx/Shape.h"
#include "prtx/prtx.h"

#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable : 4275 4251)
#endif

#include <memory>

namespace prt {
    class Cache;
}

namespace prtx {

class InitialShape;

struct VertexNormalProcessor {
enum Action {
    PASS,                           
    DELETE_NORMALS,                 
    SET_MISSING_TO_FACE_NORMALS,    
    SET_ALL_TO_FACE_NORMALS         
};
};

struct HoleProcessor {
enum Action {
    PASS,                           
    TRIANGULATE_FACES_WITH_HOLES,   
    DELETE_HOLES,                   
    CONVERT_HOLES_TO_FACES          
};
};

struct MeshMerging {
enum Action {
    NONE,                           
    ALL_OF_SAME_MATERIAL_AND_TYPE,  
    ALL_OF_SAME_TYPE                
};
};

struct MaterialTransformer {
    virtual void update(
            const prt::AttributeMap*    initialShapeAttributes,
            const prtx::MaterialPtr&    originalMaterial,
            prtx::MaterialBuilder&      materialUpdate
    ) const = 0;
};


class Reports;
typedef std::shared_ptr<Reports> ReportsPtr;

class PRTX_EXPORTS_API Reports {
public:
    Reports() { }
    Reports(
        const prtx::Shape::ReportBoolVect&      boolReps,
        const prtx::Shape::ReportFloatVect&     floatReps,
        const prtx::Shape::ReportStringVect&    stringReps
    );

    void append(const ReportsPtr& r);

    prtx::Shape::ReportBoolVect     mBools;
    prtx::Shape::ReportFloatVect    mFloats;
    prtx::Shape::ReportStringVect   mStrings;
};


class EncodePreparator;
typedef std::shared_ptr<EncodePreparator> EncodePreparatorPtr;


class PRTX_EXPORTS_API EncodePreparator {
public:
    static const prtx::DoubleVector IDENTITY;
    class FinalizedInstance;
    typedef std::vector<FinalizedInstance> InstanceVector;
    class PreparationFlags;

public:
    static EncodePreparatorPtr create(
            bool                                enforceTextureConsistency,
            NamePreparator&                     namePreparator,
            const NamePreparator::NamespacePtr& nsMeshes,
            const NamePreparator::NamespacePtr& nsMaterials,
            const MaterialTransformer*          materialTransformer = 0
    );

    virtual void add(
            prt::Cache*                 cache,
            const ShapePtr&             shape,
            const prt::AttributeMap*    initialShapeAttributes,
            const ReportsPtr&           reports = ReportsPtr()
    ) = 0;

    virtual void add(
            prt::Cache*                 cache,
            const prtx::InitialShape&   initialShape,
            size_t                      initialShapeIndex
    ) = 0;

    static uint32_t getInitialShapePseudoShapeId(size_t initialShapeIndex);

    virtual void fetchFinalizedInstances(
            InstanceVector&             instances,
            const PreparationFlags&     flags,
            prt::SimpleOutputCallbacks* cbForLogStats = nullptr
    ) = 0;

    virtual void getBoundingBox(prtx::BoundingBox& bbox) = 0;

    virtual uint64_t getUsedMem(bool considerInstanceCounts = false) const = 0;

    virtual void clear() = 0;

    virtual ~EncodePreparator();

protected:
    struct FinalizedInstanceBase {
        GeometryPtr             mGeometry;
        prtx::DoubleVector      mTransformation;
        prtx::MaterialPtrVector mMaterials;
        StringPtr               mInitialShapeName;
        StringPtr               mShapeName;
        uint32_t                mInitialShapeIndex;
        uint32_t                mShapeId;
        std::vector<uint32_t>   mMeshProperties;
        int32_t                 mPrototype;
        ReportsPtr              mReports;
    };

    EncodePreparator();
    EncodePreparator(const EncodePreparator&) = delete;
    EncodePreparator& operator=(const EncodePreparator&) = delete;

    static FinalizedInstanceBase& getBase(FinalizedInstance& instance);

public:
    enum MeshProperties {
        ALL_MESH_FACES_CONVEX = 1 << 0, 
        ALL_MESH_FACES_PLANAR = 1 << 1  
    };

    class PRTX_EXPORTS_API FinalizedInstance : private FinalizedInstanceBase {
    public:
        static const uint32_t NO_INITIAL_SHAPE_INDEX = uint32_t(-1);
        static const uint32_t NO_SHAPE_ID = uint32_t(-1);
        static const int32_t NO_PROTOTYPE_INDEX = -1;

    public:
        const GeometryPtr& getGeometry() const;

        const prtx::DoubleVector& getTransformation() const;

        const prtx::MaterialPtrVector& getMaterials() const;

        const std::wstring& getInitialShapeName() const;

        const std::wstring& getShapeName() const;

        uint32_t getInitialShapeIndex() const;

        uint32_t getShapeId() const;

        int32_t getPrototypeIndex() const;

        bool allMeshFacesConvex(size_t meshIndex) const;

        bool allMeshFacesPlanar(size_t meshIndex) const;

        const ReportsPtr& getReports() const;

    private:
        FinalizedInstanceBase& getBase();
        friend class EncodePreparator;
    };

    class PRTX_EXPORTS_API PreparationFlags {
    public:
        enum IndexSharing {
            INDICES_SEPARATE_FOR_ALL_VERTEX_ATTRIBUTES              = 0,

            INDICES_SAME_FOR_VERTICES_AND_NORMALS                   = (1 << 0),

            INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET              = (1 << 1),

            INDICES_SAME_FOR_VERTICES_AND_ALL_UV_SETS               = (1 << 2) | INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET,

            INDICES_SAME_FOR_VERTICES_AND_NORMALS_AND_FIRST_UV_SET  = INDICES_SAME_FOR_VERTICES_AND_NORMALS | INDICES_SAME_FOR_VERTICES_AND_FIRST_UV_SET,

            INDICES_SAME_FOR_ALL_VERTEX_ATTRIBUTES                  = INDICES_SAME_FOR_VERTICES_AND_NORMALS | INDICES_SAME_FOR_VERTICES_AND_ALL_UV_SETS
        };

    public:
        PreparationFlags();

        PreparationFlags& instancing(bool v);

        [[deprecated("replaced by meshMerging")]] PreparationFlags& mergeByMaterial(bool v);

        PreparationFlags& meshMerging(MeshMerging::Action v);

        PreparationFlags& cutoutTextures(bool v);

        PreparationFlags& createTextureAtlases(bool v);

        PreparationFlags& atlasRepeatingTextures(bool v);

        PreparationFlags& maxAtlasDim(int v);

        PreparationFlags& atlasAddWrapBorder(bool v);

        PreparationFlags& forceAtlasing(bool v);

        PreparationFlags& maxTexSize(uint32_t v);

        PreparationFlags& triangulate(bool v);

        PreparationFlags& offset(double x, double y, double z);

        PreparationFlags& offset(const double* xyz);

        PreparationFlags& processVertexNormals(VertexNormalProcessor::Action v);

        PreparationFlags& processHoles(HoleProcessor::Action v);

        PreparationFlags& mergeVertices(bool v);

        PreparationFlags& cleanupVertexNormals(bool v);

        PreparationFlags& cleanupUVs(bool v);

        PreparationFlags& mergeToleranceVertices(float v);

        PreparationFlags& mergeToleranceNormals(float v);

        PreparationFlags& mergeToleranceUVs(float v);

        PreparationFlags& indexSharing(IndexSharing v);

        PreparationFlags& determineMeshProperties(bool v);

        bool instancing() const;
        [[deprecated("replaced by meshMerging")]] bool mergeByMaterial() const;
        MeshMerging::Action meshMerging() const;
        bool cutoutTextures() const;
        bool createTextureAtlases() const;
        bool atlasRepeatingTextures() const;
        int maxAtlasDim() const;
        bool atlasAddWrapBorder() const;
        bool forceAtlasing() const;
        uint32_t maxTexSize() const;
        bool triangulate() const;
        const double* offset() const;
        VertexNormalProcessor::Action processVertexNormals() const;
        HoleProcessor::Action processHoles() const;
        bool mergeVertices() const;
        bool cleanupVertexNormals() const;
        bool cleanupUVs() const;
        float mergeToleranceVertices() const;
        float mergeToleranceNormals() const;
        float mergeToleranceUVs() const;
        IndexSharing indexSharing() const;
        bool determineMeshProperties() const;

    private:
        bool mInstancing;
        MeshMerging::Action mMeshMerging;
        bool mCutoutTextures;
        bool mCreateTextureAtlases;
        bool mAtlasRepeatingTextures;
        int  mMaxAtlasDim;
        bool mAtlasAddWrapBorder;
        bool mForceAtlasing;
        uint32_t mMaxTexSize;
        bool mTriangulate;
        bool mDetermineMeshProperties;
        bool mMergeVertices;
        bool mCleanupVertexNormals;
        bool mCleanupUVs;
        VertexNormalProcessor::Action mVertexNormalAction;
        HoleProcessor::Action mHoleAction;
        IndexSharing mIndexSharing;
        float mMergeToleranceVertices;
        float mMergeToleranceNormals;
        float mMergeToleranceUVs;
        double mOffset[3];
    };
};


} // namespace prtx


#ifdef _MSC_VER
#   pragma warning(pop)
#endif


#endif /* PRTX_ENCODEPREPARATOR_H_ */