FractureToolsStructs.h

Go to the documentation of this file.

//
// 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_STRUCTS_H
#define FRACTURE_TOOLS_STRUCTS_H

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

PX_PUSH_PACK_DEFAULT

namespace FractureTools
{

struct MeshProcessingParameters
{
    bool islandGeneration;

    bool removeTJunctions;

    unsigned microgridSize;

    nvidia::BSPOpenMode::Enum meshMode;

    int verbosity;

    MeshProcessingParameters()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        islandGeneration = false;
        removeTJunctions = false;
        microgridSize = 65536;
        meshMode = nvidia::BSPOpenMode::Automatic;
        verbosity = 0;
    }
};


class CutoutSet
{
public:
    virtual uint32_t                getCutoutCount() const = 0;

    virtual uint32_t                getCutoutVertexCount(uint32_t cutoutIndex) const = 0;

    virtual uint32_t                getCutoutLoopCount(uint32_t cutoutIndex) const = 0;

    virtual const physx::PxVec3&    getCutoutVertex(uint32_t cutoutIndex, uint32_t vertexIndex) const = 0;

    virtual uint32_t                getCutoutLoopSize(uint32_t coutoutIndex, uint32_t loopIndex) const = 0;

    virtual uint32_t                getCutoutLoopVertexIndex(uint32_t cutoutIndex, uint32_t loopIndex, uint32_t vertexNum) const = 0;

    virtual uint32_t                getCutoutLoopVertexFlags(uint32_t cutoutIndex, uint32_t loopIndex, uint32_t vertexNum) const = 0;

    virtual bool                    isPeriodic() const = 0;

    virtual const physx::PxVec2&    getDimensions() const = 0;

    //virtual void          serialize(physx::PxFileBuf& stream) const = 0;
    //virtual void          deserialize(physx::PxFileBuf& stream) = 0;

    virtual void                    release() = 0;

protected:
    virtual                         ~CutoutSet() {}
};


struct NoiseParameters
{
    float   amplitude;

    float   frequency;

    int     gridSize;

    int     type;

    NoiseParameters()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        amplitude = 0.0f;
        frequency = 0.25f;
        gridSize = 10;
        type = 0;
    }
};


struct SliceParameters
{
    enum Order
    {
        XYZ,
        YZX,
        ZXY,
        ZYX,
        YXZ,
        XZY,
        Through
    };

    unsigned order;

    unsigned splitsPerPass[3];

    float linearVariation[3];

    float angularVariation[3];

    NoiseParameters noise[3];

    SliceParameters()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        order = XYZ;
        splitsPerPass[0] = splitsPerPass[1] = splitsPerPass[2] = 1;
        linearVariation[0] = linearVariation[1] = linearVariation[2] = 0.1f;
        angularVariation[0] = angularVariation[1] = angularVariation[2] = 20.0f * 3.1415927f / 180.0f;
        noise[0].setToDefault();
        noise[1].setToDefault();
        noise[2].setToDefault();
    }
};


struct FractureSliceDesc
{
    unsigned                        maxDepth;

    SliceParameters*                sliceParameters;

    bool                            useTargetProportions;

    float                           targetProportions[3];

    float                           minimumChunkSize[3];

    nvidia::FractureMaterialDesc    materialDesc[3];

    bool                            instanceChunks;

    bool                            useDisplacementMaps;

    enum NoiseMode
    {
        NoiseWavePlane = 0,
        NoisePerlin2D,
        NoisePerlin3D,

        NoiseModeCount
    };

    unsigned            noiseMode;

    FractureSliceDesc()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        maxDepth             = 0;
        sliceParameters      = NULL;
        useTargetProportions = false;
        for (int i = 0; i < 3; ++i)
        {
            targetProportions[i] = 1.0f;
            minimumChunkSize[i] = 0.0f;
            materialDesc[i].setToDefault();
        }
        instanceChunks       = false;
        useDisplacementMaps  = false;
        noiseMode            = NoiseWavePlane;
    }
};


struct CutoutParameters
{
    float depth;

    nvidia::FractureMaterialDesc materialDesc;

    NoiseParameters backfaceNoise;

    NoiseParameters edgeNoise;

    CutoutParameters()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        depth = 1.0f;
        backfaceNoise.setToDefault();
        materialDesc.setToDefault();
        edgeNoise.setToDefault();
    }
};


struct FractureCutoutDesc
{
    enum Directions
    {
        UserDefined = 0,    // If no flags are set, the cutout direction is taken from userDefinedDirection

        NegativeX = 1 << 0,
        PositiveX = 1 << 1,
        NegativeY = 1 << 2,
        PositiveY = 1 << 3,
        NegativeZ = 1 << 4,
        PositiveZ = 1 << 5,

        DirectionCount = 6
    };

    unsigned directions;

    unsigned directionOrder[DirectionCount];

    CutoutParameters cutoutParameters[DirectionCount];

    physx::PxVec3 userDefinedDirection;

    physx::PxMat33 userUVMapping;

    CutoutParameters userDefinedCutoutParameters;

    enum InstancingMode
    {
        DoNotInstance,
        InstanceCongruentChunks,
        InstanceAllChunks,

        InstanceModeCount
    };

    unsigned instancingMode;

    bool tileFractureMap;

    physx::PxVec2 uvTileSize;

    bool splitNonconvexRegions;

    enum CutoutChunkFracturingMethod
    {
        DoNotFractureCutoutChunks,
        SliceFractureCutoutChunks,
        VoronoiFractureCutoutChunks,

        CutoutChunkFracturingMethodCount
    };

    unsigned chunkFracturingMethod;

    bool trimFaceCollisionHulls;

    float cutoutWidthScale[DirectionCount];

    float cutoutHeightScale[DirectionCount];

    float cutoutWidthOffset[DirectionCount];

    float cutoutHeightOffset[DirectionCount];

    bool cutoutWidthInvert[DirectionCount];

    bool cutoutHeightInvert[DirectionCount];

    float cutoutSizeX;

    float cutoutSizeY;

    float facetNormalMergeThresholdAngle;

    FractureCutoutDesc()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        directions          = 0;
        userDefinedDirection= physx::PxVec3(0.0f);
        userUVMapping       = physx::PxMat33(physx::PxIdentity);
        userDefinedCutoutParameters.setToDefault();
        instancingMode      = DoNotInstance;
        tileFractureMap     = false;
        uvTileSize          = physx::PxVec2(0.0f);
        for (uint32_t i = 0; i < DirectionCount; ++i)
        {
            directionOrder[i]     = 1u << i;
            cutoutParameters[i].setToDefault();
            cutoutWidthScale[i]   = 1.0f;
            cutoutHeightScale[i]  = 1.0f;
            cutoutWidthOffset[i]  = 0.0f;
            cutoutHeightOffset[i] = 0.0f;
            cutoutWidthInvert[i]  = false;
            cutoutHeightInvert[i] = false;
        }
        cutoutSizeX                    = 1.0f;
        cutoutSizeY                    = 1.0f;
        facetNormalMergeThresholdAngle = 60.0f;
        splitNonconvexRegions          = false;
        chunkFracturingMethod          = DoNotFractureCutoutChunks;
        trimFaceCollisionHulls         = true;
    }
};


struct FractureVoronoiDesc
{
    unsigned                siteCount;

    const physx::PxVec3*    sites;

    const uint32_t*         chunkIndices;

    NoiseParameters         faceNoise;

    bool                    instanceChunks;

    bool                    useDisplacementMaps;

    enum NoiseMode
    {
        NoiseWavePlane = 0,
        NoisePerlin2D,
        NoisePerlin3D,

        NoiseModeCount
    };

    unsigned                noiseMode;

    float                   minimumChunkSize;

    nvidia::FractureMaterialDesc    materialDesc;


    FractureVoronoiDesc()
    {
        setToDefault();
    }

    void    setToDefault()
    {
        siteCount = 0;
        sites = NULL;
        chunkIndices = NULL;
        faceNoise.setToDefault();
        instanceChunks = false;
        useDisplacementMaps = false;
        noiseMode = NoiseWavePlane;
        minimumChunkSize = 0.0f;
        materialDesc.setToDefault();
    }
};


} // namespace FractureTools


PX_POP_PACK

#endif // FRACTURE_TOOLS_H