From 293160281203f7fd5c2b8897f42cb2a5516a6f1c Mon Sep 17 00:00:00 2001 From: Lukas Stockner Date: Tue, 25 Jul 2023 02:31:20 +0200 Subject: [PATCH] Cycles: Cleanup: Move SVM execution state into a helper struct This way we don't have to pass the offset all over the place, and adding additional state (e.g. for layering in the future) becomes easier. --- intern/cycles/kernel/svm/ao.h | 12 +- intern/cycles/kernel/svm/aov.h | 8 +- intern/cycles/kernel/svm/attribute.h | 116 ++++----- intern/cycles/kernel/svm/bevel.h | 8 +- intern/cycles/kernel/svm/blackbody.h | 6 +- intern/cycles/kernel/svm/brick.h | 37 +-- intern/cycles/kernel/svm/brightness.h | 15 +- intern/cycles/kernel/svm/bump.h | 12 +- intern/cycles/kernel/svm/camera.h | 8 +- intern/cycles/kernel/svm/checker.h | 14 +- intern/cycles/kernel/svm/clamp.h | 26 +- intern/cycles/kernel/svm/closure.h | 271 ++++++++++---------- intern/cycles/kernel/svm/convert.h | 34 +-- intern/cycles/kernel/svm/displace.h | 57 ++-- intern/cycles/kernel/svm/fresnel.h | 17 +- intern/cycles/kernel/svm/gamma.h | 8 +- intern/cycles/kernel/svm/geometry.h | 62 ++--- intern/cycles/kernel/svm/gradient.h | 8 +- intern/cycles/kernel/svm/hsv.h | 14 +- intern/cycles/kernel/svm/ies.h | 8 +- intern/cycles/kernel/svm/image.h | 35 +-- intern/cycles/kernel/svm/invert.h | 8 +- intern/cycles/kernel/svm/light_path.h | 12 +- intern/cycles/kernel/svm/magic.h | 19 +- intern/cycles/kernel/svm/map_range.h | 60 ++--- intern/cycles/kernel/svm/mapping.h | 54 ++-- intern/cycles/kernel/svm/math.h | 38 ++- intern/cycles/kernel/svm/mix.h | 64 +++-- intern/cycles/kernel/svm/musgrave.h | 36 ++- intern/cycles/kernel/svm/noisetex.h | 34 ++- intern/cycles/kernel/svm/normal.h | 22 +- intern/cycles/kernel/svm/ramp.h | 61 ++--- intern/cycles/kernel/svm/sepcomb_color.h | 20 +- intern/cycles/kernel/svm/sepcomb_hsv.h | 48 ++-- intern/cycles/kernel/svm/sepcomb_vector.h | 16 +- intern/cycles/kernel/svm/sky.h | 38 ++- intern/cycles/kernel/svm/svm.h | 262 +++++++++---------- intern/cycles/kernel/svm/tex_coord.h | 82 +++--- intern/cycles/kernel/svm/value.h | 18 +- intern/cycles/kernel/svm/vector_rotate.h | 14 +- intern/cycles/kernel/svm/vector_transform.h | 6 +- intern/cycles/kernel/svm/vertex_color.h | 42 +-- intern/cycles/kernel/svm/voronoi.h | 57 ++-- intern/cycles/kernel/svm/voxel.h | 25 +- intern/cycles/kernel/svm/wave.h | 29 ++- intern/cycles/kernel/svm/wavelength.h | 6 +- intern/cycles/kernel/svm/white_noise.h | 10 +- intern/cycles/kernel/svm/wireframe.h | 6 +- 48 files changed, 913 insertions(+), 950 deletions(-) diff --git a/intern/cycles/kernel/svm/ao.h b/intern/cycles/kernel/svm/ao.h index 2e4cdb173e0..9eeae8c17bc 100644 --- a/intern/cycles/kernel/svm/ao.h +++ b/intern/cycles/kernel/svm/ao.h @@ -97,7 +97,7 @@ ccl_device_noinline svm_node_ao(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint flags, dist_offset, normal_offset, out_ao_offset; @@ -110,8 +110,8 @@ ccl_device_noinline IF_KERNEL_NODES_FEATURE(RAYTRACE) { - float dist = stack_load_float_default(stack, dist_offset, node.w); - float3 normal = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N; + float dist = stack_load_float_default(svm, dist_offset, node.w); + float3 normal = stack_valid(normal_offset) ? stack_load_float3(svm, normal_offset) : sd->N; # ifdef __KERNEL_OPTIX__ ao = optixDirectCall(0, kg, state, sd, normal, dist, samples, flags); @@ -121,12 +121,12 @@ ccl_device_noinline } if (stack_valid(out_ao_offset)) { - stack_store_float(stack, out_ao_offset, ao); + stack_store_float(svm, out_ao_offset, ao); } if (stack_valid(out_color_offset)) { - float3 color = stack_load_float3(stack, color_offset); - stack_store_float3(stack, out_color_offset, ao * color); + float3 color = stack_load_float3(svm, color_offset); + stack_store_float3(svm, out_color_offset, ao * color); } } diff --git a/intern/cycles/kernel/svm/aov.h b/intern/cycles/kernel/svm/aov.h index 41fec5ec760..493deb7ad54 100644 --- a/intern/cycles/kernel/svm/aov.h +++ b/intern/cycles/kernel/svm/aov.h @@ -21,13 +21,13 @@ template ccl_device void svm_node_aov_color(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node, ccl_global float *render_buffer) { IF_KERNEL_NODES_FEATURE(AOV) { - const float3 val = stack_load_float3(stack, node.y); + const float3 val = stack_load_float3(svm, node.y); film_write_aov_pass_color(kg, state, render_buffer, node.z, val); } } @@ -36,13 +36,13 @@ template ccl_device void svm_node_aov_value(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node, ccl_global float *render_buffer) { IF_KERNEL_NODES_FEATURE(AOV) { - const float val = stack_load_float(stack, node.y); + const float val = stack_load_float(svm, node.y); film_write_aov_pass_value(kg, state, render_buffer, node.z, val); } } diff --git a/intern/cycles/kernel/svm/attribute.h b/intern/cycles/kernel/svm/attribute.h index 8d74d68192b..6267015cb70 100644 --- a/intern/cycles/kernel/svm/attribute.h +++ b/intern/cycles/kernel/svm/attribute.h @@ -40,7 +40,7 @@ ccl_device AttributeDescriptor svm_node_attr_init(KernelGlobals kg, template ccl_device_noinline void svm_node_attr(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT; @@ -57,15 +57,15 @@ ccl_device_noinline void svm_node_attr(KernelGlobals kg, if (type == NODE_ATTR_OUTPUT_FLOAT) { const float f = volume_attribute_value_to_float(value); - stack_store_float(stack, out_offset, f); + stack_store_float(svm, out_offset, f); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { const float3 f = volume_attribute_value_to_float3(value); - stack_store_float3(stack, out_offset, f); + stack_store_float3(svm, out_offset, f); } else { const float f = volume_attribute_value_to_alpha(value); - stack_store_float(stack, out_offset, f); + stack_store_float(svm, out_offset, f); } return; } @@ -73,7 +73,7 @@ ccl_device_noinline void svm_node_attr(KernelGlobals kg, #endif if (sd->type == PRIMITIVE_LAMP && node.y == ATTR_STD_UV) { - stack_store_float3(stack, out_offset, make_float3(1.0f - sd->u - sd->v, sd->u, 0.0f)); + stack_store_float3(svm, out_offset, make_float3(1.0f - sd->u - sd->v, sd->u, 0.0f)); return; } @@ -84,13 +84,13 @@ ccl_device_noinline void svm_node_attr(KernelGlobals kg, object_inverse_position_transform(kg, sd, &f); } if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(f)); + stack_store_float(svm, out_offset, average(f)); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, f); + stack_store_float3(svm, out_offset, f); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } return; } @@ -99,49 +99,49 @@ ccl_device_noinline void svm_node_attr(KernelGlobals kg, if (desc.type == NODE_ATTR_FLOAT) { float f = primitive_surface_attribute_float(kg, sd, desc, NULL, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, f); + stack_store_float(svm, out_offset, f); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(f, f, f)); + stack_store_float3(svm, out_offset, make_float3(f, f, f)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } else if (desc.type == NODE_ATTR_FLOAT2) { float2 f = primitive_surface_attribute_float2(kg, sd, desc, NULL, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, f.x); + stack_store_float(svm, out_offset, f.x); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(f.x, f.y, 0.0f)); + stack_store_float3(svm, out_offset, make_float3(f.x, f.y, 0.0f)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) { float4 f = primitive_surface_attribute_float4(kg, sd, desc, NULL, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(float4_to_float3(f))); + stack_store_float(svm, out_offset, average(float4_to_float3(f))); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, float4_to_float3(f)); + stack_store_float3(svm, out_offset, float4_to_float3(f)); } else { - stack_store_float(stack, out_offset, f.w); + stack_store_float(svm, out_offset, f.w); } } else { float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(f)); + stack_store_float(svm, out_offset, average(f)); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, f); + stack_store_float3(svm, out_offset, f); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } } @@ -158,7 +158,7 @@ ccl_device_forceinline float3 svm_node_bump_P_dy(const ccl_private ShaderData *s ccl_device_noinline void svm_node_attr_bump_dx(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT; @@ -169,13 +169,13 @@ ccl_device_noinline void svm_node_attr_bump_dx(KernelGlobals kg, /* Volume */ if (primitive_is_volume_attribute(sd, desc)) { if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, 0.0f); + stack_store_float(svm, out_offset, 0.0f); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f)); + stack_store_float3(svm, out_offset, make_float3(0.0f, 0.0f, 0.0f)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } return; } @@ -188,13 +188,13 @@ ccl_device_noinline void svm_node_attr_bump_dx(KernelGlobals kg, object_inverse_position_transform(kg, sd, &f); } if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(f)); + stack_store_float(svm, out_offset, average(f)); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, f); + stack_store_float3(svm, out_offset, f); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } return; } @@ -204,59 +204,59 @@ ccl_device_noinline void svm_node_attr_bump_dx(KernelGlobals kg, float dx; float f = primitive_surface_attribute_float(kg, sd, desc, &dx, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, f + dx); + stack_store_float(svm, out_offset, f + dx); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(f + dx, f + dx, f + dx)); + stack_store_float3(svm, out_offset, make_float3(f + dx, f + dx, f + dx)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } else if (desc.type == NODE_ATTR_FLOAT2) { float2 dx; float2 f = primitive_surface_attribute_float2(kg, sd, desc, &dx, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, f.x + dx.x); + stack_store_float(svm, out_offset, f.x + dx.x); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(f.x + dx.x, f.y + dx.y, 0.0f)); + stack_store_float3(svm, out_offset, make_float3(f.x + dx.x, f.y + dx.y, 0.0f)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) { float4 dx; float4 f = primitive_surface_attribute_float4(kg, sd, desc, &dx, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(float4_to_float3(f + dx))); + stack_store_float(svm, out_offset, average(float4_to_float3(f + dx))); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, float4_to_float3(f + dx)); + stack_store_float3(svm, out_offset, float4_to_float3(f + dx)); } else { - stack_store_float(stack, out_offset, f.w + dx.w); + stack_store_float(svm, out_offset, f.w + dx.w); } } else { float3 dx; float3 f = primitive_surface_attribute_float3(kg, sd, desc, &dx, NULL); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(f + dx)); + stack_store_float(svm, out_offset, average(f + dx)); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, f + dx); + stack_store_float3(svm, out_offset, f + dx); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } } ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT; @@ -267,13 +267,13 @@ ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg, /* Volume */ if (primitive_is_volume_attribute(sd, desc)) { if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, 0.0f); + stack_store_float(svm, out_offset, 0.0f); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f)); + stack_store_float3(svm, out_offset, make_float3(0.0f, 0.0f, 0.0f)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } return; } @@ -286,13 +286,13 @@ ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg, object_inverse_position_transform(kg, sd, &f); } if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(f)); + stack_store_float(svm, out_offset, average(f)); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, f); + stack_store_float3(svm, out_offset, f); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } return; } @@ -302,52 +302,52 @@ ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg, float dy; float f = primitive_surface_attribute_float(kg, sd, desc, NULL, &dy); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, f + dy); + stack_store_float(svm, out_offset, f + dy); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(f + dy, f + dy, f + dy)); + stack_store_float3(svm, out_offset, make_float3(f + dy, f + dy, f + dy)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } else if (desc.type == NODE_ATTR_FLOAT2) { float2 dy; float2 f = primitive_surface_attribute_float2(kg, sd, desc, NULL, &dy); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, f.x + dy.x); + stack_store_float(svm, out_offset, f.x + dy.x); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, make_float3(f.x + dy.x, f.y + dy.y, 0.0f)); + stack_store_float3(svm, out_offset, make_float3(f.x + dy.x, f.y + dy.y, 0.0f)); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) { float4 dy; float4 f = primitive_surface_attribute_float4(kg, sd, desc, NULL, &dy); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(float4_to_float3(f + dy))); + stack_store_float(svm, out_offset, average(float4_to_float3(f + dy))); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, float4_to_float3(f + dy)); + stack_store_float3(svm, out_offset, float4_to_float3(f + dy)); } else { - stack_store_float(stack, out_offset, f.w + dy.w); + stack_store_float(svm, out_offset, f.w + dy.w); } } else { float3 dy; float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, &dy); if (type == NODE_ATTR_OUTPUT_FLOAT) { - stack_store_float(stack, out_offset, average(f + dy)); + stack_store_float(svm, out_offset, average(f + dy)); } else if (type == NODE_ATTR_OUTPUT_FLOAT3) { - stack_store_float3(stack, out_offset, f + dy); + stack_store_float3(svm, out_offset, f + dy); } else { - stack_store_float(stack, out_offset, 1.0f); + stack_store_float(svm, out_offset, 1.0f); } } } diff --git a/intern/cycles/kernel/svm/bevel.h b/intern/cycles/kernel/svm/bevel.h index 2440095f1d8..c586a8d73c6 100644 --- a/intern/cycles/kernel/svm/bevel.h +++ b/intern/cycles/kernel/svm/bevel.h @@ -297,7 +297,7 @@ ccl_device_noinline svm_node_bevel(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint num_samples, radius_offset, normal_offset, out_offset; @@ -307,7 +307,7 @@ ccl_device_noinline IF_KERNEL_NODES_FEATURE(RAYTRACE) { - float radius = stack_load_float(stack, radius_offset); + float radius = stack_load_float(svm, radius_offset); # ifdef __KERNEL_OPTIX__ bevel_N = optixDirectCall(1, kg, state, sd, radius, num_samples); @@ -317,12 +317,12 @@ ccl_device_noinline if (stack_valid(normal_offset)) { /* Preserve input normal. */ - float3 ref_N = stack_load_float3(stack, normal_offset); + float3 ref_N = stack_load_float3(svm, normal_offset); bevel_N = normalize(ref_N + (bevel_N - sd->N)); } } - stack_store_float3(stack, out_offset, bevel_N); + stack_store_float3(svm, out_offset, bevel_N); } #endif /* __SHADER_RAYTRACE__ */ diff --git a/intern/cycles/kernel/svm/blackbody.h b/intern/cycles/kernel/svm/blackbody.h index b0ff57d6e49..004864cb515 100644 --- a/intern/cycles/kernel/svm/blackbody.h +++ b/intern/cycles/kernel/svm/blackbody.h @@ -15,17 +15,17 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_blackbody(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint temperature_offset, uint col_offset) { /* Input */ - float temperature = stack_load_float(stack, temperature_offset); + float temperature = stack_load_float(svm, temperature_offset); float3 color_rgb = rec709_to_rgb(kg, svm_math_blackbody_color_rec709(temperature)); color_rgb = max(color_rgb, zero_float3()); - stack_store_float3(stack, col_offset, color_rgb); + stack_store_float3(svm, col_offset, color_rgb); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/brick.h b/intern/cycles/kernel/svm/brick.h index 9e0eceafa2e..1419d771800 100644 --- a/intern/cycles/kernel/svm/brick.h +++ b/intern/cycles/kernel/svm/brick.h @@ -62,12 +62,14 @@ ccl_device_noinline_cpu float2 svm_brick(float3 p, return make_float2(tint, mortar); } -ccl_device_noinline int svm_node_tex_brick( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_tex_brick(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { - uint4 node2 = read_node(kg, &offset); - uint4 node3 = read_node(kg, &offset); - uint4 node4 = read_node(kg, &offset); + uint4 node2 = read_node(kg, svm); + uint4 node3 = read_node(kg, svm); + uint4 node4 = read_node(kg, svm); /* Input and Output Sockets */ uint co_offset, color1_offset, color2_offset, mortar_offset, scale_offset; @@ -85,18 +87,18 @@ ccl_device_noinline int svm_node_tex_brick( svm_unpack_node_uchar2(node2.x, &offset_frequency, &squash_frequency); - float3 co = stack_load_float3(stack, co_offset); + float3 co = stack_load_float3(svm, co_offset); - float3 color1 = stack_load_float3(stack, color1_offset); - float3 color2 = stack_load_float3(stack, color2_offset); - float3 mortar = stack_load_float3(stack, mortar_offset); + float3 color1 = stack_load_float3(svm, color1_offset); + float3 color2 = stack_load_float3(svm, color2_offset); + float3 mortar = stack_load_float3(svm, mortar_offset); - float scale = stack_load_float_default(stack, scale_offset, node2.y); - float mortar_size = stack_load_float_default(stack, mortar_size_offset, node2.z); - float mortar_smooth = stack_load_float_default(stack, mortar_smooth_offset, node4.x); - float bias = stack_load_float_default(stack, bias_offset, node2.w); - float brick_width = stack_load_float_default(stack, brick_width_offset, node3.x); - float row_height = stack_load_float_default(stack, row_height_offset, node3.y); + float scale = stack_load_float_default(svm, scale_offset, node2.y); + float mortar_size = stack_load_float_default(svm, mortar_size_offset, node2.z); + float mortar_smooth = stack_load_float_default(svm, mortar_smooth_offset, node4.x); + float bias = stack_load_float_default(svm, bias_offset, node2.w); + float brick_width = stack_load_float_default(svm, brick_width_offset, node3.x); + float row_height = stack_load_float_default(svm, row_height_offset, node3.y); float offset_amount = __int_as_float(node3.z); float squash_amount = __int_as_float(node3.w); @@ -120,10 +122,9 @@ ccl_device_noinline int svm_node_tex_brick( } if (stack_valid(color_offset)) - stack_store_float3(stack, color_offset, color1 * (1.0f - f) + mortar * f); + stack_store_float3(svm, color_offset, color1 * (1.0f - f) + mortar * f); if (stack_valid(fac_offset)) - stack_store_float(stack, fac_offset, f); - return offset; + stack_store_float(svm, fac_offset, f); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/brightness.h b/intern/cycles/kernel/svm/brightness.h index 906f5f1eb23..79e7e8ff586 100644 --- a/intern/cycles/kernel/svm/brightness.h +++ b/intern/cycles/kernel/svm/brightness.h @@ -8,20 +8,23 @@ CCL_NAMESPACE_BEGIN -ccl_device_noinline void svm_node_brightness( - ccl_private ShaderData *sd, ccl_private float *stack, uint in_color, uint out_color, uint node) +ccl_device_noinline void svm_node_brightness(ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint in_color, + uint out_color, + uint node) { uint bright_offset, contrast_offset; - float3 color = stack_load_float3(stack, in_color); + float3 color = stack_load_float3(svm, in_color); svm_unpack_node_uchar2(node, &bright_offset, &contrast_offset); - float brightness = stack_load_float(stack, bright_offset); - float contrast = stack_load_float(stack, contrast_offset); + float brightness = stack_load_float(svm, bright_offset); + float contrast = stack_load_float(svm, contrast_offset); color = svm_brightness_contrast(color, brightness, contrast); if (stack_valid(out_color)) - stack_store_float3(stack, out_color, color); + stack_store_float3(svm, out_color, color); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/bump.h b/intern/cycles/kernel/svm/bump.h index 4470cc3a94e..a9bbf5a14af 100644 --- a/intern/cycles/kernel/svm/bump.h +++ b/intern/cycles/kernel/svm/bump.h @@ -10,12 +10,12 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_enter_bump_eval(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint offset) { /* save state */ - stack_store_float3(stack, offset + 0, sd->P); - stack_store_float(stack, offset + 3, sd->dP); + stack_store_float3(svm, offset + 0, sd->P); + stack_store_float(svm, offset + 3, sd->dP); /* set state as if undisplaced */ const AttributeDescriptor desc = find_attribute(kg, sd, ATTR_STD_POSITION_UNDISPLACED); @@ -35,12 +35,12 @@ ccl_device_noinline void svm_node_enter_bump_eval(KernelGlobals kg, ccl_device_noinline void svm_node_leave_bump_eval(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint offset) { /* restore state */ - sd->P = stack_load_float3(stack, offset + 0); - sd->dP = stack_load_float(stack, offset + 3); + sd->P = stack_load_float3(svm, offset + 0); + sd->dP = stack_load_float(svm, offset + 3); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/camera.h b/intern/cycles/kernel/svm/camera.h index cd684bb946f..41fac025606 100644 --- a/intern/cycles/kernel/svm/camera.h +++ b/intern/cycles/kernel/svm/camera.h @@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_camera(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint out_vector, uint out_zdepth, uint out_distance) @@ -23,13 +23,13 @@ ccl_device_noinline void svm_node_camera(KernelGlobals kg, distance = len(vector); if (stack_valid(out_vector)) - stack_store_float3(stack, out_vector, normalize(vector)); + stack_store_float3(svm, out_vector, normalize(vector)); if (stack_valid(out_zdepth)) - stack_store_float(stack, out_zdepth, zdepth); + stack_store_float(svm, out_zdepth, zdepth); if (stack_valid(out_distance)) - stack_store_float(stack, out_distance, distance); + stack_store_float(svm, out_distance, distance); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/checker.h b/intern/cycles/kernel/svm/checker.h index ee9b9c46c8b..30f32bb58d0 100644 --- a/intern/cycles/kernel/svm/checker.h +++ b/intern/cycles/kernel/svm/checker.h @@ -24,7 +24,7 @@ ccl_device float svm_checker(float3 p) ccl_device_noinline void svm_node_tex_checker(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint co_offset, color1_offset, color2_offset, scale_offset; @@ -33,17 +33,17 @@ ccl_device_noinline void svm_node_tex_checker(KernelGlobals kg, svm_unpack_node_uchar4(node.y, &co_offset, &color1_offset, &color2_offset, &scale_offset); svm_unpack_node_uchar2(node.z, &color_offset, &fac_offset); - float3 co = stack_load_float3(stack, co_offset); - float3 color1 = stack_load_float3(stack, color1_offset); - float3 color2 = stack_load_float3(stack, color2_offset); - float scale = stack_load_float_default(stack, scale_offset, node.w); + float3 co = stack_load_float3(svm, co_offset); + float3 color1 = stack_load_float3(svm, color1_offset); + float3 color2 = stack_load_float3(svm, color2_offset); + float scale = stack_load_float_default(svm, scale_offset, node.w); float f = svm_checker(co * scale); if (stack_valid(color_offset)) - stack_store_float3(stack, color_offset, (f == 1.0f) ? color1 : color2); + stack_store_float3(svm, color_offset, (f == 1.0f) ? color1 : color2); if (stack_valid(fac_offset)) - stack_store_float(stack, fac_offset, f); + stack_store_float(svm, fac_offset, f); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/clamp.h b/intern/cycles/kernel/svm/clamp.h index 8fc59a0885e..01bfa8b13b4 100644 --- a/intern/cycles/kernel/svm/clamp.h +++ b/intern/cycles/kernel/svm/clamp.h @@ -8,30 +8,28 @@ CCL_NAMESPACE_BEGIN /* Clamp Node */ -ccl_device_noinline int svm_node_clamp(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint value_stack_offset, - uint parameters_stack_offsets, - uint result_stack_offset, - int offset) +ccl_device_noinline void svm_node_clamp(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint value_stack_offset, + uint parameters_stack_offsets, + uint result_stack_offset) { uint min_stack_offset, max_stack_offset, type; svm_unpack_node_uchar3(parameters_stack_offsets, &min_stack_offset, &max_stack_offset, &type); - uint4 defaults = read_node(kg, &offset); + uint4 defaults = read_node(kg, svm); - float value = stack_load_float(stack, value_stack_offset); - float min = stack_load_float_default(stack, min_stack_offset, defaults.x); - float max = stack_load_float_default(stack, max_stack_offset, defaults.y); + float value = stack_load_float(svm, value_stack_offset); + float min = stack_load_float_default(svm, min_stack_offset, defaults.x); + float max = stack_load_float_default(svm, max_stack_offset, defaults.y); if (type == NODE_CLAMP_RANGE && (min > max)) { - stack_store_float(stack, result_stack_offset, clamp(value, max, min)); + stack_store_float(svm, result_stack_offset, clamp(value, max, min)); } else { - stack_store_float(stack, result_stack_offset, clamp(value, min, max)); + stack_store_float(svm, result_stack_offset, clamp(value, min, max)); } - return offset; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/closure.h b/intern/cycles/kernel/svm/closure.h index 5c34cc1f868..c7c85d9428e 100644 --- a/intern/cycles/kernel/svm/closure.h +++ b/intern/cycles/kernel/svm/closure.h @@ -15,55 +15,56 @@ CCL_NAMESPACE_BEGIN /* Closure Nodes */ -ccl_device_inline int svm_node_closure_bsdf_skip(KernelGlobals kg, int offset, uint type) +ccl_device_inline void svm_node_closure_bsdf_skip(KernelGlobals kg, + ccl_private SVMState *svm, + uint type) { if (type == CLOSURE_BSDF_PRINCIPLED_ID) { /* Read all principled BSDF extra data to get the right offset. */ - read_node(kg, &offset); - read_node(kg, &offset); - read_node(kg, &offset); - read_node(kg, &offset); + read_node(kg, svm); + read_node(kg, svm); + read_node(kg, svm); + read_node(kg, svm); } - - return offset; } template -ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - Spectrum closure_weight, - uint4 node, - uint32_t path_flag, - int offset) +ccl_device_noinline void svm_node_closure_bsdf(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node, + uint32_t path_flag) { uint type, param1_offset, param2_offset; uint mix_weight_offset; svm_unpack_node_uchar4(node.y, &type, ¶m1_offset, ¶m2_offset, &mix_weight_offset); - float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(stack, mix_weight_offset) : + float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(svm, mix_weight_offset) : 1.0f); + float3 closure_weight = svm->closure_weight * mix_weight; /* note we read this extra node before weight check, so offset is added */ - uint4 data_node = read_node(kg, &offset); + uint4 data_node = read_node(kg, svm); /* Only compute BSDF for surfaces, transparent variable is shared with volume extinction. */ IF_KERNEL_NODES_FEATURE(BSDF) { if ((shader_type != SHADER_TYPE_SURFACE) || mix_weight == 0.0f) { - return svm_node_closure_bsdf_skip(kg, offset, type); + svm_node_closure_bsdf_skip(kg, svm, type); + return; } } else { - return svm_node_closure_bsdf_skip(kg, offset, type); + svm_node_closure_bsdf_skip(kg, svm, type); + return; } - float3 N = stack_valid(data_node.x) ? safe_normalize(stack_load_float3(stack, data_node.x)) : + float3 N = stack_valid(data_node.x) ? safe_normalize(stack_load_float3(svm, data_node.x)) : sd->N; - float param1 = (stack_valid(param1_offset)) ? stack_load_float(stack, param1_offset) : + float param1 = (stack_valid(param1_offset)) ? stack_load_float(svm, param1_offset) : __uint_as_float(node.z); - float param2 = (stack_valid(param2_offset)) ? stack_load_float(stack, param2_offset) : + float param2 = (stack_valid(param2_offset)) ? stack_load_float(svm, param2_offset) : __uint_as_float(node.w); switch (type) { @@ -71,9 +72,9 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, uint specular_offset, roughness_offset, specular_tint_offset, anisotropic_offset, sheen_offset, sheen_tint_offset, clearcoat_offset, clearcoat_roughness_offset, eta_offset, transmission_offset, anisotropic_rotation_offset, pad1; - uint4 data_node2 = read_node(kg, &offset); + uint4 data_node2 = read_node(kg, svm); - float3 T = stack_load_float3(stack, data_node.y); + float3 T = stack_load_float3(svm, data_node.y); svm_unpack_node_uchar4(data_node.z, &specular_offset, &roughness_offset, @@ -90,17 +91,17 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, // get Disney principled parameters float metallic = param1; float subsurface = param2; - float specular = stack_load_float(stack, specular_offset); - float roughness = stack_load_float(stack, roughness_offset); - float specular_tint = stack_load_float(stack, specular_tint_offset); - float anisotropic = stack_load_float(stack, anisotropic_offset); - float sheen = stack_load_float(stack, sheen_offset); - float sheen_tint = stack_load_float(stack, sheen_tint_offset); - float clearcoat = stack_load_float(stack, clearcoat_offset); - float clearcoat_roughness = stack_load_float(stack, clearcoat_roughness_offset); - float transmission = stack_load_float(stack, transmission_offset); - float anisotropic_rotation = stack_load_float(stack, anisotropic_rotation_offset); - float eta = fmaxf(stack_load_float(stack, eta_offset), 1e-5f); + float specular = stack_load_float(svm, specular_offset); + float roughness = stack_load_float(svm, roughness_offset); + float specular_tint = stack_load_float(svm, specular_tint_offset); + float anisotropic = stack_load_float(svm, anisotropic_offset); + float sheen = stack_load_float(svm, sheen_offset); + float sheen_tint = stack_load_float(svm, sheen_tint_offset); + float clearcoat = stack_load_float(svm, clearcoat_offset); + float clearcoat_roughness = stack_load_float(svm, clearcoat_roughness_offset); + float transmission = stack_load_float(svm, transmission_offset); + float anisotropic_rotation = stack_load_float(svm, anisotropic_rotation_offset); + float eta = fmaxf(stack_load_float(svm, eta_offset), 1e-5f); ClosureType distribution = (ClosureType)data_node2.y; ClosureType subsurface_method = (ClosureType)data_node2.z; @@ -118,37 +119,37 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, float specular_weight = (1.0f - final_transmission); // get the base color - uint4 data_base_color = read_node(kg, &offset); + uint4 data_base_color = read_node(kg, svm); float3 base_color = stack_valid(data_base_color.x) ? - stack_load_float3(stack, data_base_color.x) : + stack_load_float3(svm, data_base_color.x) : make_float3(__uint_as_float(data_base_color.y), __uint_as_float(data_base_color.z), __uint_as_float(data_base_color.w)); // get the additional clearcoat normal and subsurface scattering radius - uint4 data_cn_ssr = read_node(kg, &offset); + uint4 data_cn_ssr = read_node(kg, svm); float3 clearcoat_normal = stack_valid(data_cn_ssr.x) ? - stack_load_float3(stack, data_cn_ssr.x) : + stack_load_float3(svm, data_cn_ssr.x) : sd->N; clearcoat_normal = maybe_ensure_valid_specular_reflection(sd, clearcoat_normal); float3 subsurface_radius = stack_valid(data_cn_ssr.y) ? - stack_load_float3(stack, data_cn_ssr.y) : + stack_load_float3(svm, data_cn_ssr.y) : one_float3(); - float subsurface_ior = stack_valid(data_cn_ssr.z) ? stack_load_float(stack, data_cn_ssr.z) : + float subsurface_ior = stack_valid(data_cn_ssr.z) ? stack_load_float(svm, data_cn_ssr.z) : 1.4f; float subsurface_anisotropy = stack_valid(data_cn_ssr.w) ? - stack_load_float(stack, data_cn_ssr.w) : + stack_load_float(svm, data_cn_ssr.w) : 0.0f; // get the subsurface color - uint4 data_subsurface_color = read_node(kg, &offset); + uint4 data_subsurface_color = read_node(kg, svm); float3 subsurface_color = stack_valid(data_subsurface_color.x) ? - stack_load_float3(stack, data_subsurface_color.x) : + stack_load_float3(svm, data_subsurface_color.x) : make_float3(__uint_as_float(data_subsurface_color.y), __uint_as_float(data_subsurface_color.z), __uint_as_float(data_subsurface_color.w)); - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; #ifdef __SUBSURFACE__ float3 mixed_ss_base_color = subsurface_color * subsurface + @@ -354,7 +355,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; } case CLOSURE_BSDF_DIFFUSE_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private OrenNayarBsdf *bsdf = (ccl_private OrenNayarBsdf *)bsdf_alloc( sd, sizeof(OrenNayarBsdf), weight); @@ -374,7 +375,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; } case CLOSURE_BSDF_TRANSLUCENT_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private DiffuseBsdf *bsdf = (ccl_private DiffuseBsdf *)bsdf_alloc( sd, sizeof(DiffuseBsdf), weight); @@ -385,7 +386,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; } case CLOSURE_BSDF_TRANSPARENT_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; bsdf_transparent_setup(sd, weight, path_flag); break; } @@ -397,7 +398,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, if (!kernel_data.integrator.caustics_reflective && (path_flag & PATH_RAY_DIFFUSE)) break; #endif - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private MicrofacetBsdf *bsdf = (ccl_private MicrofacetBsdf *)bsdf_alloc( sd, sizeof(MicrofacetBsdf), weight); @@ -419,10 +420,10 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, bsdf->alpha_y = roughness; } else { - bsdf->T = stack_load_float3(stack, data_node.y); + bsdf->T = stack_load_float3(svm, data_node.y); /* rotate tangent */ - float rotation = stack_load_float(stack, data_node.z); + float rotation = stack_load_float(svm, data_node.z); if (rotation != 0.0f) bsdf->T = rotate_around_axis(bsdf->T, bsdf->N, rotation * M_2PI_F); @@ -447,7 +448,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, sd->flag |= bsdf_microfacet_ggx_setup(bsdf); if (type == CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID) { kernel_assert(stack_valid(data_node.w)); - const Spectrum color = rgb_to_spectrum(stack_load_float3(stack, data_node.w)); + const Spectrum color = rgb_to_spectrum(stack_load_float3(svm, data_node.w)); bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd, color); } } @@ -460,7 +461,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, if (!kernel_data.integrator.caustics_refractive && (path_flag & PATH_RAY_DIFFUSE)) break; #endif - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private MicrofacetBsdf *bsdf = (ccl_private MicrofacetBsdf *)bsdf_alloc( sd, sizeof(MicrofacetBsdf), weight); @@ -495,7 +496,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, !kernel_data.integrator.caustics_refractive && (path_flag & PATH_RAY_DIFFUSE)) break; #endif - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private MicrofacetBsdf *bsdf = (ccl_private MicrofacetBsdf *)bsdf_alloc( sd, sizeof(MicrofacetBsdf), weight); @@ -520,7 +521,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf); if (type == CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID) { kernel_assert(stack_valid(data_node.z)); - const Spectrum color = rgb_to_spectrum(stack_load_float3(stack, data_node.z)); + const Spectrum color = rgb_to_spectrum(stack_load_float3(svm, data_node.z)); bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd, color); } } @@ -529,7 +530,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; } case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private VelvetBsdf *bsdf = (ccl_private VelvetBsdf *)bsdf_alloc( sd, sizeof(VelvetBsdf), weight); @@ -542,7 +543,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; } case CLOSURE_BSDF_SHEEN_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private SheenBsdf *bsdf = (ccl_private SheenBsdf *)bsdf_alloc( sd, sizeof(SheenBsdf), weight); @@ -561,7 +562,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, ATTR_FALLTHROUGH; #endif case CLOSURE_BSDF_DIFFUSE_TOON_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private ToonBsdf *bsdf = (ccl_private ToonBsdf *)bsdf_alloc( sd, sizeof(ToonBsdf), weight); @@ -579,16 +580,16 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, } #ifdef __HAIR__ case CLOSURE_BSDF_HAIR_PRINCIPLED_ID: { - uint4 data_node2 = read_node(kg, &offset); - uint4 data_node3 = read_node(kg, &offset); - uint4 data_node4 = read_node(kg, &offset); + uint4 data_node2 = read_node(kg, svm); + uint4 data_node3 = read_node(kg, svm); + uint4 data_node4 = read_node(kg, svm); - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; uint offset_ofs, ior_ofs, color_ofs, parametrization; svm_unpack_node_uchar4(data_node.y, &offset_ofs, &ior_ofs, &color_ofs, ¶metrization); - float alpha = stack_load_float_default(stack, offset_ofs, data_node.z); - float ior = stack_load_float_default(stack, ior_ofs, data_node.w); + float alpha = stack_load_float_default(svm, offset_ofs, data_node.z); + float ior = stack_load_float_default(svm, ior_ofs, data_node.w); uint coat_ofs, melanin_ofs, melanin_redness_ofs, absorption_coefficient_ofs; svm_unpack_node_uchar4(data_node2.x, @@ -607,7 +608,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, random = primitive_surface_attribute_float(kg, sd, attr_descr_random, NULL, NULL); } else { - random = stack_load_float_default(stack, random_ofs, data_node3.y); + random = stack_load_float_default(svm, random_ofs, data_node3.y); } ccl_private PrincipledHairBSDF *bsdf = (ccl_private PrincipledHairBSDF *)bsdf_alloc( @@ -620,14 +621,13 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; /* Random factors range: [-randomization/2, +randomization/2]. */ - float random_roughness = stack_load_float_default( - stack, random_roughness_ofs, data_node3.w); + float random_roughness = stack_load_float_default(svm, random_roughness_ofs, data_node3.w); float factor_random_roughness = 1.0f + 2.0f * (random - 0.5f) * random_roughness; float roughness = param1 * factor_random_roughness; float radial_roughness = param2 * factor_random_roughness; /* Remap Coat value to [0, 100]% of Roughness. */ - float coat = stack_load_float_default(stack, coat_ofs, data_node2.y); + float coat = stack_load_float_default(svm, coat_ofs, data_node2.y); float m0_roughness = 1.0f - clamp(coat, 0.0f, 1.0f); bsdf->N = maybe_ensure_valid_specular_reflection(sd, N); @@ -640,17 +640,17 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, switch (parametrization) { case NODE_PRINCIPLED_HAIR_DIRECT_ABSORPTION: { - float3 absorption_coefficient = stack_load_float3(stack, absorption_coefficient_ofs); + float3 absorption_coefficient = stack_load_float3(svm, absorption_coefficient_ofs); bsdf->sigma = rgb_to_spectrum(absorption_coefficient); break; } case NODE_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION: { - float melanin = stack_load_float_default(stack, melanin_ofs, data_node2.z); + float melanin = stack_load_float_default(svm, melanin_ofs, data_node2.z); float melanin_redness = stack_load_float_default( - stack, melanin_redness_ofs, data_node2.w); + svm, melanin_redness_ofs, data_node2.w); /* Randomize melanin. */ - float random_color = stack_load_float_default(stack, random_color_ofs, data_node3.z); + float random_color = stack_load_float_default(svm, random_color_ofs, data_node3.z); random_color = clamp(random_color, 0.0f, 1.0f); float factor_random_color = 1.0f + 2.0f * (random - 0.5f) * random_color; melanin *= factor_random_color; @@ -665,7 +665,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, pheomelanin); /* Optional tint. */ - float3 tint = stack_load_float3(stack, tint_ofs); + float3 tint = stack_load_float3(svm, tint_ofs); Spectrum tint_sigma = bsdf_principled_hair_sigma_from_reflectance( rgb_to_spectrum(tint), radial_roughness); @@ -673,7 +673,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, break; } case NODE_PRINCIPLED_HAIR_REFLECTANCE: { - float3 color = stack_load_float3(stack, color_ofs); + float3 color = stack_load_float3(svm, color_ofs); bsdf->sigma = bsdf_principled_hair_sigma_from_reflectance(rgb_to_spectrum(color), radial_roughness); break; @@ -692,7 +692,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, } case CLOSURE_BSDF_HAIR_REFLECTION_ID: case CLOSURE_BSDF_HAIR_TRANSMISSION_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private HairBsdf *bsdf = (ccl_private HairBsdf *)bsdf_alloc( sd, sizeof(HairBsdf), weight); @@ -701,10 +701,10 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, bsdf->N = maybe_ensure_valid_specular_reflection(sd, N); bsdf->roughness1 = param1; bsdf->roughness2 = param2; - bsdf->offset = -stack_load_float(stack, data_node.z); + bsdf->offset = -stack_load_float(svm, data_node.z); if (stack_valid(data_node.y)) { - bsdf->T = normalize(stack_load_float3(stack, data_node.y)); + bsdf->T = normalize(stack_load_float3(svm, data_node.y)); } else if (!(sd->type & PRIMITIVE_CURVE)) { bsdf->T = normalize(sd->dPdv); @@ -729,7 +729,7 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, case CLOSURE_BSSRDF_BURLEY_ID: case CLOSURE_BSSRDF_RANDOM_WALK_ID: case CLOSURE_BSSRDF_RANDOM_WALK_FIXED_RADIUS_ID: { - Spectrum weight = closure_weight * mix_weight; + Spectrum weight = closure_weight; ccl_private Bssrdf *bssrdf = bssrdf_alloc(sd, weight); if (bssrdf) { @@ -739,13 +739,13 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, if (path_flag & PATH_RAY_DIFFUSE_ANCESTOR) param1 = 0.0f; - bssrdf->radius = rgb_to_spectrum(stack_load_float3(stack, data_node.z) * param1); - bssrdf->albedo = closure_weight; + bssrdf->radius = rgb_to_spectrum(stack_load_float3(svm, data_node.z) * param1); + bssrdf->albedo = svm->closure_weight; bssrdf->N = N; bssrdf->roughness = FLT_MAX; const float subsurface_ior = clamp(param2, 1.01f, 3.8f); - const float subsurface_anisotropy = stack_load_float(stack, data_node.w); + const float subsurface_anisotropy = stack_load_float(svm, data_node.w); bssrdf->anisotropy = clamp(subsurface_anisotropy, 0.0f, 0.9f); sd->flag |= bssrdf_setup(sd, bssrdf, (ClosureType)type, subsurface_ior); @@ -757,15 +757,12 @@ ccl_device_noinline int svm_node_closure_bsdf(KernelGlobals kg, default: break; } - - return offset; } template ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, - Spectrum closure_weight, + ccl_private SVMState *svm, uint4 node) { #ifdef __VOLUME__ @@ -778,19 +775,19 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg, uint mix_weight_offset; svm_unpack_node_uchar4(node.y, &type, &density_offset, &anisotropy_offset, &mix_weight_offset); - float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(stack, mix_weight_offset) : + float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(svm, mix_weight_offset) : 1.0f); if (mix_weight == 0.0f) { return; } - float density = (stack_valid(density_offset)) ? stack_load_float(stack, density_offset) : + float density = (stack_valid(density_offset)) ? stack_load_float(svm, density_offset) : __uint_as_float(node.z); density = mix_weight * fmaxf(density, 0.0f); /* Compute scattering coefficient. */ - Spectrum weight = closure_weight; + Spectrum weight = svm->closure_weight; if (type == CLOSURE_VOLUME_ABSORPTION_ID) { weight = one_spectrum() - weight; @@ -805,7 +802,7 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg, if (volume) { float anisotropy = (stack_valid(anisotropy_offset)) ? - stack_load_float(stack, anisotropy_offset) : + stack_load_float(svm, anisotropy_offset) : __uint_as_float(node.w); volume->g = anisotropy; /* g */ sd->flag |= volume_henyey_greenstein_setup(volume); @@ -818,36 +815,34 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg, } template -ccl_device_noinline int svm_node_principled_volume(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - Spectrum closure_weight, - uint4 node, - uint32_t path_flag, - int offset) +ccl_device_noinline void svm_node_principled_volume(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node, + uint32_t path_flag) { #ifdef __VOLUME__ - uint4 value_node = read_node(kg, &offset); - uint4 attr_node = read_node(kg, &offset); + uint4 value_node = read_node(kg, svm); + uint4 attr_node = read_node(kg, svm); /* Only sum extinction for volumes, variable is shared with surface transparency. */ if (shader_type != SHADER_TYPE_VOLUME) { - return offset; + return; } uint density_offset, anisotropy_offset, absorption_color_offset, mix_weight_offset; svm_unpack_node_uchar4( node.y, &density_offset, &anisotropy_offset, &absorption_color_offset, &mix_weight_offset); - float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(stack, mix_weight_offset) : + float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(svm, mix_weight_offset) : 1.0f); if (mix_weight == 0.0f) { - return offset; + return; } /* Compute density. */ float primitive_density = 1.0f; - float density = (stack_valid(density_offset)) ? stack_load_float(stack, density_offset) : + float density = (stack_valid(density_offset)) ? stack_load_float(svm, density_offset) : __uint_as_float(value_node.x); density = mix_weight * fmaxf(density, 0.0f); @@ -862,7 +857,7 @@ ccl_device_noinline int svm_node_principled_volume(KernelGlobals kg, if (density > CLOSURE_WEIGHT_CUTOFF) { /* Compute scattering color. */ - Spectrum color = closure_weight; + Spectrum color = svm->closure_weight; const AttributeDescriptor attr_color = find_attribute(kg, sd, attr_node.y); if (attr_color.offset != ATTR_STD_NOT_FOUND) { @@ -874,14 +869,14 @@ ccl_device_noinline int svm_node_principled_volume(KernelGlobals kg, sd, sizeof(HenyeyGreensteinVolume), color * density); if (volume) { float anisotropy = (stack_valid(anisotropy_offset)) ? - stack_load_float(stack, anisotropy_offset) : + stack_load_float(svm, anisotropy_offset) : __uint_as_float(value_node.y); volume->g = anisotropy; sd->flag |= volume_henyey_greenstein_setup(volume); } /* Add extinction weight. */ - float3 absorption_color = max(sqrt(stack_load_float3(stack, absorption_color_offset)), + float3 absorption_color = max(sqrt(stack_load_float3(svm, absorption_color_offset)), zero_float3()); Spectrum zero = zero_spectrum(); @@ -894,24 +889,24 @@ ccl_device_noinline int svm_node_principled_volume(KernelGlobals kg, /* Compute emission. */ if (path_flag & PATH_RAY_SHADOW) { /* Don't need emission for shadows. */ - return offset; + return; } uint emission_offset, emission_color_offset, blackbody_offset, temperature_offset; svm_unpack_node_uchar4( node.z, &emission_offset, &emission_color_offset, &blackbody_offset, &temperature_offset); - float emission = (stack_valid(emission_offset)) ? stack_load_float(stack, emission_offset) : + float emission = (stack_valid(emission_offset)) ? stack_load_float(svm, emission_offset) : __uint_as_float(value_node.z); - float blackbody = (stack_valid(blackbody_offset)) ? stack_load_float(stack, blackbody_offset) : + float blackbody = (stack_valid(blackbody_offset)) ? stack_load_float(svm, blackbody_offset) : __uint_as_float(value_node.w); if (emission > CLOSURE_WEIGHT_CUTOFF) { - float3 emission_color = stack_load_float3(stack, emission_color_offset); + float3 emission_color = stack_load_float3(svm, emission_color_offset); emission_setup(sd, rgb_to_spectrum(emission * emission_color)); } if (blackbody > CLOSURE_WEIGHT_CUTOFF) { - float T = stack_load_float(stack, temperature_offset); + float T = stack_load_float(svm, temperature_offset); /* Add flame temperature from attribute if available. */ const AttributeDescriptor attr_temperature = find_attribute(kg, sd, attr_node.z); @@ -928,26 +923,24 @@ ccl_device_noinline int svm_node_principled_volume(KernelGlobals kg, float intensity = sigma * mix(1.0f, T4, blackbody); if (intensity > CLOSURE_WEIGHT_CUTOFF) { - float3 blackbody_tint = stack_load_float3(stack, node.w); + float3 blackbody_tint = stack_load_float3(svm, node.w); float3 bb = blackbody_tint * intensity * rec709_to_rgb(kg, svm_math_blackbody_color_rec709(T)); emission_setup(sd, rgb_to_spectrum(bb)); } } #endif - return offset; } ccl_device_noinline void svm_node_closure_emission(ccl_private ShaderData *sd, - ccl_private float *stack, - Spectrum closure_weight, + ccl_private SVMState *svm, uint4 node) { uint mix_weight_offset = node.y; - Spectrum weight = closure_weight; + Spectrum weight = svm->closure_weight; if (stack_valid(mix_weight_offset)) { - float mix_weight = stack_load_float(stack, mix_weight_offset); + float mix_weight = stack_load_float(svm, mix_weight_offset); if (mix_weight == 0.0f) return; @@ -959,15 +952,14 @@ ccl_device_noinline void svm_node_closure_emission(ccl_private ShaderData *sd, } ccl_device_noinline void svm_node_closure_background(ccl_private ShaderData *sd, - ccl_private float *stack, - Spectrum closure_weight, + ccl_private SVMState *svm, uint4 node) { uint mix_weight_offset = node.y; - Spectrum weight = closure_weight; + Spectrum weight = svm->closure_weight; if (stack_valid(mix_weight_offset)) { - float mix_weight = stack_load_float(stack, mix_weight_offset); + float mix_weight = stack_load_float(svm, mix_weight_offset); if (mix_weight == 0.0f) return; @@ -979,22 +971,21 @@ ccl_device_noinline void svm_node_closure_background(ccl_private ShaderData *sd, } ccl_device_noinline void svm_node_closure_holdout(ccl_private ShaderData *sd, - ccl_private float *stack, - Spectrum closure_weight, + ccl_private SVMState *svm, uint4 node) { uint mix_weight_offset = node.y; if (stack_valid(mix_weight_offset)) { - float mix_weight = stack_load_float(stack, mix_weight_offset); + float mix_weight = stack_load_float(svm, mix_weight_offset); if (mix_weight == 0.0f) return; - closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, closure_weight * mix_weight); + closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, svm->closure_weight * mix_weight); } else - closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, closure_weight); + closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, svm->closure_weight); sd->flag |= SD_HOLDOUT; } @@ -1002,35 +993,33 @@ ccl_device_noinline void svm_node_closure_holdout(ccl_private ShaderData *sd, /* Closure Nodes */ ccl_device void svm_node_closure_set_weight( - ccl_private ShaderData *sd, ccl_private Spectrum *closure_weight, uint r, uint g, uint b) + ccl_private ShaderData *sd, ccl_private SVMState *svm, uint r, uint g, uint b) { - *closure_weight = rgb_to_spectrum( + svm->closure_weight = rgb_to_spectrum( make_float3(__uint_as_float(r), __uint_as_float(g), __uint_as_float(b))); } ccl_device void svm_node_closure_weight(ccl_private ShaderData *sd, - ccl_private float *stack, - ccl_private Spectrum *closure_weight, + ccl_private SVMState *svm, uint weight_offset) { - *closure_weight = rgb_to_spectrum(stack_load_float3(stack, weight_offset)); + svm->closure_weight = rgb_to_spectrum(stack_load_float3(svm, weight_offset)); } ccl_device_noinline void svm_node_emission_weight(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, - ccl_private Spectrum *closure_weight, + ccl_private SVMState *svm, uint4 node) { uint color_offset = node.y; uint strength_offset = node.z; - float strength = stack_load_float(stack, strength_offset); - *closure_weight = rgb_to_spectrum(stack_load_float3(stack, color_offset)) * strength; + float strength = stack_load_float(svm, strength_offset); + svm->closure_weight = rgb_to_spectrum(stack_load_float3(svm, color_offset)) * strength; } ccl_device_noinline void svm_node_mix_closure(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { /* fetch weight from blend input, previous mix closures, @@ -1039,29 +1028,29 @@ ccl_device_noinline void svm_node_mix_closure(ccl_private ShaderData *sd, svm_unpack_node_uchar4( node.y, &weight_offset, &in_weight_offset, &weight1_offset, &weight2_offset); - float weight = stack_load_float(stack, weight_offset); + float weight = stack_load_float(svm, weight_offset); weight = saturatef(weight); - float in_weight = (stack_valid(in_weight_offset)) ? stack_load_float(stack, in_weight_offset) : + float in_weight = (stack_valid(in_weight_offset)) ? stack_load_float(svm, in_weight_offset) : 1.0f; if (stack_valid(weight1_offset)) - stack_store_float(stack, weight1_offset, in_weight * (1.0f - weight)); + stack_store_float(svm, weight1_offset, in_weight * (1.0f - weight)); if (stack_valid(weight2_offset)) - stack_store_float(stack, weight2_offset, in_weight * weight); + stack_store_float(svm, weight2_offset, in_weight * weight); } /* (Bump) normal */ ccl_device void svm_node_set_normal(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint in_direction, uint out_normal) { - float3 normal = stack_load_float3(stack, in_direction); + float3 normal = stack_load_float3(svm, in_direction); sd->N = normal; - stack_store_float3(stack, out_normal, normal); + stack_store_float3(svm, out_normal, normal); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/convert.h b/intern/cycles/kernel/svm/convert.h index e1a1fe43995..012c2b578e1 100644 --- a/intern/cycles/kernel/svm/convert.h +++ b/intern/cycles/kernel/svm/convert.h @@ -10,54 +10,54 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_convert(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint from, uint to) { switch (type) { case NODE_CONVERT_FI: { - float f = stack_load_float(stack, from); - stack_store_int(stack, to, float_to_int(f)); + float f = stack_load_float(svm, from); + stack_store_int(svm, to, float_to_int(f)); break; } case NODE_CONVERT_FV: { - float f = stack_load_float(stack, from); - stack_store_float3(stack, to, make_float3(f, f, f)); + float f = stack_load_float(svm, from); + stack_store_float3(svm, to, make_float3(f, f, f)); break; } case NODE_CONVERT_CF: { - float3 f = stack_load_float3(stack, from); + float3 f = stack_load_float3(svm, from); float g = linear_rgb_to_gray(kg, f); - stack_store_float(stack, to, g); + stack_store_float(svm, to, g); break; } case NODE_CONVERT_CI: { - float3 f = stack_load_float3(stack, from); + float3 f = stack_load_float3(svm, from); int i = (int)linear_rgb_to_gray(kg, f); - stack_store_int(stack, to, i); + stack_store_int(svm, to, i); break; } case NODE_CONVERT_VF: { - float3 f = stack_load_float3(stack, from); + float3 f = stack_load_float3(svm, from); float g = average(f); - stack_store_float(stack, to, g); + stack_store_float(svm, to, g); break; } case NODE_CONVERT_VI: { - float3 f = stack_load_float3(stack, from); + float3 f = stack_load_float3(svm, from); int i = (int)average(f); - stack_store_int(stack, to, i); + stack_store_int(svm, to, i); break; } case NODE_CONVERT_IF: { - float f = (float)stack_load_int(stack, from); - stack_store_float(stack, to, f); + float f = (float)stack_load_int(svm, from); + stack_store_float(svm, to, f); break; } case NODE_CONVERT_IV: { - float f = (float)stack_load_int(stack, from); - stack_store_float3(stack, to, make_float3(f, f, f)); + float f = (float)stack_load_int(svm, from); + stack_store_float3(svm, to, make_float3(f, f, f)); break; } } diff --git a/intern/cycles/kernel/svm/displace.h b/intern/cycles/kernel/svm/displace.h index cca9dc7a238..79fac749b27 100644 --- a/intern/cycles/kernel/svm/displace.h +++ b/intern/cycles/kernel/svm/displace.h @@ -12,7 +12,7 @@ CCL_NAMESPACE_BEGIN template ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { #ifdef __RAY_DIFFERENTIALS__ @@ -22,8 +22,7 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, uint normal_offset, scale_offset, invert, use_object_space; svm_unpack_node_uchar4(node.y, &normal_offset, &scale_offset, &invert, &use_object_space); - float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : - sd->N; + float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(svm, normal_offset) : sd->N; differential3 dP = differential_from_compact(sd->Ng, sd->dP); @@ -41,9 +40,9 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, uint c_offset, x_offset, y_offset, strength_offset; svm_unpack_node_uchar4(node.z, &c_offset, &x_offset, &y_offset, &strength_offset); - float h_c = stack_load_float(stack, c_offset); - float h_x = stack_load_float(stack, x_offset); - float h_y = stack_load_float(stack, y_offset); + float h_c = stack_load_float(svm, c_offset); + float h_x = stack_load_float(svm, x_offset); + float h_y = stack_load_float(svm, y_offset); /* compute surface gradient and determinant */ float det = dot(dP.dx, Rx); @@ -51,8 +50,8 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, float absdet = fabsf(det); - float strength = stack_load_float(stack, strength_offset); - float scale = stack_load_float(stack, scale_offset); + float strength = stack_load_float(svm, strength_offset); + float scale = stack_load_float(svm, scale_offset); if (invert) scale *= -1.0f; @@ -72,10 +71,10 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, object_normal_transform(kg, sd, &normal_out); } - stack_store_float3(stack, node.w, normal_out); + stack_store_float3(svm, node.w, normal_out); } else { - stack_store_float3(stack, node.w, zero_float3()); + stack_store_float3(svm, node.w, zero_float3()); } #endif } @@ -85,12 +84,12 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, template ccl_device void svm_node_set_displacement(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint fac_offset) { IF_KERNEL_NODES_FEATURE(BUMP) { - float3 dP = stack_load_float3(stack, fac_offset); + float3 dP = stack_load_float3(svm, fac_offset); sd->P += dP; } } @@ -98,7 +97,7 @@ ccl_device void svm_node_set_displacement(KernelGlobals kg, template ccl_device_noinline void svm_node_displacement(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { IF_KERNEL_NODES_FEATURE(BUMP) @@ -107,10 +106,10 @@ ccl_device_noinline void svm_node_displacement(KernelGlobals kg, svm_unpack_node_uchar4( node.y, &height_offset, &midlevel_offset, &scale_offset, &normal_offset); - float height = stack_load_float(stack, height_offset); - float midlevel = stack_load_float(stack, midlevel_offset); - float scale = stack_load_float(stack, scale_offset); - float3 normal = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N; + float height = stack_load_float(svm, height_offset); + float midlevel = stack_load_float(svm, midlevel_offset); + float scale = stack_load_float(svm, scale_offset); + float3 normal = stack_valid(normal_offset) ? stack_load_float3(svm, normal_offset) : sd->N; uint space = node.w; float3 dP = normal; @@ -126,18 +125,20 @@ ccl_device_noinline void svm_node_displacement(KernelGlobals kg, dP *= (height - midlevel) * scale; } - stack_store_float3(stack, node.z, dP); + stack_store_float3(svm, node.z, dP); } else { - stack_store_float3(stack, node.z, zero_float3()); + stack_store_float3(svm, node.z, zero_float3()); } } template -ccl_device_noinline int svm_node_vector_displacement( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_vector_displacement(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { - uint4 data_node = read_node(kg, &offset); + uint4 data_node = read_node(kg, svm); uint vector_offset, midlevel_offset, scale_offset, displacement_offset; svm_unpack_node_uchar4( node.y, &vector_offset, &midlevel_offset, &scale_offset, &displacement_offset); @@ -146,9 +147,9 @@ ccl_device_noinline int svm_node_vector_displacement( { uint space = data_node.x; - float3 vector = stack_load_float3(stack, vector_offset); - float midlevel = stack_load_float(stack, midlevel_offset); - float scale = stack_load_float(stack, scale_offset); + float3 vector = stack_load_float3(svm, vector_offset); + float midlevel = stack_load_float(svm, midlevel_offset); + float scale = stack_load_float(svm, scale_offset); float3 dP = (vector - make_float3(midlevel, midlevel, midlevel)) * scale; if (space == NODE_NORMAL_MAP_TANGENT) { @@ -180,14 +181,12 @@ ccl_device_noinline int svm_node_vector_displacement( object_dir_transform(kg, sd, &dP); } - stack_store_float3(stack, displacement_offset, dP); + stack_store_float3(svm, displacement_offset, dP); } else { - stack_store_float3(stack, displacement_offset, zero_float3()); + stack_store_float3(svm, displacement_offset, zero_float3()); (void)data_node; } - - return offset; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/fresnel.h b/intern/cycles/kernel/svm/fresnel.h index b204502c167..7c0b9c73b07 100644 --- a/intern/cycles/kernel/svm/fresnel.h +++ b/intern/cycles/kernel/svm/fresnel.h @@ -9,29 +9,29 @@ CCL_NAMESPACE_BEGIN /* Fresnel Node */ ccl_device_noinline void svm_node_fresnel(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint ior_offset, uint ior_value, uint node) { uint normal_offset, out_offset; svm_unpack_node_uchar2(node, &normal_offset, &out_offset); - float eta = (stack_valid(ior_offset)) ? stack_load_float(stack, ior_offset) : + float eta = (stack_valid(ior_offset)) ? stack_load_float(svm, ior_offset) : __uint_as_float(ior_value); - float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N; + float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(svm, normal_offset) : sd->N; eta = fmaxf(eta, 1e-5f); eta = (sd->flag & SD_BACKFACING) ? 1.0f / eta : eta; float f = fresnel_dielectric_cos(dot(sd->wi, normal_in), eta); - stack_store_float(stack, out_offset, f); + stack_store_float(svm, out_offset, f); } /* Layer Weight Node */ ccl_device_noinline void svm_node_layer_weight(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint blend_offset = node.y; @@ -40,10 +40,9 @@ ccl_device_noinline void svm_node_layer_weight(ccl_private ShaderData *sd, uint type, normal_offset, out_offset; svm_unpack_node_uchar3(node.w, &type, &normal_offset, &out_offset); - float blend = (stack_valid(blend_offset)) ? stack_load_float(stack, blend_offset) : + float blend = (stack_valid(blend_offset)) ? stack_load_float(svm, blend_offset) : __uint_as_float(blend_value); - float3 normal_in = (stack_valid(normal_offset)) ? stack_load_float3(stack, normal_offset) : - sd->N; + float3 normal_in = (stack_valid(normal_offset)) ? stack_load_float3(svm, normal_offset) : sd->N; float f; @@ -66,7 +65,7 @@ ccl_device_noinline void svm_node_layer_weight(ccl_private ShaderData *sd, f = 1.0f - f; } - stack_store_float(stack, out_offset, f); + stack_store_float(svm, out_offset, f); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/gamma.h b/intern/cycles/kernel/svm/gamma.h index 99384aac43c..1b29d953104 100644 --- a/intern/cycles/kernel/svm/gamma.h +++ b/intern/cycles/kernel/svm/gamma.h @@ -7,18 +7,18 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_gamma(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint in_gamma, uint in_color, uint out_color) { - float3 color = stack_load_float3(stack, in_color); - float gamma = stack_load_float(stack, in_gamma); + float3 color = stack_load_float3(svm, in_color); + float gamma = stack_load_float(svm, in_gamma); color = svm_math_gamma_color(color, gamma); if (stack_valid(out_color)) - stack_store_float3(stack, out_color, color); + stack_store_float3(svm, out_color, color); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/geometry.h b/intern/cycles/kernel/svm/geometry.h index 66a2634612f..c7ef7b35fb0 100644 --- a/intern/cycles/kernel/svm/geometry.h +++ b/intern/cycles/kernel/svm/geometry.h @@ -10,7 +10,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_geometry(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { @@ -41,12 +41,12 @@ ccl_device_noinline void svm_node_geometry(KernelGlobals kg, data = make_float3(0.0f, 0.0f, 0.0f); } - stack_store_float3(stack, out_offset, data); + stack_store_float3(svm, out_offset, data); } ccl_device_noinline void svm_node_geometry_bump_dx(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { @@ -61,19 +61,19 @@ ccl_device_noinline void svm_node_geometry_bump_dx(KernelGlobals kg, data = make_float3(1.0f - sd->u - sd->du.dx - sd->v - sd->dv.dx, sd->u + sd->du.dx, 0.0f); break; default: - svm_node_geometry(kg, sd, stack, type, out_offset); + svm_node_geometry(kg, sd, svm, type, out_offset); return; } - stack_store_float3(stack, out_offset, data); + stack_store_float3(svm, out_offset, data); #else - svm_node_geometry(kg, sd, stack, type, out_offset); + svm_node_geometry(kg, sd, svm, type, out_offset); #endif } ccl_device_noinline void svm_node_geometry_bump_dy(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { @@ -88,13 +88,13 @@ ccl_device_noinline void svm_node_geometry_bump_dy(KernelGlobals kg, data = make_float3(1.0f - sd->u - sd->du.dy - sd->v - sd->dv.dy, sd->u + sd->du.dy, 0.0f); break; default: - svm_node_geometry(kg, sd, stack, type, out_offset); + svm_node_geometry(kg, sd, svm, type, out_offset); return; } - stack_store_float3(stack, out_offset, data); + stack_store_float3(svm, out_offset, data); #else - svm_node_geometry(kg, sd, stack, type, out_offset); + svm_node_geometry(kg, sd, svm, type, out_offset); #endif } @@ -102,7 +102,7 @@ ccl_device_noinline void svm_node_geometry_bump_dy(KernelGlobals kg, ccl_device_noinline void svm_node_object_info(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { @@ -110,11 +110,11 @@ ccl_device_noinline void svm_node_object_info(KernelGlobals kg, switch (type) { case NODE_INFO_OB_LOCATION: { - stack_store_float3(stack, out_offset, object_location(kg, sd)); + stack_store_float3(svm, out_offset, object_location(kg, sd)); return; } case NODE_INFO_OB_COLOR: { - stack_store_float3(stack, out_offset, object_color(kg, sd->object)); + stack_store_float3(svm, out_offset, object_color(kg, sd->object)); return; } case NODE_INFO_OB_ALPHA: @@ -140,64 +140,64 @@ ccl_device_noinline void svm_node_object_info(KernelGlobals kg, break; } - stack_store_float(stack, out_offset, data); + stack_store_float(svm, out_offset, data); } /* Particle Info */ ccl_device_noinline void svm_node_particle_info(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { switch (type) { case NODE_INFO_PAR_INDEX: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float(stack, out_offset, particle_index(kg, particle_id)); + stack_store_float(svm, out_offset, particle_index(kg, particle_id)); break; } case NODE_INFO_PAR_RANDOM: { int particle_id = object_particle_id(kg, sd->object); float random = hash_uint2_to_float(particle_index(kg, particle_id), 0); - stack_store_float(stack, out_offset, random); + stack_store_float(svm, out_offset, random); break; } case NODE_INFO_PAR_AGE: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float(stack, out_offset, particle_age(kg, particle_id)); + stack_store_float(svm, out_offset, particle_age(kg, particle_id)); break; } case NODE_INFO_PAR_LIFETIME: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float(stack, out_offset, particle_lifetime(kg, particle_id)); + stack_store_float(svm, out_offset, particle_lifetime(kg, particle_id)); break; } case NODE_INFO_PAR_LOCATION: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float3(stack, out_offset, particle_location(kg, particle_id)); + stack_store_float3(svm, out_offset, particle_location(kg, particle_id)); break; } #if 0 /* XXX float4 currently not supported in SVM stack */ case NODE_INFO_PAR_ROTATION: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float4(stack, out_offset, particle_rotation(kg, particle_id)); + stack_store_float4(svm, out_offset, particle_rotation(kg, particle_id)); break; } #endif case NODE_INFO_PAR_SIZE: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float(stack, out_offset, particle_size(kg, particle_id)); + stack_store_float(svm, out_offset, particle_size(kg, particle_id)); break; } case NODE_INFO_PAR_VELOCITY: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float3(stack, out_offset, particle_velocity(kg, particle_id)); + stack_store_float3(svm, out_offset, particle_velocity(kg, particle_id)); break; } case NODE_INFO_PAR_ANGULAR_VELOCITY: { int particle_id = object_particle_id(kg, sd->object); - stack_store_float3(stack, out_offset, particle_angular_velocity(kg, particle_id)); + stack_store_float3(svm, out_offset, particle_angular_velocity(kg, particle_id)); break; } } @@ -209,7 +209,7 @@ ccl_device_noinline void svm_node_particle_info(KernelGlobals kg, ccl_device_noinline void svm_node_hair_info(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { @@ -219,7 +219,7 @@ ccl_device_noinline void svm_node_hair_info(KernelGlobals kg, switch (type) { case NODE_INFO_CURVE_IS_STRAND: { data = (sd->type & PRIMITIVE_CURVE) != 0; - stack_store_float(stack, out_offset, data); + stack_store_float(svm, out_offset, data); break; } case NODE_INFO_CURVE_INTERCEPT: @@ -230,12 +230,12 @@ ccl_device_noinline void svm_node_hair_info(KernelGlobals kg, break; /* handled as attribute */ case NODE_INFO_CURVE_THICKNESS: { data = curve_thickness(kg, sd); - stack_store_float(stack, out_offset, data); + stack_store_float(svm, out_offset, data); break; } case NODE_INFO_CURVE_TANGENT_NORMAL: { data3 = curve_tangent_normal(kg, sd); - stack_store_float3(stack, out_offset, data3); + stack_store_float3(svm, out_offset, data3); break; } } @@ -248,16 +248,16 @@ ccl_device_noinline void svm_node_hair_info(KernelGlobals kg, ccl_device_noinline void svm_node_point_info(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset) { switch (type) { case NODE_INFO_POINT_POSITION: - stack_store_float3(stack, out_offset, point_position(kg, sd)); + stack_store_float3(svm, out_offset, point_position(kg, sd)); break; case NODE_INFO_POINT_RADIUS: - stack_store_float(stack, out_offset, point_radius(kg, sd)); + stack_store_float(svm, out_offset, point_radius(kg, sd)); break; case NODE_INFO_POINT_RANDOM: break; /* handled as attribute */ diff --git a/intern/cycles/kernel/svm/gradient.h b/intern/cycles/kernel/svm/gradient.h index 39de2a761b7..9d16a82c73d 100644 --- a/intern/cycles/kernel/svm/gradient.h +++ b/intern/cycles/kernel/svm/gradient.h @@ -51,22 +51,22 @@ ccl_device float svm_gradient(float3 p, NodeGradientType type) } ccl_device_noinline void svm_node_tex_gradient(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint type, co_offset, color_offset, fac_offset; svm_unpack_node_uchar4(node.y, &type, &co_offset, &fac_offset, &color_offset); - float3 co = stack_load_float3(stack, co_offset); + float3 co = stack_load_float3(svm, co_offset); float f = svm_gradient(co, (NodeGradientType)type); f = saturatef(f); if (stack_valid(fac_offset)) - stack_store_float(stack, fac_offset, f); + stack_store_float(svm, fac_offset, f); if (stack_valid(color_offset)) - stack_store_float3(stack, color_offset, make_float3(f, f, f)); + stack_store_float3(svm, color_offset, make_float3(f, f, f)); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/hsv.h b/intern/cycles/kernel/svm/hsv.h index 4478236966b..84431de151d 100644 --- a/intern/cycles/kernel/svm/hsv.h +++ b/intern/cycles/kernel/svm/hsv.h @@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_hsv(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint in_color_offset, fac_offset, out_color_offset; @@ -16,13 +16,13 @@ ccl_device_noinline void svm_node_hsv(KernelGlobals kg, svm_unpack_node_uchar3(node.y, &in_color_offset, &fac_offset, &out_color_offset); svm_unpack_node_uchar3(node.z, &hue_offset, &sat_offset, &val_offset); - float fac = stack_load_float(stack, fac_offset); - float3 in_color = stack_load_float3(stack, in_color_offset); + float fac = stack_load_float(svm, fac_offset); + float3 in_color = stack_load_float3(svm, in_color_offset); float3 color = in_color; - float hue = stack_load_float(stack, hue_offset); - float sat = stack_load_float(stack, sat_offset); - float val = stack_load_float(stack, val_offset); + float hue = stack_load_float(svm, hue_offset); + float sat = stack_load_float(svm, sat_offset); + float val = stack_load_float(svm, val_offset); color = rgb_to_hsv(color); @@ -43,7 +43,7 @@ ccl_device_noinline void svm_node_hsv(KernelGlobals kg, color.z = max(color.z, 0.0f); if (stack_valid(out_color_offset)) - stack_store_float3(stack, out_color_offset, color); + stack_store_float3(svm, out_color_offset, color); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/ies.h b/intern/cycles/kernel/svm/ies.h index 8afd289215c..b289925cbf8 100644 --- a/intern/cycles/kernel/svm/ies.h +++ b/intern/cycles/kernel/svm/ies.h @@ -88,14 +88,14 @@ ccl_device_inline float kernel_ies_interp(KernelGlobals kg, int slot, float h_an #ifdef __SVM__ ccl_device_noinline void svm_node_ies(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint vector_offset, strength_offset, fac_offset, slot = node.z; svm_unpack_node_uchar3(node.y, &strength_offset, &vector_offset, &fac_offset); - float3 vector = stack_load_float3(stack, vector_offset); - float strength = stack_load_float_default(stack, strength_offset, node.w); + float3 vector = stack_load_float3(svm, vector_offset); + float strength = stack_load_float_default(svm, strength_offset, node.w); vector = normalize(vector); float v_angle = safe_acosf(-vector.z); @@ -104,7 +104,7 @@ ccl_device_noinline void svm_node_ies(KernelGlobals kg, float fac = strength * kernel_ies_interp(kg, slot, h_angle, v_angle); if (stack_valid(fac_offset)) { - stack_store_float(stack, fac_offset, fac); + stack_store_float(svm, fac_offset, fac); } } #endif diff --git a/intern/cycles/kernel/svm/image.h b/intern/cycles/kernel/svm/image.h index b8820de830f..473b682cbea 100644 --- a/intern/cycles/kernel/svm/image.h +++ b/intern/cycles/kernel/svm/image.h @@ -34,14 +34,16 @@ ccl_device_inline float3 texco_remap_square(float3 co) return (co - make_float3(0.5f, 0.5f, 0.5f)) * 2.0f; } -ccl_device_noinline int svm_node_tex_image( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_tex_image(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { uint co_offset, out_offset, alpha_offset, flags; svm_unpack_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &flags); - float3 co = stack_load_float3(stack, co_offset); + float3 co = stack_load_float3(svm, co_offset); float2 tex_co; if (node.w == NODE_IMAGE_PROJ_SPHERE) { co = texco_remap_square(co); @@ -61,7 +63,7 @@ ccl_device_noinline int svm_node_tex_image( int num_nodes = (int)node.y; if (num_nodes > 0) { /* Remember the offset of the node following the tile nodes. */ - int next_offset = offset + num_nodes; + int next_offset = svm->offset + num_nodes; /* Find the tile that the UV lies in. */ int tx = (int)tex_co.x; @@ -73,7 +75,7 @@ ccl_device_noinline int svm_node_tex_image( /* Find the index of the tile. */ for (int i = 0; i < num_nodes; i++) { - uint4 tile_node = read_node(kg, &offset); + uint4 tile_node = read_node(kg, svm); if (tile_node.x == tile) { id = tile_node.y; break; @@ -92,7 +94,7 @@ ccl_device_noinline int svm_node_tex_image( } /* Skip over the remaining nodes. */ - offset = next_offset; + svm->offset = next_offset; } else { id = -num_nodes; @@ -101,15 +103,14 @@ ccl_device_noinline int svm_node_tex_image( float4 f = svm_image_texture(kg, id, tex_co.x, tex_co.y, flags); if (stack_valid(out_offset)) - stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z)); + stack_store_float3(svm, out_offset, make_float3(f.x, f.y, f.z)); if (stack_valid(alpha_offset)) - stack_store_float(stack, alpha_offset, f.w); - return offset; + stack_store_float(svm, alpha_offset, f.w); } ccl_device_noinline void svm_node_tex_image_box(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { /* get object space normal */ @@ -184,7 +185,7 @@ ccl_device_noinline void svm_node_tex_image_box(KernelGlobals kg, uint co_offset, out_offset, alpha_offset, flags; svm_unpack_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &flags); - float3 co = stack_load_float3(stack, co_offset); + float3 co = stack_load_float3(svm, co_offset); uint id = node.y; float4 f = zero_float4(); @@ -204,14 +205,14 @@ ccl_device_noinline void svm_node_tex_image_box(KernelGlobals kg, } if (stack_valid(out_offset)) - stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z)); + stack_store_float3(svm, out_offset, make_float3(f.x, f.y, f.z)); if (stack_valid(alpha_offset)) - stack_store_float(stack, alpha_offset, f.w); + stack_store_float(svm, alpha_offset, f.w); } ccl_device_noinline void svm_node_tex_environment(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint id = node.y; @@ -220,7 +221,7 @@ ccl_device_noinline void svm_node_tex_environment(KernelGlobals kg, svm_unpack_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &flags); - float3 co = stack_load_float3(stack, co_offset); + float3 co = stack_load_float3(svm, co_offset); float2 uv; co = safe_normalize(co); @@ -233,9 +234,9 @@ ccl_device_noinline void svm_node_tex_environment(KernelGlobals kg, float4 f = svm_image_texture(kg, id, uv.x, uv.y, flags); if (stack_valid(out_offset)) - stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z)); + stack_store_float3(svm, out_offset, make_float3(f.x, f.y, f.z)); if (stack_valid(alpha_offset)) - stack_store_float(stack, alpha_offset, f.w); + stack_store_float(svm, alpha_offset, f.w); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/invert.h b/intern/cycles/kernel/svm/invert.h index 61e843492ea..b541660b5b5 100644 --- a/intern/cycles/kernel/svm/invert.h +++ b/intern/cycles/kernel/svm/invert.h @@ -12,20 +12,20 @@ ccl_device float invert(float color, float factor) } ccl_device_noinline void svm_node_invert(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint in_fac, uint in_color, uint out_color) { - float factor = stack_load_float(stack, in_fac); - float3 color = stack_load_float3(stack, in_color); + float factor = stack_load_float(svm, in_fac); + float3 color = stack_load_float3(svm, in_color); color.x = invert(color.x, factor); color.y = invert(color.y, factor); color.z = invert(color.z, factor); if (stack_valid(out_color)) - stack_store_float3(stack, out_color, color); + stack_store_float3(svm, out_color, color); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/light_path.h b/intern/cycles/kernel/svm/light_path.h index 77e4108829b..c7acebd9ad3 100644 --- a/intern/cycles/kernel/svm/light_path.h +++ b/intern/cycles/kernel/svm/light_path.h @@ -12,7 +12,7 @@ template ccl_device_noinline void svm_node_light_path(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private const ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint out_offset, uint32_t path_flag) @@ -93,20 +93,20 @@ ccl_device_noinline void svm_node_light_path(KernelGlobals kg, break; } - stack_store_float(stack, out_offset, info); + stack_store_float(svm, out_offset, info); } /* Light Falloff Node */ ccl_device_noinline void svm_node_light_falloff(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint strength_offset, out_offset, smooth_offset; svm_unpack_node_uchar3(node.z, &strength_offset, &smooth_offset, &out_offset); - float strength = stack_load_float(stack, strength_offset); + float strength = stack_load_float(svm, strength_offset); uint type = node.y; switch (type) { @@ -120,7 +120,7 @@ ccl_device_noinline void svm_node_light_falloff(ccl_private ShaderData *sd, break; } - float smooth = stack_load_float(stack, smooth_offset); + float smooth = stack_load_float(svm, smooth_offset); if (smooth > 0.0f) { float squared = sd->ray_length * sd->ray_length; @@ -130,7 +130,7 @@ ccl_device_noinline void svm_node_light_falloff(ccl_private ShaderData *sd, } } - stack_store_float(stack, out_offset, strength); + stack_store_float(svm, out_offset, strength); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/magic.h b/intern/cycles/kernel/svm/magic.h index c283bd91818..0dbc7293546 100644 --- a/intern/cycles/kernel/svm/magic.h +++ b/intern/cycles/kernel/svm/magic.h @@ -93,8 +93,10 @@ ccl_device_noinline_cpu float3 svm_magic(float3 p, float scale, int n, float dis return make_float3(0.5f - x, 0.5f - y, 0.5f - z); } -ccl_device_noinline int svm_node_tex_magic( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_tex_magic(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { uint depth; uint scale_offset, distortion_offset, co_offset, fac_offset, color_offset; @@ -102,18 +104,17 @@ ccl_device_noinline int svm_node_tex_magic( svm_unpack_node_uchar3(node.y, &depth, &color_offset, &fac_offset); svm_unpack_node_uchar3(node.z, &co_offset, &scale_offset, &distortion_offset); - uint4 node2 = read_node(kg, &offset); - float3 co = stack_load_float3(stack, co_offset); - float scale = stack_load_float_default(stack, scale_offset, node2.x); - float distortion = stack_load_float_default(stack, distortion_offset, node2.y); + uint4 node2 = read_node(kg, svm); + float3 co = stack_load_float3(svm, co_offset); + float scale = stack_load_float_default(svm, scale_offset, node2.x); + float distortion = stack_load_float_default(svm, distortion_offset, node2.y); float3 color = svm_magic(co, scale, depth, distortion); if (stack_valid(fac_offset)) - stack_store_float(stack, fac_offset, average(color)); + stack_store_float(svm, fac_offset, average(color)); if (stack_valid(color_offset)) - stack_store_float3(stack, color_offset, color); - return offset; + stack_store_float3(svm, color_offset, color); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/map_range.h b/intern/cycles/kernel/svm/map_range.h index df9bf6fca46..ae88f70ce1c 100644 --- a/intern/cycles/kernel/svm/map_range.h +++ b/intern/cycles/kernel/svm/map_range.h @@ -14,13 +14,12 @@ ccl_device_inline float smootherstep(float edge0, float edge1, float x) return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f); } -ccl_device_noinline int svm_node_map_range(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint value_stack_offset, - uint parameters_stack_offsets, - uint results_stack_offsets, - int offset) +ccl_device_noinline void svm_node_map_range(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint value_stack_offset, + uint parameters_stack_offsets, + uint results_stack_offsets) { uint from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset; uint type_stack_offset, steps_stack_offset, result_stack_offset; @@ -32,15 +31,15 @@ ccl_device_noinline int svm_node_map_range(KernelGlobals kg, svm_unpack_node_uchar3( results_stack_offsets, &type_stack_offset, &steps_stack_offset, &result_stack_offset); - uint4 defaults = read_node(kg, &offset); - uint4 defaults2 = read_node(kg, &offset); + uint4 defaults = read_node(kg, svm); + uint4 defaults2 = read_node(kg, svm); - float value = stack_load_float(stack, value_stack_offset); - float from_min = stack_load_float_default(stack, from_min_stack_offset, defaults.x); - float from_max = stack_load_float_default(stack, from_max_stack_offset, defaults.y); - float to_min = stack_load_float_default(stack, to_min_stack_offset, defaults.z); - float to_max = stack_load_float_default(stack, to_max_stack_offset, defaults.w); - float steps = stack_load_float_default(stack, steps_stack_offset, defaults2.x); + float value = stack_load_float(svm, value_stack_offset); + float from_min = stack_load_float_default(svm, from_min_stack_offset, defaults.x); + float from_max = stack_load_float_default(svm, from_max_stack_offset, defaults.y); + float to_min = stack_load_float_default(svm, to_min_stack_offset, defaults.z); + float to_max = stack_load_float_default(svm, to_max_stack_offset, defaults.w); + float steps = stack_load_float_default(svm, steps_stack_offset, defaults2.x); float result; @@ -72,17 +71,15 @@ ccl_device_noinline int svm_node_map_range(KernelGlobals kg, else { result = 0.0f; } - stack_store_float(stack, result_stack_offset, result); - return offset; + stack_store_float(svm, result_stack_offset, result); } -ccl_device_noinline int svm_node_vector_map_range(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint value_stack_offset, - uint parameters_stack_offsets, - uint results_stack_offsets, - int offset) +ccl_device_noinline void svm_node_vector_map_range(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint value_stack_offset, + uint parameters_stack_offsets, + uint results_stack_offsets) { uint from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset; uint steps_stack_offset, clamp_stack_offset, range_type_stack_offset, result_stack_offset; @@ -97,12 +94,12 @@ ccl_device_noinline int svm_node_vector_map_range(KernelGlobals kg, &range_type_stack_offset, &result_stack_offset); - float3 value = stack_load_float3(stack, value_stack_offset); - float3 from_min = stack_load_float3(stack, from_min_stack_offset); - float3 from_max = stack_load_float3(stack, from_max_stack_offset); - float3 to_min = stack_load_float3(stack, to_min_stack_offset); - float3 to_max = stack_load_float3(stack, to_max_stack_offset); - float3 steps = stack_load_float3(stack, steps_stack_offset); + float3 value = stack_load_float3(svm, value_stack_offset); + float3 from_min = stack_load_float3(svm, from_min_stack_offset); + float3 from_max = stack_load_float3(svm, from_max_stack_offset); + float3 to_min = stack_load_float3(svm, to_min_stack_offset); + float3 to_max = stack_load_float3(svm, to_max_stack_offset); + float3 steps = stack_load_float3(svm, steps_stack_offset); int type = range_type_stack_offset; int use_clamp = (type == NODE_MAP_RANGE_SMOOTHSTEP || type == NODE_MAP_RANGE_SMOOTHERSTEP) ? @@ -146,8 +143,7 @@ ccl_device_noinline int svm_node_vector_map_range(KernelGlobals kg, clamp(result.z, to_min.z, to_max.z); } - stack_store_float3(stack, result_stack_offset, result); - return offset; + stack_store_float3(svm, result_stack_offset, result); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/mapping.h b/intern/cycles/kernel/svm/mapping.h index 164a97c214c..599feae436e 100644 --- a/intern/cycles/kernel/svm/mapping.h +++ b/intern/cycles/kernel/svm/mapping.h @@ -12,7 +12,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_mapping(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint inputs_stack_offsets, uint result_stack_offset) @@ -24,51 +24,47 @@ ccl_device_noinline void svm_node_mapping(KernelGlobals kg, &rotation_stack_offset, &scale_stack_offset); - float3 vector = stack_load_float3(stack, vector_stack_offset); - float3 location = stack_load_float3(stack, location_stack_offset); - float3 rotation = stack_load_float3(stack, rotation_stack_offset); - float3 scale = stack_load_float3(stack, scale_stack_offset); + float3 vector = stack_load_float3(svm, vector_stack_offset); + float3 location = stack_load_float3(svm, location_stack_offset); + float3 rotation = stack_load_float3(svm, rotation_stack_offset); + float3 scale = stack_load_float3(svm, scale_stack_offset); float3 result = svm_mapping((NodeMappingType)type, vector, location, rotation, scale); - stack_store_float3(stack, result_stack_offset, result); + stack_store_float3(svm, result_stack_offset, result); } /* Texture Mapping */ -ccl_device_noinline int svm_node_texture_mapping(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint vec_offset, - uint out_offset, - int offset) +ccl_device_noinline void svm_node_texture_mapping(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint vec_offset, + uint out_offset) { - float3 v = stack_load_float3(stack, vec_offset); + float3 v = stack_load_float3(svm, vec_offset); Transform tfm; - tfm.x = read_node_float(kg, &offset); - tfm.y = read_node_float(kg, &offset); - tfm.z = read_node_float(kg, &offset); + tfm.x = read_node_float(kg, svm); + tfm.y = read_node_float(kg, svm); + tfm.z = read_node_float(kg, svm); float3 r = transform_point(&tfm, v); - stack_store_float3(stack, out_offset, r); - return offset; + stack_store_float3(svm, out_offset, r); } -ccl_device_noinline int svm_node_min_max(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint vec_offset, - uint out_offset, - int offset) +ccl_device_noinline void svm_node_min_max(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint vec_offset, + uint out_offset) { - float3 v = stack_load_float3(stack, vec_offset); + float3 v = stack_load_float3(svm, vec_offset); - float3 mn = float4_to_float3(read_node_float(kg, &offset)); - float3 mx = float4_to_float3(read_node_float(kg, &offset)); + float3 mn = float4_to_float3(read_node_float(kg, svm)); + float3 mx = float4_to_float3(read_node_float(kg, svm)); float3 r = min(max(mn, v), mx); - stack_store_float3(stack, out_offset, r); - return offset; + stack_store_float3(svm, out_offset, r); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/math.h b/intern/cycles/kernel/svm/math.h index 3fa85e720e1..75adda623fa 100644 --- a/intern/cycles/kernel/svm/math.h +++ b/intern/cycles/kernel/svm/math.h @@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_math(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint type, uint inputs_stack_offsets, uint result_stack_offset) @@ -16,21 +16,20 @@ ccl_device_noinline void svm_node_math(KernelGlobals kg, uint a_stack_offset, b_stack_offset, c_stack_offset; svm_unpack_node_uchar3(inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &c_stack_offset); - float a = stack_load_float(stack, a_stack_offset); - float b = stack_load_float(stack, b_stack_offset); - float c = stack_load_float(stack, c_stack_offset); + float a = stack_load_float(svm, a_stack_offset); + float b = stack_load_float(svm, b_stack_offset); + float c = stack_load_float(svm, c_stack_offset); float result = svm_math((NodeMathType)type, a, b, c); - stack_store_float(stack, result_stack_offset, result); + stack_store_float(svm, result_stack_offset, result); } -ccl_device_noinline int svm_node_vector_math(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint type, - uint inputs_stack_offsets, - uint outputs_stack_offsets, - int offset) +ccl_device_noinline void svm_node_vector_math(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint type, + uint inputs_stack_offsets, + uint outputs_stack_offsets) { uint value_stack_offset, vector_stack_offset; uint a_stack_offset, b_stack_offset, param1_stack_offset; @@ -38,10 +37,10 @@ ccl_device_noinline int svm_node_vector_math(KernelGlobals kg, inputs_stack_offsets, &a_stack_offset, &b_stack_offset, ¶m1_stack_offset); svm_unpack_node_uchar2(outputs_stack_offsets, &value_stack_offset, &vector_stack_offset); - float3 a = stack_load_float3(stack, a_stack_offset); - float3 b = stack_load_float3(stack, b_stack_offset); + float3 a = stack_load_float3(svm, a_stack_offset); + float3 b = stack_load_float3(svm, b_stack_offset); float3 c = make_float3(0.0f, 0.0f, 0.0f); - float param1 = stack_load_float(stack, param1_stack_offset); + float param1 = stack_load_float(svm, param1_stack_offset); float value; float3 vector; @@ -50,17 +49,16 @@ ccl_device_noinline int svm_node_vector_math(KernelGlobals kg, if (type == NODE_VECTOR_MATH_WRAP || type == NODE_VECTOR_MATH_FACEFORWARD || type == NODE_VECTOR_MATH_MULTIPLY_ADD) { - uint4 extra_node = read_node(kg, &offset); - c = stack_load_float3(stack, extra_node.x); + uint4 extra_node = read_node(kg, svm); + c = stack_load_float3(svm, extra_node.x); } svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, c, param1); if (stack_valid(value_stack_offset)) - stack_store_float(stack, value_stack_offset, value); + stack_store_float(svm, value_stack_offset, value); if (stack_valid(vector_stack_offset)) - stack_store_float3(stack, vector_stack_offset, vector); - return offset; + stack_store_float3(svm, vector_stack_offset, vector); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/mix.h b/intern/cycles/kernel/svm/mix.h index a4eea706cf0..e8d89116b63 100644 --- a/intern/cycles/kernel/svm/mix.h +++ b/intern/cycles/kernel/svm/mix.h @@ -8,28 +8,26 @@ CCL_NAMESPACE_BEGIN /* Node */ -ccl_device_noinline int svm_node_mix(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint fac_offset, - uint c1_offset, - uint c2_offset, - int offset) +ccl_device_noinline void svm_node_mix(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint fac_offset, + uint c1_offset, + uint c2_offset) { /* read extra data */ - uint4 node1 = read_node(kg, &offset); + uint4 node1 = read_node(kg, svm); - float fac = stack_load_float(stack, fac_offset); - float3 c1 = stack_load_float3(stack, c1_offset); - float3 c2 = stack_load_float3(stack, c2_offset); + float fac = stack_load_float(svm, fac_offset); + float3 c1 = stack_load_float3(svm, c1_offset); + float3 c2 = stack_load_float3(svm, c2_offset); float3 result = svm_mix_clamped_factor((NodeMix)node1.y, fac, c1, c2); - stack_store_float3(stack, node1.z, result); - return offset; + stack_store_float3(svm, node1.z, result); } ccl_device_noinline void svm_node_mix_color(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint options, uint input_offset, uint result_offset) @@ -40,21 +38,21 @@ ccl_device_noinline void svm_node_mix_color(ccl_private ShaderData *sd, svm_unpack_node_uchar3( input_offset, &fac_in_stack_offset, &a_in_stack_offset, &b_in_stack_offset); - float t = stack_load_float(stack, fac_in_stack_offset); + float t = stack_load_float(svm, fac_in_stack_offset); if (use_clamp > 0) { t = saturatef(t); } - float3 a = stack_load_float3(stack, a_in_stack_offset); - float3 b = stack_load_float3(stack, b_in_stack_offset); + float3 a = stack_load_float3(svm, a_in_stack_offset); + float3 b = stack_load_float3(svm, b_in_stack_offset); float3 result = svm_mix((NodeMix)blend_type, t, a, b); if (use_clamp_result) { result = saturate(result); } - stack_store_float3(stack, result_offset, result); + stack_store_float3(svm, result_offset, result); } ccl_device_noinline void svm_node_mix_float(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint use_clamp, uint input_offset, uint result_offset) @@ -63,19 +61,19 @@ ccl_device_noinline void svm_node_mix_float(ccl_private ShaderData *sd, svm_unpack_node_uchar3( input_offset, &fac_in_stack_offset, &a_in_stack_offset, &b_in_stack_offset); - float t = stack_load_float(stack, fac_in_stack_offset); + float t = stack_load_float(svm, fac_in_stack_offset); if (use_clamp > 0) { t = saturatef(t); } - float a = stack_load_float(stack, a_in_stack_offset); - float b = stack_load_float(stack, b_in_stack_offset); + float a = stack_load_float(svm, a_in_stack_offset); + float b = stack_load_float(svm, b_in_stack_offset); float result = a * (1 - t) + b * t; - stack_store_float(stack, result_offset, result); + stack_store_float(svm, result_offset, result); } ccl_device_noinline void svm_node_mix_vector(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint input_offset, uint result_offset) { @@ -83,18 +81,18 @@ ccl_device_noinline void svm_node_mix_vector(ccl_private ShaderData *sd, svm_unpack_node_uchar4( input_offset, &use_clamp, &fac_in_stack_offset, &a_in_stack_offset, &b_in_stack_offset); - float t = stack_load_float(stack, fac_in_stack_offset); + float t = stack_load_float(svm, fac_in_stack_offset); if (use_clamp > 0) { t = saturatef(t); } - float3 a = stack_load_float3(stack, a_in_stack_offset); - float3 b = stack_load_float3(stack, b_in_stack_offset); + float3 a = stack_load_float3(svm, a_in_stack_offset); + float3 b = stack_load_float3(svm, b_in_stack_offset); float3 result = a * (one_float3() - t) + b * t; - stack_store_float3(stack, result_offset, result); + stack_store_float3(svm, result_offset, result); } ccl_device_noinline void svm_node_mix_vector_non_uniform(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint input_offset, uint result_offset) { @@ -102,14 +100,14 @@ ccl_device_noinline void svm_node_mix_vector_non_uniform(ccl_private ShaderData svm_unpack_node_uchar4( input_offset, &use_clamp, &fac_in_stack_offset, &a_in_stack_offset, &b_in_stack_offset); - float3 t = stack_load_float3(stack, fac_in_stack_offset); + float3 t = stack_load_float3(svm, fac_in_stack_offset); if (use_clamp > 0) { t = saturate(t); } - float3 a = stack_load_float3(stack, a_in_stack_offset); - float3 b = stack_load_float3(stack, b_in_stack_offset); + float3 a = stack_load_float3(svm, a_in_stack_offset); + float3 b = stack_load_float3(svm, b_in_stack_offset); float3 result = a * (one_float3() - t) + b * t; - stack_store_float3(stack, result_offset, result); + stack_store_float3(svm, result_offset, result); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/musgrave.h b/intern/cycles/kernel/svm/musgrave.h index 6ea48fa8390..966566e31f8 100644 --- a/intern/cycles/kernel/svm/musgrave.h +++ b/intern/cycles/kernel/svm/musgrave.h @@ -704,13 +704,12 @@ ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_4d( return value; } -ccl_device_noinline int svm_node_tex_musgrave(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint offsets1, - uint offsets2, - uint offsets3, - int offset) +ccl_device_noinline void svm_node_tex_musgrave(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint offsets1, + uint offsets2, + uint offsets3) { uint type, dimensions, co_stack_offset, w_stack_offset; uint scale_stack_offset, detail_stack_offset, dimension_stack_offset, lacunarity_stack_offset; @@ -724,17 +723,17 @@ ccl_device_noinline int svm_node_tex_musgrave(KernelGlobals kg, &lacunarity_stack_offset); svm_unpack_node_uchar3(offsets3, &offset_stack_offset, &gain_stack_offset, &fac_stack_offset); - uint4 defaults1 = read_node(kg, &offset); - uint4 defaults2 = read_node(kg, &offset); + uint4 defaults1 = read_node(kg, svm); + uint4 defaults2 = read_node(kg, svm); - float3 co = stack_load_float3(stack, co_stack_offset); - float w = stack_load_float_default(stack, w_stack_offset, defaults1.x); - float scale = stack_load_float_default(stack, scale_stack_offset, defaults1.y); - float detail = stack_load_float_default(stack, detail_stack_offset, defaults1.z); - float dimension = stack_load_float_default(stack, dimension_stack_offset, defaults1.w); - float lacunarity = stack_load_float_default(stack, lacunarity_stack_offset, defaults2.x); - float foffset = stack_load_float_default(stack, offset_stack_offset, defaults2.y); - float gain = stack_load_float_default(stack, gain_stack_offset, defaults2.z); + float3 co = stack_load_float3(svm, co_stack_offset); + float w = stack_load_float_default(svm, w_stack_offset, defaults1.x); + float scale = stack_load_float_default(svm, scale_stack_offset, defaults1.y); + float detail = stack_load_float_default(svm, detail_stack_offset, defaults1.z); + float dimension = stack_load_float_default(svm, dimension_stack_offset, defaults1.w); + float lacunarity = stack_load_float_default(svm, lacunarity_stack_offset, defaults2.x); + float foffset = stack_load_float_default(svm, offset_stack_offset, defaults2.y); + float gain = stack_load_float_default(svm, gain_stack_offset, defaults2.z); dimension = fmaxf(dimension, 1e-5f); detail = clamp(detail, 0.0f, 15.0f); @@ -847,8 +846,7 @@ ccl_device_noinline int svm_node_tex_musgrave(KernelGlobals kg, fac = 0.0f; } - stack_store_float(stack, fac_stack_offset, fac); - return offset; + stack_store_float(svm, fac_stack_offset, fac); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/noisetex.h b/intern/cycles/kernel/svm/noisetex.h index bb4701d70d7..4dec027bf85 100644 --- a/intern/cycles/kernel/svm/noisetex.h +++ b/intern/cycles/kernel/svm/noisetex.h @@ -132,13 +132,12 @@ ccl_device void noise_texture_4d(float4 co, } } -ccl_device_noinline int svm_node_tex_noise(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint dimensions, - uint offsets1, - uint offsets2, - int offset) +ccl_device_noinline void svm_node_tex_noise(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint dimensions, + uint offsets1, + uint offsets2) { uint vector_stack_offset, w_stack_offset, scale_stack_offset; uint detail_stack_offset, roughness_stack_offset, distortion_stack_offset; @@ -152,15 +151,15 @@ ccl_device_noinline int svm_node_tex_noise(KernelGlobals kg, &value_stack_offset, &color_stack_offset); - uint4 defaults1 = read_node(kg, &offset); - uint4 defaults2 = read_node(kg, &offset); + uint4 defaults1 = read_node(kg, svm); + uint4 defaults2 = read_node(kg, svm); - float3 vector = stack_load_float3(stack, vector_stack_offset); - float w = stack_load_float_default(stack, w_stack_offset, defaults1.x); - float scale = stack_load_float_default(stack, scale_stack_offset, defaults1.y); - float detail = stack_load_float_default(stack, detail_stack_offset, defaults1.z); - float roughness = stack_load_float_default(stack, roughness_stack_offset, defaults1.w); - float distortion = stack_load_float_default(stack, distortion_stack_offset, defaults2.x); + float3 vector = stack_load_float3(svm, vector_stack_offset); + float w = stack_load_float_default(svm, w_stack_offset, defaults1.x); + float scale = stack_load_float_default(svm, scale_stack_offset, defaults1.y); + float detail = stack_load_float_default(svm, detail_stack_offset, defaults1.z); + float roughness = stack_load_float_default(svm, roughness_stack_offset, defaults1.w); + float distortion = stack_load_float_default(svm, distortion_stack_offset, defaults2.x); vector *= scale; w *= scale; @@ -199,12 +198,11 @@ ccl_device_noinline int svm_node_tex_noise(KernelGlobals kg, } if (stack_valid(value_stack_offset)) { - stack_store_float(stack, value_stack_offset, value); + stack_store_float(svm, value_stack_offset, value); } if (stack_valid(color_stack_offset)) { - stack_store_float3(stack, color_stack_offset, color); + stack_store_float3(svm, color_stack_offset, color); } - return offset; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/normal.h b/intern/cycles/kernel/svm/normal.h index c9cfcea311e..acd59bed3cf 100644 --- a/intern/cycles/kernel/svm/normal.h +++ b/intern/cycles/kernel/svm/normal.h @@ -6,17 +6,16 @@ CCL_NAMESPACE_BEGIN -ccl_device_noinline int svm_node_normal(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint in_normal_offset, - uint out_normal_offset, - uint out_dot_offset, - int offset) +ccl_device_noinline void svm_node_normal(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint in_normal_offset, + uint out_normal_offset, + uint out_dot_offset) { /* read extra data */ - uint4 node1 = read_node(kg, &offset); - float3 normal = stack_load_float3(stack, in_normal_offset); + uint4 node1 = read_node(kg, svm); + float3 normal = stack_load_float3(svm, in_normal_offset); float3 direction; direction.x = __int_as_float(node1.x); @@ -25,11 +24,10 @@ ccl_device_noinline int svm_node_normal(KernelGlobals kg, direction = normalize(direction); if (stack_valid(out_normal_offset)) - stack_store_float3(stack, out_normal_offset, direction); + stack_store_float3(svm, out_normal_offset, direction); if (stack_valid(out_dot_offset)) - stack_store_float(stack, out_dot_offset, dot(direction, normalize(normal))); - return offset; + stack_store_float(svm, out_dot_offset, dot(direction, normalize(normal))); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/ramp.h b/intern/cycles/kernel/svm/ramp.h index bb84dabc68a..cfbd609e2c4 100644 --- a/intern/cycles/kernel/svm/ramp.h +++ b/intern/cycles/kernel/svm/ramp.h @@ -78,76 +78,79 @@ ccl_device_inline float4 rgb_ramp_lookup( return a; } -ccl_device_noinline int svm_node_rgb_ramp( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_rgb_ramp(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { uint fac_offset, color_offset, alpha_offset; uint interpolate = node.z; svm_unpack_node_uchar3(node.y, &fac_offset, &color_offset, &alpha_offset); - uint table_size = read_node(kg, &offset).x; + uint table_size = read_node(kg, svm).x; - float fac = stack_load_float(stack, fac_offset); - float4 color = rgb_ramp_lookup(kg, offset, fac, interpolate, false, table_size); + float fac = stack_load_float(svm, fac_offset); + float4 color = rgb_ramp_lookup(kg, svm->offset, fac, interpolate, false, table_size); if (stack_valid(color_offset)) - stack_store_float3(stack, color_offset, float4_to_float3(color)); + stack_store_float3(svm, color_offset, float4_to_float3(color)); if (stack_valid(alpha_offset)) - stack_store_float(stack, alpha_offset, color.w); + stack_store_float(svm, alpha_offset, color.w); - offset += table_size; - return offset; + svm->offset += table_size; } -ccl_device_noinline int svm_node_curves( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_curves(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { uint fac_offset, color_offset, out_offset, extrapolate; svm_unpack_node_uchar4(node.y, &fac_offset, &color_offset, &out_offset, &extrapolate); - uint table_size = read_node(kg, &offset).x; + uint table_size = read_node(kg, svm).x; - float fac = stack_load_float(stack, fac_offset); - float3 color = stack_load_float3(stack, color_offset); + float fac = stack_load_float(svm, fac_offset); + float3 color = stack_load_float3(svm, color_offset); const float min_x = __int_as_float(node.z), max_x = __int_as_float(node.w); const float range_x = max_x - min_x; const float3 relpos = (color - make_float3(min_x, min_x, min_x)) / range_x; - float r = rgb_ramp_lookup(kg, offset, relpos.x, true, extrapolate, table_size).x; - float g = rgb_ramp_lookup(kg, offset, relpos.y, true, extrapolate, table_size).y; - float b = rgb_ramp_lookup(kg, offset, relpos.z, true, extrapolate, table_size).z; + float r = rgb_ramp_lookup(kg, svm->offset, relpos.x, true, extrapolate, table_size).x; + float g = rgb_ramp_lookup(kg, svm->offset, relpos.y, true, extrapolate, table_size).y; + float b = rgb_ramp_lookup(kg, svm->offset, relpos.z, true, extrapolate, table_size).z; color = (1.0f - fac) * color + fac * make_float3(r, g, b); - stack_store_float3(stack, out_offset, color); + stack_store_float3(svm, out_offset, color); - offset += table_size; - return offset; + svm->offset += table_size; } -ccl_device_noinline int svm_node_curve( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_curve(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { uint fac_offset, value_in_offset, out_offset, extrapolate; svm_unpack_node_uchar4(node.y, &fac_offset, &value_in_offset, &out_offset, &extrapolate); - uint table_size = read_node(kg, &offset).x; + uint table_size = read_node(kg, svm).x; - float fac = stack_load_float(stack, fac_offset); - float in = stack_load_float(stack, value_in_offset); + float fac = stack_load_float(svm, fac_offset); + float in = stack_load_float(svm, value_in_offset); const float min = __int_as_float(node.z), max = __int_as_float(node.w); const float range = max - min; const float relpos = (in - min) / range; - float v = float_ramp_lookup(kg, offset, relpos, true, extrapolate, table_size); + float v = float_ramp_lookup(kg, svm->offset, relpos, true, extrapolate, table_size); in = (1.0f - fac) * in + fac * v; - stack_store_float(stack, out_offset, in); + stack_store_float(svm, out_offset, in); - offset += table_size; - return offset; + svm->offset += table_size; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/sepcomb_color.h b/intern/cycles/kernel/svm/sepcomb_color.h index 15bcc2989c3..78e3429f4c6 100644 --- a/intern/cycles/kernel/svm/sepcomb_color.h +++ b/intern/cycles/kernel/svm/sepcomb_color.h @@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_combine_color(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint color_type, uint inputs_stack_offsets, uint result_stack_offset) @@ -17,25 +17,25 @@ ccl_device_noinline void svm_node_combine_color(KernelGlobals kg, svm_unpack_node_uchar3( inputs_stack_offsets, &red_stack_offset, &green_stack_offset, &blue_stack_offset); - float r = stack_load_float(stack, red_stack_offset); - float g = stack_load_float(stack, green_stack_offset); - float b = stack_load_float(stack, blue_stack_offset); + float r = stack_load_float(svm, red_stack_offset); + float g = stack_load_float(svm, green_stack_offset); + float b = stack_load_float(svm, blue_stack_offset); /* Combine, and convert back to RGB */ float3 color = svm_combine_color((NodeCombSepColorType)color_type, make_float3(r, g, b)); if (stack_valid(result_stack_offset)) - stack_store_float3(stack, result_stack_offset, color); + stack_store_float3(svm, result_stack_offset, color); } ccl_device_noinline void svm_node_separate_color(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint color_type, uint input_stack_offset, uint results_stack_offsets) { - float3 color = stack_load_float3(stack, input_stack_offset); + float3 color = stack_load_float3(svm, input_stack_offset); /* Convert color space */ color = svm_separate_color((NodeCombSepColorType)color_type, color); @@ -45,11 +45,11 @@ ccl_device_noinline void svm_node_separate_color(KernelGlobals kg, results_stack_offsets, &red_stack_offset, &green_stack_offset, &blue_stack_offset); if (stack_valid(red_stack_offset)) - stack_store_float(stack, red_stack_offset, color.x); + stack_store_float(svm, red_stack_offset, color.x); if (stack_valid(green_stack_offset)) - stack_store_float(stack, green_stack_offset, color.y); + stack_store_float(svm, green_stack_offset, color.y); if (stack_valid(blue_stack_offset)) - stack_store_float(stack, blue_stack_offset, color.z); + stack_store_float(svm, blue_stack_offset, color.z); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/sepcomb_hsv.h b/intern/cycles/kernel/svm/sepcomb_hsv.h index 73f7f0eeb4f..6b838a39005 100644 --- a/intern/cycles/kernel/svm/sepcomb_hsv.h +++ b/intern/cycles/kernel/svm/sepcomb_hsv.h @@ -6,52 +6,48 @@ CCL_NAMESPACE_BEGIN -ccl_device_noinline int svm_node_combine_hsv(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint hue_in, - uint saturation_in, - uint value_in, - int offset) +ccl_device_noinline void svm_node_combine_hsv(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint hue_in, + uint saturation_in, + uint value_in) { - uint4 node1 = read_node(kg, &offset); + uint4 node1 = read_node(kg, svm); uint color_out = node1.y; - float hue = stack_load_float(stack, hue_in); - float saturation = stack_load_float(stack, saturation_in); - float value = stack_load_float(stack, value_in); + float hue = stack_load_float(svm, hue_in); + float saturation = stack_load_float(svm, saturation_in); + float value = stack_load_float(svm, value_in); /* Combine, and convert back to RGB */ float3 color = hsv_to_rgb(make_float3(hue, saturation, value)); if (stack_valid(color_out)) - stack_store_float3(stack, color_out, color); - return offset; + stack_store_float3(svm, color_out, color); } -ccl_device_noinline int svm_node_separate_hsv(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint color_in, - uint hue_out, - uint saturation_out, - int offset) +ccl_device_noinline void svm_node_separate_hsv(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint color_in, + uint hue_out, + uint saturation_out) { - uint4 node1 = read_node(kg, &offset); + uint4 node1 = read_node(kg, svm); uint value_out = node1.y; - float3 color = stack_load_float3(stack, color_in); + float3 color = stack_load_float3(svm, color_in); /* Convert to HSV */ color = rgb_to_hsv(color); if (stack_valid(hue_out)) - stack_store_float(stack, hue_out, color.x); + stack_store_float(svm, hue_out, color.x); if (stack_valid(saturation_out)) - stack_store_float(stack, saturation_out, color.y); + stack_store_float(svm, saturation_out, color.y); if (stack_valid(value_out)) - stack_store_float(stack, value_out, color.z); - return offset; + stack_store_float(svm, value_out, color.z); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/sepcomb_vector.h b/intern/cycles/kernel/svm/sepcomb_vector.h index 143ee9072b6..087df70db28 100644 --- a/intern/cycles/kernel/svm/sepcomb_vector.h +++ b/intern/cycles/kernel/svm/sepcomb_vector.h @@ -9,32 +9,32 @@ CCL_NAMESPACE_BEGIN /* Vector combine / separate, used for the RGB and XYZ nodes */ ccl_device void svm_node_combine_vector(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint in_offset, uint vector_index, uint out_offset) { - float vector = stack_load_float(stack, in_offset); + float vector = stack_load_float(svm, in_offset); if (stack_valid(out_offset)) - stack_store_float(stack, out_offset + vector_index, vector); + stack_store_float(svm, out_offset + vector_index, vector); } ccl_device void svm_node_separate_vector(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint ivector_offset, uint vector_index, uint out_offset) { - float3 vector = stack_load_float3(stack, ivector_offset); + float3 vector = stack_load_float3(svm, ivector_offset); if (stack_valid(out_offset)) { if (vector_index == 0) - stack_store_float(stack, out_offset, vector.x); + stack_store_float(svm, out_offset, vector.x); else if (vector_index == 1) - stack_store_float(stack, out_offset, vector.y); + stack_store_float(svm, out_offset, vector.y); else - stack_store_float(stack, out_offset, vector.z); + stack_store_float(svm, out_offset, vector.z); } } diff --git a/intern/cycles/kernel/svm/sky.h b/intern/cycles/kernel/svm/sky.h index bafbcadec3a..c1f16e64d67 100644 --- a/intern/cycles/kernel/svm/sky.h +++ b/intern/cycles/kernel/svm/sky.h @@ -202,19 +202,18 @@ ccl_device float3 sky_radiance_nishita(KernelGlobals kg, return xyz_to_rgb_clamped(kg, xyz); } -ccl_device_noinline int svm_node_tex_sky(KernelGlobals kg, - ccl_private ShaderData *sd, - uint32_t path_flag, - ccl_private float *stack, - uint4 node, - int offset) +ccl_device_noinline void svm_node_tex_sky(KernelGlobals kg, + ccl_private ShaderData *sd, + uint32_t path_flag, + ccl_private SVMState *svm, + uint4 node) { /* Load data */ uint dir_offset = node.y; uint out_offset = node.z; int sky_model = node.w; - float3 dir = stack_load_float3(stack, dir_offset); + float3 dir = stack_load_float3(svm, dir_offset); float3 f; /* Preetham and Hosek share the same data */ @@ -223,49 +222,49 @@ ccl_device_noinline int svm_node_tex_sky(KernelGlobals kg, float sunphi, suntheta, radiance_x, radiance_y, radiance_z; float config_x[9], config_y[9], config_z[9]; - float4 data = read_node_float(kg, &offset); + float4 data = read_node_float(kg, svm); sunphi = data.x; suntheta = data.y; radiance_x = data.z; radiance_y = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); radiance_z = data.x; config_x[0] = data.y; config_x[1] = data.z; config_x[2] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); config_x[3] = data.x; config_x[4] = data.y; config_x[5] = data.z; config_x[6] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); config_x[7] = data.x; config_x[8] = data.y; config_y[0] = data.z; config_y[1] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); config_y[2] = data.x; config_y[3] = data.y; config_y[4] = data.z; config_y[5] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); config_y[6] = data.x; config_y[7] = data.y; config_y[8] = data.z; config_z[0] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); config_z[1] = data.x; config_z[2] = data.y; config_z[3] = data.z; config_z[4] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); config_z[5] = data.x; config_z[6] = data.y; config_z[7] = data.z; @@ -302,18 +301,18 @@ ccl_device_noinline int svm_node_tex_sky(KernelGlobals kg, /* Define variables */ float nishita_data[4]; - float4 data = read_node_float(kg, &offset); + float4 data = read_node_float(kg, svm); float3 pixel_bottom = make_float3(data.x, data.y, data.z); float3 pixel_top; pixel_top.x = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); pixel_top.y = data.x; pixel_top.z = data.y; nishita_data[0] = data.z; nishita_data[1] = data.w; - data = read_node_float(kg, &offset); + data = read_node_float(kg, svm); nishita_data[2] = data.x; nishita_data[3] = data.y; uint texture_id = __float_as_uint(data.z); @@ -323,8 +322,7 @@ ccl_device_noinline int svm_node_tex_sky(KernelGlobals kg, kg, dir, path_flag, pixel_bottom, pixel_top, nishita_data, texture_id); } - stack_store_float3(stack, out_offset, f); - return offset; + stack_store_float3(svm, out_offset, f); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h index 244c60ac9f3..bffb6229b42 100644 --- a/intern/cycles/kernel/svm/svm.h +++ b/intern/cycles/kernel/svm/svm.h @@ -29,62 +29,68 @@ CCL_NAMESPACE_BEGIN +typedef struct SVMState { + float stack[SVM_STACK_SIZE]; + int offset; + float3 closure_weight; +} SVMState; + /* Stack */ -ccl_device_inline float3 stack_load_float3(ccl_private float *stack, uint a) +ccl_device_inline float3 stack_load_float3(ccl_private SVMState *svm, uint a) { kernel_assert(a + 2 < SVM_STACK_SIZE); - ccl_private float *stack_a = stack + a; + ccl_private float *stack_a = svm->stack + a; return make_float3(stack_a[0], stack_a[1], stack_a[2]); } -ccl_device_inline void stack_store_float3(ccl_private float *stack, uint a, float3 f) +ccl_device_inline void stack_store_float3(ccl_private SVMState *svm, uint a, float3 f) { kernel_assert(a + 2 < SVM_STACK_SIZE); - ccl_private float *stack_a = stack + a; + ccl_private float *stack_a = svm->stack + a; stack_a[0] = f.x; stack_a[1] = f.y; stack_a[2] = f.z; } -ccl_device_inline float stack_load_float(ccl_private float *stack, uint a) +ccl_device_inline float stack_load_float(ccl_private SVMState *svm, uint a) { kernel_assert(a < SVM_STACK_SIZE); - return stack[a]; + return svm->stack[a]; } -ccl_device_inline float stack_load_float_default(ccl_private float *stack, uint a, uint value) +ccl_device_inline float stack_load_float_default(ccl_private SVMState *svm, uint a, uint value) { - return (a == (uint)SVM_STACK_INVALID) ? __uint_as_float(value) : stack_load_float(stack, a); + return (a == (uint)SVM_STACK_INVALID) ? __uint_as_float(value) : stack_load_float(svm, a); } -ccl_device_inline void stack_store_float(ccl_private float *stack, uint a, float f) +ccl_device_inline void stack_store_float(ccl_private SVMState *svm, uint a, float f) { kernel_assert(a < SVM_STACK_SIZE); - stack[a] = f; + svm->stack[a] = f; } -ccl_device_inline int stack_load_int(ccl_private float *stack, uint a) +ccl_device_inline int stack_load_int(ccl_private SVMState *svm, uint a) { kernel_assert(a < SVM_STACK_SIZE); - return __float_as_int(stack[a]); + return __float_as_int(svm->stack[a]); } -ccl_device_inline int stack_load_int_default(ccl_private float *stack, uint a, uint value) +ccl_device_inline int stack_load_int_default(ccl_private SVMState *svm, uint a, uint value) { - return (a == (uint)SVM_STACK_INVALID) ? (int)value : stack_load_int(stack, a); + return (a == (uint)SVM_STACK_INVALID) ? (int)value : stack_load_int(svm, a); } -ccl_device_inline void stack_store_int(ccl_private float *stack, uint a, int i) +ccl_device_inline void stack_store_int(ccl_private SVMState *svm, uint a, int i) { kernel_assert(a < SVM_STACK_SIZE); - stack[a] = __int_as_float(i); + svm->stack[a] = __int_as_float(i); } ccl_device_inline bool stack_valid(uint a) @@ -94,21 +100,21 @@ ccl_device_inline bool stack_valid(uint a) /* Reading Nodes */ -ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private int *offset) +ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private SVMState *svm) { - uint4 node = kernel_data_fetch(svm_nodes, *offset); - (*offset)++; + uint4 node = kernel_data_fetch(svm_nodes, svm->offset); + svm->offset++; return node; } -ccl_device_inline float4 read_node_float(KernelGlobals kg, ccl_private int *offset) +ccl_device_inline float4 read_node_float(KernelGlobals kg, ccl_private SVMState *svm) { - uint4 node = kernel_data_fetch(svm_nodes, *offset); + uint4 node = kernel_data_fetch(svm_nodes, svm->offset); float4 f = make_float4(__uint_as_float(node.x), __uint_as_float(node.y), __uint_as_float(node.z), __uint_as_float(node.w)); - (*offset)++; + svm->offset++; return f; } @@ -222,12 +228,11 @@ ccl_device void svm_eval_nodes(KernelGlobals kg, ccl_global float *render_buffer, uint32_t path_flag) { - float stack[SVM_STACK_SIZE]; - Spectrum closure_weight; - int offset = sd->shader & SHADER_MASK; + SVMState svm; + svm.offset = sd->shader & SHADER_MASK; while (1) { - uint4 node = read_node(kg, &offset); + uint4 node = read_node(kg, &svm); switch (node.x) { SVM_CASE(NODE_END) @@ -235,344 +240,341 @@ ccl_device void svm_eval_nodes(KernelGlobals kg, SVM_CASE(NODE_SHADER_JUMP) { if (type == SHADER_TYPE_SURFACE) - offset = node.y; + svm.offset = node.y; else if (type == SHADER_TYPE_VOLUME) - offset = node.z; + svm.offset = node.z; else if (type == SHADER_TYPE_DISPLACEMENT) - offset = node.w; + svm.offset = node.w; else return; break; } SVM_CASE(NODE_CLOSURE_BSDF) - offset = svm_node_closure_bsdf( - kg, sd, stack, closure_weight, node, path_flag, offset); + svm_node_closure_bsdf(kg, sd, &svm, node, path_flag); break; SVM_CASE(NODE_CLOSURE_EMISSION) IF_KERNEL_NODES_FEATURE(EMISSION) { - svm_node_closure_emission(sd, stack, closure_weight, node); + svm_node_closure_emission(sd, &svm, node); } break; SVM_CASE(NODE_CLOSURE_BACKGROUND) IF_KERNEL_NODES_FEATURE(EMISSION) { - svm_node_closure_background(sd, stack, closure_weight, node); + svm_node_closure_background(sd, &svm, node); } break; SVM_CASE(NODE_CLOSURE_SET_WEIGHT) - svm_node_closure_set_weight(sd, &closure_weight, node.y, node.z, node.w); + svm_node_closure_set_weight(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_CLOSURE_WEIGHT) - svm_node_closure_weight(sd, stack, &closure_weight, node.y); + svm_node_closure_weight(sd, &svm, node.y); break; SVM_CASE(NODE_EMISSION_WEIGHT) IF_KERNEL_NODES_FEATURE(EMISSION) { - svm_node_emission_weight(kg, sd, stack, &closure_weight, node); + svm_node_emission_weight(kg, sd, &svm, node); } break; SVM_CASE(NODE_MIX_CLOSURE) - svm_node_mix_closure(sd, stack, node); + svm_node_mix_closure(sd, &svm, node); break; SVM_CASE(NODE_JUMP_IF_ZERO) - if (stack_load_float(stack, node.z) <= 0.0f) - offset += node.y; + if (stack_load_float(&svm, node.z) <= 0.0f) + svm.offset += node.y; break; SVM_CASE(NODE_JUMP_IF_ONE) - if (stack_load_float(stack, node.z) >= 1.0f) - offset += node.y; + if (stack_load_float(&svm, node.z) >= 1.0f) + svm.offset += node.y; break; SVM_CASE(NODE_GEOMETRY) - svm_node_geometry(kg, sd, stack, node.y, node.z); + svm_node_geometry(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_CONVERT) - svm_node_convert(kg, sd, stack, node.y, node.z, node.w); + svm_node_convert(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_TEX_COORD) - offset = svm_node_tex_coord(kg, sd, path_flag, stack, node, offset); + svm_node_tex_coord(kg, sd, path_flag, &svm, node); break; SVM_CASE(NODE_VALUE_F) - svm_node_value_f(kg, sd, stack, node.y, node.z); + svm_node_value_f(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_VALUE_V) - offset = svm_node_value_v(kg, sd, stack, node.y, offset); + svm_node_value_v(kg, sd, &svm, node.y); break; SVM_CASE(NODE_ATTR) - svm_node_attr(kg, sd, stack, node); + svm_node_attr(kg, sd, &svm, node); break; SVM_CASE(NODE_VERTEX_COLOR) - svm_node_vertex_color(kg, sd, stack, node.y, node.z, node.w); + svm_node_vertex_color(kg, sd, &svm, node.y, node.z, node.w); break; SVM_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, &svm, node.y, node.z); } break; SVM_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, &svm, node.y, node.z); } break; SVM_CASE(NODE_SET_DISPLACEMENT) - svm_node_set_displacement(kg, sd, stack, node.y); + svm_node_set_displacement(kg, sd, &svm, node.y); break; SVM_CASE(NODE_DISPLACEMENT) - svm_node_displacement(kg, sd, stack, node); + svm_node_displacement(kg, sd, &svm, node); break; SVM_CASE(NODE_VECTOR_DISPLACEMENT) - offset = svm_node_vector_displacement(kg, sd, stack, node, offset); + svm_node_vector_displacement(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_IMAGE) - offset = svm_node_tex_image(kg, sd, stack, node, offset); + svm_node_tex_image(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_IMAGE_BOX) - svm_node_tex_image_box(kg, sd, stack, node); + svm_node_tex_image_box(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_NOISE) - offset = svm_node_tex_noise(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_tex_noise(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_SET_BUMP) - svm_node_set_bump(kg, sd, stack, node); + svm_node_set_bump(kg, sd, &svm, node); break; SVM_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, &svm, node); } break; SVM_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, &svm, node); } break; SVM_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, &svm, node.y, node.z, node.w); } break; SVM_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, &svm, node.y, node.z, node.w); } break; SVM_CASE(NODE_TEX_COORD_BUMP_DX) IF_KERNEL_NODES_FEATURE(BUMP) { - offset = svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node, offset); + svm_node_tex_coord_bump_dx(kg, sd, path_flag, &svm, node); } break; SVM_CASE(NODE_TEX_COORD_BUMP_DY) IF_KERNEL_NODES_FEATURE(BUMP) { - offset = svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node, offset); + svm_node_tex_coord_bump_dy(kg, sd, path_flag, &svm, node); } break; SVM_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, &svm, node.y, node.z); } break; SVM_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, &svm, node.y); } break; SVM_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, &svm, node.y); } break; SVM_CASE(NODE_HSV) - svm_node_hsv(kg, sd, stack, node); + svm_node_hsv(kg, sd, &svm, node); break; SVM_CASE(NODE_CLOSURE_HOLDOUT) - svm_node_closure_holdout(sd, stack, closure_weight, node); + svm_node_closure_holdout(sd, &svm, node); break; SVM_CASE(NODE_FRESNEL) - svm_node_fresnel(sd, stack, node.y, node.z, node.w); + svm_node_fresnel(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_LAYER_WEIGHT) - svm_node_layer_weight(sd, stack, node); + svm_node_layer_weight(sd, &svm, node); break; SVM_CASE(NODE_CLOSURE_VOLUME) IF_KERNEL_NODES_FEATURE(VOLUME) { - svm_node_closure_volume(kg, sd, stack, closure_weight, node); + svm_node_closure_volume(kg, sd, &svm, node); } break; SVM_CASE(NODE_PRINCIPLED_VOLUME) IF_KERNEL_NODES_FEATURE(VOLUME) { - offset = svm_node_principled_volume( - kg, sd, stack, closure_weight, node, path_flag, offset); + svm_node_principled_volume(kg, sd, &svm, node, path_flag); } break; SVM_CASE(NODE_MATH) - svm_node_math(kg, sd, stack, node.y, node.z, node.w); + svm_node_math(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_VECTOR_MATH) - offset = svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_vector_math(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_RGB_RAMP) - offset = svm_node_rgb_ramp(kg, sd, stack, node, offset); + svm_node_rgb_ramp(kg, sd, &svm, node); break; SVM_CASE(NODE_GAMMA) - svm_node_gamma(sd, stack, node.y, node.z, node.w); + svm_node_gamma(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_BRIGHTCONTRAST) - svm_node_brightness(sd, stack, node.y, node.z, node.w); + svm_node_brightness(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_LIGHT_PATH) - svm_node_light_path(kg, state, sd, stack, node.y, node.z, path_flag); + svm_node_light_path(kg, state, sd, &svm, node.y, node.z, path_flag); break; SVM_CASE(NODE_OBJECT_INFO) - svm_node_object_info(kg, sd, stack, node.y, node.z); + svm_node_object_info(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_PARTICLE_INFO) - svm_node_particle_info(kg, sd, stack, node.y, node.z); + svm_node_particle_info(kg, sd, &svm, node.y, node.z); break; #if defined(__HAIR__) SVM_CASE(NODE_HAIR_INFO) - svm_node_hair_info(kg, sd, stack, node.y, node.z); + svm_node_hair_info(kg, sd, &svm, node.y, node.z); break; #endif #if defined(__POINTCLOUD__) SVM_CASE(NODE_POINT_INFO) - svm_node_point_info(kg, sd, stack, node.y, node.z); + svm_node_point_info(kg, sd, &svm, node.y, node.z); break; #endif SVM_CASE(NODE_TEXTURE_MAPPING) - offset = svm_node_texture_mapping(kg, sd, stack, node.y, node.z, offset); + svm_node_texture_mapping(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_MAPPING) - svm_node_mapping(kg, sd, stack, node.y, node.z, node.w); + svm_node_mapping(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_MIN_MAX) - offset = svm_node_min_max(kg, sd, stack, node.y, node.z, offset); + svm_node_min_max(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_CAMERA) - svm_node_camera(kg, sd, stack, node.y, node.z, node.w); + svm_node_camera(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_TEX_ENVIRONMENT) - svm_node_tex_environment(kg, sd, stack, node); + svm_node_tex_environment(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_SKY) - offset = svm_node_tex_sky(kg, sd, path_flag, stack, node, offset); + svm_node_tex_sky(kg, sd, path_flag, &svm, node); break; SVM_CASE(NODE_TEX_GRADIENT) - svm_node_tex_gradient(sd, stack, node); + svm_node_tex_gradient(sd, &svm, node); break; SVM_CASE(NODE_TEX_VORONOI) - offset = svm_node_tex_voronoi( - kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_tex_voronoi(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_TEX_MUSGRAVE) - offset = svm_node_tex_musgrave(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_tex_musgrave(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_TEX_WAVE) - offset = svm_node_tex_wave(kg, sd, stack, node, offset); + svm_node_tex_wave(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_MAGIC) - offset = svm_node_tex_magic(kg, sd, stack, node, offset); + svm_node_tex_magic(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_CHECKER) - svm_node_tex_checker(kg, sd, stack, node); + svm_node_tex_checker(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_BRICK) - offset = svm_node_tex_brick(kg, sd, stack, node, offset); + svm_node_tex_brick(kg, sd, &svm, node); break; SVM_CASE(NODE_TEX_WHITE_NOISE) - svm_node_tex_white_noise(kg, sd, stack, node.y, node.z, node.w); + svm_node_tex_white_noise(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_NORMAL) - offset = svm_node_normal(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_normal(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_LIGHT_FALLOFF) - svm_node_light_falloff(sd, stack, node); + svm_node_light_falloff(sd, &svm, node); break; SVM_CASE(NODE_IES) - svm_node_ies(kg, sd, stack, node); + svm_node_ies(kg, sd, &svm, node); break; SVM_CASE(NODE_CURVES) - offset = svm_node_curves(kg, sd, stack, node, offset); + svm_node_curves(kg, sd, &svm, node); break; SVM_CASE(NODE_FLOAT_CURVE) - offset = svm_node_curve(kg, sd, stack, node, offset); + svm_node_curve(kg, sd, &svm, node); break; SVM_CASE(NODE_TANGENT) - svm_node_tangent(kg, sd, stack, node); + svm_node_tangent(kg, sd, &svm, node); break; SVM_CASE(NODE_NORMAL_MAP) - svm_node_normal_map(kg, sd, stack, node); + svm_node_normal_map(kg, sd, &svm, node); break; SVM_CASE(NODE_INVERT) - svm_node_invert(sd, stack, node.y, node.z, node.w); + svm_node_invert(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_MIX) - offset = svm_node_mix(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_mix(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_SEPARATE_COLOR) - svm_node_separate_color(kg, sd, stack, node.y, node.z, node.w); + svm_node_separate_color(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_COMBINE_COLOR) - svm_node_combine_color(kg, sd, stack, node.y, node.z, node.w); + svm_node_combine_color(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_SEPARATE_VECTOR) - svm_node_separate_vector(sd, stack, node.y, node.z, node.w); + svm_node_separate_vector(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_COMBINE_VECTOR) - svm_node_combine_vector(sd, stack, node.y, node.z, node.w); + svm_node_combine_vector(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_SEPARATE_HSV) - offset = svm_node_separate_hsv(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_separate_hsv(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_COMBINE_HSV) - offset = svm_node_combine_hsv(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_combine_hsv(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_VECTOR_ROTATE) - svm_node_vector_rotate(sd, stack, node.y, node.z, node.w); + svm_node_vector_rotate(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_VECTOR_TRANSFORM) - svm_node_vector_transform(kg, sd, stack, node); + svm_node_vector_transform(kg, sd, &svm, node); break; SVM_CASE(NODE_WIREFRAME) - svm_node_wireframe(kg, sd, stack, node); + svm_node_wireframe(kg, sd, &svm, node); break; SVM_CASE(NODE_WAVELENGTH) - svm_node_wavelength(kg, sd, stack, node.y, node.z); + svm_node_wavelength(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_BLACKBODY) - svm_node_blackbody(kg, sd, stack, node.y, node.z); + svm_node_blackbody(kg, sd, &svm, node.y, node.z); break; SVM_CASE(NODE_MAP_RANGE) - offset = svm_node_map_range(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_map_range(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_VECTOR_MAP_RANGE) - offset = svm_node_vector_map_range(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_vector_map_range(kg, sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_CLAMP) - offset = svm_node_clamp(kg, sd, stack, node.y, node.z, node.w, offset); + svm_node_clamp(kg, sd, &svm, node.y, node.z, node.w); break; #ifdef __SHADER_RAYTRACE__ SVM_CASE(NODE_BEVEL) - svm_node_bevel(kg, state, sd, stack, node); + svm_node_bevel(kg, state, sd, &svm, node); break; SVM_CASE(NODE_AMBIENT_OCCLUSION) - svm_node_ao(kg, state, sd, stack, node); + svm_node_ao(kg, state, sd, &svm, node); break; #endif SVM_CASE(NODE_TEX_VOXEL) - offset = svm_node_tex_voxel(kg, sd, stack, node, offset); + svm_node_tex_voxel(kg, sd, &svm, node); break; SVM_CASE(NODE_AOV_START) if (!svm_node_aov_check(path_flag, render_buffer)) { @@ -580,22 +582,22 @@ ccl_device void svm_eval_nodes(KernelGlobals kg, } break; SVM_CASE(NODE_AOV_COLOR) - svm_node_aov_color(kg, state, sd, stack, node, render_buffer); + svm_node_aov_color(kg, state, sd, &svm, node, render_buffer); break; SVM_CASE(NODE_AOV_VALUE) - svm_node_aov_value(kg, state, sd, stack, node, render_buffer); + svm_node_aov_value(kg, state, sd, &svm, node, render_buffer); break; SVM_CASE(NODE_MIX_COLOR) - svm_node_mix_color(sd, stack, node.y, node.z, node.w); + svm_node_mix_color(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_MIX_FLOAT) - svm_node_mix_float(sd, stack, node.y, node.z, node.w); + svm_node_mix_float(sd, &svm, node.y, node.z, node.w); break; SVM_CASE(NODE_MIX_VECTOR) - svm_node_mix_vector(sd, stack, node.y, node.z); + svm_node_mix_vector(sd, &svm, node.y, node.z); break; SVM_CASE(NODE_MIX_VECTOR_NON_UNIFORM) - svm_node_mix_vector_non_uniform(sd, stack, node.y, node.z); + svm_node_mix_vector_non_uniform(sd, &svm, node.y, node.z); break; default: kernel_assert(!"Unknown node type was passed to the SVM machine"); diff --git a/intern/cycles/kernel/svm/tex_coord.h b/intern/cycles/kernel/svm/tex_coord.h index 18df8c75a21..66905688e2e 100644 --- a/intern/cycles/kernel/svm/tex_coord.h +++ b/intern/cycles/kernel/svm/tex_coord.h @@ -12,12 +12,11 @@ CCL_NAMESPACE_BEGIN /* Texture Coordinate Node */ -ccl_device_noinline int svm_node_tex_coord(KernelGlobals kg, - ccl_private ShaderData *sd, - uint32_t path_flag, - ccl_private float *stack, - uint4 node, - int offset) +ccl_device_noinline void svm_node_tex_coord(KernelGlobals kg, + ccl_private ShaderData *sd, + uint32_t path_flag, + ccl_private SVMState *svm, + uint4 node) { float3 data = zero_float3(); uint type = node.y; @@ -33,9 +32,9 @@ ccl_device_noinline int svm_node_tex_coord(KernelGlobals kg, } else { Transform tfm; - tfm.x = read_node_float(kg, &offset); - tfm.y = read_node_float(kg, &offset); - tfm.z = read_node_float(kg, &offset); + tfm.x = read_node_float(kg, svm); + tfm.y = read_node_float(kg, svm); + tfm.z = read_node_float(kg, svm); data = transform_point(&tfm, data); } break; @@ -89,16 +88,14 @@ ccl_device_noinline int svm_node_tex_coord(KernelGlobals kg, } } - stack_store_float3(stack, out_offset, data); - return offset; + stack_store_float3(svm, out_offset, data); } -ccl_device_noinline int svm_node_tex_coord_bump_dx(KernelGlobals kg, - ccl_private ShaderData *sd, - uint32_t path_flag, - ccl_private float *stack, - uint4 node, - int offset) +ccl_device_noinline void svm_node_tex_coord_bump_dx(KernelGlobals kg, + ccl_private ShaderData *sd, + uint32_t path_flag, + ccl_private SVMState *svm, + uint4 node) { #ifdef __RAY_DIFFERENTIALS__ float3 data = zero_float3(); @@ -115,9 +112,9 @@ ccl_device_noinline int svm_node_tex_coord_bump_dx(KernelGlobals kg, } else { Transform tfm; - tfm.x = read_node_float(kg, &offset); - tfm.y = read_node_float(kg, &offset); - tfm.z = read_node_float(kg, &offset); + tfm.x = read_node_float(kg, svm); + tfm.y = read_node_float(kg, svm); + tfm.z = read_node_float(kg, svm); data = transform_point(&tfm, data); } break; @@ -171,19 +168,17 @@ ccl_device_noinline int svm_node_tex_coord_bump_dx(KernelGlobals kg, } } - stack_store_float3(stack, out_offset, data); - return offset; + stack_store_float3(svm, out_offset, data); #else - return svm_node_tex_coord(kg, sd, path_flag, stack, node, offset); + svm_node_tex_coord(kg, sd, path_flag, stack, node); #endif } -ccl_device_noinline int svm_node_tex_coord_bump_dy(KernelGlobals kg, - ccl_private ShaderData *sd, - uint32_t path_flag, - ccl_private float *stack, - uint4 node, - int offset) +ccl_device_noinline void svm_node_tex_coord_bump_dy(KernelGlobals kg, + ccl_private ShaderData *sd, + uint32_t path_flag, + ccl_private SVMState *svm, + uint4 node) { #ifdef __RAY_DIFFERENTIALS__ float3 data = zero_float3(); @@ -200,9 +195,9 @@ ccl_device_noinline int svm_node_tex_coord_bump_dy(KernelGlobals kg, } else { Transform tfm; - tfm.x = read_node_float(kg, &offset); - tfm.y = read_node_float(kg, &offset); - tfm.z = read_node_float(kg, &offset); + tfm.x = read_node_float(kg, svm); + tfm.y = read_node_float(kg, svm); + tfm.z = read_node_float(kg, svm); data = transform_point(&tfm, data); } break; @@ -256,32 +251,31 @@ ccl_device_noinline int svm_node_tex_coord_bump_dy(KernelGlobals kg, } } - stack_store_float3(stack, out_offset, data); - return offset; + stack_store_float3(svm, out_offset, data); #else - return svm_node_tex_coord(kg, sd, path_flag, stack, node, offset); + svm_node_tex_coord(kg, sd, path_flag, stack, node); #endif } ccl_device_noinline void svm_node_normal_map(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint color_offset, strength_offset, normal_offset, space; svm_unpack_node_uchar4(node.y, &color_offset, &strength_offset, &normal_offset, &space); - float3 color = stack_load_float3(stack, color_offset); + float3 color = stack_load_float3(svm, color_offset); color = 2.0f * make_float3(color.x - 0.5f, color.y - 0.5f, color.z - 0.5f); bool is_backfacing = (sd->flag & SD_BACKFACING) != 0; float3 N; - float strength = stack_load_float(stack, strength_offset); + float strength = stack_load_float(svm, strength_offset); if (space == NODE_NORMAL_MAP_TANGENT) { /* tangent space */ if (sd->object == OBJECT_NONE || (sd->type & PRIMITIVE_TRIANGLE) == 0) { /* Fallback to unperturbed normal. */ - stack_store_float3(stack, normal_offset, sd->N); + stack_store_float3(svm, normal_offset, sd->N); return; } @@ -291,7 +285,7 @@ ccl_device_noinline void svm_node_normal_map(KernelGlobals kg, if (attr.offset == ATTR_STD_NOT_FOUND || attr_sign.offset == ATTR_STD_NOT_FOUND) { /* Fallback to unperturbed normal. */ - stack_store_float3(stack, normal_offset, sd->N); + stack_store_float3(svm, normal_offset, sd->N); return; } @@ -354,12 +348,12 @@ ccl_device_noinline void svm_node_normal_map(KernelGlobals kg, N = sd->N; } - stack_store_float3(stack, normal_offset, N); + stack_store_float3(svm, normal_offset, N); } ccl_device_noinline void svm_node_tangent(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint tangent_offset, direction_type, axis; @@ -383,7 +377,7 @@ ccl_device_noinline void svm_node_tangent(KernelGlobals kg, if (direction_type == NODE_TANGENT_UVMAP) { /* UV map */ if (desc.offset == ATTR_STD_NOT_FOUND) { - stack_store_float3(stack, tangent_offset, zero_float3()); + stack_store_float3(svm, tangent_offset, zero_float3()); return; } else { @@ -409,7 +403,7 @@ ccl_device_noinline void svm_node_tangent(KernelGlobals kg, object_normal_transform(kg, sd, &tangent); tangent = cross(sd->N, normalize(cross(tangent, sd->N))); - stack_store_float3(stack, tangent_offset, tangent); + stack_store_float3(svm, tangent_offset, tangent); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/value.h b/intern/cycles/kernel/svm/value.h index b7cb4cda091..163da2dba68 100644 --- a/intern/cycles/kernel/svm/value.h +++ b/intern/cycles/kernel/svm/value.h @@ -10,26 +10,24 @@ CCL_NAMESPACE_BEGIN ccl_device void svm_node_value_f(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint ivalue, uint out_offset) { - stack_store_float(stack, out_offset, __uint_as_float(ivalue)); + stack_store_float(svm, out_offset, __uint_as_float(ivalue)); } -ccl_device int svm_node_value_v(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint out_offset, - int offset) +ccl_device void svm_node_value_v(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint out_offset) { /* read extra data */ - uint4 node1 = read_node(kg, &offset); + uint4 node1 = read_node(kg, svm); float3 p = make_float3( __uint_as_float(node1.y), __uint_as_float(node1.z), __uint_as_float(node1.w)); - stack_store_float3(stack, out_offset, p); - return offset; + stack_store_float3(svm, out_offset, p); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/vector_rotate.h b/intern/cycles/kernel/svm/vector_rotate.h index 56041b3e04d..9a7c6e91542 100644 --- a/intern/cycles/kernel/svm/vector_rotate.h +++ b/intern/cycles/kernel/svm/vector_rotate.h @@ -9,7 +9,7 @@ CCL_NAMESPACE_BEGIN /* Vector Rotate */ ccl_device_noinline void svm_node_vector_rotate(ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint input_stack_offsets, uint axis_stack_offsets, uint result_stack_offset) @@ -24,12 +24,12 @@ ccl_device_noinline void svm_node_vector_rotate(ccl_private ShaderData *sd, if (stack_valid(result_stack_offset)) { - float3 vector = stack_load_float3(stack, vector_stack_offset); - float3 center = stack_load_float3(stack, center_stack_offset); + float3 vector = stack_load_float3(svm, vector_stack_offset); + float3 center = stack_load_float3(svm, center_stack_offset); float3 result = make_float3(0.0f, 0.0f, 0.0f); if (type == NODE_VECTOR_ROTATE_TYPE_EULER_XYZ) { - float3 rotation = stack_load_float3(stack, rotation_stack_offset); // Default XYZ. + float3 rotation = stack_load_float3(svm, rotation_stack_offset); // Default XYZ. Transform rotationTransform = euler_to_transform(rotation); if (invert) { result = transform_direction_transposed(&rotationTransform, vector - center) + center; @@ -55,18 +55,18 @@ ccl_device_noinline void svm_node_vector_rotate(ccl_private ShaderData *sd, axis_length = 1.0f; break; default: - axis = stack_load_float3(stack, axis_stack_offset); + axis = stack_load_float3(svm, axis_stack_offset); axis_length = len(axis); break; } - float angle = stack_load_float(stack, angle_stack_offset); + float angle = stack_load_float(svm, angle_stack_offset); angle = invert ? -angle : angle; result = (axis_length != 0.0f) ? rotate_around_axis(vector - center, axis / axis_length, angle) + center : vector; } - stack_store_float3(stack, result_stack_offset, result); + stack_store_float3(svm, result_stack_offset, result); } } diff --git a/intern/cycles/kernel/svm/vector_transform.h b/intern/cycles/kernel/svm/vector_transform.h index 1b180c1bcd2..309aa0b6853 100644 --- a/intern/cycles/kernel/svm/vector_transform.h +++ b/intern/cycles/kernel/svm/vector_transform.h @@ -10,7 +10,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_vector_transform(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint itype, ifrom, ito; @@ -19,7 +19,7 @@ ccl_device_noinline void svm_node_vector_transform(KernelGlobals kg, svm_unpack_node_uchar3(node.y, &itype, &ifrom, &ito); svm_unpack_node_uchar2(node.z, &vector_in, &vector_out); - float3 in = stack_load_float3(stack, vector_in); + float3 in = stack_load_float3(svm, vector_in); NodeVectorTransformType type = (NodeVectorTransformType)itype; NodeVectorTransformConvertSpace from = (NodeVectorTransformConvertSpace)ifrom; @@ -117,7 +117,7 @@ ccl_device_noinline void svm_node_vector_transform(KernelGlobals kg, /* Output */ if (stack_valid(vector_out)) { - stack_store_float3(stack, vector_out, in); + stack_store_float3(svm, vector_out, in); } } diff --git a/intern/cycles/kernel/svm/vertex_color.h b/intern/cycles/kernel/svm/vertex_color.h index d9f3cc0f12e..78093fda8cf 100644 --- a/intern/cycles/kernel/svm/vertex_color.h +++ b/intern/cycles/kernel/svm/vertex_color.h @@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_vertex_color(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint layer_id, uint color_offset, uint alpha_offset) @@ -17,24 +17,24 @@ ccl_device_noinline void svm_node_vertex_color(KernelGlobals kg, if (descriptor.offset != ATTR_STD_NOT_FOUND) { if (descriptor.type == NODE_ATTR_FLOAT4 || descriptor.type == NODE_ATTR_RGBA) { float4 vertex_color = primitive_surface_attribute_float4(kg, sd, descriptor, NULL, NULL); - stack_store_float3(stack, color_offset, float4_to_float3(vertex_color)); - stack_store_float(stack, alpha_offset, vertex_color.w); + stack_store_float3(svm, color_offset, float4_to_float3(vertex_color)); + stack_store_float(svm, alpha_offset, vertex_color.w); } else { float3 vertex_color = primitive_surface_attribute_float3(kg, sd, descriptor, NULL, NULL); - stack_store_float3(stack, color_offset, vertex_color); - stack_store_float(stack, alpha_offset, 1.0f); + stack_store_float3(svm, color_offset, vertex_color); + stack_store_float(svm, alpha_offset, 1.0f); } } else { - stack_store_float3(stack, color_offset, make_float3(0.0f, 0.0f, 0.0f)); - stack_store_float(stack, alpha_offset, 0.0f); + stack_store_float3(svm, color_offset, make_float3(0.0f, 0.0f, 0.0f)); + stack_store_float(svm, alpha_offset, 0.0f); } } ccl_device_noinline void svm_node_vertex_color_bump_dx(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint layer_id, uint color_offset, uint alpha_offset) @@ -45,26 +45,26 @@ ccl_device_noinline void svm_node_vertex_color_bump_dx(KernelGlobals kg, float4 dx; float4 vertex_color = primitive_surface_attribute_float4(kg, sd, descriptor, &dx, NULL); vertex_color += dx; - stack_store_float3(stack, color_offset, float4_to_float3(vertex_color)); - stack_store_float(stack, alpha_offset, vertex_color.w); + stack_store_float3(svm, color_offset, float4_to_float3(vertex_color)); + stack_store_float(svm, alpha_offset, vertex_color.w); } else { float3 dx; float3 vertex_color = primitive_surface_attribute_float3(kg, sd, descriptor, &dx, NULL); vertex_color += dx; - stack_store_float3(stack, color_offset, vertex_color); - stack_store_float(stack, alpha_offset, 1.0f); + stack_store_float3(svm, color_offset, vertex_color); + stack_store_float(svm, alpha_offset, 1.0f); } } else { - stack_store_float3(stack, color_offset, make_float3(0.0f, 0.0f, 0.0f)); - stack_store_float(stack, alpha_offset, 0.0f); + stack_store_float3(svm, color_offset, make_float3(0.0f, 0.0f, 0.0f)); + stack_store_float(svm, alpha_offset, 0.0f); } } ccl_device_noinline void svm_node_vertex_color_bump_dy(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint layer_id, uint color_offset, uint alpha_offset) @@ -75,20 +75,20 @@ ccl_device_noinline void svm_node_vertex_color_bump_dy(KernelGlobals kg, float4 dy; float4 vertex_color = primitive_surface_attribute_float4(kg, sd, descriptor, NULL, &dy); vertex_color += dy; - stack_store_float3(stack, color_offset, float4_to_float3(vertex_color)); - stack_store_float(stack, alpha_offset, vertex_color.w); + stack_store_float3(svm, color_offset, float4_to_float3(vertex_color)); + stack_store_float(svm, alpha_offset, vertex_color.w); } else { float3 dy; float3 vertex_color = primitive_surface_attribute_float3(kg, sd, descriptor, NULL, &dy); vertex_color += dy; - stack_store_float3(stack, color_offset, vertex_color); - stack_store_float(stack, alpha_offset, 1.0f); + stack_store_float3(svm, color_offset, vertex_color); + stack_store_float(svm, alpha_offset, 1.0f); } } else { - stack_store_float3(stack, color_offset, make_float3(0.0f, 0.0f, 0.0f)); - stack_store_float(stack, alpha_offset, 0.0f); + stack_store_float3(svm, color_offset, make_float3(0.0f, 0.0f, 0.0f)); + stack_store_float(svm, alpha_offset, 0.0f); } } diff --git a/intern/cycles/kernel/svm/voronoi.h b/intern/cycles/kernel/svm/voronoi.h index 3fdb608995e..42b0393aac7 100644 --- a/intern/cycles/kernel/svm/voronoi.h +++ b/intern/cycles/kernel/svm/voronoi.h @@ -980,7 +980,7 @@ ccl_device float fractal_voronoi_distance_to_edge(ccl_private const VoronoiParam } ccl_device void svm_voronoi_output(const uint4 stack_offsets, - ccl_private float *stack, + ccl_private SVMState *svm, const float distance, const float3 color, const float3 position, @@ -996,30 +996,29 @@ ccl_device void svm_voronoi_output(const uint4 stack_offsets, stack_offsets.w, &position_stack_offset, &w_out_stack_offset, &radius_stack_offset); if (stack_valid(distance_stack_offset)) - stack_store_float(stack, distance_stack_offset, distance); + stack_store_float(svm, distance_stack_offset, distance); if (stack_valid(color_stack_offset)) - stack_store_float3(stack, color_stack_offset, color); + stack_store_float3(svm, color_stack_offset, color); if (stack_valid(position_stack_offset)) - stack_store_float3(stack, position_stack_offset, position); + stack_store_float3(svm, position_stack_offset, position); if (stack_valid(w_out_stack_offset)) - stack_store_float(stack, w_out_stack_offset, w); + stack_store_float(svm, w_out_stack_offset, w); if (stack_valid(radius_stack_offset)) - stack_store_float(stack, radius_stack_offset, radius); + stack_store_float(svm, radius_stack_offset, radius); } template -ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, - ccl_private ShaderData *sd, - ccl_private float *stack, - uint dimensions, - uint feature, - uint metric, - int offset) +ccl_device_noinline void svm_node_tex_voronoi(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint dimensions, + uint feature, + uint metric) { /* Read node defaults and stack offsets. */ - uint4 stack_offsets = read_node(kg, &offset); - uint4 defaults1 = read_node(kg, &offset); - uint4 defaults2 = read_node(kg, &offset); + uint4 stack_offsets = read_node(kg, svm); + uint4 defaults1 = read_node(kg, svm); + uint4 defaults2 = read_node(kg, svm); uint coord_stack_offset, w_stack_offset, scale_stack_offset, detail_stack_offset; uint roughness_stack_offset, lacunarity_stack_offset, smoothness_stack_offset, @@ -1039,19 +1038,19 @@ ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, svm_unpack_node_uchar2(stack_offsets.z, &randomness_stack_offset, &normalize); /* Read from stack. */ - float3 coord = stack_load_float3(stack, coord_stack_offset); - float w = stack_load_float_default(stack, w_stack_offset, defaults1.x); + float3 coord = stack_load_float3(svm, coord_stack_offset); + float w = stack_load_float_default(svm, w_stack_offset, defaults1.x); VoronoiParams params; params.feature = (NodeVoronoiFeature)feature; params.metric = (NodeVoronoiDistanceMetric)metric; - params.scale = stack_load_float_default(stack, scale_stack_offset, defaults1.y); - params.detail = stack_load_float_default(stack, detail_stack_offset, defaults1.z); - params.roughness = stack_load_float_default(stack, roughness_stack_offset, defaults1.w); - params.lacunarity = stack_load_float_default(stack, smoothness_stack_offset, defaults2.x); - params.smoothness = stack_load_float_default(stack, smoothness_stack_offset, defaults2.y); - params.exponent = stack_load_float_default(stack, exponent_stack_offset, defaults2.z); - params.randomness = stack_load_float_default(stack, randomness_stack_offset, defaults2.w); + params.scale = stack_load_float_default(svm, scale_stack_offset, defaults1.y); + params.detail = stack_load_float_default(svm, detail_stack_offset, defaults1.z); + params.roughness = stack_load_float_default(svm, roughness_stack_offset, defaults1.w); + params.lacunarity = stack_load_float_default(svm, smoothness_stack_offset, defaults2.x); + params.smoothness = stack_load_float_default(svm, smoothness_stack_offset, defaults2.y); + params.exponent = stack_load_float_default(svm, exponent_stack_offset, defaults2.z); + params.randomness = stack_load_float_default(svm, randomness_stack_offset, defaults2.w); params.max_distance = 0.0f; params.normalize = normalize; @@ -1083,7 +1082,7 @@ ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, break; } - svm_voronoi_output(stack_offsets, stack, distance, zero_float3(), zero_float3(), 0.0f, 0.0f); + svm_voronoi_output(stack_offsets, svm, distance, zero_float3(), zero_float3(), 0.0f, 0.0f); break; } case NODE_VORONOI_N_SPHERE_RADIUS: { @@ -1103,7 +1102,7 @@ ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, break; } - svm_voronoi_output(stack_offsets, stack, 0.0f, zero_float3(), zero_float3(), 0.0f, radius); + svm_voronoi_output(stack_offsets, svm, 0.0f, zero_float3(), zero_float3(), 0.0f, radius); break; } default: { @@ -1153,7 +1152,7 @@ ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, } svm_voronoi_output(stack_offsets, - stack, + svm, output.distance, output.color, float4_to_float3(output.position), @@ -1162,8 +1161,6 @@ ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, break; } } - - return offset; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/voxel.h b/intern/cycles/kernel/svm/voxel.h index e07c8b8bc67..41bc1f7751d 100644 --- a/intern/cycles/kernel/svm/voxel.h +++ b/intern/cycles/kernel/svm/voxel.h @@ -10,8 +10,10 @@ CCL_NAMESPACE_BEGIN * sampler. */ template -ccl_device_noinline int svm_node_tex_voxel( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_tex_voxel(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { uint co_offset, density_out_offset, color_out_offset, space; svm_unpack_node_uchar4(node.z, &co_offset, &density_out_offset, &color_out_offset, &space); @@ -22,33 +24,32 @@ ccl_device_noinline int svm_node_tex_voxel( IF_KERNEL_NODES_FEATURE(VOLUME) { int id = node.y; - float3 co = stack_load_float3(stack, co_offset); + float3 co = stack_load_float3(svm, co_offset); if (space == NODE_TEX_VOXEL_SPACE_OBJECT) { co = volume_normalized_position(kg, sd, co); } else { kernel_assert(space == NODE_TEX_VOXEL_SPACE_WORLD); Transform tfm; - tfm.x = read_node_float(kg, &offset); - tfm.y = read_node_float(kg, &offset); - tfm.z = read_node_float(kg, &offset); + tfm.x = read_node_float(kg, svm); + tfm.y = read_node_float(kg, svm); + tfm.z = read_node_float(kg, svm); co = transform_point(&tfm, co); } r = kernel_tex_image_interp_3d(kg, id, co, INTERPOLATION_NONE); } else if (space != NODE_TEX_VOXEL_SPACE_OBJECT) { - read_node_float(kg, &offset); - read_node_float(kg, &offset); - read_node_float(kg, &offset); + read_node_float(kg, svm); + read_node_float(kg, svm); + read_node_float(kg, svm); } #endif if (stack_valid(density_out_offset)) - stack_store_float(stack, density_out_offset, r.w); + stack_store_float(svm, density_out_offset, r.w); if (stack_valid(color_out_offset)) - stack_store_float3(stack, color_out_offset, make_float3(r.x, r.y, r.z)); - return offset; + stack_store_float3(svm, color_out_offset, make_float3(r.x, r.y, r.z)); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/wave.h b/intern/cycles/kernel/svm/wave.h index 0ff2860cf64..1cfe3282779 100644 --- a/intern/cycles/kernel/svm/wave.h +++ b/intern/cycles/kernel/svm/wave.h @@ -72,11 +72,13 @@ ccl_device_noinline_cpu float svm_wave(NodeWaveType type, } } -ccl_device_noinline int svm_node_tex_wave( - KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset) +ccl_device_noinline void svm_node_tex_wave(KernelGlobals kg, + ccl_private ShaderData *sd, + ccl_private SVMState *svm, + uint4 node) { - uint4 node2 = read_node(kg, &offset); - uint4 node3 = read_node(kg, &offset); + uint4 node2 = read_node(kg, svm); + uint4 node3 = read_node(kg, svm); /* RNA properties */ uint type_offset, bands_dir_offset, rings_dir_offset, profile_offset; @@ -92,13 +94,13 @@ ccl_device_noinline int svm_node_tex_wave( node.w, &detail_offset, &dscale_offset, &droughness_offset, &phase_offset); svm_unpack_node_uchar2(node2.x, &color_offset, &fac_offset); - float3 co = stack_load_float3(stack, co_offset); - float scale = stack_load_float_default(stack, scale_offset, node2.y); - float distortion = stack_load_float_default(stack, distortion_offset, node2.z); - float detail = stack_load_float_default(stack, detail_offset, node2.w); - float dscale = stack_load_float_default(stack, dscale_offset, node3.x); - float droughness = stack_load_float_default(stack, droughness_offset, node3.y); - float phase = stack_load_float_default(stack, phase_offset, node3.z); + float3 co = stack_load_float3(svm, co_offset); + float scale = stack_load_float_default(svm, scale_offset, node2.y); + float distortion = stack_load_float_default(svm, distortion_offset, node2.z); + float detail = stack_load_float_default(svm, detail_offset, node2.w); + float dscale = stack_load_float_default(svm, dscale_offset, node3.x); + float droughness = stack_load_float_default(svm, droughness_offset, node3.y); + float phase = stack_load_float_default(svm, phase_offset, node3.z); float f = svm_wave((NodeWaveType)type_offset, (NodeWaveBandsDirection)bands_dir_offset, @@ -112,10 +114,9 @@ ccl_device_noinline int svm_node_tex_wave( phase); if (stack_valid(fac_offset)) - stack_store_float(stack, fac_offset, f); + stack_store_float(svm, fac_offset, f); if (stack_valid(color_offset)) - stack_store_float3(stack, color_offset, make_float3(f, f, f)); - return offset; + stack_store_float3(svm, color_offset, make_float3(f, f, f)); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/wavelength.h b/intern/cycles/kernel/svm/wavelength.h index 3bf7d300db7..3b8de925a35 100644 --- a/intern/cycles/kernel/svm/wavelength.h +++ b/intern/cycles/kernel/svm/wavelength.h @@ -13,11 +13,11 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_wavelength(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint wavelength, uint color_out) { - float lambda_nm = stack_load_float(stack, wavelength); + float lambda_nm = stack_load_float(svm, wavelength); float ii = (lambda_nm - 380.0f) * (1.0f / 5.0f); // scaled 0..80 int i = float_to_int(ii); float3 color; @@ -37,7 +37,7 @@ ccl_device_noinline void svm_node_wavelength(KernelGlobals kg, /* Clamp to zero if values are smaller */ color = max(color, make_float3(0.0f, 0.0f, 0.0f)); - stack_store_float3(stack, color_out, color); + stack_store_float3(svm, color_out, color); } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/svm/white_noise.h b/intern/cycles/kernel/svm/white_noise.h index 78264111d44..2b77d25053c 100644 --- a/intern/cycles/kernel/svm/white_noise.h +++ b/intern/cycles/kernel/svm/white_noise.h @@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_tex_white_noise(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint dimensions, uint inputs_stack_offsets, uint ouptuts_stack_offsets) @@ -17,8 +17,8 @@ ccl_device_noinline void svm_node_tex_white_noise(KernelGlobals kg, svm_unpack_node_uchar2(inputs_stack_offsets, &vector_stack_offset, &w_stack_offset); svm_unpack_node_uchar2(ouptuts_stack_offsets, &value_stack_offset, &color_stack_offset); - float3 vector = stack_load_float3(stack, vector_stack_offset); - float w = stack_load_float(stack, w_stack_offset); + float3 vector = stack_load_float3(svm, vector_stack_offset); + float w = stack_load_float(svm, w_stack_offset); if (stack_valid(color_stack_offset)) { float3 color; @@ -40,7 +40,7 @@ ccl_device_noinline void svm_node_tex_white_noise(KernelGlobals kg, kernel_assert(0); break; } - stack_store_float3(stack, color_stack_offset, color); + stack_store_float3(svm, color_stack_offset, color); } if (stack_valid(value_stack_offset)) { @@ -63,7 +63,7 @@ ccl_device_noinline void svm_node_tex_white_noise(KernelGlobals kg, kernel_assert(0); break; } - stack_store_float(stack, value_stack_offset, value); + stack_store_float(svm, value_stack_offset, value); } } diff --git a/intern/cycles/kernel/svm/wireframe.h b/intern/cycles/kernel/svm/wireframe.h index 172dd60c0b0..f955c8d728b 100644 --- a/intern/cycles/kernel/svm/wireframe.h +++ b/intern/cycles/kernel/svm/wireframe.h @@ -73,7 +73,7 @@ ccl_device_inline float wireframe(KernelGlobals kg, ccl_device_noinline void svm_node_wireframe(KernelGlobals kg, ccl_private ShaderData *sd, - ccl_private float *stack, + ccl_private SVMState *svm, uint4 node) { uint in_size = node.y; @@ -82,7 +82,7 @@ ccl_device_noinline void svm_node_wireframe(KernelGlobals kg, svm_unpack_node_uchar2(node.w, &use_pixel_size, &bump_offset); /* Input Data */ - float size = stack_load_float(stack, in_size); + float size = stack_load_float(svm, in_size); int pixel_size = (int)use_pixel_size; /* Calculate wireframe */ @@ -100,7 +100,7 @@ ccl_device_noinline void svm_node_wireframe(KernelGlobals kg, } if (stack_valid(out_fac)) - stack_store_float(stack, out_fac, f); + stack_store_float(svm, out_fac, f); } CCL_NAMESPACE_END -- 2.30.2