/*
- * 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/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>
return ((dataSize / 256u) + ((dataSize % 256u) ? 1u : 0u)) * 256u;
}
+/**
+ * @brief Store latest bound RenderGeometry, and help that we can skip duplicated vertex attributes bind.
+ *
+ * @param[in] geometry Current geometry to be used, or nullptr if render finished
+ * @return True if we can reuse latest bound vertex attributes. False otherwise.
+ */
+inline bool ReuseLatestBoundVertexAttributes(const Render::Geometry* geometry)
+{
+ static const Render::Geometry* gLatestVertexBoundGeometry = nullptr;
+ if(gLatestVertexBoundGeometry == geometry)
+ {
+ return true;
+ }
+ gLatestVertexBoundGeometry = geometry;
+ return false;
+}
+
} // namespace
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;
+}
+
+void Renderer::PrepareCommandBuffer()
+{
+ // Reset latest geometry informations, So we can bind the first of geometry.
+ ReuseLatestBoundVertexAttributes(nullptr);
+
+ // todo : Fill here as many caches as we can store for reduce the number of command buffers
+}
+
+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();
{
uint32_t textureUnit = 0;
- const Dali::Vector<Render::Texture*>* textures(mRenderDataProvider->GetTextures());
- const Dali::Vector<Render::Sampler*>* samplers(mRenderDataProvider->GetSamplers());
+ auto textures(mRenderDataProvider->GetTextures());
+ auto samplers(mRenderDataProvider->GetSamplers());
std::vector<Graphics::TextureBinding> textureBindings;
// Check if there is render callback
if(mRenderCallback)
{
+ if(!mRenderCallbackInput)
+ {
+ mRenderCallbackInput = std::unique_ptr<RenderCallbackInput>(new RenderCallbackInput);
+ }
+
Graphics::DrawNativeInfo info{};
info.api = Graphics::DrawNativeAPI::GLES;
info.callback = &static_cast<Dali::CallbackBase&>(*mRenderCallback);
- info.userData = &mRenderCallbackInput;
+ info.userData = mRenderCallbackInput.get();
// Set storage for the context to be used
- info.glesNativeInfo.eglSharedContextStoragePointer = &mRenderCallbackInput.eglContext;
+ info.glesNativeInfo.eglSharedContextStoragePointer = &mRenderCallbackInput->eglContext;
info.reserved = nullptr;
auto& textureResources = mRenderCallback->GetTextureResources();
if(!textureResources.empty())
{
mRenderCallbackTextureBindings.clear();
- mRenderCallbackInput.textureBindings.resize(textureResources.size());
+ mRenderCallbackInput->textureBindings.resize(textureResources.size());
auto i = 0u;
for(auto& texture : textureResources)
{
auto& textureImpl = GetImplementation(texture);
- auto graphicsTexture = textureImpl.GetRenderObject()->GetGraphicsObject();
+ auto graphicsTexture = textureImpl.GetRenderTextureKey()->GetGraphicsObject();
auto properties = mGraphicsController->GetTextureProperties(*graphicsTexture);
mRenderCallbackTextureBindings.emplace_back(graphicsTexture);
- mRenderCallbackInput.textureBindings[i++] = properties.nativeHandle;
+ mRenderCallbackInput->textureBindings[i++] = properties.nativeHandle;
}
info.textureCount = mRenderCallbackTextureBindings.size();
info.textureList = mRenderCallbackTextureBindings.data();
}
// pass render callback input
- mRenderCallbackInput.size = size;
- mRenderCallbackInput.projection = projectionMatrix;
+ mRenderCallbackInput->size = size;
+ mRenderCallbackInput->projection = projectionMatrix;
- MatrixUtils::Multiply(mRenderCallbackInput.mvp, modelViewMatrix, projectionMatrix);
+ MatrixUtils::MultiplyProjectionMatrix(mRenderCallbackInput->mvp, modelViewMatrix, projectionMatrix);
// submit draw
commandBuffer.DrawNative(&info);
bool drawn = false; // Draw can fail if there are no vertex buffers or they haven't been uploaded yet
// @todo We should detect this case much earlier to prevent unnecessary work
- if(mDrawCommands.empty())
+ // Reuse latest bound vertex attributes location, or Bind buffers to attribute locations.
+ if(ReuseLatestBoundVertexAttributes(mGeometry) || mGeometry->BindVertexAttributes(commandBuffer))
{
- drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount);
+ if(mDrawCommands.empty())
+ {
+ drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount);
+ }
+ else
+ {
+ for(auto& cmd : commands)
+ {
+ drawn |= mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount);
+ }
+ }
}
else
{
- for(auto& cmd : commands)
- {
- mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount);
- }
+ // BindVertexAttributes failed. Reset cached geometry.
+ ReuseLatestBoundVertexAttributes(nullptr);
}
return drawn;
if(mvpUniformInfo && !mvpUniformInfo->name.empty())
{
Matrix modelViewProjectionMatrix(false);
- MatrixUtils::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix);
+ MatrixUtils::MultiplyProjectionMatrix(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix);
WriteDefaultUniform(mvpUniformInfo, *uboView, modelViewProjectionMatrix);
}
queryInfo.alphaPremultiplied = mPremultipliedAlphaEnabled;
queryInfo.cameraUsingReflection = instruction.GetCamera()->GetReflectionUsed();
+ queryInfo.GenerateHash();
+
+ // Find or generate new pipeline.
auto pipelineResult = mPipelineCache->GetPipeline(queryInfo, true);
// should be never null?
projects / platform / core / uifw / dali-core.git / blobdiff