Page MenuHome
Differential D12367 Diff 41308 intern/cycles/kernel/svm/svm.h

Changeset View

Standalone View

View Options

intern/cycles/kernel/svm/svm.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
CCL_NAMESPACE_BEGIN CCL_NAMESPACE_BEGIN
/* Stack */ /* Stack */
ccl_device_inline float3 stack_load_float3(float *stack, uint a) ccl_device_inline float3 stack_load_float3(float *stack, uint a)
{ {
kernel_assert(a + 2 < SVM_STACK_SIZE); kernel_assert(a + 2 < SVM_STACK_SIZE);
return make_float3(stack[a + 0], stack[a + 1], stack[a + 2]); float *stack_a = stack + a;
return make_float3(stack_a[0], stack_a[1], stack_a[2]);
} }
ccl_device_inline void stack_store_float3(float *stack, uint a, float3 f) ccl_device_inline void stack_store_float3(float *stack, uint a, float3 f)
{ {
kernel_assert(a + 2 < SVM_STACK_SIZE); kernel_assert(a + 2 < SVM_STACK_SIZE);
stack[a + 0] = f.x; float *stack_a = stack + a;
stack[a + 1] = f.y; stack_a[0] = f.x;
stack[a + 2] = f.z; stack_a[1] = f.y;
stack_a[2] = f.z;
} }
ccl_device_inline float stack_load_float(float *stack, uint a) ccl_device_inline float stack_load_float(float *stack, uint a)
{ {
kernel_assert(a < SVM_STACK_SIZE); kernel_assert(a < SVM_STACK_SIZE);
return stack[a]; return stack[a];
} }
Show All 31 Lines
ccl_device_inline bool stack_valid(uint a) ccl_device_inline bool stack_valid(uint a)
{ {
return a != (uint)SVM_STACK_INVALID; return a != (uint)SVM_STACK_INVALID;
} }
/* Reading Nodes */ /* Reading Nodes */
ccl_device_inline uint4 read_node(KernelGlobals *kg, int *offset) ccl_device_inline uint4 read_node(const KernelGlobals *kg, int *offset)
{ {
uint4 node = kernel_tex_fetch(__svm_nodes, *offset); uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
(*offset)++; (*offset)++;
return node; return node;
} }
ccl_device_inline float4 read_node_float(KernelGlobals *kg, int *offset) ccl_device_inline float4 read_node_float(const KernelGlobals *kg, int *offset)
{ {
uint4 node = kernel_tex_fetch(__svm_nodes, *offset); uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
float4 f = make_float4(__uint_as_float(node.x), float4 f = make_float4(__uint_as_float(node.x),
__uint_as_float(node.y), __uint_as_float(node.y),
__uint_as_float(node.z), __uint_as_float(node.z),
__uint_as_float(node.w)); __uint_as_float(node.w));
(*offset)++; (*offset)++;
return f; return f;
} }
ccl_device_inline float4 fetch_node_float(KernelGlobals *kg, int offset) ccl_device_inline float4 fetch_node_float(const KernelGlobals *kg, int offset)
{ {
uint4 node = kernel_tex_fetch(__svm_nodes, offset); uint4 node = kernel_tex_fetch(__svm_nodes, offset);
return make_float4(__uint_as_float(node.x), return make_float4(__uint_as_float(node.x),
__uint_as_float(node.y), __uint_as_float(node.y),
__uint_as_float(node.z), __uint_as_float(node.z),
__uint_as_float(node.w)); __uint_as_float(node.w));
} }
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
#ifdef __SHADER_RAYTRACE__ #ifdef __SHADER_RAYTRACE__
# include "kernel/svm/svm_ao.h" # include "kernel/svm/svm_ao.h"
# include "kernel/svm/svm_bevel.h" # include "kernel/svm/svm_bevel.h"
#endif #endif
CCL_NAMESPACE_BEGIN CCL_NAMESPACE_BEGIN
/* Main Interpreter Loop */ /* Main Interpreter Loop */
#if defined(__KERNEL_OPTIX__) && defined(__SHADER_RAYTRACE__) template<uint node_feature_mask, ShaderType type>
ccl_device_inline void svm_eval_nodes(KernelGlobals *kg, ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
ShaderData *sd, ShaderData *sd,
ccl_addr_space PathState *state, ccl_global float *render_buffer,
ccl_global float *buffer,
ShaderType type,
int path_flag)
{
optixDirectCall<void>(0, kg, sd, state, buffer, type, path_flag);
}
extern "C" __device__ void __direct_callable__svm_eval_nodes(
#else
ccl_device_noinline void svm_eval_nodes(
#endif
KernelGlobals *kg,
ShaderData *sd,
ccl_addr_space PathState *state,
ccl_global float *buffer,
ShaderType type,
int path_flag) int path_flag)
{ {
float stack[SVM_STACK_SIZE]; float stack[SVM_STACK_SIZE];
int offset = sd->shader & SHADER_MASK; int offset = sd->shader & SHADER_MASK;
while (1) { while (1) {
uint4 node = read_node(kg, &offset); uint4 node = read_node(kg, &offset);
switch (node.x) { switch (node.x) {
case NODE_END: case NODE_END:
return; return;
#if NODES_GROUP(NODE_GROUP_LEVEL_0)
case NODE_SHADER_JUMP: { case NODE_SHADER_JUMP: {
if (type == SHADER_TYPE_SURFACE) if (type == SHADER_TYPE_SURFACE)
offset = node.y; offset = node.y;
else if (type == SHADER_TYPE_VOLUME) else if (type == SHADER_TYPE_VOLUME)
offset = node.z; offset = node.z;
else if (type == SHADER_TYPE_DISPLACEMENT) else if (type == SHADER_TYPE_DISPLACEMENT)
offset = node.w; offset = node.w;
else else
return; return;
break; break;
} }
case NODE_CLOSURE_BSDF: case NODE_CLOSURE_BSDF:
svm_node_closure_bsdf(kg, sd, stack, node, type, path_flag, &offset); offset = svm_node_closure_bsdf<node_feature_mask, type>(
kg, sd, stack, node, path_flag, offset);
break; break;
case NODE_CLOSURE_EMISSION: case NODE_CLOSURE_EMISSION:
if (KERNEL_NODES_FEATURE(EMISSION)) {
svm_node_closure_emission(sd, stack, node); svm_node_closure_emission(sd, stack, node);
}
break; break;
case NODE_CLOSURE_BACKGROUND: case NODE_CLOSURE_BACKGROUND:
if (KERNEL_NODES_FEATURE(EMISSION)) {
svm_node_closure_background(sd, stack, node); svm_node_closure_background(sd, stack, node);
}
break; break;
case NODE_CLOSURE_SET_WEIGHT: case NODE_CLOSURE_SET_WEIGHT:
svm_node_closure_set_weight(sd, node.y, node.z, node.w); svm_node_closure_set_weight(sd, node.y, node.z, node.w);
break; break;
case NODE_CLOSURE_WEIGHT: case NODE_CLOSURE_WEIGHT:
svm_node_closure_weight(sd, stack, node.y); svm_node_closure_weight(sd, stack, node.y);
break; break;
case NODE_EMISSION_WEIGHT: case NODE_EMISSION_WEIGHT:
if (KERNEL_NODES_FEATURE(EMISSION)) {
svm_node_emission_weight(kg, sd, stack, node); svm_node_emission_weight(kg, sd, stack, node);
}
break; break;
case NODE_MIX_CLOSURE: case NODE_MIX_CLOSURE:
svm_node_mix_closure(sd, stack, node); svm_node_mix_closure(sd, stack, node);
break; break;
case NODE_JUMP_IF_ZERO: case NODE_JUMP_IF_ZERO:
if (stack_load_float(stack, node.z) == 0.0f) if (stack_load_float(stack, node.z) == 0.0f)
offset += node.y; offset += node.y;
break; break;
case NODE_JUMP_IF_ONE: case NODE_JUMP_IF_ONE:
if (stack_load_float(stack, node.z) == 1.0f) if (stack_load_float(stack, node.z) == 1.0f)
offset += node.y; offset += node.y;
break; break;
case NODE_GEOMETRY: case NODE_GEOMETRY:
svm_node_geometry(kg, sd, stack, node.y, node.z); svm_node_geometry(kg, sd, stack, node.y, node.z);
break; break;
case NODE_CONVERT: case NODE_CONVERT:
svm_node_convert(kg, sd, stack, node.y, node.z, node.w); svm_node_convert(kg, sd, stack, node.y, node.z, node.w);
break; break;
case NODE_TEX_COORD: case NODE_TEX_COORD:
svm_node_tex_coord(kg, sd, path_flag, stack, node, &offset); offset = svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);
break; break;
case NODE_VALUE_F: case NODE_VALUE_F:
svm_node_value_f(kg, sd, stack, node.y, node.z); svm_node_value_f(kg, sd, stack, node.y, node.z);
break; break;
case NODE_VALUE_V: case NODE_VALUE_V:
svm_node_value_v(kg, sd, stack, node.y, &offset); offset = svm_node_value_v(kg, sd, stack, node.y, offset);
break; break;
case NODE_ATTR: case NODE_ATTR:
svm_node_attr(kg, sd, stack, node); svm_node_attr<node_feature_mask>(kg, sd, stack, node);
break; break;
case NODE_VERTEX_COLOR: case NODE_VERTEX_COLOR:
svm_node_vertex_color(kg, sd, stack, node.y, node.z, node.w); svm_node_vertex_color(kg, sd, stack, node.y, node.z, node.w);
break; break;
# if NODES_FEATURE(NODE_FEATURE_BUMP)
case NODE_GEOMETRY_BUMP_DX: case NODE_GEOMETRY_BUMP_DX:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z); svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z);
}
break; break;
case NODE_GEOMETRY_BUMP_DY: case NODE_GEOMETRY_BUMP_DY:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z); svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z);
}
break; break;
case NODE_SET_DISPLACEMENT: case NODE_SET_DISPLACEMENT:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_set_displacement(kg, sd, stack, node.y); svm_node_set_displacement(kg, sd, stack, node.y);
}
break; break;
case NODE_DISPLACEMENT: case NODE_DISPLACEMENT:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_displacement(kg, sd, stack, node); svm_node_displacement(kg, sd, stack, node);
}
break; break;
case NODE_VECTOR_DISPLACEMENT: case NODE_VECTOR_DISPLACEMENT:
svm_node_vector_displacement(kg, sd, stack, node, &offset); if (KERNEL_NODES_FEATURE(BUMP)) {
offset = svm_node_vector_displacement(kg, sd, stack, node, offset);
}
break; break;
# endif /* NODES_FEATURE(NODE_FEATURE_BUMP) */
case NODE_TEX_IMAGE: case NODE_TEX_IMAGE:
svm_node_tex_image(kg, sd, stack, node, &offset); offset = svm_node_tex_image(kg, sd, stack, node, offset);
break; break;
case NODE_TEX_IMAGE_BOX: case NODE_TEX_IMAGE_BOX:
svm_node_tex_image_box(kg, sd, stack, node); svm_node_tex_image_box(kg, sd, stack, node);
break; break;
case NODE_TEX_NOISE: case NODE_TEX_NOISE:
svm_node_tex_noise(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_tex_noise(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
# if NODES_FEATURE(NODE_FEATURE_BUMP)
case NODE_SET_BUMP: case NODE_SET_BUMP:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_set_bump(kg, sd, stack, node); svm_node_set_bump(kg, sd, stack, node);
}
break; break;
case NODE_ATTR_BUMP_DX: case NODE_ATTR_BUMP_DX:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_attr_bump_dx(kg, sd, stack, node); svm_node_attr_bump_dx(kg, sd, stack, node);
}
break; break;
case NODE_ATTR_BUMP_DY: case NODE_ATTR_BUMP_DY:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_attr_bump_dy(kg, sd, stack, node); svm_node_attr_bump_dy(kg, sd, stack, node);
}
break; break;
case NODE_VERTEX_COLOR_BUMP_DX: case NODE_VERTEX_COLOR_BUMP_DX:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_vertex_color_bump_dx(kg, sd, stack, node.y, node.z, node.w); svm_node_vertex_color_bump_dx(kg, sd, stack, node.y, node.z, node.w);
}
break; break;
case NODE_VERTEX_COLOR_BUMP_DY: case NODE_VERTEX_COLOR_BUMP_DY:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_vertex_color_bump_dy(kg, sd, stack, node.y, node.z, node.w); svm_node_vertex_color_bump_dy(kg, sd, stack, node.y, node.z, node.w);
}
break; break;
case NODE_TEX_COORD_BUMP_DX: case NODE_TEX_COORD_BUMP_DX:
svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node, &offset); if (KERNEL_NODES_FEATURE(BUMP)) {
offset = svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node, offset);
}
break; break;
case NODE_TEX_COORD_BUMP_DY: case NODE_TEX_COORD_BUMP_DY:
svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node, &offset); if (KERNEL_NODES_FEATURE(BUMP)) {
offset = svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node, offset);
}
break; break;
case NODE_CLOSURE_SET_NORMAL: case NODE_CLOSURE_SET_NORMAL:
if (KERNEL_NODES_FEATURE(BUMP)) {
svm_node_set_normal(kg, sd, stack, node.y, node.z); svm_node_set_normal(kg, sd, stack, node.y, node.z);
}
break; break;
# if NODES_FEATURE(NODE_FEATURE_BUMP_STATE)
case NODE_ENTER_BUMP_EVAL: case NODE_ENTER_BUMP_EVAL:
if (KERNEL_NODES_FEATURE(BUMP_STATE)) {
svm_node_enter_bump_eval(kg, sd, stack, node.y); svm_node_enter_bump_eval(kg, sd, stack, node.y);
}
break; break;
case NODE_LEAVE_BUMP_EVAL: case NODE_LEAVE_BUMP_EVAL:
if (KERNEL_NODES_FEATURE(BUMP_STATE)) {
svm_node_leave_bump_eval(kg, sd, stack, node.y); svm_node_leave_bump_eval(kg, sd, stack, node.y);
}
break; break;
# endif /* NODES_FEATURE(NODE_FEATURE_BUMP_STATE) */
# endif /* NODES_FEATURE(NODE_FEATURE_BUMP) */
case NODE_HSV: case NODE_HSV:
svm_node_hsv(kg, sd, stack, node, &offset); svm_node_hsv(kg, sd, stack, node);
break; break;
#endif /* NODES_GROUP(NODE_GROUP_LEVEL_0) */
#if NODES_GROUP(NODE_GROUP_LEVEL_1)
case NODE_CLOSURE_HOLDOUT: case NODE_CLOSURE_HOLDOUT:
svm_node_closure_holdout(sd, stack, node); svm_node_closure_holdout(sd, stack, node);
break; break;
case NODE_FRESNEL: case NODE_FRESNEL:
svm_node_fresnel(sd, stack, node.y, node.z, node.w); svm_node_fresnel(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_LAYER_WEIGHT: case NODE_LAYER_WEIGHT:
svm_node_layer_weight(sd, stack, node); svm_node_layer_weight(sd, stack, node);
break; break;
# if NODES_FEATURE(NODE_FEATURE_VOLUME)
case NODE_CLOSURE_VOLUME: case NODE_CLOSURE_VOLUME:
svm_node_closure_volume(kg, sd, stack, node, type); if (KERNEL_NODES_FEATURE(VOLUME)) {
svm_node_closure_volume<type>(kg, sd, stack, node);
}
break; break;
case NODE_PRINCIPLED_VOLUME: case NODE_PRINCIPLED_VOLUME:
svm_node_principled_volume(kg, sd, stack, node, type, path_flag, &offset); if (KERNEL_NODES_FEATURE(VOLUME)) {
offset = svm_node_principled_volume<type>(kg, sd, stack, node, path_flag, offset);
}
break; break;
# endif /* NODES_FEATURE(NODE_FEATURE_VOLUME) */
case NODE_MATH: case NODE_MATH:
svm_node_math(kg, sd, stack, node.y, node.z, node.w, &offset); svm_node_math(kg, sd, stack, node.y, node.z, node.w);
break; break;
case NODE_VECTOR_MATH: case NODE_VECTOR_MATH:
svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_RGB_RAMP: case NODE_RGB_RAMP:
svm_node_rgb_ramp(kg, sd, stack, node, &offset); offset = svm_node_rgb_ramp(kg, sd, stack, node, offset);
break; break;
case NODE_GAMMA: case NODE_GAMMA:
svm_node_gamma(sd, stack, node.y, node.z, node.w); svm_node_gamma(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_BRIGHTCONTRAST: case NODE_BRIGHTCONTRAST:
svm_node_brightness(sd, stack, node.y, node.z, node.w); svm_node_brightness(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_LIGHT_PATH: case NODE_LIGHT_PATH:
svm_node_light_path(sd, state, stack, node.y, node.z, path_flag); svm_node_light_path(INTEGRATOR_STATE_PASS, sd, stack, node.y, node.z, path_flag);
break; break;
case NODE_OBJECT_INFO: case NODE_OBJECT_INFO:
svm_node_object_info(kg, sd, stack, node.y, node.z); svm_node_object_info(kg, sd, stack, node.y, node.z);
break; break;
case NODE_PARTICLE_INFO: case NODE_PARTICLE_INFO:
svm_node_particle_info(kg, sd, stack, node.y, node.z); svm_node_particle_info(kg, sd, stack, node.y, node.z);
break; break;
# if defined(__HAIR__) && NODES_FEATURE(NODE_FEATURE_HAIR) #if defined(__HAIR__)
case NODE_HAIR_INFO: case NODE_HAIR_INFO:
if (KERNEL_NODES_FEATURE(HAIR)) {
svm_node_hair_info(kg, sd, stack, node.y, node.z); svm_node_hair_info(kg, sd, stack, node.y, node.z);
}
break; break;
# endif /* NODES_FEATURE(NODE_FEATURE_HAIR) */ #endif
#endif /* NODES_GROUP(NODE_GROUP_LEVEL_1) */
#if NODES_GROUP(NODE_GROUP_LEVEL_2)
case NODE_TEXTURE_MAPPING: case NODE_TEXTURE_MAPPING:
svm_node_texture_mapping(kg, sd, stack, node.y, node.z, &offset); offset = svm_node_texture_mapping(kg, sd, stack, node.y, node.z, offset);
break; break;
case NODE_MAPPING: case NODE_MAPPING:
svm_node_mapping(kg, sd, stack, node.y, node.z, node.w, &offset); svm_node_mapping(kg, sd, stack, node.y, node.z, node.w);
break; break;
case NODE_MIN_MAX: case NODE_MIN_MAX:
svm_node_min_max(kg, sd, stack, node.y, node.z, &offset); offset = svm_node_min_max(kg, sd, stack, node.y, node.z, offset);
break; break;
case NODE_CAMERA: case NODE_CAMERA:
svm_node_camera(kg, sd, stack, node.y, node.z, node.w); svm_node_camera(kg, sd, stack, node.y, node.z, node.w);
break; break;
case NODE_TEX_ENVIRONMENT: case NODE_TEX_ENVIRONMENT:
svm_node_tex_environment(kg, sd, stack, node); svm_node_tex_environment(kg, sd, stack, node);
break; break;
case NODE_TEX_SKY: case NODE_TEX_SKY:
svm_node_tex_sky(kg, sd, stack, node, &offset); offset = svm_node_tex_sky(kg, sd, stack, node, offset);
break; break;
case NODE_TEX_GRADIENT: case NODE_TEX_GRADIENT:
svm_node_tex_gradient(sd, stack, node); svm_node_tex_gradient(sd, stack, node);
break; break;
case NODE_TEX_VORONOI: case NODE_TEX_VORONOI:
svm_node_tex_voronoi(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_tex_voronoi<node_feature_mask>(
kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_TEX_MUSGRAVE: case NODE_TEX_MUSGRAVE:
svm_node_tex_musgrave(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_tex_musgrave(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_TEX_WAVE: case NODE_TEX_WAVE:
svm_node_tex_wave(kg, sd, stack, node, &offset); offset = svm_node_tex_wave(kg, sd, stack, node, offset);
break; break;
case NODE_TEX_MAGIC: case NODE_TEX_MAGIC:
svm_node_tex_magic(kg, sd, stack, node, &offset); offset = svm_node_tex_magic(kg, sd, stack, node, offset);
break; break;
case NODE_TEX_CHECKER: case NODE_TEX_CHECKER:
svm_node_tex_checker(kg, sd, stack, node); svm_node_tex_checker(kg, sd, stack, node);
break; break;
case NODE_TEX_BRICK: case NODE_TEX_BRICK:
svm_node_tex_brick(kg, sd, stack, node, &offset); offset = svm_node_tex_brick(kg, sd, stack, node, offset);
break; break;
case NODE_TEX_WHITE_NOISE: case NODE_TEX_WHITE_NOISE:
svm_node_tex_white_noise(kg, sd, stack, node.y, node.z, node.w, &offset); svm_node_tex_white_noise(kg, sd, stack, node.y, node.z, node.w);
break; break;
case NODE_NORMAL: case NODE_NORMAL:
svm_node_normal(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_normal(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_LIGHT_FALLOFF: case NODE_LIGHT_FALLOFF:
svm_node_light_falloff(sd, stack, node); svm_node_light_falloff(sd, stack, node);
break; break;
case NODE_IES: case NODE_IES:
svm_node_ies(kg, sd, stack, node, &offset); svm_node_ies(kg, sd, stack, node);
break; break;
#endif /* NODES_GROUP(NODE_GROUP_LEVEL_2) */
#if NODES_GROUP(NODE_GROUP_LEVEL_3)
case NODE_RGB_CURVES: case NODE_RGB_CURVES:
case NODE_VECTOR_CURVES: case NODE_VECTOR_CURVES:
svm_node_curves(kg, sd, stack, node, &offset); offset = svm_node_curves(kg, sd, stack, node, offset);
break; break;
case NODE_TANGENT: case NODE_TANGENT:
svm_node_tangent(kg, sd, stack, node); svm_node_tangent(kg, sd, stack, node);
break; break;
case NODE_NORMAL_MAP: case NODE_NORMAL_MAP:
svm_node_normal_map(kg, sd, stack, node); svm_node_normal_map(kg, sd, stack, node);
break; break;
case NODE_INVERT: case NODE_INVERT:
svm_node_invert(sd, stack, node.y, node.z, node.w); svm_node_invert(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_MIX: case NODE_MIX:
svm_node_mix(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_mix(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_SEPARATE_VECTOR: case NODE_SEPARATE_VECTOR:
svm_node_separate_vector(sd, stack, node.y, node.z, node.w); svm_node_separate_vector(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_COMBINE_VECTOR: case NODE_COMBINE_VECTOR:
svm_node_combine_vector(sd, stack, node.y, node.z, node.w); svm_node_combine_vector(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_SEPARATE_HSV: case NODE_SEPARATE_HSV:
svm_node_separate_hsv(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_separate_hsv(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_COMBINE_HSV: case NODE_COMBINE_HSV:
svm_node_combine_hsv(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_combine_hsv(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_VECTOR_ROTATE: case NODE_VECTOR_ROTATE:
svm_node_vector_rotate(sd, stack, node.y, node.z, node.w); svm_node_vector_rotate(sd, stack, node.y, node.z, node.w);
break; break;
case NODE_VECTOR_TRANSFORM: case NODE_VECTOR_TRANSFORM:
svm_node_vector_transform(kg, sd, stack, node); svm_node_vector_transform(kg, sd, stack, node);
break; break;
case NODE_WIREFRAME: case NODE_WIREFRAME:
svm_node_wireframe(kg, sd, stack, node); svm_node_wireframe(kg, sd, stack, node);
break; break;
case NODE_WAVELENGTH: case NODE_WAVELENGTH:
svm_node_wavelength(kg, sd, stack, node.y, node.z); svm_node_wavelength(kg, sd, stack, node.y, node.z);
break; break;
case NODE_BLACKBODY: case NODE_BLACKBODY:
svm_node_blackbody(kg, sd, stack, node.y, node.z); svm_node_blackbody(kg, sd, stack, node.y, node.z);
break; break;
case NODE_MAP_RANGE: case NODE_MAP_RANGE:
svm_node_map_range(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_map_range(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
case NODE_CLAMP: case NODE_CLAMP:
svm_node_clamp(kg, sd, stack, node.y, node.z, node.w, &offset); offset = svm_node_clamp(kg, sd, stack, node.y, node.z, node.w, offset);
break; break;
# ifdef __SHADER_RAYTRACE__ #ifdef __SHADER_RAYTRACE__
case NODE_BEVEL: case NODE_BEVEL:
svm_node_bevel(kg, sd, state, stack, node); if (KERNEL_NODES_FEATURE(RAYTRACE)) {
svm_node_bevel(INTEGRATOR_STATE_PASS, sd, stack, node);
}
break; break;
case NODE_AMBIENT_OCCLUSION: case NODE_AMBIENT_OCCLUSION:
svm_node_ao(kg, sd, state, stack, node); if (KERNEL_NODES_FEATURE(RAYTRACE)) {
svm_node_ao(INTEGRATOR_STATE_PASS, sd, stack, node);
}
break; break;
# endif /* __SHADER_RAYTRACE__ */ #endif
#endif /* NODES_GROUP(NODE_GROUP_LEVEL_3) */
#if NODES_GROUP(NODE_GROUP_LEVEL_4)
# if NODES_FEATURE(NODE_FEATURE_VOLUME)
case NODE_TEX_VOXEL: case NODE_TEX_VOXEL:
svm_node_tex_voxel(kg, sd, stack, node, &offset); if (KERNEL_NODES_FEATURE(VOLUME)) {
offset = svm_node_tex_voxel(kg, sd, stack, node, offset);
}
break; break;
# endif /* NODES_FEATURE(NODE_FEATURE_VOLUME) */
case NODE_AOV_START: case NODE_AOV_START:
if (!svm_node_aov_check(state, buffer)) { if (!svm_node_aov_check(path_flag, render_buffer)) {
return; return;
} }
break; break;
case NODE_AOV_COLOR: case NODE_AOV_COLOR:
svm_node_aov_color(kg, sd, stack, node, buffer); svm_node_aov_color(INTEGRATOR_STATE_PASS, sd, stack, node, render_buffer);
break; break;
case NODE_AOV_VALUE: case NODE_AOV_VALUE:
svm_node_aov_value(kg, sd, stack, node, buffer); svm_node_aov_value(INTEGRATOR_STATE_PASS, sd, stack, node, render_buffer);
break; break;
#endif /* NODES_GROUP(NODE_GROUP_LEVEL_4) */
default: default:
kernel_assert(!"Unknown node type was passed to the SVM machine"); kernel_assert(!"Unknown node type was passed to the SVM machine");
return; return;
} }
} }
} }
CCL_NAMESPACE_END CCL_NAMESPACE_END
#endif /* __SVM_H__ */ #endif /* __SVM_H__ */