Blender V5.3
hydra/engine.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "engine.hh"
6
7#include <pxr/base/plug/plugin.h>
8#include <pxr/base/plug/registry.h>
9#include <pxr/imaging/hd/flatteningSceneIndex.h>
10#include <pxr/imaging/hd/rendererPluginRegistry.h>
11#include <pxr/imaging/hdSt/renderDelegate.h>
12#include <pxr/imaging/hdsi/extComputationPrimvarPruningSceneIndex.h>
13#include <pxr/imaging/hgi/tokens.h>
14#include <pxr/usd/usdGeom/tokens.h>
15#include <pxr/usdImaging/usdImaging/flattenedDataSourceProviders.h>
16#include <pxr/usdImaging/usdImaging/materialBindingsResolvingSceneIndex.h>
17
18#include "BKE_context.hh"
19
20#include "GPU_context.hh"
21
23
24#include "RE_engine.h"
25
26#include "CLG_log.h"
27
28namespace blender::render::hydra {
29
31
32Engine::Engine(RenderEngine *bl_engine, const std::string &render_delegate_name)
33 : render_delegate_name_(render_delegate_name), bl_engine_(bl_engine)
34{
35 pxr::HdRendererPluginRegistry &registry = pxr::HdRendererPluginRegistry::GetInstance();
36
37 pxr::TF_PY_ALLOW_THREADS_IN_SCOPE();
38
39 pxr::HdDriverVector hd_drivers;
40 if (bl_engine->type->flag & RE_USE_GPU_CONTEXT) {
41 pxr::TfToken hgi_token;
42 switch (GPU_backend_get_type()) {
44 hgi_token = pxr::TfToken("Metal");
45 break;
47 hgi_token = pxr::TfToken("OpenGL");
48 break;
50 hgi_token = pxr::TfToken("Vulkan");
51 break;
53 case GPU_BACKEND_ANY:
54 /* When pxr::Hgi::CreateNamedHgi is called with an empty token it will select the default
55 * platform Hgi. */
56 break;
57 }
58 hgi_ = pxr::Hgi::CreateNamedHgi(hgi_token);
59 hgi_driver_.name = pxr::HgiTokens->renderDriver;
60 hgi_driver_.driver = pxr::VtValue(hgi_.get());
61
62 hd_drivers.push_back(&hgi_driver_);
63 }
64 render_delegate_ = registry.CreateRenderDelegate(pxr::TfToken(render_delegate_name_));
65
66 if (!render_delegate_) {
67 throw std::runtime_error("Cannot create render delegate: " + render_delegate_name_);
68 }
69
70 render_index_.reset(pxr::HdRenderIndex::New(render_delegate_.Get(), hd_drivers));
71 free_camera_delegate_ = std::make_unique<io::hydra::CameraDelegate>(
72 render_index_.get(), pxr::SdfPath::AbsoluteRootPath().AppendElementString("freeCamera"));
73
74 /* Tasks are exposed as task prims through a retained scene index. */
75 const bool needs_prefixing = false;
76 task_scene_index_ = pxr::HdRetainedSceneIndex::New();
77 render_index_->InsertSceneIndex(
78 task_scene_index_, pxr::SdfPath::AbsoluteRootPath(), needs_prefixing);
79
81 render_task_delegate_ = std::make_unique<GPURenderTaskDelegate>(
82 render_index_.get(),
84 pxr::SdfPath::AbsoluteRootPath().AppendElementString("renderTask"));
85 }
86 else {
87 render_task_delegate_ = std::make_unique<RenderTaskDelegate>(
88 render_index_.get(),
90 pxr::SdfPath::AbsoluteRootPath().AppendElementString("renderTask"));
91 }
92 render_task_delegate_->set_camera(free_camera_delegate_->GetCameraId());
93
94 if (render_delegate_name_ == "HdStormRendererPlugin") {
95 light_tasks_delegate_ = std::make_unique<LightTasksDelegate>(
96 render_index_.get(),
98 pxr::SdfPath::AbsoluteRootPath().AppendElementString("lightTasks"));
99 light_tasks_delegate_->set_camera(free_camera_delegate_->GetCameraId());
100 }
101
102 engine_ = std::make_unique<pxr::HdEngine>();
103}
104
105void Engine::sync(Depsgraph *depsgraph, bContext *context)
106{
107 depsgraph_ = depsgraph;
108 context_ = context;
109 scene_ = DEG_get_evaluated_scene(depsgraph);
110
111 const bool use_materialx = bl_engine_->type->flag & RE_USE_MATERIALX;
112
114 /* Fast path. */
115 usd_scene_delegate_.reset();
116
117 if (!hydra_scene_index_) {
118 hydra_scene_index_path_ = pxr::SdfPath::AbsoluteRootPath().AppendElementString("scene");
119 hydra_scene_index_ = std::make_unique<io::hydra::HydraSceneIndex>(
120 hydra_scene_index_path_, render_delegate_.Get(), use_materialx);
121 const bool needs_prefixing = false;
122 pxr::HdSceneIndexBaseRefPtr filtered = hydra_scene_index_->retained();
123 filtered = pxr::HdSiExtComputationPrimvarPruningSceneIndex::New(filtered);
124 filtered = pxr::HdFlatteningSceneIndex::New(filtered,
125 pxr::UsdImagingFlattenedDataSourceProviders());
126 filtered = pxr::UsdImagingMaterialBindingsResolvingSceneIndex::New(filtered, nullptr);
127 render_index_->InsertSceneIndex(filtered, hydra_scene_index_path_, needs_prefixing);
128 }
129 hydra_scene_index_->populate(depsgraph, context ? CTX_wm_view3d(context) : nullptr);
130 }
131 else {
132 /* Slow USD export for reference. */
133 if (hydra_scene_index_) {
134 hydra_scene_index_->clear();
135 }
136
137 if (!usd_scene_delegate_) {
138 pxr::SdfPath scene_path = pxr::SdfPath::AbsoluteRootPath().AppendElementString("usd_scene");
139 usd_scene_delegate_ = std::make_unique<io::hydra::USDSceneIndex>(
140 render_index_.get(), scene_path, use_materialx);
141 }
142 usd_scene_delegate_->populate(depsgraph);
143 }
145}
146
147void Engine::set_render_setting(const std::string &key, const pxr::VtValue &val)
148{
149 render_delegate_->SetRenderSetting(pxr::TfToken(key), val);
150}
151
153{
154 pxr::VtDictionary render_stats = render_delegate_->GetRenderStats();
155 auto it = render_stats.find("percentDone");
156 if (it == render_stats.end()) {
157 return 0.0f;
158 }
159 return float(it->second.UncheckedGet<double>());
160}
161
162pxr::HdTaskSharedPtrVector Engine::tasks()
163{
164 pxr::HdTaskSharedPtrVector res;
167#ifndef __APPLE__
168 /* TODO: Temporary disable skydome task for MacOS due to crash with error:
169 * Failed to create pipeline state, error depthAttachmentPixelFormat is not valid
170 * and shader writes to depth */
171 res.push_back(light_tasks_delegate_->skydome_task());
172#endif
173 }
174 res.push_back(light_tasks_delegate_->simple_task());
175 }
176 res.push_back(render_task_delegate_->task());
177 return res;
178}
179
180} // namespace blender::render::hydra
pxr::HdRetainedSceneIndexRefPtr task_scene_index_
Definition engine.hh:57
virtual const Object * camera_object() const =0
Engine(RenderEngine *bl_engine, const std::string &render_delegate_name)
RenderEngine * bl_engine_
Definition engine.hh:41
void sync(Depsgraph *depsgraph, bContext *context)
pxr::SdfPath hydra_scene_index_path_
Definition engine.hh:54
pxr::HdTaskSharedPtrVector tasks()
std::unique_ptr< RenderTaskDelegate > render_task_delegate_
Definition engine.hh:58
pxr::HdPluginRenderDelegateUniqueHandle render_delegate_
Definition engine.hh:49
std::string render_delegate_name_
Definition engine.hh:40
std::unique_ptr< io::hydra::USDSceneIndex > usd_scene_delegate_
Definition engine.hh:55
std::unique_ptr< io::hydra::CameraDelegate > free_camera_delegate_
Definition engine.hh:52
std::unique_ptr< pxr::HdRenderIndex > render_index_
Definition engine.hh:50
std::unique_ptr< io::hydra::HydraSceneIndex > hydra_scene_index_
Definition engine.hh:53
pxr::HgiUniquePtr hgi_
Definition engine.hh:47
virtual void set_render_setting(const std::string &key, const pxr::VtValue &val)
std::unique_ptr< LightTasksDelegate > light_tasks_delegate_
Definition engine.hh:59
std::unique_ptr< pxr::HdEngine > engine_
Definition engine.hh:60
CLG_LogRef * LOG_HYDRA_RENDER
CLG_LOGREF_DECLARE_GLOBAL(LOG_HYDRA_RENDER, "hydra.render")
GPUBackendType GPU_backend_get_type()
@ RE_USE_GPU_CONTEXT
Definition RE_engine.h:52
@ RE_USE_MATERIALX
Definition RE_engine.h:55
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
View3D * CTX_wm_view3d(const bContext *C)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
RenderEngineType * type
Definition RE_engine.h:141
eSceneHydra_ExportMethod export_method
struct SceneHydra hydra
struct RenderData r