griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Revert Cycles SVM state cleanup due to Mac ARM test timeout

Browse Source 
Not sure what is happening here, needs to be checked by someone on Mac.
Let's revert for now, it's not like this is a critical change.

Pull Request: https://projects.blender.org/blender/blender/pulls/110443
This commit is contained in:
Lukas Stockner
2024-10-08 00:33:56 +02:00
parent 7a4329320f
commit 11ae08157e
48 changed files with 990 additions and 936 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
intern/cycles/kernel/svm/ao.h
View File

@@ -96,7 +96,7 @@ ccl_device_noinline
svm_node_ao(KernelGlobals kg,
ConstIntegratorGenericState state,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint flags, dist_offset, normal_offset, out_ao_offset;
@@ -109,8 +109,8 @@ ccl_device_noinline
IF_KERNEL_NODES_FEATURE(RAYTRACE)
{
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;
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;
# ifdef __KERNEL_OPTIX__
ao = optixDirectCall<float>(0, kg, state, sd, normal, dist, samples, flags);
@@ -120,12 +120,12 @@ ccl_device_noinline
}
if (stack_valid(out_ao_offset)) {
stack_store_float(svm, out_ao_offset, ao);
stack_store_float(stack, out_ao_offset, ao);
}
if (stack_valid(out_color_offset)) {
float3 color = stack_load_float3(svm, color_offset);
stack_store_float3(svm, out_color_offset, ao * color);
float3 color = stack_load_float3(stack, color_offset);
stack_store_float3(stack, out_color_offset, ao * color);
}
}

8
intern/cycles/kernel/svm/aov.h
View File

@@ -21,13 +21,13 @@ template<uint node_feature_mask, typename ConstIntegratorGenericState>
ccl_device void svm_node_aov_color(KernelGlobals kg,
ConstIntegratorGenericState state,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node,
ccl_global float *render_buffer)
{
IF_KERNEL_NODES_FEATURE(AOV)
{
const float3 val = stack_load_float3(svm, node.y);
const float3 val = stack_load_float3(stack, node.y);
film_write_aov_pass_color(kg, state, render_buffer, node.z, val);
}
}
@@ -36,13 +36,13 @@ template<uint node_feature_mask, typename ConstIntegratorGenericState>
ccl_device void svm_node_aov_value(KernelGlobals kg,
ConstIntegratorGenericState state,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node,
ccl_global float *render_buffer)
{
IF_KERNEL_NODES_FEATURE(AOV)
{
const float val = stack_load_float(svm, node.y);
const float val = stack_load_float(stack, node.y);
film_write_aov_pass_value(kg, state, render_buffer, node.z, val);
}
}

116
intern/cycles/kernel/svm/attribute.h
View File

@@ -40,7 +40,7 @@ ccl_device AttributeDescriptor svm_node_attr_init(KernelGlobals kg,
template<uint node_feature_mask>
ccl_device_noinline void svm_node_attr(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, f);
stack_store_float(stack, out_offset, f);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
const float3 f = volume_attribute_value_to_float3(value);
stack_store_float3(svm, out_offset, f);
stack_store_float3(stack, out_offset, f);
}
else {
const float f = volume_attribute_value_to_alpha(value);
stack_store_float(svm, out_offset, f);
stack_store_float(stack, 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(svm, out_offset, make_float3(1.0f - sd->u - sd->v, sd->u, 0.0f));
stack_store_float3(stack, 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(svm, out_offset, average(f));
stack_store_float(stack, out_offset, average(f));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, f);
stack_store_float3(stack, out_offset, f);
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, f);
stack_store_float(stack, out_offset, f);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(f, f, f));
stack_store_float3(stack, out_offset, make_float3(f, f, f));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, f.x);
stack_store_float(stack, out_offset, f.x);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(f.x, f.y, 0.0f));
stack_store_float3(stack, out_offset, make_float3(f.x, f.y, 0.0f));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, average(float4_to_float3(f)));
stack_store_float(stack, out_offset, average(float4_to_float3(f)));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, float4_to_float3(f));
stack_store_float3(stack, out_offset, float4_to_float3(f));
}
else {
stack_store_float(svm, out_offset, f.w);
stack_store_float(stack, 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(svm, out_offset, average(f));
stack_store_float(stack, out_offset, average(f));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, f);
stack_store_float3(stack, out_offset, f);
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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 SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, 0.0f);
stack_store_float(stack, out_offset, 0.0f);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, average(f));
stack_store_float(stack, out_offset, average(f));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, f);
stack_store_float3(stack, out_offset, f);
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, f + dx);
stack_store_float(stack, out_offset, f + dx);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(f + dx, f + dx, f + dx));
stack_store_float3(stack, out_offset, make_float3(f + dx, f + dx, f + dx));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, f.x + dx.x);
stack_store_float(stack, out_offset, f.x + dx.x);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(f.x + dx.x, f.y + dx.y, 0.0f));
stack_store_float3(stack, out_offset, make_float3(f.x + dx.x, f.y + dx.y, 0.0f));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, average(float4_to_float3(f + dx)));
stack_store_float(stack, out_offset, average(float4_to_float3(f + dx)));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, float4_to_float3(f + dx));
stack_store_float3(stack, out_offset, float4_to_float3(f + dx));
}
else {
stack_store_float(svm, out_offset, f.w + dx.w);
stack_store_float(stack, 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(svm, out_offset, average(f + dx));
stack_store_float(stack, out_offset, average(f + dx));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, f + dx);
stack_store_float3(stack, out_offset, f + dx);
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, out_offset, 1.0f);
}
}
}
ccl_device_noinline void svm_node_attr_bump_dy(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, 0.0f);
stack_store_float(stack, out_offset, 0.0f);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, average(f));
stack_store_float(stack, out_offset, average(f));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, f);
stack_store_float3(stack, out_offset, f);
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, f + dy);
stack_store_float(stack, out_offset, f + dy);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(f + dy, f + dy, f + dy));
stack_store_float3(stack, out_offset, make_float3(f + dy, f + dy, f + dy));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, f.x + dy.x);
stack_store_float(stack, out_offset, f.x + dy.x);
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, make_float3(f.x + dy.x, f.y + dy.y, 0.0f));
stack_store_float3(stack, out_offset, make_float3(f.x + dy.x, f.y + dy.y, 0.0f));
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, 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(svm, out_offset, average(float4_to_float3(f + dy)));
stack_store_float(stack, out_offset, average(float4_to_float3(f + dy)));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, float4_to_float3(f + dy));
stack_store_float3(stack, out_offset, float4_to_float3(f + dy));
}
else {
stack_store_float(svm, out_offset, f.w + dy.w);
stack_store_float(stack, 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(svm, out_offset, average(f + dy));
stack_store_float(stack, out_offset, average(f + dy));
}
else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
stack_store_float3(svm, out_offset, f + dy);
stack_store_float3(stack, out_offset, f + dy);
}
else {
stack_store_float(svm, out_offset, 1.0f);
stack_store_float(stack, out_offset, 1.0f);
}
}
}

8
intern/cycles/kernel/svm/bevel.h
View File

@@ -289,7 +289,7 @@ ccl_device_noinline
svm_node_bevel(KernelGlobals kg,
ConstIntegratorGenericState state,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint num_samples, radius_offset, normal_offset, out_offset;
@@ -299,7 +299,7 @@ ccl_device_noinline
IF_KERNEL_NODES_FEATURE(RAYTRACE)
{
float radius = stack_load_float(svm, radius_offset);
float radius = stack_load_float(stack, radius_offset);
# ifdef __KERNEL_OPTIX__
bevel_N = optixDirectCall<float3>(1, kg, state, sd, radius, num_samples);
@@ -309,12 +309,12 @@ ccl_device_noinline
if (stack_valid(normal_offset)) {
/* Preserve input normal. */
float3 ref_N = stack_load_float3(svm, normal_offset);
float3 ref_N = stack_load_float3(stack, normal_offset);
bevel_N = normalize(ref_N + (bevel_N - sd->N));
}
}
stack_store_float3(svm, out_offset, bevel_N);
stack_store_float3(stack, out_offset, bevel_N);
}
#endif /* __SHADER_RAYTRACE__ */

6
intern/cycles/kernel/svm/blackbody.h
View File

@@ -15,17 +15,17 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_blackbody(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint temperature_offset,
uint col_offset)
{
/* Input */
float temperature = stack_load_float(svm, temperature_offset);
float temperature = stack_load_float(stack, 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(svm, col_offset, color_rgb);
stack_store_float3(stack, col_offset, color_rgb);
}
CCL_NAMESPACE_END

37
intern/cycles/kernel/svm/brick.h
View File

@@ -62,14 +62,12 @@ ccl_device_noinline_cpu float2 svm_brick(float3 p,
return make_float2(tint, mortar);
}
ccl_device_noinline void svm_node_tex_brick(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_tex_brick(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
uint4 node2 = read_node(kg, svm);
uint4 node3 = read_node(kg, svm);
uint4 node4 = read_node(kg, svm);
uint4 node2 = read_node(kg, &offset);
uint4 node3 = read_node(kg, &offset);
uint4 node4 = read_node(kg, &offset);
/* Input and Output Sockets */
uint co_offset, color1_offset, color2_offset, mortar_offset, scale_offset;
@@ -87,18 +85,18 @@ ccl_device_noinline void svm_node_tex_brick(KernelGlobals kg,
svm_unpack_node_uchar2(node2.x, &offset_frequency, &squash_frequency);
float3 co = stack_load_float3(svm, co_offset);
float3 co = stack_load_float3(stack, co_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);
float3 color1 = stack_load_float3(stack, color1_offset);
float3 color2 = stack_load_float3(stack, color2_offset);
float3 mortar = stack_load_float3(stack, mortar_offset);
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 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 offset_amount = __int_as_float(node3.z);
float squash_amount = __int_as_float(node3.w);
@@ -122,9 +120,10 @@ ccl_device_noinline void svm_node_tex_brick(KernelGlobals kg,
}
if (stack_valid(color_offset))
stack_store_float3(svm, color_offset, color1 * (1.0f - f) + mortar * f);
stack_store_float3(stack, color_offset, color1 * (1.0f - f) + mortar * f);
if (stack_valid(fac_offset))
stack_store_float(svm, fac_offset, f);
stack_store_float(stack, fac_offset, f);
return offset;
}
CCL_NAMESPACE_END

15
intern/cycles/kernel/svm/brightness.h
View File

@@ -8,23 +8,20 @@
CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_brightness(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint in_color,
uint out_color,
uint node)
ccl_device_noinline void svm_node_brightness(
ccl_private ShaderData *sd, ccl_private float *stack, uint in_color, uint out_color, uint node)
{
uint bright_offset, contrast_offset;
float3 color = stack_load_float3(svm, in_color);
float3 color = stack_load_float3(stack, in_color);
svm_unpack_node_uchar2(node, &bright_offset, &contrast_offset);
float brightness = stack_load_float(svm, bright_offset);
float contrast = stack_load_float(svm, contrast_offset);
float brightness = stack_load_float(stack, bright_offset);
float contrast = stack_load_float(stack, contrast_offset);
color = svm_brightness_contrast(color, brightness, contrast);
if (stack_valid(out_color))
stack_store_float3(svm, out_color, color);
stack_store_float3(stack, out_color, color);
}
CCL_NAMESPACE_END

16
intern/cycles/kernel/svm/bump.h
View File

@@ -10,12 +10,12 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_enter_bump_eval(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint offset)
{
/* save state */
stack_store_float3(svm, offset + 0, sd->P);
stack_store_float(svm, offset + 3, sd->dP);
stack_store_float3(stack, offset + 0, sd->P);
stack_store_float(stack, offset + 3, sd->dP);
/* set state as if undisplaced */
const AttributeDescriptor desc = find_attribute(kg, sd, ATTR_STD_POSITION_UNDISPLACED);
@@ -32,19 +32,19 @@ ccl_device_noinline void svm_node_enter_bump_eval(KernelGlobals kg,
sd->dP = differential_make_compact(dP);
/* Save the full differential, the compact form isn't enough for svm_node_set_bump. */
stack_store_float3(svm, offset + 4, dP.dx);
stack_store_float3(svm, offset + 7, dP.dy);
stack_store_float3(stack, offset + 4, dP.dx);
stack_store_float3(stack, offset + 7, dP.dy);
}
}
ccl_device_noinline void svm_node_leave_bump_eval(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint offset)
{
/* restore state */
sd->P = stack_load_float3(svm, offset + 0);
sd->dP = stack_load_float(svm, offset + 3);
sd->P = stack_load_float3(stack, offset + 0);
sd->dP = stack_load_float(stack, offset + 3);
}
CCL_NAMESPACE_END

8
intern/cycles/kernel/svm/camera.h
View File

@@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_camera(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint out_vector,
uint out_zdepth,
uint out_distance)
@@ -23,15 +23,15 @@ ccl_device_noinline void svm_node_camera(KernelGlobals kg,
distance = len(vector);
if (stack_valid(out_vector)) {
stack_store_float3(svm, out_vector, normalize(vector));
stack_store_float3(stack, out_vector, normalize(vector));
}
if (stack_valid(out_zdepth)) {
stack_store_float(svm, out_zdepth, zdepth);
stack_store_float(stack, out_zdepth, zdepth);
}
if (stack_valid(out_distance)) {
stack_store_float(svm, out_distance, distance);
stack_store_float(stack, out_distance, distance);
}
}

14
intern/cycles/kernel/svm/checker.h
View File

@@ -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 SVMState *svm,
ccl_private float *stack,
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(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);
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);
float f = svm_checker(co * scale);
if (stack_valid(color_offset))
stack_store_float3(svm, color_offset, (f == 1.0f) ? color1 : color2);
stack_store_float3(stack, color_offset, (f == 1.0f) ? color1 : color2);
if (stack_valid(fac_offset))
stack_store_float(svm, fac_offset, f);
stack_store_float(stack, fac_offset, f);
}
CCL_NAMESPACE_END

26
intern/cycles/kernel/svm/clamp.h
View File

@@ -8,28 +8,30 @@ CCL_NAMESPACE_BEGIN
/* Clamp Node */
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)
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)
{
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, svm);
uint4 defaults = read_node(kg, &offset);
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);
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);
if (type == NODE_CLAMP_RANGE && (min > max)) {
stack_store_float(svm, result_stack_offset, clamp(value, max, min));
stack_store_float(stack, result_stack_offset, clamp(value, max, min));
}
else {
stack_store_float(svm, result_stack_offset, clamp(value, min, max));
stack_store_float(stack, result_stack_offset, clamp(value, min, max));
}
return offset;
}
CCL_NAMESPACE_END

317
intern/cycles/kernel/svm/closure.h
View File

@@ -15,17 +15,17 @@ CCL_NAMESPACE_BEGIN
/* Closure Nodes */
ccl_device_inline void svm_node_closure_bsdf_skip(KernelGlobals kg,
ccl_private SVMState *svm,
uint type)
ccl_device_inline int svm_node_closure_bsdf_skip(KernelGlobals kg, int offset, uint type)
{
if (type == CLOSURE_BSDF_PRINCIPLED_ID) {
/* Read all principled BSDF extra data to get the right offset. */
read_node(kg, svm);
read_node(kg, svm);
read_node(kg, svm);
read_node(kg, svm);
read_node(kg, &offset);
read_node(kg, &offset);
read_node(kg, &offset);
read_node(kg, &offset);
}
return offset;
}
template<uint node_feature_mask, ShaderType shader_type>
@@ -34,50 +34,48 @@ ccl_device_noinline
#else
ccl_device
#endif
void
int
svm_node_closure_bsdf(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
Spectrum closure_weight,
uint4 node,
uint32_t path_flag)
uint32_t path_flag,
int offset)
{
uint type, param1_offset, param2_offset;
uint mix_weight_offset;
svm_unpack_node_uchar4(node.y, &type, &param1_offset, &param2_offset, &mix_weight_offset);
float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(svm, mix_weight_offset) :
float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(stack, mix_weight_offset) :
1.0f);
Spectrum 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, svm);
uint4 data_node = read_node(kg, &offset);
/* 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) {
svm_node_closure_bsdf_skip(kg, svm, type);
return;
return svm_node_closure_bsdf_skip(kg, offset, type);
}
}
else IF_KERNEL_NODES_FEATURE(EMISSION) {
if (type != CLOSURE_BSDF_PRINCIPLED_ID) {
/* Only principled BSDF can have emission. */
svm_node_closure_bsdf_skip(kg, svm, type);
return;
return svm_node_closure_bsdf_skip(kg, offset, type);
}
}
else {
svm_node_closure_bsdf_skip(kg, svm, type);
return;
return svm_node_closure_bsdf_skip(kg, offset, type);
}
float3 N = stack_valid(data_node.x) ? stack_load_float3(svm, data_node.x) : sd->N;
float3 N = stack_valid(data_node.x) ? stack_load_float3(stack, data_node.x) : sd->N;
N = safe_normalize_fallback(N, sd->N);
float param1 = (stack_valid(param1_offset)) ? stack_load_float(svm, param1_offset) :
float param1 = (stack_valid(param1_offset)) ? stack_load_float(stack, param1_offset) :
__uint_as_float(node.z);
float param2 = (stack_valid(param2_offset)) ? stack_load_float(svm, param2_offset) :
float param2 = (stack_valid(param2_offset)) ? stack_load_float(stack, param2_offset) :
__uint_as_float(node.w);
switch (type) {
@@ -88,9 +86,9 @@ ccl_device
anisotropic_rotation_offset, coat_tint_offset, coat_normal_offset, alpha_offset,
emission_strength_offset, emission_offset, thinfilm_thickness_offset,
diffuse_roughness_offset;
uint4 data_node2 = read_node(kg, svm);
uint4 data_node2 = read_node(kg, &offset);
float3 T = stack_load_float3(svm, data_node.y);
float3 T = stack_load_float3(stack, data_node.y);
svm_unpack_node_uchar4(data_node.z,
&specular_ior_level_offset,
&roughness_offset,
@@ -115,21 +113,21 @@ ccl_device
// get Disney principled parameters
float metallic = saturatef(param1);
float subsurface_weight = saturatef(param2);
float specular_ior_level = max(stack_load_float(svm, specular_ior_level_offset), 0.0f);
float roughness = saturatef(stack_load_float(svm, roughness_offset));
float specular_ior_level = max(stack_load_float(stack, specular_ior_level_offset), 0.0f);
float roughness = saturatef(stack_load_float(stack, roughness_offset));
Spectrum specular_tint = rgb_to_spectrum(
max(stack_load_float3(svm, specular_tint_offset), zero_float3()));
float anisotropic = saturatef(stack_load_float(svm, anisotropic_offset));
float sheen_weight = max(stack_load_float(svm, sheen_weight_offset), 0.0f);
float3 sheen_tint = max(stack_load_float3(svm, sheen_tint_offset), zero_float3());
float sheen_roughness = saturatef(stack_load_float(svm, sheen_roughness_offset));
float coat_weight = fmaxf(stack_load_float(svm, coat_weight_offset), 0.0f);
float coat_roughness = saturatef(stack_load_float(svm, coat_roughness_offset));
float coat_ior = fmaxf(stack_load_float(svm, coat_ior_offset), 1.0f);
float3 coat_tint = max(stack_load_float3(svm, coat_tint_offset), zero_float3());
float transmission_weight = saturatef(stack_load_float(svm, transmission_weight_offset));
float anisotropic_rotation = stack_load_float(svm, anisotropic_rotation_offset);
float ior = fmaxf(stack_load_float(svm, eta_offset), 1e-5f);
max(stack_load_float3(stack, specular_tint_offset), zero_float3()));
float anisotropic = saturatef(stack_load_float(stack, anisotropic_offset));
float sheen_weight = max(stack_load_float(stack, sheen_weight_offset), 0.0f);
float3 sheen_tint = max(stack_load_float3(stack, sheen_tint_offset), zero_float3());
float sheen_roughness = saturatef(stack_load_float(stack, sheen_roughness_offset));
float coat_weight = fmaxf(stack_load_float(stack, coat_weight_offset), 0.0f);
float coat_roughness = saturatef(stack_load_float(stack, coat_roughness_offset));
float coat_ior = fmaxf(stack_load_float(stack, coat_ior_offset), 1.0f);
float3 coat_tint = max(stack_load_float3(stack, coat_tint_offset), zero_float3());
float transmission_weight = saturatef(stack_load_float(stack, transmission_weight_offset));
float anisotropic_rotation = stack_load_float(stack, anisotropic_rotation_offset);
float ior = fmaxf(stack_load_float(stack, eta_offset), 1e-5f);
ClosureType distribution = (ClosureType)data_node2.y;
#ifdef __SUBSURFACE__
@@ -138,14 +136,14 @@ ccl_device
float3 valid_reflection_N = maybe_ensure_valid_specular_reflection(sd, N);
float3 coat_normal = stack_valid(coat_normal_offset) ?
stack_load_float3(svm, coat_normal_offset) :
stack_load_float3(stack, coat_normal_offset) :
sd->N;
coat_normal = safe_normalize_fallback(coat_normal, sd->N);
// get the base color
uint4 data_base_color = read_node(kg, svm);
uint4 data_base_color = read_node(kg, &offset);
float3 base_color = stack_valid(data_base_color.x) ?
stack_load_float3(svm, data_base_color.x) :
stack_load_float3(stack, 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));
@@ -153,25 +151,27 @@ ccl_device
const float3 clamped_base_color = min(base_color, one_float3());
// get the subsurface scattering data
uint4 data_subsurf = read_node(kg, svm);
uint4 data_subsurf = read_node(kg, &offset);
uint4 data_alpha_emission_thin = read_node(kg, svm);
uint4 data_alpha_emission_thin = read_node(kg, &offset);
svm_unpack_node_uchar4(data_alpha_emission_thin.x,
&alpha_offset,
&emission_strength_offset,
&emission_offset,
&thinfilm_thickness_offset);
float alpha = stack_valid(alpha_offset) ? stack_load_float(svm, alpha_offset) :
float alpha = stack_valid(alpha_offset) ? stack_load_float(stack, alpha_offset) :
__uint_as_float(data_alpha_emission_thin.y);
alpha = saturatef(alpha);
float emission_strength = stack_valid(emission_strength_offset) ?
stack_load_float(svm, emission_strength_offset) :
stack_load_float(stack, emission_strength_offset) :
__uint_as_float(data_alpha_emission_thin.z);
float3 emission = stack_load_float3(svm, emission_offset) * emission_strength;
float3 emission = stack_load_float3(stack, emission_offset) * emission_strength;
float thinfilm_thickness = fmaxf(stack_load_float(svm, thinfilm_thickness_offset), 1e-5f);
float thinfilm_ior = fmaxf(stack_load_float(svm, data_alpha_emission_thin.w), 1e-5f);
float thinfilm_thickness = fmaxf(stack_load_float(stack, thinfilm_thickness_offset), 1e-5f);
float thinfilm_ior = fmaxf(stack_load_float(stack, data_alpha_emission_thin.w), 1e-5f);
Spectrum weight = closure_weight * mix_weight;
float alpha_x = sqr(roughness), alpha_y = sqr(roughness);
if (anisotropic > 0.0f) {
@@ -397,8 +397,8 @@ ccl_device
ccl_private Bssrdf *bssrdf = bssrdf_alloc(
sd, rgb_to_spectrum(clamped_base_color) * subsurface_weight * weight);
if (bssrdf) {
float3 subsurface_radius = stack_load_float3(svm, data_subsurf.y);
float subsurface_scale = stack_load_float(svm, data_subsurf.z);
float3 subsurface_radius = stack_load_float3(stack, data_subsurf.y);
float subsurface_scale = stack_load_float(stack, data_subsurf.z);
bssrdf->radius = rgb_to_spectrum(max(subsurface_radius * subsurface_scale, zero_float3()));
bssrdf->albedo = rgb_to_spectrum(clamped_base_color);
@@ -407,9 +407,9 @@ ccl_device
/* IOR is clamped to [1.01..3.8] inside bssrdf_setup */
bssrdf->ior = eta;
/* Anisotropy is clamped to [0.0..0.9] inside bssrdf_setup */
bssrdf->anisotropy = stack_load_float(svm, data_subsurf.w);
bssrdf->anisotropy = stack_load_float(stack, data_subsurf.w);
if (subsurface_method == CLOSURE_BSSRDF_RANDOM_WALK_SKIN_ID) {
bssrdf->ior = stack_load_float(svm, data_subsurf.x);
bssrdf->ior = stack_load_float(stack, data_subsurf.x);
}
/* setup bsdf */
@@ -427,7 +427,8 @@ ccl_device
if (bsdf) {
bsdf->N = N;
const float diffuse_roughness = saturatef(stack_load_float(svm, diffuse_roughness_offset));
const float diffuse_roughness = saturatef(
stack_load_float(stack, diffuse_roughness_offset));
/* setup bsdf */
if (diffuse_roughness < CLOSURE_WEIGHT_CUTOFF) {
sd->flag |= bsdf_diffuse_setup((ccl_private DiffuseBsdf *)bsdf);
@@ -441,6 +442,7 @@ ccl_device
break;
}
case CLOSURE_BSDF_DIFFUSE_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private OrenNayarBsdf *bsdf = (ccl_private OrenNayarBsdf *)bsdf_alloc(
sd, sizeof(OrenNayarBsdf), weight);
@@ -454,13 +456,14 @@ ccl_device
}
else {
bsdf->roughness = roughness;
const Spectrum color = saturate(rgb_to_spectrum(stack_load_float3(svm, data_node.y)));
const Spectrum color = saturate(rgb_to_spectrum(stack_load_float3(stack, data_node.y)));
sd->flag |= bsdf_oren_nayar_setup(sd, bsdf, color);
}
}
break;
}
case CLOSURE_BSDF_TRANSLUCENT_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private DiffuseBsdf *bsdf = (ccl_private DiffuseBsdf *)bsdf_alloc(
sd, sizeof(DiffuseBsdf), weight);
@@ -471,6 +474,7 @@ ccl_device
break;
}
case CLOSURE_BSDF_TRANSPARENT_ID: {
Spectrum weight = closure_weight * mix_weight;
bsdf_transparent_setup(sd, weight, path_flag);
break;
}
@@ -489,7 +493,7 @@ ccl_device
node.z, &base_ior_offset, &edge_tint_k_offset, &rotation_offset, &tangent_offset);
float3 valid_reflection_N = maybe_ensure_valid_specular_reflection(sd, N);
float3 T = stack_load_float3(svm, tangent_offset);
float3 T = stack_load_float3(stack, tangent_offset);
const float anisotropy = saturatef(param2);
const float roughness = saturatef(param1);
float alpha_x = sqr(roughness), alpha_y = sqr(roughness);
@@ -497,7 +501,7 @@ ccl_device
float aspect = sqrtf(1.0f - anisotropy * 0.9f);
alpha_x /= aspect;
alpha_y *= aspect;
float anisotropic_rotation = stack_load_float(svm, rotation_offset);
float anisotropic_rotation = stack_load_float(stack, rotation_offset);
if (anisotropic_rotation != 0.0f) {
T = rotate_around_axis(T, N, anisotropic_rotation * M_2PI_F);
}
@@ -524,8 +528,8 @@ ccl_device
ccl_private FresnelConductor *fresnel = (ccl_private FresnelConductor *)
closure_alloc_extra(sd, sizeof(FresnelConductor));
const float3 n = max(stack_load_float3(svm, base_ior_offset), zero_float3());
const float3 k = max(stack_load_float3(svm, edge_tint_k_offset), zero_float3());
const float3 n = max(stack_load_float3(stack, base_ior_offset), zero_float3());
const float3 k = max(stack_load_float3(stack, edge_tint_k_offset), zero_float3());
fresnel->n = rgb_to_spectrum(n);
fresnel->k = rgb_to_spectrum(k);
@@ -535,8 +539,8 @@ ccl_device
ccl_private FresnelF82Tint *fresnel = (ccl_private FresnelF82Tint *)closure_alloc_extra(
sd, sizeof(FresnelF82Tint));
const float3 color = saturate(stack_load_float3(svm, base_ior_offset));
const float3 tint = saturate(stack_load_float3(svm, edge_tint_k_offset));
const float3 color = saturate(stack_load_float3(stack, base_ior_offset));
const float3 tint = saturate(stack_load_float3(stack, edge_tint_k_offset));
fresnel->f0 = rgb_to_spectrum(color);
const Spectrum f82 = rgb_to_spectrum(tint);
@@ -546,8 +550,9 @@ ccl_device
break;
}
case CLOSURE_BSDF_RAY_PORTAL_ID: {
float3 position = stack_load_float3(svm, data_node.y);
float3 direction = stack_load_float3(svm, data_node.z);
Spectrum weight = closure_weight * mix_weight;
float3 position = stack_load_float3(stack, data_node.y);
float3 direction = stack_load_float3(stack, data_node.z);
bsdf_ray_portal_setup(sd, weight, path_flag, position, direction);
break;
}
@@ -559,6 +564,7 @@ ccl_device
if (!kernel_data.integrator.caustics_reflective && (path_flag & PATH_RAY_DIFFUSE))
break;
#endif
Spectrum weight = closure_weight * mix_weight;
ccl_private MicrofacetBsdf *bsdf = (ccl_private MicrofacetBsdf *)bsdf_alloc(
sd, sizeof(MicrofacetBsdf), weight);
@@ -580,10 +586,10 @@ ccl_device
bsdf->alpha_y = roughness;
}
else {
bsdf->T = stack_load_float3(svm, data_node.w);
bsdf->T = stack_load_float3(stack, data_node.w);
/* rotate tangent */
float rotation = stack_load_float(svm, data_node.y);
float rotation = stack_load_float(stack, data_node.y);
if (rotation != 0.0f) {
bsdf->T = rotate_around_axis(bsdf->T, bsdf->N, rotation * M_2PI_F);
}
@@ -609,7 +615,7 @@ ccl_device
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
if (type == CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID) {
kernel_assert(stack_valid(data_node.z));
const Spectrum color = max(rgb_to_spectrum(stack_load_float3(svm, data_node.z)),
const Spectrum color = max(rgb_to_spectrum(stack_load_float3(stack, data_node.z)),
zero_spectrum());
bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd, color);
}
@@ -623,6 +629,7 @@ ccl_device
if (!kernel_data.integrator.caustics_refractive && (path_flag & PATH_RAY_DIFFUSE))
break;
#endif
Spectrum weight = closure_weight * mix_weight;
ccl_private MicrofacetBsdf *bsdf = (ccl_private MicrofacetBsdf *)bsdf_alloc(
sd, sizeof(MicrofacetBsdf), weight);
@@ -681,7 +688,7 @@ ccl_device
fresnel->f0 = make_float3(F0_from_ior(ior));
fresnel->f90 = one_spectrum();
fresnel->exponent = -ior;
const float3 color = max(stack_load_float3(svm, data_node.y), zero_float3());
const float3 color = max(stack_load_float3(stack, data_node.y), zero_float3());
fresnel->reflection_tint = reflective_caustics ? rgb_to_spectrum(color) : zero_spectrum();
fresnel->transmission_tint = refractive_caustics ? rgb_to_spectrum(color) :
zero_spectrum();
@@ -701,6 +708,7 @@ ccl_device
break;
}
case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private VelvetBsdf *bsdf = (ccl_private VelvetBsdf *)bsdf_alloc(
sd, sizeof(VelvetBsdf), weight);
@@ -713,6 +721,7 @@ ccl_device
break;
}
case CLOSURE_BSDF_SHEEN_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private SheenBsdf *bsdf = (ccl_private SheenBsdf *)bsdf_alloc(
sd, sizeof(SheenBsdf), weight);
@@ -731,6 +740,7 @@ ccl_device
ATTR_FALLTHROUGH;
#endif
case CLOSURE_BSDF_DIFFUSE_TOON_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private ToonBsdf *bsdf = (ccl_private ToonBsdf *)bsdf_alloc(
sd, sizeof(ToonBsdf), weight);
@@ -752,14 +762,16 @@ ccl_device
# ifdef __PRINCIPLED_HAIR__
case CLOSURE_BSDF_HAIR_CHIANG_ID:
case CLOSURE_BSDF_HAIR_HUANG_ID: {
uint4 data_node2 = read_node(kg, svm);
uint4 data_node3 = read_node(kg, svm);
uint4 data_node4 = read_node(kg, svm);
uint4 data_node2 = read_node(kg, &offset);
uint4 data_node3 = read_node(kg, &offset);
uint4 data_node4 = read_node(kg, &offset);
Spectrum weight = closure_weight * mix_weight;
uint offset_ofs, ior_ofs, color_ofs, parametrization;
svm_unpack_node_uchar4(data_node.y, &offset_ofs, &ior_ofs, &color_ofs, &parametrization);
float alpha = stack_load_float_default(svm, offset_ofs, data_node.z);
float ior = stack_load_float_default(svm, ior_ofs, data_node.w);
float alpha = stack_load_float_default(stack, offset_ofs, data_node.z);
float ior = stack_load_float_default(stack, ior_ofs, data_node.w);
uint tint_ofs, melanin_ofs, melanin_redness_ofs, absorption_coefficient_ofs;
svm_unpack_node_uchar4(data_node2.x,
@@ -778,7 +790,7 @@ ccl_device
random = primitive_surface_attribute_float(kg, sd, attr_descr_random, NULL, NULL);
}
else {
random = stack_load_float_default(svm, random_ofs, data_node3.y);
random = stack_load_float_default(stack, random_ofs, data_node3.y);
}
/* Random factors range: [-randomization/2, +randomization/2]. */
@@ -786,23 +798,24 @@ ccl_device
float factor_random_roughness = 1.0f + 2.0f * (random - 0.5f) * random_roughness;
float roughness = param1 * factor_random_roughness;
float radial_roughness = (type == CLOSURE_BSDF_HAIR_CHIANG_ID) ?
stack_load_float_default(svm, shared_ofs2, data_node4.y) *
stack_load_float_default(stack, shared_ofs2, data_node4.y) *
factor_random_roughness :
roughness;
Spectrum sigma;
switch (parametrization) {
case NODE_PRINCIPLED_HAIR_DIRECT_ABSORPTION: {
float3 absorption_coefficient = stack_load_float3(svm, absorption_coefficient_ofs);
float3 absorption_coefficient = stack_load_float3(stack, absorption_coefficient_ofs);
sigma = rgb_to_spectrum(absorption_coefficient);
break;
}
case NODE_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION: {
float melanin = stack_load_float_default(svm, melanin_ofs, data_node2.z);
float melanin_redness = stack_load_float_default(svm, melanin_redness_ofs, data_node2.w);
float melanin = stack_load_float_default(stack, melanin_ofs, data_node2.z);
float melanin_redness = stack_load_float_default(
stack, melanin_redness_ofs, data_node2.w);
/* Randomize melanin. */
float random_color = stack_load_float_default(svm, random_color_ofs, data_node3.z);
float random_color = stack_load_float_default(stack, 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;
@@ -817,7 +830,7 @@ ccl_device
pheomelanin);
/* Optional tint. */
float3 tint = stack_load_float3(svm, tint_ofs);
float3 tint = stack_load_float3(stack, tint_ofs);
Spectrum tint_sigma = bsdf_principled_hair_sigma_from_reflectance(rgb_to_spectrum(tint),
radial_roughness);
@@ -825,7 +838,7 @@ ccl_device
break;
}
case NODE_PRINCIPLED_HAIR_REFLECTANCE: {
float3 color = stack_load_float3(svm, color_ofs);
float3 color = stack_load_float3(stack, color_ofs);
sigma = bsdf_principled_hair_sigma_from_reflectance(rgb_to_spectrum(color),
radial_roughness);
break;
@@ -843,7 +856,7 @@ ccl_device
sd, sizeof(ChiangHairBSDF), weight);
if (bsdf) {
/* Remap Coat value to [0, 100]% of Roughness. */
float coat = stack_load_float_default(svm, shared_ofs1, data_node3.w);
float coat = stack_load_float_default(stack, shared_ofs1, data_node3.w);
float m0_roughness = 1.0f - clamp(coat, 0.0f, 1.0f);
bsdf->v = roughness;
@@ -860,9 +873,9 @@ ccl_device
kernel_assert(type == CLOSURE_BSDF_HAIR_HUANG_ID);
uint R_ofs, TT_ofs, TRT_ofs, unused;
svm_unpack_node_uchar4(data_node4.x, &R_ofs, &TT_ofs, &TRT_ofs, &unused);
float R = stack_load_float_default(svm, R_ofs, data_node4.y);
float TT = stack_load_float_default(svm, TT_ofs, data_node4.z);
float TRT = stack_load_float_default(svm, TRT_ofs, data_node4.w);
float R = stack_load_float_default(stack, R_ofs, data_node4.y);
float TT = stack_load_float_default(stack, TT_ofs, data_node4.z);
float TRT = stack_load_float_default(stack, TRT_ofs, data_node4.w);
if (R <= 0.0f && TT <= 0.0f && TRT <= 0.0f) {
break;
}
@@ -897,7 +910,7 @@ ccl_device
bsdf->extra->pixel_coverage = 0.5f * sd->dP / radius;
}
bsdf->aspect_ratio = stack_load_float_default(svm, shared_ofs1, data_node3.w);
bsdf->aspect_ratio = stack_load_float_default(stack, shared_ofs1, data_node3.w);
if (bsdf->aspect_ratio != 1.0f) {
/* Align ellipse major axis with the curve normal direction. */
const AttributeDescriptor attr_descr_normal = find_attribute(kg, sd, shared_ofs2);
@@ -917,6 +930,8 @@ ccl_device
# endif /* __PRINCIPLED_HAIR__ */
case CLOSURE_BSDF_HAIR_REFLECTION_ID:
case CLOSURE_BSDF_HAIR_TRANSMISSION_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private HairBsdf *bsdf = (ccl_private HairBsdf *)bsdf_alloc(
sd, sizeof(HairBsdf), weight);
@@ -924,10 +939,10 @@ ccl_device
bsdf->N = maybe_ensure_valid_specular_reflection(sd, N);
bsdf->roughness1 = param1;
bsdf->roughness2 = param2;
bsdf->offset = -stack_load_float(svm, data_node.y);
bsdf->offset = -stack_load_float(stack, data_node.y);
if (stack_valid(data_node.w)) {
bsdf->T = normalize(stack_load_float3(svm, data_node.w));
bsdf->T = normalize(stack_load_float3(stack, data_node.w));
}
else if (!(sd->type & PRIMITIVE_CURVE)) {
bsdf->T = normalize(sd->dPdv);
@@ -952,16 +967,17 @@ ccl_device
case CLOSURE_BSSRDF_BURLEY_ID:
case CLOSURE_BSSRDF_RANDOM_WALK_ID:
case CLOSURE_BSSRDF_RANDOM_WALK_SKIN_ID: {
Spectrum weight = closure_weight * mix_weight;
ccl_private Bssrdf *bssrdf = bssrdf_alloc(sd, weight);
if (bssrdf) {
bssrdf->radius = max(rgb_to_spectrum(stack_load_float3(svm, data_node.y) * param1),
bssrdf->radius = max(rgb_to_spectrum(stack_load_float3(stack, data_node.y) * param1),
zero_spectrum());
bssrdf->albedo = svm->closure_weight;
bssrdf->albedo = closure_weight;
bssrdf->N = maybe_ensure_valid_specular_reflection(sd, N);
bssrdf->ior = param2;
bssrdf->alpha = saturatef(stack_load_float(svm, data_node.w));
bssrdf->anisotropy = stack_load_float(svm, data_node.z);
bssrdf->alpha = saturatef(stack_load_float(stack, data_node.w));
bssrdf->anisotropy = stack_load_float(stack, data_node.z);
sd->flag |= bssrdf_setup(sd, bssrdf, path_flag, (ClosureType)type);
}
@@ -972,12 +988,15 @@ ccl_device
default:
break;
}
return offset;
}
template<ShaderType shader_type>
ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
Spectrum closure_weight,
uint4 node)
{
#ifdef __VOLUME__
@@ -988,18 +1007,18 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
uint type, density_offset, param1_offset, mix_weight_offset;
svm_unpack_node_uchar4(node.y, &type, &density_offset, &param1_offset, &mix_weight_offset);
float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(svm, mix_weight_offset) :
float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(stack, mix_weight_offset) :
1.0f);
if (mix_weight == 0.0f) {
return;
}
float density = (stack_valid(density_offset)) ? stack_load_float(svm, density_offset) :
float density = (stack_valid(density_offset)) ? stack_load_float(stack, density_offset) :
__uint_as_float(node.z);
density = mix_weight * fmaxf(density, 0.0f) * object_volume_density(kg, sd->object);
/* Compute scattering coefficient. */
Spectrum weight = svm->closure_weight;
Spectrum weight = closure_weight;
if (type == CLOSURE_VOLUME_ABSORPTION_ID) {
weight = one_spectrum() - weight;
@@ -1014,7 +1033,7 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
ccl_private HenyeyGreensteinVolume *volume = (ccl_private HenyeyGreensteinVolume *)
bsdf_alloc(sd, sizeof(HenyeyGreensteinVolume), weight);
if (volume) {
volume->g = stack_valid(param1_offset) ? stack_load_float(svm, param1_offset) :
volume->g = stack_valid(param1_offset) ? stack_load_float(stack, param1_offset) :
__uint_as_float(node.w);
sd->flag |= volume_henyey_greenstein_setup(volume);
}
@@ -1023,8 +1042,8 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
ccl_private FournierForandVolume *volume = (ccl_private FournierForandVolume *)bsdf_alloc(
sd, sizeof(FournierForandVolume), weight);
if (volume) {
const float IOR = stack_load_float(svm, param1_offset);
const float B = stack_load_float(svm, node.w);
const float IOR = stack_load_float(stack, param1_offset);
const float B = stack_load_float(stack, node.w);
sd->flag |= volume_fournier_forand_setup(volume, B, IOR);
}
} break;
@@ -1040,8 +1059,8 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
ccl_private DraineVolume *volume = (ccl_private DraineVolume *)bsdf_alloc(
sd, sizeof(DraineVolume), weight);
if (volume) {
volume->g = stack_load_float(svm, param1_offset);
volume->alpha = stack_load_float(svm, node.w);
volume->g = stack_load_float(stack, param1_offset);
volume->alpha = stack_load_float(stack, node.w);
sd->flag |= volume_draine_setup(volume);
}
} break;
@@ -1055,7 +1074,7 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
* real limit is that the values need to stay within -1<g<1, 0<a and 0<mixture<1.
* This results in the condition d > 1.67154, so we clamp it to 2 to be safe. */
const float d = max(2.0f,
stack_valid(param1_offset) ? stack_load_float(svm, param1_offset) :
stack_valid(param1_offset) ? stack_load_float(stack, param1_offset) :
__uint_as_float(node.w));
const float mixture = fast_expf(-0.599085f / (d - 0.641583f) - 0.665888f);
ccl_private HenyeyGreensteinVolume *hg = (ccl_private HenyeyGreensteinVolume *)bsdf_alloc(
@@ -1081,34 +1100,36 @@ ccl_device_noinline void svm_node_closure_volume(KernelGlobals kg,
}
template<ShaderType shader_type>
ccl_device_noinline void svm_node_principled_volume(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node,
uint32_t path_flag)
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)
{
#ifdef __VOLUME__
uint4 value_node = read_node(kg, svm);
uint4 attr_node = read_node(kg, svm);
uint4 value_node = read_node(kg, &offset);
uint4 attr_node = read_node(kg, &offset);
/* Only sum extinction for volumes, variable is shared with surface transparency. */
if (shader_type != SHADER_TYPE_VOLUME) {
return;
return offset;
}
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(svm, mix_weight_offset) :
float mix_weight = (stack_valid(mix_weight_offset) ? stack_load_float(stack, mix_weight_offset) :
1.0f);
if (mix_weight == 0.0f) {
return;
return offset;
}
/* Compute density. */
float primitive_density = 1.0f;
float density = (stack_valid(density_offset)) ? stack_load_float(svm, density_offset) :
float density = (stack_valid(density_offset)) ? stack_load_float(stack, density_offset) :
__uint_as_float(value_node.x);
density = mix_weight * fmaxf(density, 0.0f) * object_volume_density(kg, sd->object);
@@ -1123,7 +1144,7 @@ ccl_device_noinline void svm_node_principled_volume(KernelGlobals kg,
if (density > CLOSURE_WEIGHT_CUTOFF) {
/* Compute scattering color. */
Spectrum color = svm->closure_weight;
Spectrum color = closure_weight;
const AttributeDescriptor attr_color = find_attribute(kg, sd, attr_node.y);
if (attr_color.offset != ATTR_STD_NOT_FOUND) {
@@ -1135,14 +1156,14 @@ ccl_device_noinline void svm_node_principled_volume(KernelGlobals kg,
sd, sizeof(HenyeyGreensteinVolume), color * density);
if (volume) {
float anisotropy = (stack_valid(anisotropy_offset)) ?
stack_load_float(svm, anisotropy_offset) :
stack_load_float(stack, 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(svm, absorption_color_offset)),
float3 absorption_color = max(sqrt(stack_load_float3(stack, absorption_color_offset)),
zero_float3());
Spectrum zero = zero_spectrum();
@@ -1155,25 +1176,25 @@ ccl_device_noinline void svm_node_principled_volume(KernelGlobals kg,
/* Compute emission. */
if (path_flag & PATH_RAY_SHADOW) {
/* Don't need emission for shadows. */
return;
return offset;
}
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(svm, emission_offset) :
float emission = (stack_valid(emission_offset)) ? stack_load_float(stack, emission_offset) :
__uint_as_float(value_node.z);
float blackbody = (stack_valid(blackbody_offset)) ? stack_load_float(svm, blackbody_offset) :
float blackbody = (stack_valid(blackbody_offset)) ? stack_load_float(stack, blackbody_offset) :
__uint_as_float(value_node.w);
if (emission > CLOSURE_WEIGHT_CUTOFF) {
float3 emission_color = stack_load_float3(svm, emission_color_offset);
float3 emission_color = stack_load_float3(stack, emission_color_offset);
emission_setup(
sd, rgb_to_spectrum(emission * emission_color * object_volume_density(kg, sd->object)));
}
if (blackbody > CLOSURE_WEIGHT_CUTOFF) {
float T = stack_load_float(svm, temperature_offset);
float T = stack_load_float(stack, temperature_offset);
/* Add flame temperature from attribute if available. */
const AttributeDescriptor attr_temperature = find_attribute(kg, sd, attr_node.z);
@@ -1190,25 +1211,27 @@ ccl_device_noinline void 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(svm, node.w);
float3 blackbody_tint = stack_load_float3(stack, node.w);
float3 bb = blackbody_tint * intensity *
rec709_to_rgb(kg, svm_math_blackbody_color_rec709(T));
emission_setup(sd, rgb_to_spectrum(bb * object_volume_density(kg, sd->object)));
}
}
#endif
return offset;
}
ccl_device_noinline void svm_node_closure_emission(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
Spectrum closure_weight,
uint4 node)
{
uint mix_weight_offset = node.y;
Spectrum weight = svm->closure_weight;
Spectrum weight = closure_weight;
if (stack_valid(mix_weight_offset)) {
float mix_weight = stack_load_float(svm, mix_weight_offset);
float mix_weight = stack_load_float(stack, mix_weight_offset);
if (mix_weight == 0.0f) {
return;
@@ -1225,14 +1248,15 @@ ccl_device_noinline void svm_node_closure_emission(KernelGlobals kg,
}
ccl_device_noinline void svm_node_closure_background(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
Spectrum closure_weight,
uint4 node)
{
uint mix_weight_offset = node.y;
Spectrum weight = svm->closure_weight;
Spectrum weight = closure_weight;
if (stack_valid(mix_weight_offset)) {
float mix_weight = stack_load_float(svm, mix_weight_offset);
float mix_weight = stack_load_float(stack, mix_weight_offset);
if (mix_weight == 0.0f) {
return;
@@ -1245,22 +1269,23 @@ 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 SVMState *svm,
ccl_private float *stack,
Spectrum closure_weight,
uint4 node)
{
uint mix_weight_offset = node.y;
if (stack_valid(mix_weight_offset)) {
float mix_weight = stack_load_float(svm, mix_weight_offset);
float mix_weight = stack_load_float(stack, mix_weight_offset);
if (mix_weight == 0.0f) {
return;
}
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, svm->closure_weight * mix_weight);
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, closure_weight * mix_weight);
}
else {
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, svm->closure_weight);
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, closure_weight);
}
sd->flag |= SD_HOLDOUT;
@@ -1269,33 +1294,35 @@ 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 SVMState *svm, uint r, uint g, uint b)
ccl_private ShaderData *sd, ccl_private Spectrum *closure_weight, uint r, uint g, uint b)
{
svm->closure_weight = rgb_to_spectrum(
*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 SVMState *svm,
ccl_private float *stack,
ccl_private Spectrum *closure_weight,
uint weight_offset)
{
svm->closure_weight = rgb_to_spectrum(stack_load_float3(svm, weight_offset));
*closure_weight = rgb_to_spectrum(stack_load_float3(stack, weight_offset));
}
ccl_device_noinline void svm_node_emission_weight(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
ccl_private Spectrum *closure_weight,
uint4 node)
{
uint color_offset = node.y;
uint strength_offset = node.z;
float strength = stack_load_float(svm, strength_offset);
svm->closure_weight = rgb_to_spectrum(stack_load_float3(svm, color_offset)) * strength;
float strength = stack_load_float(stack, strength_offset);
*closure_weight = rgb_to_spectrum(stack_load_float3(stack, color_offset)) * strength;
}
ccl_device_noinline void svm_node_mix_closure(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
/* fetch weight from blend input, previous mix closures,
@@ -1304,29 +1331,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(svm, weight_offset);
float weight = stack_load_float(stack, weight_offset);
weight = saturatef(weight);
float in_weight = (stack_valid(in_weight_offset)) ? stack_load_float(svm, in_weight_offset) :
float in_weight = (stack_valid(in_weight_offset)) ? stack_load_float(stack, in_weight_offset) :
1.0f;
if (stack_valid(weight1_offset))
stack_store_float(svm, weight1_offset, in_weight * (1.0f - weight));
stack_store_float(stack, weight1_offset, in_weight * (1.0f - weight));
if (stack_valid(weight2_offset))
stack_store_float(svm, weight2_offset, in_weight * weight);
stack_store_float(stack, weight2_offset, in_weight * weight);
}
/* (Bump) normal */
ccl_device void svm_node_set_normal(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint in_direction,
uint out_normal)
{
float3 normal = stack_load_float3(svm, in_direction);
float3 normal = stack_load_float3(stack, in_direction);
sd->N = normal;
stack_store_float3(svm, out_normal, normal);
stack_store_float3(stack, out_normal, normal);
}
CCL_NAMESPACE_END

34
intern/cycles/kernel/svm/convert.h
View File

@@ -10,54 +10,54 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_convert(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint type,
uint from,
uint to)
{
switch (type) {
case NODE_CONVERT_FI: {
float f = stack_load_float(svm, from);
stack_store_int(svm, to, float_to_int(f));
float f = stack_load_float(stack, from);
stack_store_int(stack, to, float_to_int(f));
break;
}
case NODE_CONVERT_FV: {
float f = stack_load_float(svm, from);
stack_store_float3(svm, to, make_float3(f, f, f));
float f = stack_load_float(stack, from);
stack_store_float3(stack, to, make_float3(f, f, f));
break;
}
case NODE_CONVERT_CF: {
float3 f = stack_load_float3(svm, from);
float3 f = stack_load_float3(stack, from);
float g = linear_rgb_to_gray(kg, f);
stack_store_float(svm, to, g);
stack_store_float(stack, to, g);
break;
}
case NODE_CONVERT_CI: {
float3 f = stack_load_float3(svm, from);
float3 f = stack_load_float3(stack, from);
int i = (int)linear_rgb_to_gray(kg, f);
stack_store_int(svm, to, i);
stack_store_int(stack, to, i);
break;
}
case NODE_CONVERT_VF: {
float3 f = stack_load_float3(svm, from);
float3 f = stack_load_float3(stack, from);
float g = average(f);
stack_store_float(svm, to, g);
stack_store_float(stack, to, g);
break;
}
case NODE_CONVERT_VI: {
float3 f = stack_load_float3(svm, from);
float3 f = stack_load_float3(stack, from);
int i = (int)average(f);
stack_store_int(svm, to, i);
stack_store_int(stack, to, i);
break;
}
case NODE_CONVERT_IF: {
float f = (float)stack_load_int(svm, from);
stack_store_float(svm, to, f);
float f = (float)stack_load_int(stack, from);
stack_store_float(stack, to, f);
break;
}
case NODE_CONVERT_IV: {
float f = (float)stack_load_int(svm, from);
stack_store_float3(svm, to, make_float3(f, f, f));
float f = (float)stack_load_int(stack, from);
stack_store_float3(stack, to, make_float3(f, f, f));
break;
}
}

61
intern/cycles/kernel/svm/displace.h
View File

@@ -12,7 +12,7 @@ CCL_NAMESPACE_BEGIN
template<uint node_feature_mask>
ccl_device_noinline void svm_node_set_bump(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint out_offset, bump_state_offset, dummy;
@@ -25,7 +25,8 @@ 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(svm, normal_offset) : sd->N;
float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) :
sd->N;
/* If we have saved bump state, read the full differential from there.
* Just using the compact form in those cases leads to incorrect normals (see #111588). */
@@ -34,8 +35,8 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg,
dP = differential_from_compact(sd->Ng, sd->dP);
}
else {
dP.dx = stack_load_float3(svm, bump_state_offset + 4);
dP.dy = stack_load_float3(svm, bump_state_offset + 7);
dP.dx = stack_load_float3(stack, bump_state_offset + 4);
dP.dy = stack_load_float3(stack, bump_state_offset + 7);
}
if (use_object_space) {
@@ -52,9 +53,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(svm, c_offset);
float h_x = stack_load_float(svm, x_offset);
float h_y = stack_load_float(svm, y_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);
/* compute surface gradient and determinant */
float det = dot(dP.dx, Rx);
@@ -62,8 +63,8 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg,
float absdet = fabsf(det);
float strength = stack_load_float(svm, strength_offset);
float scale = stack_load_float(svm, scale_offset);
float strength = stack_load_float(stack, strength_offset);
float scale = stack_load_float(stack, scale_offset);
if (invert)
scale *= -1.0f;
@@ -83,10 +84,10 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg,
object_normal_transform(kg, sd, &normal_out);
}
stack_store_float3(svm, out_offset, normal_out);
stack_store_float3(stack, out_offset, normal_out);
}
else {
stack_store_float3(svm, out_offset, zero_float3());
stack_store_float3(stack, out_offset, zero_float3());
}
#endif
}
@@ -96,12 +97,12 @@ ccl_device_noinline void svm_node_set_bump(KernelGlobals kg,
template<uint node_feature_mask>
ccl_device void svm_node_set_displacement(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint fac_offset)
{
IF_KERNEL_NODES_FEATURE(BUMP)
{
float3 dP = stack_load_float3(svm, fac_offset);
float3 dP = stack_load_float3(stack, fac_offset);
sd->P += dP;
}
}
@@ -109,7 +110,7 @@ ccl_device void svm_node_set_displacement(KernelGlobals kg,
template<uint node_feature_mask>
ccl_device_noinline void svm_node_displacement(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
IF_KERNEL_NODES_FEATURE(BUMP)
@@ -118,10 +119,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(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;
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;
uint space = node.w;
float3 dP = normal;
@@ -137,20 +138,18 @@ ccl_device_noinline void svm_node_displacement(KernelGlobals kg,
dP *= (height - midlevel) * scale;
}
stack_store_float3(svm, node.z, dP);
stack_store_float3(stack, node.z, dP);
}
else {
stack_store_float3(svm, node.z, zero_float3());
stack_store_float3(stack, node.z, zero_float3());
}
}
template<uint node_feature_mask>
ccl_device_noinline void svm_node_vector_displacement(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_vector_displacement(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
uint4 data_node = read_node(kg, svm);
uint4 data_node = read_node(kg, &offset);
uint vector_offset, midlevel_offset, scale_offset, displacement_offset;
svm_unpack_node_uchar4(
node.y, &vector_offset, &midlevel_offset, &scale_offset, &displacement_offset);
@@ -159,9 +158,9 @@ ccl_device_noinline void svm_node_vector_displacement(KernelGlobals kg,
{
uint space = data_node.x;
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 vector = stack_load_float3(stack, vector_offset);
float midlevel = stack_load_float(stack, midlevel_offset);
float scale = stack_load_float(stack, scale_offset);
float3 dP = (vector - make_float3(midlevel, midlevel, midlevel)) * scale;
if (space == NODE_NORMAL_MAP_TANGENT) {
@@ -193,12 +192,14 @@ ccl_device_noinline void svm_node_vector_displacement(KernelGlobals kg,
object_dir_transform(kg, sd, &dP);
}
stack_store_float3(svm, displacement_offset, dP);
stack_store_float3(stack, displacement_offset, dP);
}
else {
stack_store_float3(svm, displacement_offset, zero_float3());
stack_store_float3(stack, displacement_offset, zero_float3());
(void)data_node;
}
return offset;
}
CCL_NAMESPACE_END

17
intern/cycles/kernel/svm/fresnel.h
View File

@@ -9,29 +9,29 @@ CCL_NAMESPACE_BEGIN
/* Fresnel Node */
ccl_device_noinline void svm_node_fresnel(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, ior_offset) :
float eta = (stack_valid(ior_offset)) ? stack_load_float(stack, ior_offset) :
__uint_as_float(ior_value);
float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(svm, normal_offset) : sd->N;
float3 normal_in = stack_valid(normal_offset) ? stack_load_float3(stack, 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(svm, out_offset, f);
stack_store_float(stack, out_offset, f);
}
/* Layer Weight Node */
ccl_device_noinline void svm_node_layer_weight(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint blend_offset = node.y;
@@ -40,9 +40,10 @@ 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(svm, blend_offset) :
float blend = (stack_valid(blend_offset)) ? stack_load_float(stack, blend_offset) :
__uint_as_float(blend_value);
float3 normal_in = (stack_valid(normal_offset)) ? stack_load_float3(svm, normal_offset) : sd->N;
float3 normal_in = (stack_valid(normal_offset)) ? stack_load_float3(stack, normal_offset) :
sd->N;
float f;
@@ -65,7 +66,7 @@ ccl_device_noinline void svm_node_layer_weight(ccl_private ShaderData *sd,
f = 1.0f - f;
}
stack_store_float(svm, out_offset, f);
stack_store_float(stack, out_offset, f);
}
CCL_NAMESPACE_END

37
intern/cycles/kernel/svm/gabor.h
View File

@@ -274,12 +274,13 @@ ccl_device float2 compute_3d_gabor_noise(float3 coordinates,
return sum;
}
ccl_device_noinline void svm_node_tex_gabor(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint type,
uint stack_offsets_1,
uint stack_offsets_2)
ccl_device_noinline int svm_node_tex_gabor(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private float *stack,
uint type,
uint stack_offsets_1,
uint stack_offsets_2,
int offset)
{
uint coordinates_stack_offset;
uint scale_stack_offset;
@@ -296,22 +297,22 @@ ccl_device_noinline void svm_node_tex_gabor(KernelGlobals kg,
svm_unpack_node_uchar2(
stack_offsets_2, &orientation_2d_stack_offset, &orientation_3d_stack_offset);
float3 coordinates = stack_load_float3(svm, coordinates_stack_offset);
float3 coordinates = stack_load_float3(stack, coordinates_stack_offset);
uint value_stack_offset;
uint phase_stack_offset;
uint intensity_stack_offset;
uint4 node_1 = read_node(kg, svm);
uint4 node_1 = read_node(kg, &offset);
svm_unpack_node_uchar3(
node_1.x, &value_stack_offset, &phase_stack_offset, &intensity_stack_offset);
float scale = stack_load_float_default(svm, scale_stack_offset, node_1.y);
float frequency = stack_load_float_default(svm, frequency_stack_offset, node_1.z);
float anisotropy = stack_load_float_default(svm, anisotropy_stack_offset, node_1.w);
float scale = stack_load_float_default(stack, scale_stack_offset, node_1.y);
float frequency = stack_load_float_default(stack, frequency_stack_offset, node_1.z);
float anisotropy = stack_load_float_default(stack, anisotropy_stack_offset, node_1.w);
uint4 node_2 = read_node(kg, svm);
float orientation_2d = stack_load_float_default(svm, orientation_2d_stack_offset, node_2.x);
float3 orientation_3d = stack_load_float3(svm, orientation_3d_stack_offset);
uint4 node_2 = read_node(kg, &offset);
float orientation_2d = stack_load_float_default(stack, orientation_2d_stack_offset, node_2.x);
float3 orientation_3d = stack_load_float3(stack, orientation_3d_stack_offset);
float3 scaled_coordinates = coordinates * scale;
float isotropy = 1.0f - clamp(anisotropy, 0.0f, 1.0f);
@@ -343,20 +344,22 @@ ccl_device_noinline void svm_node_tex_gabor(KernelGlobals kg,
/* As discussed in compute_2d_gabor_kernel, we use the imaginary part of the phasor as the Gabor
* value. But remap to [0, 1] from [-1, 1]. */
if (stack_valid(value_stack_offset)) {
stack_store_float(svm, value_stack_offset, (phasor.y / normalization_factor) * 0.5f + 0.5f);
stack_store_float(stack, value_stack_offset, (phasor.y / normalization_factor) * 0.5f + 0.5f);
}
/* Compute the phase based on equation (9) in Tricard's paper. But remap the phase into the
* [0, 1] range. */
if (stack_valid(phase_stack_offset)) {
float phase = (atan2(phasor.y, phasor.x) + M_PI_F) / (2.0f * M_PI_F);
stack_store_float(svm, phase_stack_offset, phase);
stack_store_float(stack, phase_stack_offset, phase);
}
/* Compute the intensity based on equation (8) in Tricard's paper. */
if (stack_valid(intensity_stack_offset)) {
stack_store_float(svm, intensity_stack_offset, len(phasor) / normalization_factor);
stack_store_float(stack, intensity_stack_offset, len(phasor) / normalization_factor);
}
return offset;
}
CCL_NAMESPACE_END

8
intern/cycles/kernel/svm/gamma.h
View File

@@ -7,18 +7,18 @@
CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_gamma(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint in_gamma,
uint in_color,
uint out_color)
{
float3 color = stack_load_float3(svm, in_color);
float gamma = stack_load_float(svm, in_gamma);
float3 color = stack_load_float3(stack, in_color);
float gamma = stack_load_float(stack, in_gamma);
color = svm_math_gamma_color(color, gamma);
if (stack_valid(out_color)) {
stack_store_float3(svm, out_color, color);
stack_store_float3(stack, out_color, color);
}
}

62
intern/cycles/kernel/svm/geometry.h
View File

@@ -10,7 +10,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_geometry(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, data);
stack_store_float3(stack, out_offset, data);
}
ccl_device_noinline void svm_node_geometry_bump_dx(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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, svm, type, out_offset);
svm_node_geometry(kg, sd, stack, type, out_offset);
return;
}
stack_store_float3(svm, out_offset, data);
stack_store_float3(stack, out_offset, data);
#else
svm_node_geometry(kg, sd, svm, type, out_offset);
svm_node_geometry(kg, sd, stack, type, out_offset);
#endif
}
ccl_device_noinline void svm_node_geometry_bump_dy(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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, svm, type, out_offset);
svm_node_geometry(kg, sd, stack, type, out_offset);
return;
}
stack_store_float3(svm, out_offset, data);
stack_store_float3(stack, out_offset, data);
#else
svm_node_geometry(kg, sd, svm, type, out_offset);
svm_node_geometry(kg, sd, stack, 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 SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, object_location(kg, sd));
stack_store_float3(stack, out_offset, object_location(kg, sd));
return;
}
case NODE_INFO_OB_COLOR: {
stack_store_float3(svm, out_offset, object_color(kg, sd->object));
stack_store_float3(stack, 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(svm, out_offset, data);
stack_store_float(stack, out_offset, data);
}
/* Particle Info */
ccl_device_noinline void svm_node_particle_info(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint type,
uint out_offset)
{
switch (type) {
case NODE_INFO_PAR_INDEX: {
int particle_id = object_particle_id(kg, sd->object);
stack_store_float(svm, out_offset, particle_index(kg, particle_id));
stack_store_float(stack, 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(svm, out_offset, random);
stack_store_float(stack, out_offset, random);
break;
}
case NODE_INFO_PAR_AGE: {
int particle_id = object_particle_id(kg, sd->object);
stack_store_float(svm, out_offset, particle_age(kg, particle_id));
stack_store_float(stack, 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(svm, out_offset, particle_lifetime(kg, particle_id));
stack_store_float(stack, 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(svm, out_offset, particle_location(kg, particle_id));
stack_store_float3(stack, 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(svm, out_offset, particle_rotation(kg, particle_id));
stack_store_float4(stack, 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(svm, out_offset, particle_size(kg, particle_id));
stack_store_float(stack, 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(svm, out_offset, particle_velocity(kg, particle_id));
stack_store_float3(stack, 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(svm, out_offset, particle_angular_velocity(kg, particle_id));
stack_store_float3(stack, 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 SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, data);
stack_store_float(stack, 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(svm, out_offset, data);
stack_store_float(stack, out_offset, data);
break;
}
case NODE_INFO_CURVE_TANGENT_NORMAL: {
data3 = curve_tangent_normal(kg, sd);
stack_store_float3(svm, out_offset, data3);
stack_store_float3(stack, 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 SVMState *svm,
ccl_private float *stack,
uint type,
uint out_offset)
{
switch (type) {
case NODE_INFO_POINT_POSITION:
stack_store_float3(svm, out_offset, point_position(kg, sd));
stack_store_float3(stack, out_offset, point_position(kg, sd));
break;
case NODE_INFO_POINT_RADIUS:
stack_store_float(svm, out_offset, point_radius(kg, sd));
stack_store_float(stack, out_offset, point_radius(kg, sd));
break;
case NODE_INFO_POINT_RANDOM:
break; /* handled as attribute */

8
intern/cycles/kernel/svm/gradient.h
View File

@@ -53,22 +53,22 @@ ccl_device float svm_gradient(float3 p, NodeGradientType type)
}
ccl_device_noinline void svm_node_tex_gradient(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, co_offset);
float3 co = stack_load_float3(stack, co_offset);
float f = svm_gradient(co, (NodeGradientType)type);
f = saturatef(f);
if (stack_valid(fac_offset))
stack_store_float(svm, fac_offset, f);
stack_store_float(stack, fac_offset, f);
if (stack_valid(color_offset))
stack_store_float3(svm, color_offset, make_float3(f, f, f));
stack_store_float3(stack, color_offset, make_float3(f, f, f));
}
CCL_NAMESPACE_END

14
intern/cycles/kernel/svm/hsv.h
View File

@@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_hsv(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, fac_offset);
float3 in_color = stack_load_float3(svm, in_color_offset);
float fac = stack_load_float(stack, fac_offset);
float3 in_color = stack_load_float3(stack, in_color_offset);
float3 color = in_color;
float hue = stack_load_float(svm, hue_offset);
float sat = stack_load_float(svm, sat_offset);
float val = stack_load_float(svm, val_offset);
float hue = stack_load_float(stack, hue_offset);
float sat = stack_load_float(stack, sat_offset);
float val = stack_load_float(stack, val_offset);
color = rgb_to_hsv(color);
@@ -42,7 +42,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(svm, out_color_offset, color);
stack_store_float3(stack, out_color_offset, color);
}
CCL_NAMESPACE_END

8
intern/cycles/kernel/svm/ies.h
View File

@@ -10,14 +10,14 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_ies(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, vector_offset);
float strength = stack_load_float_default(svm, strength_offset, node.w);
float3 vector = stack_load_float3(stack, vector_offset);
float strength = stack_load_float_default(stack, strength_offset, node.w);
vector = normalize(vector);
float v_angle = safe_acosf(-vector.z);
@@ -26,7 +26,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(svm, fac_offset, fac);
stack_store_float(stack, fac_offset, fac);
}
}

35
intern/cycles/kernel/svm/image.h
View File

@@ -34,16 +34,14 @@ ccl_device_inline float3 texco_remap_square(float3 co)
return (co - make_float3(0.5f, 0.5f, 0.5f)) * 2.0f;
}
ccl_device_noinline void svm_node_tex_image(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_tex_image(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
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(svm, co_offset);
float3 co = stack_load_float3(stack, co_offset);
float2 tex_co;
if (node.w == NODE_IMAGE_PROJ_SPHERE) {
co = texco_remap_square(co);
@@ -63,7 +61,7 @@ ccl_device_noinline void svm_node_tex_image(KernelGlobals kg,
int num_nodes = (int)node.y;
if (num_nodes > 0) {
/* Remember the offset of the node following the tile nodes. */
int next_offset = svm->offset + num_nodes;
int next_offset = offset + num_nodes;
/* Find the tile that the UV lies in. */
int tx = (int)tex_co.x;
@@ -75,7 +73,7 @@ ccl_device_noinline void svm_node_tex_image(KernelGlobals kg,
/* Find the index of the tile. */
for (int i = 0; i < num_nodes; i++) {
uint4 tile_node = read_node(kg, svm);
uint4 tile_node = read_node(kg, &offset);
if (tile_node.x == tile) {
id = tile_node.y;
break;
@@ -94,7 +92,7 @@ ccl_device_noinline void svm_node_tex_image(KernelGlobals kg,
}
/* Skip over the remaining nodes. */
svm->offset = next_offset;
offset = next_offset;
}
else {
id = -num_nodes;
@@ -103,14 +101,15 @@ ccl_device_noinline void svm_node_tex_image(KernelGlobals kg,
float4 f = svm_image_texture(kg, id, tex_co.x, tex_co.y, flags);
if (stack_valid(out_offset))
stack_store_float3(svm, out_offset, make_float3(f.x, f.y, f.z));
stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
if (stack_valid(alpha_offset))
stack_store_float(svm, alpha_offset, f.w);
stack_store_float(stack, alpha_offset, f.w);
return offset;
}
ccl_device_noinline void svm_node_tex_image_box(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
/* get object space normal */
@@ -185,7 +184,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(svm, co_offset);
float3 co = stack_load_float3(stack, co_offset);
uint id = node.y;
float4 f = zero_float4();
@@ -205,14 +204,14 @@ ccl_device_noinline void svm_node_tex_image_box(KernelGlobals kg,
}
if (stack_valid(out_offset))
stack_store_float3(svm, out_offset, make_float3(f.x, f.y, f.z));
stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
if (stack_valid(alpha_offset))
stack_store_float(svm, alpha_offset, f.w);
stack_store_float(stack, alpha_offset, f.w);
}
ccl_device_noinline void svm_node_tex_environment(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint id = node.y;
@@ -221,7 +220,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(svm, co_offset);
float3 co = stack_load_float3(stack, co_offset);
float2 uv;
co = safe_normalize(co);
@@ -234,9 +233,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(svm, out_offset, make_float3(f.x, f.y, f.z));
stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
if (stack_valid(alpha_offset))
stack_store_float(svm, alpha_offset, f.w);
stack_store_float(stack, alpha_offset, f.w);
}
CCL_NAMESPACE_END

8
intern/cycles/kernel/svm/invert.h
View File

@@ -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 SVMState *svm,
ccl_private float *stack,
uint in_fac,
uint in_color,
uint out_color)
{
float factor = stack_load_float(svm, in_fac);
float3 color = stack_load_float3(svm, in_color);
float factor = stack_load_float(stack, in_fac);
float3 color = stack_load_float3(stack, 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(svm, out_color, color);
stack_store_float3(stack, out_color, color);
}
}

12
intern/cycles/kernel/svm/light_path.h
View File

@@ -12,7 +12,7 @@ template<uint node_feature_mask, typename ConstIntegratorGenericState>
ccl_device_noinline void svm_node_light_path(KernelGlobals kg,
ConstIntegratorGenericState state,
ccl_private const ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, out_offset, info);
stack_store_float(stack, out_offset, info);
}
/* Light Falloff Node */
ccl_device_noinline void svm_node_light_falloff(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, strength_offset);
float strength = stack_load_float(stack, 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(svm, smooth_offset);
float smooth = stack_load_float(stack, 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(svm, out_offset, strength);
stack_store_float(stack, out_offset, strength);
}
CCL_NAMESPACE_END

19
intern/cycles/kernel/svm/magic.h
View File

@@ -93,10 +93,8 @@ 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 void svm_node_tex_magic(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_tex_magic(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
uint depth;
uint scale_offset, distortion_offset, co_offset, fac_offset, color_offset;
@@ -104,17 +102,18 @@ ccl_device_noinline void svm_node_tex_magic(KernelGlobals kg,
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, 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);
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);
float3 color = svm_magic(co, scale, depth, distortion);
if (stack_valid(fac_offset))
stack_store_float(svm, fac_offset, average(color));
stack_store_float(stack, fac_offset, average(color));
if (stack_valid(color_offset))
stack_store_float3(svm, color_offset, color);
stack_store_float3(stack, color_offset, color);
return offset;
}
CCL_NAMESPACE_END

60
intern/cycles/kernel/svm/map_range.h
View File

@@ -14,12 +14,13 @@ 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 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)
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)
{
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;
@@ -31,15 +32,15 @@ ccl_device_noinline void 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, svm);
uint4 defaults2 = read_node(kg, svm);
uint4 defaults = read_node(kg, &offset);
uint4 defaults2 = read_node(kg, &offset);
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 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 result;
@@ -71,15 +72,17 @@ ccl_device_noinline void svm_node_map_range(KernelGlobals kg,
else {
result = 0.0f;
}
stack_store_float(svm, result_stack_offset, result);
stack_store_float(stack, result_stack_offset, result);
return 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)
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)
{
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;
@@ -94,12 +97,12 @@ ccl_device_noinline void svm_node_vector_map_range(KernelGlobals kg,
&range_type_stack_offset,
&result_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);
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);
int type = range_type_stack_offset;
int use_clamp = (type == NODE_MAP_RANGE_SMOOTHSTEP || type == NODE_MAP_RANGE_SMOOTHERSTEP) ?
@@ -143,7 +146,8 @@ ccl_device_noinline void svm_node_vector_map_range(KernelGlobals kg,
clamp(result.z, to_min.z, to_max.z);
}
stack_store_float3(svm, result_stack_offset, result);
stack_store_float3(stack, result_stack_offset, result);
return offset;
}
CCL_NAMESPACE_END

54
intern/cycles/kernel/svm/mapping.h
View File

@@ -12,7 +12,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_mapping(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint type,
uint inputs_stack_offsets,
uint result_stack_offset)
@@ -24,47 +24,51 @@ ccl_device_noinline void svm_node_mapping(KernelGlobals kg,
&rotation_stack_offset,
&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 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 result = svm_mapping((NodeMappingType)type, vector, location, rotation, scale);
stack_store_float3(svm, result_stack_offset, result);
stack_store_float3(stack, result_stack_offset, result);
}
/* Texture Mapping */
ccl_device_noinline void svm_node_texture_mapping(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint vec_offset,
uint out_offset)
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)
{
float3 v = stack_load_float3(svm, vec_offset);
float3 v = stack_load_float3(stack, vec_offset);
Transform tfm;
tfm.x = read_node_float(kg, svm);
tfm.y = read_node_float(kg, svm);
tfm.z = read_node_float(kg, svm);
tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, &offset);
float3 r = transform_point(&tfm, v);
stack_store_float3(svm, out_offset, r);
stack_store_float3(stack, out_offset, r);
return 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)
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)
{
float3 v = stack_load_float3(svm, vec_offset);
float3 v = stack_load_float3(stack, vec_offset);
float3 mn = float4_to_float3(read_node_float(kg, svm));
float3 mx = float4_to_float3(read_node_float(kg, svm));
float3 mn = float4_to_float3(read_node_float(kg, &offset));
float3 mx = float4_to_float3(read_node_float(kg, &offset));
float3 r = min(max(mn, v), mx);
stack_store_float3(svm, out_offset, r);
stack_store_float3(stack, out_offset, r);
return offset;
}
CCL_NAMESPACE_END

38
intern/cycles/kernel/svm/math.h
View File

@@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_math(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint type,
uint inputs_stack_offsets,
uint result_stack_offset)
@@ -16,20 +16,21 @@ 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(svm, a_stack_offset);
float b = stack_load_float(svm, b_stack_offset);
float c = stack_load_float(svm, 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 result = svm_math((NodeMathType)type, a, b, c);
stack_store_float(svm, result_stack_offset, result);
stack_store_float(stack, result_stack_offset, result);
}
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)
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)
{
uint value_stack_offset, vector_stack_offset;
uint a_stack_offset, b_stack_offset, param1_stack_offset;
@@ -37,10 +38,10 @@ ccl_device_noinline void svm_node_vector_math(KernelGlobals kg,
inputs_stack_offsets, &a_stack_offset, &b_stack_offset, &param1_stack_offset);
svm_unpack_node_uchar2(outputs_stack_offsets, &value_stack_offset, &vector_stack_offset);
float3 a = stack_load_float3(svm, a_stack_offset);
float3 b = stack_load_float3(svm, b_stack_offset);
float3 a = stack_load_float3(stack, a_stack_offset);
float3 b = stack_load_float3(stack, b_stack_offset);
float3 c = make_float3(0.0f, 0.0f, 0.0f);
float param1 = stack_load_float(svm, param1_stack_offset);
float param1 = stack_load_float(stack, param1_stack_offset);
float value;
float3 vector;
@@ -49,16 +50,17 @@ ccl_device_noinline void 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, svm);
c = stack_load_float3(svm, extra_node.x);
uint4 extra_node = read_node(kg, &offset);
c = stack_load_float3(stack, extra_node.x);
}
svm_vector_math(&value, &vector, (NodeVectorMathType)type, a, b, c, param1);
if (stack_valid(value_stack_offset))
stack_store_float(svm, value_stack_offset, value);
stack_store_float(stack, value_stack_offset, value);
if (stack_valid(vector_stack_offset))
stack_store_float3(svm, vector_stack_offset, vector);
stack_store_float3(stack, vector_stack_offset, vector);
return offset;
}
CCL_NAMESPACE_END

64
intern/cycles/kernel/svm/mix.h
View File

@@ -8,26 +8,28 @@ CCL_NAMESPACE_BEGIN
/* Node */
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)
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)
{
/* read extra data */
uint4 node1 = read_node(kg, svm);
uint4 node1 = read_node(kg, &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);
float fac = stack_load_float(stack, fac_offset);
float3 c1 = stack_load_float3(stack, c1_offset);
float3 c2 = stack_load_float3(stack, c2_offset);
float3 result = svm_mix_clamped_factor((NodeMix)node1.y, fac, c1, c2);
stack_store_float3(svm, node1.z, result);
stack_store_float3(stack, node1.z, result);
return offset;
}
ccl_device_noinline void svm_node_mix_color(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint options,
uint input_offset,
uint result_offset)
@@ -38,21 +40,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(svm, fac_in_stack_offset);
float t = stack_load_float(stack, fac_in_stack_offset);
if (use_clamp > 0) {
t = saturatef(t);
}
float3 a = stack_load_float3(svm, a_in_stack_offset);
float3 b = stack_load_float3(svm, b_in_stack_offset);
float3 a = stack_load_float3(stack, a_in_stack_offset);
float3 b = stack_load_float3(stack, b_in_stack_offset);
float3 result = svm_mix((NodeMix)blend_type, t, a, b);
if (use_clamp_result) {
result = saturate(result);
}
stack_store_float3(svm, result_offset, result);
stack_store_float3(stack, result_offset, result);
}
ccl_device_noinline void svm_node_mix_float(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint use_clamp,
uint input_offset,
uint result_offset)
@@ -61,19 +63,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(svm, fac_in_stack_offset);
float t = stack_load_float(stack, fac_in_stack_offset);
if (use_clamp > 0) {
t = saturatef(t);
}
float a = stack_load_float(svm, a_in_stack_offset);
float b = stack_load_float(svm, b_in_stack_offset);
float a = stack_load_float(stack, a_in_stack_offset);
float b = stack_load_float(stack, b_in_stack_offset);
float result = a * (1 - t) + b * t;
stack_store_float(svm, result_offset, result);
stack_store_float(stack, result_offset, result);
}
ccl_device_noinline void svm_node_mix_vector(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint input_offset,
uint result_offset)
{
@@ -81,18 +83,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(svm, fac_in_stack_offset);
float t = stack_load_float(stack, fac_in_stack_offset);
if (use_clamp > 0) {
t = saturatef(t);
}
float3 a = stack_load_float3(svm, a_in_stack_offset);
float3 b = stack_load_float3(svm, b_in_stack_offset);
float3 a = stack_load_float3(stack, a_in_stack_offset);
float3 b = stack_load_float3(stack, b_in_stack_offset);
float3 result = a * (one_float3() - t) + b * t;
stack_store_float3(svm, result_offset, result);
stack_store_float3(stack, result_offset, result);
}
ccl_device_noinline void svm_node_mix_vector_non_uniform(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint input_offset,
uint result_offset)
{
@@ -100,14 +102,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(svm, fac_in_stack_offset);
float3 t = stack_load_float3(stack, fac_in_stack_offset);
if (use_clamp > 0) {
t = saturate(t);
}
float3 a = stack_load_float3(svm, a_in_stack_offset);
float3 b = stack_load_float3(svm, b_in_stack_offset);
float3 a = stack_load_float3(stack, a_in_stack_offset);
float3 b = stack_load_float3(stack, b_in_stack_offset);
float3 result = a * (one_float3() - t) + b * t;
stack_store_float3(svm, result_offset, result);
stack_store_float3(stack, result_offset, result);
}
CCL_NAMESPACE_END

42
intern/cycles/kernel/svm/noisetex.h
View File

@@ -241,12 +241,13 @@ ccl_device void noise_texture_4d(float4 co,
}
}
ccl_device_noinline void svm_node_tex_noise(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint offsets1,
uint offsets2,
uint offsets3)
ccl_device_noinline int svm_node_tex_noise(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private float *stack,
uint offsets1,
uint offsets2,
uint offsets3,
int node_offset)
{
uint vector_stack_offset, w_stack_offset, scale_stack_offset, detail_stack_offset;
uint roughness_stack_offset, lacunarity_stack_offset, offset_stack_offset, gain_stack_offset;
@@ -262,23 +263,23 @@ ccl_device_noinline void svm_node_tex_noise(KernelGlobals kg,
svm_unpack_node_uchar3(
offsets3, &distortion_stack_offset, &value_stack_offset, &color_stack_offset);
uint4 defaults1 = read_node(kg, svm);
uint4 defaults2 = read_node(kg, svm);
uint4 properties = read_node(kg, svm);
uint4 defaults1 = read_node(kg, &node_offset);
uint4 defaults2 = read_node(kg, &node_offset);
uint4 properties = read_node(kg, &node_offset);
uint dimensions = properties.x;
uint type = properties.y;
uint normalize = properties.z;
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 lacunarity = stack_load_float_default(svm, lacunarity_stack_offset, defaults2.x);
float offset = stack_load_float_default(svm, offset_stack_offset, defaults2.y);
float gain = stack_load_float_default(svm, gain_stack_offset, defaults2.z);
float distortion = stack_load_float_default(svm, distortion_stack_offset, defaults2.w);
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 lacunarity = stack_load_float_default(stack, lacunarity_stack_offset, defaults2.x);
float offset = stack_load_float_default(stack, offset_stack_offset, defaults2.y);
float gain = stack_load_float_default(stack, gain_stack_offset, defaults2.z);
float distortion = stack_load_float_default(stack, distortion_stack_offset, defaults2.w);
detail = clamp(detail, 0.0f, 15.0f);
roughness = fmaxf(roughness, 0.0f);
@@ -350,11 +351,12 @@ ccl_device_noinline void svm_node_tex_noise(KernelGlobals kg,
}
if (stack_valid(value_stack_offset)) {
stack_store_float(svm, value_stack_offset, value);
stack_store_float(stack, value_stack_offset, value);
}
if (stack_valid(color_stack_offset)) {
stack_store_float3(svm, color_stack_offset, color);
stack_store_float3(stack, color_stack_offset, color);
}
return node_offset;
}
CCL_NAMESPACE_END

22
intern/cycles/kernel/svm/normal.h
View File

@@ -6,16 +6,17 @@
CCL_NAMESPACE_BEGIN
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)
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)
{
/* read extra data */
uint4 node1 = read_node(kg, svm);
float3 normal = stack_load_float3(svm, in_normal_offset);
uint4 node1 = read_node(kg, &offset);
float3 normal = stack_load_float3(stack, in_normal_offset);
float3 direction;
direction.x = __int_as_float(node1.x);
@@ -24,12 +25,13 @@ ccl_device_noinline void svm_node_normal(KernelGlobals kg,
direction = normalize(direction);
if (stack_valid(out_normal_offset)) {
stack_store_float3(svm, out_normal_offset, direction);
stack_store_float3(stack, out_normal_offset, direction);
}
if (stack_valid(out_dot_offset)) {
stack_store_float(svm, out_dot_offset, dot(direction, normalize(normal)));
stack_store_float(stack, out_dot_offset, dot(direction, normalize(normal)));
}
return offset;
}
CCL_NAMESPACE_END

61
intern/cycles/kernel/svm/ramp.h
View File

@@ -78,79 +78,76 @@ ccl_device_inline float4 rgb_ramp_lookup(
return a;
}
ccl_device_noinline void svm_node_rgb_ramp(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_rgb_ramp(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
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, svm).x;
uint table_size = read_node(kg, &offset).x;
float fac = stack_load_float(svm, fac_offset);
float4 color = rgb_ramp_lookup(kg, svm->offset, fac, interpolate, false, table_size);
float fac = stack_load_float(stack, fac_offset);
float4 color = rgb_ramp_lookup(kg, offset, fac, interpolate, false, table_size);
if (stack_valid(color_offset))
stack_store_float3(svm, color_offset, float4_to_float3(color));
stack_store_float3(stack, color_offset, float4_to_float3(color));
if (stack_valid(alpha_offset))
stack_store_float(svm, alpha_offset, color.w);
stack_store_float(stack, alpha_offset, color.w);
svm->offset += table_size;
offset += table_size;
return offset;
}
ccl_device_noinline void svm_node_curves(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_curves(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
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, svm).x;
uint table_size = read_node(kg, &offset).x;
float fac = stack_load_float(svm, fac_offset);
float3 color = stack_load_float3(svm, color_offset);
float fac = stack_load_float(stack, fac_offset);
float3 color = stack_load_float3(stack, 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, 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;
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;
color = (1.0f - fac) * color + fac * make_float3(r, g, b);
stack_store_float3(svm, out_offset, color);
stack_store_float3(stack, out_offset, color);
svm->offset += table_size;
offset += table_size;
return offset;
}
ccl_device_noinline void svm_node_curve(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_curve(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
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, svm).x;
uint table_size = read_node(kg, &offset).x;
float fac = stack_load_float(svm, fac_offset);
float in = stack_load_float(svm, value_in_offset);
float fac = stack_load_float(stack, fac_offset);
float in = stack_load_float(stack, 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, svm->offset, relpos, true, extrapolate, table_size);
float v = float_ramp_lookup(kg, offset, relpos, true, extrapolate, table_size);
in = (1.0f - fac) * in + fac * v;
stack_store_float(svm, out_offset, in);
stack_store_float(stack, out_offset, in);
svm->offset += table_size;
offset += table_size;
return offset;
}
CCL_NAMESPACE_END

20
intern/cycles/kernel/svm/sepcomb_color.h
View File

@@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_combine_color(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint color_type,
uint inputs_stack_offsets,
uint result_stack_offset)
@@ -17,26 +17,26 @@ 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(svm, red_stack_offset);
float g = stack_load_float(svm, green_stack_offset);
float b = stack_load_float(svm, 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);
/* 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(svm, result_stack_offset, color);
stack_store_float3(stack, result_stack_offset, color);
}
}
ccl_device_noinline void svm_node_separate_color(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint color_type,
uint input_stack_offset,
uint results_stack_offsets)
{
float3 color = stack_load_float3(svm, input_stack_offset);
float3 color = stack_load_float3(stack, input_stack_offset);
/* Convert color space */
color = svm_separate_color((NodeCombSepColorType)color_type, color);
@@ -46,11 +46,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(svm, red_stack_offset, color.x);
stack_store_float(stack, red_stack_offset, color.x);
if (stack_valid(green_stack_offset))
stack_store_float(svm, green_stack_offset, color.y);
stack_store_float(stack, green_stack_offset, color.y);
if (stack_valid(blue_stack_offset))
stack_store_float(svm, blue_stack_offset, color.z);
stack_store_float(stack, blue_stack_offset, color.z);
}
CCL_NAMESPACE_END

48
intern/cycles/kernel/svm/sepcomb_hsv.h
View File

@@ -6,49 +6,53 @@
CCL_NAMESPACE_BEGIN
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)
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)
{
uint4 node1 = read_node(kg, svm);
uint4 node1 = read_node(kg, &offset);
uint color_out = node1.y;
float hue = stack_load_float(svm, hue_in);
float saturation = stack_load_float(svm, saturation_in);
float value = stack_load_float(svm, value_in);
float hue = stack_load_float(stack, hue_in);
float saturation = stack_load_float(stack, saturation_in);
float value = stack_load_float(stack, 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(svm, color_out, color);
stack_store_float3(stack, color_out, color);
}
return 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)
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)
{
uint4 node1 = read_node(kg, svm);
uint4 node1 = read_node(kg, &offset);
uint value_out = node1.y;
float3 color = stack_load_float3(svm, color_in);
float3 color = stack_load_float3(stack, color_in);
/* Convert to HSV */
color = rgb_to_hsv(color);
if (stack_valid(hue_out))
stack_store_float(svm, hue_out, color.x);
stack_store_float(stack, hue_out, color.x);
if (stack_valid(saturation_out))
stack_store_float(svm, saturation_out, color.y);
stack_store_float(stack, saturation_out, color.y);
if (stack_valid(value_out))
stack_store_float(svm, value_out, color.z);
stack_store_float(stack, value_out, color.z);
return offset;
}
CCL_NAMESPACE_END

16
intern/cycles/kernel/svm/sepcomb_vector.h
View File

@@ -9,35 +9,35 @@ 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 SVMState *svm,
ccl_private float *stack,
uint in_offset,
uint vector_index,
uint out_offset)
{
float vector = stack_load_float(svm, in_offset);
float vector = stack_load_float(stack, in_offset);
if (stack_valid(out_offset)) {
stack_store_float(svm, out_offset + vector_index, vector);
stack_store_float(stack, out_offset + vector_index, vector);
}
}
ccl_device void svm_node_separate_vector(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint ivector_offset,
uint vector_index,
uint out_offset)
{
float3 vector = stack_load_float3(svm, ivector_offset);
float3 vector = stack_load_float3(stack, ivector_offset);
if (stack_valid(out_offset)) {
if (vector_index == 0) {
stack_store_float(svm, out_offset, vector.x);
stack_store_float(stack, out_offset, vector.x);
}
else if (vector_index == 1) {
stack_store_float(svm, out_offset, vector.y);
stack_store_float(stack, out_offset, vector.y);
}
else {
stack_store_float(svm, out_offset, vector.z);
stack_store_float(stack, out_offset, vector.z);
}
}
}

38
intern/cycles/kernel/svm/sky.h
View File

@@ -196,18 +196,19 @@ ccl_device float3 sky_radiance_nishita(KernelGlobals kg,
return xyz_to_rgb_clamped(kg, xyz);
}
ccl_device_noinline void svm_node_tex_sky(KernelGlobals kg,
ccl_private ShaderData *sd,
uint32_t path_flag,
ccl_private SVMState *svm,
uint4 node)
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)
{
/* Load data */
uint dir_offset = node.y;
uint out_offset = node.z;
int sky_model = node.w;
float3 dir = stack_load_float3(svm, dir_offset);
float3 dir = stack_load_float3(stack, dir_offset);
float3 f;
/* Preetham and Hosek share the same data */
@@ -216,49 +217,49 @@ ccl_device_noinline void 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, svm);
float4 data = read_node_float(kg, &offset);
sunphi = data.x;
suntheta = data.y;
radiance_x = data.z;
radiance_y = data.w;
data = read_node_float(kg, svm);
data = read_node_float(kg, &offset);
radiance_z = data.x;
config_x[0] = data.y;
config_x[1] = data.z;
config_x[2] = data.w;
data = read_node_float(kg, svm);
data = read_node_float(kg, &offset);
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, svm);
data = read_node_float(kg, &offset);
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, svm);
data = read_node_float(kg, &offset);
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, svm);
data = read_node_float(kg, &offset);
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, svm);
data = read_node_float(kg, &offset);
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, svm);
data = read_node_float(kg, &offset);
config_z[5] = data.x;
config_z[6] = data.y;
config_z[7] = data.z;
@@ -295,18 +296,18 @@ ccl_device_noinline void svm_node_tex_sky(KernelGlobals kg,
/* Define variables */
float nishita_data[4];
float4 data = read_node_float(kg, svm);
float4 data = read_node_float(kg, &offset);
float3 pixel_bottom = make_float3(data.x, data.y, data.z);
float3 pixel_top;
pixel_top.x = data.w;
data = read_node_float(kg, svm);
data = read_node_float(kg, &offset);
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, svm);
data = read_node_float(kg, &offset);
nishita_data[2] = data.x;
nishita_data[3] = data.y;
uint texture_id = __float_as_uint(data.z);
@@ -316,7 +317,8 @@ ccl_device_noinline void svm_node_tex_sky(KernelGlobals kg,
kg, dir, path_flag, pixel_bottom, pixel_top, nishita_data, texture_id);
}
stack_store_float3(svm, out_offset, f);
stack_store_float3(stack, out_offset, f);
return offset;
}
CCL_NAMESPACE_END

262
intern/cycles/kernel/svm/svm.h
View File

@@ -29,68 +29,62 @@
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 SVMState *svm, uint a)
ccl_device_inline float3 stack_load_float3(ccl_private float *stack, uint a)
{
kernel_assert(a + 2 < SVM_STACK_SIZE);
ccl_private float *stack_a = svm->stack + a;
ccl_private float *stack_a = stack + a;
return make_float3(stack_a[0], stack_a[1], stack_a[2]);
}
ccl_device_inline void stack_store_float3(ccl_private SVMState *svm, uint a, float3 f)
ccl_device_inline void stack_store_float3(ccl_private float *stack, uint a, float3 f)
{
kernel_assert(a + 2 < SVM_STACK_SIZE);
ccl_private float *stack_a = svm->stack + a;
ccl_private float *stack_a = 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 SVMState *svm, uint a)
ccl_device_inline float stack_load_float(ccl_private float *stack, uint a)
{
kernel_assert(a < SVM_STACK_SIZE);
return svm->stack[a];
return stack[a];
}
ccl_device_inline float stack_load_float_default(ccl_private SVMState *svm, uint a, uint value)
ccl_device_inline float stack_load_float_default(ccl_private float *stack, uint a, uint value)
{
return (a == (uint)SVM_STACK_INVALID) ? __uint_as_float(value) : stack_load_float(svm, a);
return (a == (uint)SVM_STACK_INVALID) ? __uint_as_float(value) : stack_load_float(stack, a);
}
ccl_device_inline void stack_store_float(ccl_private SVMState *svm, uint a, float f)
ccl_device_inline void stack_store_float(ccl_private float *stack, uint a, float f)
{
kernel_assert(a < SVM_STACK_SIZE);
svm->stack[a] = f;
stack[a] = f;
}
ccl_device_inline int stack_load_int(ccl_private SVMState *svm, uint a)
ccl_device_inline int stack_load_int(ccl_private float *stack, uint a)
{
kernel_assert(a < SVM_STACK_SIZE);
return __float_as_int(svm->stack[a]);
return __float_as_int(stack[a]);
}
ccl_device_inline int stack_load_int_default(ccl_private SVMState *svm, uint a, uint value)
ccl_device_inline int stack_load_int_default(ccl_private float *stack, uint a, uint value)
{
return (a == (uint)SVM_STACK_INVALID) ? (int)value : stack_load_int(svm, a);
return (a == (uint)SVM_STACK_INVALID) ? (int)value : stack_load_int(stack, a);
}
ccl_device_inline void stack_store_int(ccl_private SVMState *svm, uint a, int i)
ccl_device_inline void stack_store_int(ccl_private float *stack, uint a, int i)
{
kernel_assert(a < SVM_STACK_SIZE);
svm->stack[a] = __int_as_float(i);
stack[a] = __int_as_float(i);
}
ccl_device_inline bool stack_valid(uint a)
@@ -100,21 +94,21 @@ ccl_device_inline bool stack_valid(uint a)
/* Reading Nodes */
ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private SVMState *svm)
ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private int *offset)
{
uint4 node = kernel_data_fetch(svm_nodes, svm->offset);
svm->offset++;
uint4 node = kernel_data_fetch(svm_nodes, *offset);
(*offset)++;
return node;
}
ccl_device_inline float4 read_node_float(KernelGlobals kg, ccl_private SVMState *svm)
ccl_device_inline float4 read_node_float(KernelGlobals kg, ccl_private int *offset)
{
uint4 node = kernel_data_fetch(svm_nodes, svm->offset);
uint4 node = kernel_data_fetch(svm_nodes, *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));
svm->offset++;
(*offset)++;
return f;
}
@@ -228,11 +222,12 @@ ccl_device void svm_eval_nodes(KernelGlobals kg,
ccl_global float *render_buffer,
uint32_t path_flag)
{
SVMState svm;
svm.offset = sd->shader & SHADER_MASK;
float stack[SVM_STACK_SIZE];
Spectrum closure_weight;
int offset = sd->shader & SHADER_MASK;
while (1) {
uint4 node = read_node(kg, &svm);
uint4 node = read_node(kg, &offset);
switch (node.x) {
SVM_CASE(NODE_END)
@@ -240,13 +235,13 @@ ccl_device void svm_eval_nodes(KernelGlobals kg,
SVM_CASE(NODE_SHADER_JUMP)
{
if (type == SHADER_TYPE_SURFACE) {
svm.offset = node.y;
offset = node.y;
}
else if (type == SHADER_TYPE_VOLUME) {
svm.offset = node.z;
offset = node.z;
}
else if (type == SHADER_TYPE_DISPLACEMENT) {
svm.offset = node.w;
offset = node.w;
}
else {
return;
@@ -254,333 +249,336 @@ ccl_device void svm_eval_nodes(KernelGlobals kg,
break;
}
SVM_CASE(NODE_CLOSURE_BSDF)
svm_node_closure_bsdf<node_feature_mask, type>(kg, sd, &svm, node, path_flag);
offset = svm_node_closure_bsdf<node_feature_mask, type>(
kg, sd, stack, closure_weight, node, path_flag, offset);
break;
SVM_CASE(NODE_CLOSURE_EMISSION)
IF_KERNEL_NODES_FEATURE(EMISSION)
{
svm_node_closure_emission(kg, sd, &svm, node);
svm_node_closure_emission(kg, sd, stack, closure_weight, node);
}
break;
SVM_CASE(NODE_CLOSURE_BACKGROUND)
IF_KERNEL_NODES_FEATURE(EMISSION)
{
svm_node_closure_background(sd, &svm, node);
svm_node_closure_background(sd, stack, closure_weight, node);
}
break;
SVM_CASE(NODE_CLOSURE_SET_WEIGHT)
svm_node_closure_set_weight(sd, &svm, node.y, node.z, node.w);
svm_node_closure_set_weight(sd, &closure_weight, node.y, node.z, node.w);
break;
SVM_CASE(NODE_CLOSURE_WEIGHT)
svm_node_closure_weight(sd, &svm, node.y);
svm_node_closure_weight(sd, stack, &closure_weight, node.y);
break;
SVM_CASE(NODE_EMISSION_WEIGHT)
IF_KERNEL_NODES_FEATURE(EMISSION)
{
svm_node_emission_weight(kg, sd, &svm, node);
svm_node_emission_weight(kg, sd, stack, &closure_weight, node);
}
break;
SVM_CASE(NODE_MIX_CLOSURE)
svm_node_mix_closure(sd, &svm, node);
svm_node_mix_closure(sd, stack, node);
break;
SVM_CASE(NODE_JUMP_IF_ZERO)
if (stack_load_float(&svm, node.z) <= 0.0f) {
svm.offset += node.y;
if (stack_load_float(stack, node.z) <= 0.0f) {
offset += node.y;
}
break;
SVM_CASE(NODE_JUMP_IF_ONE)
if (stack_load_float(&svm, node.z) >= 1.0f) {
svm.offset += node.y;
if (stack_load_float(stack, node.z) >= 1.0f) {
offset += node.y;
}
break;
SVM_CASE(NODE_GEOMETRY)
svm_node_geometry(kg, sd, &svm, node.y, node.z);
svm_node_geometry(kg, sd, stack, node.y, node.z);
break;
SVM_CASE(NODE_CONVERT)
svm_node_convert(kg, sd, &svm, node.y, node.z, node.w);
svm_node_convert(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_TEX_COORD)
svm_node_tex_coord(kg, sd, path_flag, &svm, node);
offset = svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);
break;
SVM_CASE(NODE_VALUE_F)
svm_node_value_f(kg, sd, &svm, node.y, node.z);
svm_node_value_f(kg, sd, stack, node.y, node.z);
break;
SVM_CASE(NODE_VALUE_V)
svm_node_value_v(kg, sd, &svm, node.y);
offset = svm_node_value_v(kg, sd, stack, node.y, offset);
break;
SVM_CASE(NODE_ATTR)
svm_node_attr<node_feature_mask>(kg, sd, &svm, node);
svm_node_attr<node_feature_mask>(kg, sd, stack, node);
break;
SVM_CASE(NODE_VERTEX_COLOR)
svm_node_vertex_color(kg, sd, &svm, node.y, node.z, node.w);
svm_node_vertex_color(kg, sd, stack, 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, &svm, node.y, node.z);
svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z);
}
break;
SVM_CASE(NODE_GEOMETRY_BUMP_DY)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_geometry_bump_dy(kg, sd, &svm, node.y, node.z);
svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z);
}
break;
SVM_CASE(NODE_SET_DISPLACEMENT)
svm_node_set_displacement<node_feature_mask>(kg, sd, &svm, node.y);
svm_node_set_displacement<node_feature_mask>(kg, sd, stack, node.y);
break;
SVM_CASE(NODE_DISPLACEMENT)
svm_node_displacement<node_feature_mask>(kg, sd, &svm, node);
svm_node_displacement<node_feature_mask>(kg, sd, stack, node);
break;
SVM_CASE(NODE_VECTOR_DISPLACEMENT)
svm_node_vector_displacement<node_feature_mask>(kg, sd, &svm, node);
offset = svm_node_vector_displacement<node_feature_mask>(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_TEX_IMAGE)
svm_node_tex_image(kg, sd, &svm, node);
offset = svm_node_tex_image(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_TEX_IMAGE_BOX)
svm_node_tex_image_box(kg, sd, &svm, node);
svm_node_tex_image_box(kg, sd, stack, node);
break;
SVM_CASE(NODE_TEX_NOISE)
svm_node_tex_noise(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_tex_noise(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_SET_BUMP)
svm_node_set_bump<node_feature_mask>(kg, sd, &svm, node);
svm_node_set_bump<node_feature_mask>(kg, sd, stack, node);
break;
SVM_CASE(NODE_ATTR_BUMP_DX)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_attr_bump_dx(kg, sd, &svm, node);
svm_node_attr_bump_dx(kg, sd, stack, node);
}
break;
SVM_CASE(NODE_ATTR_BUMP_DY)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_attr_bump_dy(kg, sd, &svm, node);
svm_node_attr_bump_dy(kg, sd, stack, node);
}
break;
SVM_CASE(NODE_VERTEX_COLOR_BUMP_DX)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_vertex_color_bump_dx(kg, sd, &svm, node.y, node.z, node.w);
svm_node_vertex_color_bump_dx(kg, sd, stack, 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, &svm, node.y, node.z, node.w);
svm_node_vertex_color_bump_dy(kg, sd, stack, node.y, node.z, node.w);
}
break;
SVM_CASE(NODE_TEX_COORD_BUMP_DX)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_tex_coord_bump_dx(kg, sd, path_flag, &svm, node);
offset = svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node, offset);
}
break;
SVM_CASE(NODE_TEX_COORD_BUMP_DY)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_tex_coord_bump_dy(kg, sd, path_flag, &svm, node);
offset = svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node, offset);
}
break;
SVM_CASE(NODE_CLOSURE_SET_NORMAL)
IF_KERNEL_NODES_FEATURE(BUMP)
{
svm_node_set_normal(kg, sd, &svm, node.y, node.z);
svm_node_set_normal(kg, sd, stack, node.y, node.z);
}
break;
SVM_CASE(NODE_ENTER_BUMP_EVAL)
IF_KERNEL_NODES_FEATURE(BUMP_STATE)
{
svm_node_enter_bump_eval(kg, sd, &svm, node.y);
svm_node_enter_bump_eval(kg, sd, stack, node.y);
}
break;
SVM_CASE(NODE_LEAVE_BUMP_EVAL)
IF_KERNEL_NODES_FEATURE(BUMP_STATE)
{
svm_node_leave_bump_eval(kg, sd, &svm, node.y);
svm_node_leave_bump_eval(kg, sd, stack, node.y);
}
break;
SVM_CASE(NODE_HSV)
svm_node_hsv(kg, sd, &svm, node);
svm_node_hsv(kg, sd, stack, node);
break;
SVM_CASE(NODE_CLOSURE_HOLDOUT)
svm_node_closure_holdout(sd, &svm, node);
svm_node_closure_holdout(sd, stack, closure_weight, node);
break;
SVM_CASE(NODE_FRESNEL)
svm_node_fresnel(sd, &svm, node.y, node.z, node.w);
svm_node_fresnel(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_LAYER_WEIGHT)
svm_node_layer_weight(sd, &svm, node);
svm_node_layer_weight(sd, stack, node);
break;
SVM_CASE(NODE_CLOSURE_VOLUME)
IF_KERNEL_NODES_FEATURE(VOLUME)
{
svm_node_closure_volume<type>(kg, sd, &svm, node);
svm_node_closure_volume<type>(kg, sd, stack, closure_weight, node);
}
break;
SVM_CASE(NODE_PRINCIPLED_VOLUME)
IF_KERNEL_NODES_FEATURE(VOLUME)
{
svm_node_principled_volume<type>(kg, sd, &svm, node, path_flag);
offset = svm_node_principled_volume<type>(
kg, sd, stack, closure_weight, node, path_flag, offset);
}
break;
SVM_CASE(NODE_MATH)
svm_node_math(kg, sd, &svm, node.y, node.z, node.w);
svm_node_math(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_VECTOR_MATH)
svm_node_vector_math(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_vector_math(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_RGB_RAMP)
svm_node_rgb_ramp(kg, sd, &svm, node);
offset = svm_node_rgb_ramp(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_GAMMA)
svm_node_gamma(sd, &svm, node.y, node.z, node.w);
svm_node_gamma(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_BRIGHTCONTRAST)
svm_node_brightness(sd, &svm, node.y, node.z, node.w);
svm_node_brightness(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_LIGHT_PATH)
svm_node_light_path<node_feature_mask>(kg, state, sd, &svm, node.y, node.z, path_flag);
svm_node_light_path<node_feature_mask>(kg, state, sd, stack, node.y, node.z, path_flag);
break;
SVM_CASE(NODE_OBJECT_INFO)
svm_node_object_info(kg, sd, &svm, node.y, node.z);
svm_node_object_info(kg, sd, stack, node.y, node.z);
break;
SVM_CASE(NODE_PARTICLE_INFO)
svm_node_particle_info(kg, sd, &svm, node.y, node.z);
svm_node_particle_info(kg, sd, stack, node.y, node.z);
break;
#if defined(__HAIR__)
SVM_CASE(NODE_HAIR_INFO)
svm_node_hair_info(kg, sd, &svm, node.y, node.z);
svm_node_hair_info(kg, sd, stack, node.y, node.z);
break;
#endif
#if defined(__POINTCLOUD__)
SVM_CASE(NODE_POINT_INFO)
svm_node_point_info(kg, sd, &svm, node.y, node.z);
svm_node_point_info(kg, sd, stack, node.y, node.z);
break;
#endif
SVM_CASE(NODE_TEXTURE_MAPPING)
svm_node_texture_mapping(kg, sd, &svm, node.y, node.z);
offset = svm_node_texture_mapping(kg, sd, stack, node.y, node.z, offset);
break;
SVM_CASE(NODE_MAPPING)
svm_node_mapping(kg, sd, &svm, node.y, node.z, node.w);
svm_node_mapping(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_MIN_MAX)
svm_node_min_max(kg, sd, &svm, node.y, node.z);
offset = svm_node_min_max(kg, sd, stack, node.y, node.z, offset);
break;
SVM_CASE(NODE_CAMERA)
svm_node_camera(kg, sd, &svm, node.y, node.z, node.w);
svm_node_camera(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_TEX_ENVIRONMENT)
svm_node_tex_environment(kg, sd, &svm, node);
svm_node_tex_environment(kg, sd, stack, node);
break;
SVM_CASE(NODE_TEX_SKY)
svm_node_tex_sky(kg, sd, path_flag, &svm, node);
offset = svm_node_tex_sky(kg, sd, path_flag, stack, node, offset);
break;
SVM_CASE(NODE_TEX_GRADIENT)
svm_node_tex_gradient(sd, &svm, node);
svm_node_tex_gradient(sd, stack, node);
break;
SVM_CASE(NODE_TEX_VORONOI)
svm_node_tex_voronoi<node_feature_mask>(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_tex_voronoi<node_feature_mask>(
kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_TEX_GABOR)
svm_node_tex_gabor(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_tex_gabor(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_TEX_WAVE)
svm_node_tex_wave(kg, sd, &svm, node);
offset = svm_node_tex_wave(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_TEX_MAGIC)
svm_node_tex_magic(kg, sd, &svm, node);
offset = svm_node_tex_magic(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_TEX_CHECKER)
svm_node_tex_checker(kg, sd, &svm, node);
svm_node_tex_checker(kg, sd, stack, node);
break;
SVM_CASE(NODE_TEX_BRICK)
svm_node_tex_brick(kg, sd, &svm, node);
offset = svm_node_tex_brick(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_TEX_WHITE_NOISE)
svm_node_tex_white_noise(kg, sd, &svm, node.y, node.z, node.w);
svm_node_tex_white_noise(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_NORMAL)
svm_node_normal(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_normal(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_LIGHT_FALLOFF)
svm_node_light_falloff(sd, &svm, node);
svm_node_light_falloff(sd, stack, node);
break;
SVM_CASE(NODE_IES)
svm_node_ies(kg, sd, &svm, node);
svm_node_ies(kg, sd, stack, node);
break;
SVM_CASE(NODE_CURVES)
svm_node_curves(kg, sd, &svm, node);
offset = svm_node_curves(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_FLOAT_CURVE)
svm_node_curve(kg, sd, &svm, node);
offset = svm_node_curve(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_TANGENT)
svm_node_tangent(kg, sd, &svm, node);
svm_node_tangent(kg, sd, stack, node);
break;
SVM_CASE(NODE_NORMAL_MAP)
svm_node_normal_map(kg, sd, &svm, node);
svm_node_normal_map(kg, sd, stack, node);
break;
SVM_CASE(NODE_INVERT)
svm_node_invert(sd, &svm, node.y, node.z, node.w);
svm_node_invert(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_MIX)
svm_node_mix(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_mix(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_SEPARATE_COLOR)
svm_node_separate_color(kg, sd, &svm, node.y, node.z, node.w);
svm_node_separate_color(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_COMBINE_COLOR)
svm_node_combine_color(kg, sd, &svm, node.y, node.z, node.w);
svm_node_combine_color(kg, sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_SEPARATE_VECTOR)
svm_node_separate_vector(sd, &svm, node.y, node.z, node.w);
svm_node_separate_vector(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_COMBINE_VECTOR)
svm_node_combine_vector(sd, &svm, node.y, node.z, node.w);
svm_node_combine_vector(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_SEPARATE_HSV)
svm_node_separate_hsv(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_separate_hsv(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_COMBINE_HSV)
svm_node_combine_hsv(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_combine_hsv(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_VECTOR_ROTATE)
svm_node_vector_rotate(sd, &svm, node.y, node.z, node.w);
svm_node_vector_rotate(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_VECTOR_TRANSFORM)
svm_node_vector_transform(kg, sd, &svm, node);
svm_node_vector_transform(kg, sd, stack, node);
break;
SVM_CASE(NODE_WIREFRAME)
svm_node_wireframe(kg, sd, &svm, node);
svm_node_wireframe(kg, sd, stack, node);
break;
SVM_CASE(NODE_WAVELENGTH)
svm_node_wavelength(kg, sd, &svm, node.y, node.z);
svm_node_wavelength(kg, sd, stack, node.y, node.z);
break;
SVM_CASE(NODE_BLACKBODY)
svm_node_blackbody(kg, sd, &svm, node.y, node.z);
svm_node_blackbody(kg, sd, stack, node.y, node.z);
break;
SVM_CASE(NODE_MAP_RANGE)
svm_node_map_range(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_map_range(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_VECTOR_MAP_RANGE)
svm_node_vector_map_range(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_vector_map_range(kg, sd, stack, node.y, node.z, node.w, offset);
break;
SVM_CASE(NODE_CLAMP)
svm_node_clamp(kg, sd, &svm, node.y, node.z, node.w);
offset = svm_node_clamp(kg, sd, stack, node.y, node.z, node.w, offset);
break;
#ifdef __SHADER_RAYTRACE__
SVM_CASE(NODE_BEVEL)
svm_node_bevel<node_feature_mask>(kg, state, sd, &svm, node);
svm_node_bevel<node_feature_mask>(kg, state, sd, stack, node);
break;
SVM_CASE(NODE_AMBIENT_OCCLUSION)
svm_node_ao<node_feature_mask>(kg, state, sd, &svm, node);
svm_node_ao<node_feature_mask>(kg, state, sd, stack, node);
break;
#endif
SVM_CASE(NODE_TEX_VOXEL)
svm_node_tex_voxel<node_feature_mask>(kg, sd, &svm, node);
offset = svm_node_tex_voxel<node_feature_mask>(kg, sd, stack, node, offset);
break;
SVM_CASE(NODE_AOV_START)
if (!svm_node_aov_check(path_flag, render_buffer)) {
@@ -588,22 +586,22 @@ ccl_device void svm_eval_nodes(KernelGlobals kg,
}
break;
SVM_CASE(NODE_AOV_COLOR)
svm_node_aov_color<node_feature_mask>(kg, state, sd, &svm, node, render_buffer);
svm_node_aov_color<node_feature_mask>(kg, state, sd, stack, node, render_buffer);
break;
SVM_CASE(NODE_AOV_VALUE)
svm_node_aov_value<node_feature_mask>(kg, state, sd, &svm, node, render_buffer);
svm_node_aov_value<node_feature_mask>(kg, state, sd, stack, node, render_buffer);
break;
SVM_CASE(NODE_MIX_COLOR)
svm_node_mix_color(sd, &svm, node.y, node.z, node.w);
svm_node_mix_color(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_MIX_FLOAT)
svm_node_mix_float(sd, &svm, node.y, node.z, node.w);
svm_node_mix_float(sd, stack, node.y, node.z, node.w);
break;
SVM_CASE(NODE_MIX_VECTOR)
svm_node_mix_vector(sd, &svm, node.y, node.z);
svm_node_mix_vector(sd, stack, node.y, node.z);
break;
SVM_CASE(NODE_MIX_VECTOR_NON_UNIFORM)
svm_node_mix_vector_non_uniform(sd, &svm, node.y, node.z);
svm_node_mix_vector_non_uniform(sd, stack, node.y, node.z);
break;
default:
kernel_assert(!"Unknown node type was passed to the SVM machine");

82
intern/cycles/kernel/svm/tex_coord.h
View File

@@ -12,11 +12,12 @@ CCL_NAMESPACE_BEGIN
/* Texture Coordinate Node */
ccl_device_noinline void svm_node_tex_coord(KernelGlobals kg,
ccl_private ShaderData *sd,
uint32_t path_flag,
ccl_private SVMState *svm,
uint4 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)
{
float3 data = zero_float3();
uint type = node.y;
@@ -32,9 +33,9 @@ ccl_device_noinline void svm_node_tex_coord(KernelGlobals kg,
}
else {
Transform tfm;
tfm.x = read_node_float(kg, svm);
tfm.y = read_node_float(kg, svm);
tfm.z = read_node_float(kg, svm);
tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, &offset);
data = transform_point(&tfm, data);
}
break;
@@ -88,14 +89,16 @@ ccl_device_noinline void svm_node_tex_coord(KernelGlobals kg,
}
}
stack_store_float3(svm, out_offset, data);
stack_store_float3(stack, out_offset, data);
return 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)
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)
{
#ifdef __RAY_DIFFERENTIALS__
float3 data = zero_float3();
@@ -112,9 +115,9 @@ ccl_device_noinline void svm_node_tex_coord_bump_dx(KernelGlobals kg,
}
else {
Transform tfm;
tfm.x = read_node_float(kg, svm);
tfm.y = read_node_float(kg, svm);
tfm.z = read_node_float(kg, svm);
tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, &offset);
data = transform_point(&tfm, data);
}
break;
@@ -168,17 +171,19 @@ ccl_device_noinline void svm_node_tex_coord_bump_dx(KernelGlobals kg,
}
}
stack_store_float3(svm, out_offset, data);
stack_store_float3(stack, out_offset, data);
return offset;
#else
svm_node_tex_coord(kg, sd, path_flag, stack, node);
return svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);
#endif
}
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)
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)
{
#ifdef __RAY_DIFFERENTIALS__
float3 data = zero_float3();
@@ -195,9 +200,9 @@ ccl_device_noinline void svm_node_tex_coord_bump_dy(KernelGlobals kg,
}
else {
Transform tfm;
tfm.x = read_node_float(kg, svm);
tfm.y = read_node_float(kg, svm);
tfm.z = read_node_float(kg, svm);
tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, &offset);
data = transform_point(&tfm, data);
}
break;
@@ -251,31 +256,32 @@ ccl_device_noinline void svm_node_tex_coord_bump_dy(KernelGlobals kg,
}
}
stack_store_float3(svm, out_offset, data);
stack_store_float3(stack, out_offset, data);
return offset;
#else
svm_node_tex_coord(kg, sd, path_flag, stack, node);
return svm_node_tex_coord(kg, sd, path_flag, stack, node, offset);
#endif
}
ccl_device_noinline void svm_node_normal_map(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, color_offset);
float3 color = stack_load_float3(stack, 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(svm, strength_offset);
float strength = stack_load_float(stack, 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(svm, normal_offset, sd->N);
stack_store_float3(stack, normal_offset, sd->N);
return;
}
@@ -285,7 +291,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(svm, normal_offset, sd->N);
stack_store_float3(stack, normal_offset, sd->N);
return;
}
@@ -357,12 +363,12 @@ ccl_device_noinline void svm_node_normal_map(KernelGlobals kg,
N = sd->N;
}
stack_store_float3(svm, normal_offset, N);
stack_store_float3(stack, normal_offset, N);
}
ccl_device_noinline void svm_node_tangent(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint tangent_offset, direction_type, axis;
@@ -386,7 +392,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(svm, tangent_offset, zero_float3());
stack_store_float3(stack, tangent_offset, zero_float3());
return;
}
else {
@@ -412,7 +418,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(svm, tangent_offset, tangent);
stack_store_float3(stack, tangent_offset, tangent);
}
CCL_NAMESPACE_END

18
intern/cycles/kernel/svm/value.h
View File

@@ -10,24 +10,26 @@ CCL_NAMESPACE_BEGIN
ccl_device void svm_node_value_f(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint ivalue,
uint out_offset)
{
stack_store_float(svm, out_offset, __uint_as_float(ivalue));
stack_store_float(stack, out_offset, __uint_as_float(ivalue));
}
ccl_device void svm_node_value_v(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint out_offset)
ccl_device int svm_node_value_v(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private float *stack,
uint out_offset,
int offset)
{
/* read extra data */
uint4 node1 = read_node(kg, svm);
uint4 node1 = read_node(kg, &offset);
float3 p = make_float3(
__uint_as_float(node1.y), __uint_as_float(node1.z), __uint_as_float(node1.w));
stack_store_float3(svm, out_offset, p);
stack_store_float3(stack, out_offset, p);
return offset;
}
CCL_NAMESPACE_END

14
intern/cycles/kernel/svm/vector_rotate.h
View File

@@ -9,7 +9,7 @@ CCL_NAMESPACE_BEGIN
/* Vector Rotate */
ccl_device_noinline void svm_node_vector_rotate(ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, vector_stack_offset);
float3 center = stack_load_float3(svm, center_stack_offset);
float3 vector = stack_load_float3(stack, vector_stack_offset);
float3 center = stack_load_float3(stack, 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(svm, rotation_stack_offset); // Default XYZ.
float3 rotation = stack_load_float3(stack, 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(svm, axis_stack_offset);
axis = stack_load_float3(stack, axis_stack_offset);
axis_length = len(axis);
break;
}
float angle = stack_load_float(svm, angle_stack_offset);
float angle = stack_load_float(stack, 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(svm, result_stack_offset, result);
stack_store_float3(stack, result_stack_offset, result);
}
}

6
intern/cycles/kernel/svm/vector_transform.h
View File

@@ -10,7 +10,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_vector_transform(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, vector_in);
float3 in = stack_load_float3(stack, 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(svm, vector_out, in);
stack_store_float3(stack, vector_out, in);
}
}

42
intern/cycles/kernel/svm/vertex_color.h
View File

@@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_vertex_color(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, color_offset, float4_to_float3(vertex_color));
stack_store_float(svm, alpha_offset, vertex_color.w);
stack_store_float3(stack, color_offset, float4_to_float3(vertex_color));
stack_store_float(stack, alpha_offset, vertex_color.w);
}
else {
float3 vertex_color = primitive_surface_attribute_float3(kg, sd, descriptor, NULL, NULL);
stack_store_float3(svm, color_offset, vertex_color);
stack_store_float(svm, alpha_offset, 1.0f);
stack_store_float3(stack, color_offset, vertex_color);
stack_store_float(stack, alpha_offset, 1.0f);
}
}
else {
stack_store_float3(svm, color_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float(svm, alpha_offset, 0.0f);
stack_store_float3(stack, color_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float(stack, alpha_offset, 0.0f);
}
}
ccl_device_noinline void svm_node_vertex_color_bump_dx(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, color_offset, float4_to_float3(vertex_color));
stack_store_float(svm, alpha_offset, vertex_color.w);
stack_store_float3(stack, color_offset, float4_to_float3(vertex_color));
stack_store_float(stack, 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(svm, color_offset, vertex_color);
stack_store_float(svm, alpha_offset, 1.0f);
stack_store_float3(stack, color_offset, vertex_color);
stack_store_float(stack, alpha_offset, 1.0f);
}
}
else {
stack_store_float3(svm, color_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float(svm, alpha_offset, 0.0f);
stack_store_float3(stack, color_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float(stack, alpha_offset, 0.0f);
}
}
ccl_device_noinline void svm_node_vertex_color_bump_dy(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
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(svm, color_offset, float4_to_float3(vertex_color));
stack_store_float(svm, alpha_offset, vertex_color.w);
stack_store_float3(stack, color_offset, float4_to_float3(vertex_color));
stack_store_float(stack, 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(svm, color_offset, vertex_color);
stack_store_float(svm, alpha_offset, 1.0f);
stack_store_float3(stack, color_offset, vertex_color);
stack_store_float(stack, alpha_offset, 1.0f);
}
}
else {
stack_store_float3(svm, color_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float(svm, alpha_offset, 0.0f);
stack_store_float3(stack, color_offset, make_float3(0.0f, 0.0f, 0.0f));
stack_store_float(stack, alpha_offset, 0.0f);
}
}

57
intern/cycles/kernel/svm/voronoi.h
View File

@@ -982,7 +982,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 SVMState *svm,
ccl_private float *stack,
const float distance,
const float3 color,
const float3 position,
@@ -998,29 +998,30 @@ 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(svm, distance_stack_offset, distance);
stack_store_float(stack, distance_stack_offset, distance);
if (stack_valid(color_stack_offset))
stack_store_float3(svm, color_stack_offset, color);
stack_store_float3(stack, color_stack_offset, color);
if (stack_valid(position_stack_offset))
stack_store_float3(svm, position_stack_offset, position);
stack_store_float3(stack, position_stack_offset, position);
if (stack_valid(w_out_stack_offset))
stack_store_float(svm, w_out_stack_offset, w);
stack_store_float(stack, w_out_stack_offset, w);
if (stack_valid(radius_stack_offset))
stack_store_float(svm, radius_stack_offset, radius);
stack_store_float(stack, radius_stack_offset, radius);
}
template<uint node_feature_mask>
ccl_device_noinline void svm_node_tex_voronoi(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint dimensions,
uint feature,
uint metric)
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)
{
/* Read node defaults and stack offsets. */
uint4 stack_offsets = read_node(kg, svm);
uint4 defaults1 = read_node(kg, svm);
uint4 defaults2 = read_node(kg, svm);
uint4 stack_offsets = read_node(kg, &offset);
uint4 defaults1 = read_node(kg, &offset);
uint4 defaults2 = read_node(kg, &offset);
uint coord_stack_offset, w_stack_offset, scale_stack_offset, detail_stack_offset;
uint roughness_stack_offset, lacunarity_stack_offset, smoothness_stack_offset,
@@ -1040,19 +1041,19 @@ ccl_device_noinline void 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(svm, coord_stack_offset);
float w = stack_load_float_default(svm, w_stack_offset, defaults1.x);
float3 coord = stack_load_float3(stack, coord_stack_offset);
float w = stack_load_float_default(stack, w_stack_offset, defaults1.x);
VoronoiParams params;
params.feature = (NodeVoronoiFeature)feature;
params.metric = (NodeVoronoiDistanceMetric)metric;
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, lacunarity_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.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, lacunarity_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.max_distance = 0.0f;
params.normalize = normalize;
@@ -1084,7 +1085,7 @@ ccl_device_noinline void svm_node_tex_voronoi(KernelGlobals kg,
break;
}
svm_voronoi_output(stack_offsets, svm, distance, zero_float3(), zero_float3(), 0.0f, 0.0f);
svm_voronoi_output(stack_offsets, stack, distance, zero_float3(), zero_float3(), 0.0f, 0.0f);
break;
}
case NODE_VORONOI_N_SPHERE_RADIUS: {
@@ -1104,7 +1105,7 @@ ccl_device_noinline void svm_node_tex_voronoi(KernelGlobals kg,
break;
}
svm_voronoi_output(stack_offsets, svm, 0.0f, zero_float3(), zero_float3(), 0.0f, radius);
svm_voronoi_output(stack_offsets, stack, 0.0f, zero_float3(), zero_float3(), 0.0f, radius);
break;
}
default: {
@@ -1154,7 +1155,7 @@ ccl_device_noinline void svm_node_tex_voronoi(KernelGlobals kg,
}
svm_voronoi_output(stack_offsets,
svm,
stack,
output.distance,
output.color,
float4_to_float3(output.position),
@@ -1163,6 +1164,8 @@ ccl_device_noinline void svm_node_tex_voronoi(KernelGlobals kg,
break;
}
}
return offset;
}
CCL_NAMESPACE_END

25
intern/cycles/kernel/svm/voxel.h
View File

@@ -10,10 +10,8 @@ CCL_NAMESPACE_BEGIN
* sampler.
*/
template<uint node_feature_mask>
ccl_device_noinline void svm_node_tex_voxel(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_tex_voxel(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
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);
@@ -24,16 +22,16 @@ ccl_device_noinline void svm_node_tex_voxel(KernelGlobals kg,
IF_KERNEL_NODES_FEATURE(VOLUME)
{
int id = node.y;
float3 co = stack_load_float3(svm, co_offset);
float3 co = stack_load_float3(stack, 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, svm);
tfm.y = read_node_float(kg, svm);
tfm.z = read_node_float(kg, svm);
tfm.x = read_node_float(kg, &offset);
tfm.y = read_node_float(kg, &offset);
tfm.z = read_node_float(kg, &offset);
co = transform_point(&tfm, co);
}
@@ -43,17 +41,18 @@ ccl_device_noinline void svm_node_tex_voxel(KernelGlobals kg,
#endif /* __VOLUME__ */
if (space != NODE_TEX_VOXEL_SPACE_OBJECT)
{
read_node_float(kg, svm);
read_node_float(kg, svm);
read_node_float(kg, svm);
read_node_float(kg, &offset);
read_node_float(kg, &offset);
read_node_float(kg, &offset);
}
if (stack_valid(density_out_offset)) {
stack_store_float(svm, density_out_offset, r.w);
stack_store_float(stack, density_out_offset, r.w);
}
if (stack_valid(color_out_offset)) {
stack_store_float3(svm, color_out_offset, make_float3(r.x, r.y, r.z));
stack_store_float3(stack, color_out_offset, make_float3(r.x, r.y, r.z));
}
return offset;
}
CCL_NAMESPACE_END

29
intern/cycles/kernel/svm/wave.h
View File

@@ -73,13 +73,11 @@ ccl_device_noinline_cpu float svm_wave(NodeWaveType type,
}
}
ccl_device_noinline void svm_node_tex_wave(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
uint4 node)
ccl_device_noinline int svm_node_tex_wave(
KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint4 node, int offset)
{
uint4 node2 = read_node(kg, svm);
uint4 node3 = read_node(kg, svm);
uint4 node2 = read_node(kg, &offset);
uint4 node3 = read_node(kg, &offset);
/* RNA properties */
uint type_offset, bands_dir_offset, rings_dir_offset, profile_offset;
@@ -95,13 +93,13 @@ ccl_device_noinline void svm_node_tex_wave(KernelGlobals kg,
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(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);
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);
float f = svm_wave((NodeWaveType)type_offset,
(NodeWaveBandsDirection)bands_dir_offset,
@@ -115,9 +113,10 @@ ccl_device_noinline void svm_node_tex_wave(KernelGlobals kg,
phase);
if (stack_valid(fac_offset))
stack_store_float(svm, fac_offset, f);
stack_store_float(stack, fac_offset, f);
if (stack_valid(color_offset))
stack_store_float3(svm, color_offset, make_float3(f, f, f));
stack_store_float3(stack, color_offset, make_float3(f, f, f));
return offset;
}
CCL_NAMESPACE_END

6
intern/cycles/kernel/svm/wavelength.h
View File

@@ -13,11 +13,11 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_wavelength(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint wavelength,
uint color_out)
{
float lambda_nm = stack_load_float(svm, wavelength);
float lambda_nm = stack_load_float(stack, 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(svm, color_out, color);
stack_store_float3(stack, color_out, color);
}
CCL_NAMESPACE_END

10
intern/cycles/kernel/svm/white_noise.h
View File

@@ -8,7 +8,7 @@ CCL_NAMESPACE_BEGIN
ccl_device_noinline void svm_node_tex_white_noise(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint dimensions,
uint inputs_stack_offsets,
uint outputs_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(outputs_stack_offsets, &value_stack_offset, &color_stack_offset);
float3 vector = stack_load_float3(svm, vector_stack_offset);
float w = stack_load_float(svm, w_stack_offset);
float3 vector = stack_load_float3(stack, vector_stack_offset);
float w = stack_load_float(stack, 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(svm, color_stack_offset, color);
stack_store_float3(stack, 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(svm, value_stack_offset, value);
stack_store_float(stack, value_stack_offset, value);
}
}

6
intern/cycles/kernel/svm/wireframe.h
View File

@@ -74,7 +74,7 @@ ccl_device_inline float wireframe(KernelGlobals kg,
ccl_device_noinline void svm_node_wireframe(KernelGlobals kg,
ccl_private ShaderData *sd,
ccl_private SVMState *svm,
ccl_private float *stack,
uint4 node)
{
uint in_size = node.y;
@@ -83,7 +83,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(svm, in_size);
float size = stack_load_float(stack, in_size);
int pixel_size = (int)use_pixel_size;
/* Calculate wireframe */
@@ -101,7 +101,7 @@ ccl_device_noinline void svm_node_wireframe(KernelGlobals kg,
}
if (stack_valid(out_fac))
stack_store_float(svm, out_fac, f);
stack_store_float(stack, out_fac, f);
}
CCL_NAMESPACE_END