NxVertexFormat.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) 2008-2014 NVIDIA Corporation. All rights reserved.

#ifndef NX_VERTEX_FORMAT_H
#define NX_VERTEX_FORMAT_H

#include "NxApexUsingNamespace.h"
#include "NxUserRenderResourceManager.h"
#include "NxUserRenderVertexBufferDesc.h"

namespace physx
{
namespace apex
{

PX_PUSH_PACK_DEFAULT

struct PxColorRGBA
{
    PxColorRGBA() : r(0xFF), g(0xFF), b(0xFF), a(0xFF) {}
    PxColorRGBA(PxU8 _r, PxU8 _g, PxU8 _b, PxU8 _a) : r(_r), g(_g), b(_b), a(_a) {}

    PxU8    r;
    PxU8    g;
    PxU8    b;
    PxU8    a;
};

struct NxRenderDataAccess
{
    enum Enum
    {
        STATIC = 0,
        DYNAMIC,
        STREAMING,

        ACCESS_TYPE_COUNT
    };
};

class NxVertexFormat
{
public:

    enum
    {
        MAX_UV_COUNT = 4,
        MAX_BONE_PER_VERTEX_COUNT = 4,
    };

    typedef physx::PxU32 BufferID;


    virtual void                            reset() = 0;


    virtual void                            setWinding(NxRenderCullMode::Enum winding) = 0;

    virtual void                            setHasSeparateBoneBuffer(bool hasSeparateBoneBuffer) = 0;

    virtual NxRenderCullMode::Enum          getWinding() const = 0;

    virtual bool                            hasSeparateBoneBuffer() const = 0;


    virtual const char*                     getSemanticName(NxRenderVertexSemantic::Enum semantic) const = 0;

    virtual BufferID                        getSemanticID(NxRenderVertexSemantic::Enum semantic) const = 0;

    virtual BufferID                        getID(const char* name) const = 0;


    virtual physx::PxI32                    addBuffer(const char* name) = 0;

    virtual bool                            bufferReplaceWithLast(physx::PxU32 index) = 0;


    virtual bool                            setBufferFormat(physx::PxU32 index, NxRenderDataFormat::Enum format) = 0;

    virtual bool                            setBufferAccess(physx::PxU32 index, NxRenderDataAccess::Enum access) = 0;

    virtual bool                            setBufferSerialize(physx::PxU32 index, bool serialize) = 0;


    virtual const char*                     getBufferName(physx::PxU32 index) const = 0;

    virtual NxRenderVertexSemantic::Enum    getBufferSemantic(physx::PxU32 index) const = 0;

    virtual BufferID                        getBufferID(physx::PxU32 index) const = 0;

    virtual NxRenderDataFormat::Enum        getBufferFormat(physx::PxU32 index) const = 0;

    virtual NxRenderDataAccess::Enum        getBufferAccess(physx::PxU32 index) const = 0;

    virtual bool                            getBufferSerialize(physx::PxU32 index) const = 0;


    virtual physx::PxU32                    getBufferCount() const = 0;

    virtual physx::PxU32                    getCustomBufferCount() const = 0;

    virtual physx::PxI32                    getBufferIndexFromID(BufferID id) const = 0;


protected:
    NxVertexFormat()    {}
    virtual                                 ~NxVertexFormat()   {}
};

PX_POP_PACK

}
} // end namespace physx::apex

#endif // NX_VERTEX_FORMAT_H