From 37fa1bc254b880d9e8477aec28520e0bdb25b734 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= Date: Thu, 17 Feb 2022 17:03:23 +0100 Subject: OCIO: Port shader creation logic to use GPUShaderCreateInfo This commit should suffice to make the shader API agnostic now (given that all users of it use the GPU API). This makes the shaders not trigger a false positive error anymore since the binding slots are now garanteed by the backend and not changed at after compilation. This also bundles all uniforms into UBOs. Making them extendable without limitations of push constants. The generated uniforms from OCIO are not densely packed in the UBO to avoid complexity. Another approach would be to use GPU_uniformbuf_create_from_list but this requires converting uniforms to GPUInputs which is too complex for what it is. Reviewed by: brecht, jbakker Differential Revision: https://developer.blender.org/D14123 --- intern/opencolorio/CMakeLists.txt | 36 ++- .../opencolorio/gpu_shader_display_transform.glsl | 210 -------------- .../gpu_shader_display_transform_frag.glsl | 195 +++++++++++++ .../gpu_shader_display_transform_vert.glsl | 6 + .../gpu_shader_display_transform_vertex.glsl | 12 - intern/opencolorio/ocio_impl_glsl.cc | 323 ++++++++++++--------- intern/opencolorio/ocio_shader_shared.hh | 41 +++ 7 files changed, 467 insertions(+), 356 deletions(-) delete mode 100644 intern/opencolorio/gpu_shader_display_transform.glsl create mode 100644 intern/opencolorio/gpu_shader_display_transform_frag.glsl create mode 100644 intern/opencolorio/gpu_shader_display_transform_vert.glsl delete mode 100644 intern/opencolorio/gpu_shader_display_transform_vertex.glsl create mode 100644 intern/opencolorio/ocio_shader_shared.hh (limited to 'intern') diff --git a/intern/opencolorio/CMakeLists.txt b/intern/opencolorio/CMakeLists.txt index dfccb9301ac..be6ccc5c2c5 100644 --- a/intern/opencolorio/CMakeLists.txt +++ b/intern/opencolorio/CMakeLists.txt @@ -7,6 +7,7 @@ set(INC ../guardedalloc ../../source/blender/blenlib ../../source/blender/gpu + ../../source/blender/gpu/intern ../../source/blender/makesdna ) @@ -20,6 +21,7 @@ set(SRC ocio_capi.h ocio_impl.h + ocio_shader_shared.hh ) set(LIB @@ -56,8 +58,38 @@ if(WITH_OPENCOLORIO) ) endif() - data_to_c_simple(gpu_shader_display_transform.glsl SRC) - data_to_c_simple(gpu_shader_display_transform_vertex.glsl SRC) + 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}) + endif() diff --git a/intern/opencolorio/gpu_shader_display_transform.glsl b/intern/opencolorio/gpu_shader_display_transform.glsl deleted file mode 100644 index f5a7a7bf45d..00000000000 --- a/intern/opencolorio/gpu_shader_display_transform.glsl +++ /dev/null @@ -1,210 +0,0 @@ -/* Blender OpenColorIO 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) -{ - return texelFetch(curve_mapping_texture, index, 0)[table]; -} - -float curvemap_calc_extend(int table, float x, vec2 first, vec2 last) -{ - if (x <= first[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]) : - 10000.0; - return first[1] + curve_mapping_ext_in_y[table] * fac; - } - } - else if (x >= last[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]) : - -10000.0; - return last[1] + curve_mapping_ext_out_y[table] * fac; - } - } - return 0.0; -} - -float curvemap_evaluateF(int table, float value) -{ - float mintable_ = curve_mapping_mintable[table]; - float range = curve_mapping_range[table]; - float mintable = 0.0; - int CM_TABLE = curve_mapping_lut_size - 1; - - float fi; - int i; - - /* index in table */ - fi = (value - mintable) * range; - i = int(fi); - - /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */ - 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])); - } - else { - if (i < 0) { - return read_curve_mapping(table, 0); - } - if (i >= CM_TABLE) { - return read_curve_mapping(table, CM_TABLE); - } - fi = fi - float(i); - float cm1 = read_curve_mapping(table, i); - float cm2 = read_curve_mapping(table, i + 1); - return mix(cm1, cm2, fi); - } -} - -vec4 curvemapping_evaluate_premulRGBF(vec4 col) -{ - col.rgb = (col.rgb - curve_mapping_black.rgb) * curve_mapping_bwmul.rgb; - - vec4 result; - result.r = curvemap_evaluateF(0, col.r); - result.g = curvemap_evaluateF(1, col.g); - result.b = curvemap_evaluateF(2, col.b); - result.a = col.a; - return result; -} -#endif /* USE_CURVE_MAPPING */ - -/* 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. */ -/* Return triangle noise in [-1..1[ range */ -float dither_random_value(vec2 co) -{ - /* Original code from https://www.shadertoy.com/view/4t2SDh */ - /* Uniform noise in [0..1[ range */ - float nrnd0 = fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453); - /* Convert uniform distribution into triangle-shaped distribution. */ - float orig = nrnd0 * 2.0 - 1.0; - nrnd0 = orig * inversesqrt(abs(orig)); - nrnd0 = max(-1.0, nrnd0); /* Removes nan's */ - return nrnd0 - sign(orig); -} - -vec2 round_to_pixel(sampler2D tex, vec2 uv) -{ - 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 * dither; - return col; -} - -vec4 OCIO_ProcessColor(vec4 col, vec4 col_overlay, vec2 noise_uv) -{ -#ifdef USE_CURVE_MAPPING - col = curvemapping_evaluate_premulRGBF(col); -#endif - - if (predivide) { - if (col.a > 0.0 && col.a < 1.0) { - col.rgb *= 1.0 / col.a; - } - } - - /* NOTE: This is true we only do de-premul here and NO premul - * and the reason is simple -- opengl is always configured - * for straight alpha at this moment - */ - - /* Convert to scene linear (usually a no-op). */ - col = OCIO_to_scene_linear(col); - - /* Apply exposure in scene linear. */ - col.rgb *= scale; - - /* Convert to display space. */ - col = OCIO_to_display(col); - - /* Blend with overlay in UI colorspace. - * - * UI colorspace here refers to the display linear color space, - * 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 (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(exponent)); - } - - 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, noise_uv); -} diff --git a/intern/opencolorio/gpu_shader_display_transform_frag.glsl b/intern/opencolorio/gpu_shader_display_transform_frag.glsl new file mode 100644 index 00000000000..3c2352c13ba --- /dev/null +++ b/intern/opencolorio/gpu_shader_display_transform_frag.glsl @@ -0,0 +1,195 @@ +/* Blender OpenColorIO implementation */ + +/* -------------------------------------------------------------------- */ +/** \name Curve Mapping Implementation + * \{ */ + +#ifdef USE_CURVE_MAPPING + +float read_curve_mapping(int table, int index) +{ + return texelFetch(curve_mapping_texture, index, 0)[table]; +} + +float curvemap_calc_extend(int table, float x, vec2 first, vec2 last) +{ + if (x <= first[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]) : + 10000.0; + return first[1] + curve_mapping.ext_in_y[table] * fac; + } + } + else if (x >= last[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]) : + -10000.0; + return last[1] + curve_mapping.ext_out_y[table] * fac; + } + } + return 0.0; +} + +float curvemap_evaluateF(int table, float value) +{ + float mintable_ = curve_mapping.mintable[table]; + float range = curve_mapping.range[table]; + float mintable = 0.0; + int CM_TABLE = curve_mapping.lut_size - 1; + + float fi; + int i; + + /* index in table */ + fi = (value - mintable) * range; + i = int(fi); + + /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */ + 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])); + } + else { + if (i < 0) { + return read_curve_mapping(table, 0); + } + if (i >= CM_TABLE) { + return read_curve_mapping(table, CM_TABLE); + } + fi = fi - float(i); + float cm1 = read_curve_mapping(table, i); + float cm2 = read_curve_mapping(table, i + 1); + return mix(cm1, cm2, fi); + } +} + +vec4 curvemapping_evaluate_premulRGBF(vec4 col) +{ + col.rgb = (col.rgb - curve_mapping.black.rgb) * curve_mapping.bwmul.rgb; + + vec4 result; + result.r = curvemap_evaluateF(0, col.r); + result.g = curvemap_evaluateF(1, col.g); + result.b = curvemap_evaluateF(2, col.b); + 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. */ +/* Return triangle noise in [-1..1[ range */ +float dither_random_value(vec2 co) +{ + /* Original code from https://www.shadertoy.com/view/4t2SDh */ + /* Uniform noise in [0..1[ range */ + float nrnd0 = fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453); + /* Convert uniform distribution into triangle-shaped distribution. */ + float orig = nrnd0 * 2.0 - 1.0; + nrnd0 = orig * inversesqrt(abs(orig)); + nrnd0 = max(-1.0, nrnd0); /* Removes nan's */ + return nrnd0 - sign(orig); +} + +vec2 round_to_pixel(sampler2D tex, vec2 uv) +{ + vec2 size = vec2(textureSize(tex, 0)); + return floor(uv * size) / size; +} + +vec4 apply_dither(vec4 col, vec2 uv) +{ + col.rgb += dither_random_value(uv) * 0.0033 * parameters.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) +{ +#ifdef USE_CURVE_MAPPING + col = curvemapping_evaluate_premulRGBF(col); +#endif + + if (parameters.use_predivide) { + if (col.a > 0.0 && col.a < 1.0) { + col.rgb *= 1.0 / col.a; + } + } + + /* NOTE: This is true we only do de-premul here and NO premul + * and the reason is simple -- opengl is always configured + * for straight alpha at this moment + */ + + /* Convert to scene linear (usually a no-op). */ + col = OCIO_to_scene_linear(col); + + /* Apply exposure in scene linear. */ + col.rgb *= parameters.scale; + + /* Convert to display space. */ + col = OCIO_to_display(col); + + /* Blend with overlay in UI colorspace. + * + * UI colorspace here refers to the display linear color space, + * 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)); + 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)); + } + + if (parameters.dither > 0.0) { + vec2 noise_uv = round_to_pixel(image_texture, texCoord_interp.st); + col = apply_dither(col, noise_uv); + } + + return col; +} + +/** \} */ + +void main() +{ + vec4 col = texture(image_texture, texCoord_interp.st); + vec4 col_overlay = texture(overlay_texture, texCoord_interp.st); + + fragColor = OCIO_ProcessColor(col, col_overlay); +} diff --git a/intern/opencolorio/gpu_shader_display_transform_vert.glsl b/intern/opencolorio/gpu_shader_display_transform_vert.glsl new file mode 100644 index 00000000000..06788be11de --- /dev/null +++ b/intern/opencolorio/gpu_shader_display_transform_vert.glsl @@ -0,0 +1,6 @@ + +void main() +{ + gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0f, 1.0f); + texCoord_interp = texCoord; +} diff --git a/intern/opencolorio/gpu_shader_display_transform_vertex.glsl b/intern/opencolorio/gpu_shader_display_transform_vertex.glsl deleted file mode 100644 index 8cf9628b06b..00000000000 --- a/intern/opencolorio/gpu_shader_display_transform_vertex.glsl +++ /dev/null @@ -1,12 +0,0 @@ - -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); - texCoord_interp = texCoord; -} diff --git a/intern/opencolorio/ocio_impl_glsl.cc b/intern/opencolorio/ocio_impl_glsl.cc index 09803cd8038..47c965dbc8e 100644 --- a/intern/opencolorio/ocio_impl_glsl.cc +++ b/intern/opencolorio/ocio_impl_glsl.cc @@ -21,14 +21,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" - -extern "C" char datatoc_gpu_shader_display_transform_glsl[]; -extern "C" char datatoc_gpu_shader_display_transform_vertex_glsl[]; +#include "ocio_shader_shared.hh" /* **** OpenGL drawing routines using GLSL for color space transform ***** */ @@ -39,41 +39,19 @@ enum OCIO_GPUTextureSlots { TEXTURE_SLOT_LUTS_OFFSET = 3, }; -/* 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. */ +enum OCIO_GPUUniformBufSlots { + UNIFORMBUF_SLOT_DISPLAY = 0, + UNIFORMBUF_SLOT_CURVEMAP = 1, + UNIFORMBUF_SLOT_LUTS = 2, }; struct OCIO_GPUShader { /* GPU shader. */ struct GPUShader *shader = 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; + /** Uniform parameters. */ + OCIO_GPUParameters parameters = {}; + GPUUniformBuf *parameters_buffer = nullptr; /* Destructor. */ ~OCIO_GPUShader() @@ -81,6 +59,9 @@ struct OCIO_GPUShader { if (shader) { GPU_shader_free(shader); } + if (parameters_buffer) { + GPU_uniformbuf_free(parameters_buffer); + } } }; @@ -103,6 +84,7 @@ struct OCIO_GPUTextures { /* Uniforms */ std::vector uniforms; + GPUUniformBuf *uniforms_buffer = nullptr; /* Destructor. */ ~OCIO_GPUTextures() @@ -113,6 +95,9 @@ struct OCIO_GPUTextures { if (dummy) { GPU_texture_free(dummy); } + if (uniforms_buffer) { + GPU_uniformbuf_free(uniforms_buffer); + } } }; @@ -165,97 +150,134 @@ static bool createGPUShader(OCIO_GPUShader &shader, const GpuShaderDescRcPtr &shaderdesc_to_display, const bool use_curve_mapping) { - std::ostringstream os; - { - /* Fragment shader */ + using namespace blender::gpu::shader; - /* Work around OpenColorIO not supporting latest GLSL yet. */ - os << "#define texture2D texture\n"; - os << "#define texture3D texture\n"; + std::string source; + source += shaderdesc_to_scene_linear->getShaderText(); + source += "\n"; + source += shaderdesc_to_display->getShaderText(); + source += "\n"; - if (use_curve_mapping) { - os << "#define USE_CURVE_MAPPING\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; } - - os << shaderdesc_to_scene_linear->getShaderText() << "\n"; - os << shaderdesc_to_display->getShaderText() << "\n"; - - os << datatoc_gpu_shader_display_transform_glsl; } - shader.shader = GPU_shader_create(datatoc_gpu_shader_display_transform_vertex_glsl, - os.str().c_str(), - nullptr, - nullptr, - nullptr, - "OCIOShader"); - - if (shader.shader == nullptr) { - return false; - } - - 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"); - - GPU_shader_bind(shader.shader); - - /* 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); + 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; if (use_curve_mapping) { - GPU_shader_uniform_int( - sh, GPU_shader_get_uniform(sh, "curve_mapping_texture"), TEXTURE_SLOT_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"); } /* 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); - } + 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(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(); - /* Set uniforms. */ - for (OCIO_GPUUniform &uniform : textures.uniforms) { - const GpuShaderDesc::UniformData &data = uniform.data; - const char *name = uniform.name.c_str(); + info.uniform_buf(UNIFORMBUF_SLOT_LUTS, "OCIO_GPULutParameters", "lut_parameters"); - 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()); - } + textures.uniforms_buffer = GPU_uniformbuf_create_ex( + ubo_size, ubo_data_buf, "OCIO_LutParameters"); + + free(ubo_data_buf); } - return true; + shader.shader = GPU_shader_create_from_info(reinterpret_cast(&info)); + + return (shader.shader != nullptr); } /** \} */ @@ -438,27 +460,65 @@ static void updateGPUCurveMapping(OCIO_GPUCurveMappping &curvemap, /* Update uniforms. */ OCIO_GPUCurveMappingParameters data; for (int i = 0; i < 4; 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]; + 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]; } for (int i = 0; i < 3; i++) { - data.curve_mapping_black[i] = curve_mapping_settings->black[i]; - data.curve_mapping_bwmul[i] = curve_mapping_settings->bwmul[i]; + data.black[i] = curve_mapping_settings->black[i]; + data.bwmul[i] = curve_mapping_settings->bwmul[i]; } - data.curve_mapping_lut_size = curve_mapping_settings->lut_size; - data.curve_mapping_use_extend_extrapolate = curve_mapping_settings->use_extend_extrapolate; + data.lut_size = curve_mapping_settings->lut_size; + data.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); + } +} + /** \} */ /* -------------------------------------------------------------------- */ @@ -609,7 +669,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, shader.ubo_bind); + GPU_uniformbuf_bind(curvemap.buffer, UNIFORMBUF_SLOT_CURVEMAP); GPU_texture_bind(curvemap.texture, TEXTURE_SLOT_CURVE_MAPPING); } @@ -623,17 +683,16 @@ 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 new file mode 100644 index 00000000000..c7045217196 --- /dev/null +++ b/intern/opencolorio/ocio_shader_shared.hh @@ -0,0 +1,41 @@ +/* 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; +}; -- cgit v1.2.3