Cleanup: Rename GPU_* functions to make more sense
authorClément Foucault <foucault.clem@gmail.com>
Mon, 13 Aug 2018 13:30:29 +0000 (15:30 +0200)
committerClément Foucault <foucault.clem@gmail.com>
Mon, 13 Aug 2018 21:01:18 +0000 (23:01 +0200)
* Remove GPU_link_changed which is unused.
* Remove all GPU link function that are not used anymore.
* GPU_uniform_buffer is now GPU_uniform.
* GPU_texture_ramp is now GPU_color_band.
* GPU_uniform is now GPU_constant.

28 files changed:
source/blender/gpu/GPU_material.h
source/blender/gpu/intern/gpu_codegen.c
source/blender/gpu/intern/gpu_codegen.h
source/blender/gpu/intern/gpu_shader.c
source/blender/nodes/shader/node_shader_util.c
source/blender/nodes/shader/nodes/node_shader_blackbody.c
source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c
source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c
source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c
source/blender/nodes/shader/nodes/node_shader_bump.c
source/blender/nodes/shader/nodes/node_shader_curves.c
source/blender/nodes/shader/nodes/node_shader_eevee_specular.c
source/blender/nodes/shader/nodes/node_shader_mapping.c
source/blender/nodes/shader/nodes/node_shader_math.c
source/blender/nodes/shader/nodes/node_shader_mixRgb.c
source/blender/nodes/shader/nodes/node_shader_normal.c
source/blender/nodes/shader/nodes/node_shader_normal_map.c
source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.c
source/blender/nodes/shader/nodes/node_shader_tex_brick.c
source/blender/nodes/shader/nodes/node_shader_tex_gradient.c
source/blender/nodes/shader/nodes/node_shader_tex_image.c
source/blender/nodes/shader/nodes/node_shader_tex_magic.c
source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c
source/blender/nodes/shader/nodes/node_shader_tex_wave.c
source/blender/nodes/shader/nodes/node_shader_valToRgb.c
source/blender/nodes/shader/nodes/node_shader_vectTransform.c
source/blender/nodes/shader/nodes/node_shader_volume_principled.c

index 6b0296361eceb1a426018f8d7b399336effd0704..5bbe9d6d9041c6859270227baed49a94b486d3a6 100644 (file)
@@ -224,16 +224,11 @@ typedef enum GPUDynamicType {
 } GPUDynamicType;
 
 GPUNodeLink *GPU_attribute(CustomDataType type, const char *name);
+GPUNodeLink *GPU_constant(float *num);
 GPUNodeLink *GPU_uniform(float *num);
-GPUNodeLink *GPU_dynamic_uniform(float *num, GPUDynamicType dynamictype, void *data);
-GPUNodeLink *GPU_uniform_buffer(float *num, GPUType gputype);
 GPUNodeLink *GPU_image(struct Image *ima, struct ImageUser *iuser, bool is_data);
-GPUNodeLink *GPU_cube_map(struct Image *ima, struct ImageUser *iuser, bool is_data);
-GPUNodeLink *GPU_image_preview(struct PreviewImage *prv);
-GPUNodeLink *GPU_texture_ramp(GPUMaterial *mat, int size, float *pixels, float *layer);
-GPUNodeLink *GPU_dynamic_texture(struct GPUTexture *tex, GPUDynamicType dynamictype, void *data);
+GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *layer);
 GPUNodeLink *GPU_builtin(GPUBuiltin builtin);
-GPUNodeLink *GPU_opengl_builtin(GPUOpenGLBuiltin builtin);
 void GPU_node_link_set_type(GPUNodeLink *link, GPUType type);
 
 bool GPU_link(GPUMaterial *mat, const char *name, ...);
index 289befe674ea8f41feafbc2c8431f4ea2a1942cd..0eee9bf6ead866112160f7ddb3371782b013f0b0 100644 (file)
@@ -1447,19 +1447,19 @@ static GPUNodeLink *gpu_uniformbuffer_link(
                        case SOCK_FLOAT:
                        {
                                bNodeSocketValueFloat *socket_data = socket->default_value;
-                               link = GPU_uniform_buffer(&socket_data->value, GPU_FLOAT);
+                               link = GPU_uniform(&socket_data->value);
                                break;
                        }
                        case SOCK_VECTOR:
                        {
                                bNodeSocketValueRGBA *socket_data = socket->default_value;
-                               link = GPU_uniform_buffer(socket_data->value, GPU_VEC3);
+                               link = GPU_uniform(socket_data->value);
                                break;
                        }
                        case SOCK_RGBA:
                        {
                                bNodeSocketValueRGBA *socket_data = socket->default_value;
-                               link = GPU_uniform_buffer(socket_data->value, GPU_VEC4);
+                               link = GPU_uniform(socket_data->value);
                                break;
                        }
                        default:
@@ -1612,7 +1612,7 @@ GPUNodeLink *GPU_attribute(const CustomDataType type, const char *name)
        return link;
 }
 
-GPUNodeLink *GPU_uniform(float *num)
+GPUNodeLink *GPU_constant(float *num)
 {
        GPUNodeLink *link = GPU_node_link_create();
 
@@ -1622,30 +1622,13 @@ GPUNodeLink *GPU_uniform(float *num)
        return link;
 }
 
-GPUNodeLink *GPU_dynamic_uniform(float *num, GPUDynamicType dynamictype, void *data)
-{
-       GPUNodeLink *link = GPU_node_link_create();
-
-       link->ptr1 = num;
-       link->ptr2 = data;
-       link->dynamic = true;
-       link->dynamictype = dynamictype;
-
-
-       return link;
-}
-
-/**
- * Add uniform to UBO struct of GPUMaterial.
- */
-GPUNodeLink *GPU_uniform_buffer(float *num, GPUType gputype)
+GPUNodeLink *GPU_uniform(float *num)
 {
        GPUNodeLink *link = GPU_node_link_create();
        link->ptr1 = num;
        link->ptr2 = NULL;
        link->dynamic = true;
        link->dynamictype = GPU_DYNAMIC_UBO;
-       link->type = gputype;
 
        return link;
 }
@@ -1662,53 +1645,18 @@ GPUNodeLink *GPU_image(Image *ima, ImageUser *iuser, bool is_data)
        return link;
 }
 
-GPUNodeLink *GPU_cube_map(Image *ima, ImageUser *iuser, bool is_data)
-{
-       GPUNodeLink *link = GPU_node_link_create();
-
-       link->image = GPU_NODE_LINK_IMAGE_CUBE_MAP;
-       link->ptr1 = ima;
-       link->ptr2 = iuser;
-       link->image_isdata = is_data;
-
-       return link;
-}
-
-GPUNodeLink *GPU_image_preview(PreviewImage *prv)
-{
-       GPUNodeLink *link = GPU_node_link_create();
-
-       link->image = GPU_NODE_LINK_IMAGE_PREVIEW;
-       link->ptr1 = prv;
-
-       return link;
-}
-
-
-GPUNodeLink *GPU_texture_ramp(GPUMaterial *mat, int size, float *pixels, float *row)
+GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *layer)
 {
        GPUNodeLink *link = GPU_node_link_create();
 
        link->texture = true;
-       link->ptr1 = gpu_material_ramp_texture_row_set(mat, size, pixels, row);
+       link->ptr1 = gpu_material_ramp_texture_row_set(mat, size, pixels, layer);
 
        MEM_freeN(pixels);
 
        return link;
 }
 
-GPUNodeLink *GPU_dynamic_texture(GPUTexture *tex, GPUDynamicType dynamictype, void *data)
-{
-       GPUNodeLink *link = GPU_node_link_create();
-
-       link->dynamic = true;
-       link->dynamictex = tex;
-       link->dynamictype = dynamictype;
-       link->ptr2 = data;
-
-       return link;
-}
-
 GPUNodeLink *GPU_builtin(GPUBuiltin builtin)
 {
        GPUNodeLink *link = GPU_node_link_create();
@@ -1718,15 +1666,6 @@ GPUNodeLink *GPU_builtin(GPUBuiltin builtin)
        return link;
 }
 
-GPUNodeLink *GPU_opengl_builtin(GPUOpenGLBuiltin builtin)
-{
-       GPUNodeLink *link = GPU_node_link_create();
-
-       link->oglbuiltin = builtin;
-
-       return link;
-}
-
 bool GPU_link(GPUMaterial *mat, const char *name, ...)
 {
        GPUNode *node;
@@ -1826,27 +1765,6 @@ bool GPU_stack_link(GPUMaterial *material, bNode *bnode, const char *name, GPUNo
        return true;
 }
 
-int GPU_link_changed(GPUNodeLink *link)
-{
-       GPUNode *node;
-       GPUInput *input;
-       const char *name;
-
-       if (link->output) {
-               node = link->output->node;
-               name = node->name;
-
-               if (STREQ(name, "set_value") || STREQ(name, "set_rgb")) {
-                       input = node->inputs.first;
-                       return (input->link != NULL);
-               }
-
-               return 1;
-       }
-       else
-               return 0;
-}
-
 GPUNodeLink *GPU_uniformbuffer_link_out(GPUMaterial *mat, bNode *node, GPUNodeStack *stack, const int index)
 {
        return gpu_uniformbuffer_link(mat, node, stack, index, SOCK_OUT);
index 77e6e5cf4eff56ed3a3fdbd4f0f08bd0d764f37e..21dcaf6b5912c0314fd95dc06ff4ef8149574f18 100644 (file)
@@ -198,6 +198,5 @@ void gpu_codegen_exit(void);
 const char *GPU_builtin_name(GPUBuiltin builtin);
 void gpu_material_add_node(struct GPUMaterial *material, struct GPUNode *node);
 struct GPUTexture **gpu_material_ramp_texture_row_set(GPUMaterial *mat, int size, float *pixels, float *row);
-int GPU_link_changed(struct GPUNodeLink *link);
 
 #endif
index 6560b5e7f1375486e56dc02596710a7880a7a398..b812cf61483e565c1a123e7bdb2efd6d19c65a62 100644 (file)
@@ -239,13 +239,8 @@ static void gpu_shader_standard_defines(
         bool use_opensubdiv)
 {
        /* some useful defines to detect GPU type */
-       if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_ANY, GPU_DRIVER_ANY)) {
+       if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_ANY, GPU_DRIVER_ANY))
                strcat(defines, "#define GPU_ATI\n");
-               if (GLEW_VERSION_3_0) {
-                       /* TODO(merwin): revisit this version check; GLEW_VERSION_3_0 means GL 3.0 or newer */
-                       strcat(defines, "#define CLIP_WORKAROUND\n");
-               }
-       }
        else if (GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY))
                strcat(defines, "#define GPU_NVIDIA\n");
        else if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_ANY, GPU_DRIVER_ANY))
index 63c1cac566de8b29be799f1d3ef2b2079bafd971..80cfba00e0af04aaf31a1b8bb66aee80168752ab 100644 (file)
@@ -257,12 +257,12 @@ void node_shader_gpu_tex_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in
                static float min[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
                GPUNodeLink *tmin, *tmax, *tmat0, *tmat1, *tmat2, *tmat3;
 
-               tmin = GPU_uniform_buffer((domin) ? texmap->min : min, GPU_VEC3);
-               tmax = GPU_uniform_buffer((domax) ? texmap->max : max, GPU_VEC3);
-               tmat0 = GPU_uniform_buffer((float *)texmap->mat[0], GPU_VEC4);
-               tmat1 = GPU_uniform_buffer((float *)texmap->mat[1], GPU_VEC4);
-               tmat2 = GPU_uniform_buffer((float *)texmap->mat[2], GPU_VEC4);
-               tmat3 = GPU_uniform_buffer((float *)texmap->mat[3], GPU_VEC4);
+               tmin = GPU_uniform((domin) ? texmap->min : min);
+               tmax = GPU_uniform((domax) ? texmap->max : max);
+               tmat0 = GPU_uniform((float *)texmap->mat[0]);
+               tmat1 = GPU_uniform((float *)texmap->mat[1]);
+               tmat2 = GPU_uniform((float *)texmap->mat[2]);
+               tmat3 = GPU_uniform((float *)texmap->mat[3]);
 
                GPU_link(mat, "mapping", in[0].link, tmat0, tmat1, tmat2, tmat3, tmin, tmax, &in[0].link);
 
index e57f5e0d6cfd2e77f9d81a5777f9593c2c0e5597..28ba3d2c5c8d4df53e8dd5b5c2715f706f0f7e17 100644 (file)
@@ -46,9 +46,9 @@ static int node_shader_gpu_blackbody(GPUMaterial *mat, bNode *node, bNodeExecDat
        blackbody_temperature_to_rgb_table(data, size, 965.0f, 12000.0f);
 
        float layer;
-       GPUNodeLink *ramp_texture = GPU_texture_ramp(mat, size, data, &layer);
+       GPUNodeLink *ramp_texture = GPU_color_band(mat, size, data, &layer);
 
-       return GPU_stack_link(mat, node, "node_blackbody", in, out, ramp_texture, GPU_uniform(&layer));
+       return GPU_stack_link(mat, node, "node_blackbody", in, out, ramp_texture, GPU_constant(&layer));
 }
 
 /* node type definition */
index ada6e21356fc1f125dafaffdeacaea1b13e6e85d..b18dcacb98fe1ac7085c3f0661c8a389f68c40c0 100644 (file)
@@ -54,7 +54,7 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *node, bNodeExecDa
 
        GPU_material_flag_set(mat, GPU_MATFLAG_GLOSSY | GPU_MATFLAG_REFRACT);
 
-       return GPU_stack_link(mat, node, "node_bsdf_glass", in, out, GPU_uniform(&node->ssr_id));
+       return GPU_stack_link(mat, node, "node_bsdf_glass", in, out, GPU_constant(&node->ssr_id));
 }
 
 /* node type definition */
index f56837de2614e93ffbfda7a7b2f6c7456313756c..342b3a67ffb8288953839d31be2ffcf6d46d60cc 100644 (file)
@@ -53,7 +53,7 @@ static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *node, bNodeExecD
 
        GPU_material_flag_set(mat, GPU_MATFLAG_GLOSSY);
 
-       return GPU_stack_link(mat, node, "node_bsdf_glossy", in, out, GPU_uniform(&node->ssr_id));
+       return GPU_stack_link(mat, node, "node_bsdf_glossy", in, out, GPU_constant(&node->ssr_id));
 }
 
 /* node type definition */
index 370dcdcc2eae49f1d6751b89a38ed69f9c1f4863..16d35c7003a0433097eb29cf610c6488a4f80768 100644 (file)
@@ -104,7 +104,7 @@ static int node_shader_gpu_bsdf_principled(GPUMaterial *mat, bNode *node, bNodeE
        }
        else {
                float one[3] = {1.0f, 1.0f, 1.0f};
-               GPU_link(mat, "set_rgb", GPU_uniform((float *)one), &sss_scale);
+               GPU_link(mat, "set_rgb", GPU_constant((float *)one), &sss_scale);
        }
 
        bool use_diffuse = socket_not_one(4) && socket_not_one(15);
@@ -149,7 +149,7 @@ static int node_shader_gpu_bsdf_principled(GPUMaterial *mat, bNode *node, bNodeE
        GPU_material_flag_set(mat, flag);
 
        return GPU_stack_link(mat, node, node_name, in, out, GPU_builtin(GPU_VIEW_POSITION),
-                             GPU_uniform(&node->ssr_id), GPU_uniform(&node->sss_id), sss_scale);
+                             GPU_constant(&node->ssr_id), GPU_constant(&node->sss_id), sss_scale);
 }
 
 static void node_shader_update_principled(bNodeTree *UNUSED(ntree), bNode *node)
index 08b50a886c56598bda5cd25e0d34a4c20f4a1a94..b71a59d8c11b59d57a2efffcdcac9e762036e23e 100644 (file)
@@ -52,7 +52,7 @@ static int gpu_shader_bump(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(
        else
                GPU_link(mat, "direction_transform_m4v3", in[3].link, GPU_builtin(GPU_VIEW_MATRIX), &in[3].link);
        float invert = node->custom1;
-       GPU_stack_link(mat, node, "node_bump", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_uniform(&invert));
+       GPU_stack_link(mat, node, "node_bump", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_constant(&invert));
        /* Other nodes are applying view matrix if the input Normal has a link.
         * We don't want normal to have view matrix applied twice, so we cancel it here.
         *
index 21bdc3cd0d8b35f834c89d67f7c6a33bc16200f3..243d57339eacaa0569916292ca43e1cd83cd5d75 100644 (file)
@@ -66,9 +66,9 @@ static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, bNodeExecData *UN
        int size;
 
        curvemapping_table_RGBA(node->storage, &array, &size);
-       GPUNodeLink *tex = GPU_texture_ramp(mat, size, array, &layer);
+       GPUNodeLink *tex = GPU_color_band(mat, size, array, &layer);
 
-       return GPU_stack_link(mat, node, "curves_vec", in, out, tex, GPU_uniform(&layer));
+       return GPU_stack_link(mat, node, "curves_vec", in, out, tex, GPU_constant(&layer));
 }
 
 void register_node_type_sh_curve_vec(void)
@@ -126,9 +126,9 @@ static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, bNodeExecData *UN
 
        curvemapping_initialize(node->storage);
        curvemapping_table_RGBA(node->storage, &array, &size);
-       GPUNodeLink *tex = GPU_texture_ramp(mat, size, array, &layer);
+       GPUNodeLink *tex = GPU_color_band(mat, size, array, &layer);
 
-       return GPU_stack_link(mat, node, "curves_rgb", in, out, tex, GPU_uniform(&layer));
+       return GPU_stack_link(mat, node, "curves_rgb", in, out, tex, GPU_constant(&layer));
 }
 
 void register_node_type_sh_curve_rgb(void)
index 6583dd0cec36c0eb23b7bd82a638fd9b1e5a18a3..939cd9f79a279c7c41c3097e44c811a23a82a2cf 100644 (file)
@@ -64,12 +64,12 @@ static int node_shader_gpu_eevee_specular(GPUMaterial *mat, bNode *node, bNodeEx
 
        /* Occlusion */
        if (!in[9].link) {
-               GPU_link(mat, "set_value", GPU_uniform(&one), &in[9].link);
+               GPU_link(mat, "set_value", GPU_constant(&one), &in[9].link);
        }
 
        GPU_material_flag_set(mat, GPU_MATFLAG_DIFFUSE | GPU_MATFLAG_GLOSSY);
 
-       return GPU_stack_link(mat, node, "node_eevee_specular", in, out, GPU_uniform(&node->ssr_id));
+       return GPU_stack_link(mat, node, "node_eevee_specular", in, out, GPU_constant(&node->ssr_id));
 }
 
 
index 98dcd58b98337d026d7535977f3277272b7ea2f4..282c6a4f14773bf42b0c24ba19c1dbff4663ce01 100644 (file)
@@ -92,12 +92,12 @@ static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, bNodeExecData *UNUS
        static float min[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
        GPUNodeLink *tmin, *tmax, *tmat0, *tmat1, *tmat2, *tmat3;
 
-       tmin = GPU_uniform_buffer((domin) ? texmap->min : min, GPU_VEC3);
-       tmax = GPU_uniform_buffer((domax) ? texmap->max : max, GPU_VEC3);
-       tmat0 = GPU_uniform_buffer((float *)texmap->mat[0], GPU_VEC4);
-       tmat1 = GPU_uniform_buffer((float *)texmap->mat[1], GPU_VEC4);
-       tmat2 = GPU_uniform_buffer((float *)texmap->mat[2], GPU_VEC4);
-       tmat3 = GPU_uniform_buffer((float *)texmap->mat[3], GPU_VEC4);
+       tmin = GPU_uniform((domin) ? texmap->min : min);
+       tmax = GPU_uniform((domax) ? texmap->max : max);
+       tmat0 = GPU_uniform((float *)texmap->mat[0]);
+       tmat1 = GPU_uniform((float *)texmap->mat[1]);
+       tmat2 = GPU_uniform((float *)texmap->mat[2]);
+       tmat3 = GPU_uniform((float *)texmap->mat[3]);
 
        GPU_stack_link(mat, node, "mapping", in, out, tmat0, tmat1, tmat2, tmat3, tmin, tmax);
 
index 1b702a722ba6293278d77b2277a46c96cf45c5b3..a072c686686eb68a239aa098381d047c255ebc9d 100644 (file)
@@ -332,7 +332,7 @@ static int gpu_shader_math(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(
        if (node->custom2 & SHD_MATH_CLAMP) {
                float min[3] = {0.0f, 0.0f, 0.0f};
                float max[3] = {1.0f, 1.0f, 1.0f};
-               GPU_link(mat, "clamp_val", out[0].link, GPU_uniform(min), GPU_uniform(max), &out[0].link);
+               GPU_link(mat, "clamp_val", out[0].link, GPU_constant(min), GPU_constant(max), &out[0].link);
        }
 
        return 1;
index b598859ab8e45c4a9551f32637670771dded2a2d..5bf5ce6926168ec9a986de03daac525d7307d41e 100644 (file)
@@ -76,7 +76,7 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUS
        if (ret && node->custom2 & SHD_MIXRGB_CLAMP) {
                float min[3] = {0.0f, 0.0f, 0.0f};
                float max[3] = {1.0f, 1.0f, 1.0f};
-               GPU_link(mat, "clamp_vec3", out[0].link, GPU_uniform(min), GPU_uniform(max), &out[0].link);
+               GPU_link(mat, "clamp_vec3", out[0].link, GPU_constant(min), GPU_constant(max), &out[0].link);
        }
        return ret;
 }
index 121cb9cc1a5f50330a455cef17ec8098dd6e708d..13335c8638270026d08ab1693cccb265984fba29 100644 (file)
@@ -60,7 +60,7 @@ static void node_shader_exec_normal(void *UNUSED(data), int UNUSED(thread), bNod
 
 static int gpu_shader_normal(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-       GPUNodeLink *vec = GPU_uniform(out[0].vec);
+       GPUNodeLink *vec = GPU_constant(out[0].vec);
        return GPU_stack_link(mat, node, "normal_new_shading", in, out, vec);
 }
 
index e4b5aaef72d628386ec4e591acb591eb9d8e21b4..c066fea81adc74276c03fcb8cb75c257bc717990 100644 (file)
@@ -66,23 +66,23 @@ static int gpu_shader_normal_map(GPUMaterial *mat, bNode *node, bNodeExecData *U
        else if (node->original) {
                bNodeSocket *socket = BLI_findlink(&node->original->inputs, 0);
                bNodeSocketValueFloat *socket_data = socket->default_value;
-               strength = GPU_uniform_buffer(&socket_data->value, GPU_FLOAT);
+               strength = GPU_uniform(&socket_data->value);
        }
        else
-               strength = GPU_uniform(in[0].vec);
+               strength = GPU_constant(in[0].vec);
 
        if (in[1].link)
                realnorm = in[1].link;
        else if (node->original) {
                bNodeSocket *socket = BLI_findlink(&node->original->inputs, 1);
                bNodeSocketValueRGBA *socket_data = socket->default_value;
-               realnorm = GPU_uniform_buffer(socket_data->value, GPU_VEC3);
+               realnorm = GPU_uniform(socket_data->value);
        }
        else
-               realnorm = GPU_uniform(in[1].vec);
+               realnorm = GPU_constant(in[1].vec);
 
        negnorm = GPU_builtin(GPU_VIEW_NORMAL);
-       GPU_link(mat, "math_max", strength, GPU_uniform(d), &strength);
+       GPU_link(mat, "math_max", strength, GPU_constant(d), &strength);
 
        const char *color_to_normal_fnc_name = "color_to_normal_new_shading";
        if (nm->space == SHD_SPACE_BLENDER_OBJECT || nm->space == SHD_SPACE_BLENDER_WORLD)
index f8af125eb9ecf21fc8ef87a68370e3a88bba0238..7cc80a0c6368349950cbe053303ab9d3134532f3 100644 (file)
@@ -67,7 +67,7 @@ static int node_shader_gpu_subsurface_scattering(GPUMaterial *mat, bNode *node,
                                                     &socket_data_sharp->value);
        }
 
-       return GPU_stack_link(mat, node, "node_subsurface_scattering", in, out, GPU_uniform(&node->sss_id));
+       return GPU_stack_link(mat, node, "node_subsurface_scattering", in, out, GPU_constant(&node->sss_id));
 }
 
 static void node_shader_update_subsurface_scattering(bNodeTree *UNUSED(ntree), bNode *node)
index 227df5e8e56b5069038b8c951d68077943f7247e..2002e3c14c9f3ea8c22a989dce1a39de6d9e2ead 100644 (file)
@@ -82,8 +82,8 @@ static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, bNodeExecDat
        float squash_freq = tex->squash_freq;
        return GPU_stack_link(mat, node, "node_tex_brick",
                              in, out,
-                             GPU_uniform(&tex->offset), GPU_uniform(&offset_freq),
-                             GPU_uniform(&tex->squash), GPU_uniform(&squash_freq));
+                             GPU_constant(&tex->offset), GPU_constant(&offset_freq),
+                             GPU_constant(&tex->squash), GPU_constant(&squash_freq));
 }
 
 /* node type definition */
index 06f3773e6d8df007ee2a84ea29e95cb86201f628..750ce60e84d1e707432d5879e58dada0eacc5c11 100644 (file)
@@ -61,7 +61,7 @@ static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, bNodeExec
 
        NodeTexGradient *tex = (NodeTexGradient *)node->storage;
        float gradient_type = tex->gradient_type;
-       return GPU_stack_link(mat, node, "node_tex_gradient", in, out, GPU_uniform(&gradient_type));
+       return GPU_stack_link(mat, node, "node_tex_gradient", in, out, GPU_constant(&gradient_type));
 }
 
 /* node type definition */
index 9782df2638f513c2d65a8d545d4f077310398d7c..0b33b186dd24e25249dec2839bc0a355e4615457 100644 (file)
@@ -124,7 +124,7 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, bNodeExecDat
                                                            norm,
                                                            col1, col2, col3,
                                                            GPU_image(ima, iuser, isdata),
-                                                           GPU_uniform(&blend),
+                                                           GPU_constant(&blend),
                                                            &out[0].link,
                                                            &out[1].link);
                        break;
index deb81b7b78f469ac39c994473d039189c0037149..fb3012e1d2b24d880f3dc9601fe71d28f839f4f2 100644 (file)
@@ -64,7 +64,7 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, bNodeExecDat
 
        node_shader_gpu_tex_mapping(mat, node, in, out);
 
-       return GPU_stack_link(mat, node, "node_tex_magic", in, out, GPU_uniform(&depth));
+       return GPU_stack_link(mat, node, "node_tex_magic", in, out, GPU_constant(&depth));
 }
 
 /* node type definition */
index 03f401e7f01502c9353f96d9235ca84dad4031dd..30171eea9e2b4d6c384f8989dadfb76b199aa291 100644 (file)
@@ -68,7 +68,7 @@ static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, bNodeExec
        NodeTexMusgrave *tex = (NodeTexMusgrave *)node->storage;
        float type = tex->musgrave_type;
 
-       return GPU_stack_link(mat, node, "node_tex_musgrave", in, out, GPU_uniform(&type));
+       return GPU_stack_link(mat, node, "node_tex_musgrave", in, out, GPU_constant(&type));
 }
 
 /* node type definition */
index 18d0dee8b88c3ea8733aeaa42c0c4c936b3fdf4e..2105bbfa25af768c6eb0dcc1d40b1e2dda5d1e9e 100644 (file)
@@ -66,7 +66,7 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, bNodeExecD
        NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
        float coloring = tex->coloring;
 
-       return GPU_stack_link(mat, node, "node_tex_voronoi", in, out, GPU_uniform(&coloring));
+       return GPU_stack_link(mat, node, "node_tex_voronoi", in, out, GPU_constant(&coloring));
 }
 
 static void node_shader_update_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node)
index 2b06f66eb6381d3f20eb94f76e23ce0c83d097e0..ac955b29808b648a39b6312e23c906e2e662d432 100644 (file)
@@ -67,7 +67,7 @@ static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, bNodeExecData
        float wave_type = tex->wave_type;
        float wave_profile = tex->wave_profile;
 
-       return GPU_stack_link(mat, node, "node_tex_wave", in, out, GPU_uniform(&wave_type), GPU_uniform(&wave_profile));
+       return GPU_stack_link(mat, node, "node_tex_wave", in, out, GPU_constant(&wave_type), GPU_constant(&wave_profile));
 }
 
 /* node type definition */
index 5f583e1e29bdbca7414af39668e6537239951b56..4f4462f20bbc82a015dc3f437bbb3e42b8aac737 100644 (file)
@@ -70,13 +70,13 @@ static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNU
        int size;
 
        BKE_colorband_evaluate_table_rgba(coba, &array, &size);
-       GPUNodeLink *tex = GPU_texture_ramp(mat, size, array, &layer);
+       GPUNodeLink *tex = GPU_color_band(mat, size, array, &layer);
 
        if (coba->ipotype == COLBAND_INTERP_CONSTANT) {
-               return GPU_stack_link(mat, node, "valtorgb_nearest", in, out, tex, GPU_uniform(&layer));
+               return GPU_stack_link(mat, node, "valtorgb_nearest", in, out, tex, GPU_constant(&layer));
        }
        else {
-               return GPU_stack_link(mat, node, "valtorgb", in, out, tex, GPU_uniform(&layer));
+               return GPU_stack_link(mat, node, "valtorgb", in, out, tex, GPU_constant(&layer));
        }
 }
 
index 63964e27d2043f25b7782c0f6594026c7940c816..bce96230403c7a0ea2e47313b2dbe842993fbfb6 100644 (file)
@@ -106,7 +106,7 @@ static int gpu_shader_vect_transform(GPUMaterial *mat, bNode *node, bNodeExecDat
        if (in[0].hasinput)
                inputlink = in[0].link;
        else
-               inputlink = GPU_uniform(in[0].vec);
+               inputlink = GPU_constant(in[0].vec);
 
        fromto = get_gpulink_matrix_from_to(nodeprop->convert_from, nodeprop->convert_to);
 
index c946c42f9af1db465c12ec2e0a1f3abb7ea0092f..cf458ac8f51e2e5b40635d93b1122df4efb14d36 100644 (file)
@@ -120,15 +120,15 @@ static int node_shader_gpu_volume_principled(GPUMaterial *mat, bNode *node, bNod
        /* Default values if attributes not found. */
        if (!density) {
                static float one = 1.0f;
-               density = GPU_uniform(&one);
+               density = GPU_constant(&one);
        }
        if (!color) {
                static float white[4] = {1.0f, 1.0f, 1.0f, 1.0f};
-               color = GPU_uniform(white);
+               color = GPU_constant(white);
        }
        if (!temperature) {
                static float one = 1.0f;
-               temperature = GPU_uniform(&one);
+               temperature = GPU_constant(&one);
        }
 
        /* Create blackbody spectrum. */
@@ -141,10 +141,10 @@ static int node_shader_gpu_volume_principled(GPUMaterial *mat, bNode *node, bNod
        else {
                data = MEM_callocN(sizeof(float) * size * 4, "blackbody black");
        }
-       GPUNodeLink *spectrummap = GPU_texture_ramp(mat, size, data, &layer);
+       GPUNodeLink *spectrummap = GPU_color_band(mat, size, data, &layer);
 
        return GPU_stack_link(mat, node, "node_volume_principled", in, out, density, color, temperature, spectrummap,
-                                                                  GPU_uniform(&layer));
+                                                                  GPU_constant(&layer));
 }
 
 /* node type definition */