Cleanup: DRW: Move ModelMatrix declaration to common_view_lib
[blender.git] / source / blender / gpu / intern / gpu_codegen.c
index 458c0d5da85505ed24c888f7fa41229de06c1a93..8dda98ab99044d6dcf2a6c3eb33fe61148120d6b 100644 (file)
@@ -81,8 +81,9 @@ static uint32_t gpu_pass_hash(const char *frag_gen, const char *defs, GPUVertAtt
       BLI_hash_mm2a_add(&hm2a, (uchar *)name, strlen(name));
     }
   }
-  if (defs)
+  if (defs) {
     BLI_hash_mm2a_add(&hm2a, (uchar *)defs, strlen(defs));
+  }
 
   return BLI_hash_mm2a_end(&hm2a);
 }
@@ -180,8 +181,9 @@ static GPUShader *FUNCTION_LIB = NULL;
 static int gpu_str_prefix(const char *str, const char *prefix)
 {
   while (*str && *prefix) {
-    if (*str != *prefix)
+    if (*str != *prefix) {
       return 0;
+    }
 
     str++;
     prefix++;
@@ -196,8 +198,9 @@ static char *gpu_str_skip_token(char *str, char *token, int max)
 
   /* skip a variable/function name */
   while (*str) {
-    if (ELEM(*str, ' ', '(', ')', ',', ';', '\t', '\n', '\r'))
+    if (ELEM(*str, ' ', '(', ')', ',', ';', '\t', '\n', '\r')) {
       break;
+    }
     else {
       if (token && len < max - 1) {
         *token = *str;
@@ -208,16 +211,19 @@ static char *gpu_str_skip_token(char *str, char *token, int max)
     }
   }
 
-  if (token)
+  if (token) {
     *token = '\0';
+  }
 
   /* skip the next special characters:
    * note the missing ')' */
   while (*str) {
-    if (ELEM(*str, ' ', '(', ',', ';', '\t', '\n', '\r'))
+    if (ELEM(*str, ' ', '(', ',', ';', '\t', '\n', '\r')) {
       str++;
-    else
+    }
+    else {
       break;
+    }
   }
 
   return str;
@@ -240,12 +246,15 @@ static void gpu_parse_functions_string(GHash *hash, char *code)
     while (*code && *code != ')') {
       /* test if it's an input or output */
       qual = FUNCTION_QUAL_IN;
-      if (gpu_str_prefix(code, "out "))
+      if (gpu_str_prefix(code, "out ")) {
         qual = FUNCTION_QUAL_OUT;
-      if (gpu_str_prefix(code, "inout "))
+      }
+      if (gpu_str_prefix(code, "inout ")) {
         qual = FUNCTION_QUAL_INOUT;
-      if ((qual != FUNCTION_QUAL_IN) || gpu_str_prefix(code, "in "))
+      }
+      if ((qual != FUNCTION_QUAL_IN) || gpu_str_prefix(code, "in ")) {
         code = gpu_str_skip_token(code, NULL, 0);
+      }
 
       /* test for type */
       type = GPU_NONE;
@@ -368,8 +377,9 @@ void gpu_codegen_exit(void)
 {
   extern Material defmaterial; /* render module abuse... */
 
-  if (defmaterial.gpumaterial.first)
+  if (defmaterial.gpumaterial.first) {
     GPU_material_free(&defmaterial.gpumaterial);
+  }
 
   if (FUNCTION_HASH) {
     BLI_ghash_free(FUNCTION_HASH, NULL, MEM_freeN);
@@ -407,46 +417,62 @@ static void codegen_convert_datatype(DynStr *ds, int from, int to, const char *t
     BLI_dynstr_append(ds, name);
   }
   else if (to == GPU_FLOAT) {
-    if (from == GPU_VEC4)
+    if (from == GPU_VEC4) {
       BLI_dynstr_appendf(ds, "convert_rgba_to_float(%s)", name);
-    else if (from == GPU_VEC3)
+    }
+    else if (from == GPU_VEC3) {
       BLI_dynstr_appendf(ds, "(%s.r + %s.g + %s.b) / 3.0", name, name, name);
-    else if (from == GPU_VEC2)
+    }
+    else if (from == GPU_VEC2) {
       BLI_dynstr_appendf(ds, "%s.r", name);
+    }
   }
   else if (to == GPU_VEC2) {
-    if (from == GPU_VEC4)
+    if (from == GPU_VEC4) {
       BLI_dynstr_appendf(ds, "vec2((%s.r + %s.g + %s.b) / 3.0, %s.a)", name, name, name, name);
-    else if (from == GPU_VEC3)
+    }
+    else if (from == GPU_VEC3) {
       BLI_dynstr_appendf(ds, "vec2((%s.r + %s.g + %s.b) / 3.0, 1.0)", name, name, name);
-    else if (from == GPU_FLOAT)
+    }
+    else if (from == GPU_FLOAT) {
       BLI_dynstr_appendf(ds, "vec2(%s, 1.0)", name);
+    }
   }
   else if (to == GPU_VEC3) {
-    if (from == GPU_VEC4)
+    if (from == GPU_VEC4) {
       BLI_dynstr_appendf(ds, "%s.rgb", name);
-    else if (from == GPU_VEC2)
+    }
+    else if (from == GPU_VEC2) {
       BLI_dynstr_appendf(ds, "vec3(%s.r, %s.r, %s.r)", name, name, name);
-    else if (from == GPU_FLOAT)
+    }
+    else if (from == GPU_FLOAT) {
       BLI_dynstr_appendf(ds, "vec3(%s, %s, %s)", name, name, name);
+    }
   }
   else if (to == GPU_VEC4) {
-    if (from == GPU_VEC3)
+    if (from == GPU_VEC3) {
       BLI_dynstr_appendf(ds, "vec4(%s, 1.0)", name);
-    else if (from == GPU_VEC2)
+    }
+    else if (from == GPU_VEC2) {
       BLI_dynstr_appendf(ds, "vec4(%s.r, %s.r, %s.r, %s.g)", name, name, name, name);
-    else if (from == GPU_FLOAT)
+    }
+    else if (from == GPU_FLOAT) {
       BLI_dynstr_appendf(ds, "vec4(%s, %s, %s, 1.0)", name, name, name);
+    }
   }
   else if (to == GPU_CLOSURE) {
-    if (from == GPU_VEC4)
+    if (from == GPU_VEC4) {
       BLI_dynstr_appendf(ds, "closure_emission(%s.rgb)", name);
-    else if (from == GPU_VEC3)
+    }
+    else if (from == GPU_VEC3) {
       BLI_dynstr_appendf(ds, "closure_emission(%s.rgb)", name);
-    else if (from == GPU_VEC2)
+    }
+    else if (from == GPU_VEC2) {
       BLI_dynstr_appendf(ds, "closure_emission(%s.rrr)", name);
-    else if (from == GPU_FLOAT)
+    }
+    else if (from == GPU_FLOAT) {
       BLI_dynstr_appendf(ds, "closure_emission(vec3(%s, %s, %s))", name, name, name);
+    }
   }
   else {
     BLI_dynstr_append(ds, name);
@@ -461,69 +487,96 @@ static void codegen_print_datatype(DynStr *ds, const eGPUType type, float *data)
 
   for (i = 0; i < type; i++) {
     BLI_dynstr_appendf(ds, "%.12f", data[i]);
-    if (i == type - 1)
+    if (i == type - 1) {
       BLI_dynstr_append(ds, ")");
-    else
+    }
+    else {
       BLI_dynstr_append(ds, ", ");
+    }
   }
 }
 
 static int codegen_input_has_texture(GPUInput *input)
 {
-  if (input->link)
+  if (input->link) {
     return 0;
-  else
+  }
+  else {
     return (input->source == GPU_SOURCE_TEX);
+  }
 }
 
 const char *GPU_builtin_name(eGPUBuiltin builtin)
 {
-  if (builtin == GPU_VIEW_MATRIX)
+  if (builtin == GPU_VIEW_MATRIX) {
     return "unfviewmat";
-  else if (builtin == GPU_OBJECT_MATRIX)
+  }
+  else if (builtin == GPU_OBJECT_MATRIX) {
     return "unfobmat";
-  else if (builtin == GPU_INVERSE_VIEW_MATRIX)
+  }
+  else if (builtin == GPU_INVERSE_VIEW_MATRIX) {
     return "unfinvviewmat";
-  else if (builtin == GPU_INVERSE_OBJECT_MATRIX)
+  }
+  else if (builtin == GPU_INVERSE_OBJECT_MATRIX) {
     return "unfinvobmat";
-  else if (builtin == GPU_INVERSE_NORMAL_MATRIX)
-    return "unfinvnormat";
-  else if (builtin == GPU_LOC_TO_VIEW_MATRIX)
+  }
+  else if (builtin == GPU_LOC_TO_VIEW_MATRIX) {
     return "unflocaltoviewmat";
-  else if (builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX)
+  }
+  else if (builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
     return "unfinvlocaltoviewmat";
-  else if (builtin == GPU_VIEW_POSITION)
+  }
+  else if (builtin == GPU_VIEW_POSITION) {
     return "varposition";
-  else if (builtin == GPU_VIEW_NORMAL)
+  }
+  else if (builtin == GPU_WORLD_NORMAL) {
+    return "varwnormal";
+  }
+  else if (builtin == GPU_VIEW_NORMAL) {
     return "varnormal";
-  else if (builtin == GPU_OBCOLOR)
+  }
+  else if (builtin == GPU_OBCOLOR) {
     return "unfobcolor";
-  else if (builtin == GPU_AUTO_BUMPSCALE)
+  }
+  else if (builtin == GPU_AUTO_BUMPSCALE) {
     return "unfobautobumpscale";
-  else if (builtin == GPU_CAMERA_TEXCO_FACTORS)
+  }
+  else if (builtin == GPU_CAMERA_TEXCO_FACTORS) {
     return "unfcameratexfactors";
-  else if (builtin == GPU_PARTICLE_SCALAR_PROPS)
+  }
+  else if (builtin == GPU_PARTICLE_SCALAR_PROPS) {
     return "unfparticlescalarprops";
-  else if (builtin == GPU_PARTICLE_LOCATION)
+  }
+  else if (builtin == GPU_PARTICLE_LOCATION) {
     return "unfparticleco";
-  else if (builtin == GPU_PARTICLE_VELOCITY)
+  }
+  else if (builtin == GPU_PARTICLE_VELOCITY) {
     return "unfparticlevel";
-  else if (builtin == GPU_PARTICLE_ANG_VELOCITY)
+  }
+  else if (builtin == GPU_PARTICLE_ANG_VELOCITY) {
     return "unfparticleangvel";
-  else if (builtin == GPU_OBJECT_INFO)
+  }
+  else if (builtin == GPU_OBJECT_INFO) {
     return "unfobjectinfo";
-  else if (builtin == GPU_VOLUME_DENSITY)
+  }
+  else if (builtin == GPU_VOLUME_DENSITY) {
     return "sampdensity";
-  else if (builtin == GPU_VOLUME_FLAME)
+  }
+  else if (builtin == GPU_VOLUME_FLAME) {
     return "sampflame";
-  else if (builtin == GPU_VOLUME_TEMPERATURE)
+  }
+  else if (builtin == GPU_VOLUME_TEMPERATURE) {
     return "unftemperature";
-  else if (builtin == GPU_BARYCENTRIC_TEXCO)
+  }
+  else if (builtin == GPU_BARYCENTRIC_TEXCO) {
     return "unfbarycentrictex";
-  else if (builtin == GPU_BARYCENTRIC_DIST)
+  }
+  else if (builtin == GPU_BARYCENTRIC_DIST) {
     return "unfbarycentricdist";
-  else
+  }
+  else {
     return "";
+  }
 }
 
 /* assign only one texid per buffer to avoid sampling the same texture twice */
@@ -706,32 +759,45 @@ static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *final
       }
       else if (input->source == GPU_SOURCE_BUILTIN) {
         /* TODO(fclem) get rid of that. */
-        if (input->builtin == GPU_INVERSE_VIEW_MATRIX)
+        if (input->builtin == GPU_INVERSE_VIEW_MATRIX) {
           BLI_dynstr_append(ds, "viewinv");
-        else if (input->builtin == GPU_VIEW_MATRIX)
+        }
+        else if (input->builtin == GPU_VIEW_MATRIX) {
           BLI_dynstr_append(ds, "viewmat");
-        else if (input->builtin == GPU_CAMERA_TEXCO_FACTORS)
+        }
+        else if (input->builtin == GPU_CAMERA_TEXCO_FACTORS) {
           BLI_dynstr_append(ds, "camtexfac");
-        else if (input->builtin == GPU_LOC_TO_VIEW_MATRIX)
+        }
+        else if (input->builtin == GPU_LOC_TO_VIEW_MATRIX) {
           BLI_dynstr_append(ds, "localtoviewmat");
-        else if (input->builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX)
+        }
+        else if (input->builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
           BLI_dynstr_append(ds, "invlocaltoviewmat");
-        else if (input->builtin == GPU_BARYCENTRIC_DIST)
+        }
+        else if (input->builtin == GPU_BARYCENTRIC_DIST) {
           BLI_dynstr_append(ds, "barycentricDist");
-        else if (input->builtin == GPU_BARYCENTRIC_TEXCO)
+        }
+        else if (input->builtin == GPU_BARYCENTRIC_TEXCO) {
           BLI_dynstr_append(ds, "barytexco");
-        else if (input->builtin == GPU_OBJECT_MATRIX)
+        }
+        else if (input->builtin == GPU_OBJECT_MATRIX) {
           BLI_dynstr_append(ds, "objmat");
-        else if (input->builtin == GPU_INVERSE_OBJECT_MATRIX)
+        }
+        else if (input->builtin == GPU_INVERSE_OBJECT_MATRIX) {
           BLI_dynstr_append(ds, "objinv");
-        else if (input->builtin == GPU_INVERSE_NORMAL_MATRIX)
-          BLI_dynstr_append(ds, "norinv");
-        else if (input->builtin == GPU_VIEW_POSITION)
+        }
+        else if (input->builtin == GPU_VIEW_POSITION) {
           BLI_dynstr_append(ds, "viewposition");
-        else if (input->builtin == GPU_VIEW_NORMAL)
+        }
+        else if (input->builtin == GPU_VIEW_NORMAL) {
           BLI_dynstr_append(ds, "facingnormal");
-        else
+        }
+        else if (input->builtin == GPU_WORLD_NORMAL) {
+          BLI_dynstr_append(ds, "facingwnormal");
+        }
+        else {
           BLI_dynstr_append(ds, GPU_builtin_name(input->builtin));
+        }
       }
       else if (input->source == GPU_SOURCE_STRUCT) {
         BLI_dynstr_appendf(ds, "strct%d", input->id);
@@ -751,8 +817,9 @@ static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *final
 
     for (output = node->outputs.first; output; output = output->next) {
       BLI_dynstr_appendf(ds, "tmp%d", output->id);
-      if (output->next)
+      if (output->next) {
         BLI_dynstr_append(ds, ", ");
+      }
     }
 
     BLI_dynstr_append(ds, ");\n");
@@ -778,11 +845,13 @@ static char *code_generate_fragment(GPUMaterial *material,
   codegen_set_unique_ids(nodes);
   *rbuiltins = builtins = codegen_process_uniforms_functions(material, ds, nodes);
 
-  if (builtins & GPU_BARYCENTRIC_TEXCO)
+  if (builtins & GPU_BARYCENTRIC_TEXCO) {
     BLI_dynstr_append(ds, "in vec2 barycentricTexCo;\n");
+  }
 
-  if (builtins & GPU_BARYCENTRIC_DIST)
+  if (builtins & GPU_BARYCENTRIC_DIST) {
     BLI_dynstr_append(ds, "flat in vec3 barycentricDist;\n");
+  }
 
   BLI_dynstr_append(ds, "Closure nodetree_exec(void)\n{\n");
 
@@ -798,33 +867,61 @@ static char *code_generate_fragment(GPUMaterial *material,
     BLI_dynstr_append(ds, "#endif\n");
   }
   /* TODO(fclem) get rid of that. */
-  if (builtins & GPU_VIEW_MATRIX)
+  if (builtins & GPU_VIEW_MATRIX) {
     BLI_dynstr_append(ds, "\t#define viewmat ViewMatrix\n");
-  if (builtins & GPU_CAMERA_TEXCO_FACTORS)
+  }
+  if (builtins & GPU_CAMERA_TEXCO_FACTORS) {
     BLI_dynstr_append(ds, "\t#define camtexfac CameraTexCoFactors\n");
-  if (builtins & GPU_OBJECT_MATRIX)
+  }
+  if (builtins & GPU_OBJECT_MATRIX) {
     BLI_dynstr_append(ds, "\t#define objmat ModelMatrix\n");
-  if (builtins & GPU_INVERSE_OBJECT_MATRIX)
+  }
+  if (builtins & GPU_INVERSE_OBJECT_MATRIX) {
     BLI_dynstr_append(ds, "\t#define objinv ModelMatrixInverse\n");
-  if (builtins & GPU_INVERSE_NORMAL_MATRIX)
-    BLI_dynstr_append(ds, "\t#define norinv NormalMatrixInverse\n");
-  if (builtins & GPU_INVERSE_VIEW_MATRIX)
+  }
+  if (builtins & GPU_INVERSE_VIEW_MATRIX) {
     BLI_dynstr_append(ds, "\t#define viewinv ViewMatrixInverse\n");
-  if (builtins & GPU_LOC_TO_VIEW_MATRIX)
-    BLI_dynstr_append(ds, "\t#define localtoviewmat ModelViewMatrix\n");
-  if (builtins & GPU_INVERSE_LOC_TO_VIEW_MATRIX)
-    BLI_dynstr_append(ds, "\t#define invlocaltoviewmat ModelViewMatrixInverse\n");
-  if (builtins & GPU_VIEW_NORMAL)
-    BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing? viewNormal: -viewNormal;\n");
-  if (builtins & GPU_VIEW_POSITION)
+  }
+  if (builtins & GPU_LOC_TO_VIEW_MATRIX) {
+    BLI_dynstr_append(ds, "\t#define localtoviewmat (ViewMatrix * ModelMatrix)\n");
+  }
+  if (builtins & GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
+    BLI_dynstr_append(ds,
+                      "\t#define invlocaltoviewmat (ModelMatrixInverse * ViewMatrixInverse)\n");
+  }
+  if (builtins & GPU_VIEW_NORMAL) {
+    BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
+    BLI_dynstr_append(ds, "\tvec3 n;\n");
+    BLI_dynstr_append(ds, "\tworld_normals_get(n);\n");
+    BLI_dynstr_append(ds, "\tvec3 facingnormal = transform_direction(ViewMatrix, n);\n");
+    BLI_dynstr_append(ds, "#else\n");
+    BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing ? viewNormal: -viewNormal;\n");
+    BLI_dynstr_append(ds, "#endif\n");
+  }
+  if (builtins & GPU_WORLD_NORMAL) {
+    BLI_dynstr_append(ds, "\tvec3 facingwnormal;\n");
+    if (builtins & GPU_VIEW_NORMAL) {
+      BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
+      BLI_dynstr_append(ds, "\tfacingwnormal = n;\n");
+      BLI_dynstr_append(ds, "#else\n");
+      BLI_dynstr_append(ds, "\tworld_normals_get(facingwnormal);\n");
+      BLI_dynstr_append(ds, "#endif\n");
+    }
+    else {
+      BLI_dynstr_append(ds, "\tworld_normals_get(facingwnormal);\n");
+    }
+  }
+  if (builtins & GPU_VIEW_POSITION) {
     BLI_dynstr_append(ds, "\t#define viewposition viewPosition\n");
+  }
 
   codegen_declare_tmps(ds, nodes);
   codegen_call_functions(ds, nodes, output);
 
   BLI_dynstr_append(ds, "}\n");
 
-  /* XXX This cannot go into gpu_shader_material.glsl because main() would be parsed and generate error */
+  /* XXX This cannot go into gpu_shader_material.glsl because main()
+   * would be parsed and generate error */
   /* Old glsl mode compat. */
   BLI_dynstr_append(ds, "#ifndef NODETREE_EXEC\n");
   BLI_dynstr_append(ds, "out vec4 fragColor;\n");
@@ -840,7 +937,8 @@ static char *code_generate_fragment(GPUMaterial *material,
   BLI_dynstr_free(ds);
 
 #if 0
-  if (G.debug & G_DEBUG) printf("%s\n", code);
+  if (G.debug & G_DEBUG)
+    printf("%s\n", code);
 #endif
 
   return code;
@@ -937,13 +1035,39 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
     BLI_dynstr_append(ds, "out vec3 barycentricPosg;\n");
   }
 
+  BLI_dynstr_append(ds, "\n#define USE_ATTR\n");
+
+  /* Prototype, defined later (this is because of matrices definition). */
+  BLI_dynstr_append(ds, "void pass_attr(in vec3 position);\n");
+
+  BLI_dynstr_append(ds, "\n");
+
+  if (use_geom) {
+    /* XXX HACK: Eevee specific. */
+    char *vert_new, *vert_new2;
+    vert_new = BLI_str_replaceN(vert_code, "worldPosition", "worldPositiong");
+    vert_new2 = vert_new;
+    vert_new = BLI_str_replaceN(vert_new2, "viewPosition", "viewPositiong");
+    MEM_freeN(vert_new2);
+    vert_new2 = vert_new;
+    vert_new = BLI_str_replaceN(vert_new2, "worldNormal", "worldNormalg");
+    MEM_freeN(vert_new2);
+    vert_new2 = vert_new;
+    vert_new = BLI_str_replaceN(vert_new2, "viewNormal", "viewNormalg");
+    MEM_freeN(vert_new2);
+
+    BLI_dynstr_append(ds, vert_new);
+
+    MEM_freeN(vert_new);
+  }
+  else {
+    BLI_dynstr_append(ds, vert_code);
+  }
+
   BLI_dynstr_append(ds, "\n");
 
   BLI_dynstr_append(ds,
                     "#define USE_ATTR\n"
-                    "uniform mat3 NormalMatrix;\n"
-                    "uniform mat4 ModelMatrixInverse;\n"
-                    "uniform mat4 ModelMatrix;\n"
                     "vec3 srgb_to_linear_attr(vec3 c) {\n"
                     "\tc = max(c, vec3(0.0));\n"
                     "\tvec3 c1 = c * (1.0 / 12.92);\n"
@@ -1021,7 +1145,7 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
       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 = NormalMatrix * att%d.xyz;\n",
+                             "\tvar%d%s.xyz = transpose(mat3(ModelMatrixInverse)) * att%d.xyz;\n",
                              input->attr_id,
                              use_geom ? "g" : "",
                              input->attr_id);
@@ -1080,34 +1204,13 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
 
   BLI_dynstr_append(ds, "}\n");
 
-  if (use_geom) {
-    /* XXX HACK: Eevee specific. */
-    char *vert_new, *vert_new2;
-    vert_new = BLI_str_replaceN(vert_code, "worldPosition", "worldPositiong");
-    vert_new2 = vert_new;
-    vert_new = BLI_str_replaceN(vert_new2, "viewPosition", "viewPositiong");
-    MEM_freeN(vert_new2);
-    vert_new2 = vert_new;
-    vert_new = BLI_str_replaceN(vert_new2, "worldNormal", "worldNormalg");
-    MEM_freeN(vert_new2);
-    vert_new2 = vert_new;
-    vert_new = BLI_str_replaceN(vert_new2, "viewNormal", "viewNormalg");
-    MEM_freeN(vert_new2);
-
-    BLI_dynstr_append(ds, vert_new);
-
-    MEM_freeN(vert_new);
-  }
-  else {
-    BLI_dynstr_append(ds, vert_code);
-  }
-
   code = BLI_dynstr_get_cstring(ds);
 
   BLI_dynstr_free(ds);
 
 #if 0
-  if (G.debug & G_DEBUG) printf("%s\n", code);
+  if (G.debug & G_DEBUG)
+    printf("%s\n", code);
 #endif
 
   return code;
@@ -1264,8 +1367,9 @@ void GPU_code_generate_glsl_lib(void)
   DynStr *ds;
 
   /* only initialize the library once */
-  if (glsl_material_library)
+  if (glsl_material_library) {
     return;
+  }
 
   ds = BLI_dynstr_new();
 
@@ -1290,8 +1394,9 @@ void GPU_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs, ListB
 
   BLI_listbase_clear(inputs);
 
-  if (!shader)
+  if (!shader) {
     return;
+  }
 
   for (node = nodes->first; node; node = node->next) {
     int z = 0;
@@ -1305,8 +1410,9 @@ void GPU_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs, ListB
         continue;
       }
 
-      if (input->source == GPU_SOURCE_TEX)
+      if (input->source == GPU_SOURCE_TEX) {
         BLI_snprintf(input->shadername, sizeof(input->shadername), "samp%d", input->texid);
+      }
       else {
         BLI_snprintf(input->shadername, sizeof(input->shadername), "unf%d", input->id);
       }
@@ -1337,12 +1443,14 @@ static void gpu_node_link_free(GPUNodeLink *link)
 {
   link->users--;
 
-  if (link->users < 0)
+  if (link->users < 0) {
     fprintf(stderr, "GPU_node_link_free: negative refcount\n");
+  }
 
   if (link->users == 0) {
-    if (link->output)
+    if (link->output) {
       link->output->link = NULL;
+    }
     MEM_freeN(link);
   }
 }
@@ -1371,8 +1479,9 @@ static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType
 
     if ((STR_ELEM(name, "set_value", "set_rgb", "set_rgba")) && (input->type == type)) {
       input = MEM_dupallocN(outnode->inputs.first);
-      if (input->link)
+      if (input->link) {
         input->link->users++;
+      }
       BLI_addtail(&node->inputs, input);
       return;
     }
@@ -1400,7 +1509,6 @@ static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType
       input->source = GPU_SOURCE_TEX;
       input->ima = link->ima;
       input->iuser = link->iuser;
-      input->image_isdata = link->image_isdata;
       break;
     case GPU_NODE_LINK_ATTR:
       input->source = GPU_SOURCE_ATTR;
@@ -1537,8 +1645,9 @@ void GPU_inputs_free(ListBase *inputs)
   GPUInput *input;
 
   for (input = inputs->first; input; input = input->next) {
-    if (input->link)
+    if (input->link) {
       gpu_node_link_free(input->link);
+    }
   }
 
   BLI_freelistN(inputs);
@@ -1550,11 +1659,12 @@ static void gpu_node_free(GPUNode *node)
 
   GPU_inputs_free(&node->inputs);
 
-  for (output = node->outputs.first; output; output = output->next)
+  for (output = node->outputs.first; output; output = output->next) {
     if (output->link) {
       output->link->output = NULL;
       gpu_node_link_free(output->link);
     }
+  }
 
   BLI_freelistN(&node->outputs);
   MEM_freeN(node);
@@ -1643,13 +1753,12 @@ GPUNodeLink *GPU_uniform(float *num)
   return link;
 }
 
-GPUNodeLink *GPU_image(Image *ima, ImageUser *iuser, bool is_data)
+GPUNodeLink *GPU_image(Image *ima, ImageUser *iuser)
 {
   GPUNodeLink *link = GPU_node_link_create();
   link->link_type = GPU_NODE_LINK_IMAGE_BLENDER;
   link->ima = ima;
   link->iuser = iuser;
-  link->image_isdata = is_data;
   return link;
 }
 
@@ -1752,19 +1861,23 @@ bool GPU_stack_link(GPUMaterial *material,
         linkptr = va_arg(params, GPUNodeLink **);
         gpu_node_output(node, function->paramtype[i], linkptr);
       }
-      else
+      else {
         totout--;
+      }
     }
     else {
       if (totin == 0) {
         link = va_arg(params, GPUNodeLink *);
-        if (link->socket)
+        if (link->socket) {
           gpu_node_input_socket(NULL, NULL, node, link->socket, -1);
-        else
+        }
+        else {
           gpu_node_input_link(node, link, function->paramtype[i]);
+        }
       }
-      else
+      else {
         totin--;
+      }
     }
   }
   va_end(params);
@@ -1789,25 +1902,30 @@ static void gpu_nodes_tag(GPUNodeLink *link)
   GPUNode *node;
   GPUInput *input;
 
-  if (!link->output)
+  if (!link->output) {
     return;
+  }
 
   node = link->output->node;
-  if (node->tag)
+  if (node->tag) {
     return;
+  }
 
   node->tag = true;
-  for (input = node->inputs.first; input; input = input->next)
-    if (input->link)
+  for (input = node->inputs.first; input; input = input->next) {
+    if (input->link) {
       gpu_nodes_tag(input->link);
+    }
+  }
 }
 
 void GPU_nodes_prune(ListBase *nodes, GPUNodeLink *outlink)
 {
   GPUNode *node, *next;
 
-  for (node = nodes->first; node; node = node->next)
+  for (node = nodes->first; node; node = node->next) {
     node->tag = false;
+  }
 
   gpu_nodes_tag(outlink);
 
@@ -2066,8 +2184,9 @@ void GPU_pass_cache_garbage_collect(void)
   const int shadercollectrate = 60; /* hardcoded for now. */
   int ctime = (int)PIL_check_seconds_timer();
 
-  if (ctime < shadercollectrate + lasttime)
+  if (ctime < shadercollectrate + lasttime) {
     return;
+  }
 
   lasttime = ctime;