xref: /ohos5.0/foundation/graphic/graphic_3d/lume/scenewidgetplugin/plugin/src/scene_holder.cpp

/*
 * Copyright (c) 2024 Huawei Device 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.
 */

#include "scene_holder.h"

#include <algorithm>
#include <chrono>
#include <inttypes.h>
#include <scene_plugin/api/material.h>
#include <scene_plugin/interface/intf_scene.h>

#include <3d/ecs/components/environment_component.h>
#include <3d/ecs/components/local_matrix_component.h>
#include <3d/ecs/components/post_process_component.h>
#include <3d/ecs/components/render_configuration_component.h>
#include <3d/ecs/components/render_handle_component.h>
#include <3d/ecs/components/render_mesh_batch_component.h>
#include <3d/ecs/components/transform_component.h>
#include <3d/ecs/components/uri_component.h>
#include <3d/ecs/components/world_matrix_component.h>
#include <3d/ecs/systems/intf_render_preprocessor_system.h>
#include <3d/implementation_uids.h>
#include <3d/render/default_material_constants.h>
#include <3d/util/intf_mesh_builder.h>
#include <3d/util/intf_scene_util.h>
#include <base/util/uid_util.h>
#include <core/ecs/intf_system_graph_loader.h>
#include <core/intf_engine.h>
#include <core/plugin/intf_class_factory.h>
#include <render/device/intf_gpu_resource_manager.h>
#include <render/device/intf_shader_manager.h>
#include <render/intf_render_context.h>
#include <render/intf_renderer.h>
#include <render/util/intf_render_util.h>

#include <meta/api/make_callback.h>
#include <meta/base/shared_ptr.h>
#include <meta/interface/intf_task_queue.h>
#include <meta/interface/intf_task_queue_registry.h>

#include "asset_loader.h"
#include "asset_manager.h"
#include "ecs_util.h"
#include "entity_collection.h"
#include "intf_node_private.h"
#include "task_utils.h"

// Initialize ecs on scene holder initialization or do it lazily when there's a scene to load

using namespace BASE_NS;
using namespace CORE_NS;
using namespace CORE3D_NS;
using namespace RENDER_NS;

using SCENE_NS::MakeTask;

namespace {

bool TickFrame(IEcs& ecs, uint64_t totalTime, uint64_t deltaTime)
{
    // run garbage collection before updating the systems to ensure only valid entities/ components are available.
    ecs.ProcessEvents();

    const bool needRender = ecs.Update(totalTime, deltaTime);

    // do gc also after the systems have been updated to ensure any deletes done by systems are effective
    // and client doesn't see stale entities.
    ecs.ProcessEvents();

    return needRender;
}
constexpr GpuImageDesc GetColorImageDesc(const uint32_t width, const uint32_t height)
{
    GpuImageDesc resolveDesc;
    resolveDesc.width = width;
    resolveDesc.height = height;
    resolveDesc.depth = 1;
    resolveDesc.format = BASE_NS::Format::BASE_FORMAT_R8G8B8A8_SRGB;
    resolveDesc.memoryPropertyFlags = MemoryPropertyFlagBits::CORE_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    resolveDesc.usageFlags =
        ImageUsageFlagBits::CORE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | ImageUsageFlagBits::CORE_IMAGE_USAGE_SAMPLED_BIT;
    resolveDesc.imageType = ImageType::CORE_IMAGE_TYPE_2D;
    resolveDesc.imageTiling = ImageTiling::CORE_IMAGE_TILING_OPTIMAL;
    resolveDesc.imageViewType = ImageViewType::CORE_IMAGE_VIEW_TYPE_2D;
    resolveDesc.engineCreationFlags = EngineImageCreationFlagBits::CORE_ENGINE_IMAGE_CREATION_DYNAMIC_BARRIERS;
    return resolveDesc;
}

constexpr GpuImageDesc GetDepthImageDesc(const uint32_t width, const uint32_t height)
{
    GpuImageDesc resolveDesc;
    resolveDesc.width = width;
    resolveDesc.height = height;
    resolveDesc.depth = 1;
    resolveDesc.format = BASE_NS::Format::BASE_FORMAT_D16_UNORM;
    resolveDesc.memoryPropertyFlags = MemoryPropertyFlagBits::CORE_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    resolveDesc.usageFlags = ImageUsageFlagBits::CORE_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
                             ImageUsageFlagBits::CORE_IMAGE_USAGE_SAMPLED_BIT;
    resolveDesc.imageType = ImageType::CORE_IMAGE_TYPE_2D;
    resolveDesc.imageTiling = ImageTiling::CORE_IMAGE_TILING_OPTIMAL;
    resolveDesc.imageViewType = ImageViewType::CORE_IMAGE_VIEW_TYPE_2D;
    resolveDesc.engineCreationFlags = EngineImageCreationFlagBits::CORE_ENGINE_IMAGE_CREATION_DYNAMIC_BARRIERS;
    return resolveDesc;
}

static BASE_NS::string ROOTNODE_NAME = "rootNode_";
static BASE_NS::string ROOTNODE_PATH = "/" + ROOTNODE_NAME + "/";

BASE_NS::string_view RemoveRootNodeFromPath(const BASE_NS::string_view& path)
{
    if (path.starts_with(ROOTNODE_PATH)) {
        return path.substr(ROOTNODE_PATH.length());
    }

    if (path.starts_with("/")) {
        return path.substr(1);
    }

    return path;
}
} // namespace

SceneHolder::SceneHolder(META_NS::InstanceId uid, META_NS::IObjectRegistry& registry,
    const BASE_NS::shared_ptr<RENDER_NS::IRenderContext>& gc, META_NS::ITaskQueue::Ptr appQueue,
    META_NS::ITaskQueue::Ptr engineQueue)
    : instanceId_(uid), renderContext_(gc), appTaskQueue_(appQueue), engineTaskQueue_(engineQueue),
      objectRegistry_(registry)
{}

SceneHolder::~SceneHolder()
{
    ResetScene(false);
}

CORE_NS::IEcs::Ptr SceneHolder::GetEcs()
{
    // once we offer Ecs to anyone, we cannot know it is intact
    scenePrepared_ = false;
    return ecs_;
}

void SceneHolder::Initialize(WeakPtr me)
{
    me_ = me;
    InitializeScene();
}

void SceneHolder::Uninitialize()
{
    // Remove callbacks, these are no longer needed.
    SetInitializeCallback({}, me_);
    SetSceneLoadedCallback({}, me_);

    // Move processing to engine thread.
    UninitializeScene();
}
void SceneHolder::SetRenderSize(uint32_t width, uint32_t height, uint64_t cameraHandle)
{
    // Render size changed, schedule update engine thread.
    UpdateViewportSize(width, height, cameraHandle);
}

void SceneHolder::SetCameraTarget(
    const SCENE_NS::ICamera::Ptr& camera, BASE_NS::Math::UVec2 size, RENDER_NS::RenderHandleReference ref)
{
    auto cameraEnt = interface_cast<SCENE_NS::IEcsObject>(camera)->GetEntity();

    CameraData::Ptr cd;
    for (auto c : cameras_) {
        if (c->entity == cameraEnt) {
            cd = c;
            break;
        }
    }
    if (!cd) {
        // invalid.
        return;
    }
    cd->width = size.x;
    cd->height = size.y;
    if (!ref) {
        cd->colorImage = {};
        cd->ownsColorImage = true;
        RecreateOutputTexture(cd);
    } else {
        cd->colorImage = ref;
        cd->ownsColorImage = false;
    }
    cd->updateTargets = true;
}

void SceneHolder::RequestReload()
{
    LoadScene();
}

void SceneHolder::Load(const BASE_NS::string& uri)
{
    // Scene systems graph uri changed, schedule update to engine thread.
    if (sceneUri_ != uri) {
        sceneUri_ = uri;

        RequestReload();
    }
}

void SceneHolder::SetSystemGraphUri(const string& uri)
{
    // Scene systems graph uri changed, schedule update to engine thread.
    if (uri != sceneSystemGraphUri_) {
        sceneSystemGraphUri_ = uri;

        RequestReload();
    }
}

void SceneHolder::SetInitializeCallback(ISceneInitialized::Ptr callback, SceneHolder::WeakPtr weakMe)
{
    // Schedule update of callback to engine thread.
    sceneInitializedCallback_ = callback;
}

void SceneHolder::SetSceneLoadedCallback(ISceneLoaded::Ptr callback, SceneHolder::WeakPtr weakMe)
{
    // Schedule update of callback to engine thread.
    sceneLoadedCallback_ = callback;
}

void SceneHolder::SetUninitializeCallback(ISceneUninitialized::Ptr callback, SceneHolder::WeakPtr weakMe)
{
    // Schedule update of callback to engine thread.
    sceneUninitializedCallback_ = callback;
}

void SceneHolder::ActivateCamera(const Entity& cameraEntity) const
{
    if (!(cameraComponentManager_ && EntityUtil::IsValid(cameraEntity))) {
        CORE_LOG_W("SceneHolder::ActivateCamera: Can not be activated. cameraEntity: %" PRIx64
                   ", cameraComponentManager_: %d, IsValid(cameraEntity): %d",
            cameraEntity.id, static_cast<bool>(cameraComponentManager_), EntityUtil::IsValid(cameraEntity));
        return;
    }

    CameraComponent cameraComponent = cameraComponentManager_->Get(cameraEntity);
    cameraComponent.sceneFlags |= CameraComponent::ACTIVE_RENDER_BIT;
    cameraComponentManager_->Set(cameraEntity, cameraComponent);
}

void SceneHolder::DeactivateCamera(const Entity& cameraEntity) const
{
    if (!(cameraComponentManager_ && EntityUtil::IsValid(cameraEntity))) {
        CORE_LOG_W("SceneHolder::DeactivateCamera: Can not be deactivated. cameraEntity: %" PRIx64
                   ", cameraComponentManager_: %d, IsValid(cameraEntity): %d",
            cameraEntity.id, static_cast<bool>(cameraComponentManager_), EntityUtil::IsValid(cameraEntity));
        return;
    }

    CameraComponent cameraComponent = cameraComponentManager_->Get(cameraEntity);
    cameraComponent.sceneFlags &= ~(CameraComponent::ACTIVE_RENDER_BIT /* | CameraComponent::MAIN_CAMERA_BIT*/);
    cameraComponentManager_->Set(cameraEntity, cameraComponent);
}

bool SceneHolder::IsCameraActive(const Entity& cameraEntity) const
{
    if (!(cameraComponentManager_ && EntityUtil::IsValid(cameraEntity))) {
        CORE_LOG_W("SceneHolder::DeactivateCamera: Can not be deactivated. cameraEntity: %" PRIx64
                   ", cameraComponentManager_: %d, IsValid(cameraEntity): %d",
            cameraEntity.id, static_cast<bool>(cameraComponentManager_), EntityUtil::IsValid(cameraEntity));
        return false;
    }

    CameraComponent cameraComponent = cameraComponentManager_->Get(cameraEntity);
    return cameraComponent.sceneFlags & (CameraComponent::ACTIVE_RENDER_BIT);
}

bool SceneHolder::InitializeScene()
{
    graphicsContext3D_ = CreateInstance<CORE3D_NS::IGraphicsContext>(
        *renderContext_->GetInterface<IClassFactory>(), UID_GRAPHICS_CONTEXT);
    graphicsContext3D_->Init();

    picking_ = GetInstance<CORE3D_NS::IPicking>(*renderContext_->GetInterface<IClassRegister>(), UID_PICKING);

    // scene loading was attempted before initialization, retry now
    if (loadSceneFailed_) {
        loadSceneFailed_ = false;
        RequestReload();
    } else {
        // business as usual, set up things according build time settings
#ifdef INITIALIZE_ECS_IMMEDIATELY
        ResetScene(true);
        scenePrepared_ = true;
#else
        ResetScene(false);
#endif
    }

    // This is one-time init.
    return false;
}

BASE_NS::vector<CORE_NS::Entity> SceneHolder::RenderCameras()
{
    // nobody has asked for updates, yet
    if (!ecs_ /*|| isReadyForNewFrame_.empty()*/) {
        return {};
    }

    bool busy = false;
    BASE_NS::vector<CORE_NS::Entity> activeCameras;
    for (auto& camera : cameras_) {
        if (!EntityUtil::IsValid(camera->entity))
            continue;

        if (auto cc = cameraComponentManager_->Read(camera->entity)) {
            if (cc->sceneFlags & CameraComponent::SceneFlagBits::ACTIVE_RENDER_BIT) {
                if (camera->updateTargets) {
                    UpdateCameraRenderTarget(camera);
                    camera->updateTargets = false;
                }
                activeCameras.push_back(camera->entity);
            }
        }
    }
    isRunningFrame_ = true;
    // Tick frame. One camera could have static view while other is moving
    IEcs* ecs = ecs_.get();
    ecs->ProcessEvents();
    using namespace std::chrono;
    const auto currentTime =
        static_cast<uint64_t>(duration_cast<microseconds>(high_resolution_clock::now().time_since_epoch()).count());
    if (firstTime_ == ~0u) {
        previousFrameTime_ = firstTime_ = currentTime;
    }
    auto deltaTime = currentTime - previousFrameTime_;
    constexpr auto limitHz = duration_cast<microseconds>(duration<float, std::ratio<1, 15u>>(1)).count();
    if (deltaTime > limitHz) {
        deltaTime = limitHz; // clampthe time step to no longer than 15hz.
    }
    previousFrameTime_ = currentTime;
    const uint64_t totalTime = currentTime - firstTime_;
    const bool needsRender = ecs->Update(totalTime, deltaTime);
    ecs->ProcessEvents();
    auto renderHandles = graphicsContext3D_->GetRenderNodeGraphs(*ecs_);

    if ((needsRender) && (!renderHandles.empty())) {
        // The scene needs to be rendered.
        RENDER_NS::IRenderer& renderer = renderContext_->GetRenderer();
        renderer.RenderDeferred(renderHandles);
    } else {
        // did not render anything.
        bool nr = needsRender;
        activeCameras.clear();
    }
    isRunningFrame_ = false;

    if (requiresEventProcessing_) {
        ProcessEvents();
    }

    // Schedule new update to scene.
    return activeCameras;
}

bool SceneHolder::UninitializeScene()
{
    ResetScene();

    if (ecs_) {
        ecs_->Uninitialize();
        ecs_.reset();
    }

    if (sceneUninitializedCallback_) {
        QueueApplicationTask(MakeTask(
                                 [](auto callback) {
                                     callback->Invoke();
                                     return false;
                                 },
                                 sceneUninitializedCallback_),
            false);
    }

    sceneInitializedCallback_.reset();
    sceneUpdatedCallback_.reset();
    sceneUninitializedCallback_.reset();

    return false;
}

void SceneHolder::ProcessEvents()
{
    if (isRunningFrame_) {
        requiresEventProcessing_ = true;
        return;
    }

    if (ecsListener_ && ecsListener_->IsCallbackActive()) {
        requiresEventProcessing_ = true;
        return;
    }

    if (ecs_) {
        ecs_->ProcessEvents();
        requiresEventProcessing_ = false;
    }
}

bool SceneHolder::CreateDefaultEcs()
{
    if (!renderContext_) {
        CORE_LOG_W("%s: Graphics contexts is not available, can not create ecs", __func__);
        return false;
    }

    auto& engine = renderContext_->GetEngine();

    ecs_ = engine.CreateEcs();
    ecs_->SetRenderMode(renderMode_);

    if (!ecsListener_) {
        ecsListener_ = BASE_NS::shared_ptr<SCENE_NS::EcsListener>(new SCENE_NS::EcsListener());
    }
    ecsListener_->SetEcs(ecs_);

    // Get systemGraphLoader factory from global plugin registry.
    auto* factory = GetInstance<ISystemGraphLoaderFactory>(UID_SYSTEM_GRAPH_LOADER);
    auto systemGraphLoader = factory->Create(engine.GetFileManager());

    // First try to load project-specific system graph.
    auto result = sceneSystemGraphUri_.empty() ? false : systemGraphLoader->Load(sceneSystemGraphUri_, *ecs_).success;

    if (!result) {
        // Fall back to default graph.
        systemGraphLoader->Load("rofs3D://systemGraph.json", *ecs_);
    }

    auto renderPreprocessorSystem = GetSystem<IRenderPreprocessorSystem>(*ecs_);

    string dataStorePrefix = "renderDataStore:" + GetUniqueName();

    auto& renderDataStoreManager = renderContext_->GetRenderDataStoreManager();

    auto sceneDataStore = dataStorePrefix + "RenderDataStoreDefaultScene";
    auto cameraDataStore = dataStorePrefix + "RenderDataStoreDefaultCamera";
    auto lightDataStore = dataStorePrefix + "RenderDataStoreDefaultLight";
    auto materialDataStore = dataStorePrefix + "RenderDataStoreDefaultMaterial";
    auto morphDataStore = dataStorePrefix + "RenderDataStoreMorph";

    if (renderPreprocessorSystem) {
        IRenderPreprocessorSystem::Properties props;
        props.dataStorePrefix = dataStorePrefix;
        props.dataStoreScene = sceneDataStore;
        props.dataStoreCamera = cameraDataStore;
        props.dataStoreLight = lightDataStore;
        props.dataStoreMaterial = materialDataStore;
        props.dataStoreMorph = morphDataStore;

        *ScopedHandle<IRenderPreprocessorSystem::Properties>(renderPreprocessorSystem->GetProperties()) = props;
    }

    if (auto callback = ecsInitializationCallback_.lock()) {
        auto result = callback->Invoke(ecs_);
        if (!result) {
            CORE_LOG_W("Ecs initialization failed in the callback, expect trouble");
        }
    }

    ecs_->Initialize();

    animationComponentManager_ = CORE_NS::GetManager<CORE3D_NS::IAnimationComponentManager>(*ecs_);
    cameraComponentManager_ = GetManager<CORE3D_NS::ICameraComponentManager>(*ecs_);
    envComponentManager_ = GetManager<CORE3D_NS::IEnvironmentComponentManager>(*ecs_);
    layerComponentManager_ = GetManager<CORE3D_NS::ILayerComponentManager>(*ecs_);
    lightComponentManager_ = GetManager<CORE3D_NS::ILightComponentManager>(*ecs_);
    materialComponentManager_ = GetManager<CORE3D_NS::IMaterialComponentManager>(*ecs_);
    meshComponentManager_ = GetManager<CORE3D_NS::IMeshComponentManager>(*ecs_);
    nameComponentManager_ = GetManager<CORE3D_NS::INameComponentManager>(*ecs_);
    nodeComponentManager_ = GetManager<CORE3D_NS::INodeComponentManager>(*ecs_);
    renderMeshComponentManager_ = GetManager<CORE3D_NS::IRenderMeshComponentManager>(*ecs_);
    rhComponentManager_ = GetManager<CORE3D_NS::IRenderHandleComponentManager>(*ecs_);
    transformComponentManager_ = GetManager<CORE3D_NS::ITransformComponentManager>(*ecs_);
    uriComponentManager_ = GetManager<CORE3D_NS::IUriComponentManager>(*ecs_);

    if (animationComponentManager_) {
        animationQuery_.reset(new CORE_NS::ComponentQuery());
        animationQuery_->SetEcsListenersEnabled(true);
        const ComponentQuery::Operation operations[] = { { *nodeComponentManager_,
                                                             ComponentQuery::Operation::OPTIONAL },
            { *nameComponentManager_, ComponentQuery::Operation::OPTIONAL } };
        animationQuery_->SetupQuery(*animationComponentManager_, operations);
    }

    if (meshComponentManager_) {
        meshQuery_.reset(new CORE_NS::ComponentQuery());
        meshQuery_->SetEcsListenersEnabled(true);
        const ComponentQuery::Operation operations[] = { { *nodeComponentManager_,
                                                             ComponentQuery::Operation::OPTIONAL },
            { *nameComponentManager_, ComponentQuery::Operation::OPTIONAL } };
        meshQuery_->SetupQuery(*meshComponentManager_, operations);
    }

    if (materialComponentManager_) {
        materialQuery_.reset(new CORE_NS::ComponentQuery());
        materialQuery_->SetEcsListenersEnabled(true);
        const ComponentQuery::Operation operations[] = { { *nodeComponentManager_,
                                                             ComponentQuery::Operation::OPTIONAL },
            { *nameComponentManager_, ComponentQuery::Operation::OPTIONAL },
            { *uriComponentManager_, ComponentQuery::Operation::OPTIONAL } };
        materialQuery_->SetupQuery(*materialComponentManager_, operations);
    }
    nodeSystem_ = static_cast<CORE3D_NS::INodeSystem*>(ecs_->GetSystem(CORE3D_NS::INodeSystem::UID));
    return true;
}

CORE_NS::Entity SceneHolder::CreateCamera(const BASE_NS::string& name, uint32_t flagBits)
{
    return CreateCamera({}, name, flagBits);
}

CORE_NS::Entity SceneHolder::CreateCamera(const BASE_NS::string& path, const BASE_NS::string& name, uint32_t flagBits)
{
    if (ecs_) {
        auto pathWithoutRootNode = RemoveRootNodeFromPath(path);

        // Create camera. Scene util produces an invalid node so set up our camera from node system ourself
        auto nodeSystem = GetSystem<INodeSystem>(*ecs_);
        auto node = nodeSystem->CreateNode();
        auto entity = node->GetEntity();

        CORE3D_NS::ISceneNode* parent = nullptr;
        if (pathWithoutRootNode.empty()) {
            parent = rootNode_;
        } else {
            parent = rootNode_->LookupNodeByPath(pathWithoutRootNode);
        }

        CORE_ASSERT(parent);

        node->SetParent(*parent);
        node->SetName(name);

        auto tcm = GetManager<ITransformComponentManager>(*ecs_);
        TransformComponent tc;
        tc.position = Math::Vec3(0.0f, 0.0f, 2.5f);
        tc.rotation = {};
        tcm->Set(entity, tc);

        CameraComponent cc;
        cc.sceneFlags |= CameraComponent::SceneFlagBits::ACTIVE_RENDER_BIT;
        cc.projection = CameraComponent::Projection::PERSPECTIVE;
        cc.yFov = Math::DEG2RAD * 60.f;
        cc.zNear = 0.1f;
        cc.zFar = 100.f;
        cc.sceneFlags |= flagBits;
        cameraComponentManager_->Set(entity, cc);

        cameras_.emplace_back(CameraData::Create(entity));
        return entity;
    } else {
        CORE_LOG_E("%s: Ecs not available, can not create camera %s", __func__, name.c_str());
    }
    return CORE_NS::Entity();
}

void SceneHolder::SetDefaultCamera()
{
    if (cameraComponentManager_) {
        auto cameraCount = cameraComponentManager_->GetComponentCount();
        while (cameraCount) {
            --cameraCount;
            // if the scene already contains main camera, respect it
            if (cameraComponentManager_->Get(cameraComponentManager_->GetEntity(cameraCount)).sceneFlags &
                CameraComponent::MAIN_CAMERA_BIT) {
                auto entity = cameraComponentManager_->GetEntity(cameraCount);
                cameras_.emplace_back(CameraData::Create(entity));
                defaultCameraEntity_ = entity;
                SetMainCamera(entity);
                return;
            }
        }
    }
}

void SceneHolder::SetMainCamera(const Entity& entity)
{
    if (cameras_.empty() || (mainCamera_ && entity == mainCamera_->entity)) {
        return;
    }

    if (mainCamera_ && cameraComponentManager_ && EntityUtil::IsValid(mainCamera_->entity)) {
        bool isAlive = ecs_->GetEntityManager().IsAlive(mainCamera_->entity);
        if (isAlive) {
            // Mark previous main camera as inactive.
            CameraComponent cameraComponent = cameraComponentManager_->Get(mainCamera_->entity);
            cameraComponent.sceneFlags &= ~CameraComponent::MAIN_CAMERA_BIT;
            cameraComponentManager_->Set(mainCamera_->entity, cameraComponent);
        }
    }

    mainCamera_ = {};

    for (auto& camera : cameras_) {
        if (camera->entity == entity) {
            mainCamera_ = camera;
            break;
        }
    }

    if (!mainCamera_) {
        if (EntityUtil::IsValid(entity)) {
            CORE_LOG_W("%s: was not able to set camera for: %" PRIx64 " ", __func__, entity.id);
        }
        return;
    }

    if (cameraComponentManager_ && EntityUtil::IsValid(mainCamera_->entity)) {
        // Mark new camera as active.
        CameraComponent cameraComponent = cameraComponentManager_->Get(mainCamera_->entity);
        cameraComponent.sceneFlags |= CameraComponent::MAIN_CAMERA_BIT;
        cameraComponentManager_->Set(mainCamera_->entity, cameraComponent);
        UpdateViewportSize(mainCamera_->width, mainCamera_->height, mainCamera_->entity.id);
    }
}

void SceneHolder::AddCamera(const CORE_NS::Entity& entity)
{
    for (auto c : cameras_) {
        if (c->entity == entity) {
            return;
        }
    }
    cameras_.emplace_back(CameraData::Create(entity));
}

void SceneHolder::RemoveCamera(const CORE_NS::Entity& entity)
{
    auto it = std::find_if(cameras_.begin(), cameras_.end(), [entity](const auto& item) {
        // Check if camera entities are the same.
        return item->entity == entity;
    });

    if (it != cameras_.end()) {
        cameras_.erase(it);
    }
}

void SceneHolder::UpdateViewportSize(uint32_t width, uint32_t height, uint64_t cameraHandle)
{
    CORE_LOG_D("%s: w: %u h: %u", __func__, width, height);
    // these would be never valid as render target so use some default values to make sure that buffers are prepared
    if (width == 0) {
        width = 128; // 128 default width
    }
    if (height == 0) {
        height = 128; // // 128 default height
    }

    if (ecs_) {
        if (cameraHandle == 0 && !cameras_.empty()) {
            // short circuit defaut camera
            cameraHandle = cameras_.front()->entity.id;
        }

        // Make sure that render target will be updated
        // ToDo: Clean this up to select the correct camera instance
        CameraData::Ptr camera;

        for (auto& c : cameras_) {
            if (c->entity.id == cameraHandle) {
                camera = c;
                break;
            }
        }
        if (!camera) {
            return;
        }
        if (!camera->ownsColorImage) {
            // we don't own the bitmap so.
            return;
        }

        camera->width = width;
        camera->height = height;
        RecreateOutputTexture(camera);

        if (!EntityUtil::IsValid(camera->entity)) {
            return;
        }
        camera->updateTargets = true;
        ecs_->RequestRender();
    }
}

void SceneHolder::RecreateOutputTexture(CameraData::Ptr camera)
{
    if ((renderContext_) && (camera)) {
        if (camera->ownsColorImage) {
            camera->colorImage = renderContext_->GetDevice().GetGpuResourceManager().Create(
                GetColorImageDesc(camera->width, camera->height));
#ifdef SCENE_PLUGIN_CREATE_IMPLICIT_DEPTH_TARGET
            camera->depthImage = renderContext_->GetDevice().GetGpuResourceManager().Create(
                GetDepthImageDesc(camera->width, camera->height));
#endif
        }
    }
}

bool SceneHolder::UpdateCameraRenderTarget(CameraData::Ptr camera)
{
    if (!EntityUtil::IsValid(camera->entity))
        return false;

    if (auto cc = cameraComponentManager_->Write(camera->entity)) {
        auto& em = ecs_->GetEntityManager();
        cc->renderResolution[0] = static_cast<float>(camera->width);
        cc->renderResolution[1] = static_cast<float>(camera->height);
        cc->customColorTargets = { GetOrCreateEntityReference(em, *rhComponentManager_, camera->colorImage) };
        if (camera->depthImage) {
            cc->customDepthTarget = GetOrCreateEntityReference(em, *rhComponentManager_, camera->depthImage);
        }
        if (cc->sceneFlags & CameraComponent::SceneFlagBits::ACTIVE_RENDER_BIT) {
            // please render also.
            return true;
        }
    }
    // no render.
    return false;
}

void SceneHolder::ResetScene(bool initialize)
{
    bool wasScenePrepared = scenePrepared_;
    scenePrepared_ = false;
    if (wasScenePrepared && initialize) {
        return;
    }

    SetMainCamera({});
    cameras_.clear();

    animations_.clear();

    // Release resource data.
    gltfResourceData_ = {};
    sceneEntity_ = {};

    // Release default camera.
    defaultCameraEntity_ = {};

    // Release scene
    scene_ = {};
    assetManager_ = {};

    // Release scene root.
    rootNode_ = {};

    // fully recreate ECS if requested
    if (ecs_) {
        cameraComponentManager_ = {};
        meshComponentManager_ = {};
        nameComponentManager_ = {};
        nodeComponentManager_ = {};
        meshQuery_ = {};
        materialQuery_ = {};
        animationQuery_ = {};
        ecsListener_->Reset();
        ecs_->Uninitialize();
        ecs_.reset();
    }

    if (sceneUninitializedCallback_) {
        QueueApplicationTask(MakeTask(
                                 [](auto callback) {
                                     callback->Invoke();
                                     return false;
                                 },
                                 sceneUninitializedCallback_),
            false);
    }

    if (initialize && CreateDefaultEcs()) {
        // Create new root node.
        CORE3D_NS::INodeSystem& nodeSystem = *GetSystem<CORE3D_NS::INodeSystem>(*ecs_);
        rootNode_ = nodeSystem.CreateNode();
        rootNode_->SetName(ROOTNODE_NAME);
        if (nodeComponentManager_) {
            nodeComponentManager_->Create(rootNode_->GetEntity());
        }
        scene_ = SCENE_NS::IEntityCollection::Ptr { new SCENE_NS::EntityCollection(*ecs_, "scene", {}) };

        // it seems that having our root entity as a part of loaded entify has no significant effect on
        // anything Presumably it is ok to keep it out of the serialization auto entityRef =

        rootNode_->SetEnabled(true);

        assetManager_ =
            SCENE_NS::IAssetManager::Ptr { new SCENE_NS::AssetManager(*renderContext_, *graphicsContext3D_) };
    }
}

void SceneHolder::SetSceneSystemGraph(const BASE_NS::string& uri)
{
    if (uri != sceneSystemGraphUri_) {
        sceneSystemGraphUri_ = uri;
        scenePrepared_ = false;
        if (scene_) {
            // reload with new graph
            LoadScene();

        } else if (sceneLoadedCallback_) {
            QueueApplicationTask(MakeTask(
                                     [](auto sceneLoadedCallback) {
                                         if (sceneLoadedCallback) {
                                             sceneLoadedCallback->Invoke(SCENE_NS::IScene::SCENE_STATUS_UNINITIALIZED);
                                         }
                                         return false;
                                     },
                                     sceneLoadedCallback_),
                false);
        }
    }
}

void SceneHolder::LoadScene(const BASE_NS::string& uri)
{
    // ToDo: LoadScene shoud deal with this, but currently triggers a problem when we swap between instances
    if (sceneUri_ == uri) {
        if (sceneLoadedCallback_) {
            bool haveEcs = (ecs_ == nullptr);
            QueueApplicationTask(MakeTask(
                                     [haveEcs](auto sceneLoadedCallback) {
                                         if (sceneLoadedCallback) {
                                             sceneLoadedCallback->Invoke(
                                                 haveEcs ? SCENE_NS::IScene::SCENE_STATUS_READY
                                                         : SCENE_NS::IScene::SCENE_STATUS_LOADING_FAILED);
                                         }
                                         return false;
                                     },
                                     sceneLoadedCallback_),
                false);
        }
        return;
    }
    sceneUri_ = uri;
    LoadScene();
}

static constexpr BASE_NS::string_view KDUMMY_STRING { "!#&/dummy" };

void SceneHolder::IntrospectNodeless()
{
#ifndef NDEBUG
    Entity dummy {};
    FindMesh(KDUMMY_STRING, KDUMMY_STRING, dummy);
    FindMaterial(KDUMMY_STRING, KDUMMY_STRING, dummy);
#endif // !NDEBUG

    RemoveUriComponentsFromMeshes();
    ResolveAnimations();
}

bool GetEntityId(const CORE_NS::Entity& entity, BASE_NS::string_view& entityName,
    SCENE_NS::IEntityCollection& collection, BASE_NS::string_view backupCollection,
    CORE3D_NS::INameComponentManager& nameComponentManager)
{
    if (EntityUtil::IsValid(entity)) {
        entityName = collection.GetUniqueIdentifierRecursive(entity);
        if (!entityName.empty() && entityName != "/") {
            return true;
        } else {
            if (auto readHandle = nameComponentManager.Read(entity)) {
                entityName = readHandle->name;
                collection.AddEntityToSubcollection(backupCollection, entityName, entity, true);
                auto gltfCollectionIx = collection.GetSubCollectionIndex(backupCollection);
                if (auto gltfCollection = collection.GetSubCollection(gltfCollectionIx)) {
                    entityName = gltfCollection->GetUniqueIdentifier(entity);
                    return true;
                }
            } else {
                // ToDo: we could store entity id even it did not have name component
                CORE_LOG_W("%s: entity missing from collections", __func__);
            }
        }
    }
    return false;
}

void ExtractQueryResults(CORE_NS::ComponentQuery& query, SCENE_NS::IEntityCollection& collection,
    BASE_NS::string_view backupCollection, BASE_NS::shared_ptr<BASE_NS::vector<BASE_NS::string_view>>& result,
    CORE3D_NS::INameComponentManager& nameComponentManager)
{
    query.Execute();
    auto results = query.GetResults();
    for (auto& row : results) {
        BASE_NS::string_view id;
        if (GetEntityId(row.entity, id, collection, backupCollection, nameComponentManager)) {
            result->push_back(id);
        }
    }
}

BASE_NS::shared_ptr<BASE_NS::vector<BASE_NS::string_view>> SceneHolder::ListMaterialNames()
{
    BASE_NS::shared_ptr<BASE_NS::vector<BASE_NS::string_view>> ret { new BASE_NS::vector<BASE_NS::string_view> };
    if (materialQuery_ && scene_) {
        ExtractQueryResults(*materialQuery_, *scene_.get(), "GLTF_Materials", ret, *nameComponentManager_);
    }
    return ret;
}

BASE_NS::shared_ptr<BASE_NS::vector<BASE_NS::string_view>> SceneHolder::ListMeshNames()
{
    BASE_NS::shared_ptr<BASE_NS::vector<BASE_NS::string_view>> ret { new BASE_NS::vector<BASE_NS::string_view> };
    if (meshQuery_ && scene_) {
        ExtractQueryResults(*meshQuery_, *scene_.get(), "GLTF_Meshes", ret, *nameComponentManager_);
    }
    return ret;
}

void SceneHolder::RemoveUriComponentsFromMeshes()
{
    meshQuery_->Execute();
    auto meshes = meshQuery_->GetResults();

    SCENE_PLUGIN_VERBOSE_LOG("found %zu meshes", meshes.size());

    // Remove uri component from meshes, since it causes issues with prefab loading.
    // The gltf importer shares the meshes between collections, if they have
    // similar uri.
    // However, this is not desired behavior, because scene-overridden property
    // values will propagate to future prefab instances (e.g. material).
    for (auto& mesh : meshes) {
        if (uriComponentManager_->HasComponent(mesh.entity)) {
            uriComponentManager_->Destroy(mesh.entity);
        }
    }
}

bool SceneHolder::FindMesh(const BASE_NS::string_view name, const BASE_NS::string_view fullPath, Entity& entity)
{
    if (ecs_) {
        entity = scene_->GetEntityRecursive(fullPath);
        if (CORE_NS::EntityUtil::IsValid(entity)) {
            return true;
        }

        meshQuery_->Execute();
        auto meshes = meshQuery_->GetResults();

        SCENE_PLUGIN_VERBOSE_LOG("found %zu meshes", meshes.size());

#ifdef NDEBUG
        if (name == KDUMMY_STRING) {
            return false;
        }
#endif

        for (auto&& mesh : meshes) {
            bool effectivelyEnabled = false;
            if (auto readHandle = nodeComponentManager_->Read(mesh.components[1])) {
                effectivelyEnabled = readHandle->effectivelyEnabled;
            }
            BASE_NS::string entityName;
            if (auto readHandle = nameComponentManager_->Read(mesh.components[2])) {
                entityName = readHandle->name;
            }
            SCENE_PLUGIN_VERBOSE_LOG("name: %s enabled: %i", entityName.c_str(), effectivelyEnabled);
            if (name == entityName || fullPath == entityName) {
                entity = mesh.entity;
                return true;
            }
        }
        // Could not find the mesh with given the name, try if it has a node
        const auto& root = nodeSystem_->GetRootNode();
        if (auto ecsNode = root.LookupNodeByPath(fullPath)) {
            entity = ecsNode->GetEntity();
            return true;
        }
    }
    return false;
}

BASE_NS::string SceneHolder::GetResourceId(CORE_NS::Entity entity)
{
    BASE_NS::string result;

    if (scene_) {
        result = scene_->GetUniqueIdentifierRecursive(entity);
    }
    return result;
}

bool SceneHolder::FindMaterial(const BASE_NS::string_view name, const BASE_NS::string_view fullPath, Entity& entity)
{
    if (ecs_) {
        entity = scene_->GetEntityRecursive(fullPath);
        if (CORE_NS::EntityUtil::IsValid(entity)) {
            return true;
        }

        materialQuery_->Execute();
        auto materials = materialQuery_->GetResults();

        SCENE_PLUGIN_VERBOSE_LOG("found %zu materials", materials.size());

#ifdef NDEBUG
        if (name == KDUMMY_STRING) {
            return false;
        }
#endif

        for (auto&& material : materials) {
            bool effectivelyEnabled = false;
            if (auto readHandle = nodeComponentManager_->Read(material.components[1])) {
                effectivelyEnabled = readHandle->effectivelyEnabled;
            }
            BASE_NS::string entityName;
            if (auto readHandle = nameComponentManager_->Read(material.components[2])) {
                entityName = readHandle->name;
            }
            SCENE_PLUGIN_VERBOSE_LOG("name: %s enabled: %i", entityName.c_str(), effectivelyEnabled);
            if (name == entityName) {
                entity = material.entity;
                return true;
            }
            if (auto readHandle = uriComponentManager_->Read(material.components[3])) {
                entityName = readHandle->uri;
            }

            if (!entityName.empty()) {
                if (name == entityName || fullPath == entityName) {
                    entity = material.entity;
                    return true;
                }
            }
        }
        // Could not find the material with the given name, try if it has a node
        const auto& root = nodeSystem_->GetRootNode();
        if (auto ecsNode = root.LookupNodeByPath(fullPath)) {
            entity = ecsNode->GetEntity();
            return true;
        }
        // Desperate measures, to be rectified
        if (auto created = rootNode_->LookupNodeByPath(fullPath)) {
            entity = created->GetEntity();
            return true;
        }
    }
    return false;
}

bool SceneHolder::FindAnimation(const BASE_NS::string_view name, const BASE_NS::string_view fullPath, Entity& entity)
{
    if (ecs_) {
        if (!animations_.empty()) {
            size_t ix = name.rfind(":");
            if (ix != BASE_NS::string_view::npos && ix != name.size() - 1) {
                char* dummy = nullptr;
                auto entityId = strtoll(name.substr(ix + 1).data(), &dummy, 16);
                if (animations_.find(entityId) != animations_.cend()) {
                    entity.id = entityId;
                    return true;
                }
            }

            for (auto&& animation : animations_) {
                if (META_NS::GetValue(interface_pointer_cast<META_NS::INamed>(animation.second)->Name()) == name) {
                    entity.id = animation.first;
                    return true;
                }
            }
        } else {
            animationQuery_->Execute();
            auto animations = animationQuery_->GetResults();

            SCENE_PLUGIN_VERBOSE_LOG("found %zu animations", animations.size());

#ifdef NDEBUG
            if (name == KDUMMY_STRING) {
                return false;
            }
#endif

            for (auto&& animation : animations) {
                bool effectivelyEnabled = false;
                if (auto readHandle = nodeComponentManager_->Read(animation.components[1])) {
                    effectivelyEnabled = readHandle->effectivelyEnabled;
                }
                BASE_NS::string entityName;
                if (auto readHandle = nameComponentManager_->Read(animation.components[2])) {
                    entityName = readHandle->name;
                }
                SCENE_PLUGIN_VERBOSE_LOG("name: %s enabled: %i", entityName.c_str(), effectivelyEnabled);
                if (name == entityName || fullPath == entityName) {
                    entity = animation.entity;
                    return true;
                }
            }
            // Could not find the animation with given the name, try if it has a node
            const auto& root = nodeSystem_->GetRootNode();
            if (auto ecsNode = root.LookupNodeByPath(fullPath)) {
                entity = ecsNode->GetEntity();
                return true;
            }
        }
    }
    return false;
}

void SceneHolder::ResolveAnimations()
{
    if (ecs_) {
        animationQuery_->Execute();
        auto animations = animationQuery_->GetResults();

        SCENE_PLUGIN_VERBOSE_LOG("%s, found %zu animations", __func__, animations.size());

        for (auto&& animation : animations) {
            if (animations_.find(animation.entity.id) == animations_.cend()) {
                animations_[animation.entity.id] =
                    GetObjectRegistry().Create<SCENE_NS::IEcsAnimation>(SCENE_NS::ClassId::EcsAnimation);
                if (auto ecsProxyIf =
                        interface_pointer_cast<SCENE_NS::IEcsProxyObject>(animations_[animation.entity.id])) {
                    ecsProxyIf->SetCommonListener(GetCommonEcsListener());
                }
                animations_[animation.entity.id]->SetEntity(*ecs_, animation.entity);
            }
        }
    }
}

void SceneHolder::UpdateAttachments(SCENE_NS::IEcsObject::Ptr& ecsObject)
{
    if (ecs_) {
        auto entity = ecsObject->GetEntity();
        if (EntityUtil::IsValid(entity)) {
            for (auto&& animation : animations_) {
                if (animation.second->GetRootEntity() == entity) {
                    ecsObject->AddAttachment(animation.second->GetEntity());
                }
            }
        }
    }
}

// This could be highly inefficient, in most cases we should have a clue of resource type
bool SceneHolder::FindResource(const BASE_NS::string_view name, const BASE_NS::string_view fullPath, Entity& entity)
{
    if (ecs_ && scene_) {
        if (FindAnimation(name, fullPath, entity) || FindMaterial(name, fullPath, entity) ||
            FindMesh(name, fullPath, entity)) {
            return true;
        }

        // traverse through scene collection
        for (size_t ix = 0; ix < scene_->GetSubCollectionCount(); ix++) {
            if (const auto& subcollection = scene_->GetSubCollection(ix); subcollection->GetUri() == fullPath) {
                // the assumption is that we do not have to dig deeper
                if (subcollection->GetEntityCount() > 0) {
                    entity = subcollection->GetEntity(0);
                    return true;
                }
            }
        }

        // Try finding an existing resource with an uri. This is needed e.g. for the images loaded from an glTF
        // file where the uri does not point to an actual image file but the resource is just a entity with uri in
        // ECS.
        if (renderMeshComponentManager_ && uriComponentManager_) {
            for (size_t i = 0; i < uriComponentManager_->GetComponentCount(); ++i) {
                const Entity currentEntity =
                    uriComponentManager_->GetEntity(static_cast<IComponentManager::ComponentId>(i));
                if (ecs_->GetEntityManager().IsAlive(currentEntity)) {
                    if (auto uriComponent = uriComponentManager_->Read(currentEntity);
                        uriComponent && uriComponent->uri == fullPath) {
                        if (renderMeshComponentManager_->HasComponent(currentEntity)) {
                            entity = currentEntity;
                            return true;
                        }
                    }
                }
            }
        }
    }

    return false;
}

bool SceneHolder::GetImageEntity(CORE_NS::Entity material, size_t index, CORE_NS::Entity& entity)
{
    bool ret { false };
    if (ecs_ && scene_ && CORE_NS::EntityUtil::IsValid(material)) {
        if (auto handle = materialComponentManager_->Read(material)) {
            entity = handle->textures[index].image;
            ret = true;
        }
    }

    return ret;
}

bool SceneHolder::GetRenderHandleUri(const RENDER_NS::RenderHandle& handle, BASE_NS::string& uriString)
{
    if (ecs_) {
        auto& renderUtil = graphicsContext3D_->GetRenderContext().GetRenderUtil();

        size_t index { 0 };
        while (auto handleReference = rhComponentManager_->GetRenderHandleReference(index)) {
            if (handleReference.GetHandle() == handle) {
                auto& renderUtil = graphicsContext3D_->GetRenderContext().GetRenderUtil();
                const auto desc = renderUtil.GetRenderHandleDesc(handleReference);
                if (desc.type == RenderHandleType::GPU_IMAGE && !desc.name.empty()) {
                    // Note: assuming that the name is the image uri. Ignore the name if not in uri format.
                    if (desc.name.find(":/") != BASE_NS::string::npos) {
                        uriString = desc.name;
                        return true;
                    }
                }
            }
            index++;
        }
    }
    return false;
}

CORE_NS::Entity SceneHolder::CreatePostProcess()
{
    CORE_NS::Entity entity;
    if (ecs_) {
        auto pm = CORE_NS::GetManager<CORE3D_NS::IPostProcessComponentManager>(*ecs_);
        entity = ecs_->GetEntityManager().Create();
        // createComponent
        pm->Create(entity);
    }
    return entity;
}

CORE_NS::Entity SceneHolder::CreateRenderConfiguration()
{
    CORE_NS::Entity entity;
    if (ecs_) {
        entity = ecs_->GetEntityManager().Create();

        auto rcm = CORE_NS::GetManager<CORE3D_NS::IRenderConfigurationComponentManager>(*ecs_);
        rcm->Create(entity);
    }
    return entity;
}

void SceneHolder::SetRenderHandle(const CORE_NS::Entity& target, const CORE_NS::Entity& source)
{
    if (ecs_) {
        if (auto sourceHandle = rhComponentManager_->GetRenderHandleReference(source)) {
            if (!rhComponentManager_->HasComponent(target)) {
                rhComponentManager_->Create(target);
            }
            if (auto handle = rhComponentManager_->Write(target)) {
                handle->reference = sourceHandle;
            }
        }
    }
}

bool SceneHolder::GetEntityUri(const CORE_NS::Entity& entity, BASE_NS::string& uriString)
{
    bool ret { false };
    if (ecs_ && scene_ && CORE_NS::EntityUtil::IsValid(entity)) {
        if (auto handle = uriComponentManager_->Read(entity)) {
            uriString = BASE_NS::string(handle->uri.data(), handle->uri.size());
            ret = true;
        }
    }

    if (!ret) {
        // Special handling for render handles (automatically loaded images in the ecs are now just render handles
        // with a name containing the uri).
        auto handle = rhComponentManager_->GetRenderHandleReference(entity);
        if (handle) {
            auto& renderUtil = renderContext_->GetRenderUtil();
            const auto desc = renderUtil.GetRenderHandleDesc(handle);
            if (desc.type == RenderHandleType::GPU_IMAGE && !desc.name.empty()) {
                // Note: assuming that the name is the image uri. Ignore the name if not in uri format.
                if (desc.name.find(":/") != BASE_NS::string::npos) {
                    uriString = desc.name;
                    ret = true;
                }
            }
        }
    }

    return ret;
}
bool SceneHolder::GetImageHandle(
    const CORE_NS::Entity& entity, RENDER_NS::RenderHandleReference& handle, RENDER_NS::GpuImageDesc& desc)
{
    if (rhComponentManager_->HasComponent(entity)) {
        handle = rhComponentManager_->GetRenderHandleReference(entity);
        desc = renderContext_->GetDevice().GetGpuResourceManager().GetImageDescriptor(handle);
        return true;
    }
    return false;
}

bool SceneHolder::SetEntityUri(const CORE_NS::Entity& entity, const BASE_NS::string& uriString)
{
    bool ret { false };
    if (ecs_ && scene_ && CORE_NS::EntityUtil::IsValid(entity)) {
        if (!uriComponentManager_->HasComponent(entity)) {
            uriComponentManager_->Create(entity);
        }

        if (auto handle = uriComponentManager_->Write(entity)) {
            handle->uri = uriString;
            ret = true;
        }
    }

    return ret;
}

bool SceneHolder::GetEntityName(const CORE_NS::Entity& entity, BASE_NS::string& nameString)
{
    bool ret { false };
    if (ecs_ && scene_ && CORE_NS::EntityUtil::IsValid(entity)) {
        if (auto handle = nameComponentManager_->Read(entity)) {
            nameString = BASE_NS::string(handle->name.data(), handle->name.size());
            ret = true;
        }
    }

    return ret;
}

CORE_NS::Entity SceneHolder::GetEntityByUri(BASE_NS::string_view uriString)
{
    for (size_t i = 0; i < uriComponentManager_->GetComponentCount(); ++i) {
        const Entity entity = uriComponentManager_->GetEntity(static_cast<IComponentManager::ComponentId>(i));
        if (ecs_->GetEntityManager().IsAlive(entity)) {
            if (auto uriComponent = uriComponentManager_->Read(entity);
                uriComponent && uriComponent->uri == uriString) {
                return entity;
            }
        }
    }

    return {};
}

bool ResolveNodeFullPath(CORE3D_NS::ISceneNode* node, BASE_NS::string& path)
{
    if (node) {
        path = node->GetName();
        while ((node = node->GetParent())) {
            path.insert(0, "/");
            auto name = node->GetName();
            path.insert(0, name.data(), name.size());
        }
    }
    return (!path.empty());
}

BASE_NS::string ResolveNodeFullPath(CORE_NS::IEcs& ecs, const CORE_NS::Entity& entity)
{
    CORE3D_NS::INodeSystem& nodeSystem = *CORE_NS::GetSystem<CORE3D_NS::INodeSystem>(ecs);
    BASE_NS::string ret;
    ResolveNodeFullPath(nodeSystem.GetNode(entity), ret);
    return ret;
}

void SceneHolder::LoadScene()
{
    // Reset scene to default.
    CORE_LOG_I("Loading scene: '%s'", sceneUri_.c_str());
    uint32_t loadingStatus = SCENE_NS::IScene::SCENE_STATUS_LOADING_FAILED;
    bool replacedRoot { false };

    while (true) {
        if (sceneUri_.empty()) {
            ResetScene();
            loadingStatus = SCENE_NS::IScene::SCENE_STATUS_UNINITIALIZED;
            break;
        }

        auto params = SCENE_NS::PathUtil::GetUriParameters(sceneUri_);
        auto ite = params.find("target");
        if (!scene_ || ite == params.end() || ite->second.empty()) {
            ResetScene(true);
            replacedRoot = true;
        } else {
            CORE_LOG_I("Load into scene: %s", ite->second.c_str());
        }

        // If ecs initializing failed, report it back and return
        if (!ecs_) {
            break;
        }

        if (assetManager_) {
            if ((sceneUri_ != "scene://empty") && !assetManager_->LoadAsset(*scene_, sceneUri_, "project://")) {
                CORE_LOG_E("Loading scene %s failed", sceneUri_.c_str());
                ResetScene();
                break;
            } else { // ToDo: This is currently done also when a node is added to container, so no need to do it
                     // here
                // Rearrange scene to have a concrete common root node, this will be more important for prefabs
                CORE3D_NS::INodeSystem& nodeSystem = *CORE_NS::GetSystem<CORE3D_NS::INodeSystem>(*ecs_);
                auto& root = nodeSystem.GetRootNode();

                // ToDo: should this fetch the named root node instead
                auto ourRoot = root.GetChildren().at(0);
                ourRoot->SetEnabled(true);

                auto ite = root.GetChildren().begin() + 1;
                while (ite != root.GetChildren().end()) {
                    (*ite)->SetParent(*ourRoot);
                    ite = root.GetChildren().begin() + 1;
                }
            }

            // Loading might have cached some assets (in case there are multiple
            // instances). Scene widget will not need them after loading so clear the
            // cache.
            if (replacedRoot) {
                assetManager_->ClearCache();
            }
        }
        if (sceneUri_ != "scene://empty") {
            // Set default camera.
            SetDefaultCamera();
        }
        // ask synchronous update
        RenderCameras();
        loadingStatus = SCENE_NS::IScene::SCENE_STATUS_READY;
        break;
    }

    // If ecs initialization fails, all we can do is to retry loading later
    if (!ecs_) {
        loadSceneFailed_ = true;

        if (sceneLoadedCallback_) {
            QueueApplicationTask(MakeTask(
                                     [](auto sceneLoadedCallback, auto loadingStatus) {
                                         if (sceneLoadedCallback)
                                             sceneLoadedCallback->Invoke(loadingStatus);
                                         return false;
                                     },
                                     sceneLoadedCallback_, loadingStatus),
                false);
        }
        return;
    }

    // make sure that components get updated
    ProcessEvents();

    IntrospectNodeless();
    // Call back the app thread, notify that the graphics and ecs are ready. This
    // is not quite true, though
    if (ecs_ && replacedRoot && sceneInitializedCallback_) {
        BASE_NS::string id { rootNode_->GetName() };
        BASE_NS::string cameraId = ResolveNodeFullPath(*ecs_, defaultCameraEntity_);
        QueueApplicationTask(MakeTask(
                                 [](auto sceneInitializedCallback, auto id, auto cameraId) {
                                     if (sceneInitializedCallback) {
                                         sceneInitializedCallback->Invoke(id, cameraId);
                                     }
                                     return false;
                                 },
                                 sceneInitializedCallback_, id, cameraId),
            false);
    } else if (sceneLoadedCallback_) { // Call back the app thread, notify that new scene is loaded
        QueueApplicationTask(MakeTask(
                                 [](auto sceneLoadedCallback, auto loadingStatus) {
                                     if (sceneLoadedCallback) {
                                         sceneLoadedCallback->Invoke(loadingStatus);
                                     }
                                     return false;
                                 },
                                 sceneLoadedCallback_, loadingStatus),
            false);
    }
}

void SceneHolder::ChangeCamera(SCENE_NS::ICamera::Ptr camera)
{
    if (auto cameraObject = interface_pointer_cast<SCENE_NS::IEcsObject>(camera)) {
        auto entity = cameraObject->GetEntity();
        if (EntityUtil::IsValid(entity)) {
            SetMainCamera(entity);
        }
    }
}

void logNodes(const CORE3D_NS::ISceneNode& node, BASE_NS::string path)
{
    if (!path.empty() && path.back() != '/') {
        path.append("/");
    }
    if (!node.GetName().empty()) {
        path.append(node.GetName());
    } else {
        path.append("[");
        path.append(BASE_NS::to_string(node.GetEntity().id));
        path.append("]");
    }
    CORE_LOG_I("%s", path.c_str());

    for (const auto child : node.GetChildren())
        logNodes(*child, path);
}

void SceneHolder::SaveScene(const BASE_NS::string& fileName)
{
    assetManager_->SaveJsonEntityCollection(*scene_.get(), fileName.empty() ? sceneUri_ : fileName, "file://");

    // Verbose logs, to be suppressed at some point
    CORE3D_NS::INodeSystem& nodeSystem = *GetSystem<CORE3D_NS::INodeSystem>(*ecs_);
    logNodes(nodeSystem.GetRootNode(), "/");
    IntrospectNodeless();
}

CORE3D_NS::ISceneNode* SceneHolder::CreateNode(const BASE_NS::string& name)
{
    return CreateNode({}, name);
}

CORE3D_NS::ISceneNode* SceneHolder::CreateNode(const BASE_NS::string& path, const BASE_NS::string& name)
{
    if (ecs_) {
        auto pathWithoutRootNode = RemoveRootNodeFromPath(path);

        CORE3D_NS::INodeSystem& nodeSystem = *GetSystem<CORE3D_NS::INodeSystem>(*ecs_);

        CORE3D_NS::ISceneNode* parent = nullptr;
        if (pathWithoutRootNode.empty()) {
            parent = rootNode_;
        } else {
            parent = rootNode_->LookupNodeByPath(pathWithoutRootNode);
        }

        CORE_ASSERT(parent);

        auto instanceRoot = nodeSystem.CreateNode();
        instanceRoot->SetName(name);
        instanceRoot->SetParent(*parent);
        return instanceRoot;
    } else {
        CORE_LOG_E("%s: Ecs not available, can not create node %s", __func__, name.c_str());
    }

    return nullptr;
}

CORE_NS::Entity SceneHolder::CreateMaterial(const BASE_NS::string& name)
{
    if (ecs_) {
        auto entity = ecs_->GetEntityManager().Create();

        RenameEntity(entity, name);

        materialComponentManager_->Create(entity);
        scene_->AddEntityToSubcollection("created_materials", name, entity);
        ProcessEvents();
        return entity;

    } else {
        CORE_LOG_E("%s: Ecs not available, can not create material %s", __func__, name.c_str());
    }

    return {};
}

void SceneHolder::RenameEntity(CORE_NS::Entity entity, const BASE_NS::string& name)
{
    if (ecs_) {
        // Name Component
        if (!nameComponentManager_->HasComponent(entity)) {
            nameComponentManager_->Create(entity);
        }
        if (auto nameHandle = nameComponentManager_->Write(entity)) {
            nameHandle->name = name;
        }

        // Root level entity collection item
        if (BASE_NS::string_view prevName = scene_->GetUniqueIdentifier(entity); !prevName.empty()) {
            scene_->SetUniqueIdentifier(name, scene_->GetEntity(prevName));
        } else if (nodeComponentManager_->HasComponent(entity)) {
            if (auto ecsNode = nodeSystem_->GetNode(entity)) {
                if (const auto& children = ecsNode->GetChildren(); children.size()) {
                    if (auto ix = scene_->GetSubCollectionIndexByRoot(children[0]->GetEntity()); ix != -1) {
                        scene_->GetSubCollection(ix)->SetUri(name);
                    }
                }
            }
        }
        // Experimentals: Subcollection root (will not traverse further, the rest should go through normal property
        // serialization)
    }
}

// Clone the entity, reference will be stored
CORE_NS::Entity SceneHolder::CloneEntity(CORE_NS::Entity entity, const BASE_NS::string& name, bool storeWithUniqueId)
{
    CORE_NS::Entity ret {};

    if (ecs_ && scene_) {
        ret = ecs_->GetEntityManager().Create();
        CORE_NS::CloneComponents(*ecs_, entity, *ecs_, ret);
        RenameEntity(ret, name);
        // when cloning, we trust that implementation uses unique name so no padding required
        scene_->AddEntityToSubcollection("cloned_entities", name, ret, storeWithUniqueId);
    }
    return ret;
}

void SceneHolder::DestroyEntity(CORE_NS::Entity entity)
{
    // Destroy created materials & meshes here.
    auto meshCollectionIndex = scene_->GetSubCollectionIndex("GLTF_Meshes");
    if (meshCollectionIndex != -1) {
        auto meshCollection = scene_->GetSubCollection(meshCollectionIndex);
        if (meshCollection->Contains(entity)) {
            auto ref = meshCollection->GetReference(entity);
            meshCollection->RemoveEntity(ref);
        }
    }

    auto materialCollectionIndex = scene_->GetSubCollectionIndex("GLTF_Materials");
    if (materialCollectionIndex != -1) {
        auto materialCollection = scene_->GetSubCollection(materialCollectionIndex);
        if (materialCollection->Contains(entity)) {
            auto ref = materialCollection->GetReference(entity);
            materialCollection->RemoveEntity(ref);
        }
    }
    scene_->RemoveEntityRecursive(entity);
}

void SceneHolder::SetEntityActive(CORE_NS::Entity entity, bool active)
{
    ecs_->GetEntityManager().SetActive(entity, active);
}

bool SceneHolder::ReparentEntity(CORE_NS::Entity entity, const BASE_NS::string& parentPath, size_t index)
{
    auto& root = nodeSystem_->GetRootNode();

    auto node = nodeSystem_->GetNode(entity);
    if (!node) {
        CORE_LOG_W("SceneHolder::ReparentEntity, Failed to find node from entity.");
        return false;
    }

    auto parentNode = root.LookupNodeByPath(parentPath);
    if (!parentNode) {
        if (parentPath == "/" || parentPath.empty()) {
            parentNode = &root;
        } else {
            CORE_LOG_W("SceneHolder::ReparentEntity, Failed to find parent node '%s'", parentPath.c_str());
            return false;
        }
    }

    if (parentNode != node->GetParent()) {
        if (index != SIZE_MAX) {
            parentNode->InsertChild(index, *node);
        } else {
            parentNode->AddChild(*node);
        }
    }

    return true;
}

const CORE3D_NS::ISceneNode* SceneHolder::ReparentEntity(const BASE_NS::string& parentPath, const BASE_NS::string& name)
{
    if (ecs_) {
        const auto& root = nodeSystem_->GetRootNode();
        auto ecsNode = root.LookupNodeByPath(name);
        auto parentNode = root.LookupNodeByPath(parentPath);

        if (!ecsNode && parentNode) {
            if (ecsNode = parentNode->LookupNodeByPath(name); !ecsNode) {
                CORE_LOG_W("Could not find: '%s', tried root and parent '%s'", name.c_str(), parentPath.c_str());
            }
        } else if (parentNode && parentNode != ecsNode) { // prefabs may get have their path pointing them self
                                                          // before they are positioned into scene
            const_cast<CORE3D_NS::ISceneNode*>(ecsNode)->SetParent(*parentNode);
            SCENE_PLUGIN_VERBOSE_LOG("reparenting '%s' to '%s'", name.c_str(), parentPath.c_str());
        } else if (!parentPath.empty() && parentPath != "/") {
            CORE_LOG_W("Could not find parent '%s'", parentPath.c_str());
            // Even parent is not found, we can still activate the bindings, still we could
            // reschedule retry here
        }
        return ecsNode;
    }
    return {};
}

void SceneHolder::SetMesh(CORE_NS::Entity targetEntity, CORE_NS::Entity mesh)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity) && EntityUtil::IsValid(mesh)) {
            // ToDo: should perhaps generate render mesh component for entity if it does not exist yet?

            if (!renderMeshComponentManager_->HasComponent(targetEntity)) {
                renderMeshComponentManager_->Create(targetEntity);
            }

            if (auto handle = renderMeshComponentManager_->Write(targetEntity)) {
                handle->mesh = mesh;
            }
        }
    }
}

CORE_NS::Entity SceneHolder::GetMaterial(CORE_NS::Entity meshEntity, int64_t submeshIndex)
{
    CORE_NS::Entity material;
    if (ecs_) {
        if (EntityUtil::IsValid(meshEntity)) {
            if (auto handle = meshComponentManager_->Read(meshEntity)) {
                if (submeshIndex >= 0 && submeshIndex < handle->submeshes.size()) {
                    material = handle->submeshes[submeshIndex].material;
                }
            }
        }
    }
    return material;
}

BASE_NS::string_view SceneHolder::GetMaterialName(CORE_NS::Entity meshEntity, int64_t submeshIndex)
{
    BASE_NS::string_view entityName;
    auto entity = GetMaterial(meshEntity, submeshIndex);

    if (!GetEntityId(entity, entityName, *scene_.get(), "GLTF_Materials", *nameComponentManager_)) {
        CORE_LOG_W("%s: could not find material", __func__);
    }

    return entityName;
}

BASE_NS::string_view SceneHolder::GetMeshName(CORE_NS::Entity referringEntity)
{
    BASE_NS::string_view entityName;

    if (EntityUtil::IsValid(referringEntity)) {
        CORE_NS::Entity meshEntity;

        if (renderMeshComponentManager_->HasComponent(referringEntity)) {
            if (auto handle = renderMeshComponentManager_->Read(referringEntity)) {
                meshEntity = handle->mesh;
            }
        } else {
            CORE_LOG_W("%s: could not find mesh from entity", __func__);
        }
        if (!GetEntityId(meshEntity, entityName, *scene_.get(), "GLTF_Meshes", *nameComponentManager_)) {
            CORE_LOG_W("%s: could not find valid mesh", __func__);
        }
    }
    return entityName;
}

void SceneHolder::SetMaterial(CORE_NS::Entity targetEntity, CORE_NS::Entity material, int64_t submeshIndex)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity)) {
            // ToDo: should perhaps generate mesh component for entity if it does not exist yet?

            if (auto handle = meshComponentManager_->Write(targetEntity)) {
                if (submeshIndex == -1) {
                    for (auto&& submesh : handle->submeshes) {
                        submesh.material = material;
                    }
                } else if (submeshIndex >= 0 && submeshIndex < handle->submeshes.size()) {
                    handle->submeshes[submeshIndex].material = material;
                }
            }
        }
    }
}

CORE_NS::EntityReference SceneHolder::BindUIBitmap(SCENE_NS::IBitmap::Ptr bitmap, bool createNew)
{
    if (ecs_) {
        BASE_NS::string uri;
        RENDER_NS::RenderHandleReference imageHandle {};

        // Need two things, uri
        if (auto uriBmp = interface_pointer_cast<SCENE_NS::IBitmap>(bitmap)) {
            uri = uriBmp->Uri()->GetValue();
        } else {
            uri = interface_pointer_cast<META_NS::IObjectInstance>(bitmap)->GetInstanceId().ToString();
        }

        // And concrete handle to data
        if (auto lumeBmp = interface_pointer_cast<SCENE_NS::IBitmap>(bitmap)) {
            imageHandle = lumeBmp->GetRenderHandle();
        }

        if (imageHandle) {
            // check if we have existing resource
            CORE_NS::Entity existing;
            if (FindResource(uri, uri, existing)) {
                auto hande = rhComponentManager_->Get(existing);
                hande.reference = imageHandle;
                rhComponentManager_->Set(existing, hande);

                return ecs_->GetEntityManager().GetReferenceCounted(existing);
            }

            if (!createNew) {
                return {};
            }

            // if not, create new one
            EntityReference entity = ecs_->GetEntityManager().CreateReferenceCounted();

            nameComponentManager_->Create(entity);
            auto component = nameComponentManager_->Get(entity);
            component.name = uri;
            nameComponentManager_->Set(entity, component);

            // Not sure if we should do this, somehow we need to keep the entity alive
            // with proper uri it could be found afterwards
            auto& subcollection = scene_->AddSubCollection(uri, "bitmap://");
            subcollection.AddEntity(entity);

            // Or this. We should perhaps use URI component more
            rhComponentManager_->Create(entity);
            auto hande = rhComponentManager_->Get(entity);
            hande.reference = imageHandle;
            rhComponentManager_->Set(entity, hande);
            return entity;
        }
    }

    return {};
}

void SceneHolder::SetTexture(size_t index, CORE_NS::Entity targetEntity, CORE_NS::EntityReference imageEntity)
{
    if (ecs_) {
        if (auto handle = materialComponentManager_->Write(targetEntity)) {
            handle->textures[index].image = imageEntity;
        }
    }
}

BASE_NS::string_view ResolveSamplerUri(SCENE_NS::ITextureInfo::SamplerId samplerId)
{
    switch (samplerId) {
        case SCENE_NS::ITextureInfo::CORE_DEFAULT_SAMPLER_NEAREST_REPEAT:
            return "engine://CORE_DEFAULT_SAMPLER_NEAREST_REPEAT";
        case SCENE_NS::ITextureInfo::CORE_DEFAULT_SAMPLER_NEAREST_CLAMP:
            return "engine://CORE_DEFAULT_SAMPLER_NEAREST_CLAMP";
        case SCENE_NS::ITextureInfo::CORE_DEFAULT_SAMPLER_LINEAR_REPEAT:
            return "engine://CORE_DEFAULT_SAMPLER_LINEAR_REPEAT";
        case SCENE_NS::ITextureInfo::CORE_DEFAULT_SAMPLER_LINEAR_CLAMP:
            return "engine://CORE_DEFAULT_SAMPLER_LINEAR_CLAMP";
        case SCENE_NS::ITextureInfo::CORE_DEFAULT_SAMPLER_LINEAR_MIPMAP_REPEAT:
            return "engine://CORE_DEFAULT_SAMPLER_LINEAR_MIPMAP_REPEAT";
        case SCENE_NS::ITextureInfo::CORE_DEFAULT_SAMPLER_LINEAR_MIPMAP_CLAMP:
            return "engine://CORE_DEFAULT_SAMPLER_LINEAR_MIPMAP_CLAMP";
        default:
            CORE_LOG_W("%s: unable to find sampler uri for: %d", __func__, samplerId);
    }

    return "";
}

static constexpr size_t ENGINE_URI_PREFIX_LEN = BASE_NS::string_view("engine://").size();

SCENE_NS::IShader::Ptr SceneHolder::GetShader(CORE_NS::Entity materialEntity, ShaderType type)
{
    // Resolve render handle from material.
    if (!ecs_) {
        return {};
    }

    if (!EntityUtil::IsValid(materialEntity)) {
        return {};
    }

    RENDER_NS::RenderHandleReference shaderHandleRef;

    EntityReference shaderEntityRef {};
    if (auto readHandle = materialComponentManager_->Read(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            shaderEntityRef = readHandle->materialShader.shader;
        } else if (type == ShaderType::DEPTH_SHADER) {
            shaderEntityRef = readHandle->depthShader.shader;
        }
    }

    if (shaderEntityRef) {
        auto rh = rhComponentManager_->GetRenderHandleReference(shaderEntityRef);
        if (RENDER_NS::RenderHandleUtil::IsValid(rh.GetHandle())) {
            auto uri = GetHandleUri(rh, HANDLE_TYPE_SHADER);
            if (!uri.empty()) {
                auto shader = SCENE_NS::Shader();

                auto shaderInterface = interface_pointer_cast<SCENE_NS::IShader>(shader);
                SetValue(shaderInterface->Uri(), uri);

                return shader;
            }
        }
    }

    return {};
}

SCENE_NS::IGraphicsState::Ptr SceneHolder::GetGraphicsState(CORE_NS::Entity materialEntity, ShaderType type)
{
    // Resolve render handle from material.
    if (!ecs_) {
        return {};
    }

    if (!EntityUtil::IsValid(materialEntity)) {
        return {};
    }

    RENDER_NS::RenderHandleReference shaderHandleRef;

    EntityReference stateEntityRef {};
    if (auto readHandle = materialComponentManager_->Read(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            stateEntityRef = readHandle->materialShader.graphicsState;
        } else if (type == ShaderType::DEPTH_SHADER) {
            stateEntityRef = readHandle->depthShader.graphicsState;
        }
    }

    if (stateEntityRef) {
        auto rh = rhComponentManager_->GetRenderHandleReference(stateEntityRef);
        if (RENDER_NS::RenderHandleUtil::IsValid(rh.GetHandle())) {
            auto uri = GetHandleUri(rh);
            if (!uri.empty()) {
                auto state = SCENE_NS::GraphicsState();

                auto interface = interface_pointer_cast<SCENE_NS::IGraphicsState>(state);

                // The uri contains either .shader or .shadergs.
                BASE_NS::string extension = ".shadergs";
                if (uri.find(extension) == BASE_NS::string::npos) {
                    extension = ".shader";
                }

                // Split the uri to uri and variant.
                auto ix = uri.find_last_of(extension);
                if (ix != BASE_NS::string_view::npos && ix < uri.size() - 1) {
                    SetValue(interface->Uri(), BASE_NS::string(uri.substr(0, ix + 1)));
                    SetValue(interface->Variant(), BASE_NS::string(uri.substr(ix + 1)));
                    SCENE_PLUGIN_VERBOSE_LOG("Got graphics state: %s variant: %s",
                        META_NS::GetValue(interface->Uri()).c_str(), META_NS::GetValue(interface->Variant()).c_str());
                } else {
                    SetValue(interface->Uri(), uri);
                    SetValue(interface->Variant(), "");
                }

                if (auto shRef = interface_cast<ISceneHolderRef>(state)) {
                    shRef->SetSceneHolder(me_);
                    shRef->SetIndex(type);
                }

                return state;
            }
        }
    }

    return {};
}

void SceneHolder::SetGraphicsState(
    CORE_NS::Entity materialEntity, ShaderType type, const RENDER_NS::GraphicsState& state)
{
    if (!ecs_) {
        return;
    }

    if (!EntityUtil::IsValid(materialEntity)) {
        return;
    }

    CORE_NS::EntityReference entityRef;
    if (auto readHandle = materialComponentManager_->Read(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            entityRef = readHandle->materialShader.graphicsState;
        } else if (type == ShaderType::DEPTH_SHADER) {
            entityRef = readHandle->depthShader.graphicsState;
        }
    }

    auto rh = rhComponentManager_->GetRenderHandleReference(entityRef);
    if (RENDER_NS::RenderHandleUtil::IsValid(rh.GetHandle())) {
        auto& engineShaderManager = renderContext_->GetDevice().GetShaderManager();
        auto hash = engineShaderManager.HashGraphicsState(state);
        auto currentState = engineShaderManager.GetGraphicsState(rh);
        if (hash != engineShaderManager.HashGraphicsState(currentState)) {
            auto desc = engineShaderManager.GetIdDesc(rh);
            engineShaderManager.CreateGraphicsState({ desc.path, state });
        }
    }
}

bool SceneHolder::GetGraphicsState(
    CORE_NS::Entity materialEntity, ShaderType type, const SCENE_NS::IShaderGraphicsState::Ptr& ret)
{
    if (!ecs_) {
        return false;
    }

    if (!EntityUtil::IsValid(materialEntity)) {
        return false;
    }

    CORE_NS::EntityReference entityRef;
    if (auto readHandle = materialComponentManager_->Read(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            entityRef = readHandle->materialShader.graphicsState;
        } else if (type == ShaderType::DEPTH_SHADER) {
            entityRef = readHandle->depthShader.graphicsState;
        }
    }
    auto rh = rhComponentManager_->GetRenderHandleReference(entityRef);
    if (RENDER_NS::RenderHandleUtil::IsValid(rh.GetHandle())) {
        auto& engineShaderManager = renderContext_->GetDevice().GetShaderManager();
        auto state = engineShaderManager.GetGraphicsState(rh);
        if (auto typed = interface_cast<SCENE_NS::IPendingRequestData<RENDER_NS::GraphicsState>>(ret)) {
            typed->Add(state);
            return true;
        }
    }
    return false;
}

void SceneHolder::SetShader(CORE_NS::Entity materialEntity, ShaderType type, SCENE_NS::IShader::Ptr shader)
{
    if (!ecs_) {
        return;
    }

    if (!EntityUtil::IsValid(materialEntity)) {
        return;
    }

    EntityReference shaderEntityRef {};
    RenderHandleReference rh {};

    auto& engineShaderManager = renderContext_->GetDevice().GetShaderManager();
    if (shader) {
        rh = shader->GetRenderHandleReference(engineShaderManager);
        auto uri = META_NS::GetValue(shader->Uri());

        if (RenderHandleUtil::IsValid(rh.GetHandle())) {
            shaderEntityRef = GetOrCreateEntityReference(ecs_->GetEntityManager(), *rhComponentManager_, rh);
            // Studio used to update also uri component, maybe someone else should do this
            // if needed to begin with
            if (!uriComponentManager_->HasComponent(shaderEntityRef)) {
                uriComponentManager_->Create(shaderEntityRef);
            }
            if (auto handle = uriComponentManager_->Write(shaderEntityRef)) {
                handle->uri = uri;
            }
        } else {
            CORE_LOG_W("Failed to set shader, invalid render handle: %s", uri.c_str());
            return;
        }
        if (auto shref = interface_cast<ISceneHolderRef>(shader)) {
            shref->SetSceneHolder(me_);
            shref->SetIndex(type);
        }
    }

    // Only writing the value if it has changed.
    bool valueChanged = false;

    if (auto readHandle = materialComponentManager_->Read(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            valueChanged = readHandle->materialShader.shader != shaderEntityRef;
        } else if (type == ShaderType::DEPTH_SHADER) {
            valueChanged = readHandle->depthShader.shader != shaderEntityRef;
        }
    }

    if (!valueChanged) {
        return;
    }

    if (auto writeHandle = materialComponentManager_->Write(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            writeHandle->materialShader.shader = shaderEntityRef;
            if (!writeHandle->materialShader.graphicsState) {
                // initialize the graphics state handle, so we can resolve it later
                if (auto graphicsStateHandle = engineShaderManager.GetGraphicsStateHandleByShaderHandle(rh)) {
                    writeHandle->materialShader.graphicsState =
                        GetOrCreateEntityReference(ecs_->GetEntityManager(), *rhComponentManager_, graphicsStateHandle);
                }
            }
        } else if (type == ShaderType::DEPTH_SHADER) {
            writeHandle->depthShader.shader = shaderEntityRef;
            if (!writeHandle->depthShader.graphicsState) {
                if (auto graphicsStateHandle = engineShaderManager.GetGraphicsStateHandleByShaderHandle(rh)) {
                    writeHandle->depthShader.graphicsState =
                        GetOrCreateEntityReference(ecs_->GetEntityManager(), *rhComponentManager_, graphicsStateHandle);
                }
            }
        }
    }

    ProcessEvents();
}

void SceneHolder::SetGraphicsState(CORE_NS::Entity materialEntity, ShaderType type, SCENE_NS::IGraphicsState::Ptr state)
{
    if (!ecs_) {
        return;
    }

    if (!EntityUtil::IsValid(materialEntity)) {
        return;
    }

    EntityReference stateEntityRef {};
    if (state) {
        auto& engineShaderManager = renderContext_->GetDevice().GetShaderManager();
        auto rh = state->GetRenderHandleReference(engineShaderManager);

        if (RenderHandleUtil::IsValid(rh.GetHandle())) {
            auto uri = META_NS::GetValue(state->Uri());
            auto variant = META_NS::GetValue(state->Variant());

            stateEntityRef = GetOrCreateEntityReference(ecs_->GetEntityManager(), *rhComponentManager_, rh);
            // Studio used to update also uri component, maybe someone else should do this
            // if needed to begin with
            if (!uriComponentManager_->HasComponent(stateEntityRef)) {
                uriComponentManager_->Create(stateEntityRef);
            }
            if (auto handle = uriComponentManager_->Write(stateEntityRef)) {
                handle->uri = uri.append(variant);
            }
        } else {
            CORE_LOG_W("Failed to set shader, invalid render handle: %s", META_NS::GetValue(state->Uri()).c_str());
            return;
        }
        if (auto shref = interface_cast<ISceneHolderRef>(state)) {
            shref->SetSceneHolder(me_);
            shref->SetIndex(type);
        }
    }

    // Only writing the value if it has changed.
    bool valueChanged = false;

    if (auto readHandle = materialComponentManager_->Read(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            valueChanged = readHandle->materialShader.graphicsState != stateEntityRef;
        } else if (type == ShaderType::DEPTH_SHADER) {
            valueChanged = readHandle->depthShader.graphicsState != stateEntityRef;
        }
    }

    if (!valueChanged) {
        return;
    }

    if (auto writeHandle = materialComponentManager_->Write(materialEntity)) {
        if (type == ShaderType::MATERIAL_SHADER) {
            writeHandle->materialShader.graphicsState = stateEntityRef;
        } else if (type == ShaderType::DEPTH_SHADER) {
            writeHandle->depthShader.graphicsState = stateEntityRef;
        }
    }

    ProcessEvents();
}

BASE_NS::string SceneHolder::GetHandleUri(RENDER_NS::RenderHandleReference renderHandleReference, UriHandleType type)
{
    if (ecs_ && renderContext_) {
        auto& device = renderContext_->GetDevice();

        auto& shaderManager = device.GetShaderManager();

        if ((type == HANDLE_TYPE_SHADER && shaderManager.IsShader(renderHandleReference)) ||
            (type == HANDLE_TYPE_DO_NOT_CARE)) {
            auto desc = shaderManager.GetIdDesc(renderHandleReference);
            return desc.path;
        }
    }
    return BASE_NS::string();
}

CORE_NS::Entity SceneHolder::LoadSampler(BASE_NS::string_view uri)
{
    CORE_NS::Entity ret;
    if (ecs_ && renderContext_) {
        const auto name = uri.substr(ENGINE_URI_PREFIX_LEN);
        auto linearHandle = renderContext_->GetDevice().GetGpuResourceManager().GetSamplerHandle(name);

        auto entity = rhComponentManager_->GetEntityWithReference(linearHandle);
        if (!EntityUtil::IsValid(entity)) {
            // No existing sampler found, prepare one
            auto uriManager = GetManager<CORE3D_NS::IUriComponentManager>(*ecs_);
            entity = ecs_->GetEntityManager().Create();

            uriManager->Create(entity);
            uriManager->Write(entity)->uri = uri;

            rhComponentManager_->Create(entity);
            rhComponentManager_->Write(entity)->reference = linearHandle;

            RenameEntity(entity, BASE_NS::string(name.data(), name.size()));
            scene_->AddEntityToSubcollection("samplers", name, entity, false);
        }
        ret = entity;
    }

    return ret;
}

CORE_NS::EntityReference SceneHolder::LoadImage(BASE_NS::string_view uri, RENDER_NS::RenderHandleReference rh)
{
    CORE_NS::Entity ret;
    if (FindResource(uri, uri, ret)) {
        return ecs_->GetEntityManager().GetReferenceCounted(ret);
    }

    if (scene_ && assetManager_) {
        RENDER_NS::RenderHandleReference imageHandle;
        if (rh) {
            imageHandle = rh;
        } else {
            imageHandle = assetManager_->GetEcsSerializer().LoadImageResource(uri);
        }
        if (imageHandle) {
            return GetOrCreateEntityReference(ecs_->GetEntityManager(), *rhComponentManager_, imageHandle);
        }
    }

    return {};
}

void SceneHolder::SetSampler(size_t index, CORE_NS::Entity targetEntity, SCENE_NS::ITextureInfo::SamplerId samplerId)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity)) {
            bool wrote = false;
            if (auto handle = materialComponentManager_->Write(targetEntity)) {
                auto entity = LoadSampler(ResolveSamplerUri(samplerId));
                if (EntityUtil::IsValid(entity)) {
                    // both scene and texture array will hold a reference to entity
                    handle->textures[index].sampler = ecs_->GetEntityManager().GetReferenceCounted(entity);
                    wrote = true;
                }
            }
            if (wrote) {
                ProcessEvents();
            }
        }
    }
}

void SceneHolder::SetSubmeshRenderSortOrder(CORE_NS::Entity targetEntity, int64_t submeshIndex, uint8_t value)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity)) {
            bool wrote = false;
            if (auto handle = meshComponentManager_->Write(targetEntity)) {
                if (submeshIndex >= 0 && submeshIndex < handle->submeshes.size()) {
                    handle->submeshes[submeshIndex].renderSortLayerOrder = value;
                    wrote = true;
                }
            }
            if (wrote) {
                ProcessEvents();
            }
        }
    }
}

void SceneHolder::SetSubmeshAABBMin(CORE_NS::Entity targetEntity, int64_t submeshIndex, const BASE_NS::Math::Vec3& vec)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity)) {
            bool wrote = false;
            if (auto handle = meshComponentManager_->Write(targetEntity)) {
                if (submeshIndex >= 0 && submeshIndex < handle->submeshes.size()) {
                    handle->submeshes[submeshIndex].aabbMin = vec;
                    handle->aabbMin = min(handle->aabbMin, vec);
                    wrote = true;
                }
            }
            if (wrote) {
                ProcessEvents();
            }
        }
    }
}

void SceneHolder::RemoveSubmesh(CORE_NS::Entity targetEntity, int64_t submeshIndex)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity)) {
            bool wrote = false;
            if (auto handle = meshComponentManager_->Write(targetEntity)) {
                if (submeshIndex < 0) {
                    handle->submeshes.clear();
                    handle->aabbMin = { 0.f, 0.f, 0.f };
                    handle->aabbMax = { 0.f, 0.f, 0.f };
                    wrote = true;
                } else if (submeshIndex < handle->submeshes.size()) {
                    handle->submeshes.erase(handle->submeshes.begin() + submeshIndex);
                    for (const auto& submesh : handle->submeshes) {
                        handle->aabbMin = BASE_NS::Math::min(handle->aabbMin, submesh.aabbMin);
                        handle->aabbMax = BASE_NS::Math::max(handle->aabbMax, submesh.aabbMax);
                    }
                    wrote = true;
                }
            }
            if (wrote) {
                ProcessEvents();
            }
        }
    }
}

void SceneHolder::SetSubmeshAABBMax(CORE_NS::Entity targetEntity, int64_t submeshIndex, const BASE_NS::Math::Vec3& vec)
{
    if (ecs_) {
        if (EntityUtil::IsValid(targetEntity)) {
            bool wrote = false;
            if (auto handle = meshComponentManager_->Write(targetEntity)) {
                if (submeshIndex >= 0 && submeshIndex < handle->submeshes.size()) {
                    handle->submeshes[submeshIndex].aabbMax = vec;
                    handle->aabbMax = max(handle->aabbMax, vec);
                    wrote = true;
                }
            }
            if (wrote) {
                ProcessEvents();
            }
        }
    }
}

void SceneHolder::EnableEnvironmentComponent(CORE_NS::Entity entity)
{
    if (ecs_) {
        if (EntityUtil::IsValid(entity)) {
            if (!envComponentManager_->HasComponent(entity)) {
                envComponentManager_->Create(entity);
            }
        }
    }
}

void SceneHolder::EnableLayerComponent(CORE_NS::Entity entity)
{
    if (ecs_) {
        if (EntityUtil::IsValid(entity)) {
            if (!layerComponentManager_->HasComponent(entity)) {
                layerComponentManager_->Create(entity);
            }
        }
    }
}

void SceneHolder::EnableLightComponent(CORE_NS::Entity entity)
{
    if (ecs_) {
        if (EntityUtil::IsValid(entity)) {
            if (!lightComponentManager_->HasComponent(entity)) {
                lightComponentManager_->Create(entity);
            }
        }
    }
}

template<typename T>
constexpr inline CORE3D_NS::IMeshBuilder::DataBuffer FillData(array_view<const T> c) noexcept
{
    Format format = BASE_FORMAT_UNDEFINED;
    if constexpr (is_same_v<T, Math::Vec2>) {
        format = BASE_FORMAT_R32G32_SFLOAT;
    } else if constexpr (is_same_v<T, Math::Vec3>) {
        format = BASE_FORMAT_R32G32B32_SFLOAT;
    } else if constexpr (is_same_v<T, Math::Vec4>) {
        format = BASE_FORMAT_R32G32B32A32_SFLOAT;
    } else if constexpr (is_same_v<T, uint16_t>) {
        format = BASE_FORMAT_R16_UINT;
    } else if constexpr (is_same_v<T, uint32_t>) {
        format = BASE_FORMAT_R32_UINT;
    }
    return CORE3D_NS::IMeshBuilder::DataBuffer { format, sizeof(T),
        { reinterpret_cast<const uint8_t*>(c.data()), c.size() * sizeof(T) } };
}

template<typename IndicesType>
CORE_NS::Entity SceneHolder::CreateMeshFromArrays(const BASE_NS::string& name,
    SCENE_NS::MeshGeometryArrayPtr<IndicesType> arrays, RENDER_NS::IndexType indexType, Entity existingEntity,
    bool append)
{
    if (!ecs_) {
        CORE_LOG_W("%s: no ecs, cannot create mesh", __func__);
        return {};
    }

    if (!arrays || arrays->size() == 0) {
        if (EntityUtil::IsValid(existingEntity)) {
            RemoveSubmesh(existingEntity, -1);
            return existingEntity;
        } else {
            // create empty, submeshes may follow
            auto entity = ecs_->GetEntityManager().Create();

            RenameEntity(entity, name);

            meshComponentManager_->Create(entity);
            scene_->AddEntityToSubcollection("created_meshes", name, entity);
            return entity;
        }
    }

    if (EntityUtil::IsValid(existingEntity) && !append) {
        RemoveSubmesh(existingEntity, -1);
    }

    size_t subMeshIndex = 0;
    auto meshBuilder = CORE_NS::CreateInstance<CORE3D_NS::IMeshBuilder>(*renderContext_, CORE3D_NS::UID_MESH_BUILDER);

    RENDER_NS::IShaderManager& shaderManager = renderContext_->GetDevice().GetShaderManager();
    const RENDER_NS::VertexInputDeclarationView vertexInputDeclaration =
        shaderManager.GetVertexInputDeclarationView(shaderManager.GetVertexInputDeclarationHandle(
            CORE3D_NS::DefaultMaterialShaderConstants::VERTEX_INPUT_DECLARATION_FORWARD));

    meshBuilder->Initialize(vertexInputDeclaration, 1);

    for (auto&& geometry : *arrays.get()) {
        CORE3D_NS::IMeshBuilder::Submesh submesh;

        submesh.indexType = indexType;
        submesh.vertexCount = static_cast<uint32_t>(geometry->vertices.size());
        submesh.indexCount = static_cast<uint32_t>(geometry->indices.size());
        submesh.tangents = geometry->generateTangents;

        meshBuilder->AddSubmesh(submesh);
    }
    meshBuilder->Allocate();

    for (auto&& geometry : *arrays.get()) {
        meshBuilder->SetVertexData(subMeshIndex, FillData<BASE_NS::Math::Vec3>(geometry->vertices),
            FillData<BASE_NS::Math::Vec3>(geometry->normals), FillData<BASE_NS::Math::Vec2>(geometry->uvs),
            FillData<BASE_NS::Math::Vec2>(geometry->uv2s), FillData<BASE_NS::Math::Vec4>(geometry->tangents),
            FillData<BASE_NS::Math::Vec4>(geometry->colors));
        meshBuilder->CalculateAABB(subMeshIndex, FillData<BASE_NS::Math::Vec3>(geometry->vertices));
        meshBuilder->SetIndexData(subMeshIndex, FillData<IndicesType>(geometry->indices));
    }

    auto entity = meshBuilder->CreateMesh(*ecs_);

    if (EntityUtil::IsValid(existingEntity)) {
        for (size_t ii = 0; ii < arrays->size(); ii++) {
            CopySubMesh(existingEntity, entity, ii);
        }
        ecs_->GetEntityManager().Destroy(entity);
        return existingEntity;
    }

    RenameEntity(entity, name);
    scene_->AddEntityToSubcollection("created_meshes", name, entity);

    ProcessEvents();
    return entity;
}

// we rely that someone else will ret up correct flags to components
void SceneHolder::SetMultiviewCamera(CORE_NS::Entity target, CORE_NS::Entity source)
{
    if (!ecs_ || !EntityUtil::IsValid(target) || !EntityUtil::IsValid(source) ||
        !cameraComponentManager_->HasComponent(source) || !cameraComponentManager_->HasComponent(target)) {
        CORE_LOG_W("%s: camera component not valid", __func__);
        return;
    }
    if (auto handle = cameraComponentManager_->Write(target)) {
        for (auto& ref : handle->multiViewCameras) {
            if (ref.id == target.id) {
                return;
            }
        }
        handle->multiViewCameras.push_back(source);
    }
}

// we rely that someone else will ret up correct flags to components
void SceneHolder::RemoveMultiviewCamera(CORE_NS::Entity target, CORE_NS::Entity source)
{
    if (!ecs_ || !EntityUtil::IsValid(target) || !EntityUtil::IsValid(source) ||
        !cameraComponentManager_->HasComponent(source) || !cameraComponentManager_->HasComponent(target)) {
        CORE_LOG_W("%s: camera component not valid", __func__);
        return;
    }
    if (auto handle = cameraComponentManager_->Write(target)) {
        for (size_t ii = 0; ii < handle->multiViewCameras.size(); ii++) {
            if (handle->multiViewCameras[ii] == target) {
                handle->multiViewCameras.erase(handle->multiViewCameras.cbegin() + ii);
                return;
            }
        }
    }
}

void SceneHolder::CopySubMesh(CORE_NS::Entity target, CORE_NS::Entity source, size_t index)
{
    if (!ecs_ || !EntityUtil::IsValid(target) || !EntityUtil::IsValid(source) ||
        !meshComponentManager_->HasComponent(source)) {
        CORE_LOG_W("%s: cannot copy submesh", __func__);
        return;
    }

    bool wrote = false;
    if (auto sourceComponent = meshComponentManager_->Read(source)) {
        if (sourceComponent->submeshes.size() > index) {
            if (!meshComponentManager_->HasComponent(target)) {
                meshComponentManager_->Create(target);
            }
            if (auto targetComponent = meshComponentManager_->Write(target)) {
                targetComponent->submeshes.push_back(CORE3D_NS::MeshComponent::Submesh());
                // Todo: verify if copy by assignment is enough, or do we need deep copy
                // and explicit reference modifications
                targetComponent->submeshes.back() = sourceComponent->submeshes.at(index);
                for (const auto& submesh : targetComponent->submeshes) {
                    targetComponent->aabbMin = BASE_NS::Math::min(targetComponent->aabbMin, submesh.aabbMin);
                    targetComponent->aabbMax = BASE_NS::Math::max(targetComponent->aabbMax, submesh.aabbMax);
                }
                wrote = true;
            }
        }
    }
    if (wrote) {
        ProcessEvents();
    }
}

void SceneHolder::ReleaseOwnership(CORE_NS::Entity entity)
{
    if (ecs_ && scene_) {
        if (EntityUtil::IsValid(entity)) {
            if (const auto cachedEntity = FindCachedRelatedEntity(entity);
                EntityUtil::IsValid(cachedEntity) && entity != cachedEntity) {
                SCENE_PLUGIN_VERBOSE_LOG("%s: Cached entity does not match: entity: %I64u, cachedEntity: %I64u",
                    __func__, entity.id, cachedEntity.id);
                if (auto cachedIdx = scene_->GetSubCollectionIndexByRoot(cachedEntity); cachedIdx != -1) {
                    scene_->GetSubCollection(cachedIdx)->SetActive(false);
                    scene_->RemoveEntityRecursive(cachedEntity);
                }
            }
            scene_->RemoveEntityRecursive(entity);
        }
    }
}

// Reposition a node within its parent
void SceneHolder::ReindexEntity(CORE_NS::Entity target, size_t index)
{
    if (ecs_ && scene_ && EntityUtil::IsValid(target)) {
        // Get the node
        if (auto node = nodeSystem_->GetNode(target)) {
            // Get the parent
            if (auto parent = node->GetParent()) {
                parent->RemoveChild(*node);
                parent->InsertChild(index, *node);
            }
        }

        // do we need to adjust also collection manually (it should be reference only)
        scene_->MarkModified(true, true);
    }
}

template CORE_NS::Entity SceneHolder::CreateMeshFromArrays<uint16_t>(const BASE_NS::string& name,
    SCENE_NS::MeshGeometryArrayPtr<uint16_t> arrays, RENDER_NS::IndexType indexType, Entity existingEntity,
    bool append);

template CORE_NS::Entity SceneHolder::CreateMeshFromArrays<uint32_t>(const BASE_NS::string& name,
    SCENE_NS::MeshGeometryArrayPtr<uint32_t> arrays, RENDER_NS::IndexType indexType, Entity existingEntity,
    bool append);

string SceneHolder::GetUniqueName()
{
    return instanceId_.ToString().append(to_string(++instanceNumber_));
}

// Enable new multi-mesh batch
CORE_NS::Entity SceneHolder::CreateMultiMeshInstance(CORE_NS::Entity baseComponent)
{
    if (ecs_) {
        if (!nodeSystem_->GetNode(baseComponent)) {
            CORE_LOG_I("%s: selected base entity does not have node on ecs", __func__);

            // Now, the assumption is that entity should have either RenderMeshComponent or MeshComponent
            // It is bit open if it has render mesh component, shoud we copy its mesh data implicitly
            CORE3D_NS::RenderMeshComponent renderMeshData;

            if (auto data = renderMeshComponentManager_->Read(baseComponent)) {
                renderMeshData = *data;
            }

            auto node = nodeSystem_->CreateNode();
            auto nodeEntity = node->GetEntity();

            renderMeshComponentManager_->Create(nodeEntity);
            if (auto data = renderMeshComponentManager_->Write(nodeEntity)) {
                *data = renderMeshData;

                if (!EntityUtil::IsValid(data->mesh)) {
                    // base component may have mesh component, or then it does not
                    data->mesh = baseComponent;
                }
            }
            baseComponent = nodeEntity;
        }

        if (!renderMeshComponentManager_->HasComponent(baseComponent)) {
            renderMeshComponentManager_->Create(baseComponent);
        }
    }

    return baseComponent;
}

static constexpr size_t MULTI_MESH_CHILD_PREFIX_LEN = MULTI_MESH_CHILD_PREFIX.size();

bool SceneHolder::IsMultiMeshChild(const CORE3D_NS::ISceneNode* child)
{
    auto entity = child->GetEntity();
    if (auto nameHandle = nameComponentManager_->Read(entity)) {
        auto name = BASE_NS::string_view(nameHandle->name.data(), nameHandle->name.size());
        if (name.compare(0, MULTI_MESH_CHILD_PREFIX_LEN, MULTI_MESH_CHILD_PREFIX) == 0) {
            return true;
        }
    }
    return false;
}

CORE_NS::Entity SceneHolder::FindCachedRelatedEntity(const CORE_NS::Entity& entity)
{
    if (!(scene_ && nodeSystem_ && CORE_NS::EntityUtil::IsValid(entity))) {
        return {};
    }

    CORE_NS::Entity cachedEntity {};
    if (const auto node = nodeSystem_->GetNode(entity)) {
        if (const auto idx = scene_->GetSubCollectionIndex(node->GetName()); idx != -1) {
            cachedEntity = scene_->GetSubCollection(idx)->GetEntity("/");
        }
    }

    return cachedEntity;
}

// Set mesh to multi-mesh
void SceneHolder::SetMeshMultimeshArray(CORE_NS::Entity target, CORE_NS::Entity mesh)
{
    if (ecs_) {
        if (auto data = renderMeshComponentManager_->Write(target)) {
            data->mesh = mesh;
        }

        if (const CORE3D_NS::ISceneNode* parent = nodeSystem_->GetNode(target)) {
            MeshComponent givenData;
            if (auto givenMeshData = meshComponentManager_->Read(mesh)) {
                givenData = *givenMeshData;
            }

            for (auto& child : parent->GetChildren()) {
                auto entity = child->GetEntity();
                if (!IsMultiMeshChild(child)) {
                    continue;
                }

                if (auto data = renderMeshComponentManager_->Read(entity)) {
                    auto mesh = data->mesh;
                    if (auto meshData = meshComponentManager_->Write(mesh)) {
                        *meshData = givenData;
                    }
                }

                if (auto data = renderMeshComponentManager_->Write(entity)) {
                    data->renderMeshBatch = target;
                }
            }
        }
    }
}

void SetAll(CORE_NS::Entity target, CORE_NS::Entity material, BASE_NS::vector<CORE_NS::Entity>& ret,
    CORE3D_NS::IMeshComponentManager* meshComponentManager)
{
    if (EntityUtil::IsValid(target)) {
        if (auto handle = meshComponentManager->Write(target)) {
            for (auto&& submesh : handle->submeshes) {
                ret.push_back(submesh.material);
                submesh.material = material;
            }
        }
    }
}

void ResetAll(CORE_NS::Entity target, BASE_NS::vector<CORE_NS::Entity>& in,
    CORE3D_NS::IMeshComponentManager* meshComponentManager)
{
    if (EntityUtil::IsValid(target)) {
        if (auto handle = meshComponentManager->Write(target)) {
            for (auto&& submesh : handle->submeshes) {
                if (in.size() > 0) {
                    submesh.material = in.front();
                    in.erase(in.begin());
                }
            }
        }
    }
}

// Set override material to multi-mesh
BASE_NS::vector<CORE_NS::Entity> SceneHolder::SetOverrideMaterialMultimeshArray(
    CORE_NS::Entity target, CORE_NS::Entity material)
{
    BASE_NS::vector<CORE_NS::Entity> ret;
    if (ecs_) {
        // if we contain render mesh handle, use it to set material
        if (auto data = renderMeshComponentManager_->Read(target)) {
            auto mesh = data->mesh;
            SetAll(mesh, material, ret, meshComponentManager_);
        }

        // if our child contain meshes, update material on those
        if (const CORE3D_NS::ISceneNode* parent = nodeSystem_->GetNode(target)) {
            for (auto& child : parent->GetChildren()) {
                if (IsMultiMeshChild(child)) {
                    auto entity = child->GetEntity();
                    if (auto data = renderMeshComponentManager_->Read(entity)) {
                        auto mesh = data->mesh;
                        SetAll(mesh, material, ret, meshComponentManager_);
                    }
                }
            }
        }
    }
    return ret;
}

// reset override material from multi-mesh
void SceneHolder::ResetOverrideMaterialMultimeshArray(CORE_NS::Entity target, BASE_NS::vector<CORE_NS::Entity>& in)
{
    if (ecs_) {
        BASE_NS::vector<CORE_NS::Entity> ret;

        // if we contain render mesh handle, use it to set material
        if (auto data = renderMeshComponentManager_->Read(target)) {
            auto mesh = data->mesh;
            ResetAll(mesh, in, meshComponentManager_);
        }

        // if our child contain meshes, update material on those
        if (const CORE3D_NS::ISceneNode* parent = nodeSystem_->GetNode(target)) {
            for (auto& child : parent->GetChildren()) {
                if (IsMultiMeshChild(child)) {
                    auto entity = child->GetEntity();
                    if (auto data = renderMeshComponentManager_->Read(entity)) {
                        auto mesh = data->mesh;
                        ResetAll(mesh, in, meshComponentManager_);
                    }
                }
            }
        }
    }
    in.clear();
}

// Set instance count to multi-mesh
void SceneHolder::SetInstanceCountMultimeshArray(CORE_NS::Entity target, size_t count)
{
    if (ecs_) {
        if (auto parent = nodeSystem_->GetNode(target)) {
            // this is kind of sub-optimization. If we have instances available, the mesh component is stored only
            // in instances
            CORE_NS::Entity firstBorn;
            auto children = parent->GetChildren();

            for (auto& child : children) {
                if (IsMultiMeshChild(child)) {
                    firstBorn = child->GetEntity();
                    break;
                }
            }

            CORE3D_NS::MeshComponent meshData;

            // when the instance count goes back to zero, we need to restore the data on parent
            if (count == 0) {
                if (CORE_NS::EntityUtil::IsValid(firstBorn)) {
                    renderMeshComponentManager_->Create(target);
                    if (auto renderMeshData = renderMeshComponentManager_->Write(target)) {
                        if (auto instancingData = renderMeshComponentManager_->Read(firstBorn)) {
                            *renderMeshData = *instancingData;
                        }
                    }
                }
                // now, when we move the templated item back to root, it will become visible by default
            } else {
                // if we have mesh, set things up using mesh
                if (auto data = meshComponentManager_->Read(target)) {
                    meshData = *data;
                } else if (auto instanceData = renderMeshComponentManager_->Read(firstBorn)) {
                    // otherwise we prefer the instanced data
                    if (auto data = meshComponentManager_->Read(instanceData->mesh)) {
                        // use instance data
                        meshData = *data;
                        // and switch target
                        target = firstBorn;
                    }
                } else if (auto renderMeshData = renderMeshComponentManager_->Read(target)) {
                    // and fallback to existing render mesh data if it exists
                    if (auto data = meshComponentManager_->Read(renderMeshData->mesh)) {
                        meshData = *data;
                    }
                }
            }

            size_t mmcount = 0;
            for (auto& child : children) {
                if (IsMultiMeshChild(child)) {
                    if (mmcount == count) {
                        parent->RemoveChild(*child);
                    } else {
                        mmcount++;
                    }
                }
            }

            BASE_NS::vector<CORE_NS::Entity> clones;
            while (mmcount < count) {
                clones.push_back(ecs_->CloneEntity(target));
                mmcount++;
            }

            for (auto clone : clones) {
                // set up node system
                auto node = nodeSystem_->GetNode(clone);
                node->SetParent(*parent);
                node->SetEnabled(true);
                nameComponentManager_->Create(clone);

                // set up name so we can identify cloned instances afterwards
                if (auto nameHandle = nameComponentManager_->Write(clone)) {
                    BASE_NS::string postFixed(MULTI_MESH_CHILD_PREFIX.data(), MULTI_MESH_CHILD_PREFIX.size());
                    postFixed.append(BASE_NS::to_string(mmcount));
                    nameHandle->name = postFixed;
                }

                // and finally mesh specifics
                if (auto rmcHandle = renderMeshComponentManager_->Write(clone)) {
                    // during the first clone, switch from template to first instance
                    if (mmcount == 0) {
                        renderMeshComponentManager_->Destroy(target);
                        target = clone;
                    }
                    // Set batch
                    rmcHandle->renderMeshBatch = target;
                    // create new entity for mesh
                    const CORE_NS::Entity entity = ecs_->GetEntityManager().Create();
                    meshComponentManager_->Create(entity);
                    // copy the data of the original
                    *meshComponentManager_->Write(entity) = meshData;
                    // and set the mesh to a new instance
                    rmcHandle->mesh = entity;
                }
                mmcount++;
            }
            // Set up a batch
            auto renderMeshBatchComponentManager =
                CORE_NS::GetManager<CORE3D_NS::IRenderMeshBatchComponentManager>(*ecs_);
            if (!renderMeshBatchComponentManager->HasComponent(firstBorn)) {
                renderMeshBatchComponentManager->Create(firstBorn);
            }
            if (auto batchHandle = renderMeshBatchComponentManager->Write(firstBorn)) {
                batchHandle->batchType = CORE3D_NS::RenderMeshBatchComponent::BatchType::GPU_INSTANCING;
            }
        }
    }
}

// Set visible count to multi-mesh
void SceneHolder::SetVisibleCountMultimeshArray(CORE_NS::Entity target, size_t count)
{
    if (ecs_) {
        if (const CORE3D_NS::ISceneNode* parent = nodeSystem_->GetNode(target)) {
            size_t ix = 0;
            for (auto& child : parent->GetChildren()) {
                if (IsMultiMeshChild(child)) {
                    child->SetEnabled(ix < count);
                    ix++;
                }
            }
        }
    }
}

// Set custom data to multi-mesh index
void SceneHolder::SetCustomData(CORE_NS::Entity target, size_t index, const BASE_NS::Math::Vec4& data)
{
    if (ecs_) {
        if (const CORE3D_NS::ISceneNode* parent = nodeSystem_->GetNode(target)) {
            size_t ix = 0;
            for (auto& child : parent->GetChildren()) {
                if (IsMultiMeshChild(child)) {
                    if (ix == index) {
                        auto entity = child->GetEntity();
                        if (auto handle = renderMeshComponentManager_->Write(entity)) {
                            *static_cast<float*>(static_cast<void*>(&handle->customData[0].x)) = data.x;
                            *static_cast<float*>(static_cast<void*>(&handle->customData[0].y)) = data.y;
                            *static_cast<float*>(static_cast<void*>(&handle->customData[0].z)) = data.z;
                            *static_cast<float*>(static_cast<void*>(&handle->customData[0].w)) = data.w;
                        }
                        return;
                    }
                    ix++;
                }
            }
        }
    }
}

// Set transformation to multi-mesh index
void SceneHolder::SetTransformation(CORE_NS::Entity target, size_t index, const BASE_NS::Math::Mat4X4& transform)
{
    if (ecs_) {
        if (const CORE3D_NS::ISceneNode* parent = nodeSystem_->GetNode(target)) {
            size_t ix = 0;
            for (auto& child : parent->GetChildren()) {
                if (IsMultiMeshChild(child)) {
                    if (ix == index) {
                        auto entity = child->GetEntity();
                        if (auto handle = transformComponentManager_->Write(entity)) {
                            BASE_NS::Math::Quat rotation;
                            BASE_NS::Math::Vec3 scale;
                            BASE_NS::Math::Vec3 position;
                            BASE_NS::Math::Vec3 skew;
                            BASE_NS::Math::Vec4 persp;
                            if (BASE_NS::Math::Decompose(transform, scale, rotation, position, skew, persp)) {
                                handle->scale = scale;
                                handle->rotation = rotation;
                                handle->position = position;
                            }
                            return;
                        }
                    }
                    ix++;
                }
            }
        }
    }
}

bool SceneHolder::GetWorldMatrixComponentAABB(
    SCENE_NS::IPickingResult::Ptr ret, CORE_NS::Entity entity, bool isRecursive)
{
    if (picking_ && ecs_) {
        auto result = picking_->GetWorldMatrixComponentAABB(entity, isRecursive, *ecs_);
        if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
            writable->Add(result.minAABB);
            writable->Add(result.maxAABB);
            return true;
        }
    }
    return false;
}

bool SceneHolder::GetTransformComponentAABB(SCENE_NS::IPickingResult::Ptr ret, CORE_NS::Entity entity, bool isRecursive)
{
    if (picking_ && ecs_) {
        auto result = picking_->GetTransformComponentAABB(entity, isRecursive, *ecs_);
        if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
            writable->Add(result.minAABB);
            writable->Add(result.maxAABB);
            return true;
        }
    }
    return false;
}

bool SceneHolder::GetWorldAABB(SCENE_NS::IPickingResult::Ptr ret, const BASE_NS::Math::Mat4X4& world,
    const BASE_NS::Math::Vec3& aabbMin, const BASE_NS::Math::Vec3& aabbMax)
{
    if (picking_ && ecs_) {
        auto result = picking_->GetWorldAABB(world, aabbMin, aabbMax);
        if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
            writable->Add(result.minAABB);
            writable->Add(result.maxAABB);
            return true;
        }
    }
    return false;
}

bool ConvertToToolkit(const BASE_NS::vector<CORE3D_NS::RayCastResult>& result, SCENE_NS::IRayCastResult::Ptr ret)
{
    if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<SCENE_NS::NodeDistance>>(ret)) {
        for (auto& value : result) {
            BASE_NS::string path;
            if (ResolveNodeFullPath(value.node, path)) {
                writable->Add({ {}, value.distance });
                writable->MetaData().push_back(path);
            }
        }
        return true;
    }
    return false;
}

bool SceneHolder::RayCast(
    SCENE_NS::IRayCastResult::Ptr ret, const BASE_NS::Math::Vec3& start, const BASE_NS::Math::Vec3& direction)
{
    if (picking_ && ecs_) {
        auto result = picking_->RayCast(*ecs_, start, direction);
        return ConvertToToolkit(result, ret);
    }
    return false;
}

bool SceneHolder::RayCast(SCENE_NS::IRayCastResult::Ptr ret, const BASE_NS::Math::Vec3& start,
    const BASE_NS::Math::Vec3& direction, uint64_t layerMask)
{
    if (picking_ && ecs_) {
        auto result = picking_->RayCast(*ecs_, start, direction, layerMask);
        return ConvertToToolkit(result, ret);
    }
    return false;
}

bool SceneHolder::ScreenToWorld(
    SCENE_NS::IPickingResult::Ptr ret, CORE_NS::Entity camera, BASE_NS::Math::Vec3 screenCoordinate)
{
    if (picking_ && ecs_) {
        auto result = picking_->ScreenToWorld(*ecs_, camera, screenCoordinate);
        if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
            writable->Add(result);
            return true;
        }
    }
    return false;
}

bool SceneHolder::WorldToScreen(
    SCENE_NS::IPickingResult::Ptr ret, CORE_NS::Entity camera, BASE_NS::Math::Vec3 worldCoordinate)

{
    if (picking_ && ecs_) {
        auto result = picking_->WorldToScreen(*ecs_, camera, worldCoordinate);
        if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
            writable->Add(result);
            return true;
        }
    }
    return false;
}

bool SceneHolder::RayCastFromCamera(
    SCENE_NS::IRayCastResult::Ptr ret, CORE_NS::Entity camera, const BASE_NS::Math::Vec2& screenPos)
{
    if (picking_ && ecs_) {
        auto result = picking_->RayCastFromCamera(*ecs_, camera, screenPos);
        return ConvertToToolkit(result, ret);
    }
    return false;
}

bool SceneHolder::RayCastFromCamera(
    SCENE_NS::IRayCastResult::Ptr ret, CORE_NS::Entity camera, const BASE_NS::Math::Vec2& screenPos, uint64_t layerMask)
{
    if (picking_ && ecs_) {
        auto result = picking_->RayCastFromCamera(*ecs_, camera, screenPos, layerMask);
        return ConvertToToolkit(result, ret);
    }
    return false;
}

bool SceneHolder::RayFromCamera(
    SCENE_NS::IPickingResult::Ptr ret, CORE_NS::Entity camera, BASE_NS::Math::Vec2 screenCoordinate)
{
    if (auto cameraComponent = cameraComponentManager_->Read(camera)) {
        if (auto worldMatrixManager = GetManager<CORE3D_NS::IWorldMatrixComponentManager>(*ecs_)) {
            if (auto cameraWorldMatrixComponent = worldMatrixManager->Read(camera)) {
                if (cameraComponent->projection == CORE3D_NS::CameraComponent::Projection::ORTHOGRAPHIC) {
                    const auto worldPos = picking_->ScreenToWorld(
                        *ecs_, camera, BASE_NS::Math::Vec3(screenCoordinate.x, screenCoordinate.y, 0.0f));
                    const auto direction =
                        cameraWorldMatrixComponent->matrix * BASE_NS::Math::Vec4(0.0f, 0.0f, -1.0f, 0.0f);
                    if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
                        writable->Add(worldPos);
                        writable->Add(direction);
                        return true;
                    }
                } else {
                    // Ray origin is the camera world position.
                    const auto rayOrigin = BASE_NS::Math::Vec3(cameraWorldMatrixComponent->matrix.w);
                    const auto targetPos = picking_->ScreenToWorld(
                        *ecs_, camera, BASE_NS::Math::Vec3(screenCoordinate.x, screenCoordinate.y, 1.0f));
                    const auto direction = BASE_NS::Math::Normalize(targetPos - rayOrigin);
                    if (auto writable = interface_cast<SCENE_NS::IPendingRequestData<BASE_NS::Math::Vec3>>(ret)) {
                        writable->Add(rayOrigin);
                        writable->Add(direction);
                        return true;
                    }
                }
            }
        }
    }
    return false;
}