RenderMeshAsset.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 RENDER_MESH_ASSET_H
#define RENDER_MESH_ASSET_H

#include "ApexUsingNamespace.h"
#include "VertexFormat.h"
#include "Asset.h"
#include "RenderBufferData.h"
#include "RenderMesh.h"

namespace nvidia
{
namespace apex
{

PX_PUSH_PACK_DEFAULT

class RenderMeshActor;
class RenderMeshActorDesc;
class CustomBufferIterator;

#define RENDER_MESH_AUTHORING_TYPE_NAME "ApexRenderMesh"

struct RenderMeshAssetStats
{
    uint32_t    totalBytes;             
    uint32_t    submeshCount;           
    uint32_t    partCount;              
    uint32_t    vertexCount;            
    uint32_t    indexCount;             
    uint32_t    vertexBufferBytes;      
    uint32_t    indexBufferBytes;       
};

struct RenderMeshAssetInstanceMode
{
    enum Enum
    {
        POSE_SCALE = 0,
        POS_VEL_LIFE,

        NUM_MODES
    };
};


struct VertexColor
{
public:

    PX_INLINE                   VertexColor()   {}

    PX_INLINE                   VertexColor(const ColorRGBA c)
    {
        const float recip255 = 1 / (float)255;
        set((float)c.r * recip255, (float)c.g * recip255, (float)c.b * recip255, (float)c.a * recip255);
    }

    PX_INLINE   VertexColor&    operator = (const VertexColor& c)
    {
        r = c.r;
        g = c.g;
        b = c.b;
        a = c.a;
        return *this;
    }

    PX_INLINE   void            set(float _r, float _g, float _b, float _a)
    {
        r = _r;
        g = _g;
        b = _b;
        a = _a;
    }

    PX_INLINE   ColorRGBA       toColorRGBA() const
    {
        return ColorRGBA((uint8_t)(255 * r + (float)0.5),
                           (uint8_t)(255 * g + (float)0.5),
                           (uint8_t)(255 * b + (float)0.5),
                           (uint8_t)(255 * a + (float)0.5));
    }

    float r;        
    float g;        
    float b;        
    float a;        
};


struct VertexUV
{
    VertexUV() {}

    VertexUV(float _u, float _v)
    {
        set(_u, _v);
    }

    VertexUV(const float uv[])
    {
        set(uv);
    }

    void            set(float _u, float _v)
    {
        u = _u;
        v = _v;
    }

    void            set(const float uv[])
    {
        u = uv[0];
        v = uv[1];
    }

    float&          operator [](int i)
    {
        PX_ASSERT(i >= 0 && i <= 1);
        return (&u)[i];
    }

    const float&    operator [](int i) const
    {
        PX_ASSERT(i >= 0 && i <= 1);
        return (&u)[i];
    }

    float   u;
    float   v;
};


struct Vertex
{
    PxVec3      position;       
    PxVec3      normal;         
    PxVec3      tangent;        
    PxVec3      binormal;       
    VertexUV    uv[VertexFormat::MAX_UV_COUNT]; 
    VertexColor color;          
    uint16_t    boneIndices[VertexFormat::MAX_BONE_PER_VERTEX_COUNT]; 
    float       boneWeights[VertexFormat::MAX_BONE_PER_VERTEX_COUNT]; 
    uint16_t    displacementFlags; 

    Vertex()
    {
        memset(this, 0, sizeof(Vertex));
    }
};


struct ExplicitRenderTriangle
{
    Vertex      vertices[3];        
    int32_t     submeshIndex;       
    uint32_t    smoothingMask;      
    uint32_t    extraDataIndex;     

    PxVec3  calculateNormal() const
    {
        return (vertices[1].position - vertices[0].position).cross(vertices[2].position - vertices[0].position);
    }
};



struct RenderMeshPartData
{
    RenderMeshPartData() : triangleCount(0), userData(NULL) {}

    RenderMeshPartData(uint32_t _triCount, void* _data) : triangleCount(_triCount), userData(_data) {}

    uint32_t        triangleCount;  
    void*           userData;       
};


class RenderMeshAssetAuthoring : public AssetAuthoring
{
public:
    class VertexBuffer : public RenderBufferData<RenderVertexSemantic, RenderVertexSemantic::Enum> {};

    struct Primitive
    {
        enum Enum
        {
            TRIANGLE_LIST,
            //      TRIANGLE_STRIP, // Not supported for now
            //      TRIANGLE_FAN,   // Not supported for now

            COUNT
        };
    };

    struct IndexType
    {
        enum Enum
        {
            UINT,
            USHORT,

            COUNT
        };
    };

    class SubmeshDesc
    {
    public:
        const char*             m_materialName;

        const VertexBuffer*     m_vertexBuffers;

        uint32_t                m_numVertexBuffers;

        uint32_t                m_numVertices;

        Primitive::Enum         m_primitive;

        IndexType::Enum         m_indexType;

        const void*             m_vertexIndices;

        uint32_t                m_numIndices;

        uint32_t*               m_smoothingGroups;

        uint32_t                m_firstVertex;

        const void*             m_partIndices;

        uint32_t                m_numParts;

        RenderCullMode::Enum    m_cullMode;

        SubmeshDesc()
        {
            memset(this, 0, sizeof(SubmeshDesc));
        }

        bool    isValid() const
        {
            return  m_materialName != NULL &&
                    m_vertexBuffers != NULL &&  // BRG - todo: check the vertex buffers for validity
                    m_numVertexBuffers > 0 &&
                    m_numVertices > 0 &&
                    m_primitive >= (Primitive::Enum)0 && m_primitive < Primitive::COUNT &&
                    m_indexType >= (IndexType::Enum)0 && m_indexType < IndexType::COUNT &&
                    m_numIndices > 0 &&
                    (m_partIndices == NULL || m_numParts > 0) &&
                    (m_cullMode == RenderCullMode::CLOCKWISE || m_cullMode == RenderCullMode::COUNTER_CLOCKWISE || m_cullMode == RenderCullMode::NONE);
        }
    };

    class MeshDesc
    {
    public:
        const SubmeshDesc*      m_submeshes;

        uint32_t                m_numSubmeshes;

        TextureUVOrigin::Enum   m_uvOrigin;



        MeshDesc() : m_submeshes(NULL), m_numSubmeshes(0), m_uvOrigin(TextureUVOrigin::ORIGIN_TOP_LEFT) {}

        bool    isValid() const
        {
            return  m_submeshes != NULL &&
                    m_numSubmeshes > 0;
        }
    };


    virtual void                    createRenderMesh(const MeshDesc& meshDesc, bool createMappingInformation) = 0;


    virtual uint32_t                createReductionMap(uint32_t* map, const Vertex* vertices, const uint32_t* smoothingGroups, uint32_t vertexCount,
                                                       const PxVec3& positionTolerance, float normalTolerance, float UVTolerance) = 0;


    virtual void                    deleteStaticBuffersAfterUse(bool set)   = 0;

    /* Public access to RenderMeshAsset get methods */

    virtual uint32_t                getSubmeshCount() const = 0;
    virtual uint32_t                getPartCount() const = 0;
    virtual const char*             getMaterialName(uint32_t submeshIndex) const = 0;
    virtual void                    setMaterialName(uint32_t submeshIndex, const char* name) = 0;
    virtual void                    setWindingOrder(uint32_t submeshIndex, RenderCullMode::Enum winding) = 0;
    virtual RenderCullMode::Enum    getWindingOrder(uint32_t submeshIndex) const = 0;
    virtual const RenderSubmesh&    getSubmesh(uint32_t submeshIndex) const = 0;
    virtual RenderSubmesh&          getSubmeshWritable(uint32_t submeshIndex) = 0;
    virtual const PxBounds3&        getBounds(uint32_t partIndex = 0) const = 0;
    virtual void                    getStats(RenderMeshAssetStats& stats) const = 0;
};


class RenderMeshAsset : public Asset
{
public:

    virtual RenderMeshActor*        createActor(const RenderMeshActorDesc& desc) = 0;

    virtual void                    releaseActor(RenderMeshActor&) = 0;

    virtual uint32_t                getSubmeshCount() const = 0;

    virtual uint32_t                getPartCount() const = 0;

    virtual const char*             getMaterialName(uint32_t submeshIndex) const = 0;

    virtual const RenderSubmesh&    getSubmesh(uint32_t submeshIndex) const = 0;

    virtual const PxBounds3&        getBounds(uint32_t partIndex = 0) const = 0;

    virtual void                    getStats(RenderMeshAssetStats& stats) const = 0;

    virtual UserOpaqueMesh*         getOpaqueMesh(void) const = 0;

protected:
    virtual                         ~RenderMeshAsset() {}
};

PX_POP_PACK

}
} // end namespace nvidia::apex

#endif // RENDER_MESH_ASSET_H