mainnika/weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge tag '11.0.3' into dev

Browse Source 
11.0.3
This commit is contained in:
nikita tokarchuk
2024-07-20 21:35:16 +02:00
parent 2e543aef21 742ad74bc0
commit 0cc7369023
217 changed files with 15749 additions and 15899 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libweston/renderer-gl/egl-glue.c
+31 -6
View File
@@ -31,6 +31,7 @@
#include "shared/helpers.h"
#include "shared/platform.h"
#include "shared/string-helpers.h"
#include "gl-renderer.h"
#include "gl-renderer-internal.h"
@@ -477,7 +478,7 @@ gl_renderer_set_egl_device(struct gl_renderer *gr)
return;
}
gl_renderer_log_extensions("EGL device extensions", extensions);
gl_renderer_log_extensions(gr, "EGL device extensions", extensions);
/* Try to query the render node using EGL_DRM_RENDER_NODE_FILE_EXT */
if (weston_check_egl_extension(extensions, "EGL_EXT_device_drm_render_node"))
@@ -490,8 +491,10 @@ gl_renderer_set_egl_device(struct gl_renderer *gr)
gr->drm_device = gr->query_device_string(gr->egl_device,
EGL_DRM_DEVICE_FILE_EXT);
if (!gr->drm_device)
weston_log("failed to query DRM device from EGL\n");
if (gr->drm_device)
weston_log("Using rendering device: %s\n", gr->drm_device);
else
weston_log("warning: failed to query rendering device from EGL\n");
}
int
@@ -573,8 +576,7 @@ gl_renderer_setup_egl_client_extensions(struct gl_renderer *gr)
return 0;
}
gl_renderer_log_extensions("EGL client extensions",
extensions);
gl_renderer_log_extensions(gr, "EGL client extensions", extensions);
if (weston_check_egl_extension(extensions, "EGL_EXT_device_query")) {
gr->query_display_attrib =
@@ -594,8 +596,10 @@ gl_renderer_setup_egl_client_extensions(struct gl_renderer *gr)
weston_log("warning: EGL_EXT_platform_base not supported.\n");
/* Surfaceless is unusable without platform_base extension */
if (gr->platform == EGL_PLATFORM_SURFACELESS_MESA)
if (gr->platform == EGL_PLATFORM_SURFACELESS_MESA) {
weston_log("Error: EGL surfaceless platform cannot be used.\n");
return -1;
}
return 0;
}
@@ -615,6 +619,7 @@ gl_renderer_setup_egl_client_extensions(struct gl_renderer *gr)
/* at this point we definitely have some platform extensions but
* haven't found the supplied platform, so chances are it's
* not supported. */
weston_log("Error: EGL does not support %s platform.\n", extension_suffix);
return -1;
}
@@ -739,5 +744,25 @@ gl_renderer_setup_egl_extensions(struct weston_compositor *ec)
"to missing EGL_KHR_wait_sync extension\n");
}
weston_log("EGL features:\n");
weston_log_continue(STAMP_SPACE "EGL Wayland extension: %s\n",
yesno(gr->has_bind_display));
weston_log_continue(STAMP_SPACE "context priority: %s\n",
yesno(gr->has_context_priority));
weston_log_continue(STAMP_SPACE "buffer age: %s\n",
yesno(gr->has_egl_buffer_age));
weston_log_continue(STAMP_SPACE "partial update: %s\n",
yesno(gr->has_egl_partial_update));
weston_log_continue(STAMP_SPACE "swap buffers with damage: %s\n",
yesno(gr->swap_buffers_with_damage));
weston_log_continue(STAMP_SPACE "configless context: %s\n",
yesno(gr->has_configless_context));
weston_log_continue(STAMP_SPACE "surfaceless context: %s\n",
yesno(gr->has_surfaceless_context));
weston_log_continue(STAMP_SPACE "dmabuf support: %s\n",
gr->has_dmabuf_import ?
(gr->has_dmabuf_import_modifiers ? "modifiers" : "legacy") :
"no");
return 0;
}
libweston/renderer-gl/fragment.glsl
+62 -27
View File
@@ -2,6 +2,7 @@
* Copyright 2012 Intel Corporation
* Copyright 2015,2019,2021 Collabora, Ltd.
* Copyright 2016 NVIDIA Corporation
* Copyright 2021 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
@@ -46,10 +47,18 @@
#define SHADER_COLOR_CURVE_IDENTITY 0
#define SHADER_COLOR_CURVE_LUT_3x1D 1
/* enum gl_shader_color_mapping */
#define SHADER_COLOR_MAPPING_IDENTITY 0
#define SHADER_COLOR_MAPPING_3DLUT 1
#if DEF_VARIANT == SHADER_VARIANT_EXTERNAL
#extension GL_OES_EGL_image_external : require
#endif
#if DEF_COLOR_MAPPING == SHADER_COLOR_MAPPING_3DLUT
#extension GL_OES_texture_3D : require
#endif
#ifdef GL_FRAGMENT_PRECISION_HIGH
#define HIGHPRECISION highp
#else
@@ -66,6 +75,11 @@ compile_const int c_variant = DEF_VARIANT;
compile_const bool c_input_is_premult = DEF_INPUT_IS_PREMULT;
compile_const bool c_green_tint = DEF_GREEN_TINT;
compile_const int c_color_pre_curve = DEF_COLOR_PRE_CURVE;
compile_const int c_color_mapping = DEF_COLOR_MAPPING;
compile_const bool c_need_color_pipeline =
c_color_pre_curve != SHADER_COLOR_CURVE_IDENTITY ||
c_color_mapping != SHADER_COLOR_MAPPING_IDENTITY;
compile_const bool c_need_color_pipeline =
c_color_pre_curve != SHADER_COLOR_CURVE_IDENTITY;
@@ -108,11 +122,16 @@ uniform sampler2D tex;
varying vec2 v_texcoord;
uniform sampler2D tex1;
uniform sampler2D tex2;
uniform float alpha;
uniform float view_alpha;
uniform vec4 unicolor;
uniform HIGHPRECISION sampler2D color_pre_curve_lut_2d;
uniform HIGHPRECISION vec2 color_pre_curve_lut_scale_offset;
#if DEF_COLOR_MAPPING == SHADER_COLOR_MAPPING_3DLUT
uniform HIGHPRECISION sampler3D color_mapping_lut_3d;
uniform HIGHPRECISION vec2 color_mapping_lut_scale_offset;
#endif
vec4
sample_input_texture()
{
@@ -171,6 +190,12 @@ lut_texcoord(float x, vec2 scale_offset)
return x * scale_offset.s + scale_offset.t;
}
vec3
lut_texcoord(vec3 pos, vec2 scale_offset)
{
return pos * scale_offset.s + scale_offset.t;
}
/*
* Sample a 1D LUT which is a single row of a 2D texture. The 2D texture has
* four rows so that the centers of texels have precise y-coordinates.
@@ -202,10 +227,41 @@ color_pre_curve(vec3 color)
}
}
vec3
sample_color_mapping_lut_3d(vec3 color)
{
vec3 pos, ret = vec3(0.0, 0.0, 0.0);
#if DEF_COLOR_MAPPING == SHADER_COLOR_MAPPING_3DLUT
pos = lut_texcoord(color, color_mapping_lut_scale_offset);
ret = texture3D(color_mapping_lut_3d, pos).rgb;
#endif
return ret;
}
vec3
color_mapping(vec3 color)
{
if (c_color_mapping == SHADER_COLOR_MAPPING_IDENTITY)
return color;
else if (c_color_mapping == SHADER_COLOR_MAPPING_3DLUT)
return sample_color_mapping_lut_3d(color);
else /* Never reached, bad c_color_mapping. */
return vec3(1.0, 0.3, 1.0);
}
vec4
color_pipeline(vec4 color)
{
/* Ensure straight alpha */
if (c_input_is_premult) {
if (color.a == 0.0)
color.rgb = vec3(0, 0, 0);
else
color.rgb *= 1.0 / color.a;
}
color.rgb = color_pre_curve(color.rgb);
color.rgb = color_mapping(color.rgb);
return color;
}
@@ -218,35 +274,14 @@ main()
/* Electrical (non-linear) RGBA values, may be premult or not */
color = sample_input_texture();
if (c_need_color_pipeline) {
/* Ensure straight alpha */
if (c_input_is_premult) {
if (color.a == 0.0)
color.rgb = vec3(0, 0, 0);
else
color.rgb *= 1.0 / color.a;
}
if (c_need_color_pipeline)
color = color_pipeline(color); /* Produces straight alpha */
color = color_pipeline(color);
/* View alpha (opacity) */
color.a *= alpha;
/* pre-multiply for blending */
/* Ensure pre-multiplied for blending */
if (!c_input_is_premult || c_need_color_pipeline)
color.rgb *= color.a;
} else {
/* Fast path for disabled color management */
if (c_input_is_premult) {
/* View alpha (opacity) */
color *= alpha;
} else {
/* View alpha (opacity) */
color.a *= alpha;
/* pre-multiply for blending */
color.rgb *= color.a;
}
}
color *= view_alpha;
if (c_green_tint)
color = vec4(0.0, 0.3, 0.0, 0.2) + color * 0.8;
libweston/renderer-gl/gl-renderer-internal.h
+20 -3
View File
@@ -2,6 +2,7 @@
* Copyright © 2019 Collabora, Ltd.
* Copyright © 2019 Harish Krupo
* Copyright © 2019 Intel Corporation
* Copyright 2021 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
@@ -56,6 +57,12 @@ enum gl_shader_color_curve {
SHADER_COLOR_CURVE_LUT_3x1D,
};
/* Keep the following in sync with fragment.glsl. */
enum gl_shader_color_mapping {
SHADER_COLOR_MAPPING_IDENTITY = 0,
SHADER_COLOR_MAPPING_3DLUT,
};
/** GL shader requirements key
*
* This structure is used as a binary blob key for building and searching
@@ -70,13 +77,14 @@ struct gl_shader_requirements
unsigned variant:4; /* enum gl_shader_texture_variant */
bool input_is_premult:1;
bool green_tint:1;
unsigned color_pre_curve:1; /* enum gl_shader_color_curve */
unsigned color_pre_curve:1; /* enum gl_shader_color_curve */
unsigned color_mapping:1; /* enum gl_shader_color_mapping */
/*
* The total size of all bitfields plus pad_bits_ must fill up exactly
* how many bytes the compiler allocates for them together.
*/
unsigned pad_bits_:25;
unsigned pad_bits_:24;
};
static_assert(sizeof(struct gl_shader_requirements) ==
4 /* total bitfield size in bytes */,
@@ -96,11 +104,18 @@ struct gl_shader_config {
GLuint input_tex[GL_SHADER_INPUT_TEX_MAX];
GLuint color_pre_curve_lut_tex;
GLfloat color_pre_curve_lut_scale_offset[2];
union {
struct {
GLuint tex;
GLfloat scale_offset[2];
} lut3d;
} color_mapping;
};
struct gl_renderer {
struct weston_renderer base;
struct weston_compositor *compositor;
struct weston_log_scope *renderer_scope;
bool fragment_shader_debug;
bool fan_debug;
@@ -156,6 +171,7 @@ struct gl_renderer {
bool has_texture_type_2_10_10_10_rev;
bool has_gl_texture_rg;
bool has_texture_norm16;
struct gl_shader *current_shader;
struct gl_shader *fallback_shader;
@@ -198,7 +214,8 @@ void
gl_renderer_print_egl_error_state(void);
void
gl_renderer_log_extensions(const char *name, const char *extensions);
gl_renderer_log_extensions(struct gl_renderer *gr,
const char *name, const char *extensions);
void
log_egl_config_info(EGLDisplay egldpy, EGLConfig eglconfig);
libweston/renderer-gl/gl-renderer.c
+766 -808
View File
File diff suppressed because it is too large Load Diff
libweston/renderer-gl/gl-shader-config-color-transformation.c
+96 -2
View File
@@ -1,5 +1,6 @@
/*
* Copyright 2021 Collabora, Ltd.
* Copyright 2021 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
@@ -44,11 +45,22 @@ struct gl_renderer_color_curve {
float offset;
};
struct gl_renderer_color_mapping {
enum gl_shader_color_mapping type;
union {
struct {
GLuint tex3d;
float scale;
float offset;
} lut3d;
};
} ;
struct gl_renderer_color_transform {
struct weston_color_transform *owner;
struct wl_listener destroy_listener;
struct gl_renderer_color_curve pre_curve;
struct gl_renderer_color_mapping mapping;
};
static void
@@ -58,10 +70,19 @@ gl_renderer_color_curve_fini(struct gl_renderer_color_curve *gl_curve)
glDeleteTextures(1, &gl_curve->tex);
}
static void
gl_renderer_color_mapping_fini(struct gl_renderer_color_mapping *gl_mapping)
{
if (gl_mapping->type == SHADER_COLOR_MAPPING_3DLUT &&
gl_mapping->lut3d.tex3d)
glDeleteTextures(1, &gl_mapping->lut3d.tex3d);
}
static void
gl_renderer_color_transform_destroy(struct gl_renderer_color_transform *gl_xform)
{
gl_renderer_color_curve_fini(&gl_xform->pre_curve);
gl_renderer_color_mapping_fini(&gl_xform->mapping);
wl_list_remove(&gl_xform->destroy_listener.link);
free(gl_xform);
}
@@ -152,6 +173,47 @@ gl_color_curve_lut_3x1d(struct gl_renderer_color_curve *gl_curve,
return true;
}
static bool
gl_3d_lut(struct gl_renderer_color_transform *gl_xform,
struct weston_color_transform *xform)
{
GLuint tex3d;
float *lut;
const unsigned dim_size = xform->mapping.u.lut3d.optimal_len;
lut = calloc(3 * dim_size * dim_size * dim_size, sizeof *lut);
if (!lut)
return false;
xform->mapping.u.lut3d.fill_in(xform, lut, dim_size);
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &tex3d);
glBindTexture(GL_TEXTURE_3D, tex3d);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS_EXT, 0);
glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0);
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB32F, dim_size, dim_size, dim_size, 0,
GL_RGB, GL_FLOAT, lut);
glBindTexture(GL_TEXTURE_3D, 0);
gl_xform->mapping.type = SHADER_COLOR_MAPPING_3DLUT;
gl_xform->mapping.lut3d.tex3d = tex3d;
gl_xform->mapping.lut3d.scale = (float)(dim_size - 1) / dim_size;
gl_xform->mapping.lut3d.offset = 0.5f / dim_size;
free(lut);
return true;
}
static const struct gl_renderer_color_transform *
gl_renderer_color_transform_from(struct weston_color_transform *xform)
{
@@ -160,6 +222,7 @@ gl_renderer_color_transform_from(struct weston_color_transform *xform)
.pre_curve.tex = 0,
.pre_curve.scale = 0.0f,
.pre_curve.offset = 0.0f,
.mapping.type = SHADER_COLOR_MAPPING_IDENTITY,
};
struct gl_renderer_color_transform *gl_xform;
bool ok = false;
@@ -190,6 +253,19 @@ gl_renderer_color_transform_from(struct weston_color_transform *xform)
break;
}
if (!ok) {
gl_renderer_color_transform_destroy(gl_xform);
return NULL;
}
switch (xform->mapping.type) {
case WESTON_COLOR_MAPPING_TYPE_IDENTITY:
gl_xform->mapping = no_op_gl_xform.mapping;
ok = true;
break;
case WESTON_COLOR_MAPPING_TYPE_3D_LUT:
ok = gl_3d_lut(gl_xform, xform);
break;
}
if (!ok) {
gl_renderer_color_transform_destroy(gl_xform);
return NULL;
@@ -203,6 +279,7 @@ gl_shader_config_set_color_transform(struct gl_shader_config *sconf,
struct weston_color_transform *xform)
{
const struct gl_renderer_color_transform *gl_xform;
bool ret = false;
gl_xform = gl_renderer_color_transform_from(xform);
if (!gl_xform)
@@ -213,5 +290,22 @@ gl_shader_config_set_color_transform(struct gl_shader_config *sconf,
sconf->color_pre_curve_lut_scale_offset[0] = gl_xform->pre_curve.scale;
sconf->color_pre_curve_lut_scale_offset[1] = gl_xform->pre_curve.offset;
return true;
sconf->req.color_mapping = gl_xform->mapping.type;
switch (gl_xform->mapping.type) {
case SHADER_COLOR_MAPPING_3DLUT:
sconf->color_mapping.lut3d.tex = gl_xform->mapping.lut3d.tex3d;
sconf->color_mapping.lut3d.scale_offset[0] =
gl_xform->mapping.lut3d.scale;
sconf->color_mapping.lut3d.scale_offset[1] =
gl_xform->mapping.lut3d.offset;
assert(sconf->color_mapping.lut3d.scale_offset[0] > 0.0);
assert(sconf->color_mapping.lut3d.scale_offset[1] > 0.0);
ret = true;
break;
case SHADER_COLOR_MAPPING_IDENTITY:
ret = true;
break;
}
return ret;
}
libweston/renderer-gl/gl-shaders.c
+60 -8
View File
@@ -4,6 +4,7 @@
* Copyright 2016 NVIDIA Corporation
* Copyright 2019 Harish Krupo
* Copyright 2019 Intel Corporation
* Copyright 2021 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
@@ -56,10 +57,16 @@ struct gl_shader {
GLuint vertex_shader, fragment_shader;
GLint proj_uniform;
GLint tex_uniforms[3];
GLint alpha_uniform;
GLint view_alpha_uniform;
GLint color_uniform;
GLint color_pre_curve_lut_2d_uniform;
GLint color_pre_curve_lut_scale_offset_uniform;
union {
struct {
GLint tex_uniform;
GLint scale_offset_uniform;
} lut3d;
} color_mapping;
struct wl_list link; /* gl_renderer::shader_list */
struct timespec last_used;
};
@@ -97,6 +104,19 @@ gl_shader_color_curve_to_string(enum gl_shader_color_curve kind)
return "!?!?"; /* never reached */
}
static const char *
gl_shader_color_mapping_to_string(enum gl_shader_color_mapping kind)
{
switch (kind) {
#define CASERET(x) case x: return #x;
CASERET(SHADER_COLOR_MAPPING_IDENTITY)
CASERET(SHADER_COLOR_MAPPING_3DLUT)
#undef CASERET
}
return "!?!?"; /* never reached */
}
static void
dump_program_with_line_numbers(int count, const char **sources)
{
@@ -162,9 +182,10 @@ create_shader_description_string(const struct gl_shader_requirements *req)
int size;
char *str;
size = asprintf(&str, "%s %s %cinput_is_premult %cgreen",
size = asprintf(&str, "%s %s %s %cinput_is_premult %cgreen",
gl_shader_texture_variant_to_string(req->variant),
gl_shader_color_curve_to_string(req->color_pre_curve),
gl_shader_color_mapping_to_string(req->color_mapping),
req->input_is_premult ? '+' : '-',
req->green_tint ? '+' : '-');
if (size < 0)
@@ -182,10 +203,12 @@ create_shader_config_string(const struct gl_shader_requirements *req)
"#define DEF_GREEN_TINT %s\n"
"#define DEF_INPUT_IS_PREMULT %s\n"
"#define DEF_COLOR_PRE_CURVE %s\n"
"#define DEF_COLOR_MAPPING %s\n"
"#define DEF_VARIANT %s\n",
req->green_tint ? "true" : "false",
req->input_is_premult ? "true" : "false",
gl_shader_color_curve_to_string(req->color_pre_curve),
gl_shader_color_mapping_to_string(req->color_mapping),
gl_shader_texture_variant_to_string(req->variant));
if (size < 0)
return NULL;
@@ -260,7 +283,7 @@ gl_shader_create(struct gl_renderer *gr,
shader->tex_uniforms[0] = glGetUniformLocation(shader->program, "tex");
shader->tex_uniforms[1] = glGetUniformLocation(shader->program, "tex1");
shader->tex_uniforms[2] = glGetUniformLocation(shader->program, "tex2");
shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
shader->view_alpha_uniform = glGetUniformLocation(shader->program, "view_alpha");
shader->color_uniform = glGetUniformLocation(shader->program,
"unicolor");
shader->color_pre_curve_lut_2d_uniform =
@@ -268,6 +291,16 @@ gl_shader_create(struct gl_renderer *gr,
shader->color_pre_curve_lut_scale_offset_uniform =
glGetUniformLocation(shader->program, "color_pre_curve_lut_scale_offset");
switch(requirements->color_mapping) {
case SHADER_COLOR_MAPPING_3DLUT:
shader->color_mapping.lut3d.tex_uniform =
glGetUniformLocation(shader->program, "color_mapping_lut_3d");
shader->color_mapping.lut3d.scale_offset_uniform =
glGetUniformLocation(shader->program,"color_mapping_lut_scale_offset");
break;
case SHADER_COLOR_MAPPING_IDENTITY:
break;
}
free(conf);
wl_list_insert(&gr->shader_list, &shader->link);
@@ -376,6 +409,7 @@ gl_renderer_create_fallback_shader(struct gl_renderer *gr)
.variant = SHADER_VARIANT_SOLID,
.input_is_premult = true,
.color_pre_curve = SHADER_COLOR_CURVE_IDENTITY,
.color_mapping = SHADER_COLOR_MAPPING_IDENTITY,
};
struct gl_shader *shader;
@@ -481,7 +515,7 @@ gl_shader_load_config(struct gl_shader *shader,
glUniformMatrix4fv(shader->proj_uniform,
1, GL_FALSE, sconf->projection.d);
glUniform4fv(shader->color_uniform, 1, sconf->unicolor);
glUniform1f(shader->alpha_uniform, sconf->view_alpha);
glUniform1f(shader->view_alpha_uniform, sconf->view_alpha);
in_tgt = gl_shader_texture_variant_get_target(sconf->req.variant);
for (i = 0; i < GL_SHADER_INPUT_TEX_MAX; i++) {
@@ -497,9 +531,8 @@ gl_shader_load_config(struct gl_shader *shader,
glTexParameteri(in_tgt, GL_TEXTURE_MAG_FILTER, in_filter);
}
/* Fixed texture unit for color_pre_curve LUT */
/* Fixed texture unit for color_pre_curve LUT if it is available */
i = GL_SHADER_INPUT_TEX_MAX;
glActiveTexture(GL_TEXTURE0 + i);
switch (sconf->req.color_pre_curve) {
case SHADER_COLOR_CURVE_IDENTITY:
assert(sconf->color_pre_curve_lut_tex == 0);
@@ -508,13 +541,32 @@ gl_shader_load_config(struct gl_shader *shader,
assert(sconf->color_pre_curve_lut_tex != 0);
assert(shader->color_pre_curve_lut_2d_uniform != -1);
assert(shader->color_pre_curve_lut_scale_offset_uniform != -1);
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, sconf->color_pre_curve_lut_tex);
glUniform1i(shader->color_pre_curve_lut_2d_uniform, i);
i++;
glUniform2fv(shader->color_pre_curve_lut_scale_offset_uniform,
1, sconf->color_pre_curve_lut_scale_offset);
break;
}
switch (sconf->req.color_mapping) {
case SHADER_COLOR_MAPPING_IDENTITY:
break;
case SHADER_COLOR_MAPPING_3DLUT:
assert(shader->color_mapping.lut3d.tex_uniform != -1);
assert(sconf->color_mapping.lut3d.tex != 0);
assert(shader->color_mapping.lut3d.scale_offset_uniform != -1);
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_3D, sconf->color_mapping.lut3d.tex);
glUniform1i(shader->color_mapping.lut3d.tex_uniform, i);
glUniform2fv(shader->color_mapping.lut3d.scale_offset_uniform,
1, sconf->color_mapping.lut3d.scale_offset);
break;
default:
assert(false);
break;
}
}
bool
@@ -540,7 +592,7 @@ gl_renderer_use_program(struct gl_renderer *gr,
shader = gr->fallback_shader;
glUseProgram(shader->program);
glUniform4fv(shader->color_uniform, 1, fallback_shader_color);
glUniform1f(shader->alpha_uniform, 1.0f);
glUniform1f(shader->view_alpha_uniform, 1.0f);
return false;
}