Blender V5.3
render_task_delegate.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
6
7#ifdef WITH_OPENGL_BACKEND
8# include "GPU_context.hh"
9# include <epoxy/gl.h>
10#endif
11
12#include <pxr/imaging/hd/legacyTaskFactory.h>
13#include <pxr/imaging/hd/legacyTaskSchema.h>
14#include <pxr/imaging/hd/renderBuffer.h>
15#include <pxr/imaging/hd/renderBufferSchema.h>
16#include <pxr/imaging/hd/renderDelegate.h>
17#include <pxr/imaging/hd/retainedDataSource.h>
18#include <pxr/imaging/hd/sceneIndexObserver.h>
19#include <pxr/imaging/hd/tokens.h>
20#include <pxr/imaging/hdx/renderTask.h>
21
22#include "BLI_utildefines.hh"
23
24#include "MEM_guardedalloc.h"
25
26#include <Eigen/Core>
27
28#include "engine.hh"
29
30namespace blender::render::hydra {
31
32RenderTaskDelegate::RenderTaskDelegate(pxr::HdRenderIndex *render_index,
33 pxr::HdRetainedSceneIndexRefPtr task_scene_index,
34 pxr::SdfPath const &base_id)
35 : render_index_(render_index),
36 task_scene_index_(std::move(task_scene_index)),
37 base_id_(base_id),
38 task_id_(base_id.AppendElementString("task"))
39{
40 task_params_.enableLighting = true;
41 task_params_.alphaThreshold = 0.1f;
42
43 /* Disable this so Metal and OpenGL match in Storm render tests, only
44 * the former seems to use multisample. */
45 task_params_.useAovMultiSample = false;
46
48
49 CLOG_DEBUG(LOG_HYDRA_RENDER, "%s", task_id_.GetText());
50}
51
53{
54 const pxr::HdRprimCollection collection(pxr::HdTokens->geometry,
55 pxr::HdReprSelector(pxr::HdReprTokens->smoothHull));
56 const pxr::TfTokenVector render_tags = {pxr::HdRenderTagTokens->geometry};
57
58 pxr::HdContainerDataSourceHandle task_ds =
59 pxr::HdLegacyTaskSchema::Builder()
60 .SetFactory(
61 pxr::HdRetainedTypedSampledDataSource<pxr::HdLegacyTaskFactorySharedPtr>::New(
62 pxr::HdMakeLegacyTaskFactory<pxr::HdxRenderTask>()))
63 .SetParameters(task_params_ds_)
64 .SetCollection(
65 pxr::HdRetainedTypedSampledDataSource<pxr::HdRprimCollection>::New(collection))
66 .SetRenderTags(
67 pxr::HdRetainedTypedSampledDataSource<pxr::TfTokenVector>::New(render_tags))
68 .Build();
69
70 task_scene_index_->AddPrims({{task_id_,
71 pxr::HdPrimTypeTokens->task,
72 pxr::HdRetainedContainerDataSource::New(
73 pxr::HdLegacyTaskSchema::GetSchemaToken(), task_ds)}});
74}
75
77{
78 task_scene_index_->DirtyPrims({{task_id_, pxr::HdLegacyTaskSchema::GetParametersLocator()}});
79}
80
81void RenderTaskDelegate::publish_buffer(pxr::SdfPath const &buf_id,
82 pxr::HdRenderBufferDescriptor const &desc)
83{
84 pxr::HdContainerDataSourceHandle buffer_ds =
85 pxr::HdRenderBufferSchema::Builder()
86 .SetDimensions(pxr::HdRetainedTypedSampledDataSource<pxr::GfVec3i>::New(desc.dimensions))
87 .SetFormat(pxr::HdRetainedTypedSampledDataSource<pxr::HdFormat>::New(desc.format))
88 .SetMultiSampled(pxr::HdRetainedTypedSampledDataSource<bool>::New(desc.multiSampled))
89 .Build();
90
91 task_scene_index_->AddPrims({{buf_id,
92 pxr::HdPrimTypeTokens->renderBuffer,
93 pxr::HdRetainedContainerDataSource::New(
94 pxr::HdRenderBufferSchema::GetSchemaToken(), buffer_ds)}});
95}
96
97pxr::HdTaskSharedPtr RenderTaskDelegate::task()
98{
99 return render_index_->GetTask(task_id_);
100}
101
102void RenderTaskDelegate::set_camera(pxr::SdfPath const &camera_id)
103{
104 if (task_params_.camera == camera_id) {
105 return;
106 }
107 task_params_.camera = camera_id;
109}
110
112{
113 return static_cast<pxr::HdxRenderTask *>(task().get())->IsConverged();
114}
115
116void RenderTaskDelegate::set_viewport(pxr::GfVec4d const &viewport)
117{
118 if (task_params_.viewport == viewport) {
119 return;
120 }
121 task_params_.viewport = viewport;
123
124 int w = viewport[2] - viewport[0];
125 int h = viewport[3] - viewport[1];
126 for (auto &it : buffer_descriptors_) {
127 it.second.dimensions = pxr::GfVec3i(w, h, 1);
128 publish_buffer(it.first, it.second);
129 task_scene_index_->DirtyPrims({{it.first, pxr::HdRenderBufferSchema::GetDimensionsLocator()}});
130 }
131}
132
133void RenderTaskDelegate::add_aov(pxr::TfToken const &aov_key)
134{
135 pxr::SdfPath buf_id = buffer_id(aov_key);
136 if (buffer_descriptors_.find(buf_id) != buffer_descriptors_.end()) {
137 return;
138 }
139 pxr::HdAovDescriptor aov_desc = render_index_->GetRenderDelegate()->GetDefaultAovDescriptor(
140 aov_key);
141
142 if (aov_desc.format == pxr::HdFormatInvalid) {
143 CLOG_ERROR(LOG_HYDRA_RENDER, "Invalid AOV: %s", aov_key.GetText());
144 return;
145 }
146 if (!ELEM(
147 pxr::HdGetComponentFormat(aov_desc.format), pxr::HdFormatFloat32, pxr::HdFormatFloat16))
148 {
150 "Unsupported data format %s for AOV %s",
151 pxr::TfEnum::GetName(aov_desc.format).c_str(),
152 aov_key.GetText());
153 return;
154 }
155
156 int w = task_params_.viewport[2] - task_params_.viewport[0];
157 int h = task_params_.viewport[3] - task_params_.viewport[1];
158 pxr::HdRenderBufferDescriptor desc(
159 pxr::GfVec3i(w, h, 1), aov_desc.format, aov_desc.multiSampled);
160 buffer_descriptors_[buf_id] = desc;
161 publish_buffer(buf_id, desc);
162
163 pxr::HdRenderPassAovBinding binding;
164 binding.aovName = aov_key;
165 binding.renderBufferId = buf_id;
166 binding.aovSettings = aov_desc.aovSettings;
167 binding.clearValue = aov_desc.clearValue;
168 task_params_.aovBindings.push_back(binding);
170
171 CLOG_DEBUG(LOG_HYDRA_RENDER, "%s", aov_key.GetText());
172}
173
174void RenderTaskDelegate::read_aov(pxr::TfToken const &aov_key, void *data)
175{
176 pxr::HdRenderBuffer *buffer = static_cast<pxr::HdRenderBuffer *>(
177 render_index_->GetBprim(pxr::HdPrimTypeTokens->renderBuffer, buffer_id(aov_key)));
178 if (!buffer) {
179 return;
180 }
181
182 pxr::HdFormat format = buffer->GetFormat();
183 size_t len = buffer->GetWidth() * buffer->GetHeight() * pxr::HdGetComponentCount(format);
184 if (pxr::HdGetComponentFormat(format) == pxr::HdFormatFloat32) {
185 void *buf_data = buffer->Map();
186 memcpy(data, buf_data, len * sizeof(float));
187 buffer->Unmap();
188 }
189 else if (pxr::HdGetComponentFormat(format) == pxr::HdFormatFloat16) {
190 Eigen::half *buf_data = (Eigen::half *)buffer->Map();
191 float *fdata = static_cast<float *>(data);
192 for (size_t i = 0; i < len; ++i) {
193 fdata[i] = buf_data[i];
194 }
195 buffer->Unmap();
196 }
197 else {
199 }
200}
201
202pxr::HdRenderBuffer *RenderTaskDelegate::get_aov_buffer(pxr::TfToken const &aov_key)
203{
204 return (pxr::HdRenderBuffer *)render_index_->GetBprim(pxr::HdPrimTypeTokens->renderBuffer,
205 buffer_id(aov_key));
206}
207
209
211
212pxr::SdfPath RenderTaskDelegate::buffer_id(pxr::TfToken const &aov_key) const
213{
214 return base_id_.AppendElementString("aov_" + aov_key.GetString());
215}
216
218{
219 unbind();
220 if (tex_color_) {
221 GPU_texture_free(tex_color_);
222 }
223 if (tex_depth_) {
224 GPU_texture_free(tex_depth_);
225 }
226}
227
228void GPURenderTaskDelegate::set_viewport(pxr::GfVec4d const &viewport)
229{
230 if (task_params_.viewport == viewport) {
231 return;
232 }
233 task_params_.viewport = viewport;
235
236 if (tex_color_) {
237 GPU_texture_free(tex_color_);
238 tex_color_ = nullptr;
239 add_aov(pxr::HdAovTokens->color);
240 }
241 if (tex_depth_) {
242 GPU_texture_free(tex_depth_);
243 tex_depth_ = nullptr;
244 add_aov(pxr::HdAovTokens->depth);
245 }
246}
247
248void GPURenderTaskDelegate::add_aov(pxr::TfToken const &aov_key)
249{
250 gpu::TextureFormat format;
251 gpu::Texture **tex;
252 if (aov_key == pxr::HdAovTokens->color) {
253 format = gpu::TextureFormat::SFLOAT_32_32_32_32;
254 tex = &tex_color_;
255 }
256 else if (aov_key == pxr::HdAovTokens->depth) {
257 format = gpu::TextureFormat::SFLOAT_32_DEPTH;
258 tex = &tex_depth_;
259 }
260 else {
261 CLOG_ERROR(LOG_HYDRA_RENDER, "Invalid AOV: %s", aov_key.GetText());
262 return;
263 }
264
265 if (*tex) {
266 return;
267 }
268
269 *tex = GPU_texture_create_2d(("tex_render_hydra_" + aov_key.GetString()).c_str(),
270 task_params_.viewport[2] - task_params_.viewport[0],
271 task_params_.viewport[3] - task_params_.viewport[1],
272 1,
273 format,
275 nullptr);
276
277 CLOG_DEBUG(LOG_HYDRA_RENDER, "%s", aov_key.GetText());
278}
279
280void GPURenderTaskDelegate::read_aov(pxr::TfToken const &aov_key, void *data)
281{
282 gpu::Texture *tex = nullptr;
283 int c;
284 if (aov_key == pxr::HdAovTokens->color) {
285 tex = tex_color_;
286 c = 4;
287 }
288 else if (aov_key == pxr::HdAovTokens->depth) {
289 tex = tex_depth_;
290 c = 1;
291 }
292 if (!tex) {
293 return;
294 }
295
296 int w = GPU_texture_width(tex), h = GPU_texture_height(tex);
297 void *tex_data = GPU_texture_read(tex, GPU_DATA_FLOAT, 0);
298 memcpy(data, tex_data, sizeof(float) * w * h * c);
299 MEM_delete_void(tex_data);
300}
301
303{
304 if (!framebuffer_) {
305 framebuffer_ = GPU_framebuffer_create("fb_render_hydra");
306 }
308 &framebuffer_, {GPU_ATTACHMENT_TEXTURE(tex_depth_), GPU_ATTACHMENT_TEXTURE(tex_color_)});
309 GPU_framebuffer_bind(framebuffer_);
310
311 GPU_framebuffer_clear_color_depth(framebuffer_, {0.0, 0.0, 0.0, 0.0}, 1.0f);
312
313#ifdef WITH_OPENGL_BACKEND
314 /* Workaround missing/buggy VAOs in hgiGL and hdSt. For OpenGL compatibility
315 * profile this is not a problem, but for core profile it is. */
316 if (VAO_ == 0 && GPU_backend_get_type() == GPU_BACKEND_OPENGL) {
317 glGenVertexArrays(1, &VAO_);
318 glBindVertexArray(VAO_);
319 }
320#else
321 UNUSED_VARS(VAO_);
322#endif
324}
325
327{
328#ifdef WITH_OPENGL_BACKEND
329 if (VAO_) {
330 glDeleteVertexArrays(1, &VAO_);
331 VAO_ = 0;
332 }
333#endif
334 if (framebuffer_) {
335 GPU_framebuffer_free(framebuffer_);
336 framebuffer_ = nullptr;
337 }
338 CLOG_DEBUG(LOG_HYDRA_RENDER, "unbind");
339}
340
342{
343 if (aov_key == pxr::HdAovTokens->color) {
344 return tex_color_;
345 }
346 if (aov_key == pxr::HdAovTokens->depth) {
347 return tex_depth_;
348 }
349 return nullptr;
350}
351
352} // namespace blender::render::hydra
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define CLOG_DEBUG(clg_ref,...)
Definition CLG_log.h:191
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
#define GPU_ATTACHMENT_TEXTURE(_texture)
#define GPU_framebuffer_ensure_config(_fb,...)
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS(...)
#define ELEM(...)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
void add_aov(pxr::TfToken const &aov_key) override
void set_viewport(pxr::GfVec4d const &viewport) override
gpu::Texture * get_aov_texture(pxr::TfToken const &aov_key)
void read_aov(pxr::TfToken const &aov_key, void *data) override
pxr::HdRenderBuffer * get_aov_buffer(pxr::TfToken const &aov_key)
virtual void set_viewport(pxr::GfVec4d const &viewport)
RenderTaskDelegate(pxr::HdRenderIndex *render_index, pxr::HdRetainedSceneIndexRefPtr task_scene_index, pxr::SdfPath const &base_id)
virtual void add_aov(pxr::TfToken const &aov_key)
pxr::SdfPath buffer_id(pxr::TfToken const &aov_key) const
void set_camera(pxr::SdfPath const &camera_id)
void publish_buffer(pxr::SdfPath const &buf_id, pxr::HdRenderBufferDescriptor const &desc)
virtual void read_aov(pxr::TfToken const &aov_key, void *data)
pxr::HdRetainedSceneIndexRefPtr task_scene_index_
RenderTaskParamsDataSource::Handle task_params_ds_
pxr::TfHashMap< pxr::SdfPath, pxr::HdRenderBufferDescriptor, pxr::SdfPath::Hash > buffer_descriptors_
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
CLG_LogRef * LOG_HYDRA_RENDER
void GPU_framebuffer_bind(gpu::FrameBuffer *fb)
void GPU_framebuffer_free(gpu::FrameBuffer *fb)
GPUBackendType GPU_backend_get_type()
void MEM_delete_void(void *vmemh)
@ GPU_TEXTURE_USAGE_GENERAL
BMesh const char void * data
int GPU_texture_width(const gpu::Texture *texture)
gpu::FrameBuffer * GPU_framebuffer_create(const char *name)
int GPU_texture_height(const gpu::Texture *texture)
void GPU_texture_free(gpu::Texture *texture)
void * GPU_texture_read(gpu::Texture *texture, eGPUDataFormat data_format, int mip_level)
void GPU_framebuffer_clear_color_depth(gpu::FrameBuffer *fb, const double4 clear_col, float clear_depth)
gpu::Texture * GPU_texture_create_2d(const char *name, int width, int height, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)