Mesh.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_MESH_H
#define MATERIALX_MESH_H
 
 
#include <MaterialXCore/Types.h>
#include <MaterialXRender/Export.h>
 
MATERIALX_NAMESPACE_BEGIN
 
using MeshIndexBuffer = vector<uint32_t>;
using MeshFloatBuffer = vector<float>;
 
using MeshStreamPtr = shared_ptr<class MeshStream>;
 
using MeshStreamList = vector<MeshStreamPtr>;
 
class MX_RENDER_API MeshStream
{
  public:
    static const string POSITION_ATTRIBUTE;
    static const string NORMAL_ATTRIBUTE;
    static const string TEXCOORD_ATTRIBUTE;
    static const string TANGENT_ATTRIBUTE;
    static const string BITANGENT_ATTRIBUTE;
    static const string COLOR_ATTRIBUTE;
    static const string GEOMETRY_PROPERTY_ATTRIBUTE;
 
    static const unsigned int STRIDE_2D = 2;
    static const unsigned int STRIDE_3D = 3;
    static const unsigned int STRIDE_4D = 4;
    static const unsigned int DEFAULT_STRIDE = STRIDE_3D;
 
  public:
    MeshStream(const string& name, const string& type, unsigned int index) :
        _name(name),
        _type(type),
        _index(index),
        _stride(DEFAULT_STRIDE)
    {
    }
    ~MeshStream() { }
 
    static MeshStreamPtr create(const string& name, const string& type, unsigned int index = 0)
    {
        return std::make_shared<MeshStream>(name, type, index);
    }
 
    void reserve(size_t elementCount)
    {
        _data.reserve(elementCount * (size_t) _stride);
    }
 
    void resize(size_t elementCount)
    {
        _data.resize(elementCount * (size_t) _stride);
    }
 
    const string& getName() const
    {
        return _name;
    }
 
    const string& getType() const
    {
        return _type;
    }
 
    unsigned int getIndex() const
    {
        return _index;
    }
 
    MeshFloatBuffer& getData()
    {
        return _data;
    }
 
    const MeshFloatBuffer& getData() const
    {
        return _data;
    }
 
    // Return the typed element at the given index
    template <class T> T& getElement(size_t index)
    {
        return reinterpret_cast<T*>(getData().data())[index];
    }
 
    // Return the typed element at the given index
    template <class T> const T& getElement(size_t index) const
    {
        return reinterpret_cast<const T*>(getData().data())[index];
    }
 
    unsigned int getStride() const
    {
        return _stride;
    }
 
    void setStride(unsigned int stride)
    {
        _stride = stride;
    }
 
    size_t getSize() const
    {
        return _data.size() / _stride;
    }
 
    void transform(const Matrix44& matrix);
 
  protected:
    string _name;
    string _type;
    unsigned int _index;
    MeshFloatBuffer _data;
    unsigned int _stride;
};
 
using MeshPartitionPtr = shared_ptr<class MeshPartition>;
 
class MX_RENDER_API MeshPartition
{
  public:
    MeshPartition() :
        _faceCount(0)
    {
    }
    ~MeshPartition() { }
 
    static MeshPartitionPtr create()
    {
        return std::make_shared<MeshPartition>();
    }
 
    void resize(size_t indexCount)
    {
        _indices.resize(indexCount);
    }
 
    void setName(const string& val)
    {
        _name = val;
    }
 
    const string& getName() const
    {
        return _name;
    }
 
    void addSourceName(const string& val)
    {
        _sourceNames.insert(val);
    }
 
    const StringSet& getSourceNames() const
    {
        return _sourceNames;
    }
 
    MeshIndexBuffer& getIndices()
    {
        return _indices;
    }
 
    const MeshIndexBuffer& getIndices() const
    {
        return _indices;
    }
 
    size_t getFaceCount() const
    {
        return _faceCount;
    }
 
    void setFaceCount(size_t val)
    {
        _faceCount = val;
    }
 
  private:
    string _name;
    StringSet _sourceNames;
    MeshIndexBuffer _indices;
    size_t _faceCount;
};
 
using MeshPtr = shared_ptr<class Mesh>;
 
using MeshList = vector<MeshPtr>;
 
using MeshMap = std::unordered_map<string, MeshPtr>;
 
class MX_RENDER_API Mesh
{
  public:
    Mesh(const string& name);
    ~Mesh() { }
 
    static MeshPtr create(const string& name)
    {
        return std::make_shared<Mesh>(name);
    }
 
    const string& getName() const
    {
        return _name;
    }
 
    void setSourceUri(const string& sourceUri)
    {
        _sourceUri = sourceUri;
    }
 
    bool hasSourceUri() const
    {
        return !_sourceUri.empty();
    }
 
    const string& getSourceUri() const
    {
        return _sourceUri;
    }
 
    MeshStreamPtr getStream(const string& name) const
    {
        for (const auto& stream : _streams)
        {
            if (stream->getName() == name)
            {
                return stream;
            }
        }
        return MeshStreamPtr();
    }
 
    MeshStreamPtr getStream(const string& type, unsigned int index) const
    {
        for (const auto& stream : _streams)
        {
            if (stream->getType() == type &&
                stream->getIndex() == index)
            {
                return stream;
            }
        }
        return MeshStreamPtr();
    }
 
    void addStream(MeshStreamPtr stream)
    {
        _streams.push_back(stream);
    }
 
    void removeStream(MeshStreamPtr stream)
    {
        auto it = std::find(_streams.begin(), _streams.end(), stream);
        if (it != _streams.end())
        {
            _streams.erase(it);
        }
    }
 
    void setVertexCount(size_t val)
    {
        _vertexCount = val;
    }
 
    size_t getVertexCount() const
    {
        return _vertexCount;
    }
 
    void setMinimumBounds(const Vector3& val)
    {
        _minimumBounds = val;
    }
 
    const Vector3& getMinimumBounds() const
    {
        return _minimumBounds;
    }
 
    void setMaximumBounds(const Vector3& v)
    {
        _maximumBounds = v;
    }
 
    const Vector3& getMaximumBounds() const
    {
        return _maximumBounds;
    }
 
    void setSphereCenter(const Vector3& val)
    {
        _sphereCenter = val;
    }
 
    const Vector3& getSphereCenter() const
    {
        return _sphereCenter;
    }
 
    void setSphereRadius(float val)
    {
        _sphereRadius = val;
    }
 
    float getSphereRadius() const
    {
        return _sphereRadius;
    }
 
    size_t getPartitionCount() const
    {
        return _partitions.size();
    }
 
    void addPartition(MeshPartitionPtr partition)
    {
        _partitions.push_back(partition);
    }
 
    MeshPartitionPtr getPartition(size_t partIndex) const
    {
        return _partitions[partIndex];
    }
 
    MeshStreamPtr generateTextureCoordinates(MeshStreamPtr positionStream);
 
    MeshStreamPtr generateNormals(MeshStreamPtr positionStream);
 
    MeshStreamPtr generateTangents(MeshStreamPtr positionStream, MeshStreamPtr normalStream, MeshStreamPtr texcoordStream);
 
    MeshStreamPtr generateBitangents(MeshStreamPtr normalStream, MeshStreamPtr tangentStream);
 
    void mergePartitions();
 
    void splitByUdims();
 
  private:
    string _name;
    string _sourceUri;
 
    Vector3 _minimumBounds;
    Vector3 _maximumBounds;
 
    Vector3 _sphereCenter;
    float _sphereRadius;
 
    MeshStreamList _streams;
    size_t _vertexCount;
    vector<MeshPartitionPtr> _partitions;
};
 
MATERIALX_NAMESPACE_END
 
#endif