Blender V5.3
viewport_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 "viewport_engine.hh"
6#include "camera.hh"
7
8#include <pxr/base/gf/camera.h>
9#include <pxr/imaging/glf/drawTarget.h>
10#include <pxr/usd/usdGeom/camera.h>
11
12#include "DNA_camera_types.h"
13#include "DNA_scene_types.h"
14#include "DNA_screen_types.h"
15#include "DNA_vec_types.h" /* This include must be before `BKE_camera.h` due to `rctf` type. */
16#include "DNA_view3d_types.h"
17
18#include "BLI_math_matrix_c.hh"
19#include "BLI_time.hh"
20#include "BLI_timecode.hh"
21
22#include "BKE_camera.h"
23#include "BKE_context.hh"
24
25#include "GPU_matrix.hh"
26#include "GPU_texture.hh"
27
29
30#include "RE_engine.h"
31
32namespace blender::render::hydra {
33
37 pxr::GfVec4i border;
38 pxr::GfCamera camera;
39
40 ViewSettings(bContext *context);
41
42 int width();
43 int height();
44};
45
47{
48 View3D *view3d = CTX_wm_view3d(context);
49 RegionView3D *region_data = static_cast<RegionView3D *>(CTX_wm_region_data(context));
50 ARegion *region = CTX_wm_region(context);
51 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(context);
52 Scene *scene = DEG_get_evaluated_scene(depsgraph);
53
54 screen_width = region->winx;
55 screen_height = region->winy;
56
57 /* Apply the render border. */
58 int x1 = 0, y1 = 0;
59 int x2 = screen_width, y2 = screen_height;
60
61 rctf border_rect;
63 depsgraph,
64 view3d,
65 region_data,
68 &border_rect,
69 nullptr))
70 {
71 x1 = std::max(std::min(int(border_rect.xmin), screen_width), 0);
72 x2 = std::max(std::min(int(border_rect.xmax), screen_width), 0);
73 y1 = std::max(std::min(int(border_rect.ymin), screen_height), 0);
74 y2 = std::max(std::min(int(border_rect.ymax), screen_height), 0);
75 }
76
77 border = pxr::GfVec4i(x1, y1, x2, y2);
78
79 camera = gf_camera(depsgraph,
80 view3d,
81 region,
82 pxr::GfVec4f(float(border[0]) / screen_width,
83 float(border[1]) / screen_height,
84 float(width()) / screen_width,
85 float(height()) / screen_height));
86}
87
89{
90 return border[2] - border[0];
91}
92
94{
95 return border[3] - border[1];
96}
97
99{
100 float coords[8] = {0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0};
101
102 GPUVertFormat format = {0};
103 GPU_vertformat_attr_add(&format, "pos", gpu::VertAttrType::SFLOAT_32_32);
104 GPU_vertformat_attr_add(&format, "texCoord", gpu::VertAttrType::SFLOAT_32_32);
105 gpu::VertBuf *vbo = GPU_vertbuf_create_with_format(format);
106 GPU_vertbuf_data_alloc(*vbo, 4);
107 GPU_vertbuf_attr_fill(vbo, 0, coords);
108 GPU_vertbuf_attr_fill(vbo, 1, coords);
109
111}
112
114{
115 if (texture_) {
116 GPU_texture_free(texture_);
117 }
118 GPU_batch_discard(batch_);
119}
120
121void DrawTexture::create_from_buffer(pxr::HdRenderBuffer *buffer)
122{
123 if (buffer == nullptr) {
124 return;
125 }
126
127 gpu::TextureFormat texture_format;
128 eGPUDataFormat data_format;
129
130 if (buffer->GetFormat() == pxr::HdFormat::HdFormatFloat16Vec4) {
131 texture_format = gpu::TextureFormat::SFLOAT_16_16_16_16;
132 data_format = GPU_DATA_HALF_FLOAT;
133 }
134 else {
135 texture_format = gpu::TextureFormat::SFLOAT_32_32_32_32;
136 data_format = GPU_DATA_FLOAT;
137 }
138
139 if (texture_ && (GPU_texture_width(texture_) != buffer->GetWidth() ||
140 GPU_texture_height(texture_) != buffer->GetHeight() ||
141 GPU_texture_format(texture_) != texture_format))
142 {
143 GPU_texture_free(texture_);
144 texture_ = nullptr;
145 }
146
147 if (texture_ == nullptr) {
148 texture_ = GPU_texture_create_2d("tex_hydra_render_viewport",
149 buffer->GetWidth(),
150 buffer->GetHeight(),
151 1,
152 texture_format,
154 nullptr);
155 }
156
157 void *data = buffer->Map();
158 GPU_texture_update(texture_, data_format, data);
159 buffer->Unmap();
160}
161
162void DrawTexture::draw(gpu::Shader *shader, const pxr::GfVec4d &viewport, gpu::Texture *tex)
163{
164 if (!tex) {
165 tex = texture_;
166 }
167 int slot = GPU_shader_get_sampler_binding(shader, "image");
168 GPU_texture_bind(tex, slot);
169 GPU_shader_uniform_1i(shader, "image", slot);
170
172 GPU_matrix_translate_2f(viewport[0], viewport[1]);
173 GPU_matrix_scale_2f(viewport[2] - viewport[0], viewport[3] - viewport[1]);
175 GPU_batch_draw(batch_);
177}
178
180{
181 return texture_;
182}
183
185{
186 ViewSettings view_settings(context_);
187 if (view_settings.width() * view_settings.height() == 0) {
188 return;
189 };
190
191 free_camera_delegate_->SetCamera(view_settings.camera);
192
193 pxr::GfVec4d viewport(0.0, 0.0, view_settings.width(), view_settings.height());
194 render_task_delegate_->set_viewport(viewport);
196 light_tasks_delegate_->set_viewport(viewport);
197 }
198
199 render_task_delegate_->add_aov(pxr::HdAovTokens->color);
200 render_task_delegate_->add_aov(pxr::HdAovTokens->depth);
201
202 gpu::FrameBuffer *view_framebuffer = GPU_framebuffer_active_get();
203 render_task_delegate_->bind();
204
205 auto t = tasks();
206 engine_->Execute(render_index_.get(), &t);
207
208 render_task_delegate_->unbind();
209
210 GPU_framebuffer_bind(view_framebuffer);
213
214 pxr::GfVec4d draw_viewport(view_settings.border[0],
215 view_settings.border[1],
216 view_settings.border[2],
217 view_settings.border[3]);
218 GPURenderTaskDelegate *gpu_task = dynamic_cast<GPURenderTaskDelegate *>(
220 if (gpu_task) {
221 draw_texture_.draw(shader, draw_viewport, gpu_task->get_aov_texture(pxr::HdAovTokens->color));
222 }
223 else {
224 draw_texture_.create_from_buffer(
225 render_task_delegate_->get_aov_buffer(pxr::HdAovTokens->color));
226 draw_texture_.draw(shader, draw_viewport);
227 }
228
230
231 if (renderer_percent_done() == 0.0f) {
232 time_begin_ = BLI_time_now_seconds();
233 }
234
235 char elapsed_time[32];
236
238 elapsed_time, sizeof(elapsed_time), BLI_time_now_seconds() - time_begin_);
239
240 float percent_done = renderer_percent_done();
241 if (!render_task_delegate_->is_converged()) {
242 notify_status(percent_done / 100.0,
243 std ::string("Time: ") + elapsed_time +
244 " | Done: " + std::to_string(int(percent_done)) + "%",
245 "Render");
247 }
248 else {
249 notify_status(percent_done / 100.0, std::string("Time: ") + elapsed_time, "Rendering Done");
250 }
251}
252
254{
255 context_ = context;
256 render();
257}
258
260{
261 const View3D *v3d = context_ ? CTX_wm_view3d(context_) : nullptr;
262 if (v3d && v3d->camera) {
263 return DEG_get_evaluated(depsgraph_, v3d->camera);
264 }
265 return scene_->camera;
266}
267
268void ViewportEngine::notify_status(float /*progress*/,
269 const std::string &info,
270 const std::string &status)
271{
272 RE_engine_update_stats(bl_engine_, status.c_str(), info.c_str());
273}
274
275} // namespace blender::render::hydra
Camera data-block and utility functions.
Platform independent time functions.
void draw(gpu::Shader *shader, const pxr::GfVec4d &viewport, gpu::Texture *tex=nullptr)
void create_from_buffer(pxr::HdRenderBuffer *buffer)
RenderEngine * bl_engine_
Definition engine.hh:41
pxr::HdTaskSharedPtrVector tasks()
std::unique_ptr< RenderTaskDelegate > render_task_delegate_
Definition engine.hh:58
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< LightTasksDelegate > light_tasks_delegate_
Definition engine.hh:59
std::unique_ptr< pxr::HdEngine > engine_
Definition engine.hh:60
gpu::Texture * get_aov_texture(pxr::TfToken const &aov_key)
void notify_status(float progress, const std::string &info, const std::string &status) override
const Object * camera_object() const override
pxr::GfCamera gf_camera(const Depsgraph *depsgraph, const View3D *v3d, const ARegion *region, const pxr::GfVec4f &border)
void RE_engine_update_stats(RenderEngine *engine, const char *stats, const char *info)
void GPU_framebuffer_bind(gpu::FrameBuffer *fb)
int GPU_shader_get_sampler_binding(gpu::Shader *shader, const char *name)
gpu::FrameBuffer * GPU_framebuffer_active_get()
gpu::Batch * GPU_batch_create_ex(GPUPrimType primitive_type, gpu::VertBuf *vertex_buf, gpu::IndexBuf *index_buf, GPUBatchFlag owns_flag)
Definition gpu_batch.cc:53
void GPU_texture_update(gpu::Texture *texture, eGPUDataFormat data_format, const void *data)
gpu::TextureFormat GPU_texture_format(const gpu::Texture *texture)
bool BKE_camera_view_render_border(const struct Scene *scene, const struct Depsgraph *depsgraph, const struct View3D *v3d, const struct RegionView3D *rv3d, int winx, int winy, rctf *r_border, rctf *r_unrolled_border)
@ GPU_DATA_HALF_FLOAT
void GPU_batch_discard(gpu::Batch *batch)
void GPU_batch_set_shader(gpu::Batch *batch, gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void * CTX_wm_region_data(const bContext *C)
void GPU_matrix_scale_2f(float x, float y)
@ GPU_TEXTURE_USAGE_GENERAL
BMesh const char void * data
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void GPU_shader_unbind()
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
int GPU_texture_width(const gpu::Texture *texture)
void GPU_batch_draw(gpu::Batch *batch)
@ GPU_BATCH_OWNS_VBO
Definition GPU_batch.hh:44
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void GPU_shader_uniform_1i(gpu::Shader *sh, const char *name, int value)
void GPU_matrix_translate_2f(float x, float y)
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
gpu::Shader * GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
void GPU_vertbuf_attr_fill(gpu::VertBuf *, uint a_idx, const void *data)
void GPU_texture_bind(gpu::Texture *texture, int unit)
int GPU_texture_height(const gpu::Texture *texture)
void GPU_texture_free(gpu::Texture *texture)
void GPU_vertbuf_data_alloc(gpu::VertBuf &verts, uint v_len)
double BLI_time_now_seconds()
Definition time.cc:30
@ RE_ENGINE_DO_DRAW
Definition RE_engine.h:65
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
void GPU_matrix_pop()
size_t BLI_timecode_string_from_time_simple(char *str, size_t maxncpy, double time_seconds) ATTR_NONNULL()
Definition timecode.cc:172
ARegion * CTX_wm_region(const bContext *C)
View3D * CTX_wm_view3d(const bContext *C)
gpu::Texture * GPU_texture_create_2d(const char *name, int width, int height, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
void GPU_matrix_push()
struct Object * camera
struct Object * camera