Cleanup: more refactoring of GPU material attributes and textures

This further separates requested attributes and textures from the actual
node graph, that can be retained after the graph has been compiled and
freed. It makes it easier to add volume grids as a native concept, which
sits somewhere between an attribute and a texture.

It also adds explicit link types for UDIM tile mapping, rather than
relying on fairly hidden logic.

1 files changed, 148 insertions, 263 deletions

diff --git a/source/blender/gpu/intern/gpu_codegen.c b/source/blender/gpu/intern/gpu_codegen.c
index 6c14d918816..553ecb65529 100644
--- a/source/blender/gpu/intern/gpu_codegen.c
+++ b/source/blender/gpu/intern/gpu_codegen.c
@@ -216,16 +216,6 @@ static void codegen_print_datatype(DynStr *ds, const eGPUType type, float *data)
   }
 }
 
-static int codegen_input_has_texture(GPUInput *input)
-{
-  if (input->link) {
-    return 0;
-  }
-  else {
-    return (input->source == GPU_SOURCE_TEX);
-  }
-}
-
 static const char *gpu_builtin_name(eGPUBuiltin builtin)
 {
   if (builtin == GPU_VIEW_MATRIX) {
@@ -299,14 +289,14 @@ static const char *gpu_builtin_name(eGPUBuiltin builtin)
   }
 }
 
-static void codegen_set_unique_ids(ListBase *nodes)
+static void codegen_set_unique_ids(GPUNodeGraph *graph)
 {
   GPUNode *node;
   GPUInput *input;
   GPUOutput *output;
   int id = 1;
 
-  for (node = nodes->first; node; node = node->next) {
+  for (node = graph->nodes.first; node; node = node->next) {
     for (input = node->inputs.first; input; input = input->next) {
       /* set id for unique names of uniform variables */
       input->id = id++;
@@ -322,7 +312,9 @@ static void codegen_set_unique_ids(ListBase *nodes)
 /**
  * It will create an UBO for GPUMaterial if there is any GPU_DYNAMIC_UBO.
  */
-static int codegen_process_uniforms_functions(GPUMaterial *material, DynStr *ds, ListBase *nodes)
+static int codegen_process_uniforms_functions(GPUMaterial *material,
+                                              DynStr *ds,
+                                              GPUNodeGraph *graph)
 {
   GPUNode *node;
   GPUInput *input;
@@ -330,27 +322,29 @@ static int codegen_process_uniforms_functions(GPUMaterial *material, DynStr *ds,
   int builtins = 0;
   ListBase ubo_inputs = {NULL, NULL};
 
-  /* print uniforms */
-  for (node = nodes->first; node; node = node->next) {
+  /* Attributes */
+  for (GPUMaterialAttribute *attr = graph->attributes.first; attr; attr = attr->next) {
+    BLI_dynstr_appendf(ds, "in %s var%d;\n", gpu_data_type_to_string(attr->gputype), attr->id);
+  }
+
+  /* Textures */
+  for (GPUMaterialTexture *tex = graph->textures.first; tex; tex = tex->next) {
+    if (tex->colorband) {
+      BLI_dynstr_appendf(ds, "uniform sampler1DArray %s;\n", tex->sampler_name);
+    }
+    else if (tex->tiled_mapping_name[0]) {
+      BLI_dynstr_appendf(ds, "uniform sampler2DArray %s;\n", tex->sampler_name);
+      BLI_dynstr_appendf(ds, "uniform sampler1DArray %s;\n", tex->tiled_mapping_name);
+    }
+    else {
+      BLI_dynstr_appendf(ds, "uniform sampler2D %s;\n", tex->sampler_name);
+    }
+  }
+
+  /* Print other uniforms */
+  for (node = graph->nodes.first; node; node = node->next) {
     for (input = node->inputs.first; input; input = input->next) {
-      if (input->source == GPU_SOURCE_TEX) {
-        /* create exactly one sampler for each texture */
-        if (codegen_input_has_texture(input) && input->bindtex) {
-          const char *type;
-          if (input->colorband || input->type == GPU_TEX1D_ARRAY) {
-            type = "sampler1DArray";
-          }
-          else if (input->type == GPU_TEX2D_ARRAY) {
-            type = "sampler2DArray";
-          }
-          else {
-            BLI_assert(input->type == GPU_TEX2D);
-            type = "sampler2D";
-          }
-          BLI_dynstr_appendf(ds, "uniform %s samp%d;\n", type, input->texid);
-        }
-      }
-      else if (input->source == GPU_SOURCE_BUILTIN) {
+      if (input->source == GPU_SOURCE_BUILTIN) {
         /* only define each builtin uniform/varying once */
         if (!(builtins & input->builtin)) {
           builtins |= input->builtin;
@@ -385,10 +379,6 @@ static int codegen_process_uniforms_functions(GPUMaterial *material, DynStr *ds,
         codegen_print_datatype(ds, input->type, input->vec);
         BLI_dynstr_append(ds, ";\n");
       }
-      else if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
-        BLI_dynstr_appendf(
-            ds, "in %s var%d;\n", gpu_data_type_to_string(input->type), input->attr_id);
-      }
     }
   }
 
@@ -412,12 +402,12 @@ static int codegen_process_uniforms_functions(GPUMaterial *material, DynStr *ds,
   return builtins;
 }
 
-static void codegen_declare_tmps(DynStr *ds, ListBase *nodes)
+static void codegen_declare_tmps(DynStr *ds, GPUNodeGraph *graph)
 {
   GPUNode *node;
   GPUOutput *output;
 
-  for (node = nodes->first; node; node = node->next) {
+  for (node = graph->nodes.first; node; node = node->next) {
     /* declare temporary variables for node output storage */
     for (output = node->outputs.first; output; output = output->next) {
       if (output->type == GPU_CLOSURE) {
@@ -432,18 +422,21 @@ static void codegen_declare_tmps(DynStr *ds, ListBase *nodes)
   BLI_dynstr_append(ds, "\n");
 }
 
-static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *finaloutput)
+static void codegen_call_functions(DynStr *ds, GPUNodeGraph *graph, GPUOutput *finaloutput)
 {
   GPUNode *node;
   GPUInput *input;
   GPUOutput *output;
 
-  for (node = nodes->first; node; node = node->next) {
+  for (node = graph->nodes.first; node; node = node->next) {
     BLI_dynstr_appendf(ds, "\t%s(", node->name);
 
     for (input = node->inputs.first; input; input = input->next) {
       if (input->source == GPU_SOURCE_TEX) {
-        BLI_dynstr_appendf(ds, "samp%d", input->texid);
+        BLI_dynstr_append(ds, input->texture->sampler_name);
+      }
+      else if (input->source == GPU_SOURCE_TEX_TILED_MAPPING) {
+        BLI_dynstr_append(ds, input->texture->tiled_mapping_name);
       }
       else if (input->source == GPU_SOURCE_OUTPUT) {
         codegen_convert_datatype(
@@ -507,7 +500,7 @@ static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *final
         BLI_dynstr_appendf(ds, "cons%d", input->id);
       }
       else if (input->source == GPU_SOURCE_ATTR) {
-        BLI_dynstr_appendf(ds, "var%d", input->attr_id);
+        BLI_dynstr_appendf(ds, "var%d", input->attr->id);
       }
 
       BLI_dynstr_append(ds, ", ");
@@ -527,7 +520,7 @@ static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *final
   BLI_dynstr_append(ds, ";\n");
 }
 
-static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUOutput *output)
+static char *code_generate_fragment(GPUMaterial *material, GPUNodeGraph *graph)
 {
   DynStr *ds = BLI_dynstr_new();
   char *code;
@@ -537,8 +530,8 @@ static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUO
   BLI_dynstr_append(ds, FUNCTION_PROTOTYPES);
 #endif
 
-  codegen_set_unique_ids(nodes);
-  builtins = codegen_process_uniforms_functions(material, ds, nodes);
+  codegen_set_unique_ids(graph);
+  builtins = codegen_process_uniforms_functions(material, ds, graph);
 
   if (builtins & (GPU_OBJECT_INFO | GPU_OBJECT_COLOR)) {
     BLI_dynstr_append(ds, datatoc_gpu_shader_common_obinfos_lib_glsl);
@@ -614,8 +607,8 @@ static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUO
     BLI_dynstr_append(ds, "\t#define viewposition viewPosition\n");
   }
 
-  codegen_declare_tmps(ds, nodes);
-  codegen_call_functions(ds, nodes, output);
+  codegen_declare_tmps(ds, graph);
+  codegen_call_functions(ds, graph, graph->outlink->output);
 
   BLI_dynstr_append(ds, "}\n");
 
@@ -666,7 +659,7 @@ static const char *attr_prefix_get(CustomDataType type)
   }
 }
 
-static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool use_geom)
+static char *code_generate_vertex(GPUNodeGraph *graph, const char *vert_code, bool use_geom)
 {
   DynStr *ds = BLI_dynstr_new();
   GPUNode *node;
@@ -682,48 +675,44 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
                     "#define DEFINE_ATTR(type, attr) in type attr\n"
                     "#endif\n");
 
-  for (node = nodes->first; node; node = node->next) {
+  for (GPUMaterialAttribute *attr = graph->attributes.first; attr; attr = attr->next) {
+    /* XXX FIXME : see notes in mesh_render_data_create() */
+    /* NOTE : Replicate changes to mesh_render_data_create() in draw_cache_impl_mesh.c */
+    if (attr->type == CD_ORCO) {
+      /* OPTI : orco is computed from local positions, but only if no modifier is present. */
+      BLI_dynstr_append(ds, datatoc_gpu_shader_common_obinfos_lib_glsl);
+      BLI_dynstr_append(ds, "DEFINE_ATTR(vec4, orco);\n");
+    }
+    else if (attr->name[0] == '\0') {
+      BLI_dynstr_appendf(ds,
+                         "DEFINE_ATTR(%s, %s);\n",
+                         gpu_data_type_to_string(attr->gputype),
+                         attr_prefix_get(attr->type));
+      BLI_dynstr_appendf(ds, "#define att%d %s\n", attr->id, attr_prefix_get(attr->type));
+    }
+    else {
+      char attr_safe_name[GPU_MAX_SAFE_ATTRIB_NAME];
+      GPU_vertformat_safe_attrib_name(attr->name, attr_safe_name, GPU_MAX_SAFE_ATTRIB_NAME);
+      BLI_dynstr_appendf(ds,
+                         "DEFINE_ATTR(%s, %s%s);\n",
+                         gpu_data_type_to_string(attr->gputype),
+                         attr_prefix_get(attr->type),
+                         attr_safe_name);
+      BLI_dynstr_appendf(
+          ds, "#define att%d %s%s\n", attr->id, attr_prefix_get(attr->type), attr_safe_name);
+    }
+    BLI_dynstr_appendf(ds,
+                       "out %s var%d%s;\n",
+                       gpu_data_type_to_string(attr->gputype),
+                       attr->id,
+                       use_geom ? "g" : "");
+  }
+
+  for (node = graph->nodes.first; node; node = node->next) {
     for (input = node->inputs.first; input; input = input->next) {
       if (input->source == GPU_SOURCE_BUILTIN) {
         builtins |= input->builtin;
       }
-      if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
-        /* XXX FIXME : see notes in mesh_render_data_create() */
-        /* NOTE : Replicate changes to mesh_render_data_create() in draw_cache_impl_mesh.c */
-        if (input->attr_type == CD_ORCO) {
-          /* OPTI : orco is computed from local positions, but only if no modifier is present. */
-          BLI_dynstr_append(ds, datatoc_gpu_shader_common_obinfos_lib_glsl);
-          BLI_dynstr_append(ds, "DEFINE_ATTR(vec4, orco);\n");
-        }
-        else if (input->attr_name[0] == '\0') {
-          BLI_dynstr_appendf(ds,
-                             "DEFINE_ATTR(%s, %s);\n",
-                             gpu_data_type_to_string(input->type),
-                             attr_prefix_get(input->attr_type));
-          BLI_dynstr_appendf(
-              ds, "#define att%d %s\n", input->attr_id, attr_prefix_get(input->attr_type));
-        }
-        else {
-          char attr_safe_name[GPU_MAX_SAFE_ATTRIB_NAME];
-          GPU_vertformat_safe_attrib_name(
-              input->attr_name, attr_safe_name, GPU_MAX_SAFE_ATTRIB_NAME);
-          BLI_dynstr_appendf(ds,
-                             "DEFINE_ATTR(%s, %s%s);\n",
-                             gpu_data_type_to_string(input->type),
-                             attr_prefix_get(input->attr_type),
-                             attr_safe_name);
-          BLI_dynstr_appendf(ds,
-                             "#define att%d %s%s\n",
-                             input->attr_id,
-                             attr_prefix_get(input->attr_type),
-                             attr_safe_name);
-        }
-        BLI_dynstr_appendf(ds,
-                           "out %s var%d%s;\n",
-                           gpu_data_type_to_string(input->type),
-                           input->attr_id,
-                           use_geom ? "g" : "");
-      }
     }
   }
 
@@ -800,30 +789,26 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
     BLI_dynstr_append(ds, "\tbarycentricPosg = position;\n");
   }
 
-  for (node = nodes->first; node; node = node->next) {
-    for (input = node->inputs.first; input; input = input->next) {
-      if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
-        if (input->attr_type == CD_TANGENT) {
-          /* Not supported by hairs */
-          BLI_dynstr_appendf(ds, "\tvar%d%s = vec4(0.0);\n", input->attr_id, use_geom ? "g" : "");
-        }
-        else if (input->attr_type == CD_ORCO) {
-          BLI_dynstr_appendf(ds,
-                             "\tvar%d%s = OrcoTexCoFactors[0].xyz + (ModelMatrixInverse * "
-                             "vec4(hair_get_strand_pos(), 1.0)).xyz * OrcoTexCoFactors[1].xyz;\n",
-                             input->attr_id,
-                             use_geom ? "g" : "");
-          /* TODO: fix ORCO with modifiers. */
-        }
-        else {
-          BLI_dynstr_appendf(ds,
-                             "\tvar%d%s = hair_get_customdata_%s(att%d);\n",
-                             input->attr_id,
-                             use_geom ? "g" : "",
-                             gpu_data_type_to_string(input->type),
-                             input->attr_id);
-        }
-      }
+  for (GPUMaterialAttribute *attr = graph->attributes.first; attr; attr = attr->next) {
+    if (attr->type == CD_TANGENT) {
+      /* Not supported by hairs */
+      BLI_dynstr_appendf(ds, "\tvar%d%s = vec4(0.0);\n", attr->id, use_geom ? "g" : "");
+    }
+    else if (attr->type == CD_ORCO) {
+      BLI_dynstr_appendf(ds,
+                         "\tvar%d%s = OrcoTexCoFactors[0].xyz + (ModelMatrixInverse * "
+                         "vec4(hair_get_strand_pos(), 1.0)).xyz * OrcoTexCoFactors[1].xyz;\n",
+                         attr->id,
+                         use_geom ? "g" : "");
+      /* TODO: fix ORCO with modifiers. */
+    }
+    else {
+      BLI_dynstr_appendf(ds,
+                         "\tvar%d%s = hair_get_customdata_%s(att%d);\n",
+                         attr->id,
+                         use_geom ? "g" : "",
+                         gpu_data_type_to_string(attr->gputype),
+                         attr->id);
     }
   }
 
@@ -837,49 +822,43 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
     BLI_dynstr_append(ds, "\tbarycentricPosg = (ModelMatrix * vec4(position, 1.0)).xyz;\n");
   }
 
-  for (node = nodes->first; node; node = node->next) {
-    for (input = node->inputs.first; input; input = input->next) {
-      if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
-        if (input->attr_type == CD_TANGENT) { /* silly exception */
-          BLI_dynstr_appendf(ds,
-                             "\tvar%d%s.xyz = transpose(mat3(ModelMatrixInverse)) * att%d.xyz;\n",
-                             input->attr_id,
-                             use_geom ? "g" : "",
-                             input->attr_id);
-          BLI_dynstr_appendf(
-              ds, "\tvar%d%s.w = att%d.w;\n", input->attr_id, use_geom ? "g" : "", input->attr_id);
-          /* Normalize only if vector is not null. */
-          BLI_dynstr_appendf(ds,
-                             "\tfloat lvar%d = dot(var%d%s.xyz, var%d%s.xyz);\n",
-                             input->attr_id,
-                             input->attr_id,
-                             use_geom ? "g" : "",
-                             input->attr_id,
-                             use_geom ? "g" : "");
-          BLI_dynstr_appendf(ds,
-                             "\tvar%d%s.xyz *= (lvar%d > 0.0) ? inversesqrt(lvar%d) : 1.0;\n",
-                             input->attr_id,
-                             use_geom ? "g" : "",
-                             input->attr_id,
-                             input->attr_id);
-        }
-        else if (input->attr_type == CD_ORCO) {
-          BLI_dynstr_appendf(ds,
-                             "\tvar%d%s = OrcoTexCoFactors[0].xyz + position *"
-                             " OrcoTexCoFactors[1].xyz;\n",
-                             input->attr_id,
-                             use_geom ? "g" : "");
-          /* See mesh_create_loop_orco() for explanation. */
-          BLI_dynstr_appendf(ds,
-                             "\tif (orco.w == 0.0) { var%d%s = orco.xyz * 0.5 + 0.5; }\n",
-                             input->attr_id,
-                             use_geom ? "g" : "");
-        }
-        else {
-          BLI_dynstr_appendf(
-              ds, "\tvar%d%s = att%d;\n", input->attr_id, use_geom ? "g" : "", input->attr_id);
-        }
-      }
+  for (GPUMaterialAttribute *attr = graph->attributes.first; attr; attr = attr->next) {
+    if (attr->type == CD_TANGENT) { /* silly exception */
+      BLI_dynstr_appendf(ds,
+                         "\tvar%d%s.xyz = transpose(mat3(ModelMatrixInverse)) * att%d.xyz;\n",
+                         attr->id,
+                         use_geom ? "g" : "",
+                         attr->id);
+      BLI_dynstr_appendf(ds, "\tvar%d%s.w = att%d.w;\n", attr->id, use_geom ? "g" : "", attr->id);
+      /* Normalize only if vector is not null. */
+      BLI_dynstr_appendf(ds,
+                         "\tfloat lvar%d = dot(var%d%s.xyz, var%d%s.xyz);\n",
+                         attr->id,
+                         attr->id,
+                         use_geom ? "g" : "",
+                         attr->id,
+                         use_geom ? "g" : "");
+      BLI_dynstr_appendf(ds,
+                         "\tvar%d%s.xyz *= (lvar%d > 0.0) ? inversesqrt(lvar%d) : 1.0;\n",
+                         attr->id,
+                         use_geom ? "g" : "",
+                         attr->id,
+                         attr->id);
+    }
+    else if (attr->type == CD_ORCO) {
+      BLI_dynstr_appendf(ds,
+                         "\tvar%d%s = OrcoTexCoFactors[0].xyz + position *"
+                         " OrcoTexCoFactors[1].xyz;\n",
+                         attr->id,
+                         use_geom ? "g" : "");
+      /* See mesh_create_loop_orco() for explanation. */
+      BLI_dynstr_appendf(ds,
+                         "\tif (orco.w == 0.0) { var%d%s = orco.xyz * 0.5 + 0.5; }\n",
+                         attr->id,
+                         use_geom ? "g" : "");
+    }
+    else {
+      BLI_dynstr_appendf(ds, "\tvar%d%s = att%d;\n", attr->id, use_geom ? "g" : "", attr->id);
     }
   }
   BLI_dynstr_append(ds, "#endif /* HAIR_SHADER */\n");
@@ -899,7 +878,9 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
   return code;
 }
 
-static char *code_generate_geometry(ListBase *nodes, const char *geom_code, const char *defines)
+static char *code_generate_geometry(GPUNodeGraph *graph,
+                                    const char *geom_code,
+                                    const char *defines)
 {
   DynStr *ds = BLI_dynstr_new();
   GPUNode *node;
@@ -916,20 +897,19 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code, cons
   BLI_dynstr_append(ds, "#define USE_ATTR\n");
 
   /* Generate varying declarations. */
-  for (node = nodes->first; node; node = node->next) {
+  for (node = graph->nodes.first; node; node = node->next) {
     for (input = node->inputs.first; input; input = input->next) {
       if (input->source == GPU_SOURCE_BUILTIN) {
         builtins |= input->builtin;
       }
-      if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
-        BLI_dynstr_appendf(
-            ds, "in %s var%dg[];\n", gpu_data_type_to_string(input->type), input->attr_id);
-        BLI_dynstr_appendf(
-            ds, "out %s var%d;\n", gpu_data_type_to_string(input->type), input->attr_id);
-      }
     }
   }
 
+  for (GPUMaterialAttribute *attr = graph->attributes.first; attr; attr = attr->next) {
+    BLI_dynstr_appendf(ds, "in %s var%dg[];\n", gpu_data_type_to_string(attr->gputype), attr->id);
+    BLI_dynstr_appendf(ds, "out %s var%d;\n", gpu_data_type_to_string(attr->gputype), attr->id);
+  }
+
   if (builtins & GPU_BARYCENTRIC_TEXCO) {
     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
     BLI_dynstr_append(ds, "in vec2 barycentricTexCog[];\n");
@@ -1032,13 +1012,9 @@ static char *code_generate_geometry(ListBase *nodes, const char *geom_code, cons
     BLI_dynstr_append(ds, "#endif\n");
   }
 
-  for (node = nodes->first; node; node = node->next) {
-    for (input = node->inputs.first; input; input = input->next) {
-      if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
-        /* TODO let shader choose what to do depending on what the attribute is. */
-        BLI_dynstr_appendf(ds, "\tvar%d = var%dg[vert];\n", input->attr_id, input->attr_id);
-      }
-    }
+  for (GPUMaterialAttribute *attr = graph->attributes.first; attr; attr = attr->next) {
+    /* TODO let shader choose what to do depending on what the attribute is. */
+    BLI_dynstr_appendf(ds, "\tvar%d = var%dg[vert];\n", attr->id, attr->id);
   }
   BLI_dynstr_append(ds, "}\n");
 
@@ -1053,94 +1029,6 @@ GPUShader *GPU_pass_shader_get(GPUPass *pass)
   return pass->shader;
 }
 
-/* Requested Attributes */
-
-static ListBase gpu_nodes_requested_attributes(ListBase *nodes)
-{
-  ListBase attributes = {NULL};
-  int num_attributes = 0;
-
-  /* Convert attributes requested by node inputs to list, checking for
-   * checking for duplicates and assigning id's starting from zero. */
-  for (GPUNode *node = nodes->first; node; node = node->next) {
-    for (GPUInput *input = node->inputs.first; input; input = input->next) {
-      if (input->source != GPU_SOURCE_ATTR) {
-        continue;
-      }
-
-      GPUMaterialAttribute *attr = attributes.first;
-      for (; attr; attr = attr->next) {
-        if (attr->type == input->attr_type && STREQ(attr->name, input->attr_name)) {
-          break;
-        }
-      }
-
-      /* Add new requested attribute if it's within GPU limits. */
-      if (attr == NULL && num_attributes < GPU_MAX_ATTR) {
-        attr = MEM_callocN(sizeof(*attr), __func__);
-        attr->type = input->attr_type;
-        STRNCPY(attr->name, input->attr_name);
-        attr->id = num_attributes++;
-        BLI_addtail(&attributes, attr);
-
-        input->attr_id = attr->id;
-        input->attr_first = true;
-      }
-      else if (attr != NULL) {
-        input->attr_id = attr->id;
-      }
-    }
-  }
-
-  return attributes;
-}
-
-/* Requested Textures */
-
-static ListBase gpu_nodes_requested_textures(ListBase *nodes)
-{
-  ListBase textures = {NULL};
-  int num_textures = 0;
-
-  /* Convert textures requested by node inputs to list, checking for
-   * checking for duplicates and assigning id's starting from zero. */
-  for (GPUNode *node = nodes->first; node; node = node->next) {
-    for (GPUInput *input = node->inputs.first; input; input = input->next) {
-      if (!codegen_input_has_texture(input)) {
-        continue;
-      }
-
-      GPUMaterialTexture *tex = textures.first;
-      for (; tex; tex = tex->next) {
-        if (tex->ima == input->ima && tex->colorband == input->colorband &&
-            tex->type == input->type) {
-          break;
-        }
-      }
-
-      if (tex == NULL) {
-        tex = MEM_callocN(sizeof(*tex), __func__);
-        tex->ima = input->ima;
-        tex->iuser = input->iuser;
-        tex->colorband = input->colorband;
-        tex->id = num_textures++;
-        tex->type = input->type;
-        BLI_snprintf(tex->shadername, sizeof(tex->shadername), "samp%d", tex->id);
-        BLI_addtail(&textures, tex);
-
-        input->texid = tex->id;
-        input->bindtex = true;
-      }
-      else {
-        input->texid = tex->id;
-        input->bindtex = false;
-      }
-    }
-  }
-
-  return textures;
-}
-
 /* Pass create/free */
 
 static bool gpu_pass_is_valid(GPUPass *pass)
@@ -1160,11 +1048,8 @@ GPUPass *GPU_generate_pass(GPUMaterial *material,
    * generated VBOs are ready to accept the future shader. */
   gpu_node_graph_prune_unused(graph);
 
-  graph->attributes = gpu_nodes_requested_attributes(&graph->nodes);
-  graph->textures = gpu_nodes_requested_textures(&graph->nodes);
-
   /* generate code */
-  char *fragmentgen = code_generate_fragment(material, &graph->nodes, graph->outlink->output);
+  char *fragmentgen = code_generate_fragment(material, graph);
 
   /* Cache lookup: Reuse shaders already compiled */
   uint32_t hash = gpu_pass_hash(fragmentgen, defines, &graph->attributes);
@@ -1186,8 +1071,8 @@ GPUPass *GPU_generate_pass(GPUMaterial *material,
   GSet *used_libraries = gpu_material_used_libraries(material);
   char *tmp = gpu_material_library_generate_code(used_libraries, frag_lib);
 
-  char *geometrycode = code_generate_geometry(&graph->nodes, geom_code, defines);
-  char *vertexcode = code_generate_vertex(&graph->nodes, vert_code, (geometrycode != NULL));
+  char *geometrycode = code_generate_geometry(graph, geom_code, defines);
+  char *vertexcode = code_generate_vertex(graph, vert_code, (geometrycode != NULL));
   char *fragmentcode = BLI_strdupcat(tmp, fragmentgen);
 
   MEM_freeN(fragmentgen);