FractureToolsAPI.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2017, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */


#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