Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cycles: Refactor PassType from bitflag to index in order to allow for more passes

Browse Source
This commit is contained in:
Lukas Stockner
2017-11-14 07:20:02 +01:00
parent 9c0a38ee33
commit f78e963858
4 changed files with 170 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
intern/cycles/kernel/kernel_passes.h
View File

@@ -170,19 +170,19 @@ ccl_device_inline void kernel_write_debug_passes(KernelGlobals *kg,
PathRadiance *L) PathRadiance *L)
{ {
int flag = kernel_data.film.pass_flag; int flag = kernel_data.film.pass_flag;
if(flag & PASS_BVH_TRAVERSED_NODES) { if(flag & PASSMASK(BVH_TRAVERSED_NODES)) {
kernel_write_pass_float(buffer + kernel_data.film.pass_bvh_traversed_nodes, kernel_write_pass_float(buffer + kernel_data.film.pass_bvh_traversed_nodes,
L->debug_data.num_bvh_traversed_nodes); L->debug_data.num_bvh_traversed_nodes);
} }
if(flag & PASS_BVH_TRAVERSED_INSTANCES) { if(flag & PASSMASK(BVH_TRAVERSED_INSTANCES)) {
kernel_write_pass_float(buffer + kernel_data.film.pass_bvh_traversed_instances, kernel_write_pass_float(buffer + kernel_data.film.pass_bvh_traversed_instances,
L->debug_data.num_bvh_traversed_instances); L->debug_data.num_bvh_traversed_instances);
} }
if(flag & PASS_BVH_INTERSECTIONS) { if(flag & PASSMASK(BVH_INTERSECTIONS)) {
kernel_write_pass_float(buffer + kernel_data.film.pass_bvh_intersections, kernel_write_pass_float(buffer + kernel_data.film.pass_bvh_intersections,
L->debug_data.num_bvh_intersections); L->debug_data.num_bvh_intersections);
} }
if(flag & PASS_RAY_BOUNCES) { if(flag & PASSMASK(RAY_BOUNCES)) {
kernel_write_pass_float(buffer + kernel_data.film.pass_ray_bounces, kernel_write_pass_float(buffer + kernel_data.film.pass_ray_bounces,
L->debug_data.num_ray_bounces); L->debug_data.num_ray_bounces);
} }
@@ -199,8 +199,9 @@ ccl_device_inline void kernel_write_data_passes(KernelGlobals *kg, ccl_global fl
return; return;
int flag = kernel_data.film.pass_flag; int flag = kernel_data.film.pass_flag;
int light_flag = kernel_data.film.light_pass_flag;
if(!(flag & PASS_ALL)) if(!((flag | light_flag) & PASS_ANY))
return; return;
if(!(path_flag & PATH_RAY_SINGLE_PASS_DONE)) { if(!(path_flag & PATH_RAY_SINGLE_PASS_DONE)) {
@@ -209,29 +210,29 @@ ccl_device_inline void kernel_write_data_passes(KernelGlobals *kg, ccl_global fl
average(shader_bsdf_alpha(kg, sd)) >= kernel_data.film.pass_alpha_threshold) average(shader_bsdf_alpha(kg, sd)) >= kernel_data.film.pass_alpha_threshold)
{ {
if(state->sample == 0) { if(state->sample == 0) {
if(flag & PASS_DEPTH) { if(flag & PASSMASK(DEPTH)) {
float depth = camera_distance(kg, sd->P); float depth = camera_distance(kg, sd->P);
kernel_write_pass_float(buffer + kernel_data.film.pass_depth, depth); kernel_write_pass_float(buffer + kernel_data.film.pass_depth, depth);
} }
if(flag & PASS_OBJECT_ID) { if(flag & PASSMASK(OBJECT_ID)) {
float id = object_pass_id(kg, sd->object); float id = object_pass_id(kg, sd->object);
kernel_write_pass_float(buffer + kernel_data.film.pass_object_id, id); kernel_write_pass_float(buffer + kernel_data.film.pass_object_id, id);
} }
if(flag & PASS_MATERIAL_ID) { if(flag & PASSMASK(MATERIAL_ID)) {
float id = shader_pass_id(kg, sd); float id = shader_pass_id(kg, sd);
kernel_write_pass_float(buffer + kernel_data.film.pass_material_id, id); kernel_write_pass_float(buffer + kernel_data.film.pass_material_id, id);
} }
} }
if(flag & PASS_NORMAL) { if(flag & PASSMASK(NORMAL)) {
float3 normal = shader_bsdf_average_normal(kg, sd); float3 normal = shader_bsdf_average_normal(kg, sd);
kernel_write_pass_float3(buffer + kernel_data.film.pass_normal, normal); kernel_write_pass_float3(buffer + kernel_data.film.pass_normal, normal);
} }
if(flag & PASS_UV) { if(flag & PASSMASK(UV)) {
float3 uv = primitive_uv(kg, sd); float3 uv = primitive_uv(kg, sd);
kernel_write_pass_float3(buffer + kernel_data.film.pass_uv, uv); kernel_write_pass_float3(buffer + kernel_data.film.pass_uv, uv);
} }
if(flag & PASS_MOTION) { if(flag & PASSMASK(MOTION)) {
float4 speed = primitive_motion_vector(kg, sd); float4 speed = primitive_motion_vector(kg, sd);
kernel_write_pass_float4(buffer + kernel_data.film.pass_motion, speed); kernel_write_pass_float4(buffer + kernel_data.film.pass_motion, speed);
kernel_write_pass_float(buffer + kernel_data.film.pass_motion_weight, 1.0f); kernel_write_pass_float(buffer + kernel_data.film.pass_motion_weight, 1.0f);
@@ -241,16 +242,16 @@ ccl_device_inline void kernel_write_data_passes(KernelGlobals *kg, ccl_global fl
} }
} }
if(flag & (PASS_DIFFUSE_INDIRECT|PASS_DIFFUSE_COLOR|PASS_DIFFUSE_DIRECT)) if(light_flag & PASSMASK_COMPONENT(DIFFUSE))
L->color_diffuse += shader_bsdf_diffuse(kg, sd)*throughput; L->color_diffuse += shader_bsdf_diffuse(kg, sd)*throughput;
if(flag & (PASS_GLOSSY_INDIRECT|PASS_GLOSSY_COLOR|PASS_GLOSSY_DIRECT)) if(light_flag & PASSMASK_COMPONENT(GLOSSY))
L->color_glossy += shader_bsdf_glossy(kg, sd)*throughput; L->color_glossy += shader_bsdf_glossy(kg, sd)*throughput;
if(flag & (PASS_TRANSMISSION_INDIRECT|PASS_TRANSMISSION_COLOR|PASS_TRANSMISSION_DIRECT)) if(light_flag & PASSMASK_COMPONENT(TRANSMISSION))
L->color_transmission += shader_bsdf_transmission(kg, sd)*throughput; L->color_transmission += shader_bsdf_transmission(kg, sd)*throughput;
if(flag & (PASS_SUBSURFACE_INDIRECT|PASS_SUBSURFACE_COLOR|PASS_SUBSURFACE_DIRECT)) if(light_flag & PASSMASK_COMPONENT(SUBSURFACE))
L->color_subsurface += shader_bsdf_subsurface(kg, sd)*throughput; L->color_subsurface += shader_bsdf_subsurface(kg, sd)*throughput;
if(flag & PASS_MIST) { if(light_flag & PASSMASK(MIST)) {
/* bring depth into 0..1 range */ /* bring depth into 0..1 range */
float mist_start = kernel_data.film.mist_start; float mist_start = kernel_data.film.mist_start;
float mist_inv_depth = kernel_data.film.mist_inv_depth; float mist_inv_depth = kernel_data.film.mist_inv_depth;
@@ -280,49 +281,49 @@ ccl_device_inline void kernel_write_data_passes(KernelGlobals *kg, ccl_global fl
ccl_device_inline void kernel_write_light_passes(KernelGlobals *kg, ccl_global float *buffer, PathRadiance *L) ccl_device_inline void kernel_write_light_passes(KernelGlobals *kg, ccl_global float *buffer, PathRadiance *L)
{ {
#ifdef __PASSES__ #ifdef __PASSES__
int flag = kernel_data.film.pass_flag; int light_flag = kernel_data.film.light_pass_flag;
if(!kernel_data.film.use_light_pass) if(!kernel_data.film.use_light_pass)
return; return;
if(flag & PASS_DIFFUSE_INDIRECT) if(light_flag & PASSMASK(DIFFUSE_INDIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_diffuse_indirect, L->indirect_diffuse); kernel_write_pass_float3(buffer + kernel_data.film.pass_diffuse_indirect, L->indirect_diffuse);
if(flag & PASS_GLOSSY_INDIRECT) if(light_flag & PASSMASK(GLOSSY_INDIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_indirect, L->indirect_glossy); kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_indirect, L->indirect_glossy);
if(flag & PASS_TRANSMISSION_INDIRECT) if(light_flag & PASSMASK(TRANSMISSION_INDIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_indirect, L->indirect_transmission); kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_indirect, L->indirect_transmission);
if(flag & PASS_SUBSURFACE_INDIRECT) if(light_flag & PASSMASK(SUBSURFACE_INDIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_subsurface_indirect, L->indirect_subsurface); kernel_write_pass_float3(buffer + kernel_data.film.pass_subsurface_indirect, L->indirect_subsurface);
if(flag & PASS_DIFFUSE_DIRECT) if(light_flag & PASSMASK(DIFFUSE_DIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_diffuse_direct, L->direct_diffuse); kernel_write_pass_float3(buffer + kernel_data.film.pass_diffuse_direct, L->direct_diffuse);
if(flag & PASS_GLOSSY_DIRECT) if(light_flag & PASSMASK(GLOSSY_DIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_direct, L->direct_glossy); kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_direct, L->direct_glossy);
if(flag & PASS_TRANSMISSION_DIRECT) if(light_flag & PASSMASK(TRANSMISSION_DIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_direct, L->direct_transmission); kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_direct, L->direct_transmission);
if(flag & PASS_SUBSURFACE_DIRECT) if(light_flag & PASSMASK(SUBSURFACE_DIRECT))
kernel_write_pass_float3(buffer + kernel_data.film.pass_subsurface_direct, L->direct_subsurface); kernel_write_pass_float3(buffer + kernel_data.film.pass_subsurface_direct, L->direct_subsurface);
if(flag & PASS_EMISSION) if(light_flag & PASSMASK(EMISSION))
kernel_write_pass_float3(buffer + kernel_data.film.pass_emission, L->emission); kernel_write_pass_float3(buffer + kernel_data.film.pass_emission, L->emission);
if(flag & PASS_BACKGROUND) if(light_flag & PASSMASK(BACKGROUND))
kernel_write_pass_float3(buffer + kernel_data.film.pass_background, L->background); kernel_write_pass_float3(buffer + kernel_data.film.pass_background, L->background);
if(flag & PASS_AO) if(light_flag & PASSMASK(AO))
kernel_write_pass_float3(buffer + kernel_data.film.pass_ao, L->ao); kernel_write_pass_float3(buffer + kernel_data.film.pass_ao, L->ao);
if(flag & PASS_DIFFUSE_COLOR) if(light_flag & PASSMASK(DIFFUSE_COLOR))
kernel_write_pass_float3(buffer + kernel_data.film.pass_diffuse_color, L->color_diffuse); kernel_write_pass_float3(buffer + kernel_data.film.pass_diffuse_color, L->color_diffuse);
if(flag & PASS_GLOSSY_COLOR) if(light_flag & PASSMASK(GLOSSY_COLOR))
kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_color, L->color_glossy); kernel_write_pass_float3(buffer + kernel_data.film.pass_glossy_color, L->color_glossy);
if(flag & PASS_TRANSMISSION_COLOR) if(light_flag & PASSMASK(TRANSMISSION_COLOR))
kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_color, L->color_transmission); kernel_write_pass_float3(buffer + kernel_data.film.pass_transmission_color, L->color_transmission);
if(flag & PASS_SUBSURFACE_COLOR) if(light_flag & PASSMASK(SUBSURFACE_COLOR))
kernel_write_pass_float3(buffer + kernel_data.film.pass_subsurface_color, L->color_subsurface); kernel_write_pass_float3(buffer + kernel_data.film.pass_subsurface_color, L->color_subsurface);
if(flag & PASS_SHADOW) { if(light_flag & PASSMASK(SHADOW)) {
float4 shadow = L->shadow; float4 shadow = L->shadow;
shadow.w = kernel_data.film.pass_shadow_scale; shadow.w = kernel_data.film.pass_shadow_scale;
kernel_write_pass_float4(buffer + kernel_data.film.pass_shadow, shadow); kernel_write_pass_float4(buffer + kernel_data.film.pass_shadow, shadow);
} }
if(flag & PASS_MIST) if(light_flag & PASSMASK(MIST))
kernel_write_pass_float(buffer + kernel_data.film.pass_mist, 1.0f - L->mist); kernel_write_pass_float(buffer + kernel_data.film.pass_mist, 1.0f - L->mist);
#endif #endif
} }

2
intern/cycles/kernel/kernel_path.h
View File

@@ -140,7 +140,7 @@ ccl_device_forceinline void kernel_path_background(
L->transparent += average(throughput); L->transparent += average(throughput);
#ifdef __PASSES__ #ifdef __PASSES__
if(!(kernel_data.film.pass_flag & PASS_BACKGROUND)) if(!(kernel_data.film.light_pass_flag & PASSMASK(BACKGROUND)))
#endif /* __PASSES__ */ #endif /* __PASSES__ */
return; return;
} }

76
intern/cycles/kernel/kernel_types.h
View File

@@ -368,43 +368,55 @@ typedef enum ClosureLabel {
/* Render Passes */ /* Render Passes */
#define PASS_NAME_JOIN(a, b) a ## _ ## b
#define PASSMASK(pass) (1 << ((PASS_NAME_JOIN(PASS, pass)) % 32))
#define PASSMASK_COMPONENT(comp) (PASSMASK(PASS_NAME_JOIN(comp, DIRECT)) | \
PASSMASK(PASS_NAME_JOIN(comp, INDIRECT)) | \
PASSMASK(PASS_NAME_JOIN(comp, COLOR)))
typedef enum PassType { typedef enum PassType {
PASS_NONE = 0, PASS_NONE = 0,
PASS_COMBINED = (1 << 0),
PASS_DEPTH = (1 << 1), /* Main passes */
PASS_NORMAL = (1 << 2), PASS_COMBINED = 1,
PASS_UV = (1 << 3), PASS_DEPTH,
PASS_OBJECT_ID = (1 << 4), PASS_NORMAL,
PASS_MATERIAL_ID = (1 << 5), PASS_UV,
PASS_DIFFUSE_COLOR = (1 << 6), PASS_OBJECT_ID,
PASS_GLOSSY_COLOR = (1 << 7), PASS_MATERIAL_ID,
PASS_TRANSMISSION_COLOR = (1 << 8), PASS_MOTION,
PASS_DIFFUSE_INDIRECT = (1 << 9), PASS_MOTION_WEIGHT,
PASS_GLOSSY_INDIRECT = (1 << 10),
PASS_TRANSMISSION_INDIRECT = (1 << 11),
PASS_DIFFUSE_DIRECT = (1 << 12),
PASS_GLOSSY_DIRECT = (1 << 13),
PASS_TRANSMISSION_DIRECT = (1 << 14),
PASS_EMISSION = (1 << 15),
PASS_BACKGROUND = (1 << 16),
PASS_AO = (1 << 17),
PASS_SHADOW = (1 << 18),
PASS_MOTION = (1 << 19),
PASS_MOTION_WEIGHT = (1 << 20),
PASS_MIST = (1 << 21),
PASS_SUBSURFACE_DIRECT = (1 << 22),
PASS_SUBSURFACE_INDIRECT = (1 << 23),
PASS_SUBSURFACE_COLOR = (1 << 24),
PASS_LIGHT = (1 << 25), /* no real pass, used to force use_light_pass */
#ifdef __KERNEL_DEBUG__ #ifdef __KERNEL_DEBUG__
PASS_BVH_TRAVERSED_NODES = (1 << 26), PASS_BVH_TRAVERSED_NODES,
PASS_BVH_TRAVERSED_INSTANCES = (1 << 27), PASS_BVH_TRAVERSED_INSTANCES,
PASS_BVH_INTERSECTIONS = (1 << 28), PASS_BVH_INTERSECTIONS,
PASS_RAY_BOUNCES = (1 << 29), PASS_RAY_BOUNCES,
#endif #endif
PASS_CATEGORY_MAIN_END = 31,
PASS_MIST = 32,
PASS_EMISSION,
PASS_BACKGROUND,
PASS_AO,
PASS_SHADOW,
PASS_LIGHT, /* no real pass, used to force use_light_pass */
PASS_DIFFUSE_DIRECT,
PASS_DIFFUSE_INDIRECT,
PASS_DIFFUSE_COLOR,
PASS_GLOSSY_DIRECT,
PASS_GLOSSY_INDIRECT,
PASS_GLOSSY_COLOR,
PASS_TRANSMISSION_DIRECT,
PASS_TRANSMISSION_INDIRECT,
PASS_TRANSMISSION_COLOR,
PASS_SUBSURFACE_DIRECT,
PASS_SUBSURFACE_INDIRECT,
PASS_SUBSURFACE_COLOR,
PASS_CATEGORY_LIGHT_END = 63,
} PassType; } PassType;
#define PASS_ALL (~0) #define PASS_ANY (~0)
typedef enum DenoisingPassOffsets { typedef enum DenoisingPassOffsets {
DENOISING_PASS_NORMAL = 0, DENOISING_PASS_NORMAL = 0,
@@ -1179,6 +1191,7 @@ static_assert_align(KernelCamera, 16);
typedef struct KernelFilm { typedef struct KernelFilm {
float exposure; float exposure;
int pass_flag; int pass_flag;
int light_pass_flag;
int pass_stride; int pass_stride;
int use_light_pass; int use_light_pass;
@@ -1215,7 +1228,6 @@ typedef struct KernelFilm {
int pass_shadow; int pass_shadow;
float pass_shadow_scale; float pass_shadow_scale;
int filter_table_offset; int filter_table_offset;
int pass_pad2;
int pass_mist; int pass_mist;
float mist_start; float mist_start;

195
intern/cycles/render/film.cpp
View File

@@ -85,52 +85,6 @@ void Pass::add(PassType type, array<Pass>& passes)
pass.components = 1; pass.components = 1;
pass.filter = false; pass.filter = false;
break; break;
case PASS_DIFFUSE_COLOR:
case PASS_GLOSSY_COLOR:
case PASS_TRANSMISSION_COLOR:
case PASS_SUBSURFACE_COLOR:
pass.components = 4;
break;
case PASS_DIFFUSE_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_DIFFUSE_COLOR;
break;
case PASS_GLOSSY_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_GLOSSY_COLOR;
break;
case PASS_TRANSMISSION_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_TRANSMISSION_COLOR;
break;
case PASS_SUBSURFACE_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_SUBSURFACE_COLOR;
break;
case PASS_DIFFUSE_DIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_DIFFUSE_COLOR;
break;
case PASS_GLOSSY_DIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_GLOSSY_COLOR;
break;
case PASS_TRANSMISSION_DIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_TRANSMISSION_COLOR;
break;
case PASS_SUBSURFACE_DIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_SUBSURFACE_COLOR;
break;
case PASS_EMISSION: case PASS_EMISSION:
case PASS_BACKGROUND: case PASS_BACKGROUND:
@@ -162,6 +116,41 @@ void Pass::add(PassType type, array<Pass>& passes)
pass.exposure = false; pass.exposure = false;
break; break;
#endif #endif
case PASS_DIFFUSE_COLOR:
case PASS_GLOSSY_COLOR:
case PASS_TRANSMISSION_COLOR:
case PASS_SUBSURFACE_COLOR:
pass.components = 4;
break;
case PASS_DIFFUSE_DIRECT:
case PASS_DIFFUSE_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_DIFFUSE_COLOR;
break;
case PASS_GLOSSY_DIRECT:
case PASS_GLOSSY_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_GLOSSY_COLOR;
break;
case PASS_TRANSMISSION_DIRECT:
case PASS_TRANSMISSION_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_TRANSMISSION_COLOR;
break;
case PASS_SUBSURFACE_DIRECT:
case PASS_SUBSURFACE_INDIRECT:
pass.components = 4;
pass.exposure = true;
pass.divide_type = PASS_SUBSURFACE_COLOR;
break;
default:
assert(false);
break;
} }
passes.push_back_slow(pass); passes.push_back_slow(pass);
@@ -318,7 +307,19 @@ void Film::device_update(Device *device, DeviceScene *dscene, Scene *scene)
for(size_t i = 0; i < passes.size(); i++) { for(size_t i = 0; i < passes.size(); i++) {
Pass& pass = passes[i]; Pass& pass = passes[i];
kfilm->pass_flag |= pass.type;
if(pass.type == PASS_NONE)
continue;
int pass_flag = (1 << (pass.type % 32));
if(pass.type <= PASS_CATEGORY_MAIN_END) {
kfilm->pass_flag |= pass_flag;
}
else {
assert(pass.type <= PASS_CATEGORY_LIGHT_END);
kfilm->use_light_pass = 1;
kfilm->light_pass_flag |= pass_flag;
}
switch(pass.type) { switch(pass.type) {
case PASS_COMBINED: case PASS_COMBINED:
@@ -327,10 +328,6 @@ void Film::device_update(Device *device, DeviceScene *dscene, Scene *scene)
case PASS_DEPTH: case PASS_DEPTH:
kfilm->pass_depth = kfilm->pass_stride; kfilm->pass_depth = kfilm->pass_stride;
break; break;
case PASS_MIST:
kfilm->pass_mist = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_NORMAL: case PASS_NORMAL:
kfilm->pass_normal = kfilm->pass_stride; kfilm->pass_normal = kfilm->pass_stride;
break; break;
@@ -349,74 +346,61 @@ void Film::device_update(Device *device, DeviceScene *dscene, Scene *scene)
case PASS_MATERIAL_ID: case PASS_MATERIAL_ID:
kfilm->pass_material_id = kfilm->pass_stride; kfilm->pass_material_id = kfilm->pass_stride;
break; break;
case PASS_DIFFUSE_COLOR:
kfilm->pass_diffuse_color = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_GLOSSY_COLOR:
kfilm->pass_glossy_color = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_TRANSMISSION_COLOR:
kfilm->pass_transmission_color = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_SUBSURFACE_COLOR:
kfilm->pass_subsurface_color = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_DIFFUSE_INDIRECT:
kfilm->pass_diffuse_indirect = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_GLOSSY_INDIRECT:
kfilm->pass_glossy_indirect = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_TRANSMISSION_INDIRECT:
kfilm->pass_transmission_indirect = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_SUBSURFACE_INDIRECT:
kfilm->pass_subsurface_indirect = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_DIFFUSE_DIRECT:
kfilm->pass_diffuse_direct = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_GLOSSY_DIRECT:
kfilm->pass_glossy_direct = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_TRANSMISSION_DIRECT:
kfilm->pass_transmission_direct = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_SUBSURFACE_DIRECT:
kfilm->pass_subsurface_direct = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break;
case PASS_MIST:
kfilm->pass_mist = kfilm->pass_stride;
break;
case PASS_EMISSION: case PASS_EMISSION:
kfilm->pass_emission = kfilm->pass_stride; kfilm->pass_emission = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break; break;
case PASS_BACKGROUND: case PASS_BACKGROUND:
kfilm->pass_background = kfilm->pass_stride; kfilm->pass_background = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break; break;
case PASS_AO: case PASS_AO:
kfilm->pass_ao = kfilm->pass_stride; kfilm->pass_ao = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break; break;
case PASS_SHADOW: case PASS_SHADOW:
kfilm->pass_shadow = kfilm->pass_stride; kfilm->pass_shadow = kfilm->pass_stride;
kfilm->use_light_pass = 1;
break; break;
case PASS_LIGHT: case PASS_LIGHT:
kfilm->use_light_pass = 1; break;
case PASS_DIFFUSE_COLOR:
kfilm->pass_diffuse_color = kfilm->pass_stride;
break;
case PASS_GLOSSY_COLOR:
kfilm->pass_glossy_color = kfilm->pass_stride;
break;
case PASS_TRANSMISSION_COLOR:
kfilm->pass_transmission_color = kfilm->pass_stride;
break;
case PASS_SUBSURFACE_COLOR:
kfilm->pass_subsurface_color = kfilm->pass_stride;
break;
case PASS_DIFFUSE_INDIRECT:
kfilm->pass_diffuse_indirect = kfilm->pass_stride;
break;
case PASS_GLOSSY_INDIRECT:
kfilm->pass_glossy_indirect = kfilm->pass_stride;
break;
case PASS_TRANSMISSION_INDIRECT:
kfilm->pass_transmission_indirect = kfilm->pass_stride;
break;
case PASS_SUBSURFACE_INDIRECT:
kfilm->pass_subsurface_indirect = kfilm->pass_stride;
break;
case PASS_DIFFUSE_DIRECT:
kfilm->pass_diffuse_direct = kfilm->pass_stride;
break;
case PASS_GLOSSY_DIRECT:
kfilm->pass_glossy_direct = kfilm->pass_stride;
break;
case PASS_TRANSMISSION_DIRECT:
kfilm->pass_transmission_direct = kfilm->pass_stride;
break;
case PASS_SUBSURFACE_DIRECT:
kfilm->pass_subsurface_direct = kfilm->pass_stride;
break; break;
#ifdef WITH_CYCLES_DEBUG #ifdef WITH_CYCLES_DEBUG
@@ -434,7 +418,8 @@ void Film::device_update(Device *device, DeviceScene *dscene, Scene *scene)
break; break;
#endif #endif
case PASS_NONE: default:
assert(false);
break; break;
} }