NvBlastExtAuthoringMeshImpl.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 NVBLASTAUTHORINGMESHIMPL_H
#define NVBLASTAUTHORINGMESHIMPL_H

#include "NvBlastExtAuthoringMesh.h"
#include <PxBounds3.h>
#include <vector>
#include <map>
#include <set>

namespace Nv
{
namespace Blast
{

class MeshImpl : public Mesh
{
public:
        
    MeshImpl(const NvcVec3* position, const NvcVec3* normals, const NvcVec2* uv, uint32_t verticesCount, const uint32_t* indices, uint32_t indicesCount);

    MeshImpl(const Vertex* vertices, const Edge* edges, const Facet* facets, uint32_t posCount, uint32_t edgesCount, uint32_t facetsCount);

    MeshImpl(const Vertex* vertices, uint32_t count);

    MeshImpl(const Vertex* vertices, uint32_t count, uint32_t* indices, uint32_t indexCount, void* materials, uint32_t materialStride);

    ~MeshImpl();

    virtual void        release() override;

    bool                isValid() const override;

    Vertex*             getVerticesWritable() override;

    Edge*               getEdgesWritable() override;

    Facet*              getFacetsBufferWritable() override;

    const Vertex*           getVertices() const override;

    const Edge*             getEdges() const override;

    const Facet*            getFacetsBuffer() const override;

    Facet*              getFacetWritable(int32_t facet) override;

    const Facet*        getFacet(int32_t facet) const override;

    uint32_t            getEdgesCount() const override;

    uint32_t            getVerticesCount() const override;

    uint32_t            getFacetCount() const override;


    const NvcBounds3&   getBoundingBox() const override;

    NvcBounds3& getBoundingBoxWritable() override;

    void                recalculateBoundingBox() override;

    float               getMeshVolume() override;


    void    setMaterialId(const int32_t* materialIds) override;

    void    replaceMaterialId(int32_t oldMaterialId, int32_t newMaterialId) override;

    void    setSmoothingGroup(const int32_t* smoothingGroups) override;

    virtual void                        calcPerFacetBounds() override;

    virtual const  NvcBounds3*  getFacetBound(uint32_t index) const override;

private:
    std::vector<Vertex> mVertices;
    std::vector<Edge>   mEdges;
    std::vector<Facet>  mFacets;
    physx::PxBounds3 mBounds;
    std::vector<physx::PxBounds3> mPerFacetBounds;
};

} // namespace Blast
} // namespace Nv


#endif // ifndef NVBLASTAUTHORINGMESHIMPL_H