Scene.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2017, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, 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.
 */


#ifndef SCENE_H
#define SCENE_H

#include "ApexDesc.h"
#include "Renderable.h"
#include "RenderDebugInterface.h"
#include "Context.h"
#include "foundation/PxVec3.h"
#include <ApexDefs.h>

#if PX_PHYSICS_VERSION_MAJOR == 3
#include "PxFiltering.h"
#endif
#include "MirrorScene.h"

namespace NvParameterized
{
class Interface;
}

namespace physx
{
    class PxBaseTask;
    class PxTaskManager;
    class PxCpuDispatcher;
    class PxGpuDispatcher;
}

namespace nvidia
{
namespace apex
{
// Forward declaration for the PhysX3Interface::setContactReportFlags() callback
class DestructibleActor;

PX_PUSH_PACK_DEFAULT

#if PX_PHYSICS_VERSION_MAJOR == 3

class PhysX3Interface
{
public:
    virtual void setContactReportFlags(PxShape* shape, physx::PxPairFlags flags, DestructibleActor* actor, uint16_t actorChunkIndex) = 0;

    virtual physx::PxPairFlags getContactReportFlags(const physx::PxShape* shape) const = 0;
};
#endif

class SceneDesc : public ApexDesc
{
public:

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

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


    PxScene* scene;

    RenderDebugInterface* debugInterface;

#if PX_PHYSICS_VERSION_MAJOR == 0

    PxCpuDispatcher* cpuDispatcher;

    PxGpuDispatcher* gpuDispatcher;

#elif PX_PHYSICS_VERSION_MAJOR == 3

    PhysX3Interface* physX3Interface;

#endif

    bool    useDebugRenderable;

    bool    debugVisualizeRemotely;

    bool    debugVisualizeLocally;

    bool    useCuda;

private:
    PX_INLINE void init()
    {
#if PX_PHYSICS_VERSION_MAJOR == 0
        cpuDispatcher = 0;
        gpuDispatcher = 0;
#elif PX_PHYSICS_VERSION_MAJOR == 3
        physX3Interface = 0;
#endif
        scene = 0;
        debugInterface = 0;
        useDebugRenderable = false;
        debugVisualizeRemotely = false;
        debugVisualizeLocally = true;
#if APEX_CUDA_SUPPORT
        useCuda = true;
#else
        useCuda = false;
#endif
    }
};


struct StatDataType
{
    enum Enum
    {
        INVALID = 0,
        STRING  = 1,
        INT     = 2,
        FLOAT   = 3,
        ENUM    = 4,
        BOOL    = 5,
    };
};

typedef struct oaValueStruct
{
    union
    {
        char*           String;
        int32_t         Int;
        float           Float;
        char*           Enum;
        bool            Bool;
    };
} StatValue;

typedef struct
{
    const char*         StatName;

    StatDataType::Enum  StatType;

    StatValue           StatCurrentValue;
} StatsInfo;

struct SceneStats
{
    uint32_t            numApexStats;
    StatsInfo*          ApexStatsInfoPtr;
};

struct ViewMatrixType
{
    enum Enum
    {
        USER_CUSTOMIZED = 0,
        LOOK_AT_RH,
        LOOK_AT_LH,
    };
};

struct ProjMatrixType
{
    enum Enum
    {
        USER_CUSTOMIZED = 0,
    };
};

struct UserBoundingBoxFlags
{
    enum Enum
    {
        NONE    = 1 << 0,
        ENTER   = 1 << 1,
        LEAVE   = 1 << 2
    };
};

class Scene : public Renderable, public Context, public ApexInterface
{
public:

#if PX_PHYSICS_VERSION_MAJOR == 3

    virtual void setPhysXScene(PxScene* s) = 0;

    virtual PxScene* getPhysXScene() const = 0;

#endif

    virtual const SceneStats* getStats(void) const = 0;

    virtual void simulate(float elapsedTime, 
                          bool finalStep = true, 
                          PxBaseTask *completionTask = NULL,
                          void* scratchMemBlock = 0, 
                          uint32_t scratchMemBlockSize = 0) = 0;

    virtual bool fetchResults(bool block, uint32_t* errorState) = 0;

    virtual const PxRenderBuffer* getRenderBuffer() const = 0;

    virtual const PxRenderBuffer* getRenderBufferScreenSpace() const = 0;

    virtual bool checkResults(bool block) const = 0;

    virtual uint32_t allocViewMatrix(ViewMatrixType::Enum) = 0;

    virtual uint32_t allocProjMatrix(ProjMatrixType::Enum) = 0;

    virtual uint32_t getNumViewMatrices() const = 0;

    virtual uint32_t getNumProjMatrices() const = 0;

    virtual void setViewMatrix(const PxMat44& viewTransform, const uint32_t viewID = 0) = 0;

    virtual PxMat44 getViewMatrix(const uint32_t viewID = 0) const = 0;

    virtual void setProjMatrix(const PxMat44& projTransform, const uint32_t projID = 0) = 0;

    virtual PxMat44 getProjMatrix(const uint32_t projID = 0) const = 0;

    virtual void setUseViewProjMatrix(const uint32_t viewID = 0, const uint32_t projID = 0) = 0;

    virtual void setViewParams(const PxVec3& eyePosition, const PxVec3& eyeDirection, const PxVec3& worldUpDirection = PxVec3(0, 1, 0), const uint32_t viewID = 0) = 0;

    virtual void setProjParams(float nearPlaneDistance, float farPlaneDistance, float fieldOfViewDegree, uint32_t viewportWidth, uint32_t viewportHeight, const uint32_t projID = 0) = 0;

    virtual PxVec3 getEyePosition(const uint32_t viewID = 0) const = 0;

    virtual PxVec3 getEyeDirection(const uint32_t viewID = 0) const = 0;

    virtual PxTaskManager* getTaskManager() const = 0;

    virtual void setUseDebugRenderable(bool state) = 0;

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

    virtual ::NvParameterized::Interface* getModuleDebugRenderParams(const char* name) const = 0;

    virtual PxVec3 getGravity() const = 0;

    virtual void setGravity(const PxVec3& gravity) = 0;


#if PX_PHYSICS_VERSION_MAJOR == 3

    virtual void lockRead(const char *fileName,uint32_t lineo) = 0;

    virtual void lockWrite(const char *fileName,uint32_t lineno) = 0;

    virtual void unlockRead() = 0;

    virtual void unlockWrite() = 0;

    virtual void addActorPair(PxActor *actor0,PxActor *actor1) = 0;

    virtual void removeActorPair(PxActor *actor0,PxActor *actor1) = 0;

    virtual bool findActorPair(PxActor *actor0,PxActor *actor1) const = 0;


    virtual MirrorScene *createMirrorScene(nvidia::apex::Scene &mirrorScene,
        MirrorScene::MirrorFilter &mirrorFilter,
        float mirrorStaticDistance,
        float mirrorDynamicDistance,
        float mirrorRefreshDistance) = 0;
#endif


    virtual void addBoundingBox(const PxBounds3& bounds, UserBoundingBoxFlags::Enum flags) = 0;

    virtual const PxBounds3 getBoundingBox(const uint32_t index) const = 0;

    virtual UserBoundingBoxFlags::Enum getBoundingBoxFlags(const uint32_t index) const = 0;

    virtual uint32_t getBoundingBoxCount() const = 0;

    virtual void  removeBoundingBox(const uint32_t index) = 0;

    virtual void  removeAllBoundingBoxes() = 0;

    virtual void* getCudaTestManager() const = 0;
    
    virtual void* getCudaProfileManager() const = 0;

    virtual void setCudaKernelCheckEnabled(bool enabled) = 0;
    
    virtual bool getCudaKernelCheckEnabled() const = 0;

#if APEX_UE4

    virtual void updateGravity() = 0;
#endif
};


PX_POP_PACK

}
} // end namespace nvidia::apex

#endif // SCENE_H