}
/**
+ * Erase an object from OwnerKeyContainer
+ * @param[in] object to remove
+ */
+ inline void EraseKey(MemoryPoolKey<ObjectType> key)
+ {
+ DALI_ASSERT_DEBUG(key && "NULL object not allowed");
+
+ Iterator iter = BaseType::Begin();
+ const ConstIterator endIter = BaseType::End();
+ for(; iter != endIter; ++iter)
+ {
+ if(*iter == key)
+ {
+ Erase(iter);
+ return;
+ }
+ }
+ }
+
+ /**
* Release the ownership of an object, without deleting it.
* @param[in] position A dereferencable iterator to an element in mContainer.
* @post iterators are invalidated by this method.
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
int orientation)
{
RenderMode::Type renderMode = RenderMode::AUTO;
- const Renderer* renderer = item.mRenderer;
+ RendererKey renderer = item.mRenderer;
if(renderer)
{
renderMode = renderer->GetRenderMode();
: mModelMatrix(false),
mModelViewMatrix(false),
mSize(),
- mRenderer(nullptr),
+ mRenderer{},
mNode(nullptr),
mTextureSet(nullptr),
mDepthIndex(0),
*/
void operator delete(void* ptr);
- Matrix mModelMatrix;
- Matrix mModelViewMatrix;
- Vector3 mSize;
- Vector4 mUpdateArea; ///< Update area hint is provided for damaged area calculation. (x, y, width, height)
- Render::Renderer* mRenderer;
- Node* mNode;
- const void* mTextureSet; ///< Used for sorting only
- int mDepthIndex;
- bool mIsOpaque : 1;
- bool mIsUpdated : 1;
+ Matrix mModelMatrix;
+ Matrix mModelViewMatrix;
+ Vector3 mSize;
+ Vector4 mUpdateArea; ///< Update area hint is provided for damaged area calculation. (x, y, width, height)
+ Render::RendererKey mRenderer;
+ Node* mNode;
+ const void* mTextureSet; ///< Used for sorting only
+ int mDepthIndex;
+ bool mIsOpaque : 1;
+ bool mIsUpdated : 1;
/**
* Get the capacity of the global pool.
/**
* Get renderer from an item in the list
*/
- const Render::Renderer& GetRenderer(uint32_t index) const
+ Render::RendererKey GetRenderer(uint32_t index) const
{
DALI_ASSERT_DEBUG(index < GetCachedItemCount());
- return *mItems[index]->mRenderer;
+ return mItems[index]->mRenderer;
}
/**
std::vector<SceneGraph::Scene*> sceneContainer; ///< List of pointers to the scene graph objects of the scenes
Render::RenderAlgorithms renderAlgorithms; ///< The RenderAlgorithms object is used to action the renders required by a RenderInstruction
- OwnerContainer<Render::Renderer*> rendererContainer; ///< List of owned renderers
OwnerContainer<Render::Sampler*> samplerContainer; ///< List of owned samplers
OwnerContainer<Render::FrameBuffer*> frameBufferContainer; ///< List of owned framebuffers
OwnerContainer<Render::VertexBuffer*> vertexBufferContainer; ///< List of owned vertex buffers
OwnerContainer<Render::Geometry*> geometryContainer; ///< List of owned Geometries
OwnerContainer<Render::RenderTracker*> mRenderTrackers; ///< List of render trackers
+ OwnerKeyContainer<Render::Renderer> rendererContainer; ///< List of owned renderers
OwnerKeyContainer<Render::Texture> textureContainer; ///< List of owned textures
ProgramController programController; ///< Owner of the programs
{
}
-void RenderManager::AddRenderer(OwnerPointer<Render::Renderer>& renderer)
+void RenderManager::AddRenderer(const Render::RendererKey& renderer)
{
// Initialize the renderer as we are now in render thread
renderer->Initialize(mImpl->graphicsController, mImpl->programController, mImpl->shaderCache, *(mImpl->uniformBufferManager.get()), *(mImpl->pipelineCache.get()));
- mImpl->rendererContainer.PushBack(renderer.Release());
+ mImpl->rendererContainer.PushBack(renderer);
}
-void RenderManager::RemoveRenderer(Render::Renderer* renderer)
+void RenderManager::RemoveRenderer(const Render::RendererKey& renderer)
{
- mImpl->rendererContainer.EraseObject(renderer);
+ mImpl->rendererContainer.EraseKey(renderer);
}
void RenderManager::AddSampler(OwnerPointer<Render::Sampler>& sampler)
#include <dali/integration-api/core-enumerations.h>
#include <dali/internal/common/shader-saver.h>
#include <dali/internal/event/rendering/texture-impl.h>
+#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/render/renderers/render-vertex-buffer.h>
#include <dali/public-api/math/rect.h>
/**
* Add a Renderer to the render manager.
* @param[in] renderer The renderer to add.
- * @post renderer is owned by RenderManager
+ * @post renderer is notionally owned by RenderManager
*/
- void AddRenderer(OwnerPointer<Render::Renderer>& renderer);
+ void AddRenderer(const Render::RendererKey& renderer);
/**
* Remove a Renderer from the render manager.
* @param[in] renderer The renderer to remove.
* @post renderer is destroyed.
*/
- void RemoveRenderer(Render::Renderer* renderer);
+ void RemoveRenderer(const Render::RendererKey& renderer);
/**
* Add a sampler to the render manager.
#include <dali/integration-api/debug.h>
#include <dali/internal/common/image-sampler.h>
#include <dali/internal/common/matrix-utils.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/rendering/texture-impl.h>
#include <dali/internal/render/common/render-instruction.h>
#include <dali/internal/render/data-providers/node-data-provider.h>
namespace Render
{
-Renderer* Renderer::New(SceneGraph::RenderDataProvider* dataProvider,
- Render::Geometry* geometry,
- uint32_t blendingBitmask,
- const Vector4& blendColor,
- FaceCullingMode::Type faceCullingMode,
- bool preMultipliedAlphaEnabled,
- DepthWriteMode::Type depthWriteMode,
- DepthTestMode::Type depthTestMode,
- DepthFunction::Type depthFunction,
- StencilParameters& stencilParameters)
+namespace
+{
+MemoryPoolObjectAllocator<Renderer> gRenderRendererMemoryPool;
+}
+
+RendererKey Renderer::NewKey(SceneGraph::RenderDataProvider* dataProvider,
+ Render::Geometry* geometry,
+ uint32_t blendingBitmask,
+ const Vector4& blendColor,
+ FaceCullingMode::Type faceCullingMode,
+ bool preMultipliedAlphaEnabled,
+ DepthWriteMode::Type depthWriteMode,
+ DepthTestMode::Type depthTestMode,
+ DepthFunction::Type depthFunction,
+ StencilParameters& stencilParameters)
{
- return new Renderer(dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, depthFunction, stencilParameters);
+ void* ptr = gRenderRendererMemoryPool.AllocateRawThreadSafe();
+ auto key = gRenderRendererMemoryPool.GetKeyFromPtr(static_cast<Renderer*>(ptr));
+
+ // Use placement new to construct renderer.
+ new(ptr) Renderer(dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, depthFunction, stencilParameters);
+ return RendererKey(key);
}
Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider,
Renderer::~Renderer() = default;
+void Renderer::operator delete(void* ptr)
+{
+ gRenderRendererMemoryPool.FreeThreadSafe(static_cast<Renderer*>(ptr));
+}
+
+Renderer* Renderer::Get(RendererKey::KeyType rendererKey)
+{
+ return gRenderRendererMemoryPool.GetPtrFromKey(rendererKey);
+}
+
void Renderer::SetGeometry(Render::Geometry* geometry)
{
mGeometry = geometry;
}
+
void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)
{
mDrawCommands.clear();
#define DALI_INTERNAL_RENDER_RENDERER_H
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
class PipelineCache;
class UniformBufferManager;
class PipelineCache;
+class Renderer;
+using RendererKey = MemoryPoolKey<Render::Renderer>;
+} //namespace Render
+} //namespace Internal
+
+// Ensure RendererKey can be used in Dali::Vector
+template<>
+struct TypeTraits<Internal::Render::RendererKey> : public BasicTypes<Internal::Render::RendererKey>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
+
+namespace Internal
+{
+namespace Render
+{
/**
* Renderers are used to render meshes
* These objects are used during RenderManager::Render(), so properties modified during
* @param[in] depthFunction Depth function
* @param[in] stencilParameters Struct containing all stencil related options
*/
- static Renderer* New(SceneGraph::RenderDataProvider* dataProviders,
- Render::Geometry* geometry,
- uint32_t blendingBitmask,
- const Vector4& blendColor,
- FaceCullingMode::Type faceCullingMode,
- bool preMultipliedAlphaEnabled,
- DepthWriteMode::Type depthWriteMode,
- DepthTestMode::Type depthTestMode,
- DepthFunction::Type depthFunction,
- StencilParameters& stencilParameters);
+ static RendererKey NewKey(SceneGraph::RenderDataProvider* dataProviders,
+ Render::Geometry* geometry,
+ uint32_t blendingBitmask,
+ const Vector4& blendColor,
+ FaceCullingMode::Type faceCullingMode,
+ bool preMultipliedAlphaEnabled,
+ DepthWriteMode::Type depthWriteMode,
+ DepthTestMode::Type depthTestMode,
+ DepthFunction::Type depthFunction,
+ StencilParameters& stencilParameters);
/**
* Constructor.
StencilParameters& stencilParameters);
/**
- * Change the geometry used by the renderer
- * @param[in] geometry The new geometry
- */
- void SetGeometry(Render::Geometry* geometry);
-
- void SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size);
-
- /**
- * @brief Returns a reference to an array of draw commands
- * @return Valid array of draw commands (may be empty)
- */
- [[nodiscard]] const std::vector<Dali::DevelRenderer::DrawCommand>& GetDrawCommands() const
- {
- return mDrawCommands;
- }
-
- /**
* Second-phase construction.
* This is called when the renderer is inside render thread
* @param[in] graphicsController The graphics controller to use
~Renderer();
/**
+ * Overriden delete operator
+ * Deletes the renderer from its global memory pool
+ */
+ void operator delete(void* ptr);
+
+ /**
+ * Get a pointer to the object from the given key.
+ * Used by MemoryPoolKey to provide pointer semantics.
+ */
+ static Renderer* Get(RendererKey::KeyType rendererKey);
+
+ /**
+ * Change the geometry used by the renderer
+ * @param[in] geometry The new geometry
+ */
+ void SetGeometry(Render::Geometry* geometry);
+
+ void SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size);
+
+ /**
+ * @brief Returns a reference to an array of draw commands
+ * @return Valid array of draw commands (may be empty)
+ */
+ [[nodiscard]] const std::vector<Dali::DevelRenderer::DrawCommand>& GetDrawCommands() const
+ {
+ return mDrawCommands;
+ }
+
+ /**
* Set the face-culling mode.
* @param[in] mode The face-culling mode.
*/
#define DALI_INTERNAL_SCENE_GRAPH_SCENE_H
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/common/message.h>
#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/render/common/render-instruction-container.h>
+#include <dali/internal/render/renderers/render-renderer.h> // RendererKey
#include <dali/internal/update/nodes/scene-graph-layer.h>
#include <dali/public-api/common/vector-wrapper.h>
{
namespace Internal
{
-namespace Render
-{
-class Renderer;
-}
-
namespace SceneGraph
{
class RenderInstructionContainer;
struct DirtyRect
{
- DirtyRect(Node* node, Render::Renderer* renderer, Rect<int>& rect)
+ DirtyRect(Node* node, Render::RendererKey renderer, Rect<int>& rect)
: node(node),
renderer(renderer),
rect(rect),
{
if(node == rhs.node)
{
- return renderer < rhs.renderer;
+ return renderer.Value() < rhs.renderer.Value();
}
else
{
}
}
- Node* node{nullptr};
- Render::Renderer* renderer{nullptr};
- Rect<int32_t> rect{};
- bool visited{true};
+ Node* node{nullptr};
+ Render::RendererKey renderer{};
+ Rect<int32_t> rect{};
+ bool visited{true};
};
class Scene
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
RenderMessageDispatcher::~RenderMessageDispatcher() = default;
-void RenderMessageDispatcher::AddRenderer(OwnerPointer<Render::Renderer>& renderer)
+void RenderMessageDispatcher::AddRenderer(const Render::RendererKey& renderer)
{
// Message has ownership of renderer while in transit from update -> render
- typedef MessageValue1<RenderManager, OwnerPointer<Render::Renderer> > DerivedType;
+ typedef MessageValue1<RenderManager, Render::RendererKey> DerivedType;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot(mBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
new(slot) DerivedType(&mRenderManager, &RenderManager::AddRenderer, renderer);
}
-void RenderMessageDispatcher::RemoveRenderer(Render::Renderer& renderer)
+void RenderMessageDispatcher::RemoveRenderer(const Render::RendererKey& renderer)
{
- using DerivedType = MessageValue1<RenderManager, Render::Renderer*>;
+ using DerivedType = MessageValue1<RenderManager, Render::RendererKey>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot(mBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
// Construct message in the render queue memory; note that delete should not be called on the return value
- new(slot) DerivedType(&mRenderManager, &RenderManager::RemoveRenderer, &renderer);
+ new(slot) DerivedType(&mRenderManager, &RenderManager::RemoveRenderer, renderer);
}
void RenderMessageDispatcher::AddRenderTracker(Render::RenderTracker& renderTracker)
#define DALI_INTERNAL_SCENE_GRAPH_RENDER_MESSAGE_DISPATCHER_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] renderer The renderer to add.
* @post renderer ownership is transferred.
*/
- void AddRenderer(OwnerPointer<Render::Renderer>& renderer);
+ void AddRenderer(const Render::RendererKey& renderer);
/**
* Remove a Renderer.
* @param[in] renderer The renderer to remove.
* @post renderer will be destroyed in the next Render.
*/
- void RemoveRenderer(Render::Renderer& renderer);
+ void RemoveRenderer(const Render::RendererKey& renderer);
/**
* Add a Render tracker.
if(DALI_LIKELY(renderable.mRenderer))
{
- item.mRenderer = &renderable.mRenderer->GetRenderer();
+ item.mRenderer = renderable.mRenderer->GetRenderer();
item.mTextureSet = renderable.mRenderer->GetTextureSet();
item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
}
else
{
- item.mRenderer = nullptr;
+ item.mRenderer = Render::RendererKey{};
}
item.mIsUpdated |= isLayer3d;
//@todo just use keys, don't deref.
for(uint32_t index = 0; index < renderableCount; ++index)
{
- if(DALI_LIKELY(renderables[index].mRenderer != nullptr))
+ if(DALI_LIKELY(renderables[index].mRenderer))
{
- const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
- checkSumNew += reinterpret_cast<std::size_t>(&renderer);
+ Render::RendererKey renderer = renderables[index].mRenderer->GetRenderer();
+ checkSumNew += renderer.Value();
}
if(DALI_LIKELY(renderList.GetItem(index).mRenderer))
{
- checkSumOld += reinterpret_cast<std::size_t>(&renderList.GetRenderer(index));
+ checkSumOld += renderList.GetItem(index).mRenderer.Value();
}
}
if(checkSumNew == checkSumOld)
for(uint32_t index = 0; index < renderableCount; ++index, ++renderListIter)
{
*renderListIter = mSortingHelper[index].renderItem;
- DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, mSortingHelper[index].renderItem->mRenderer);
+ DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %x\n", index, mSortingHelper[index].renderItem->mRenderer);
}
}
} // Anonymous namespace
-Renderer* Renderer::New()
-{
- return new(gRendererMemoryPool.AllocateRawThreadSafe()) Renderer();
-}
-
RendererKey Renderer::NewKey()
{
void* ptr = gRendererMemoryPool.AllocateRawThreadSafe();
Renderer::Renderer()
: mSceneController(nullptr),
- mRenderer(nullptr),
+ mRenderer{},
mTextureSet(nullptr),
mGeometry(nullptr),
mShader(nullptr),
if(mResendFlag != 0)
{
+ Render::Renderer* rendererPtr = mRenderer.Get();
if(mResendFlag & RESEND_GEOMETRY)
{
typedef MessageValue1<Render::Renderer, Render::Geometry*> DerivedType;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetGeometry, mGeometry);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetGeometry, mGeometry);
}
if(mResendFlag & RESEND_DRAW_COMMANDS)
{
using DerivedType = MessageValue2<Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetDrawCommands, mDrawCommands.data(), mDrawCommands.size());
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDrawCommands, mDrawCommands.data(), mDrawCommands.size());
}
if(mResendFlag & RESEND_FACE_CULLING_MODE)
{
using DerivedType = MessageValue1<Render::Renderer, FaceCullingMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode);
}
if(mResendFlag & RESEND_BLEND_BIT_MASK)
{
using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetBlendingBitMask, mBlendBitmask);
}
if(mResendFlag & RESEND_BLEND_COLOR)
{
using DerivedType = MessageValue1<Render::Renderer, Vector4>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor());
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetBlendColor, GetBlendColor());
}
if(mResendFlag & RESEND_PREMULTIPLIED_ALPHA)
{
using DerivedType = MessageValue1<Render::Renderer, bool>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled);
}
if(mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT)
{
using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement);
}
if(mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT)
{
using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount);
}
if(mResendFlag & RESEND_DEPTH_WRITE_MODE)
{
using DerivedType = MessageValue1<Render::Renderer, DepthWriteMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode);
}
if(mResendFlag & RESEND_DEPTH_TEST_MODE)
{
using DerivedType = MessageValue1<Render::Renderer, DepthTestMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDepthTestMode, mDepthTestMode);
}
if(mResendFlag & RESEND_DEPTH_FUNCTION)
{
using DerivedType = MessageValue1<Render::Renderer, DepthFunction::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetDepthFunction, mDepthFunction);
}
if(mResendFlag & RESEND_RENDER_MODE)
{
using DerivedType = MessageValue1<Render::Renderer, RenderMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode);
}
if(mResendFlag & RESEND_STENCIL_FUNCTION)
{
using DerivedType = MessageValue1<Render::Renderer, StencilFunction::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction);
}
if(mResendFlag & RESEND_STENCIL_FUNCTION_MASK)
{
using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask);
}
if(mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE)
{
using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference);
}
if(mResendFlag & RESEND_STENCIL_MASK)
{
using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask);
}
if(mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL)
{
using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail);
}
if(mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL)
{
using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail);
}
if(mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS)
{
using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass);
}
if(mResendFlag & RESEND_SHADER)
{
using DerivedType = MessageValue1<Render::Renderer, bool>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetShaderChanged, true);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetShaderChanged, true);
}
if(mResendFlag & RESEND_SET_RENDER_CALLBACK)
{
using DerivedType = MessageValue1<Render::Renderer, Dali::RenderCallback*>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
- new(slot) DerivedType(mRenderer, &Render::Renderer::SetRenderCallback, mRenderCallback);
+ new(slot) DerivedType(rendererPtr, &Render::Renderer::SetRenderCallback, mRenderCallback);
}
SetUpdated(true);
mRegenerateUniformMap = true;
mSceneController = &sceneController;
- mRenderer = Render::Renderer::New(this, mGeometry, mBlendBitmask, GetBlendColor(), static_cast<FaceCullingMode::Type>(mFaceCullingMode), mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters);
+ mRenderer = Render::Renderer::NewKey(this, mGeometry, mBlendBitmask, GetBlendColor(), static_cast<FaceCullingMode::Type>(mFaceCullingMode), mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters);
- OwnerPointer<Render::Renderer> transferOwnership(mRenderer);
- mSceneController->GetRenderMessageDispatcher().AddRenderer(transferOwnership);
+ mSceneController->GetRenderMessageDispatcher().AddRenderer(mRenderer);
}
// Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
// Remove renderer from RenderManager
if(mRenderer)
{
- mSceneController->GetRenderMessageDispatcher().RemoveRenderer(*mRenderer);
- mRenderer = nullptr;
+ mSceneController->GetRenderMessageDispatcher().RemoveRenderer(mRenderer);
+ mRenderer = Render::RendererKey{};
}
mSceneController = nullptr;
}
-Render::Renderer& Renderer::GetRenderer()
+Render::RendererKey Renderer::GetRenderer()
{
- return *mRenderer;
+ return mRenderer;
}
Renderer::OpacityType Renderer::GetOpacityType(BufferIndex updateBufferIndex, const Node& node) const
/**
* Construct a new Renderer
*/
- static Renderer* New();
-
static RendererKey NewKey();
/**
*/
void operator delete(void* ptr);
+ /**
+ * Get a pointer to the object from the given key.
+ * Used by MemoryPoolKey to provide pointer semantics.
+ */
static Renderer* Get(RendererKey::KeyType);
/**
* Retrieve the Render thread renderer
* @return The associated render thread renderer
*/
- Render::Renderer& GetRenderer();
+ Render::RendererKey GetRenderer();
/**
* Query whether the renderer is fully opaque, fully transparent or transparent.
private:
CollectedUniformMap mCollectedUniformMap; ///< Uniform maps collected by the renderer
- SceneController* mSceneController; ///< Used for initializing renderers
- Render::Renderer* mRenderer; ///< Raw pointer to the renderer (that's owned by RenderManager)
- TextureSet* mTextureSet; ///< The texture set this renderer uses. (Not owned)
- Render::Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
- Shader* mShader; ///< The shader this renderer uses. (Not owned)
+ SceneController* mSceneController; ///< Used for initializing renderers
+ Render::RendererKey mRenderer; ///< Key to the renderer (that's owned by RenderManager)
+ TextureSet* mTextureSet; ///< The texture set this renderer uses. (Not owned)
+ Render::Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
+ Shader* mShader; ///< The shader this renderer uses. (Not owned)
OwnerPointer<VisualRenderer::AnimatableVisualProperties> mVisualProperties{nullptr}; ///< VisualProperties (optional/owned)
OwnerPointer<Vector4> mBlendColor; ///< The blend color for blending operation
projects / platform / core / uifw / dali-core.git / commitdiff