Differential D12367 Diff 41308 intern/cycles/render/scene.h

Changeset View

Standalone View

intern/cycles/render/scene.h

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines	public:

DeviceScene(Device *device);		DeviceScene(Device *device);
};		};

/* Scene Parameters */		/* Scene Parameters */

class SceneParams {		class SceneParams {
public:		public:
/* Type of BVH, in terms whether it is supported dynamic updates of meshes
* or whether modifying geometry requires full BVH rebuild.
*/
enum BVHType {
/* BVH supports dynamic updates of geometry.
*
* Faster for updating BVH tree when doing modifications in viewport,
* but slower for rendering.
*/
BVH_DYNAMIC = 0,
/* BVH tree is calculated for specific scene, updates in geometry
* requires full tree rebuild.
*
* Slower to update BVH tree when modifying objects in viewport, also
* slower to build final BVH tree but gives best possible render speed.
*/
BVH_STATIC = 1,

BVH_NUM_TYPES,
};

ShadingSystem shadingsystem;		ShadingSystem shadingsystem;

/* Requested BVH layout.		/* Requested BVH layout.
*		*
* If it's not supported by the device, the widest one from supported ones		* If it's not supported by the device, the widest one from supported ones
* will be used, but BVH wider than this one will never be used.		* will be used, but BVH wider than this one will never be used.
*/		*/
BVHLayout bvh_layout;		BVHLayout bvh_layout;

BVHType bvh_type;		BVHType bvh_type;
bool use_bvh_spatial_split;		bool use_bvh_spatial_split;
bool use_bvh_unaligned_nodes;		bool use_bvh_unaligned_nodes;
int num_bvh_time_steps;		int num_bvh_time_steps;
int hair_subdivisions;		int hair_subdivisions;
CurveShapeType hair_shape;		CurveShapeType hair_shape;
int texture_limit;		int texture_limit;

bool background;		bool background;

SceneParams()		SceneParams()
{		{
shadingsystem = SHADINGSYSTEM_SVM;		shadingsystem = SHADINGSYSTEM_SVM;
bvh_layout = BVH_LAYOUT_BVH2;		bvh_layout = BVH_LAYOUT_BVH2;
bvh_type = BVH_DYNAMIC;		bvh_type = BVH_TYPE_DYNAMIC;
use_bvh_spatial_split = false;		use_bvh_spatial_split = false;
use_bvh_unaligned_nodes = true;		use_bvh_unaligned_nodes = true;
num_bvh_time_steps = 0;		num_bvh_time_steps = 0;
hair_subdivisions = 3;		hair_subdivisions = 3;
hair_shape = CURVE_RIBBON;		hair_shape = CURVE_RIBBON;
texture_limit = 0;		texture_limit = 0;
background = true;		background = true;
}		}

bool modified(const SceneParams &params)		bool modified(const SceneParams &params) const
{		{
return !(shadingsystem == params.shadingsystem && bvh_layout == params.bvh_layout &&		return !(shadingsystem == params.shadingsystem && bvh_layout == params.bvh_layout &&
bvh_type == params.bvh_type &&		bvh_type == params.bvh_type &&
use_bvh_spatial_split == params.use_bvh_spatial_split &&		use_bvh_spatial_split == params.use_bvh_spatial_split &&
use_bvh_unaligned_nodes == params.use_bvh_unaligned_nodes &&		use_bvh_unaligned_nodes == params.use_bvh_unaligned_nodes &&
num_bvh_time_steps == params.num_bvh_time_steps &&		num_bvh_time_steps == params.num_bvh_time_steps &&
hair_subdivisions == params.hair_subdivisions && hair_shape == params.hair_shape &&		hair_subdivisions == params.hair_subdivisions && hair_shape == params.hair_shape &&
texture_limit == params.texture_limit);		texture_limit == params.texture_limit);
Show All 23 Lines	public:
Integrator *integrator;		Integrator *integrator;

/* data lists */		/* data lists */
vector<Object *> objects;		vector<Object *> objects;
vector<Geometry *> geometry;		vector<Geometry *> geometry;
vector<Shader *> shaders;		vector<Shader *> shaders;
vector<Light *> lights;		vector<Light *> lights;
vector<ParticleSystem *> particle_systems;		vector<ParticleSystem *> particle_systems;
vector<Pass> passes;		vector<Pass *> passes;
vector<Procedural *> procedurals;		vector<Procedural *> procedurals;

/* data managers */		/* data managers */
ImageManager *image_manager;		ImageManager *image_manager;
LightManager *light_manager;		LightManager *light_manager;
ShaderManager *shader_manager;		ShaderManager *shader_manager;
GeometryManager *geometry_manager;		GeometryManager *geometry_manager;
ObjectManager *object_manager;		ObjectManager *object_manager;
Show All 38 Lines	public:

void reset();		void reset();
void device_free();		void device_free();

void collect_statistics(RenderStats *stats);		void collect_statistics(RenderStats *stats);

void enable_update_stats();		void enable_update_stats();

bool update(Progress &progress, bool &kernel_switch_needed);		void update_kernel_features();
		bool update(Progress &progress);

		bool has_shadow_catcher();
		void tag_shadow_catcher_modified();

/* This function is used to create a node of a specified type instead of		/* This function is used to create a node of a specified type instead of
* calling 'new', and sets the scene as the owner of the node.		* calling 'new', and sets the scene as the owner of the node.
* The function has overloads that will also add the created node to the right		* The function has overloads that will also add the created node to the right
* node array (e.g. Scene::geometry for Geometry nodes) and tag the appropriate		* node array (e.g. Scene::geometry for Geometry nodes) and tag the appropriate
* manager for an update.		* manager for an update.
*/		*/
template<typename T, typename... Args> T *create_node(Args &&...args)		template<typename T, typename... Args> T *create_node(Args &&...args)
Show All 40 Lines	protected:
/* Check if some heavy data worth logging was updated.		/* Check if some heavy data worth logging was updated.
* Mainly used to suppress extra annoying logging.		* Mainly used to suppress extra annoying logging.
*/		*/
bool need_data_update();		bool need_data_update();

void free_memory(bool final);		void free_memory(bool final);

bool kernels_loaded;		bool kernels_loaded;
DeviceRequestedFeatures loaded_kernel_features;		uint loaded_kernel_features;

bool load_kernels(Progress &progress, bool lock_scene = true);		bool load_kernels(Progress &progress, bool lock_scene = true);

/* Split kernel routines */		bool has_shadow_catcher_ = false;
		bool shadow_catcher_modified_ = true;
DeviceRequestedFeatures get_requested_device_features();

/* Maximum number of closure during session lifetime. */		/* Maximum number of closure during session lifetime. */
int max_closure_global;		int max_closure_global;

/* Get maximum number of closures to be used in kernel. */		/* Get maximum number of closures to be used in kernel. */
int get_max_closure_count();		int get_max_closure_count();

template<typename T> void delete_node_impl(T *node)		template<typename T> void delete_node_impl(T *node)
Show All 13 Lines
template<> Volume *Scene::create_node<Volume>();		template<> Volume *Scene::create_node<Volume>();

template<> ParticleSystem *Scene::create_node<ParticleSystem>();		template<> ParticleSystem *Scene::create_node<ParticleSystem>();

template<> Shader *Scene::create_node<Shader>();		template<> Shader *Scene::create_node<Shader>();

template<> AlembicProcedural *Scene::create_node<AlembicProcedural>();		template<> AlembicProcedural *Scene::create_node<AlembicProcedural>();

		template<> Pass *Scene::create_node<Pass>();

template<> void Scene::delete_node_impl(Light *node);		template<> void Scene::delete_node_impl(Light *node);

template<> void Scene::delete_node_impl(Mesh *node);		template<> void Scene::delete_node_impl(Mesh *node);

template<> void Scene::delete_node_impl(Volume *node);		template<> void Scene::delete_node_impl(Volume *node);

template<> void Scene::delete_node_impl(Hair *node);		template<> void Scene::delete_node_impl(Hair *node);

template<> void Scene::delete_node_impl(Geometry *node);		template<> void Scene::delete_node_impl(Geometry *node);

template<> void Scene::delete_node_impl(Object *node);		template<> void Scene::delete_node_impl(Object *node);

template<> void Scene::delete_node_impl(ParticleSystem *node);		template<> void Scene::delete_node_impl(ParticleSystem *node);

template<> void Scene::delete_node_impl(Shader *node);		template<> void Scene::delete_node_impl(Shader *node);

template<> void Scene::delete_node_impl(Procedural *node);		template<> void Scene::delete_node_impl(Procedural *node);

template<> void Scene::delete_node_impl(AlembicProcedural *node);		template<> void Scene::delete_node_impl(AlembicProcedural *node);

		template<> void Scene::delete_node_impl(Pass *node);

template<> void Scene::delete_nodes(const set<Light > &nodes, const NodeOwner owner);		template<> void Scene::delete_nodes(const set<Light > &nodes, const NodeOwner owner);

template<> void Scene::delete_nodes(const set<Geometry > &nodes, const NodeOwner owner);		template<> void Scene::delete_nodes(const set<Geometry > &nodes, const NodeOwner owner);

template<> void Scene::delete_nodes(const set<Object > &nodes, const NodeOwner owner);		template<> void Scene::delete_nodes(const set<Object > &nodes, const NodeOwner owner);

template<> void Scene::delete_nodes(const set<ParticleSystem > &nodes, const NodeOwner owner);		template<> void Scene::delete_nodes(const set<ParticleSystem > &nodes, const NodeOwner owner);

template<> void Scene::delete_nodes(const set<Shader > &nodes, const NodeOwner owner);		template<> void Scene::delete_nodes(const set<Shader > &nodes, const NodeOwner owner);

template<> void Scene::delete_nodes(const set<Procedural > &nodes, const NodeOwner owner);		template<> void Scene::delete_nodes(const set<Procedural > &nodes, const NodeOwner owner);

		template<> void Scene::delete_nodes(const set<Pass > &nodes, const NodeOwner owner);

CCL_NAMESPACE_END		CCL_NAMESPACE_END

#endif /* __SCENE_H__ */		#endif /* __SCENE_H__ */