FractureToolsAPI.h

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2018 NVIDIA Corporation. All rights reserved.



#ifndef FRACTURE_TOOLS_API_H
#define FRACTURE_TOOLS_API_H

#include "foundation/Px.h"
#include "ExplicitHierarchicalMesh.h"
#include "FractureToolsStructs.h"

PX_PUSH_PACK_DEFAULT

namespace nvidia
{
namespace apex
{

struct IntersectMesh;
class DestructibleAsset;

class FractureToolsAPI
{
public:

    virtual FractureTools::CutoutSet* createCutoutSet() = 0;

    virtual void buildCutoutSet(FractureTools::CutoutSet& cutoutSet, const uint8_t* pixelBuffer, uint32_t bufferWidth, uint32_t bufferHeight, float snapThreshold, bool periodic) = 0;

    virtual bool calculateCutoutUVMapping(const nvidia::ExplicitRenderTriangle& triangle, PxMat33& theMapping) = 0;

    virtual bool calculateCutoutUVMapping(nvidia::ExplicitHierarchicalMesh& hMesh, const PxVec3& targetDirection, PxMat33& theMapping) = 0;

    virtual bool    createVoronoiSplitMesh
    (
        nvidia::ExplicitHierarchicalMesh& hMesh,
        nvidia::ExplicitHierarchicalMesh& iHMeshCore,
        bool exportCoreMesh,
        int32_t coreMeshImprintSubmeshIndex,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureVoronoiDesc& desc,
        const CollisionDesc& collisionDesc,
        uint32_t randomSeed,
        nvidia::IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual uint32_t    createVoronoiSitesInsideMesh
    (
        nvidia::ExplicitHierarchicalMesh& hMesh,
        PxVec3* siteBuffer,
        uint32_t* siteChunkIndices,
        uint32_t siteCount,
        uint32_t* randomSeed,
        uint32_t* microgridSize,
        BSPOpenMode::Enum meshMode,
        nvidia::IProgressListener& progressListener,
        uint32_t chunkIndex = 0xFFFFFFFF
    ) = 0;

    virtual uint32_t    createScatterMeshSites
    (
        uint8_t*                        meshIndices,
        PxMat44*                        relativeTransforms,
        uint32_t*                       chunkMeshStarts,
        uint32_t                        scatterMeshInstancesBufferSize,
        nvidia::ExplicitHierarchicalMesh&   hMesh,
        uint32_t                        targetChunkCount,
        const uint16_t*                 targetChunkIndices,
        uint32_t*                       randomSeed,
        uint32_t                        scatterMeshAssetCount,
        nvidia::RenderMeshAsset**           scatterMeshAssets,
        const uint32_t*                 minCount,
        const uint32_t*                 maxCount,
        const float*                    minScales,
        const float*                    maxScales,
        const float*                    maxAngles
    ) = 0;

    virtual void    visualizeVoronoiCells
    (
        nvidia::RenderDebugInterface& debugRender,
        const PxVec3* sites,
        uint32_t siteCount,
        const uint32_t* cellColors,
        uint32_t cellColorCount,
        const PxBounds3& bounds,
        uint32_t cellIndex = 0xFFFFFFFF
    ) = 0;

    virtual bool buildExplicitHierarchicalMesh
    (
        nvidia::ExplicitHierarchicalMesh& iHMesh,
        const nvidia::ExplicitRenderTriangle* meshTriangles,
        uint32_t meshTriangleCount,
        const nvidia::ExplicitSubmeshData* submeshData,
        uint32_t submeshCount,
        uint32_t* meshPartition = NULL,
        uint32_t meshPartitionCount = 0,
        int32_t* parentIndices = NULL,
        uint32_t parentIndexCount = 0
    ) = 0;

    virtual void setBSPTolerances
    (
        float linearTolerance,
        float angularTolerance,
        float baseTolerance,
        float clipTolerance,
        float cleaningTolerance
    ) = 0;

    virtual void setBSPBuildParameters
    (
        float logAreaSigmaThreshold,
        uint32_t testSetSize,
        float splitWeight,
        float imbalanceWeight
    ) = 0;


    virtual bool buildExplicitHierarchicalMeshFromRenderMeshAsset(nvidia::ExplicitHierarchicalMesh& iHMesh, const nvidia::RenderMeshAsset& renderMeshAsset, uint32_t maxRootDepth = UINT32_MAX) = 0;

    virtual bool buildExplicitHierarchicalMeshFromDestructibleAsset(nvidia::ExplicitHierarchicalMesh& iHMesh, const nvidia::DestructibleAsset& destructibleAsset, uint32_t maxRootDepth = UINT32_MAX) = 0;

    virtual bool createHierarchicallySplitMesh
    (
        nvidia::ExplicitHierarchicalMesh& hMesh,
        nvidia::ExplicitHierarchicalMesh& iHMeshCore,
        bool exportCoreMesh,
        int32_t coreMeshImprintSubmeshIndex,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureSliceDesc& desc,
        const CollisionDesc& collisionDesc,
        uint32_t randomSeed,
        nvidia::IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual bool createChippedMesh
    (
        nvidia::ExplicitHierarchicalMesh& hMesh,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureCutoutDesc& desc,
        const FractureTools::CutoutSet& iCutoutSet,
        const FractureTools::FractureSliceDesc& sliceDesc,
        const FractureTools::FractureVoronoiDesc& voronoiDesc,
        const CollisionDesc& collisionDesc,
        uint32_t randomSeed,
        nvidia::IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual bool hierarchicallySplitChunk
    (
        nvidia::ExplicitHierarchicalMesh& hMesh,
        uint32_t chunkIndex,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureSliceDesc& desc,
        const CollisionDesc& collisionDesc,
        uint32_t* randomSeed,
        nvidia::IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual bool voronoiSplitChunk
    (
        nvidia::ExplicitHierarchicalMesh& hMesh,
        uint32_t chunkIndex,
        const FractureTools::MeshProcessingParameters& meshProcessingParams,
        const FractureTools::FractureVoronoiDesc& desc,
        const CollisionDesc& collisionDesc,
        uint32_t* randomSeed,
        nvidia::IProgressListener& progressListener,
        volatile bool* cancel = NULL
    ) = 0;

    virtual bool buildSliceMesh
    (
        nvidia::IntersectMesh& intersectMesh,
        nvidia::ExplicitHierarchicalMesh& referenceMesh,
        const PxPlane& slicePlane,
        const FractureTools::NoiseParameters& noiseParameters,
        uint32_t randomSeed
    ) = 0;

    virtual nvidia::ExplicitHierarchicalMesh*   createExplicitHierarchicalMesh() = 0;

    virtual nvidia::ExplicitHierarchicalMesh::ConvexHull*   createExplicitHierarchicalMeshConvexHull() = 0;

};

}} // namespaces


PX_POP_PACK

#endif // FRACTURE_TOOLS_API_H