NvBlastExtAuthoringMeshNoiser.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 NVBLASTEXTAUTHORINGMESHNOISER_H
#define NVBLASTEXTAUTHORINGMESHNOISER_H
#include <vector>
#include <map>
#include "NvBlastExtAuthoringInternalCommon.h"

namespace Nv
{
    namespace Blast
    {
        class SimplexNoise;

        struct EdgeToTriangles
        {
            int32_t tr[2];
            int32_t c;
            EdgeToTriangles()
            {
                c = 0;
            }
            void    add(int32_t t)
            {
                tr[c] = t;
                ++c;
            }
            void    replace(int32_t from, int32_t to)
            {
                if (tr[0] == from)
                {
                    tr[0] = to;
                }
                else
                {
                    if (c == 2 && tr[1] == from)
                    {
                        tr[1] = to;
                    }
                }
            }
            int32_t getNot(int32_t id)
            {
                if (tr[0] != id)
                {
                    return tr[0];
                }
                if (c == 2 && tr[1] != id)
                {
                    return tr[1];
                }
                return -1;
            }

        };

        class MeshNoiser
        {
        public:
            MeshNoiser()
            {
                reset();
            }

            void reset();

            enum EdgeFlag { INTERNAL_EDGE, EXTERNAL_BORDER_EDGE, INTERNAL_BORDER_EDGE, EXTERNAL_EDGE, NONE };

    
            void setMesh(const std::vector<Triangle>& mesh);

            void                            tesselateInternalSurface(float maxLen);

            void                            applyNoise(SimplexNoise& noise, float falloff, int32_t relaxIterations, float relaxFactor);

            std::vector<Triangle>           getMesh();

        private:
            physx::PxVec3                       mOffset;
            float                               mScale;
            bool                                isTesselated;
            std::vector<Vertex>                 mVertices;
            std::vector<TriangleIndexed>        mTriangles;
            std::vector<Edge>                   mEdges;
            std::map<Vertex, int32_t, VrtComp>  mVertMap;
            std::map<Edge, int32_t>             mEdgeMap;


            std::vector<Triangle>           mResultTriangles;


            int32_t                         addVerticeIfNotExist(const Vertex& p);
            int32_t                         addEdge(const Edge& e);
            int32_t                         findEdge(const Edge& e);



            void                            collapseEdge(int32_t id);
            void                            divideEdge(int32_t id);
            void                            updateVertEdgeInfo();
            void                            updateEdgeTriangleInfo();
            void                            relax(int32_t iterations, float factor, std::vector<Vertex>& vertices);
            void                            recalcNoiseDirs();


            std::vector<bool>                           mRestrictionFlag;
            std::vector<EdgeFlag>                       mEdgeFlag;
            std::vector<EdgeToTriangles>                mTrMeshEdToTr;
            std::vector<int32_t>                        mVertexValence;
            std::vector<std::vector<int32_t> >          mVertexToTriangleMap;



            std::vector<float>                          mVerticesDistances;
            std::vector<physx::PxVec3>                  mVerticesNormalsSmoothed;
            std::vector<uint32_t>                       mPositionMappedVrt;
            std::vector<std::vector<int32_t> >          mGeometryGraph;

            void                                        prebuildEdgeFlagArray();
            void                                        computePositionedMapping();
            void                                        computeFalloffAndNormals();

            void                                        prebuildTesselatedTriangles();
        };

    } // namespace Blast
} // namespace Nv
#endif // ! NVBLASTEXTAUTHORINGMESHNOISER_H