Blender  V3.3
scene.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0
2  * Copyright 2011-2022 Blender Foundation */
3 
4 #ifndef __SCENE_H__
5 #define __SCENE_H__
6 
7 #include "bvh/params.h"
8 
9 #include "scene/film.h"
10 #include "scene/image.h"
11 #include "scene/shader.h"
12 
13 #include "device/device.h"
14 #include "device/memory.h"
15 
16 #include "util/param.h"
17 #include "util/string.h"
18 #include "util/system.h"
19 #include "util/texture.h"
20 #include "util/thread.h"
21 #include "util/types.h"
22 #include "util/vector.h"
23 
25 
26 class AlembicProcedural;
28 class Background;
29 class BVH;
30 class Camera;
31 class Device;
32 class DeviceInfo;
33 class Film;
34 class Integrator;
35 class Light;
36 class LightManager;
37 class LookupTables;
38 class Geometry;
39 class GeometryManager;
40 class Object;
41 class ObjectManager;
43 class ParticleSystem;
44 class PointCloud;
45 class Procedural;
46 class ProceduralManager;
47 class CurveSystemManager;
48 class Shader;
49 class ShaderManager;
50 class Progress;
51 class BakeManager;
52 class BakeData;
53 class RenderStats;
54 class SceneUpdateStats;
55 class Volume;
56 
57 /* Scene Device Data */
58 
59 class DeviceScene {
60  public:
61  /* BVH */
70 
71  /* mesh */
78 
82 
84 
85  /* point-cloud */
88 
89  /* objects */
96 
97  /* cameras */
99 
100  /* attributes */
107 
108  /* lights */
113 
114  /* particles */
116 
117  /* shaders */
120 
121  /* lookup tables */
123 
124  /* integrator */
126 
127  /* IES lights */
129 
131 
132  DeviceScene(Device *device);
133 };
134 
135 /* Scene Parameters */
136 
137 class SceneParams {
138  public:
140 
141  /* Requested BVH layout.
142  *
143  * If it's not supported by the device, the widest one from supported ones
144  * will be used, but BVH wider than this one will never be used.
145  */
147 
156 
158 
160  {
164  use_bvh_spatial_split = false;
167  num_bvh_time_steps = 0;
168  hair_subdivisions = 3;
170  texture_limit = 0;
171  background = true;
172  }
173 
174  bool modified(const SceneParams &params) const
175  {
176  return !(shadingsystem == params.shadingsystem && bvh_layout == params.bvh_layout &&
177  bvh_type == params.bvh_type &&
178  use_bvh_spatial_split == params.use_bvh_spatial_split &&
179  use_bvh_compact_structure == params.use_bvh_compact_structure &&
180  use_bvh_unaligned_nodes == params.use_bvh_unaligned_nodes &&
181  num_bvh_time_steps == params.num_bvh_time_steps &&
182  hair_subdivisions == params.hair_subdivisions && hair_shape == params.hair_shape &&
183  texture_limit == params.texture_limit);
184  }
185 
187  {
188  /* Matching the tessellation rate limit in Embree. */
189  return clamp(1 << hair_subdivisions, 1, 16);
190  }
191 };
192 
193 /* Scene */
194 
195 class Scene : public NodeOwner {
196  public:
197  /* Optional name. Is used for logging and reporting. */
198  string name;
199 
200  /* Maps from Light group names to their pass ID. */
201  map<ustring, int> lightgroups;
202 
203  /* data */
211 
212  /* data lists */
220 
221  /* data managers */
230 
231  /* default shaders */
237 
238  /* device */
241 
242  /* parameters */
244 
245  /* mutex must be locked manually by callers */
247 
248  /* scene update statistics */
250 
252  ~Scene();
253 
254  void device_update(Device *device, Progress &progress);
255 
258 
260  MotionType need_motion() const;
261  float motion_shutter_time();
262 
263  bool need_update();
264  bool need_reset();
265 
266  void reset();
267  void device_free();
268 
269  void collect_statistics(RenderStats *stats);
270 
271  void enable_update_stats();
272 
273  bool update(Progress &progress);
274 
275  bool has_shadow_catcher();
277 
278  /* This function is used to create a node of a specified type instead of
279  * calling 'new', and sets the scene as the owner of the node.
280  * The function has overloads that will also add the created node to the right
281  * node array (e.g. Scene::geometry for Geometry nodes) and tag the appropriate
282  * manager for an update.
283  */
284  template<typename T, typename... Args> T *create_node(Args &&...args)
285  {
286  T *node = new T(args...);
287  node->set_owner(this);
288  return node;
289  }
290 
291  /* This function is used to delete a node from the scene instead of calling 'delete'
292  * and manually removing the node from the data array. It also tags the
293  * appropriate manager for an update, if any, and checks that the scene is indeed
294  * the owner of the node. Calling this function on a node not owned by the scene
295  * will likely cause a crash which we want in order to detect such cases.
296  */
297  template<typename T> void delete_node(T *node)
298  {
299  assert(node->get_owner() == this);
301  }
302 
303  /* Same as above, but specify the actual owner.
304  */
305  template<typename T> void delete_node(T *node, const NodeOwner *owner)
306  {
307  assert(node->get_owner() == owner);
309  (void)owner;
310  }
311 
312  /* Remove all nodes in the set from the appropriate data arrays, and tag the
313  * specific managers for an update. This assumes that the scene owns the nodes.
314  */
315  template<typename T> void delete_nodes(const set<T *> &nodes)
316  {
317  delete_nodes(nodes, this);
318  }
319 
320  /* Same as above, but specify the actual owner of all the nodes in the set.
321  */
322  template<typename T> void delete_nodes(const set<T *> &nodes, const NodeOwner *owner);
323 
324  protected:
325  /* Check if some heavy data worth logging was updated.
326  * Mainly used to suppress extra annoying logging.
327  */
328  bool need_data_update();
329 
330  void free_memory(bool final);
331 
334 
335  void update_kernel_features();
336  bool load_kernels(Progress &progress, bool lock_scene = true);
337 
338  bool has_shadow_catcher_ = false;
340 
341  /* Maximum number of closure during session lifetime. */
343 
344  /* Get maximum number of closures to be used in kernel. */
345  int get_max_closure_count();
346 
347  /* Get size of a volume stack needed to render this scene. */
348  int get_volume_stack_size() const;
349 
350  template<typename T> void delete_node_impl(T *node)
351  {
352  delete node;
353  }
354 };
355 
356 template<> Light *Scene::create_node<Light>();
357 
358 template<> Mesh *Scene::create_node<Mesh>();
359 
360 template<> Object *Scene::create_node<Object>();
361 
362 template<> Hair *Scene::create_node<Hair>();
363 
364 template<> Volume *Scene::create_node<Volume>();
365 
366 template<> PointCloud *Scene::create_node<PointCloud>();
367 
368 template<> ParticleSystem *Scene::create_node<ParticleSystem>();
369 
370 template<> Shader *Scene::create_node<Shader>();
371 
372 template<> AlembicProcedural *Scene::create_node<AlembicProcedural>();
373 
374 template<> Pass *Scene::create_node<Pass>();
375 
376 template<> void Scene::delete_node_impl(Light *node);
377 
378 template<> void Scene::delete_node_impl(Mesh *node);
379 
380 template<> void Scene::delete_node_impl(Volume *node);
381 
382 template<> void Scene::delete_node_impl(PointCloud *node);
383 
384 template<> void Scene::delete_node_impl(Hair *node);
385 
386 template<> void Scene::delete_node_impl(Geometry *node);
387 
388 template<> void Scene::delete_node_impl(Object *node);
389 
391 
392 template<> void Scene::delete_node_impl(Shader *node);
393 
394 template<> void Scene::delete_node_impl(Procedural *node);
395 
396 template<> void Scene::delete_node_impl(AlembicProcedural *node);
397 
398 template<> void Scene::delete_node_impl(Pass *node);
399 
400 template<> void Scene::delete_nodes(const set<Light *> &nodes, const NodeOwner *owner);
401 
402 template<> void Scene::delete_nodes(const set<Geometry *> &nodes, const NodeOwner *owner);
403 
404 template<> void Scene::delete_nodes(const set<Object *> &nodes, const NodeOwner *owner);
405 
406 template<> void Scene::delete_nodes(const set<ParticleSystem *> &nodes, const NodeOwner *owner);
407 
408 template<> void Scene::delete_nodes(const set<Shader *> &nodes, const NodeOwner *owner);
409 
410 template<> void Scene::delete_nodes(const set<Procedural *> &nodes, const NodeOwner *owner);
411 
412 template<> void Scene::delete_nodes(const set<Pass *> &nodes, const NodeOwner *owner);
413 
415 
416 #endif /* __SCENE_H__ */
unsigned int uint
Definition: BLI_sys_types.h:67
Definition: bvh/bvh.h:63
device_vector< DecomposedTransform > object_motion
Definition: scene.h:92
device_vector< uint > points_shader
Definition: scene.h:87
device_vector< float2 > prim_time
Definition: scene.h:69
device_vector< uint > patches
Definition: scene.h:83
device_vector< float4 > points
Definition: scene.h:86
device_vector< uint > prim_visibility
Definition: scene.h:66
device_vector< uint4 > tri_vindex
Definition: scene.h:75
device_vector< KernelShader > shaders
Definition: scene.h:119
device_vector< float4 > attributes_float4
Definition: scene.h:105
device_vector< KernelCurveSegment > curve_segments
Definition: scene.h:81
device_vector< float2 > attributes_float2
Definition: scene.h:103
device_vector< Transform > object_motion_pass
Definition: scene.h:91
device_vector< float > object_volume_step
Definition: scene.h:94
device_vector< AttributeMap > attributes_map
Definition: scene.h:101
device_vector< KernelCurve > curves
Definition: scene.h:79
device_vector< int > object_node
Definition: scene.h:64
device_vector< float2 > light_background_marginal_cdf
Definition: scene.h:111
device_vector< packed_float3 > attributes_float3
Definition: scene.h:104
DeviceScene(Device *device)
Definition: scene.cpp:36
device_vector< float > lookup_table
Definition: scene.h:122
device_vector< int > prim_object
Definition: scene.h:68
device_vector< uint > object_prim_offset
Definition: scene.h:95
device_vector< float4 > curve_keys
Definition: scene.h:80
device_vector< packed_float3 > tri_vnormal
Definition: scene.h:74
device_vector< float > ies_lights
Definition: scene.h:128
device_vector< float2 > light_background_conditional_cdf
Definition: scene.h:112
device_vector< KernelParticle > particles
Definition: scene.h:115
device_vector< KernelLightDistribution > light_distribution
Definition: scene.h:109
device_vector< int4 > bvh_leaf_nodes
Definition: scene.h:63
device_vector< float > sample_pattern_lut
Definition: scene.h:125
device_vector< uint > tri_shader
Definition: scene.h:73
device_vector< packed_float3 > tri_verts
Definition: scene.h:72
device_vector< uint > object_flag
Definition: scene.h:93
device_vector< DecomposedTransform > camera_motion
Definition: scene.h:98
device_vector< float > attributes_float
Definition: scene.h:102
device_vector< int4 > svm_nodes
Definition: scene.h:118
device_vector< float2 > tri_patch_uv
Definition: scene.h:77
device_vector< uint > tri_patch
Definition: scene.h:76
KernelData data
Definition: scene.h:130
device_vector< int > prim_type
Definition: scene.h:65
device_vector< KernelLight > lights
Definition: scene.h:110
device_vector< int4 > bvh_nodes
Definition: scene.h:62
device_vector< KernelObject > objects
Definition: scene.h:90
device_vector< int > prim_index
Definition: scene.h:67
device_vector< uchar4 > attributes_uchar4
Definition: scene.h:106
Definition: film.h:29
Definition: hair.h:13
Definition: pass.h:48
BVHLayout bvh_layout
Definition: scene.h:146
bool background
Definition: scene.h:157
bool use_bvh_unaligned_nodes
Definition: scene.h:151
int texture_limit
Definition: scene.h:155
SceneParams()
Definition: scene.h:159
bool use_bvh_spatial_split
Definition: scene.h:149
int curve_subdivisions()
Definition: scene.h:186
CurveShapeType hair_shape
Definition: scene.h:154
int num_bvh_time_steps
Definition: scene.h:152
int hair_subdivisions
Definition: scene.h:153
bool modified(const SceneParams &params) const
Definition: scene.h:174
BVHType bvh_type
Definition: scene.h:148
bool use_bvh_compact_structure
Definition: scene.h:150
ShadingSystem shadingsystem
Definition: scene.h:139
#define CCL_NAMESPACE_END
Definition: cuda/compat.h:9
OperationNode * node
SyclQueue void void size_t num_bytes void
uiWidgetBaseParameters params[MAX_WIDGET_BASE_BATCH]
AttributeStandard
Definition: kernel/types.h:612
CurveShapeType
Definition: kernel/types.h:581
@ CURVE_RIBBON
Definition: kernel/types.h:582
@ BVH_LAYOUT_AUTO
#define T
T clamp(const T &a, const T &min, const T &max)
CCL_NAMESPACE_BEGIN typedef KernelBVHLayout BVHLayout
Definition: params.h:19
BVHType
Definition: params.h:24
@ BVH_TYPE_DYNAMIC
Definition: params.h:30
ShadingSystem
Definition: scene/shader.h:34
@ SHADINGSYSTEM_SVM
Definition: scene/shader.h:34
bool kernels_loaded
Definition: scene.h:332
BakeManager * bake_manager
Definition: scene.h:228
Film * film
Definition: scene.h:208
string name
Definition: scene.h:198
BVH * bvh
Definition: scene.h:204
T * create_node(Args &&...args)
Definition: scene.h:284
bool need_global_attribute(AttributeStandard std)
Definition: scene.cpp:405
ParticleSystemManager * particle_system_manager
Definition: scene.h:227
vector< Geometry * > geometry
Definition: scene.h:214
MotionType need_motion() const
Definition: scene.cpp:387
void need_global_attributes(AttributeRequestSet &attributes)
Definition: scene.cpp:421
bool update(Progress &progress)
Definition: scene.cpp:574
vector< Pass * > passes
Definition: scene.h:218
Device * device
Definition: scene.h:239
vector< Shader * > shaders
Definition: scene.h:215
vector< Procedural * > procedurals
Definition: scene.h:219
int get_max_closure_count()
Definition: scene.cpp:661
~Scene()
Definition: scene.cpp:128
void device_free()
Definition: scene.cpp:468
bool load_kernels(Progress &progress, bool lock_scene=true)
Definition: scene.cpp:626
bool has_shadow_catcher_
Definition: scene.h:338
Shader * default_volume
Definition: scene.h:233
Camera * dicing_camera
Definition: scene.h:206
LookupTables * lookup_tables
Definition: scene.h:207
SceneParams params
Definition: scene.h:243
vector< Light * > lights
Definition: scene.h:216
Shader * default_surface
Definition: scene.h:232
void tag_shadow_catcher_modified()
Definition: scene.cpp:754
void free_memory(bool final)
Definition: scene.cpp:133
Shader * default_empty
Definition: scene.h:236
vector< ParticleSystem * > particle_systems
Definition: scene.h:217
ImageManager * image_manager
Definition: scene.h:222
void enable_update_stats()
Definition: scene.cpp:479
Shader * default_background
Definition: scene.h:235
uint loaded_kernel_features
Definition: scene.h:333
vector< Object * > objects
Definition: scene.h:213
ObjectManager * object_manager
Definition: scene.h:226
void delete_node(T *node)
Definition: scene.h:297
bool shadow_catcher_modified_
Definition: scene.h:339
Background * background
Definition: scene.h:209
MotionType
Definition: scene.h:259
@ MOTION_PASS
Definition: scene.h:259
@ MOTION_NONE
Definition: scene.h:259
@ MOTION_BLUR
Definition: scene.h:259
void update_kernel_features()
Definition: scene.cpp:486
void delete_nodes(const set< T * > &nodes)
Definition: scene.h:315
Camera * camera
Definition: scene.h:205
bool has_shadow_catcher()
Definition: scene.cpp:737
ProceduralManager * procedural_manager
Definition: scene.h:229
ShaderManager * shader_manager
Definition: scene.h:224
void delete_node_impl(T *node)
Definition: scene.h:350
int max_closure_global
Definition: scene.h:342
Integrator * integrator
Definition: scene.h:210
LightManager * light_manager
Definition: scene.h:223
thread_mutex mutex
Definition: scene.h:246
bool need_data_update()
Definition: scene.cpp:433
int get_volume_stack_size() const
Definition: scene.cpp:693
bool need_update()
Definition: scene.cpp:428
Shader * default_light
Definition: scene.h:234
void delete_node(T *node, const NodeOwner *owner)
Definition: scene.h:305
map< ustring, int > lightgroups
Definition: scene.h:201
void reset()
Definition: scene.cpp:448
void collect_statistics(RenderStats *stats)
Definition: scene.cpp:473
bool need_reset()
Definition: scene.cpp:443
SceneUpdateStats * update_stats
Definition: scene.h:249
GeometryManager * geometry_manager
Definition: scene.h:225
DeviceScene dscene
Definition: scene.h:240
void delete_nodes(const set< T * > &nodes, const NodeOwner *owner)
float motion_shutter_time()
Definition: scene.cpp:397
Scene(const SceneParams &params, Device *device)
Definition: scene.cpp:84
void device_update(Device *device, Progress &progress)
Definition: scene.cpp:223
CCL_NAMESPACE_BEGIN typedef std::mutex thread_mutex
Definition: thread.h:27