GeometryHandler.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_GEOMETRYHANDLER_H
#define MATERIALX_GEOMETRYHANDLER_H
 
 
#include <MaterialXRender/Export.h>
#include <MaterialXRender/Mesh.h>
 
#include <MaterialXFormat/File.h>
 
#include <map>
 
MATERIALX_NAMESPACE_BEGIN
 
using GeometryLoaderPtr = std::shared_ptr<class GeometryLoader>;
 
class MX_RENDER_API GeometryLoader
{
  public:
    GeometryLoader()
    {
    }
    virtual ~GeometryLoader() { }
 
    const StringSet& supportedExtensions() const
    {
        return _extensions;
    }
 
    virtual bool load(const FilePath& filePath, MeshList& meshList, bool texcoordVerticalFlip = false) = 0;
 
  protected:
    // List of supported string extensions
    StringSet _extensions;
};
 
using GeometryHandlerPtr = std::shared_ptr<class GeometryHandler>;
 
using GeometryLoaderMap = std::multimap<string, GeometryLoaderPtr>;
 
class MX_RENDER_API GeometryHandler
{
  public:
    GeometryHandler()
    {
    }
    virtual ~GeometryHandler() { }
 
    static GeometryHandlerPtr create()
    {
        return std::make_shared<GeometryHandler>();
    }
 
    void addLoader(GeometryLoaderPtr loader);
 
    void supportedExtensions(StringSet& extensions);
 
    void clearGeometry();
 
    // Determine if any meshes have been loaded from a given location
    bool hasGeometry(const string& location);
 
    // Find all meshes loaded from a given location
    void getGeometry(MeshList& meshes, const string& location);
 
    bool loadGeometry(const FilePath& filePath, bool texcoordVerticalFlip = false);
 
    const MeshList& getMeshes() const
    {
        return _meshes;
    }
 
    MeshPtr findParentMesh(MeshPartitionPtr part);
 
    const Vector3& getMinimumBounds() const
    {
        return _minimumBounds;
    }
 
    const Vector3& getMaximumBounds() const
    {
        return _maximumBounds;
    }
 
    static MeshPtr createQuadMesh(const Vector2& uvMin = Vector2(0.0f, 0.0f),
                                  const Vector2& uvMax = Vector2(1.0f, 1.0f),
                                  bool flipTexCoordsHorizontally = false);
 
  protected:
    // Recompute bounds for all stored geometry
    void computeBounds();
 
  protected:
    GeometryLoaderMap _geometryLoaders;
    MeshList _meshes;
    Vector3 _minimumBounds;
    Vector3 _maximumBounds;
};
 
MATERIALX_NAMESPACE_END
 
#endif