Revert "OCIO: Port shader creation logic to use GPUShaderCreateInfo"

This reverts commit 7f7c614ecddbcb66de0bff1657366970dede99be.

5 files changed, 202 insertions, 313 deletions

diff --git a/intern/opencolorio/CMakeLists.txt b/intern/opencolorio/CMakeLists.txt
index a2ef0d46a40..0b46ae471d2 100644
--- a/intern/opencolorio/CMakeLists.txt
+++ b/intern/opencolorio/CMakeLists.txt
@@ -24,7 +24,6 @@ set(INC
   ../guardedalloc
   ../../source/blender/blenlib
   ../../source/blender/gpu
-  ../../source/blender/gpu/intern
   ../../source/blender/makesdna
 )
 
@@ -38,7 +37,6 @@ set(SRC
 
   ocio_capi.h
   ocio_impl.h
-  ocio_shader_shared.hh
 )
 
 set(LIB
@@ -75,38 +73,8 @@ if(WITH_OPENCOLORIO)
     )
   endif()
 
-  set(GLSL_SRC
-    gpu_shader_display_transform_vert.glsl
-    gpu_shader_display_transform_frag.glsl
-
-    ocio_shader_shared.hh
-  )
-
-  set(GLSL_C)
-  foreach(GLSL_FILE ${GLSL_SRC})
-    data_to_c_simple(${GLSL_FILE} GLSL_C)
-  endforeach()
-
-  blender_add_lib(bf_ocio_shaders "${GLSL_C}" "" "" "")
-
-  list(APPEND LIB
-    bf_ocio_shaders
-  )
-
-  set(GLSL_SOURCE_CONTENT "")
-  foreach(GLSL_FILE ${GLSL_SRC})
-    get_filename_component(GLSL_FILE_NAME ${GLSL_FILE} NAME)
-    string(REPLACE "." "_" GLSL_FILE_NAME_UNDERSCORES ${GLSL_FILE_NAME})
-    string(APPEND GLSL_SOURCE_CONTENT "SHADER_SOURCE\(datatoc_${GLSL_FILE_NAME_UNDERSCORES}, \"${GLSL_FILE_NAME}\", \"${GLSL_FILE}\"\)\n")
-  endforeach()
-
-  set(glsl_source_list_file "${CMAKE_CURRENT_BINARY_DIR}/glsl_ocio_source_list.h")
-  file(GENERATE OUTPUT ${glsl_source_list_file} CONTENT "${GLSL_SOURCE_CONTENT}")
-  list(APPEND SRC ${glsl_source_list_file})
-  list(APPEND INC ${CMAKE_CURRENT_BINARY_DIR})
-
-  target_include_directories(bf_ocio_shaders PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
-
+  data_to_c_simple(gpu_shader_display_transform.glsl SRC)
+  data_to_c_simple(gpu_shader_display_transform_vertex.glsl SRC)
 endif()
 
 
diff --git a/intern/opencolorio/gpu_shader_display_transform_frag.glsl b/intern/opencolorio/gpu_shader_display_transform.glsl
index 3c2352c13ba..f5a7a7bf45d 100644
--- a/intern/opencolorio/gpu_shader_display_transform_frag.glsl
+++ b/intern/opencolorio/gpu_shader_display_transform.glsl
@@ -1,10 +1,39 @@
 /* Blender OpenColorIO implementation */
 
-/* -------------------------------------------------------------------- */
-/** \name Curve Mapping Implementation
- * \{ */
+uniform sampler2D image_texture;
+uniform sampler2D overlay_texture;
+
+uniform float dither;
+uniform float scale;
+uniform float exponent;
+uniform bool predivide;
+uniform bool overlay;
 
 #ifdef USE_CURVE_MAPPING
+uniform sampler1D curve_mapping_texture;
+
+layout(std140) uniform OCIO_GPUCurveMappingParameters
+{
+  /* Curve mapping parameters
+   *
+   * See documentation for OCIO_CurveMappingSettings to get fields descriptions.
+   * (this ones pretty much copies stuff from C structure.)
+   */
+  vec4 curve_mapping_mintable;
+  vec4 curve_mapping_range;
+  vec4 curve_mapping_ext_in_x;
+  vec4 curve_mapping_ext_in_y;
+  vec4 curve_mapping_ext_out_x;
+  vec4 curve_mapping_ext_out_y;
+  vec4 curve_mapping_first_x;
+  vec4 curve_mapping_first_y;
+  vec4 curve_mapping_last_x;
+  vec4 curve_mapping_last_y;
+  vec4 curve_mapping_black;
+  vec4 curve_mapping_bwmul;
+  int curve_mapping_lut_size;
+  int curve_mapping_use_extend_extrapolate;
+};
 
 float read_curve_mapping(int table, int index)
 {
@@ -14,27 +43,27 @@ float read_curve_mapping(int table, int index)
 float curvemap_calc_extend(int table, float x, vec2 first, vec2 last)
 {
   if (x <= first[0]) {
-    if (curve_mapping.use_extend_extrapolate == 0) {
+    if (curve_mapping_use_extend_extrapolate == 0) {
       /* horizontal extrapolation */
       return first[1];
     }
     else {
-      float fac = (curve_mapping.ext_in_x[table] != 0.0) ?
-                      ((x - first[0]) / curve_mapping.ext_in_x[table]) :
+      float fac = (curve_mapping_ext_in_x[table] != 0.0) ?
+                      ((x - first[0]) / curve_mapping_ext_in_x[table]) :
                       10000.0;
-      return first[1] + curve_mapping.ext_in_y[table] * fac;
+      return first[1] + curve_mapping_ext_in_y[table] * fac;
     }
   }
   else if (x >= last[0]) {
-    if (curve_mapping.use_extend_extrapolate == 0) {
+    if (curve_mapping_use_extend_extrapolate == 0) {
       /* horizontal extrapolation */
       return last[1];
     }
     else {
-      float fac = (curve_mapping.ext_out_x[table] != 0.0) ?
-                      ((x - last[0]) / curve_mapping.ext_out_x[table]) :
+      float fac = (curve_mapping_ext_out_x[table] != 0.0) ?
+                      ((x - last[0]) / curve_mapping_ext_out_x[table]) :
                       -10000.0;
-      return last[1] + curve_mapping.ext_out_y[table] * fac;
+      return last[1] + curve_mapping_ext_out_y[table] * fac;
     }
   }
   return 0.0;
@@ -42,10 +71,10 @@ float curvemap_calc_extend(int table, float x, vec2 first, vec2 last)
 
 float curvemap_evaluateF(int table, float value)
 {
-  float mintable_ = curve_mapping.mintable[table];
-  float range = curve_mapping.range[table];
+  float mintable_ = curve_mapping_mintable[table];
+  float range = curve_mapping_range[table];
   float mintable = 0.0;
-  int CM_TABLE = curve_mapping.lut_size - 1;
+  int CM_TABLE = curve_mapping_lut_size - 1;
 
   float fi;
   int i;
@@ -58,8 +87,8 @@ float curvemap_evaluateF(int table, float value)
   if (fi < 0.0 || fi > float(CM_TABLE)) {
     return curvemap_calc_extend(table,
                                 value,
-                                vec2(curve_mapping.first_x[table], curve_mapping.first_y[table]),
-                                vec2(curve_mapping.last_x[table], curve_mapping.last_y[table]));
+                                vec2(curve_mapping_first_x[table], curve_mapping_first_y[table]),
+                                vec2(curve_mapping_last_x[table], curve_mapping_last_y[table]));
   }
   else {
     if (i < 0) {
@@ -77,7 +106,7 @@ float curvemap_evaluateF(int table, float value)
 
 vec4 curvemapping_evaluate_premulRGBF(vec4 col)
 {
-  col.rgb = (col.rgb - curve_mapping.black.rgb) * curve_mapping.bwmul.rgb;
+  col.rgb = (col.rgb - curve_mapping_black.rgb) * curve_mapping_bwmul.rgb;
 
   vec4 result;
   result.r = curvemap_evaluateF(0, col.r);
@@ -86,15 +115,8 @@ vec4 curvemapping_evaluate_premulRGBF(vec4 col)
   result.a = col.a;
   return result;
 }
-
 #endif /* USE_CURVE_MAPPING */
 
-/** \} */
-
-/* -------------------------------------------------------------------- */
-/** \name Dithering
- * \{ */
-
 /* Using a triangle distribution which gives a more final uniform noise.
  * See Banding in Games:A Noisy Rant(revision 5) Mikkel Gjøl, Playdead (slide 27) */
 /* GPUs are rounding before writing to framebuffer so we center the distribution around 0.0. */
@@ -113,33 +135,23 @@ float dither_random_value(vec2 co)
 
 vec2 round_to_pixel(sampler2D tex, vec2 uv)
 {
-  vec2 size = vec2(textureSize(tex, 0));
-  return floor(uv * size) / size;
+  vec2 size = textureSize(tex, 0);
+  return vec2(ivec2(uv * size)) / size;
 }
 
 vec4 apply_dither(vec4 col, vec2 uv)
 {
-  col.rgb += dither_random_value(uv) * 0.0033 * parameters.dither;
+  col.rgb += dither_random_value(uv) * 0.0033 * dither;
   return col;
 }
 
-/** \} */
-
-/* -------------------------------------------------------------------- */
-/** \name Main Processing
- * \{ */
-
-/* Prototypes: Implementation is generaterd and defined after. */
-vec4 OCIO_to_scene_linear(vec4 pixel);
-vec4 OCIO_to_display(vec4 pixel);
-
-vec4 OCIO_ProcessColor(vec4 col, vec4 col_overlay)
+vec4 OCIO_ProcessColor(vec4 col, vec4 col_overlay, vec2 noise_uv)
 {
 #ifdef USE_CURVE_MAPPING
   col = curvemapping_evaluate_premulRGBF(col);
 #endif
 
-  if (parameters.use_predivide) {
+  if (predivide) {
     if (col.a > 0.0 && col.a < 1.0) {
       col.rgb *= 1.0 / col.a;
     }
@@ -154,7 +166,7 @@ vec4 OCIO_ProcessColor(vec4 col, vec4 col_overlay)
   col = OCIO_to_scene_linear(col);
 
   /* Apply exposure in scene linear. */
-  col.rgb *= parameters.scale;
+  col.rgb *= scale;
 
   /* Convert to display space. */
   col = OCIO_to_display(col);
@@ -165,31 +177,34 @@ vec4 OCIO_ProcessColor(vec4 col, vec4 col_overlay)
    * i.e: The linear color space w.r.t. display chromaticity and radiometry.
    * We separate the colormanagement process into two steps to be able to
    * merge UI using alpha blending in the correct color space. */
-  if (parameters.use_overlay) {
-    col.rgb = pow(col.rgb, vec3(parameters.exponent * 2.2));
+  if (overlay) {
+    col.rgb = pow(col.rgb, vec3(exponent * 2.2));
     col = clamp(col, 0.0, 1.0);
     col *= 1.0 - col_overlay.a;
     col += col_overlay; /* Assumed unassociated alpha. */
     col.rgb = pow(col.rgb, vec3(1.0 / 2.2));
   }
   else {
-    col.rgb = pow(col.rgb, vec3(parameters.exponent));
+    col.rgb = pow(col.rgb, vec3(exponent));
   }
 
-  if (parameters.dither > 0.0) {
-    vec2 noise_uv = round_to_pixel(image_texture, texCoord_interp.st);
+  if (dither > 0.0) {
     col = apply_dither(col, noise_uv);
   }
 
   return col;
 }
 
-/** \} */
+/* ------------------------------------------------------------------------ */
+
+in vec2 texCoord_interp;
+out vec4 fragColor;
 
 void main()
 {
   vec4 col = texture(image_texture, texCoord_interp.st);
   vec4 col_overlay = texture(overlay_texture, texCoord_interp.st);
+  vec2 noise_uv = round_to_pixel(image_texture, texCoord_interp.st);
 
-  fragColor = OCIO_ProcessColor(col, col_overlay);
+  fragColor = OCIO_ProcessColor(col, col_overlay, noise_uv);
 }
diff --git a/intern/opencolorio/gpu_shader_display_transform_vert.glsl b/intern/opencolorio/gpu_shader_display_transform_vertex.glsl
index 06788be11de..8cf9628b06b 100644
--- a/intern/opencolorio/gpu_shader_display_transform_vert.glsl
+++ b/intern/opencolorio/gpu_shader_display_transform_vertex.glsl
@@ -1,4 +1,10 @@
 
+uniform mat4 ModelViewProjectionMatrix;
+
+in vec2 texCoord;
+in vec2 pos;
+out vec2 texCoord_interp;
+
 void main()
 {
   gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0f, 1.0f);
diff --git a/intern/opencolorio/ocio_impl_glsl.cc b/intern/opencolorio/ocio_impl_glsl.cc
index e4840eb05f6..fc45ec4e301 100644
--- a/intern/opencolorio/ocio_impl_glsl.cc
+++ b/intern/opencolorio/ocio_impl_glsl.cc
@@ -49,14 +49,14 @@
 #include "GPU_shader.h"
 #include "GPU_uniform_buffer.h"
 
-#include "gpu_shader_create_info.hh"
-
 using namespace OCIO_NAMESPACE;
 
 #include "MEM_guardedalloc.h"
 
 #include "ocio_impl.h"
-#include "ocio_shader_shared.hh"
+
+extern "C" char datatoc_gpu_shader_display_transform_glsl[];
+extern "C" char datatoc_gpu_shader_display_transform_vertex_glsl[];
 
 /* **** OpenGL drawing routines using GLSL for color space transform ***** */
 
@@ -67,19 +67,41 @@ enum OCIO_GPUTextureSlots {
   TEXTURE_SLOT_LUTS_OFFSET = 3,
 };
 
-enum OCIO_GPUUniformBufSlots {
-  UNIFORMBUF_SLOT_DISPLAY = 0,
-  UNIFORMBUF_SLOT_CURVEMAP = 1,
-  UNIFORMBUF_SLOT_LUTS = 2,
+/* Curve mapping parameters
+ *
+ * See documentation for OCIO_CurveMappingSettings to get fields descriptions.
+ * (this ones pretty much copies stuff from C structure.)
+ */
+struct OCIO_GPUCurveMappingParameters {
+  float curve_mapping_mintable[4];
+  float curve_mapping_range[4];
+  float curve_mapping_ext_in_x[4];
+  float curve_mapping_ext_in_y[4];
+  float curve_mapping_ext_out_x[4];
+  float curve_mapping_ext_out_y[4];
+  float curve_mapping_first_x[4];
+  float curve_mapping_first_y[4];
+  float curve_mapping_last_x[4];
+  float curve_mapping_last_y[4];
+  float curve_mapping_black[4];
+  float curve_mapping_bwmul[4];
+  int curve_mapping_lut_size;
+  int curve_mapping_use_extend_extrapolate;
+  int _pad[2];
+  /** WARNING: Needs to be 16byte aligned. Used as UBO data. */
 };
 
 struct OCIO_GPUShader {
   /* GPU shader. */
   struct GPUShader *shader = nullptr;
 
-  /** Uniform parameters. */
-  OCIO_GPUParameters parameters = {};
-  GPUUniformBuf *parameters_buffer = nullptr;
+  /** Uniform locations. */
+  int scale_loc = 0;
+  int exponent_loc = 0;
+  int dither_loc = 0;
+  int overlay_loc = 0;
+  int predivide_loc = 0;
+  int ubo_bind = 0;
 
   /* Destructor. */
   ~OCIO_GPUShader()
@@ -87,9 +109,6 @@ struct OCIO_GPUShader {
     if (shader) {
       GPU_shader_free(shader);
     }
-    if (parameters_buffer) {
-      GPU_uniformbuf_free(parameters_buffer);
-    }
   }
 };
 
@@ -112,7 +131,6 @@ struct OCIO_GPUTextures {
 
   /* Uniforms */
   std::vector<OCIO_GPUUniform> uniforms;
-  GPUUniformBuf *uniforms_buffer = nullptr;
 
   /* Destructor. */
   ~OCIO_GPUTextures()
@@ -123,9 +141,6 @@ struct OCIO_GPUTextures {
     if (dummy) {
       GPU_texture_free(dummy);
     }
-    if (uniforms_buffer) {
-      GPU_uniformbuf_free(uniforms_buffer);
-    }
   }
 };
 
@@ -178,134 +193,97 @@ static bool createGPUShader(OCIO_GPUShader &shader,
                             const GpuShaderDescRcPtr &shaderdesc_to_display,
                             const bool use_curve_mapping)
 {
-  using namespace blender::gpu::shader;
+  std::ostringstream os;
+  {
+    /* Fragment shader */
 
-  std::string source;
-  source += shaderdesc_to_scene_linear->getShaderText();
-  source += "\n";
-  source += shaderdesc_to_display->getShaderText();
-  source += "\n";
+    /* Work around OpenColorIO not supporting latest GLSL yet. */
+    os << "#define texture2D texture\n";
+    os << "#define texture3D texture\n";
 
-  {
-    /* Replace all uniform declarations by a comment.
-     * This avoids double declarations from the backend. */
-    size_t index = 0;
-    while (true) {
-      index = source.find("uniform ", index);
-      if (index == -1) {
-        break;
-      }
-      source.replace(index, 2, "//");
-      index += 2;
+    if (use_curve_mapping) {
+      os << "#define USE_CURVE_MAPPING\n";
     }
+
+    os << shaderdesc_to_scene_linear->getShaderText() << "\n";
+    os << shaderdesc_to_display->getShaderText() << "\n";
+
+    os << datatoc_gpu_shader_display_transform_glsl;
   }
 
-  StageInterfaceInfo iface("OCIO_Interface", "");
-  iface.smooth(Type::VEC2, "texCoord_interp");
-
-  ShaderCreateInfo info("OCIO_Display");
-  /* Work around OpenColorIO not supporting latest GLSL yet. */
-  info.define("texture2D", "texture");
-  info.define("texture3D", "texture");
-  info.typedef_source("ocio_shader_shared.hh");
-  info.sampler(TEXTURE_SLOT_IMAGE, ImageType::FLOAT_2D, "image_texture");
-  info.sampler(TEXTURE_SLOT_OVERLAY, ImageType::FLOAT_2D, "overlay_texture");
-  info.uniform_buf(UNIFORMBUF_SLOT_DISPLAY, "OCIO_GPUParameters", "parameters");
-  info.push_constant(Type::MAT4, "ModelViewProjectionMatrix");
-  info.vertex_in(0, Type::VEC2, "pos");
-  info.vertex_in(1, Type::VEC2, "texCoord");
-  info.vertex_out(iface);
-  info.fragment_out(0, Type::VEC4, "fragColor");
-  info.vertex_source("gpu_shader_display_transform_vert.glsl");
-  info.fragment_source("gpu_shader_display_transform_frag.glsl");
-  info.fragment_source_generated = source;
+  shader.shader = GPU_shader_create(datatoc_gpu_shader_display_transform_vertex_glsl,
+                                    os.str().c_str(),
+                                    nullptr,
+                                    nullptr,
+                                    nullptr,
+                                    "OCIOShader");
 
-  if (use_curve_mapping) {
-    info.define("USE_CURVE_MAPPING");
-    info.uniform_buf(UNIFORMBUF_SLOT_CURVEMAP, "OCIO_GPUCurveMappingParameters", "curve_mapping");
-    info.sampler(TEXTURE_SLOT_CURVE_MAPPING, ImageType::FLOAT_1D, "curve_mapping_texture");
+  if (shader.shader == nullptr) {
+    return false;
   }
 
-  /* Set LUT textures. */
-  int slot = TEXTURE_SLOT_LUTS_OFFSET;
-  for (OCIO_GPULutTexture &texture : textures.luts) {
-    ImageType type = GPU_texture_dimensions(texture.texture) == 2 ? ImageType::FLOAT_2D :
-                                                                    ImageType::FLOAT_3D;
-    info.sampler(slot++, type, texture.sampler_name.c_str());
-  }
-
-  /* Set LUT uniforms. */
-  if (!textures.uniforms.empty()) {
-    /* NOTE: For simplicity, we pad everything to size of vec4 avoiding sorting and alignment
-     * issues. It is unlikely that this becomes a real issue. */
-    size_t ubo_size = textures.uniforms.size() * sizeof(float) * 4;
-    void *ubo_data_buf = malloc(ubo_size);
-
-    uint32_t *ubo_data = reinterpret_cast<uint32_t *>(ubo_data_buf);
-
-    std::stringstream ss;
-    ss << "struct OCIO_GPULutParameters {\n";
-
-    int index = 0;
-    for (OCIO_GPUUniform &uniform : textures.uniforms) {
-      index += 1;
-      const GpuShaderDesc::UniformData &data = uniform.data;
-      const char *name = uniform.name.c_str();
-      char prefix = ' ';
-      int vec_len;
-      switch (data.m_type) {
-        case UNIFORM_DOUBLE: {
-          vec_len = 1;
-          float value = float(data.m_getDouble());
-          memcpy(ubo_data, &value, sizeof(float));
-          break;
-        }
-        case UNIFORM_BOOL: {
-          prefix = 'b';
-          vec_len = 1;
-          int value = int(data.m_getBool());
-          memcpy(ubo_data, &value, sizeof(int));
-          break;
-        }
-        case UNIFORM_FLOAT3:
-          vec_len = 3;
-          memcpy(ubo_data, data.m_getFloat3().data(), sizeof(float) * 3);
-          break;
-        case UNIFORM_VECTOR_FLOAT:
-          vec_len = data.m_vectorFloat.m_getSize();
-          memcpy(ubo_data, data.m_vectorFloat.m_getVector(), sizeof(float) * vec_len);
-          break;
-        case UNIFORM_VECTOR_INT:
-          prefix = 'i';
-          vec_len = data.m_vectorInt.m_getSize();
-          memcpy(ubo_data, data.m_vectorInt.m_getVector(), sizeof(int) * vec_len);
-          break;
-        default:
-          continue;
-      }
-      /* Align every member to 16bytes. */
-      ubo_data += 4;
-      /* Use a generic variable name because some GLSL compilers can interpret the preprocessor
-       * define as recursive. */
-      ss << "  " << prefix << "vec4 var" << index << ";\n";
-      /* Use a define to keep the generated code working. */
-      blender::StringRef suffix = blender::StringRefNull("xyzw").substr(0, vec_len);
-      ss << "#define " << name << " lut_parameters.var" << index << "." << suffix << "\n";
-    }
-    ss << "};\n";
-    info.typedef_source_generated = ss.str();
+  shader.scale_loc = GPU_shader_get_uniform(shader.shader, "scale");
+  shader.exponent_loc = GPU_shader_get_uniform(shader.shader, "exponent");
+  shader.dither_loc = GPU_shader_get_uniform(shader.shader, "dither");
+  shader.overlay_loc = GPU_shader_get_uniform(shader.shader, "overlay");
+  shader.predivide_loc = GPU_shader_get_uniform(shader.shader, "predivide");
+  shader.ubo_bind = GPU_shader_get_uniform_block_binding(shader.shader,
+                                                         "OCIO_GPUCurveMappingParameters");
 
-    info.uniform_buf(UNIFORMBUF_SLOT_LUTS, "OCIO_GPULutParameters", "lut_parameters");
+  GPU_shader_bind(shader.shader);
 
-    textures.uniforms_buffer = GPU_uniformbuf_create_ex(
-        ubo_size, ubo_data_buf, "OCIO_LutParameters");
+  /* Set texture bind point uniform once. This is saved by the shader. */
+  GPUShader *sh = shader.shader;
+  GPU_shader_uniform_int(sh, GPU_shader_get_uniform(sh, "image_texture"), TEXTURE_SLOT_IMAGE);
+  GPU_shader_uniform_int(sh, GPU_shader_get_uniform(sh, "overlay_texture"), TEXTURE_SLOT_OVERLAY);
 
-    free(ubo_data_buf);
+  if (use_curve_mapping) {
+    GPU_shader_uniform_int(
+        sh, GPU_shader_get_uniform(sh, "curve_mapping_texture"), TEXTURE_SLOT_CURVE_MAPPING);
   }
 
-  shader.shader = GPU_shader_create_from_info(reinterpret_cast<GPUShaderCreateInfo *>(&info));
+  /* Set LUT textures. */
+  for (int i = 0; i < textures.luts.size(); i++) {
+    GPU_shader_uniform_int(sh,
+                           GPU_shader_get_uniform(sh, textures.luts[i].sampler_name.c_str()),
+                           TEXTURE_SLOT_LUTS_OFFSET + i);
+  }
 
-  return (shader.shader != nullptr);
+  /* Set uniforms. */
+  for (OCIO_GPUUniform &uniform : textures.uniforms) {
+    const GpuShaderDesc::UniformData &data = uniform.data;
+    const char *name = uniform.name.c_str();
+
+    if (data.m_getDouble) {
+      GPU_shader_uniform_1f(sh, name, (float)data.m_getDouble());
+    }
+    else if (data.m_getBool) {
+      GPU_shader_uniform_1f(sh, name, (float)(data.m_getBool() ? 1.0f : 0.0f));
+    }
+    else if (data.m_getFloat3) {
+      GPU_shader_uniform_3f(sh,
+                            name,
+                            (float)data.m_getFloat3()[0],
+                            (float)data.m_getFloat3()[1],
+                            (float)data.m_getFloat3()[2]);
+    }
+    else if (data.m_vectorFloat.m_getSize && data.m_vectorFloat.m_getVector) {
+      GPU_shader_uniform_vector(sh,
+                                GPU_shader_get_uniform(sh, name),
+                                (int)data.m_vectorFloat.m_getSize(),
+                                1,
+                                (float *)data.m_vectorFloat.m_getVector());
+    }
+    else if (data.m_vectorInt.m_getSize && data.m_vectorInt.m_getVector) {
+      GPU_shader_uniform_vector_int(sh,
+                                    GPU_shader_get_uniform(sh, name),
+                                    (int)data.m_vectorInt.m_getSize(),
+                                    1,
+                                    (int *)data.m_vectorInt.m_getVector());
+    }
+  }
+
+  return true;
 }
 
 /** \} */
@@ -488,65 +466,27 @@ static void updateGPUCurveMapping(OCIO_GPUCurveMappping &curvemap,
   /* Update uniforms. */
   OCIO_GPUCurveMappingParameters data;
   for (int i = 0; i < 4; i++) {
-    data.range[i] = curve_mapping_settings->range[i];
-    data.mintable[i] = curve_mapping_settings->mintable[i];
-    data.ext_in_x[i] = curve_mapping_settings->ext_in_x[i];
-    data.ext_in_y[i] = curve_mapping_settings->ext_in_y[i];
-    data.ext_out_x[i] = curve_mapping_settings->ext_out_x[i];
-    data.ext_out_y[i] = curve_mapping_settings->ext_out_y[i];
-    data.first_x[i] = curve_mapping_settings->first_x[i];
-    data.first_y[i] = curve_mapping_settings->first_y[i];
-    data.last_x[i] = curve_mapping_settings->last_x[i];
-    data.last_y[i] = curve_mapping_settings->last_y[i];
+    data.curve_mapping_range[i] = curve_mapping_settings->range[i];
+    data.curve_mapping_mintable[i] = curve_mapping_settings->mintable[i];
+    data.curve_mapping_ext_in_x[i] = curve_mapping_settings->ext_in_x[i];
+    data.curve_mapping_ext_in_y[i] = curve_mapping_settings->ext_in_y[i];
+    data.curve_mapping_ext_out_x[i] = curve_mapping_settings->ext_out_x[i];
+    data.curve_mapping_ext_out_y[i] = curve_mapping_settings->ext_out_y[i];
+    data.curve_mapping_first_x[i] = curve_mapping_settings->first_x[i];
+    data.curve_mapping_first_y[i] = curve_mapping_settings->first_y[i];
+    data.curve_mapping_last_x[i] = curve_mapping_settings->last_x[i];
+    data.curve_mapping_last_y[i] = curve_mapping_settings->last_y[i];
   }
   for (int i = 0; i < 3; i++) {
-    data.black[i] = curve_mapping_settings->black[i];
-    data.bwmul[i] = curve_mapping_settings->bwmul[i];
+    data.curve_mapping_black[i] = curve_mapping_settings->black[i];
+    data.curve_mapping_bwmul[i] = curve_mapping_settings->bwmul[i];
   }
-  data.lut_size = curve_mapping_settings->lut_size;
-  data.use_extend_extrapolate = curve_mapping_settings->use_extend_extrapolate;
+  data.curve_mapping_lut_size = curve_mapping_settings->lut_size;
+  data.curve_mapping_use_extend_extrapolate = curve_mapping_settings->use_extend_extrapolate;
 
   GPU_uniformbuf_update(curvemap.buffer, &data);
 }
 
-static void updateGPUDisplayParameters(OCIO_GPUShader &shader,
-                                       float scale,
-                                       float exponent,
-                                       float dither,
-                                       bool use_predivide,
-                                       bool use_overlay)
-{
-  bool do_update = false;
-  if (shader.parameters_buffer == nullptr) {
-    shader.parameters_buffer = GPU_uniformbuf_create(sizeof(OCIO_GPUParameters));
-    do_update = true;
-  }
-  OCIO_GPUParameters &data = shader.parameters;
-  if (data.scale != scale) {
-    data.scale = scale;
-    do_update = true;
-  }
-  if (data.exponent != exponent) {
-    data.exponent = exponent;
-    do_update = true;
-  }
-  if (data.dither != dither) {
-    data.dither = dither;
-    do_update = true;
-  }
-  if (data.use_predivide != use_predivide) {
-    data.use_predivide = use_predivide;
-    do_update = true;
-  }
-  if (data.use_overlay != use_overlay) {
-    data.use_overlay = use_overlay;
-    do_update = true;
-  }
-  if (do_update) {
-    GPU_uniformbuf_update(shader.parameters_buffer, &data);
-  }
-}
-
 /** \} */
 
 /* -------------------------------------------------------------------- */
@@ -697,7 +637,7 @@ bool OCIOImpl::gpuDisplayShaderBind(OCIO_ConstConfigRcPtr *config,
   /* Update and bind curve mapping data. */
   if (curve_mapping_settings) {
     updateGPUCurveMapping(curvemap, curve_mapping_settings);
-    GPU_uniformbuf_bind(curvemap.buffer, UNIFORMBUF_SLOT_CURVEMAP);
+    GPU_uniformbuf_bind(curvemap.buffer, shader.ubo_bind);
     GPU_texture_bind(curvemap.texture, TEXTURE_SLOT_CURVE_MAPPING);
   }
 
@@ -711,16 +651,17 @@ bool OCIOImpl::gpuDisplayShaderBind(OCIO_ConstConfigRcPtr *config,
     GPU_texture_bind(textures.luts[i].texture, TEXTURE_SLOT_LUTS_OFFSET + i);
   }
 
-  if (textures.uniforms_buffer) {
-    GPU_uniformbuf_bind(textures.uniforms_buffer, UNIFORMBUF_SLOT_LUTS);
-  }
-
-  updateGPUDisplayParameters(shader, scale, exponent, dither, use_predivide, use_overlay);
-  GPU_uniformbuf_bind(shader.parameters_buffer, UNIFORMBUF_SLOT_DISPLAY);
-
   /* TODO(fclem): remove remains of IMM. */
   immBindShader(shader.shader);
 
+  /* Bind Shader and set uniforms. */
+  // GPU_shader_bind(shader.shader);
+  GPU_shader_uniform_float(shader.shader, shader.scale_loc, scale);
+  GPU_shader_uniform_float(shader.shader, shader.exponent_loc, exponent);
+  GPU_shader_uniform_float(shader.shader, shader.dither_loc, dither);
+  GPU_shader_uniform_int(shader.shader, shader.overlay_loc, use_overlay);
+  GPU_shader_uniform_int(shader.shader, shader.predivide_loc, use_predivide);
+
   return true;
 }
 
diff --git a/intern/opencolorio/ocio_shader_shared.hh b/intern/opencolorio/ocio_shader_shared.hh
deleted file mode 100644
index c7045217196..00000000000
--- a/intern/opencolorio/ocio_shader_shared.hh
+++ /dev/null
@@ -1,41 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later
- * Copyright 2022 Blender Foundation. All rights reserved. */
-
-#ifndef GPU_SHADER
-#  include "GPU_shader_shared_utils.h"
-#endif
-
-struct OCIO_GPUCurveMappingParameters {
-  /* Curve mapping parameters
-   *
-   * See documentation for OCIO_CurveMappingSettings to get fields descriptions.
-   * (this ones pretty much copies stuff from C structure.)
-   */
-  float4 mintable;
-  float4 range;
-  float4 ext_in_x;
-  float4 ext_in_y;
-  float4 ext_out_x;
-  float4 ext_out_y;
-  float4 first_x;
-  float4 first_y;
-  float4 last_x;
-  float4 last_y;
-  float4 black;
-  float4 bwmul;
-  int lut_size;
-  int use_extend_extrapolate;
-  int _pad0;
-  int _pad1;
-};
-
-struct OCIO_GPUParameters {
-  float dither;
-  float scale;
-  float exponent;
-  bool1 use_predivide;
-  bool1 use_overlay;
-  int _pad0;
-  int _pad1;
-  int _pad2;
-};