Scene.h

Go to the documentation of this file.

//  -------------------------------------------------------------------------
//  Copyright (C) 2014 BMW Car IT GmbH
//  -------------------------------------------------------------------------
//  This Source Code Form is subject to the terms of the Mozilla Public
//  License, v. 2.0. If a copy of the MPL was not distributed with this
//  file, You can obtain one at https://mozilla.org/MPL/2.0/.
//  -------------------------------------------------------------------------
 
#ifndef RAMSES_SCENE_H
#define RAMSES_SCENE_H
 
#include "ramses-client-api/ClientObject.h"
#include "ramses-client-api/TextureEnums.h"
#include "ramses-client-api/AnimationSystemEnums.h"
#include "ramses-client-api/EScenePublicationMode.h"
#include "ramses-client-api/EDataType.h"
#include "ramses-client-api/MipLevelData.h"
#include "ramses-client-api/TextureSwizzle.h"
 
#include "ramses-framework-api/RamsesFrameworkTypes.h"
 
#include <string>
 
namespace ramses
{
    class Node;
    class MeshNode;
    class PerspectiveCamera;
    class OrthographicCamera;
    class Appearance;
    class Effect;
    class GeometryBinding;
    class SceneImpl;
    class RamsesClientImpl;
    class AnimationSystem;
    class AnimationSystemRealTime;
    class RenderGroup;
    class RenderPass;
    class RenderBuffer;
    class BlitPass;
    class PickableObject;
    class RenderTarget;
    class RenderTargetDescription;
    class TextureSampler;
    class TextureSamplerMS;
    class TextureSamplerExternal;
    class AttributeInput;
    class DataObject;
    class DataFloat;
    class DataVector2f;
    class DataVector3f;
    class DataVector4f;
    class DataMatrix22f;
    class DataMatrix33f;
    class DataMatrix44f;
    class DataInt32;
    class DataVector2i;
    class DataVector3i;
    class DataVector4i;
    class StreamTexture;
    class Texture2D;
    class Texture3D;
    class TextureCube;
    class ArrayBuffer;
    class Texture2DBuffer;
    class SceneReference;
    class SceneObject;
    class RamsesClient;
    class ArrayResource;
    class EffectDescription;
    class Texture2D;
    class Texture3D;
    class TextureCube;
    class Effect;
    class Resource;
 
    class RAMSES_API Scene : public ClientObject
    {
    public:
        status_t publish(EScenePublicationMode publicationMode = EScenePublicationMode_LocalAndRemote);
 
        status_t unpublish();
 
        bool isPublished() const;
 
        sceneId_t getSceneId() const;
 
        status_t saveToFile(const char* fileName, bool compress) const;
 
        PerspectiveCamera* createPerspectiveCamera(const char* name = nullptr);
 
        OrthographicCamera* createOrthographicCamera(const char* name = nullptr);
 
        Appearance* createAppearance(const Effect& effect, const char* name = nullptr);
 
        GeometryBinding* createGeometryBinding(const Effect& effect, const char* name = nullptr);
 
        StreamTexture* createStreamTexture(const Texture2D& fallbackTexture, waylandIviSurfaceId_t source, const char* name = nullptr);
 
        Node* createNode(const char* name = nullptr);
 
        MeshNode* createMeshNode(const char* name = nullptr);
 
        status_t destroy(SceneObject& object);
 
        status_t setExpirationTimestamp(uint64_t ptpExpirationTimestampInMilliseconds);
 
        status_t flush(sceneVersionTag_t sceneVersionTag = InvalidSceneVersionTag);
 
        status_t resetUniformTimeMs();
 
        int32_t getUniformTimeMs() const;
 
        const RamsesObject* findObjectByName(const char* name) const;
 
        RamsesObject* findObjectByName(const char* name);
 
        const SceneObject* findObjectById(sceneObjectId_t id) const;
 
        SceneObject* findObjectById(sceneObjectId_t id);
 
        SceneImpl& impl;
 
        RenderGroup* createRenderGroup(const char* name = nullptr);
 
        RenderPass* createRenderPass(const char* name = nullptr);
 
        BlitPass* createBlitPass(const RenderBuffer& sourceRenderBuffer, const RenderBuffer& destinationRenderBuffer, const char* name = nullptr);
 
        RenderBuffer* createRenderBuffer(uint32_t width, uint32_t height, ERenderBufferType bufferType, ERenderBufferFormat bufferFormat, ERenderBufferAccessMode accessMode, uint32_t sampleCount = 0u, const char* name = nullptr);
 
        PickableObject* createPickableObject(const ArrayBuffer& geometryBuffer, const pickableObjectId_t id, const char* name = nullptr);
 
        RenderTarget* createRenderTarget(const RenderTargetDescription& rtDesc, const char* name = nullptr);
 
        TextureSampler* createTextureSampler(
            ETextureAddressMode wrapUMode,
            ETextureAddressMode wrapVMode,
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const Texture2D& texture,
            uint32_t anisotropyLevel = 1,
            const char* name = nullptr);
 
        TextureSampler* createTextureSampler(
            ETextureAddressMode wrapUMode,
            ETextureAddressMode wrapVMode,
            ETextureAddressMode wrapRMode,
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const Texture3D& texture,
            const char* name = nullptr);
 
        TextureSampler* createTextureSampler(
            ETextureAddressMode wrapUMode,
            ETextureAddressMode wrapVMode,
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const TextureCube& texture,
            uint32_t anisotropyLevel = 1,
            const char* name = nullptr);
 
        TextureSampler* createTextureSampler(
            ETextureAddressMode wrapUMode,
            ETextureAddressMode wrapVMode,
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const RenderBuffer& renderBuffer,
            uint32_t anisotropyLevel = 1,
            const char* name = nullptr);
 
        TextureSampler* createTextureSampler(
            ETextureAddressMode wrapUMode,
            ETextureAddressMode wrapVMode,
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const Texture2DBuffer& texture2DBuffer,
            uint32_t anisotropyLevel = 1,
            const char* name = nullptr);
 
        TextureSampler* createTextureSampler(
            ETextureAddressMode wrapUMode,
            ETextureAddressMode wrapVMode,
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const StreamTexture& streamTexture,
            const char* name = nullptr);
 
        TextureSamplerMS* createTextureSamplerMS(const RenderBuffer& renderBuffer, const char* name);
 
        TextureSamplerExternal* createTextureSamplerExternal(
            ETextureSamplingMethod minSamplingMethod,
            ETextureSamplingMethod magSamplingMethod,
            const char* name = nullptr);
 
        ArrayResource* createArrayResource(
            EDataType type,
            uint32_t numElements,
            const void* arrayData,
            resourceCacheFlag_t cacheFlag = ResourceCacheFlag_DoNotCache,
            const char* name = nullptr);
 
        Texture2D* createTexture2D(
            ETextureFormat format,
            uint32_t width,
            uint32_t height,
            uint32_t mipMapCount,
            const MipLevelData mipLevelData[],
            bool generateMipChain = false,
            const TextureSwizzle& swizzle = {},
            resourceCacheFlag_t cacheFlag = ResourceCacheFlag_DoNotCache,
            const char* name = nullptr);
 
        Texture3D* createTexture3D(
            ETextureFormat format,
            uint32_t width,
            uint32_t height,
            uint32_t depth,
            uint32_t mipMapCount,
            const MipLevelData mipLevelData[],
            bool generateMipChain = false,
            resourceCacheFlag_t cacheFlag = ResourceCacheFlag_DoNotCache,
            const char* name = nullptr);
 
        TextureCube* createTextureCube(
            ETextureFormat format,
            uint32_t size,
            uint32_t mipMapCount,
            const CubeMipLevelData mipLevelData[],
            bool generateMipChain = false,
            const TextureSwizzle& swizzle = {},
            resourceCacheFlag_t cacheFlag = ResourceCacheFlag_DoNotCache,
            const char* name = nullptr);
 
        Effect* createEffect(const EffectDescription& effectDesc, resourceCacheFlag_t cacheFlag = ResourceCacheFlag_DoNotCache, const char* name = nullptr);
 
        std::string getLastEffectErrorMessages() const;
 
        ArrayBuffer* createArrayBuffer(EDataType dataType, uint32_t maxNumElements, const char* name = nullptr);
 
        Texture2DBuffer* createTexture2DBuffer(ETextureFormat textureFormat, uint32_t width, uint32_t height, uint32_t mipLevelCount, const char* name = nullptr);
 
        DataFloat* createDataFloat(const char* name = nullptr);
 
        DataVector2f* createDataVector2f(const char* name = nullptr);
 
        DataVector3f* createDataVector3f(const char* name = nullptr);
 
        DataVector4f* createDataVector4f(const char* name = nullptr);
 
        DataMatrix22f* createDataMatrix22f(const char* name = nullptr);
 
        DataMatrix33f* createDataMatrix33f(const char* name = nullptr);
 
        DataMatrix44f* createDataMatrix44f(const char* name = nullptr);
 
        DataInt32* createDataInt32(const char* name = nullptr);
 
        DataVector2i* createDataVector2i(const char* name = nullptr);
 
        DataVector3i* createDataVector3i(const char* name = nullptr);
 
        DataVector4i* createDataVector4i(const char* name = nullptr);
 
        status_t createTransformationDataProvider(const Node& node, dataProviderId_t dataId);
 
        status_t createTransformationDataConsumer(const Node& node, dataConsumerId_t dataId);
 
        status_t createDataProvider(const DataObject& dataObject, dataProviderId_t dataId);
 
        status_t createDataConsumer(const DataObject& dataObject, dataConsumerId_t dataId);
 
        status_t createTextureProvider(const Texture2D& texture, dataProviderId_t dataId);
 
        status_t updateTextureProvider(const Texture2D& texture, dataProviderId_t dataId);
 
        status_t createTextureConsumer(const TextureSampler& sampler, dataConsumerId_t dataId);
 
        status_t createTextureConsumer(const TextureSamplerMS& sampler, dataConsumerId_t dataId);
 
        status_t createTextureConsumer(const TextureSamplerExternal& sampler, dataConsumerId_t dataId);
 
        AnimationSystem* createAnimationSystem(uint32_t flags = EAnimationSystemFlags_Default, const char* name = nullptr);
 
        AnimationSystemRealTime* createRealTimeAnimationSystem(uint32_t flags = EAnimationSystemFlags_Default, const char* name = nullptr);
 
        SceneReference* createSceneReference(sceneId_t referencedScene, const char* name = nullptr);
 
        status_t linkData(SceneReference* providerReference, dataProviderId_t providerId, SceneReference* consumerReference, dataConsumerId_t consumerId);
 
        status_t unlinkData(SceneReference* consumerReference, dataConsumerId_t consumerId);
 
        RamsesClient& getRamsesClient();
 
        const Resource* getResource(resourceId_t id) const;
 
        Resource* getResource(resourceId_t id);
 
    protected:
        friend class RamsesClientImpl;
 
        explicit Scene(SceneImpl& pimpl);
 
        Scene(const Scene& other);
 
        Scene& operator=(const Scene& other);
 
        virtual ~Scene();
    };
}
 
#endif