ApexSDK.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 APEX_SDK_H
#define APEX_SDK_H

#include "ApexDefs.h"
#include "ApexUsingNamespace.h"
#include "ApexDesc.h"
#include "ApexInterface.h"

#include "nvparameterized/NvSerializer.h"
#include "nvparameterized/NvParameterized.h"
#include "nvparameterized/NvParameterizedTraits.h"
#include "Shape.h"


namespace RENDER_DEBUG
{
    class RenderDebugInterface;
};

namespace physx
{
    class PxFoundation;
    class PxCpuDispatcher;

    namespace profile
    {
        class PxProfileZoneManager;
    }
    class PxPvd;
}

namespace nvidia
{
namespace apex
{

class UserRenderResourceManager;
class Scene;
class SceneDesc;
class AssetPreviewScene;
class RenderMeshAsset;
class RenderMeshAssetAuthoring;
class Module;
class PhysXObjectDesc;
class ResourceProvider;
class ResourceCallback;
class RenderDebugInterface;
class Asset;
class AssetAuthoring;
class ApexSDKCachedData;
class RenderMeshActor;

PX_PUSH_PACK_DEFAULT

class GroupsMask64
{
public:
    PX_INLINE GroupsMask64() 
    {
        bits0 = bits1 = 0;
    }

    PX_INLINE GroupsMask64(uint32_t b0, uint32_t b1) : bits0(b0), bits1(b1) {}

    PX_INLINE void setToDefault()
    {
        *this = GroupsMask64();
    }

    uint32_t        bits0;
    uint32_t        bits1;
};

struct GroupsFilterOp
{
    enum Enum
    {
        AND,
        OR,
        XOR,
        NAND,
        NOR,
        NXOR,
        SWAP_AND
    };
};

typedef unsigned int AuthObjTypeID;

class ApexSDKDesc : public ApexDesc
{
public:
    PxFoundation* foundation;

    uint32_t physXSDKVersion;

#if PX_PHYSICS_VERSION_MAJOR == 3

    PxPhysics* physXSDK;

    PxCooking* cooking;
#endif

    PxPvd*  pvd;

    UserRenderResourceManager* renderResourceManager;

    ResourceCallback* resourceCallback;

    const char* dllLoadPath;

    const char* wireframeMaterial;

    const char* solidShadedMaterial;

    bool renderMeshActorLoadMaterialsLazily;

    const char* dllNamePostfix;

    const char* appGuid;


    bool resourceProviderIsCaseSensitive;

    uint32_t physXObjDescTableAllocationIncrement;

    bool enableConcurrencyCheck;

    PX_INLINE ApexSDKDesc() : ApexDesc()
    {
        init();
    }

    PX_INLINE void setToDefault()
    {
        ApexDesc::setToDefault();
        init();
    }

    PX_INLINE bool isValid() const
    {
        bool retVal = ApexDesc::isValid();

        if (foundation == NULL)
        {
            return false;
        }
#if PX_PHYSICS_VERSION_MAJOR == 3
        if (physXSDK == NULL)
        {
            return false;
        }
        if (cooking == NULL)
        {
            return false;
        }
        if (physXSDKVersion != PX_PHYSICS_VERSION)
        {
            return false;
        }
#endif
        return retVal;
    }

private:
    PX_INLINE void init()
    {
        renderResourceManager = NULL;
        foundation = NULL;
#if PX_PHYSICS_VERSION_MAJOR == 3
        physXSDKVersion = PX_PHYSICS_VERSION;
        physXSDK = NULL;
        cooking = NULL;
#endif
        pvd = NULL;
        resourceCallback = NULL;
        dllLoadPath = NULL;
        solidShadedMaterial = "ApexSolidShaded";
        wireframeMaterial = "ApexWireframe";
        renderMeshActorLoadMaterialsLazily = true;
        dllNamePostfix = NULL;
        appGuid = NULL;
        resourceProviderIsCaseSensitive = false;
        physXObjDescTableAllocationIncrement = 128;
        enableConcurrencyCheck = false;
    }
};


enum ApexCreateError
{
    APEX_CE_NO_ERROR = 0,

    APEX_CE_NOT_FOUND = 1,

    APEX_CE_WRONG_VERSION = 2,

    APEX_CE_DESCRIPTOR_INVALID = 3,

    APEX_CE_CREATE_NO_ALLOWED = 4,

};


class ApexSDK : public ApexInterface
{
public:
    virtual Scene* createScene(const SceneDesc&) = 0;

    virtual void releaseScene(Scene*) = 0;

    virtual AssetPreviewScene* createAssetPreviewScene() = 0;

    virtual void releaseAssetPreviewScene(AssetPreviewScene* nxScene) = 0;

    virtual Module* createModule(const char* name, ApexCreateError* err = NULL) = 0;

#if PX_PHYSICS_VERSION_MAJOR == 0

    virtual physx::PxCpuDispatcher* createCpuDispatcher(uint32_t numThreads = 0) = 0;
    virtual void releaseCpuDispatcher(physx::PxCpuDispatcher& cd) = 0;
#endif

#if PX_PHYSICS_VERSION_MAJOR == 3

    virtual const PhysXObjectDesc* getPhysXObjectInfo(const PxActor* actor) const = 0;

    virtual const PhysXObjectDesc* getPhysXObjectInfo(const PxShape* shape) const = 0;

    virtual const PhysXObjectDesc* getPhysXObjectInfo(const PxJoint* joint) const = 0;

    virtual const PhysXObjectDesc* getPhysXObjectInfo(const PxCloth* cloth) const = 0;

    virtual PxCooking* getCookingInterface() = 0;
#endif

    PX_DEPRECATED virtual PxErrorCallback* getOutputStream() = 0;

    virtual PxErrorCallback* getErrorCallback() const = 0;

    virtual PxAllocatorCallback* getAllocator() const = 0;

    virtual ResourceProvider* getNamedResourceProvider() = 0;

    virtual PxFileBuf* createStream(const char* filename, PxFileBuf::OpenMode mode) = 0;

    virtual PxFileBuf* createMemoryReadStream(const void* mem, uint32_t len) = 0;

    virtual PxFileBuf* createMemoryWriteStream(uint32_t alignment = 0) = 0;

    virtual const void* getMemoryWriteBuffer(PxFileBuf& stream, uint32_t& len) = 0;

    virtual void releaseMemoryReadStream(PxFileBuf& stream) = 0;

    virtual void releaseMemoryWriteStream(PxFileBuf& stream) = 0;

#if PX_PHYSICS_VERSION_MAJOR == 3

    virtual PxPhysics* getPhysXSDK() = 0;
#endif

    virtual uint32_t getNbModules() = 0;

    virtual Module** getModules() = 0;

    virtual void releaseModule(Module* module) = 0;

    virtual RenderDebugInterface* createApexRenderDebug(RENDER_DEBUG::RenderDebugInterface* iface, bool useRemoteDebugVisualization = false) = 0;

    virtual void releaseApexRenderDebug(RenderDebugInterface& debug) = 0;

    virtual SphereShape* createApexSphereShape() = 0;

    virtual CapsuleShape* createApexCapsuleShape() = 0;

    virtual BoxShape* createApexBoxShape() = 0;

    virtual HalfSpaceShape* createApexHalfSpaceShape() = 0;

    virtual void releaseApexShape(Shape& shape) = 0;

    virtual uint32_t forceLoadAssets() = 0;

    virtual bool getAuthorableObjectNames(const char** authTypeNames, uint32_t& outCount, uint32_t inCount) = 0;

    virtual ::NvParameterized::Traits* getParameterizedTraits() = 0;

    virtual Asset* createAsset(AssetAuthoring&, const char* name) = 0;

    virtual Asset* createAsset(::NvParameterized::Interface*, const char* name) = 0;

    virtual void releaseAsset(Asset&) = 0;

    virtual AssetAuthoring* createAssetAuthoring(const char* authorTypeName) = 0;

    virtual AssetAuthoring* createAssetAuthoring(const char* authorTypeName, const char* name) = 0;

    virtual AssetAuthoring* createAssetAuthoring(::NvParameterized::Interface*, const char* name) = 0;

    virtual void releaseAssetAuthoring(AssetAuthoring&) = 0;

    virtual ApexSDKCachedData& getCachedData() const = 0;

    virtual ::NvParameterized::Serializer* createSerializer(::NvParameterized::Serializer::SerializeType type) = 0;

    virtual ::NvParameterized::Serializer* createSerializer(::NvParameterized::Serializer::SerializeType type, ::NvParameterized::Traits* traits) = 0;

    virtual ::NvParameterized::Serializer::SerializeType getSerializeType(const void* data, uint32_t dlen) = 0;

    virtual ::NvParameterized::Serializer::SerializeType getSerializeType(PxFileBuf& stream) = 0;

    virtual NvParameterized::Serializer::ErrorType getSerializePlatform(PxFileBuf& stream, NvParameterized::SerializePlatform& platform) = 0;

    virtual NvParameterized::Serializer::ErrorType getSerializePlatform(const void* data, uint32_t dlen, NvParameterized::SerializePlatform& platform) = 0;

    virtual void getCurrentPlatform(NvParameterized::SerializePlatform& platform) const = 0;

    virtual bool getPlatformFromString(const char* name, NvParameterized::SerializePlatform& platform) const = 0;

    virtual const char* getPlatformName(const NvParameterized::SerializePlatform& platform) const = 0;

    virtual ::NvParameterized::Interface* getDebugColorParams() const = 0;

    virtual const char* getWireframeMaterial() = 0;

    virtual const char* getSolidShadedMaterial() = 0;

    virtual void setEnableApexStats(bool enableApexStats) = 0;

    virtual void setEnableConcurrencyCheck(bool enableConcurrencyChecks) = 0;

    virtual bool isConcurrencyCheckEnabled() = 0;

protected:
    virtual ~ApexSDK() {}

};

PX_POP_PACK

#ifdef CALL_CONV
#undef CALL_CONV
#endif

#if PX_WINDOWS_FAMILY

#define APEX_API extern "C" __declspec(dllexport)
#define CALL_CONV __cdecl
#else
#define APEX_API extern "C"
#define CALL_CONV /* void */
#endif

APEX_API ApexSDK*   CALL_CONV CreateApexSDK(    const ApexSDKDesc& desc, 
                                                        ApexCreateError* errorCode = NULL, 
                                                        uint32_t APEXsdkVersion = APEX_SDK_VERSION, 
                                                        PxAllocatorCallback* alloc = 0);

APEX_API ApexSDK*   CALL_CONV GetApexSDK();

}
} // end namespace nvidia::apex

#endif // APEX_SDK_H