Blender V5.3
eevee_sync.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include "BKE_paint.hh"
12#include "BKE_paint_bvh.hh"
13#include "DNA_curves_types.h"
14#include "DNA_modifier_types.h"
15#include "DNA_particle_types.h"
17#include "DNA_volume_types.h"
18
19#include "draw_cache.hh"
20#include "draw_common.hh"
21#include "draw_sculpt.hh"
22
23#include "eevee_instance.hh"
24
25namespace blender::eevee {
26
27/* -------------------------------------------------------------------- */
31
33 const ResourceHandleRange &res_handle,
34 uint sub_key)
35{
36 return ObjectHandle(ob_ref, res_handle, inst_.get_recalc_flags(ob_ref), sub_key);
37}
38
40
41/* -------------------------------------------------------------------- */
44
45static inline void geometry_call(PassMain::Sub *sub_pass,
46 gpu::Batch *geom,
47 ResourceHandleRange resource_handle)
48{
49 if (sub_pass != nullptr) {
50 sub_pass->draw(geom, resource_handle);
51 }
52}
53
54static inline void geometry_volume_call(PassMain::Sub *pass,
55 GPUMaterial *gpumat,
56 Scene *scene,
57 Object *ob,
58 gpu::Batch *geom,
59 ResourceHandle res_handle)
60{
62 if (pass != nullptr) {
63 PassMain::Sub *object_pass = volume_sub_pass(*pass, scene, ob, gpumat);
64 if (object_pass != nullptr) {
65 object_pass->draw(geom, {ResourceID(res_handle)});
66 }
67 }
68}
69
71
72/* -------------------------------------------------------------------- */
75
76void SyncModule::sync_common_passes(const Material &material,
77 FunctionRef<void(const MaterialPass &)> sync_cb)
78{
79 sync_cb(material.shadow);
80 sync_cb(material.shading);
81 sync_cb(material.prepass);
82
83 sync_cb(material.capture);
84 sync_cb(material.lightprobe_sphere_prepass);
85 sync_cb(material.lightprobe_sphere_shading);
86 sync_cb(material.planar_probe_prepass);
87 sync_cb(material.planar_probe_shading);
88}
89
90void SyncModule::sync_volume_passes(const ObjectHandle &ob_handle,
91 const Material &material,
92 FunctionRef<void(const MaterialPass &, int)> sync_cb)
93{
94 if (material.volume_occupancy.gpumat == nullptr || material.volume_material.gpumat == nullptr) {
95 return;
96 }
97
98 blender::Material *blender_mat = GPU_material_get_material(material.volume_material.gpumat);
99
100 for (int instance : IndexRange(ob_handle.instances_count())) {
101 /* TODO(fclem): This is against design. Sync shouldn't depend on view properties (camera). */
102 VolumeLayer *layer = inst_.pipelines.volume.register_and_get_layer(
103 VolumeObjectBounds(inst_.camera, ob_handle, instance));
104
105 if (!layer) {
106 continue;
107 }
108
109 sync_cb(MaterialPass{material.volume_occupancy.gpumat,
110 layer->occupancy_add(
111 ob_handle.object, blender_mat, material.volume_occupancy.gpumat)},
112 instance);
113
114 sync_cb(MaterialPass{material.volume_material.gpumat,
115 layer->material_add(
116 ob_handle.object, blender_mat, material.volume_material.gpumat)},
117 instance);
118 }
119}
120
121void SyncModule::sync_alpha_blended_passes(const ObjectHandle &ob_handle,
122 const Material &material,
123 FunctionRef<void(const MaterialPass &, int)> sync_cb)
124{
125 const bool hide_on_camera = ob_handle.object->visibility_flag & OB_HIDE_CAMERA;
126 if (hide_on_camera || !material.is_alpha_blend_transparent) {
127 return;
128 }
129
130 blender::Material *blender_mat = GPU_material_get_material(material.shading.gpumat);
131
132 for (int instance : IndexRange(ob_handle.instances_count())) {
133 PassMain::Sub *prepass = nullptr;
134 PassMain::Sub *matpass = nullptr;
135
136 inst_.pipelines.forward.transparent_add(ob_handle.object,
137 ob_handle.object_to_world(instance).location(),
138 blender_mat,
139 material.shading.gpumat,
140 prepass,
141 matpass);
142
143 sync_cb(MaterialPass{material.overlap_masking.gpumat, prepass}, instance);
144 sync_cb(MaterialPass{material.shading.gpumat, matpass}, instance);
145 }
146}
147
148void SyncModule::sync_common(const ObjectHandle &ob_handle,
149 Span<Material *> materials,
150 Span<GPUMaterial *> gpu_materials)
151{
152 bool has_volume = false;
153 bool is_alpha_blend = false;
154 bool has_transparent_shadows = false;
155 bool has_time_dependent_shadows = false;
156 bool has_shadow_offset = false;
157 float inflate_bounds = 0.0f;
158
159 for (const Material *material : materials) {
160 has_volume |= material->has_volume;
161 if (material->has_volume && !material->has_surface) {
162 continue;
163 }
164
165 GPUMaterial *gpu_material = material->shading.gpumat;
166 blender::Material *bl_material = GPU_material_get_material(gpu_material);
167
168 const bool has_displacement = GPU_material_has_displacement_output(gpu_material) &&
169 (bl_material->displacement_method != MA_DISPLACEMENT_BUMP);
170 const bool has_time_node = GPU_material_flag_get(gpu_material, GPU_MATFLAG_SCENE_TIME);
171 const bool mat_has_shadow_offset = GPU_material_flag_get(gpu_material,
173
174 is_alpha_blend |= material->is_alpha_blend_transparent;
175 has_transparent_shadows |= material->has_transparent_shadows;
176 has_shadow_offset |= mat_has_shadow_offset;
177 has_time_dependent_shadows |= has_time_node && (material->has_transparent_shadows ||
178 has_displacement || mat_has_shadow_offset);
179
180 if (has_displacement || mat_has_shadow_offset) {
181 inflate_bounds = math::max(inflate_bounds, bl_material->inflate_bounds);
182 }
183
184 inst_.cryptomatte.sync_material(bl_material);
185 }
186
187 inst_.cryptomatte.sync_object(ob_handle);
188
189 inst_.shadows.sync_object(ob_handle,
190 is_alpha_blend,
191 has_transparent_shadows,
192 has_time_dependent_shadows,
193 has_shadow_offset);
194
195 if (has_volume) {
196 inst_.volume.object_sync(ob_handle);
197 }
198
199 if (inflate_bounds != 0.0f) {
200 inst_.manager->update_handle_bounds(ob_handle.res_handle, ob_handle, inflate_bounds);
201 }
202
203 inst_.manager->extract_object_attributes(ob_handle.res_handle, ob_handle, gpu_materials);
204}
205
207
208/* -------------------------------------------------------------------- */
211
213{
214 if (!inst_.use_surfaces) {
215 return;
216 }
217
218 if ((ob_ref.object->dt < OB_SOLID) &&
219 (inst_.is_viewport() && inst_.v3d->shading.type != OB_RENDER))
220 {
222 return;
223 }
224
225 ObjectHandle ob_handle = sync_object(ob_ref, inst_.manager->unique_handle(ob_ref));
226
227 bool has_motion = inst_.velocity.step_object_sync(ob_handle);
228
229 MaterialArray &material_array = inst_.materials.material_array_get(ob_handle, has_motion);
230
232 ob_handle.object, material_array.gpu_materials);
233 if (mat_geom.is_empty()) {
234 return;
235 }
236
237 Vector<Material *, 8> synced_materials;
238
239 for (auto i : material_array.gpu_materials.index_range()) {
240 gpu::Batch *geom = mat_geom[i];
241 if (geom == nullptr) {
242 continue;
243 }
244
245 Material &material = material_array.materials[i];
246 synced_materials.append(&material);
247
248 if (material.has_volume) {
249 sync_volume_passes(ob_handle, material, [&](const MaterialPass &pass, int instance) {
251 pass.gpumat,
252 inst_.scene,
253 ob_handle.object,
254 geom,
255 ob_handle.res_handle.sub_handle(instance));
256 });
257
258 /* Do not render surface if we are rendering a volume object
259 * and do not have a surface closure. */
260 if (!material.has_surface) {
261 continue;
262 }
263 }
264
265 sync_common_passes(material, [&](const MaterialPass &pass) {
266 geometry_call(pass.sub_pass, geom, ob_handle.res_handle);
267 });
268
269 sync_alpha_blended_passes(ob_handle, material, [&](const MaterialPass &pass, int instance) {
270 geometry_call(pass.sub_pass, geom, ob_handle.res_handle.sub_handle(instance));
271 });
272 }
273
274 sync_common(ob_handle, synced_materials.as_span(), material_array.gpu_materials);
275}
276
278{
279 if (!inst_.use_surfaces) {
280 return false;
281 }
282
283 bool pbvh_draw = BKE_sculptsession_use_pbvh_draw(ob_ref.object, inst_.rv3d) &&
284 !inst_.is_image_render;
285 if (!pbvh_draw) {
286 return false;
287 }
288
289 ObjectHandle ob_handle = sync_object(ob_ref, inst_.manager->unique_handle_for_sculpt(ob_ref));
290
291 bool has_motion = false;
292 MaterialArray &material_array = inst_.materials.material_array_get(ob_handle, has_motion);
293
294 Vector<Material *, 8> synced_materials;
295
296 for (SculptBatch &batch :
298 {
299 gpu::Batch *geom = batch.batch;
300 if (geom == nullptr) {
301 continue;
302 }
303
304 Material &material = material_array.materials[batch.material_slot];
305 synced_materials.append(&material);
306
307 if (material.has_volume) {
308 sync_volume_passes(ob_handle, material, [&](const MaterialPass &pass, int instance) {
310 pass.gpumat,
311 inst_.scene,
312 ob_handle.object,
313 geom,
314 ob_handle.res_handle.sub_handle(instance));
315 });
316
317 /* Do not render surface if we are rendering a volume object
318 * and do not have a surface closure. */
319 if (!material.has_surface) {
320 continue;
321 }
322 }
323
324 sync_common_passes(material, [&](const MaterialPass &pass) {
325 geometry_call(pass.sub_pass, geom, ob_handle.res_handle);
326 });
327
328 sync_alpha_blended_passes(ob_handle, material, [&](const MaterialPass &pass, int instance) {
329 geometry_call(pass.sub_pass, geom, ob_handle.res_handle.sub_handle(instance));
330 });
331 }
332
333 sync_common(ob_handle, synced_materials.as_span(), material_array.gpu_materials);
334
335 return true;
336}
337
339
340/* -------------------------------------------------------------------- */
343
345{
346 const int material_slot = POINTCLOUD_MATERIAL_NR;
347
348 ObjectHandle ob_handle = sync_object(ob_ref, inst_.manager->unique_handle(ob_ref));
349
350 bool has_motion = inst_.velocity.step_object_sync(ob_handle);
351 eMaterialGeometry mat_geom_type = to_pointcloud_material_geometry(ob_ref.object);
352
353 Material material = inst_.materials.material_get(
354 ob_handle, has_motion, material_slot - 1, mat_geom_type);
355
356 auto drawcall_add = [&](const MaterialPass &matpass, bool dual_sided = false) {
357 if (matpass.sub_pass == nullptr) {
358 return;
359 }
360
361 PassMain::Sub &object_pass = matpass.sub_pass->sub("Point Cloud Sub Pass");
363 object_pass, ob_ref, ob_handle.res_handle, matpass.gpumat);
364
365 if (dual_sided) {
366 /* WORKAROUND: Hack to generate backfaces. Should also be baked into the Index Buf too at
367 * some point in the future. */
368 object_pass.push_constant("ptcloud_backface", false);
369 object_pass.draw(geometry, ob_handle.res_handle);
370 object_pass.push_constant("ptcloud_backface", true);
371 object_pass.draw(geometry, ob_handle.res_handle);
372 }
373 else {
374 object_pass.push_constant("ptcloud_backface", false);
375 object_pass.draw(geometry, ob_handle.res_handle);
376 }
377 };
378
379 if (material.has_volume) {
380 /* Volumes not supported for now. */
381 /* NOTE: Point Cloud volumes used to work at some point,
382 * but we didn't catch the regression due to the test being disabled. :( */
383 if (!material.has_surface) {
384 /* Do not render surface if we are rendering a volume object
385 * and do not have a surface closure. */
386 return;
387 }
388 }
389
390 sync_common_passes(material, [&](const MaterialPass &pass) { drawcall_add(pass); });
391
392 sync_alpha_blended_passes(ob_handle, material, [&](const MaterialPass &pass, int /*instance*/) {
393 drawcall_add(pass);
394 });
395
396 sync_common(ob_handle, {&material}, {material.shading.gpumat});
397}
398
400
401/* -------------------------------------------------------------------- */
404
406{
407 if (!inst_.use_volumes) {
408 return;
409 }
410
411 ObjectHandle ob_handle = sync_object(ob_ref, inst_.manager->unique_handle(ob_ref));
412
413 const int material_slot = VOLUME_MATERIAL_NR;
414
415 /* Motion is not supported on volumes yet. */
416 const bool has_motion = false;
417
418 Material material = inst_.materials.material_get(
419 ob_handle, has_motion, material_slot - 1, MAT_GEOM_VOLUME);
420
421 if (!material.has_volume) {
422 return;
423 }
424
425 /* Do not render the object if there is no attribute used in the volume.
426 * This mimic Cycles behavior (see #124061). */
427 ListBaseT<GPUMaterialAttribute> attr_list = GPU_material_attributes(
428 material.volume_material.gpumat);
429 if (attr_list.is_empty()) {
430 return;
431 }
432
433 /* Use bounding box tag empty spaces. */
434 gpu::Batch *geom = inst_.volume.unit_cube_batch_get();
435 bool is_rendered = false;
436
437 sync_volume_passes(ob_handle, material, [&](const MaterialPass &pass, int /*instance*/) {
438 if (pass.sub_pass == nullptr) {
439 return;
440 }
441 BLI_assert_msg(!ob_handle.is_range(),
442 "volume_object_grids_init pass setup is object/instance specific.");
443 PassMain::Sub *object_pass = volume_sub_pass(
444 *pass.sub_pass, inst_.scene, ob_handle.object, pass.gpumat);
445 if (object_pass != nullptr) {
446 object_pass->draw(geom, ob_handle.res_handle);
447 is_rendered = true;
448 }
449 });
450
451 if (!is_rendered) {
452 return;
453 }
454
455 inst_.volume.object_sync(ob_handle);
456
457 inst_.manager->extract_object_attributes(
458 ob_handle.res_handle, ob_handle, material.volume_material.gpumat);
459}
460
462
463/* -------------------------------------------------------------------- */
466
467void SyncModule::sync_curves(const ObjectRef &ob_ref, HairParticleInfo const *hair_particle)
468{
469 if (!inst_.use_curves) {
470 return;
471 }
472
473 int mat_nr = CURVES_MATERIAL_NR;
474 if (hair_particle != nullptr) {
475 mat_nr = hair_particle->psys.part->omat;
476 }
477
478 ObjectHandle ob_handle = hair_particle ?
479 ObjectHandle(ob_ref,
480 inst_.manager->resource_handle_for_psys(
481 ob_ref, ob_ref.object_to_world()),
482 hair_particle->recalc_flags,
483 hair_particle->sub_key) :
484 sync_object(ob_ref, inst_.manager->unique_handle(ob_ref));
485
486 bool has_motion = inst_.velocity.step_object_sync(ob_handle, hair_particle);
487 Material material = inst_.materials.material_get(
488 ob_handle, has_motion, mat_nr - 1, MAT_GEOM_CURVES);
489
490 auto drawcall_add = [&](const MaterialPass &matpass) {
491 if (matpass.sub_pass == nullptr) {
492 return;
493 }
494 if (hair_particle != nullptr) {
495 PassMain::Sub &sub_pass = matpass.sub_pass->sub("Hair SubPass");
496 gpu::Batch *geometry = hair_sub_pass_setup(
497 sub_pass, inst_.scene, ob_ref, &hair_particle->psys, &hair_particle->md, matpass.gpumat);
498 sub_pass.draw(geometry, ob_handle.res_handle);
499 }
500 else {
501 PassMain::Sub &sub_pass = matpass.sub_pass->sub("Curves SubPass");
502 const char *error = nullptr;
503 gpu::Batch *geometry = curves_sub_pass_setup(
504 sub_pass, inst_.scene, ob_ref.object, error, matpass.gpumat);
505 if (error) {
506 inst_.info_append(error);
507 }
508 sub_pass.draw(geometry, ob_handle.res_handle);
509 }
510 };
511
512 if (material.has_volume) {
513 /* Volumes not supported for now. */
514 if (!material.has_surface) {
515 /* Do not render surface if we are rendering a volume object
516 * and do not have a surface closure. */
517 return;
518 }
519 }
520
521 sync_common_passes(material, [&](const MaterialPass &pass) { drawcall_add(pass); });
522
523 sync_alpha_blended_passes(ob_handle, material, [&](const MaterialPass &pass, int /*instance*/) {
524 drawcall_add(pass);
525 });
526
527 sync_common(ob_handle, {&material}, {material.shading.gpumat});
528}
529
531
533{
534 uint sub_key = 1;
535
536 for (ModifierData &md : ob_ref.object->modifiers) {
538 ParticleSystem *particle_sys = reinterpret_cast<ParticleSystemModifierData *>(&md)->psys;
539 ParticleSettings *part_settings = particle_sys->part;
540 /* Only use the viewport drawing mode for material preview. */
541 const int draw_as = (part_settings->draw_as == PART_DRAW_REND || !inst.is_viewport()) ?
542 part_settings->ren_as :
543 part_settings->draw_as;
544 if (draw_as != PART_DRAW_PATH ||
546 {
547 continue;
548 }
549 callback({md, *particle_sys, uint(particle_sys->recalc), sub_key++});
550 }
551 }
552}
553
554} // namespace blender::eevee
A BVH for high poly meshes.
#define CURVES_MATERIAL_NR
#define POINTCLOUD_MATERIAL_NR
#define VOLUME_MATERIAL_NR
#define BLI_assert_msg(a, msg)
constexpr IndexRange()=default
constexpr bool is_empty() const
Definition BLI_span.hh:264
void append(const T &value)
Span< T > as_span() const
float4x4 object_to_world(int instance_index) const
ResourceHandle sub_handle(int index) const
PassBase< DrawCommandBufType > & sub(const char *name)
Definition draw_pass.hh:701
void push_constant(const char *name, const float &data)
void draw(gpu::Batch *batch, uint instance_len=-1, uint vertex_len=-1, uint vertex_first=-1, ResourceIDRange res_id={}, uint custom_id=0)
Definition draw_pass.hh:906
detail::PassBase< command::DrawMultiBuf > Sub
Definition draw_pass.hh:509
A running instance of the engine.
ObjectHandle sync_object(const ObjectRef &ob_ref, const ResourceHandleRange &res_handle, uint sub_key=0)
Definition eevee_sync.cc:32
void sync_curves(const ObjectRef &ob_ref, struct HairParticleInfo const *hair_particle=nullptr)
void sync_mesh(const ObjectRef &ob_ref)
void sync_pointcloud(const ObjectRef &ob_ref)
void sync_volume(const ObjectRef &ob_ref)
bool sync_sculpt(const ObjectRef &ob_ref)
#define layer
PassMain::Sub * volume_sub_pass(PassMain::Sub &ps, Scene *scene, Object *ob, GPUMaterial *gpu_material)
gpu::Batch * curves_sub_pass_setup(PassMain::Sub &ps, const Scene *scene, Object *ob, const char *&r_error, GPUMaterial *gpu_material=nullptr)
gpu::Batch * pointcloud_sub_pass_setup(PassMain::Sub &sub_ps, const ObjectRef &ob_ref, const ResourceHandleRange &res_handle, GPUMaterial *gpu_material=nullptr)
gpu::Batch * hair_sub_pass_setup(PassMain::Sub &sub_ps, const Scene *scene, const ObjectRef &ob_ref, ParticleSystem *psys, ModifierData *md, GPUMaterial *gpu_material=nullptr)
Definition draw_hair.cc:103
Vector< SculptBatch > sculpt_batches_per_material_get(const Object *ob, Span< const GPUMaterial * > materials)
Span< gpu::Batch * > DRW_cache_object_surface_material_get(Object *ob, const Span< const GPUMaterial * > materials)
FunctionRef< void(const HairParticleInfo &)> HairHandleCallback
Definition eevee_sync.hh:94
static void geometry_call(PassMain::Sub *sub_pass, gpu::Batch *geom, ResourceHandleRange resource_handle)
Definition eevee_sync.cc:45
static void geometry_volume_call(PassMain::Sub *pass, GPUMaterial *gpumat, Scene *scene, Object *ob, gpu::Batch *geom, ResourceHandle res_handle)
Definition eevee_sync.cc:54
void foreach_hair_particle(Instance &inst, ObjectRef &ob_ref, HairHandleCallback callback)
T max(const T &a, const T &b)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool GPU_material_has_displacement_output(GPUMaterial *mat)
unsigned int uint
Definition BKE_text.h:55
@ eModifierType_ParticleSystem
@ GPU_MATFLAG_SHADOW_OFFSET
@ GPU_MATFLAG_SCENE_TIME
bool GPU_material_flag_get(const GPUMaterial *mat, eGPUMaterialFlag flag)
bool DRW_object_is_visible_psys_in_active_context(const Object *object, const ParticleSystem *psys)
ListBaseT< GPUMaterialAttribute > GPU_material_attributes(const GPUMaterial *material)
bool BKE_sculptsession_use_pbvh_draw(const Object *ob, const RegionView3D *rv3d)
Material * GPU_material_get_material(GPUMaterial *material)
bool is_alpha_blend_transparent
MaterialPass overlap_masking
MaterialPass volume_material
bool has_transparent_shadows
MaterialPass volume_occupancy
MaterialPass shading
ListBaseT< ModifierData > modifiers
Vector< GPUMaterial * > gpu_materials
MaterialPass lightprobe_sphere_shading
MaterialPass lightprobe_sphere_prepass
ObjectHandle(const ObjectRef &ob_ref, const ResourceHandleRange &res_handle, uint recalc, uint sub_key=0)
Definition eevee_sync.hh:41
const ResourceHandleRange res_handle
Definition eevee_sync.hh:39
VolumeObjectBounds(const Camera &camera, const ObjectHandle &ob_handle, int instance_index)