Mesh.h

/*
  COPYRIGHT (c) 2012-2026 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_MESH_H_
#define PRTX_MESH_H_

#include "prtx/prtx.h"
#include "prtx/Types.h"
#include "prtx/Material.h"
#include "prtx/OpaquePtr.h"

#include <vector>
#include <memory>

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


namespace prtx {


typedef std::vector<uint32_t>  IndexVector;     

class BoundingBox;

class Mesh;
typedef std::shared_ptr<Mesh> MeshPtr;      
typedef std::vector<MeshPtr>  MeshPtrVector;     


class PRTX_EXPORTS_API Mesh : public Content {
public:
    // @cond
    friend class MeshBuilder;
    struct Payload;
    // @endcond

public:
    virtual ~Mesh();

    const std::wstring&         getName() const;
    const BoundingBox&          getBoundingBox() const;

    const DoubleVector&         getVertexCoords() const;
    const DoubleVector&         getVertexNormalsCoords() const;
    const DoubleVector&         getUVCoords(uint32_t uvSet) const;
    const DoubleVector&         getTextureRegions(uint32_t uvSet) const;
    uint32_t                    getUVSetsCount() const;
    const MaterialPtrVector&    getMaterials() const;

    uint32_t                    getFaceCount() const;
    const IndexVector&          getFaceVertexCounts() const;
    uint32_t                    getFaceVertexCount(uint32_t faceId) const;
    const uint32_t*             getFaceVertexIndices(uint32_t faceId) const;

    uint32_t                    getHolesCount() const;
    const IndexVector&          getFaceHolesCounts() const;
    uint32_t                    getFaceHolesCount(uint32_t faceId) const;
    const uint32_t*             getFaceHolesIndices(uint32_t faceId) const;

    const IndexVector&          getFaceMaterialIndices() const;
    uint32_t                    getFaceMaterialIndex(uint32_t faceId) const;

    const IndexVector&          getFaceVertexNormalCounts() const;
    uint32_t                    getFaceVertexNormalCount(uint32_t faceId) const;
    const uint32_t*             getFaceVertexNormalIndices(uint32_t faceId) const;

    const IndexVector&          getFaceUVCounts(uint32_t uvSet) const;
    uint32_t                    getFaceUVCount(uint32_t faceId, uint32_t uvSet) const;
    const uint32_t*             getFaceUVIndices(uint32_t faceId, uint32_t uvSet) const;
    const IndexVector&          getFaceTextureRegionIndices(uint32_t uvSet) const;
    uint32_t                    getFaceTextureRegionIndex(uint32_t faceId, uint32_t uvSet) const;

    int32_t                     getFaceEncirclingFace(uint32_t faceId) const;

    size_t                      getUsedMem() const;

protected:
    // @cond
    Mesh(Payload const* p);
    const Payload* mPayload;
    // @endcond
};


class PRTX_EXPORTS_API MeshBuilder : public SharedPtrBuilder<Mesh> {
public:
    MeshBuilder();
    MeshBuilder(const MeshBuilder& mb);
    MeshBuilder(const MeshBuilder& mb, const DoubleVector& trafoMatrix);
    MeshBuilder(const Mesh& mesh);
    MeshBuilder(const Mesh& mesh, const DoubleVector& trafoMatrix);
    virtual ~MeshBuilder();

    MeshBuilder& operator=(const MeshBuilder& right);


    // SharedPtrBuilder interface implementation
    virtual MeshPtr createShared(std::wstring* warnings = 0) const;
    virtual MeshPtr createSharedAndReset(std::wstring* warnings = 0);


    void reset();
    void resetMaterials();
    void resetVertexCoords();
    void resetNormalCoords();
    void resetUVCoords();
    void resetFaces();

    void     setName(const std::wstring& name);

    uint32_t addMaterial(const MaterialPtr& material);
    void     addMaterials(const MaterialPtrVector& materials);

    uint32_t addVertexCoords(const double coords[3]);
    void     addVertexCoords(const double* coords, size_t count);
    void     addVertexCoords(const DoubleVector& coords);

    uint32_t addNormalCoords(const double coords[3]);
    void     addNormalCoords(const double* coords, size_t count);
    void     addNormalCoords(const DoubleVector& coords);

    uint32_t addUVCoords(uint32_t uvSet, const double coords[2]);
    void     addUVCoords(uint32_t uvSet, const double* coords, size_t count);
    void     addUVCoords(uint32_t uvSet, const DoubleVector& coords);

    uint32_t addTextureRegionCoords(uint32_t uvSet, const double coords[4]);
    void     addTextureRegionCoords(uint32_t uvSet, const double* coords, size_t count);
    void     addTextureRegionCoords(uint32_t uvSet, const DoubleVector& coords);

    uint32_t addFace(const IndexVector& vertexIndices, const IndexVector& holeFacesIndices,
            uint32_t materialIndex, const IndexVector& normalIndices, const std::vector<IndexVector>& uvIndices);


    uint32_t addFace(
            const uint32_t* vertexIndices, size_t vertexIndicesCount,
            const uint32_t* holeFaceIndices, size_t holeFacesIndicesCount,
            uint32_t materialIndex,
            const uint32_t* normalIndices, size_t normalIndicesCount,
            const std::vector<const uint32_t*>& uvIndices, const std::vector<size_t>& uvIndicesCounts);

    uint32_t addFace();
    void addFaceVertexIndex(uint32_t faceId, uint32_t index);
    void addFaceHoleIndex(uint32_t faceId, uint32_t index);
    void addFaceNormalIndex(uint32_t faceId, uint32_t index);
    void addFaceUVIndex(uint32_t faceId, uint32_t uvSet, uint32_t i);

    void setFaceVertexIndices(uint32_t faceId, const IndexVector& indices);
    void setFaceNormalIndices(uint32_t faceId, const IndexVector& indices);
    void setFaceUVIndices(uint32_t faceId, uint32_t uvSet, const IndexVector& indices);

    void setFaceMaterialIndex(uint32_t faceId, uint32_t index);
    void setFaceTextureRegionIndex(uint32_t faceId, uint32_t uvSet, uint32_t index);

    void setFacesVertexIndices(const uint32_t* indices, size_t indicesCount, const uint32_t* faceCounts, size_t faceCount);
    void setFacesNormalIndices(const uint32_t* indices, size_t indicesCount, const uint32_t* faceCounts, size_t faceCount);
    void setFacesUVIndices(uint32_t uvSet, const uint32_t* indices, size_t indicesCount, const uint32_t* faceCounts, size_t faceCount);
    void setFacesMaterialIndices(const uint32_t* indices, size_t faceCount);
    void setFacesHoleIndices(const uint32_t* indices, size_t indicesCount, const uint32_t* faceCounts, size_t faceCount);

    bool isEmpty() const;

    struct MBImpl;

private:
    OpaquePtr<MBImpl> mImpl;
};

} // namespace prtx

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif /* PRTX_MESH_H_ */