Cycles: replace integrator state argument macros

* Rename struct KernelGlobals to struct KernelGlobalsCPU
* Add KernelGlobals, IntegratorState and ConstIntegratorState typedefs
  that every device can define in its own way.
* Remove INTEGRATOR_STATE_ARGS and INTEGRATOR_STATE_PASS macros and
  replace with these new typedefs.
* Add explicit state argument to INTEGRATOR_STATE and similar macros

In preparation for decoupling main and shadow paths.

Differential Revision: https://developer.blender.org/D12888

1 files changed, 54 insertions, 32 deletions

diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h
index 871e370123e..9692308c496 100644
--- a/intern/cycles/kernel/svm/svm.h
+++ b/intern/cycles/kernel/svm/svm.h
@@ -107,15 +107,14 @@ ccl_device_inline bool stack_valid(uint a)
 
 /* Reading Nodes */
 
-ccl_device_inline uint4 read_node(ccl_global const KernelGlobals *kg, ccl_private int *offset)
+ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private int *offset)
 {
   uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
   (*offset)++;
   return node;
 }
 
-ccl_device_inline float4 read_node_float(ccl_global const KernelGlobals *kg,
-                                         ccl_private int *offset)
+ccl_device_inline float4 read_node_float(KernelGlobals kg, ccl_private int *offset)
 {
   uint4 node = kernel_tex_fetch(__svm_nodes, *offset);
   float4 f = make_float4(__uint_as_float(node.x),
@@ -126,7 +125,7 @@ ccl_device_inline float4 read_node_float(ccl_global const KernelGlobals *kg,
   return f;
 }
 
-ccl_device_inline float4 fetch_node_float(ccl_global const KernelGlobals *kg, int offset)
+ccl_device_inline float4 fetch_node_float(KernelGlobals kg, int offset)
 {
   uint4 node = kernel_tex_fetch(__svm_nodes, offset);
   return make_float4(__uint_as_float(node.x),
@@ -227,7 +226,8 @@ CCL_NAMESPACE_BEGIN
 
 /* Main Interpreter Loop */
 template<uint node_feature_mask, ShaderType type>
-ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
+ccl_device void svm_eval_nodes(KernelGlobals kg,
+                               ConstIntegratorState state,
                                ShaderData *sd,
                                ccl_global float *render_buffer,
                                int path_flag)
@@ -257,12 +257,14 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
             kg, sd, stack, node, path_flag, offset);
         break;
       case NODE_CLOSURE_EMISSION:
-        if (KERNEL_NODES_FEATURE(EMISSION)) {
+        IF_KERNEL_NODES_FEATURE(EMISSION)
+        {
           svm_node_closure_emission(sd, stack, node);
         }
         break;
       case NODE_CLOSURE_BACKGROUND:
-        if (KERNEL_NODES_FEATURE(EMISSION)) {
+        IF_KERNEL_NODES_FEATURE(EMISSION)
+        {
           svm_node_closure_background(sd, stack, node);
         }
         break;
@@ -273,7 +275,8 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         svm_node_closure_weight(sd, stack, node.y);
         break;
       case NODE_EMISSION_WEIGHT:
-        if (KERNEL_NODES_FEATURE(EMISSION)) {
+        IF_KERNEL_NODES_FEATURE(EMISSION)
+        {
           svm_node_emission_weight(kg, sd, stack, node);
         }
         break;
@@ -310,27 +313,32 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         svm_node_vertex_color(kg, sd, stack, node.y, node.z, node.w);
         break;
       case NODE_GEOMETRY_BUMP_DX:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z);
         }
         break;
       case NODE_GEOMETRY_BUMP_DY:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z);
         }
         break;
       case NODE_SET_DISPLACEMENT:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_set_displacement(kg, sd, stack, node.y);
         }
         break;
       case NODE_DISPLACEMENT:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_displacement(kg, sd, stack, node);
         }
         break;
       case NODE_VECTOR_DISPLACEMENT:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           offset = svm_node_vector_displacement(kg, sd, stack, node, offset);
         }
         break;
@@ -344,52 +352,62 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         offset = svm_node_tex_noise(kg, sd, stack, node.y, node.z, node.w, offset);
         break;
       case NODE_SET_BUMP:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_set_bump(kg, sd, stack, node);
         }
         break;
       case NODE_ATTR_BUMP_DX:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_attr_bump_dx(kg, sd, stack, node);
         }
         break;
       case NODE_ATTR_BUMP_DY:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_attr_bump_dy(kg, sd, stack, node);
         }
         break;
       case NODE_VERTEX_COLOR_BUMP_DX:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_vertex_color_bump_dx(kg, sd, stack, node.y, node.z, node.w);
         }
         break;
       case NODE_VERTEX_COLOR_BUMP_DY:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_vertex_color_bump_dy(kg, sd, stack, node.y, node.z, node.w);
         }
         break;
       case NODE_TEX_COORD_BUMP_DX:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           offset = svm_node_tex_coord_bump_dx(kg, sd, path_flag, stack, node, offset);
         }
         break;
       case NODE_TEX_COORD_BUMP_DY:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           offset = svm_node_tex_coord_bump_dy(kg, sd, path_flag, stack, node, offset);
         }
         break;
       case NODE_CLOSURE_SET_NORMAL:
-        if (KERNEL_NODES_FEATURE(BUMP)) {
+        IF_KERNEL_NODES_FEATURE(BUMP)
+        {
           svm_node_set_normal(kg, sd, stack, node.y, node.z);
         }
         break;
       case NODE_ENTER_BUMP_EVAL:
-        if (KERNEL_NODES_FEATURE(BUMP_STATE)) {
+        IF_KERNEL_NODES_FEATURE(BUMP_STATE)
+        {
           svm_node_enter_bump_eval(kg, sd, stack, node.y);
         }
         break;
       case NODE_LEAVE_BUMP_EVAL:
-        if (KERNEL_NODES_FEATURE(BUMP_STATE)) {
+        IF_KERNEL_NODES_FEATURE(BUMP_STATE)
+        {
           svm_node_leave_bump_eval(kg, sd, stack, node.y);
         }
         break;
@@ -407,12 +425,14 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         svm_node_layer_weight(sd, stack, node);
         break;
       case NODE_CLOSURE_VOLUME:
-        if (KERNEL_NODES_FEATURE(VOLUME)) {
+        IF_KERNEL_NODES_FEATURE(VOLUME)
+        {
           svm_node_closure_volume<type>(kg, sd, stack, node);
         }
         break;
       case NODE_PRINCIPLED_VOLUME:
-        if (KERNEL_NODES_FEATURE(VOLUME)) {
+        IF_KERNEL_NODES_FEATURE(VOLUME)
+        {
           offset = svm_node_principled_volume<type>(kg, sd, stack, node, path_flag, offset);
         }
         break;
@@ -432,7 +452,7 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         svm_node_brightness(sd, stack, node.y, node.z, node.w);
         break;
       case NODE_LIGHT_PATH:
-        svm_node_light_path(INTEGRATOR_STATE_PASS, sd, stack, node.y, node.z, path_flag);
+        svm_node_light_path<node_feature_mask>(kg, state, sd, stack, node.y, node.z, path_flag);
         break;
       case NODE_OBJECT_INFO:
         svm_node_object_info(kg, sd, stack, node.y, node.z);
@@ -442,7 +462,8 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         break;
 #if defined(__HAIR__)
       case NODE_HAIR_INFO:
-        if (KERNEL_NODES_FEATURE(HAIR)) {
+        IF_KERNEL_NODES_FEATURE(HAIR)
+        {
           svm_node_hair_info(kg, sd, stack, node.y, node.z);
         }
         break;
@@ -554,15 +575,16 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         break;
 #ifdef __SHADER_RAYTRACE__
       case NODE_BEVEL:
-        svm_node_bevel<node_feature_mask>(INTEGRATOR_STATE_PASS, sd, stack, node);
+        svm_node_bevel<node_feature_mask>(kg, state, sd, stack, node);
         break;
       case NODE_AMBIENT_OCCLUSION:
-        svm_node_ao<node_feature_mask>(INTEGRATOR_STATE_PASS, sd, stack, node);
+        svm_node_ao<node_feature_mask>(kg, state, sd, stack, node);
         break;
 #endif
 
       case NODE_TEX_VOXEL:
-        if (KERNEL_NODES_FEATURE(VOLUME)) {
+        IF_KERNEL_NODES_FEATURE(VOLUME)
+        {
           offset = svm_node_tex_voxel(kg, sd, stack, node, offset);
         }
         break;
@@ -572,10 +594,10 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
         }
         break;
       case NODE_AOV_COLOR:
-        svm_node_aov_color(INTEGRATOR_STATE_PASS, sd, stack, node, render_buffer);
+        svm_node_aov_color<node_feature_mask>(kg, state, sd, stack, node, render_buffer);
         break;
       case NODE_AOV_VALUE:
-        svm_node_aov_value(INTEGRATOR_STATE_PASS, sd, stack, node, render_buffer);
+        svm_node_aov_value<node_feature_mask>(kg, state, sd, stack, node, render_buffer);
         break;
       default:
         kernel_assert(!"Unknown node type was passed to the SVM machine");