AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

gl renderer: Rework program creation

Browse Source 
Make sure all uniform names have to match between the shader names and
the _location integers we save in every Program struct.
This commit is contained in:
Timm Bäder 2017-11-30 18:47:55 +01:00
parent 388157b995
commit 5c7838e168
15 changed files with 188 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

264
gsk/gl/gskglrenderer.c
View File

@ -36,12 +36,20 @@
#define OP_PRINT(format, ...)
#endif
#define INIT_PROGRAM_UNIFORM_LOCATION(program_name, location_name, uniform_name) \
#define INIT_PROGRAM_UNIFORM_LOCATION2(program_name, uniform_basename) \
G_STMT_START{\
self->program_name.location_name = glGetUniformLocation(self->program_name.id, uniform_name);\
g_assert (self->program_name.location_name != 0); \
self->program_name ## _program.program_name.uniform_basename ## _location = \
glGetUniformLocation(self->program_name ## _program.id, "u_" #uniform_basename);\
g_assert_cmpint (self->program_name ## _program.program_name.uniform_basename ## _location, >, -1); \
}G_STMT_END
#define INIT_COMMON_UNIFORM_LOCATION(program_ptr, uniform_basename) \
G_STMT_START{\
program_ptr->uniform_basename ## _location = \
glGetUniformLocation(program_ptr->id, "u_" #uniform_basename);\
}G_STMT_END
static void G_GNUC_UNUSED
dump_framebuffer (const char *filename, int w, int h)
{
@ -244,33 +252,27 @@ gsk_gl_renderer_destroy_buffers (GskGLRenderer *self)
self->has_buffers = FALSE;
}
static void
init_common_locations (GskGLRenderer *self,
GskShaderBuilder *builder,
Program *prog)
{
prog->source_location = glGetUniformLocation (prog->id, "uSource");
prog->mask_location = glGetUniformLocation (prog->id, "uMask");
prog->alpha_location = glGetUniformLocation (prog->id, "uAlpha");
prog->blend_mode_location = glGetUniformLocation (prog->id, "uBlendMode");
prog->viewport_location = glGetUniformLocation (prog->id, "uViewport");
prog->projection_location = glGetUniformLocation (prog->id, "uProjection");
prog->modelview_location = glGetUniformLocation (prog->id, "uModelview");
prog->clip_location = glGetUniformLocation (prog->id, "uClip");
prog->clip_corner_widths_location = glGetUniformLocation (prog->id, "uClipCornerWidths");
prog->clip_corner_heights_location = glGetUniformLocation (prog->id, "uClipCornerHeights");
prog->position_location = glGetAttribLocation (prog->id, "aPosition");
prog->uv_location = glGetAttribLocation (prog->id, "aUv");
}
static gboolean
gsk_gl_renderer_create_programs (GskGLRenderer *self,
GError **error)
{
GskShaderBuilder *builder;
GError *shader_error = NULL;
gboolean res = FALSE;
int i;
static struct {
const char *name;
const char *vs;
const char *fs;
} program_definitions[] = {
{ "blend", "blend.vs.glsl", "blend.fs.glsl" },
{ "blit", "blit.vs.glsl", "blit.fs.glsl" },
{ "color", "blit.vs.glsl", "color.fs.glsl" },
{ "coloring", "blit.vs.glsl", "coloring.fs.glsl" },
{ "color matrix", "blit.vs.glsl", "color_matrix.fs.glsl" },
{ "linear gradient", "blit.vs.glsl", "linear_gradient.fs.glsl" },
{ "blur", "blit.vs.glsl", "blur.fs.glsl" },
{ "inset shadow", "blit.vs.glsl", "inset_shadow.fs.glsl" },
};
builder = gsk_shader_builder_new ();
@ -310,140 +312,70 @@ gsk_gl_renderer_create_programs (GskGLRenderer *self,
gsk_shader_builder_add_define (builder, "GSK_DEBUG", "1");
#endif
self->blend_program.id = gsk_shader_builder_create_program (builder,
"blend.vs.glsl", "blend.fs.glsl",
&shader_error);
if (shader_error != NULL)
for (i = 0; i < GL_N_PROGRAMS; i ++)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'blend' program: ");
goto out;
Program *prog = &self->programs[i];
prog->index = i;
prog->id = gsk_shader_builder_create_program (builder,
program_definitions[i].vs,
program_definitions[i].fs,
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error, shader_error,
"Unable to create '%s' program (from %s and %s):\n",
program_definitions[i].name,
program_definitions[i].vs,
program_definitions[i].fs);
g_object_unref (builder);
return FALSE;
}
INIT_COMMON_UNIFORM_LOCATION (prog, alpha);
INIT_COMMON_UNIFORM_LOCATION (prog, source);
INIT_COMMON_UNIFORM_LOCATION (prog, mask);
INIT_COMMON_UNIFORM_LOCATION (prog, clip);
INIT_COMMON_UNIFORM_LOCATION (prog, clip_corner_widths);
INIT_COMMON_UNIFORM_LOCATION (prog, clip_corner_heights);
INIT_COMMON_UNIFORM_LOCATION (prog, viewport);
INIT_COMMON_UNIFORM_LOCATION (prog, projection);
INIT_COMMON_UNIFORM_LOCATION (prog, modelview);
}
self->blend_program.index = 0;
self->blend_program.name = "blend";
init_common_locations (self, builder, &self->blend_program);
self->blit_program.id = gsk_shader_builder_create_program (builder,
"blit.vs.glsl", "blit.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'blit' program: ");
goto out;
}
self->blit_program.index = 1;
self->blit_program.name = "blit";
init_common_locations (self, builder, &self->blit_program);
/* color */
INIT_PROGRAM_UNIFORM_LOCATION2 (color, color);
self->color_program.id = gsk_shader_builder_create_program (builder,
"blit.vs.glsl", "color.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'color' program: ");
goto out;
}
self->color_program.index = 2;
self->color_program.name = "color";
init_common_locations (self, builder, &self->color_program);
INIT_PROGRAM_UNIFORM_LOCATION (color_program, color_location, "uColor");
/* coloring */
INIT_PROGRAM_UNIFORM_LOCATION2 (coloring, color);
self->coloring_program.id = gsk_shader_builder_create_program (builder,
"blit.vs.glsl", "coloring.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'coloring' program: ");
goto out;
}
self->coloring_program.index = 3;
self->coloring_program.name = "coloring";
init_common_locations (self, builder, &self->coloring_program);
INIT_PROGRAM_UNIFORM_LOCATION (coloring_program, color_location, "uColor");
/* color matrix */
INIT_PROGRAM_UNIFORM_LOCATION2 (color_matrix, color_matrix);
INIT_PROGRAM_UNIFORM_LOCATION2 (color_matrix, color_offset);
self->color_matrix_program.id = gsk_shader_builder_create_program (builder,
"blit.vs.glsl", "color_matrix.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'color_matrix' program: ");
goto out;
}
self->color_matrix_program.index = 4;
self->color_matrix_program.name = "color matrix";
init_common_locations (self, builder, &self->color_matrix_program);
INIT_PROGRAM_UNIFORM_LOCATION (color_matrix_program, color_matrix_location, "uColorMatrix");
INIT_PROGRAM_UNIFORM_LOCATION (color_matrix_program, color_offset_location, "uColorOffset");
/* linear gradient */
INIT_PROGRAM_UNIFORM_LOCATION2 (linear_gradient, color_stops);
INIT_PROGRAM_UNIFORM_LOCATION2 (linear_gradient, color_offsets);
INIT_PROGRAM_UNIFORM_LOCATION2 (linear_gradient, num_color_stops);
INIT_PROGRAM_UNIFORM_LOCATION2 (linear_gradient, start_point);
INIT_PROGRAM_UNIFORM_LOCATION2 (linear_gradient, end_point);
self->linear_gradient_program.id = gsk_shader_builder_create_program (builder,
"blit.vs.glsl", "linear_gradient.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'linear_gradient' program: ");
goto out;
}
self->linear_gradient_program.index = 5;
self->linear_gradient_program.name = "linear gradient";
init_common_locations (self, builder, &self->linear_gradient_program);
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient_program, color_stops_location, "uColorStops");
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient_program, color_offsets_location, "uColorOffsets");
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient_program, n_color_stops_location, "uNumColorStops");
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient_program, start_point_location, "uStartPoint");
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient_program, end_point_location, "uEndPoint");
/* blur */
INIT_PROGRAM_UNIFORM_LOCATION2 (blur, blur_radius);
INIT_PROGRAM_UNIFORM_LOCATION2 (blur, blur_size);
self->blur_program.id = gsk_shader_builder_create_program (builder,
"blur.vs.glsl", "blur.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'blur' program: ");
goto out;
}
self->blur_program.index = 6;
self->blur_program.name = "blur";
init_common_locations (self, builder, &self->blur_program);
INIT_PROGRAM_UNIFORM_LOCATION (blur_program, blur_radius_location, "uBlurRadius");
INIT_PROGRAM_UNIFORM_LOCATION (blur_program, blur_size_location, "uSize");
self->inset_shadow_program.id = gsk_shader_builder_create_program (builder,
"blit.vs.glsl", "inset_shadow.fs.glsl",
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error,
shader_error,
"Unable to create 'inset shadow' program: ");
goto out;
}
self->blur_program.index = 7;
self->blur_program.name = "inset shadow";
init_common_locations (self, builder, &self->inset_shadow_program);
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow_program, inset_shadow_color_location, "uColor");
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow_program, inset_shadow_spread_location, "uSpread");
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow_program, inset_shadow_outline_location, "uOutline");
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow_program, inset_shadow_outline_corner_widths_location, "uOutlineCornerWidths");
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow_program, inset_shadow_outline_corner_heights_location, "uOutlineCornerHeights");
res = TRUE;
out:
/* inset shadow */
INIT_PROGRAM_UNIFORM_LOCATION2 (inset_shadow, color);
INIT_PROGRAM_UNIFORM_LOCATION2 (inset_shadow, spread);
INIT_PROGRAM_UNIFORM_LOCATION2 (inset_shadow, offset);
INIT_PROGRAM_UNIFORM_LOCATION2 (inset_shadow, outline);
INIT_PROGRAM_UNIFORM_LOCATION2 (inset_shadow, corner_widths);
INIT_PROGRAM_UNIFORM_LOCATION2 (inset_shadow, corner_heights);
g_object_unref (builder);
return res;
return TRUE;
}
static gboolean
@ -1071,8 +1003,8 @@ gsk_gl_renderer_add_render_ops (GskGLRenderer *self,
op.inset_shadow.corner_heights);
op.inset_shadow.radius = gsk_inset_shadow_node_get_blur_radius (node);
op.inset_shadow.spread = gsk_inset_shadow_node_get_spread (node);
op.inset_shadow.d[0] = gsk_inset_shadow_node_get_dx (node);
op.inset_shadow.d[1] = -gsk_inset_shadow_node_get_dy (node);
op.inset_shadow.offset[0] = gsk_inset_shadow_node_get_dx (node);
op.inset_shadow.offset[1] = -gsk_inset_shadow_node_get_dy (node);
ops_set_program (builder, &self->inset_shadow_program);
ops_add (builder, &op);
@ -1318,16 +1250,16 @@ gsk_gl_renderer_render_ops (GskGLRenderer *self,
OP_PRINT (" -> Color Matrix");
g_assert (program == &self->color_matrix_program);
graphene_matrix_to_float (&op->color_matrix.matrix, mat);
glUniformMatrix4fv (program->color_matrix_location, 1, GL_FALSE, mat);
glUniformMatrix4fv (program->color_matrix.color_matrix_location, 1, GL_FALSE, mat);
graphene_vec4_to_float (&op->color_matrix.offset, vec);
glUniform4fv (program->color_offset_location, 1, vec);
glUniform4fv (program->color_matrix.color_offset_location, 1, vec);
break;
case OP_CHANGE_COLOR:
OP_PRINT (" -> Color: (%f, %f, %f, %f)", op->color.red, op->color.green, op->color.blue, op->color.alpha);
g_assert (program == &self->color_program || program == &self->coloring_program);
glUniform4f (program->color_location,
glUniform4f (program->color.color_location,
op->color.red, op->color.green, op->color.blue, op->color.alpha);
break;
@ -1361,34 +1293,34 @@ gsk_gl_renderer_render_ops (GskGLRenderer *self,
case OP_CHANGE_LINEAR_GRADIENT:
OP_PRINT (" -> Linear gradient");
glUniform1i (program->n_color_stops_location,
glUniform1i (program->linear_gradient.num_color_stops_location,
op->linear_gradient.n_color_stops);
glUniform4fv (program->color_stops_location,
glUniform4fv (program->linear_gradient.color_stops_location,
op->linear_gradient.n_color_stops,
op->linear_gradient.color_stops);
glUniform1fv (program->color_offsets_location,
glUniform1fv (program->linear_gradient.color_offsets_location,
op->linear_gradient.n_color_stops,
op->linear_gradient.color_offsets);
glUniform2f (program->start_point_location,
glUniform2f (program->linear_gradient.start_point_location,
op->linear_gradient.start_point.x, op->linear_gradient.start_point.y);
glUniform2f (program->end_point_location,
glUniform2f (program->linear_gradient.end_point_location,
op->linear_gradient.end_point.x, op->linear_gradient.end_point.y);
break;
case OP_CHANGE_BLUR:
g_assert (program == &self->blur_program);
glUniform1f (program->blur_radius_location, op->blur.radius);
glUniform2f (program->blur_size_location, op->blur.size.width, op->blur.size.height);
glUniform1f (program->blur.blur_radius_location, op->blur.radius);
glUniform2f (program->blur.blur_size_location, op->blur.size.width, op->blur.size.height);
break;
case OP_CHANGE_INSET_SHADOW:
g_assert (program == &self->inset_shadow_program);
glUniform4fv (program->inset_shadow_color_location, 1, op->inset_shadow.color);
glUniform2fv (program->inset_shadow_d_location, 1, op->inset_shadow.d);
glUniform1f (program->inset_shadow_spread_location, op->inset_shadow.spread);
glUniform4fv (program->inset_shadow_outline_location, 1, op->inset_shadow.outline);
glUniform4fv (program->inset_shadow_outline_corner_widths_location, 1, op->inset_shadow.corner_widths);
glUniform4fv (program->inset_shadow_outline_corner_heights_location, 1, op->inset_shadow.corner_heights);
glUniform4fv (program->inset_shadow.color_location, 1, op->inset_shadow.color);
glUniform2fv (program->inset_shadow.offset_location, 1, op->inset_shadow.offset);
glUniform1f (program->inset_shadow.spread_location, op->inset_shadow.spread);
glUniform4fv (program->inset_shadow.outline_location, 1, op->inset_shadow.outline);
glUniform4fv (program->inset_shadow.corner_widths_location, 1, op->inset_shadow.corner_widths);
glUniform4fv (program->inset_shadow.corner_heights_location, 1, op->inset_shadow.corner_heights);
break;
case OP_DRAW:

2
gsk/gl/gskglrenderops.c
View File

@ -216,8 +216,6 @@ ops_set_color (RenderOpBuilder *builder,
{
RenderOp op;
g_assert (builder->current_program->color_location != 0);
if (gdk_rgba_equal (color, &builder->program_state[builder->current_program->index].color))
return;

39
gsk/gl/gskglrenderopsprivate.h
View File

@ -35,14 +35,13 @@ enum {
typedef struct
{
int index; /* Into the renderer's program array */
const char *name; /* For debugging */
int id;
/* Common locations (gl_common)*/
int source_location;
int mask_location;
int uv_location;
int position_location;
int uv_location;
int alpha_location;
int blend_mode_location;
int viewport_location;
@ -52,40 +51,38 @@ typedef struct
int clip_corner_widths_location;
int clip_corner_heights_location;
/* Program-specific locations */
union {
struct {
int color_location;
};
} color;
struct {
int color_location;
} coloring;
struct {
int color_matrix_location;
int color_offset_location;
};
} color_matrix;
struct {
int n_color_stops_location;
int num_color_stops_location;
int color_stops_location;
int color_offsets_location;
int start_point_location;
int end_point_location;
};
struct {
int clip_bounds_location;
int corner_widths_location;
int corner_heights_location;
};
} linear_gradient;
struct {
int blur_radius_location;
int blur_size_location;
};
} blur;
struct {
int inset_shadow_color_location;
int inset_shadow_spread_location;
int inset_shadow_d_location;
int inset_shadow_outline_location;
int inset_shadow_outline_corner_widths_location;
int inset_shadow_outline_corner_heights_location;
};
int color_location;
int spread_location;
int offset_location;
int outline_location;
int corner_widths_location;
int corner_heights_location;
} inset_shadow;
};
} Program;
typedef struct
@ -128,7 +125,7 @@ typedef struct
float corner_heights[4];
float radius;
float spread;
float d[2];
float offset[2];
float color[4];
} inset_shadow;
};

6
gsk/resources/glsl/blend.fs.glsl
View File

@ -28,8 +28,8 @@ vec3 BlendLighten(vec3 Cb, vec3 Cs) {
}
void main() {
vec4 Cs = Texture(uSource, vUv);
vec4 Cb = Texture(uMask, vUv);
vec4 Cs = Texture(u_source, vUv);
vec4 Cb = Texture(u_mask, vUv);
vec3 res;
if (uBlendMode == 0) {
@ -57,5 +57,5 @@ void main() {
// Use red for debugging missing blend modes
res = vec3(1.0, 0.0, 0.0);
}
setOutputColor(vec4(res, Cs.a) * uAlpha);
setOutputColor(vec4(res, Cs.a) * u_alpha);
}

2
gsk/resources/glsl/blend.vs.glsl
View File

@ -1,5 +1,5 @@
void main() {
gl_Position = uModelview * uProjection * vec4(aPosition, 0.0, 1.0);
gl_Position = u_modelview * u_projection * vec4(aPosition, 0.0, 1.0);
vUv = vec2(aUv.x, aUv.y);
}

4
gsk/resources/glsl/blit.fs.glsl
View File

@ -1,5 +1,5 @@
void main() {
vec4 diffuse = Texture(uSource, vUv);
vec4 diffuse = Texture(u_source, vUv);
setOutputColor(diffuse * uAlpha);
setOutputColor(diffuse * u_alpha);
}

2
gsk/resources/glsl/blit.vs.glsl
View File

@ -1,5 +1,5 @@
void main() {
gl_Position = uProjection * uModelview * vec4(aPosition, 0.0, 1.0);
gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
vUv = vec2(aUv.x, aUv.y);
}

14
gsk/resources/glsl/blur.fs.glsl
View File

@ -1,6 +1,6 @@
uniform float uBlurRadius = 4.0;
uniform vec2 uSize;
uniform float u_blur_radius = 4.0;
uniform vec2 u_blur_size;
const int samples_x = 15; // must be odd
const int samples_y = 15; // must be odd
@ -17,19 +17,19 @@ vec4 blur_pixel (in vec2 uv)
{
float total = 0.0;
vec4 ret = vec4 (0);
float pixel_size_x = (1.0 / uSize.x);
float pixel_size_y = (1.0 / uSize.y);
float pixel_size_x = (1.0 / u_blur_size.x);
float pixel_size_y = (1.0 / u_blur_size.y);
for (int y = 0; y < samples_y; ++y)
{
float fy = Gaussian (uBlurRadius, float(y) - float(half_samples_x));
float fy = Gaussian (u_blur_radius, float(y) - float(half_samples_x));
float offset_y = float(y - half_samples_y) * pixel_size_y;
for (int x = 0; x < samples_x; ++x)
{
float fx = Gaussian (uBlurRadius, float(x) - float(half_samples_x));
float fx = Gaussian (u_blur_radius, float(x) - float(half_samples_x));
float offset_x = float(x - half_samples_x) * pixel_size_x;
total += fx * fy;
ret += Texture(uSource, uv + vec2(offset_x, offset_y)) * fx * fy;
ret += Texture(u_source, uv + vec2(offset_x, offset_y)) * fx * fy;
}
}
return ret / total;

6
gsk/resources/glsl/color.fs.glsl
View File

@ -1,9 +1,9 @@
uniform vec4 uColor;
uniform vec4 u_color;
void main() {
vec4 color = uColor;
vec4 color = u_color;
// Pre-multiply alpha
color.rgb *= color.a;
setOutputColor(color * uAlpha);
setOutputColor(color * u_alpha);
}

10
gsk/resources/glsl/color_matrix.fs.glsl
View File

@ -1,8 +1,8 @@
uniform mat4 uColorMatrix;
uniform vec4 uColorOffset;
uniform mat4 u_color_matrix;
uniform vec4 u_color_offset;
void main() {
vec4 diffuse = Texture(uSource, vUv);
vec4 diffuse = Texture(u_source, vUv);
vec4 color;
color = diffuse;
@ -11,10 +11,10 @@ void main() {
if (color.a != 0.0)
color.rgb /= color.a;
color = uColorMatrix * diffuse + uColorOffset;
color = u_color_matrix * diffuse + u_color_offset;
color = clamp(color, 0.0f, 1.0f);
color.rgb *= color.a;
setOutputColor(color * uAlpha);
setOutputColor(color * u_alpha);
}

8
gsk/resources/glsl/coloring.fs.glsl
View File

@ -1,12 +1,12 @@
uniform vec4 uColor;
uniform vec4 u_color;
void main() {
vec4 diffuse = Texture(uSource, vUv);
vec4 color = uColor;
vec4 diffuse = Texture(u_source, vUv);
vec4 color = u_color;
// pre-multiply
color.rgb *= color.a;
setOutputColor((diffuse * color) * uAlpha);
setOutputColor((diffuse * color) * u_alpha);
}

26
gsk/resources/glsl/gl3_common.fs.glsl
View File

@ -1,17 +1,17 @@
precision highp float;
uniform sampler2D uSource;
uniform sampler2D uMask;
uniform mat4 uProjection = mat4(1.0);
uniform mat4 uModelview = mat4(1.0);
uniform float uAlpha = 1.0;
uniform sampler2D u_source;
uniform sampler2D u_mask;
uniform mat4 u_projection = mat4(1.0);
uniform mat4 u_modelview = mat4(1.0);
uniform float u_alpha = 1.0;
uniform int uBlendMode;
uniform vec4 uViewport;
uniform vec4 u_viewport;
// In GtkSnapshot coordinates
uniform vec4 uClip;
uniform vec4 uClipCornerWidths = vec4(1, 1, 1, 1);
uniform vec4 uClipCornerHeights = vec4(1, 1, 1, 1);
uniform vec4 u_clip;
uniform vec4 u_clip_corner_widths = vec4(1, 1, 1, 1);
uniform vec4 u_clip_corner_heights = vec4(1, 1, 1, 1);
in vec2 vUv;
@ -88,16 +88,16 @@ vec4 Texture(sampler2D sampler, vec2 texCoords) {
}
void setOutputColor(vec4 color) {
vec4 clipBounds = uClip;
vec4 clipBounds = u_clip;
vec4 f = gl_FragCoord;
f.x += uViewport.x;
f.y = (uViewport.y + uViewport.w) - f.y;
f.x += u_viewport.x;
f.y = (u_viewport.y + u_viewport.w) - f.y;
clipBounds.z = clipBounds.x + clipBounds.z;
clipBounds.w = clipBounds.y + clipBounds.w;
RoundedRect r = RoundedRect(clipBounds, uClipCornerWidths, uClipCornerHeights);
RoundedRect r = RoundedRect(clipBounds, u_clip_corner_widths, u_clip_corner_heights);
outputColor = color * rounded_rect_coverage(r, f.xy);
/*outputColor = color;*/

4
gsk/resources/glsl/gl3_common.vs.glsl
View File

@ -1,5 +1,5 @@
uniform mat4 uProjection;
uniform mat4 uModelview;
uniform mat4 u_projection;
uniform mat4 u_modelview;
in vec2 aPosition;
in vec2 aUv;

33
gsk/resources/glsl/inset_shadow.fs.glsl
View File

@ -1,28 +1,27 @@
uniform float uSpread;
uniform float uBlurRadius;
uniform vec4 uColor;
uniform vec2 uD;
uniform vec4 uOutline;
uniform vec4 uOutlineCornerWidths;
uniform vec4 uOutlineCornerHeights;
uniform float u_spread;
uniform float u_blur_radius;
uniform vec4 u_color;
uniform vec2 u_offset;
uniform vec4 u_outline;
uniform vec4 u_corner_widths;
uniform vec4 u_corner_heights;
void main() {
vec4 f = gl_FragCoord;
f.x += uViewport.x;
f.y = (uViewport.y + uViewport.w) - f.y;
f.x += u_viewport.x;
f.y = (u_viewport.y + u_viewport.w) - f.y;
RoundedRect outline = RoundedRect(vec4(uOutline.xy, uOutline.xy + uOutline.zw),
uOutlineCornerWidths, uOutlineCornerHeights);
RoundedRect inside = rounded_rect_shrink(outline, vec4(uSpread));
RoundedRect outline = RoundedRect(vec4(u_outline.xy, u_outline.xy + u_outline.zw),
u_corner_widths, u_corner_heights);
RoundedRect inside = rounded_rect_shrink(outline, vec4(u_spread));
vec4 color = vec4(uColor.rgb * uColor.a, uColor.a);
vec4 color = vec4(u_color.rgb * u_color.a, u_color.a);
color = color * clamp (rounded_rect_coverage (outline, f.xy) -
rounded_rect_coverage (inside, f.xy - uD),
rounded_rect_coverage (inside, f.xy + u_offset),
0.0, 1.0);
setOutputColor(color);
/*setOutputColor(vec4(1, 0, 0, 1) * rounded_rect_coverage (outline, f.xy));*/
/*setOutputColor(vec4(0, 0, 1, 1) * rounded_rect_coverage (inside, f.xy));*/
}

30
gsk/resources/glsl/linear_gradient.fs.glsl
View File

@ -1,19 +1,19 @@
uniform vec4 uColorStops[8];
uniform float uColorOffsets[8];
uniform int uNumColorStops;
uniform vec2 uStartPoint;
uniform vec2 uEndPoint;
uniform vec4 u_color_stops[8];
uniform float u_color_offsets[8];
uniform int u_num_color_stops;
uniform vec2 u_start_point;
uniform vec2 u_end_point;
vec4 fragCoord() {
vec4 f = gl_FragCoord;
f.x += uViewport.x;
f.y = (uViewport.y + uViewport.w) - f.y;
f.x += u_viewport.x;
f.y = (u_viewport.y + u_viewport.w) - f.y;
return f;
}
void main() {
vec2 startPoint = (uModelview * vec4(uStartPoint, 0, 1)).xy;
vec2 endPoint = (uModelview * vec4(uEndPoint, 0, 1)).xy;
vec2 startPoint = (u_modelview * vec4(u_start_point, 0, 1)).xy;
vec2 endPoint = (u_modelview * vec4(u_end_point, 0, 1)).xy;
float maxDist = length(endPoint - startPoint);
// Position relative to startPoint
@ -30,16 +30,16 @@ void main() {
// Offset of the current pixel
float offset = length(proj) / maxDist;
vec4 color = uColorStops[0];
for (int i = 1; i < uNumColorStops; i ++) {
if (offset >= uColorOffsets[i - 1]) {
float o = (offset - uColorOffsets[i - 1]) / (uColorOffsets[i] - uColorOffsets[i - 1]);
color = mix(uColorStops[i - 1], uColorStops[i], o);
vec4 color = u_color_stops[0];
for (int i = 1; i < u_num_color_stops; i ++) {
if (offset >= u_color_offsets[i - 1]) {
float o = (offset - u_color_offsets[i - 1]) / (u_color_offsets[i] - u_color_offsets[i - 1]);
color = mix(u_color_stops[i - 1], u_color_stops[i], o);
}
}
/* Pre-multiply */
color.rgb *= color.a;
setOutputColor(color * uAlpha);
setOutputColor(color * u_alpha);
}