mImpl->RenderScene(status, scene, renderToFbo, clippingRect);
}
-void Core::PreCompileShader(const std::string& vertexShader, const std::string& fragmentShader)
-{
- mImpl->PreCompileShader(vertexShader, fragmentShader);
-}
-
void Core::PostRender()
{
mImpl->PostRender();
void RenderScene(RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect);
/**
- * Precompile shaders for launching time
- *
- * @param[in] vertexShader vertexShader need to precompile
- * @param[in] fragmentShader fragmentShader need to precompile
- */
- void PreCompileShader(const std::string& vertexShader, const std::string& fragmentShader);
-
- /**
* This is called after rendering all the scenes in the next frame. This method should be
* followed by a call up RenderScene.
* Multi-threading note: this method should be called from a dedicated rendering thread.
${platform_abstraction_src_dir}/profiling.cpp
${platform_abstraction_src_dir}/render-task-list-integ.cpp
${platform_abstraction_src_dir}/scene.cpp
- ${platform_abstraction_src_dir}/shader-precompiler.cpp
${platform_abstraction_src_dir}/texture-integ.cpp
- ${platform_abstraction_src_dir}/trace.cpp
+ ${platform_abstraction_src_dir}/trace.cpp
)
SET( platform_abstraction_events_src_files
${platform_abstraction_src_dir}/resource-policies.h
${platform_abstraction_src_dir}/resource-types.h
${platform_abstraction_src_dir}/scene.h
- ${platform_abstraction_src_dir}/shader-precompiler.h
${platform_abstraction_src_dir}/texture-integ.h
${platform_abstraction_src_dir}/trace.h
)
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// CLASS HEADER
-#include <dali/integration-api/shader-precompiler.h>
-
-// INTERNAL HEADER
-#include <dali/integration-api/debug.h>
-
-namespace Dali
-{
-
-namespace Integration
-{
-
-std::unique_ptr<ShaderPrecompiler> ShaderPrecompiler::mInstance = nullptr;
-std::once_flag ShaderPrecompiler::mOnceFlag;
-
-ShaderPrecompiler::ShaderPrecompiler()
-: mRawShaderData(),
- mPrecompiled(false),
- mEnabled(false)
-{
-}
-
-ShaderPrecompiler& ShaderPrecompiler::Get()
-{
- std::call_once(mOnceFlag, []()
- { mInstance.reset(new ShaderPrecompiler); });
-
- return *(mInstance.get());
-}
-
-void ShaderPrecompiler::GetPrecompileShaderList(RawShaderData& shaders)
-{
- ConditionalWait::ScopedLock lock(mConditionalWait);
- if(!IsReady())
- {
- DALI_LOG_RELEASE_INFO("Precompiled shader list is not ready yet, need to wait \n");
- mConditionalWait.Wait(lock);
- }
-
- // move shader list
- shaders = mRawShaderData;
-}
-
-void ShaderPrecompiler::SavePrecomipleShaderList(RawShaderData& shaders)
-{
- ConditionalWait::ScopedLock lock(mConditionalWait);
- mRawShaderData.vertexPrefix = shaders.vertexPrefix;
- mRawShaderData.fragmentPrefix = shaders.fragmentPrefix;
- mRawShaderData.vertexShader = shaders.vertexShader;
- mRawShaderData.fragmentShader = shaders.fragmentShader;
- mRawShaderData.shaderCount = shaders.shaderCount;
-
- mPrecompiled = true;
- mConditionalWait.Notify(lock);
-}
-
-bool ShaderPrecompiler::IsReady() const
-{
- return mPrecompiled;
-}
-
-void ShaderPrecompiler::Enable()
-{
- mEnabled = true;
-}
-
-bool ShaderPrecompiler::IsEnable()
-{
- return mEnabled;
-}
-
-
-} // namespace Integration
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTEGRATION_SHADER_PRECOMPILER_H
-#define DALI_INTEGRATION_SHADER_PRECOMPILER_H
-
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// INTERNAL HEADER
-#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/object/base-handle.h>
-#include <dali/devel-api/threading/conditional-wait.h>
-#include <dali/devel-api/threading/mutex.h>
-
-// EXTERNAL HEDAER
-#include <string_view>
-#include <memory>
-#include <mutex>
-
-namespace Dali
-{
-namespace Internal DALI_INTERNAL
-{
-class ShaderPrecompiler;
-}
-
-struct RawShaderData
-{
- int shaderCount;
- std::vector<std::string_view> vertexPrefix;
- std::vector<std::string_view> fragmentPrefix;
- std::string_view vertexShader;
- std::string_view fragmentShader;
-};
-
-namespace Integration
-{
-/**
- * ShaderPrecompiler is used to precompile shaders.
- * The precompiled shaders are stored in a file.
- * @SINCE_2_2.45
- */
-class DALI_CORE_API ShaderPrecompiler : public BaseHandle
-{
-public:
- /**
- * @brief Gets the singleton of ShaderPrecompiler object.
- *
- * @SINCE_2_2.45
- * @return A handle to the ShaderPrecompiler
- */
- static ShaderPrecompiler& Get();
-
- /**
- * @brief Get the precompile shader list.
- *
- * @SINCE_2_2.45
- * @param[in] shaders shader data for precompile
- */
- void GetPrecompileShaderList(RawShaderData& shaders);
-
- /**
- * @brief Save the precompile shader list.
- *
- * @SINCE_2_2.45
- * @param[in] shaders shader data for precompile
- */
- void SavePrecomipleShaderList(RawShaderData& shaders);
-
- /**
- * @brief Check precompile list is ready or not
- *
- * @SINCE_2_2.45
- * @return true if precompile list is ready
- */
- bool IsReady() const;
-
- /**
- * @brief Enable the feature of precompile
- *
- * @SINCE_2_2.45
- */
- void Enable();
-
- /**
- * @brief Check the feature of precompile is enabled or not
- *
- * @SINCE_2_2.45
- * @return true if the feature of precompile is enabled
- */
- bool IsEnable();
-
- /**
- * Construct a new ShaderPrecompiler.
- */
- ShaderPrecompiler();
-
- // Undefined
- ShaderPrecompiler(const ShaderPrecompiler&) = delete;
-
- // Undefined
- ShaderPrecompiler& operator=(const ShaderPrecompiler& rhs) = delete;
-
-private:
- static std::unique_ptr<ShaderPrecompiler> mInstance;
- static std::once_flag mOnceFlag;
- RawShaderData mRawShaderData;
- ConditionalWait mConditionalWait;
- bool mPrecompiled;
- bool mEnabled;
-};
-
-} // namespace Integration
-
-} // namespace Dali
-
-#endif // DALI_INTEGRATION_SHADER_PRECOMPILER_H
mRenderManager->RenderScene(status, scene, renderToFbo, clippingRect);
}
-void Core::PreCompileShader(const std::string& vertexShader, const std::string& fragmentShader)
-{
- mRenderManager->PreCompileShader(vertexShader, fragmentShader);
-}
-
void Core::PostRender()
{
mUpdateManager->PostRender();
void RenderScene(Integration::RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect);
/**
- * @copydoc Dali::Integration::Core::PreCompileShader()
- */
- void PreCompileShader(const std::string& vertexShader, const std::string& fragmentShader);
-
- /**
* @copydoc Dali::Integration::Core::Render()
*/
void PostRender();
}
}
-void RenderManager::PreCompileShader(const std::string& vertexShader, const std::string& fragmentShader)
-{
- uint32_t renderPassTag{0u};
- Dali::Shader::Hint::Value hints = Dali::Shader::Hint::NONE;
- auto shaderHash = CalculateHash(vertexShader.data(), fragmentShader.data());
- auto shaderData = new ShaderData(std::string(vertexShader.data()), std::string(fragmentShader.data()), hints, renderPassTag);
- shaderData->SetHashValue(shaderHash);
- auto program = Program::New(mImpl->programController, shaderData, mImpl->graphicsController);
- if(!program)
- {
- DALI_LOG_RELEASE_INFO("Fail to create program \n");
- }
- else
- {
- // If program doesn't have Gfx program object assigned yet, prepare it.
- if(!program->GetGraphicsProgramPtr())
- {
- const std::vector<char>& vertShader = shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::VERTEX_SHADER);
- const std::vector<char>& fragShader = shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER);
- Dali::Graphics::Shader& vertexShader = mImpl->shaderCache.GetShader(
- vertShader,
- Graphics::PipelineStage::VERTEX_SHADER,
- shaderData->GetSourceMode());
-
- Dali::Graphics::Shader& fragmentShader = mImpl->shaderCache.GetShader(
- fragShader,
- Graphics::PipelineStage::FRAGMENT_SHADER,
- shaderData->GetSourceMode());
-
- std::vector<Graphics::ShaderState> shaderStates{
- Graphics::ShaderState()
- .SetShader(vertexShader)
- .SetPipelineStage(Graphics::PipelineStage::VERTEX_SHADER),
- Graphics::ShaderState()
- .SetShader(fragmentShader)
- .SetPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER)};
-
- auto createInfo = Graphics::ProgramCreateInfo();
- createInfo.SetShaderState(shaderStates);
- auto graphicsProgram = mImpl->graphicsController.CreateProgram(createInfo, nullptr);
- program->SetGraphicsProgram(std::move(graphicsProgram), *(mImpl->uniformBufferManager.get())); // generates reflection
- }
- }
-}
-
void RenderManager::PostRender()
{
if(!mImpl->commandBufferSubmitted)
*/
void RenderScene(Integration::RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect);
- /**
- * Precompile shaders for launching time
- *
- * @param[in] vertexShader vertexShader need to precompile
- * @param[in] fragmentShader fragmentShader need to precompile
- */
- void PreCompileShader(const std::string& vertexShader, const std::string& fragmentShader);
-
// This method should be called from Core::PostRender()
/**
projects / platform / core / uifw / dali-core.git / commitdiff