NvBlastExtAuthoringBooleanTool.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 NVBLASTEXTAUTHORINGBOOLEANTOOL_H
#define NVBLASTEXTAUTHORINGBOOLEANTOOL_H

#include "NvBlastExtAuthoringTypes.h"
#include "NvBlastExtAuthoringInternalCommon.h"
#include <vector>
#include "NvBlastTypes.h"


namespace Nv
{
namespace Blast
{

class Mesh;

struct BooleanConf
{
    int32_t ca, cb, ci;
    BooleanConf(int32_t a, int32_t b, int32_t c) : ca(a), cb(b), ci(c)
    {
    }
};


namespace BooleanConfigurations
{
inline BooleanConf BOOLEAN_INTERSECION()
{
    return BooleanConf(0, 0, 1);
}

inline BooleanConf BOOLEAN_UNION()
{
    return BooleanConf(1, 1, -1);
}
inline BooleanConf BOOLEAN_DIFFERENCE()
{
    return BooleanConf(1, 0, -1);
}
}

struct EdgeFacetIntersectionData
{
    int32_t edId;
    int32_t intersectionType;
    Vertex  intersectionPoint;
    EdgeFacetIntersectionData(int32_t edId, int32_t intersType, Vertex& inters) : edId(edId), intersectionType(intersType), intersectionPoint(inters)
    {   }
    EdgeFacetIntersectionData(int32_t edId) : edId(edId)
    {   }
    bool operator<(const EdgeFacetIntersectionData& b) const
    {
        return edId < b.edId;
    }
};


class SpatialAccelerator;

class BooleanEvaluator
{

public:
    BooleanEvaluator();
    ~BooleanEvaluator();

    void    performBoolean(const Mesh* meshA, const Mesh* meshB, SpatialAccelerator* spAccelA, SpatialAccelerator* spAccelB, BooleanConf mode);

    void    performBoolean(const Mesh* meshA, const Mesh* meshB, BooleanConf mode);

    void    performFastCutting(const Mesh* meshA, const Mesh* meshB, SpatialAccelerator* spAccelA, SpatialAccelerator* spAccelB, BooleanConf mode);

    void    performFastCutting(const Mesh* meshA, const Mesh* meshB, BooleanConf mode);

    int32_t isPointContainedInMesh(const Mesh* mesh, const NvcVec3& point);
    int32_t isPointContainedInMesh(const Mesh* mesh, SpatialAccelerator* spAccel, const NvcVec3& point);


    Mesh*   createNewMesh();

    void    reset();

private:

    void    buildFaceFaceIntersections(BooleanConf);
    void    buildFastFaceFaceIntersection(BooleanConf);
    void    collectRetainedPartsFromA(BooleanConf mode);
    void    collectRetainedPartsFromB(BooleanConf mode);

    int32_t addIfNotExist(Vertex& p);
    void    addEdgeIfValid(EdgeWithParent& ed);
private:

    int32_t vertexMeshStatus03(const NvcVec3& p, const Mesh* mesh);
    int32_t vertexMeshStatus30(const NvcVec3& p, const Mesh* mesh);

    const Mesh*                                             mMeshA;
    const Mesh*                                             mMeshB;

    SpatialAccelerator*                                     mAcceleratorA;
    SpatialAccelerator*                                     mAcceleratorB;

    std::vector<EdgeWithParent>                             mEdgeAggregate;
    std::vector<Vertex>                                     mVerticesAggregate;

    std::vector<std::vector<EdgeFacetIntersectionData> >    mEdgeFacetIntersectionData12;
    std::vector<std::vector<EdgeFacetIntersectionData> >    mEdgeFacetIntersectionData21;
};

} // namespace Blast
} // namespace Nv


#endif // ifndef NVBLASTEXTAUTHORINGBOOLEANTOOL_H