Differential D10082 Diff 32640 intern/cycles/render/film.cpp

Changeset View

Standalone View

intern/cycles/render/film.cpp

Show All 29 Lines
#include "util/util_time.h"		#include "util/util_time.h"

CCL_NAMESPACE_BEGIN		CCL_NAMESPACE_BEGIN

/* Pass */		/* Pass */

static bool compare_pass_order(const Pass &a, const Pass &b)		static bool compare_pass_order(const Pass &a, const Pass &b)
{		{
if (a.components == b.components)		if (a.get_components() == b.get_components())
return (a.type < b.type);		return (a.get_pass_type() < b.get_pass_type());
return (a.components > b.components);		return (a.get_components() > b.get_components());
}		}

static NodeEnum *get_pass_type_enum()		static NodeEnum *get_pass_type_enum()
{		{
static NodeEnum pass_type_enum;		static NodeEnum pass_type_enum;
pass_type_enum.insert("combined", PASS_COMBINED);		pass_type_enum.insert("combined", PASS_COMBINED);
pass_type_enum.insert("depth", PASS_DEPTH);		pass_type_enum.insert("depth", PASS_DEPTH);
pass_type_enum.insert("normal", PASS_NORMAL);		pass_type_enum.insert("normal", PASS_NORMAL);
Show All 36 Lines	#endif
return &pass_type_enum;		return &pass_type_enum;
}		}

NODE_DEFINE(Pass)		NODE_DEFINE(Pass)
{		{
NodeType *type = NodeType::add("pass", create);		NodeType *type = NodeType::add("pass", create);

NodeEnum *pass_type_enum = get_pass_type_enum();		NodeEnum *pass_type_enum = get_pass_type_enum();
SOCKET_ENUM(type, "Type", *pass_type_enum, PASS_COMBINED);		SOCKET_ENUM(pass_type, "Type", *pass_type_enum, PASS_COMBINED);
SOCKET_STRING(name, "Name", ustring());

return type;		return type;
}		}

Pass::Pass() : Node(node_type)		Pass::Pass() : Node(node_type)
{		{
}		}

void Pass::add(PassType type, vector<Pass> &passes, const char *name)		void Pass::add(PassType type, vector<Pass> &passes, const char *name)
{		{
for (size_t i = 0; i < passes.size(); i++) {		for (size_t i = 0; i < passes.size(); i++) {
if (passes[i].type != type) {		if (passes[i].get_pass_type() != type) {
continue;		continue;
}		}

/* An empty name is used as a placeholder to signal that any pass of		/* An empty name is used as a placeholder to signal that any pass of
* that type is fine (because the content always is the same).		* that type is fine (because the content always is the same).
* This is important to support divide_type: If the pass that has a		* This is important to support divide_type: If the pass that has a
* divide_type is added first, a pass for divide_type with an empty		* divide_type is added first, a pass for divide_type with an empty
* name will be added. Then, if a matching pass with a name is later		* name will be added. Then, if a matching pass with a name is later
Show All 17 Lines	for (size_t i = 0; i < passes.size(); i++) {
* must match. */		* must match. */
if (name == passes[i].name) {		if (name == passes[i].name) {
return;		return;
}		}
}		}

Pass pass;		Pass pass;

pass.type = type;		pass.pass_type = type;
pass.filter = true;		pass.filter = true;
pass.exposure = false;		pass.exposure = false;
pass.divide_type = PASS_NONE;		pass.divide_type = PASS_NONE;
if (name) {		if (name) {
pass.name = name;		pass.name = name;
}		}

switch (type) {		switch (type) {
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines	if (A[i].type != B[i].type \|\| A[i].name != B[i].name)
return false;		return false;

return true;		return true;
}		}

bool Pass::contains(const vector<Pass> &passes, PassType type)		bool Pass::contains(const vector<Pass> &passes, PassType type)
{		{
for (size_t i = 0; i < passes.size(); i++)		for (size_t i = 0; i < passes.size(); i++)
if (passes[i].type == type)		if (passes[i].get_pass_type() == type)
return true;		return true;

return false;		return false;
}		}

/* Pixel Filter */		/* Pixel Filter */

static float filter_func_box(float /v/, float /width/)		static float filter_func_box(float /v/, float /width/)
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
}		}

Film::~Film()		Film::~Film()
{		{
}		}

void Film::add_default(Scene *scene)		void Film::add_default(Scene *scene)
{		{
Pass::add(PASS_COMBINED, scene->passes);		Pass::add(PASS_COMBINED, scene->get_passes());
}		}

void Film::device_update(Device device, DeviceScene dscene, Scene *scene)		void Film::device_update(Device device, DeviceScene dscene, Scene *scene)
{		{
if (!is_modified())		if (!is_modified())
return;		return;

scoped_callback_timer timer([scene](double time) {		scoped_callback_timer timer([scene](double time) {
if (scene->update_stats) {		if (scene->get_update_stats()) {
scene->update_stats->film.times.add_entry({"update", time});		scene->get_update_stats()->film.times.add_entry({"update", time});
}		}
});		});

device_free(device, dscene, scene);		device_free(device, dscene, scene);

KernelFilm *kfilm = &dscene->data.film;		KernelFilm *kfilm = &dscene->data.film;

/* update __data */		/* update __data */
Show All 9 Lines	void Film::device_update(Device device, DeviceScene dscene, Scene *scene)
kfilm->light_pass_flag = 0;		kfilm->light_pass_flag = 0;
kfilm->pass_stride = 0;		kfilm->pass_stride = 0;
kfilm->use_light_pass = use_light_visibility;		kfilm->use_light_pass = use_light_visibility;
kfilm->pass_aov_value_num = 0;		kfilm->pass_aov_value_num = 0;
kfilm->pass_aov_color_num = 0;		kfilm->pass_aov_color_num = 0;

bool have_cryptomatte = false;		bool have_cryptomatte = false;

for (size_t i = 0; i < scene->passes.size(); i++) {		for (size_t i = 0; i < scene->get_passes().size(); i++) {
Pass &pass = scene->passes[i];		Pass &pass = scene->get_passes()[i];

if (pass.type == PASS_NONE) {		if (pass.get_pass_type() == PASS_NONE) {
continue;		continue;
}		}

/* Can't do motion pass if no motion vectors are available. */		/* Can't do motion pass if no motion vectors are available. */
if (pass.type == PASS_MOTION \|\| pass.type == PASS_MOTION_WEIGHT) {		if (pass.get_pass_type() == PASS_MOTION \|\| pass.get_pass_type() == PASS_MOTION_WEIGHT) {
if (scene->need_motion() != Scene::MOTION_PASS) {		if (scene->need_motion() != Scene::MOTION_PASS) {
kfilm->pass_stride += pass.components;		kfilm->pass_stride += pass.get_components();
continue;		continue;
}		}
}		}

int pass_flag = (1 << (pass.type % 32));		int pass_flag = (1 << (pass.get_pass_type() % 32));
if (pass.type <= PASS_CATEGORY_MAIN_END) {		if (pass.get_pass_type() <= PASS_CATEGORY_MAIN_END) {
kfilm->pass_flag \|= pass_flag;		kfilm->pass_flag \|= pass_flag;
}		}
else if (pass.type <= PASS_CATEGORY_LIGHT_END) {		else if (pass.get_pass_type() <= PASS_CATEGORY_LIGHT_END) {
kfilm->use_light_pass = 1;		kfilm->use_light_pass = 1;
kfilm->light_pass_flag \|= pass_flag;		kfilm->light_pass_flag \|= pass_flag;
}		}
else {		else {
assert(pass.type <= PASS_CATEGORY_BAKE_END);		assert(pass.get_pass_type() <= PASS_CATEGORY_BAKE_END);
}		}

switch (pass.type) {		switch (pass.get_pass_type()) {
case PASS_COMBINED:		case PASS_COMBINED:
kfilm->pass_combined = kfilm->pass_stride;		kfilm->pass_combined = kfilm->pass_stride;
break;		break;
case PASS_DEPTH:		case PASS_DEPTH:
kfilm->pass_depth = kfilm->pass_stride;		kfilm->pass_depth = kfilm->pass_stride;
break;		break;
case PASS_NORMAL:		case PASS_NORMAL:
kfilm->pass_normal = kfilm->pass_stride;		kfilm->pass_normal = kfilm->pass_stride;
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines	#endif
}		}
kfilm->pass_aov_value_num++;		kfilm->pass_aov_value_num++;
break;		break;
default:		default:
assert(false);		assert(false);
break;		break;
}		}

if (pass.type == display_pass) {		if (pass.get_pass_type() == display_pass) {
kfilm->display_pass_stride = kfilm->pass_stride;		kfilm->display_pass_stride = kfilm->pass_stride;
kfilm->display_pass_components = pass.components;		kfilm->display_pass_components = pass.get_components();
kfilm->use_display_exposure = pass.exposure && (kfilm->exposure != 1.0f);		kfilm->use_display_exposure = pass.get_exposure() && (kfilm->exposure != 1.0f);
}		}
else if (pass.type == PASS_DIFFUSE_COLOR \|\| pass.type == PASS_TRANSMISSION_COLOR \|\|		else if (pass.get_pass_type() == PASS_DIFFUSE_COLOR \|\|
pass.type == PASS_GLOSSY_COLOR) {		pass.get_pass_type() == PASS_TRANSMISSION_COLOR \|\|
		pass.get_pass_type() == PASS_GLOSSY_COLOR) {
kfilm->display_divide_pass_stride = kfilm->pass_stride;		kfilm->display_divide_pass_stride = kfilm->pass_stride;
}		}

kfilm->pass_stride += pass.components;		kfilm->pass_stride += pass.get_components();
}		}

kfilm->pass_denoising_data = 0;		kfilm->pass_denoising_data = 0;
kfilm->pass_denoising_clean = 0;		kfilm->pass_denoising_clean = 0;
kfilm->denoising_flags = 0;		kfilm->denoising_flags = 0;
if (denoising_data_pass) {		if (denoising_data_pass) {
kfilm->pass_denoising_data = kfilm->pass_stride;		kfilm->pass_denoising_data = kfilm->pass_stride;
kfilm->pass_stride += DENOISING_PASS_SIZE_BASE;		kfilm->pass_stride += DENOISING_PASS_SIZE_BASE;
Show All 19 Lines	if (display_pass == PASS_NORMAL \|\| display_pass == PASS_UV) {
kfilm->use_light_pass = 0;		kfilm->use_light_pass = 0;
}		}
else {		else {
kfilm->pass_alpha_threshold = pass_alpha_threshold;		kfilm->pass_alpha_threshold = pass_alpha_threshold;
}		}

/* update filter table */		/* update filter table */
vector<float> table = filter_table(filter_type, filter_width);		vector<float> table = filter_table(filter_type, filter_width);
scene->lookup_tables->remove_table(&filter_table_offset);		scene->get_lookup_tables()->remove_table(&filter_table_offset);
filter_table_offset = scene->lookup_tables->add_table(dscene, table);		filter_table_offset = scene->get_lookup_tables()->add_table(dscene, table);
kfilm->filter_table_offset = (int)filter_table_offset;		kfilm->filter_table_offset = (int)filter_table_offset;

/* mist pass parameters */		/* mist pass parameters */
kfilm->mist_start = mist_start;		kfilm->mist_start = mist_start;
kfilm->mist_inv_depth = (mist_depth > 0.0f) ? 1.0f / mist_depth : 0.0f;		kfilm->mist_inv_depth = (mist_depth > 0.0f) ? 1.0f / mist_depth : 0.0f;
kfilm->mist_falloff = mist_falloff;		kfilm->mist_falloff = mist_falloff;

kfilm->cryptomatte_passes = cryptomatte_passes;		kfilm->cryptomatte_passes = cryptomatte_passes;
kfilm->cryptomatte_depth = cryptomatte_depth;		kfilm->cryptomatte_depth = cryptomatte_depth;

pass_stride = kfilm->pass_stride;		pass_stride = kfilm->pass_stride;
denoising_data_offset = kfilm->pass_denoising_data;		denoising_data_offset = kfilm->pass_denoising_data;
denoising_clean_offset = kfilm->pass_denoising_clean;		denoising_clean_offset = kfilm->pass_denoising_clean;

clear_modified();		clear_modified();
}		}

void Film::device_free(Device * /device/, DeviceScene * /dscene/, Scene *scene)		void Film::device_free(Device * /device/, DeviceScene * /dscene/, Scene *scene)
{		{
scene->lookup_tables->remove_table(&filter_table_offset);		scene->get_lookup_tables()->remove_table(&filter_table_offset);
}		}

void Film::tag_passes_update(Scene *scene, const vector<Pass> &passes_, bool update_passes)		void Film::tag_passes_update(Scene *scene, const vector<Pass> &passes_, bool update_passes)
{		{
if (Pass::contains(scene->passes, PASS_UV) != Pass::contains(passes_, PASS_UV)) {		if (Pass::contains(scene->get_passes(), PASS_UV) != Pass::contains(passes_, PASS_UV)) {
scene->geometry_manager->tag_update(scene);		scene->get_geometry_manager()->tag_update(scene);

foreach (Shader *shader, scene->shaders)		foreach (Shader *shader, scene->get_shaders())
shader->need_update_geometry = true;		shader->set_need_update_geometry(true);
}		}
else if (Pass::contains(scene->passes, PASS_MOTION) != Pass::contains(passes_, PASS_MOTION)) {		else if (Pass::contains(scene->get_passes(), PASS_MOTION) !=
scene->geometry_manager->tag_update(scene);		Pass::contains(passes_, PASS_MOTION)) {
		scene->get_geometry_manager()->tag_update(scene);
}		}
else if (Pass::contains(scene->passes, PASS_AO) != Pass::contains(passes_, PASS_AO)) {		else if (Pass::contains(scene->get_passes(), PASS_AO) != Pass::contains(passes_, PASS_AO)) {
scene->integrator->tag_update(scene);		scene->get_integrator()->tag_update(scene);
}		}

if (update_passes) {		if (update_passes) {
scene->passes = passes_;		scene->get_passes() = passes_;
}		}
}		}

int Film::get_aov_offset(Scene *scene, string name, bool &is_color)		int Film::get_aov_offset(Scene *scene, string name, bool &is_color)
{		{
int num_color = 0, num_value = 0;		int num_color = 0, num_value = 0;
foreach (const Pass &pass, scene->passes) {		foreach (const Pass &pass, scene->get_passes()) {
if (pass.type == PASS_AOV_COLOR) {		if (pass.get_pass_type() == PASS_AOV_COLOR) {
num_color++;		num_color++;
}		}
else if (pass.type == PASS_AOV_VALUE) {		else if (pass.get_pass_type() == PASS_AOV_VALUE) {
num_value++;		num_value++;
}		}
else {		else {
continue;		continue;
}		}

if (pass.name == name) {		if (pass.get_name() == name) {
is_color = (pass.type == PASS_AOV_COLOR);		is_color = (pass.get_pass_type() == PASS_AOV_COLOR);
return (is_color ? num_color : num_value) - 1;		return (is_color ? num_color : num_value) - 1;
}		}
}		}

return -1;		return -1;
}		}

int Film::get_pass_stride() const		int Film::get_pass_stride() const
Show All 20 Lines