NvBlastExtAuthoringFractureToolImpl.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and 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.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2016-2020 NVIDIA Corporation. All rights reserved.

#ifndef NVBLASTAUTHORINGFRACTURETOOLIMPL_H
#define NVBLASTAUTHORINGFRACTURETOOLIMPL_H

#include "NvBlastExtAuthoringFractureTool.h"
#include "NvBlastExtAuthoringMesh.h"
#include <vector>
#include <set>

namespace Nv
{
namespace Blast
{

class SpatialAccelerator;
class Triangulator;


class VoronoiSitesGeneratorImpl : public VoronoiSitesGenerator
{
public:
    
    VoronoiSitesGeneratorImpl(const Mesh* mesh, RandomGeneratorBase* rnd);
    ~VoronoiSitesGeneratorImpl();

    void                        release() override;

    void                        setBaseMesh(const Mesh* m) override;

     uint32_t                   getVoronoiSites(const NvcVec3*& sites) override;
    
    void                        addSite(const NvcVec3& site) override;
    void                        uniformlyGenerateSitesInMesh(uint32_t numberOfSites) override;

    void                        clusteredSitesGeneration(uint32_t numberOfClusters, uint32_t sitesPerCluster, float clusterRadius) override;

    void                        radialPattern(const NvcVec3& center, const NvcVec3& normal, float radius, int32_t angularSteps, int32_t radialSteps, float angleOffset = 0.0f, float variability = 0.0f) override;

    void                        generateInSphere(const uint32_t count, const float radius, const NvcVec3& center) override;
    void                        setStencil(const Mesh* stencil) override;
    void                        clearStencil() override;

    void                        deleteInSphere(const float radius, const NvcVec3& center, const float eraserProbability = 1) override;

private:
    std::vector <NvcVec3>   mGeneratedSites;
    const Mesh*                 mMesh;
    const Mesh*                 mStencil;
    RandomGeneratorBase*        mRnd;
    SpatialAccelerator*         mAccelerator;
};



class FractureToolImpl : public FractureTool
{

public:

    FractureToolImpl()
    {
        mPlaneIndexerOffset = 1;
        mChunkIdCounter = 0;
        mRemoveIslands = false;
        mInteriorMaterialId = kMaterialInteriorId;
    }

    ~FractureToolImpl()
    {
        reset();
    }

    void                                    release() override;

    void                                    reset() override;
    
    void                                    setInteriorMaterialId(int32_t materialId) override;

    int32_t                                 getInteriorMaterialId() const override;
    
    void                                    replaceMaterialId(int32_t oldMaterialId, int32_t newMaterialId) override;

    void                                    setSourceMesh(const Mesh* mesh) override;

    int32_t                                 setChunkMesh(const Mesh* mesh, int32_t parentId) override;

    Mesh*                                   createChunkMesh(int32_t chunkId) override;

    void                                    getTransformation(NvcVec3& offset, float& scale) override;


    int32_t                                 voronoiFracturing(uint32_t chunkId, uint32_t cellCount, const NvcVec3* cellPoints, bool replaceChunk) override;

    int32_t                                 voronoiFracturing(uint32_t chunkId, uint32_t cellCount, const NvcVec3* cellPoints, const NvcVec3& scale, const NvcQuat& rotation, bool replaceChunk) override;


    int32_t                                 slicing(uint32_t chunkId, const SlicingConfiguration& conf, bool replaceChunk, RandomGeneratorBase* rnd) override;


    int32_t                                 cut(uint32_t chunkId, const NvcVec3& normal, const NvcVec3& position, const NoiseConfiguration& noise, bool replaceChunk, RandomGeneratorBase* rnd) override;

    int32_t                                 cutout(uint32_t chunkId, CutoutConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd) override;


    void                                    finalizeFracturing() override;
    
    uint32_t                                getChunkCount() const override;

    const ChunkInfo&                        getChunkInfo(int32_t chunkIndex) override;

    float                                   getMeshOverlap(const Mesh& meshA, const Mesh& meshB) override;

    uint32_t                                getBaseMesh(int32_t chunkIndex, Triangle*& output) override;

    uint32_t                                updateBaseMesh(int32_t chunkIndex, Triangle* output) override;

    int32_t                                 getChunkIndex(int32_t chunkId) override;

    int32_t                                 getChunkId(int32_t chunkIndex) override;

    int32_t                                 getChunkDepth(int32_t chunkId) override;

    uint32_t                                getChunksIdAtDepth(uint32_t depth, int32_t*& chunkIds) override;


    uint32_t                                getBufferedBaseMeshes(Vertex*& vertexBuffer, uint32_t*& indexBuffer, uint32_t*& indexBufferOffsets) override;

    void                                    setRemoveIslands(bool isRemoveIslands) override;

    int32_t                                 islandDetectionAndRemoving(int32_t chunkId, bool createAtNewDepth = false) override;

    bool                                    isMeshContainOpenEdges(const Mesh* input) override;

    bool                                    deleteChunkSubhierarchy(int32_t chunkId, bool deleteRoot = false) override;

    void                                    uniteChunks(uint32_t threshold, uint32_t targetClusterSize,
                                                        const uint32_t* chunksToMerge, uint32_t mergeChunkCount,
                                                        const NvcVec2i* adjChunks, uint32_t adjChunksSize,
                                                        bool removeOriginalChunks = false) override;
    
    bool                                    setApproximateBonding(uint32_t chunkId, bool useApproximateBonding) override;

    void                                    fitUvToRect(float side, uint32_t chunkId) override;

    void                                    fitAllUvToRect(float side) override;



private:    
    bool                                    isAncestorForChunk(int32_t ancestorId, int32_t chunkId);
    int32_t                                 slicingNoisy(uint32_t chunkId, const SlicingConfiguration& conf, bool replaceChunk, RandomGeneratorBase* rnd);
    uint32_t                                stretchGroup(const std::vector<uint32_t>& group, std::vector<std::vector<uint32_t>>& graph);
    void                                    rebuildAdjGraph(const std::vector<uint32_t>& chunksToRebuild, const NvcVec2i* adjChunks, uint32_t adjChunksSize,
                                                            std::vector<std::vector<uint32_t> >& chunkGraph);
    void                                    fitAllUvToRect(float side, std::set<uint32_t>& mask);
    void                                    markLeaves();

    uint32_t                                createNewChunk(uint32_t parentId);


protected:
    float                               mScaleFactor;
    NvcVec3                             mOffset;

    /* Chunk mesh wrappers */
    std::vector<Triangulator*>          mChunkPostprocessors;


    
    int64_t                             mPlaneIndexerOffset;
    int32_t                             mChunkIdCounter;
    std::vector<ChunkInfo>              mChunkData;

    bool                                mRemoveIslands;
    int32_t                             mInteriorMaterialId;
};

void findCellBasePlanes(const std::vector<NvcVec3>& sites, std::vector<std::vector<int32_t> >& neighboors);
Mesh* getCellMesh(class BooleanEvaluator& eval, int32_t planeIndexerOffset, int32_t cellId, const std::vector<NvcVec3>& sites, std::vector < std::vector<int32_t> >& neighboors, int32_t interiorMaterialId, NvcVec3 origin);

} // namespace Blast
} // namespace Nv


#endif // ifndef NVBLASTAUTHORINGFRACTURETOOLIMPL_H