Add Chromium-only Blender WebEngine parity work

blender-5.2.0/source/blender/render/hydra/engine.cc

@@ -0,0 +1,180 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "engine.hh"
+
+#include <pxr/base/plug/plugin.h>
+#include <pxr/base/plug/registry.h>
+#include <pxr/imaging/hd/flatteningSceneIndex.h>
+#include <pxr/imaging/hd/rendererPluginRegistry.h>
+#include <pxr/imaging/hdSt/renderDelegate.h>
+#include <pxr/imaging/hdsi/extComputationPrimvarPruningSceneIndex.h>
+#include <pxr/imaging/hgi/tokens.h>
+#include <pxr/usd/usdGeom/tokens.h>
+#include <pxr/usdImaging/usdImaging/flattenedDataSourceProviders.h>
+#include <pxr/usdImaging/usdImaging/materialBindingsResolvingSceneIndex.h>
+
+#include "BKE_context.hh"
+
+#include "GPU_context.hh"
+
+#include "DEG_depsgraph_query.hh"
+
+#include "RE_engine.h"
+
+#include "CLG_log.h"
+
+namespace blender::render::hydra {
+
+CLG_LOGREF_DECLARE_GLOBAL(LOG_HYDRA_RENDER, "hydra.render");
+
+Engine::Engine(RenderEngine *bl_engine, const std::string &render_delegate_name)
+    : render_delegate_name_(render_delegate_name), bl_engine_(bl_engine)
+{
+  pxr::HdRendererPluginRegistry &registry = pxr::HdRendererPluginRegistry::GetInstance();
+
+  pxr::TF_PY_ALLOW_THREADS_IN_SCOPE();
+
+  pxr::HdDriverVector hd_drivers;
+  if (bl_engine->type->flag & RE_USE_GPU_CONTEXT) {
+    pxr::TfToken hgi_token;
+    switch (GPU_backend_get_type()) {
+      case GPU_BACKEND_METAL:
+        hgi_token = pxr::TfToken("Metal");
+        break;
+      case GPU_BACKEND_OPENGL:
+        hgi_token = pxr::TfToken("OpenGL");
+        break;
+      case GPU_BACKEND_VULKAN:
+        hgi_token = pxr::TfToken("Vulkan");
+        break;
+      case GPU_BACKEND_NONE:
+      case GPU_BACKEND_ANY:
+        /* When pxr::Hgi::CreateNamedHgi is called with an empty token it will select the default
+         * platform Hgi. */
+        break;
+    }
+    hgi_ = pxr::Hgi::CreateNamedHgi(hgi_token);
+    hgi_driver_.name = pxr::HgiTokens->renderDriver;
+    hgi_driver_.driver = pxr::VtValue(hgi_.get());
+
+    hd_drivers.push_back(&hgi_driver_);
+  }
+  render_delegate_ = registry.CreateRenderDelegate(pxr::TfToken(render_delegate_name_));
+
+  if (!render_delegate_) {
+    throw std::runtime_error("Cannot create render delegate: " + render_delegate_name_);
+  }
+
+  render_index_.reset(pxr::HdRenderIndex::New(render_delegate_.Get(), hd_drivers));
+  free_camera_delegate_ = std::make_unique<io::hydra::CameraDelegate>(
+      render_index_.get(), pxr::SdfPath::AbsoluteRootPath().AppendElementString("freeCamera"));
+
+  /* Tasks are exposed as task prims through a retained scene index. */
+  const bool needs_prefixing = false;
+  task_scene_index_ = pxr::HdRetainedSceneIndex::New();
+  render_index_->InsertSceneIndex(
+      task_scene_index_, pxr::SdfPath::AbsoluteRootPath(), needs_prefixing);
+
+  if (bl_engine->type->flag & RE_USE_GPU_CONTEXT && GPU_backend_get_type() == GPU_BACKEND_OPENGL) {
+    render_task_delegate_ = std::make_unique<GPURenderTaskDelegate>(
+        render_index_.get(),
+        task_scene_index_,
+        pxr::SdfPath::AbsoluteRootPath().AppendElementString("renderTask"));
+  }
+  else {
+    render_task_delegate_ = std::make_unique<RenderTaskDelegate>(
+        render_index_.get(),
+        task_scene_index_,
+        pxr::SdfPath::AbsoluteRootPath().AppendElementString("renderTask"));
+  }
+  render_task_delegate_->set_camera(free_camera_delegate_->GetCameraId());
+
+  if (render_delegate_name_ == "HdStormRendererPlugin") {
+    light_tasks_delegate_ = std::make_unique<LightTasksDelegate>(
+        render_index_.get(),
+        task_scene_index_,
+        pxr::SdfPath::AbsoluteRootPath().AppendElementString("lightTasks"));
+    light_tasks_delegate_->set_camera(free_camera_delegate_->GetCameraId());
+  }
+
+  engine_ = std::make_unique<pxr::HdEngine>();
+}
+
+void Engine::sync(Depsgraph *depsgraph, bContext *context)
+{
+  depsgraph_ = depsgraph;
+  context_ = context;
+  scene_ = DEG_get_evaluated_scene(depsgraph);
+
+  const bool use_materialx = bl_engine_->type->flag & RE_USE_MATERIALX;
+
+  if (scene_->hydra.export_method == SCE_HYDRA_EXPORT_HYDRA) {
+    /* Fast path. */
+    usd_scene_delegate_.reset();
+
+    if (!hydra_scene_index_) {
+      hydra_scene_index_path_ = pxr::SdfPath::AbsoluteRootPath().AppendElementString("scene");
+      hydra_scene_index_ = std::make_unique<io::hydra::HydraSceneIndex>(
+          hydra_scene_index_path_, render_delegate_.Get(), use_materialx);
+      const bool needs_prefixing = false;
+      pxr::HdSceneIndexBaseRefPtr filtered = hydra_scene_index_->retained();
+      filtered = pxr::HdSiExtComputationPrimvarPruningSceneIndex::New(filtered);
+      filtered = pxr::HdFlatteningSceneIndex::New(filtered,
+                                                  pxr::UsdImagingFlattenedDataSourceProviders());
+      filtered = pxr::UsdImagingMaterialBindingsResolvingSceneIndex::New(filtered, nullptr);
+      render_index_->InsertSceneIndex(filtered, hydra_scene_index_path_, needs_prefixing);
+    }
+    hydra_scene_index_->populate(depsgraph, context ? CTX_wm_view3d(context) : nullptr);
+  }
+  else {
+    /* Slow USD export for reference. */
+    if (hydra_scene_index_) {
+      hydra_scene_index_->clear();
+    }
+
+    if (!usd_scene_delegate_) {
+      pxr::SdfPath scene_path = pxr::SdfPath::AbsoluteRootPath().AppendElementString("usd_scene");
+      usd_scene_delegate_ = std::make_unique<io::hydra::USDSceneIndex>(
+          render_index_.get(), scene_path, use_materialx);
+    }
+    usd_scene_delegate_->populate(depsgraph);
+  }
+  free_camera_delegate_->sync(scene_);
+}
+
+void Engine::set_render_setting(const std::string &key, const pxr::VtValue &val)
+{
+  render_delegate_->SetRenderSetting(pxr::TfToken(key), val);
+}
+
+float Engine::renderer_percent_done()
+{
+  pxr::VtDictionary render_stats = render_delegate_->GetRenderStats();
+  auto it = render_stats.find("percentDone");
+  if (it == render_stats.end()) {
+    return 0.0f;
+  }
+  return float(it->second.UncheckedGet<double>());
+}
+
+pxr::HdTaskSharedPtrVector Engine::tasks()
+{
+  pxr::HdTaskSharedPtrVector res;
+  if (light_tasks_delegate_) {
+    if (scene_->r.alphamode != R_ALPHAPREMUL) {
+#ifndef __APPLE__
+      /* TODO: Temporary disable skydome task for MacOS due to crash with error:
+       * Failed to create pipeline state, error depthAttachmentPixelFormat is not valid
+       * and shader writes to depth */
+      res.push_back(light_tasks_delegate_->skydome_task());
+#endif
+    }
+    res.push_back(light_tasks_delegate_->simple_task());
+  }
+  res.push_back(render_task_delegate_->task());
+  return res;
+}
+
+}  // namespace blender::render::hydra