From d118fa4511f1abfc0711564b6329d4aba4f03cd8 Mon Sep 17 00:00:00 2001 From: Richard Huang Date: Fri, 7 May 2021 15:13:24 +0100 Subject: [PATCH] Move glyphy shaders into separate files Change-Id: I7bd2afc719c759d57d73e31680b24c35789a16a9 --- .../graphics/shaders/glyphy-common-glsl-shader.def | 211 +++++++++++++++++++ .../graphics/shaders/glyphy-sdf-glsl-shader.def | 160 ++++++++++++++ .../shaders/glyphy-shader-extention-prefix.def | 3 + .../shaders/glyphy-shader-fragment-prefix.frag | 34 +++ .../graphics/shaders/glyphy-shader-main.frag | 66 ++++++ .../graphics/shaders/glyphy-shader-main.vert | 31 +++ .../glyphy-shader/glyphy-common-glsl.h | 229 --------------------- .../vector-based/glyphy-shader/glyphy-sdf-glsl.h | 151 -------------- .../vector-based/glyphy-shader/glyphy-shader.cpp | 167 +-------------- 9 files changed, 512 insertions(+), 540 deletions(-) create mode 100644 dali-toolkit/internal/graphics/shaders/glyphy-common-glsl-shader.def create mode 100644 dali-toolkit/internal/graphics/shaders/glyphy-sdf-glsl-shader.def create mode 100644 dali-toolkit/internal/graphics/shaders/glyphy-shader-extention-prefix.def create mode 100644 dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag create mode 100644 dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag create mode 100644 dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert delete mode 100644 dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-common-glsl.h delete mode 100644 dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-sdf-glsl.h diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-common-glsl-shader.def b/dali-toolkit/internal/graphics/shaders/glyphy-common-glsl-shader.def new file mode 100644 index 0000000..f044a16 --- /dev/null +++ b/dali-toolkit/internal/graphics/shaders/glyphy-common-glsl-shader.def @@ -0,0 +1,211 @@ +/* + * Copyright 2012 Google, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the \"License\"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an \"AS IS\" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Google Author(s): Behdad Esfahbod, Maysum Panju + */ + + +#ifndef GLYPHY_INFINITY +#define GLYPHY_INFINITY 1e9 +#endif +#ifndef GLYPHY_EPSILON +#define GLYPHY_EPSILON 1e-5 +#endif + +#ifndef GLYPHY_RGBA +#ifdef GLYPHY_BGRA +#define GLYPHY_RGBA(v) glyphy_bgra (v) +#else +#define GLYPHY_RGBA(v) glyphy_rgba (v) +#endif +#endif + +vec4 glyphy_rgba (const vec4 v) +{ + return v.rgba; +} + +vec4 glyphy_bgra (const vec4 v) +{ + return v.bgra; +} + +struct glyphy_arc_t +{ + vec2 p0; + vec2 p1; + float d; +}; + +struct glyphy_arc_endpoint_t +{ + /* Second arc endpoint */ + vec2 p; + /* Infinity if this endpoint does not form an arc with the previous + * endpoint. Ie. a \"move_to\". Test with glyphy_isinf(). + * Arc depth otherwise. */ + float d; +}; + +struct glyphy_arc_list_t +{ + /* Number of endpoints in the list. + * Will be zero if we're far away inside or outside, in which case side is set. + * Will be -1 if this arc-list encodes a single line, in which case line_* are set. */ + int num_endpoints; + + /* If num_endpoints is zero, this specifies whether we are inside (-1) + * or outside (+1). Otherwise we're unsure (0). */ + int side; + /* Offset to the arc-endpoints from the beginning of the glyph blob */ + int offset; + + /* A single line is all we care about. It's right here. */ + float line_angle; + float line_distance; /* From nominal glyph center */ +}; + +bool glyphy_isinf (const float v) +{ + return abs (v) >= GLYPHY_INFINITY * .5; +} + +bool glyphy_iszero (const float v) +{ + return abs (v) <= GLYPHY_EPSILON * 2.; +} + +vec2 glyphy_ortho (const vec2 v) +{ + return vec2 (-v.y, v.x); +} + +int glyphy_float_to_byte (const float v) +{ + return int (v * (256. - GLYPHY_EPSILON)); +} + +ivec4 glyphy_vec4_to_bytes (const vec4 v) +{ + return ivec4 (v * (256. - GLYPHY_EPSILON)); +} + +ivec2 glyphy_float_to_two_nimbles (const float v) +{ + int f = glyphy_float_to_byte (v); + return ivec2 (f / 16, int(mod (float(f), 16.))); +} + +/* returns tan (2 * atan (d)) */ +float glyphy_tan2atan (const float d) +{ + return 2. * d / (1. - d * d); +} + +glyphy_arc_endpoint_t glyphy_arc_endpoint_decode(const vec4 v, const ivec2 nominal_size) +{ + vec2 p = (vec2 (glyphy_float_to_two_nimbles (v.a)) + v.gb) / 16.; + float d = v.r; + if (d == 0.) + d = GLYPHY_INFINITY; + else +#define GLYPHY_MAX_D .5 + d = float(glyphy_float_to_byte (d) - 128) * GLYPHY_MAX_D / 127.; +#undef GLYPHY_MAX_D + return glyphy_arc_endpoint_t (p * vec2(nominal_size), d); +} + +vec2 glyphy_arc_center (const glyphy_arc_t a) +{ + return mix (a.p0, a.p1, .5) + + glyphy_ortho (a.p1 - a.p0) / (2. * glyphy_tan2atan (a.d)); +} + +bool glyphy_arc_wedge_contains (const glyphy_arc_t a, const vec2 p) +{ + float d2 = glyphy_tan2atan (a.d); + return dot (p - a.p0, (a.p1 - a.p0) * mat2(1, d2, -d2, 1)) >= 0. && + dot (p - a.p1, (a.p1 - a.p0) * mat2(1, -d2, d2, 1)) <= 0.; +} + +float glyphy_arc_wedge_signed_dist_shallow (const glyphy_arc_t a, const vec2 p) +{ + vec2 v = normalize (a.p1 - a.p0); + float line_d = dot (p - a.p0, glyphy_ortho (v)); + if (a.d == 0.) + return line_d; + + float d0 = dot ((p - a.p0), v); + if (d0 < 0.) + return sign (line_d) * distance (p, a.p0); + float d1 = dot ((a.p1 - p), v); + if (d1 < 0.) + return sign (line_d) * distance (p, a.p1); + float r = 2. * a.d * (d0 * d1) / (d0 + d1); + if (r * line_d > 0.) + return sign (line_d) * min (abs (line_d + r), min (distance (p, a.p0), distance (p, a.p1))); + return line_d + r; +} + +float glyphy_arc_wedge_signed_dist (const glyphy_arc_t a, const vec2 p) +{ + if (abs (a.d) <= .03) + return glyphy_arc_wedge_signed_dist_shallow (a, p); + vec2 c = glyphy_arc_center (a); + return sign (a.d) * (distance (a.p0, c) - distance (p, c)); +} + +float glyphy_arc_extended_dist (const glyphy_arc_t a, const vec2 p) +{ + /* Note: this doesn't handle points inside the wedge. */ + vec2 m = mix (a.p0, a.p1, .5); + float d2 = glyphy_tan2atan (a.d); + if (dot (p - m, a.p1 - m) < 0.) + return dot (p - a.p0, normalize ((a.p1 - a.p0) * mat2(+d2, -1, +1, +d2))); + else + return dot (p - a.p1, normalize ((a.p1 - a.p0) * mat2(-d2, -1, +1, -d2))); +} + +int glyphy_arc_list_offset (const vec2 p, const ivec2 nominal_size) +{ + ivec2 cell = ivec2 (clamp (floor (p), vec2 (0.,0.), vec2(nominal_size - 1))); + return cell.y * nominal_size.x + cell.x; +} + +glyphy_arc_list_t glyphy_arc_list_decode (const vec4 v, const ivec2 nominal_size) +{ + glyphy_arc_list_t l; + ivec4 iv = glyphy_vec4_to_bytes (v); + l.side = 0; /* unsure */ + if (iv.r == 0) + { /* arc-list encoded */ + l.offset = (iv.g * 256) + iv.b; + l.num_endpoints = iv.a; + if (l.num_endpoints == 255) + { + l.num_endpoints = 0; + l.side = -1; + } + else if (l.num_endpoints == 0) + l.side = +1; + } + else + { /* single line encoded */ + l.num_endpoints = -1; + l.line_distance = ( float(iv.r)/32. + 0.01*float(iv.g)/82.0 - 6.) * max (float (nominal_size.x), float (nominal_size.y)); + l.line_angle = ( -float(iv.b)/40.74 - float( iv.a )*0.0001 )-3.142; + } + return l; +} diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-sdf-glsl-shader.def b/dali-toolkit/internal/graphics/shaders/glyphy-sdf-glsl-shader.def new file mode 100644 index 0000000..2b5accd --- /dev/null +++ b/dali-toolkit/internal/graphics/shaders/glyphy-sdf-glsl-shader.def @@ -0,0 +1,160 @@ +/* + * Copyright 2012 Google, Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the \"License\"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an \"AS IS\" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Google Author(s): Behdad Esfahbod, Maysum Panju + */ + +#ifndef GLYPHY_TEXTURE1D_FUNC +#define GLYPHY_TEXTURE1D_FUNC glyphy_texture1D_func +#endif +#ifndef GLYPHY_TEXTURE1D_EXTRA_DECLS +#define GLYPHY_TEXTURE1D_EXTRA_DECLS +#endif +#ifndef GLYPHY_TEXTURE1D_EXTRA_ARGS +#define GLYPHY_TEXTURE1D_EXTRA_ARGS +#endif + +#ifndef GLYPHY_SDF_TEXTURE1D_FUNC +#define GLYPHY_SDF_TEXTURE1D_FUNC GLYPHY_TEXTURE1D_FUNC +#endif +#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS +#define GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS GLYPHY_TEXTURE1D_EXTRA_DECLS +#endif +#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS +#define GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS GLYPHY_TEXTURE1D_EXTRA_ARGS +#endif +#ifndef GLYPHY_SDF_TEXTURE1D +#define GLYPHY_SDF_TEXTURE1D(offset) GLYPHY_RGBA(GLYPHY_SDF_TEXTURE1D_FUNC (offset GLYPHY_TEXTURE1D_EXTRA_ARGS)) +#endif + +#ifndef GLYPHY_MAX_NUM_ENDPOINTS +#define GLYPHY_MAX_NUM_ENDPOINTS 32 +#endif + +glyphy_arc_list_t glyphy_arc_list (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS) +{ + int cell_offset = glyphy_arc_list_offset (p, nominal_size); + vec4 arc_list_data = GLYPHY_SDF_TEXTURE1D (cell_offset); + return glyphy_arc_list_decode (arc_list_data, nominal_size); +} + +float glyphy_sdf (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS) +{ + glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS); + + /* Short-circuits */ + if (arc_list.num_endpoints == 0) + { + /* far-away cell */ + return GLYPHY_INFINITY * float(arc_list.side); + } + if (arc_list.num_endpoints == -1) + { + /* single-line */ + float angle = arc_list.line_angle; + vec2 n = vec2 (cos (angle), sin (angle)); + return dot (p - (vec2(nominal_size) * .5), n) - arc_list.line_distance; + } + + float side = float(arc_list.side); + float min_dist = GLYPHY_INFINITY; + glyphy_arc_t closest_arc; + + glyphy_arc_endpoint_t endpoint_prev, endpoint; + endpoint_prev = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset), nominal_size); + for (int i = 1; i < GLYPHY_MAX_NUM_ENDPOINTS; i++) + { + if (i >= arc_list.num_endpoints) + { + break; + } + endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size); + glyphy_arc_t a = glyphy_arc_t (endpoint_prev.p, endpoint.p, endpoint.d); + endpoint_prev = endpoint; + if (glyphy_isinf (a.d)) continue; + + if (glyphy_arc_wedge_contains (a, p)) + { + float sdist = glyphy_arc_wedge_signed_dist (a, p); + float udist = abs (sdist) * (1. - GLYPHY_EPSILON); + if (udist <= min_dist) + { + min_dist = udist; + side = sign (sdist); + } + } + else + { + float udist = min (distance (p, a.p0), distance (p, a.p1)); + if (udist < min_dist) + { + min_dist = udist; + side = 0.; /* unsure */ + closest_arc = a; + } + else if (side == 0. && udist == min_dist) + { + /* If this new distance is the same as the current minimum, + * compare extended distances. Take the sign from the arc + * with larger extended distance. */ + float old_ext_dist = glyphy_arc_extended_dist (closest_arc, p); + float new_ext_dist = glyphy_arc_extended_dist (a, p); + + float ext_dist = abs (new_ext_dist) <= abs (old_ext_dist) ? + old_ext_dist : new_ext_dist; + +#ifdef GLYPHY_SDF_PSEUDO_DISTANCE + /* For emboldening and stuff: */ + min_dist = abs (ext_dist); +#endif + side = sign (ext_dist); + } + } + } + + if (side == 0.) + { + // Technically speaking this should not happen, but it does. So try to fix it. + float ext_dist = glyphy_arc_extended_dist (closest_arc, p); + side = sign (ext_dist); + } + + return min_dist * side; +} + +float glyphy_point_dist (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS) +{ + glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS); + + float side = float(arc_list.side); + float min_dist = GLYPHY_INFINITY; + + if (arc_list.num_endpoints == 0) + return min_dist; + + glyphy_arc_endpoint_t endpoint; + for (int i = 0; i < GLYPHY_MAX_NUM_ENDPOINTS; i++) + { + if (i >= arc_list.num_endpoints) + { + break; + } + endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size); + if (glyphy_isinf (endpoint.d)) continue; + min_dist = min (min_dist, distance (p, endpoint.p)); + } + + return min_dist; +} diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-extention-prefix.def b/dali-toolkit/internal/graphics/shaders/glyphy-shader-extention-prefix.def new file mode 100644 index 0000000..3f7237d --- /dev/null +++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-extention-prefix.def @@ -0,0 +1,3 @@ +#extension GL_OES_standard_derivatives : enable +precision highp float; +precision highp int; diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag b/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag new file mode 100644 index 0000000..4cb1423 --- /dev/null +++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag @@ -0,0 +1,34 @@ +struct Material +{ + mediump float mOpacity; + mediump float mShininess; + lowp vec4 mAmbient; + lowp vec4 mDiffuse; + lowp vec4 mSpecular; + lowp vec4 mEmissive; +}; + +uniform sampler2D sTexture; +uniform sampler2D sOpacityTexture; +uniform sampler2D sNormalMapTexture; +uniform sampler2D sEffect; +varying mediump vec2 vTexCoord; +uniform Material uMaterial; +uniform lowp vec4 uColor; +varying highp vec4 vVertex; +varying highp vec3 vNormal; +varying mediump vec4 vColor; +uniform vec4 u_atlas_info; + +#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos +#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos +#define GLYPHY_DEMO_EXTRA_ARGS , sTexture, uu_atlas_info, gi.atlas_pos + +vec4 glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS) +{ + ivec2 item_geom = _atlas_info.zw; + vec2 pos = (vec2 (_atlas_pos.xy * item_geom + + ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) + + + vec2 (.5, .5)) / vec2(_atlas_info.xy); + return texture2D (_tex, pos); +} diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag new file mode 100644 index 0000000..4fc43da --- /dev/null +++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag @@ -0,0 +1,66 @@ +uniform float u_contrast; +uniform float u_gamma_adjust; +uniform float u_outline_thickness; +uniform float u_outline; +uniform float u_boldness; + +varying vec4 v_glyph; + +#define SQRT2_2 0.70711 /* 1 / sqrt(2.) */ +#define SQRT2 1.41421 + +struct glyph_info_t +{ + ivec2 nominal_size; + ivec2 atlas_pos; +}; + +glyph_info_t glyph_info_decode (vec4 v) +{ + glyph_info_t gi; + gi.nominal_size = (ivec2 (mod (v.zw, 256.)) + 2) / 4; + gi.atlas_pos = ivec2 (v_glyph.zw) / 256; + return gi; +} + + +float antialias (float d) +{ + return smoothstep (-.75, +.75, d); +} + +vec4 source_over (const vec4 src, const vec4 dst) +{ + // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators_srcover + float alpha = src.a + (dst.a * (1. - src.a)); + return vec4 (((src.rgb * src.a) + (dst.rgb * dst.a * (1. - src.a))) / alpha, alpha); +} + +void main() +{ + vec2 p = v_glyph.xy; + glyph_info_t gi = glyph_info_decode (v_glyph); + + /* isotropic antialiasing */ + vec2 dpdx = dFdx (p); + vec2 dpdy = dFdy (p); + float m = length (vec2 (length (dpdx), length (dpdy))) * SQRT2_2; + + vec4 color = vec4( vColor.rgb * uColor.rgb, vColor.a * uColor.a ); + + ivec4 uu_atlas_info = ivec4( u_atlas_info ); + float gsdist = glyphy_sdf (p, gi.nominal_size GLYPHY_DEMO_EXTRA_ARGS); + float sdist = gsdist / m * u_contrast; + + sdist -= u_boldness * 10.; + if ( glyphy_iszero( u_outline ) ) + sdist = abs (sdist) - u_outline_thickness * .5; + if (sdist > 1.) + discard; + float alpha = antialias (-sdist); + if (u_gamma_adjust != 1.) + alpha = pow (alpha, 1./u_gamma_adjust); + color = vec4 (color.rgb,color.a * alpha); + + gl_FragColor = color; +} diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert new file mode 100644 index 0000000..9b0f342 --- /dev/null +++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert @@ -0,0 +1,31 @@ +uniform mediump mat4 uProjection; +uniform mediump mat4 uModelView; +uniform mediump mat4 uMvpMatrix; +uniform bool uTextureMapped; +uniform mediump vec4 uCustomTextureCoords; +attribute highp vec2 aTexCoord; +varying mediump vec2 vTexCoord; +uniform mat3 uModelViewIT; +attribute mediump vec3 aNormal; +varying mediump vec3 vNormal; +attribute mediump vec2 aPosition; +varying mediump vec4 vVertex; +attribute mediump vec4 aColor; +varying mediump vec4 vColor; +varying vec4 v_glyph; + +vec4 glyph_vertex_transcode (vec2 v) +{ + ivec2 g = ivec2 (v); + ivec2 corner = ivec2 (mod (v, 2.)); + g /= 2; + ivec2 nominal_size = ivec2 (mod (vec2(g), 64.)); + return vec4 (corner * nominal_size, g * 4); +} + +void main() +{ + gl_Position = uMvpMatrix * vec4 (aPosition, 0.0, 1.0); + v_glyph = glyph_vertex_transcode (aTexCoord); + vColor = aColor; +} \ No newline at end of file diff --git a/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-common-glsl.h b/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-common-glsl.h deleted file mode 100644 index 48a8335..0000000 --- a/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-common-glsl.h +++ /dev/null @@ -1,229 +0,0 @@ -static const char* glyphy_common_glsl = - "/*\n" - " * Copyright 2012 Google, Inc. All Rights Reserved.\n" - " *\n" - " * Licensed under the Apache License, Version 2.0 (the \"License\");\n" - " * you may not use this file except in compliance with the License.\n" - " * You may obtain a copy of the License at\n" - " *\n" - " * http://www.apache.org/licenses/LICENSE-2.0\n" - " *\n" - " * Unless required by applicable law or agreed to in writing, software\n" - " * distributed under the License is distributed on an \"AS IS\" BASIS,\n" - " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" - " * See the License for the specific language governing permissions and\n" - " * limitations under the License.\n" - " *\n" - " * Google Author(s): Behdad Esfahbod, Maysum Panju\n" - " */\n" - "\n" - "\n" - "#ifndef GLYPHY_INFINITY\n" - "# define GLYPHY_INFINITY 1e9\n" - "#endif\n" - "#ifndef GLYPHY_EPSILON\n" - "# define GLYPHY_EPSILON 1e-5\n" - "#endif\n" - "\n" - "#ifndef GLYPHY_RGBA\n" - "# ifdef GLYPHY_BGRA\n" - "# define GLYPHY_RGBA(v) glyphy_bgra (v)\n" - "# else\n" - "# define GLYPHY_RGBA(v) glyphy_rgba (v)\n" - "# endif\n" - "#endif\n" - "\n" - "vec4\n" - "glyphy_rgba (const vec4 v)\n" - "{\n" - " return v.rgba;\n" - "}\n" - "\n" - "vec4\n" - "glyphy_bgra (const vec4 v)\n" - "{\n" - " return v.bgra;\n" - "}\n" - "\n" - "\n" - "struct glyphy_arc_t {\n" - " vec2 p0;\n" - " vec2 p1;\n" - " float d;\n" - "};\n" - "\n" - "struct glyphy_arc_endpoint_t {\n" - " /* Second arc endpoint */\n" - " vec2 p;\n" - " /* Infinity if this endpoint does not form an arc with the previous\n" - " * endpoint. Ie. a \"move_to\". Test with glyphy_isinf().\n" - " * Arc depth otherwise. */\n" - " float d;\n" - "};\n" - "\n" - "struct glyphy_arc_list_t {\n" - " /* Number of endpoints in the list.\n" - " * Will be zero if we're far away inside or outside, in which case side is set.\n" - " * Will be -1 if this arc-list encodes a single line, in which case line_* are set. */\n" - " int num_endpoints;\n" - "\n" - " /* If num_endpoints is zero, this specifies whether we are inside (-1)\n" - " * or outside (+1). Otherwise we're unsure (0). */\n" - " int side;\n" - " /* Offset to the arc-endpoints from the beginning of the glyph blob */\n" - " int offset;\n" - "\n" - " /* A single line is all we care about. It's right here. */\n" - " float line_angle;\n" - " float line_distance; /* From nominal glyph center */\n" - "};\n" - "\n" - "bool\n" - "glyphy_isinf (const float v)\n" - "{\n" - " return abs (v) >= GLYPHY_INFINITY * .5;\n" - "}\n" - "\n" - "bool\n" - "glyphy_iszero (const float v)\n" - "{\n" - " return abs (v) <= GLYPHY_EPSILON * 2.;\n" - "}\n" - "\n" - "vec2\n" - "glyphy_ortho (const vec2 v)\n" - "{\n" - " return vec2 (-v.y, v.x);\n" - "}\n" - "\n" - "int\n" - "glyphy_float_to_byte (const float v)\n" - "{\n" - " return int (v * (256. - GLYPHY_EPSILON));\n" - "}\n" - "\n" - "ivec4\n" - "glyphy_vec4_to_bytes (const vec4 v)\n" - "{\n" - " return ivec4 (v * (256. - GLYPHY_EPSILON));\n" - "}\n" - "\n" - "ivec2\n" - "glyphy_float_to_two_nimbles (const float v)\n" - "{\n" - " int f = glyphy_float_to_byte (v);\n" - " return ivec2 (f / 16, int(mod (float(f), 16.)));\n" - "}\n" - "\n" - "/* returns tan (2 * atan (d)) */\n" - "float\n" - "glyphy_tan2atan (const float d)\n" - "{\n" - " return 2. * d / (1. - d * d);\n" - "}\n" - "\n" - "glyphy_arc_endpoint_t\n" - "glyphy_arc_endpoint_decode (const vec4 v, const ivec2 nominal_size)\n" - "{\n" - " vec2 p = (vec2 (glyphy_float_to_two_nimbles (v.a)) + v.gb) / 16.;\n" - " float d = v.r;\n" - " if (d == 0.)\n" - " d = GLYPHY_INFINITY;\n" - " else\n" - "#define GLYPHY_MAX_D .5\n" - " d = float(glyphy_float_to_byte (d) - 128) * GLYPHY_MAX_D / 127.;\n" - "#undef GLYPHY_MAX_D\n" - " return glyphy_arc_endpoint_t (p * vec2(nominal_size), d);\n" - "}\n" - "\n" - "vec2\n" - "glyphy_arc_center (const glyphy_arc_t a)\n" - "{\n" - " return mix (a.p0, a.p1, .5) +\n" - " glyphy_ortho (a.p1 - a.p0) / (2. * glyphy_tan2atan (a.d));\n" - "}\n" - "\n" - "bool\n" - "glyphy_arc_wedge_contains (const glyphy_arc_t a, const vec2 p)\n" - "{\n" - " float d2 = glyphy_tan2atan (a.d);\n" - " return dot (p - a.p0, (a.p1 - a.p0) * mat2(1, d2, -d2, 1)) >= 0. &&\n" - " dot (p - a.p1, (a.p1 - a.p0) * mat2(1, -d2, d2, 1)) <= 0.;\n" - "}\n" - "\n" - "float\n" - "glyphy_arc_wedge_signed_dist_shallow (const glyphy_arc_t a, const vec2 p)\n" - "{\n" - " vec2 v = normalize (a.p1 - a.p0);\n" - " float line_d = dot (p - a.p0, glyphy_ortho (v));\n" - " if (a.d == 0.)\n" - " return line_d;\n" - "\n" - " float d0 = dot ((p - a.p0), v);\n" - " if (d0 < 0.)\n" - " return sign (line_d) * distance (p, a.p0);\n" - " float d1 = dot ((a.p1 - p), v);\n" - " if (d1 < 0.)\n" - " return sign (line_d) * distance (p, a.p1);\n" - " float r = 2. * a.d * (d0 * d1) / (d0 + d1);\n" - " if (r * line_d > 0.)\n" - " return sign (line_d) * min (abs (line_d + r), min (distance (p, a.p0), distance (p, a.p1)));\n" - " return line_d + r;\n" - "}\n" - "\n" - "float\n" - "glyphy_arc_wedge_signed_dist (const glyphy_arc_t a, const vec2 p)\n" - "{\n" - " if (abs (a.d) <= .03)\n" - " return glyphy_arc_wedge_signed_dist_shallow (a, p);\n" - " vec2 c = glyphy_arc_center (a);\n" - " return sign (a.d) * (distance (a.p0, c) - distance (p, c));\n" - "}\n" - "\n" - "float\n" - "glyphy_arc_extended_dist (const glyphy_arc_t a, const vec2 p)\n" - "{\n" - " /* Note: this doesn't handle points inside the wedge. */\n" - " vec2 m = mix (a.p0, a.p1, .5);\n" - " float d2 = glyphy_tan2atan (a.d);\n" - " if (dot (p - m, a.p1 - m) < 0.)\n" - " return dot (p - a.p0, normalize ((a.p1 - a.p0) * mat2(+d2, -1, +1, +d2)));\n" - " else\n" - " return dot (p - a.p1, normalize ((a.p1 - a.p0) * mat2(-d2, -1, +1, -d2)));\n" - "}\n" - "\n" - "int\n" - "glyphy_arc_list_offset (const vec2 p, const ivec2 nominal_size)\n" - "{\n" - " ivec2 cell = ivec2 (clamp (floor (p), vec2 (0.,0.), vec2(nominal_size - 1)));\n" - " return cell.y * nominal_size.x + cell.x;\n" - "}\n" - "\n" - "glyphy_arc_list_t\n" - "glyphy_arc_list_decode (const vec4 v, const ivec2 nominal_size)\n" - "{\n" - " glyphy_arc_list_t l;\n" - " ivec4 iv = glyphy_vec4_to_bytes (v);\n" - " l.side = 0; /* unsure */\n" - " if (iv.r == 0) { /* arc-list encoded */\n" - " l.offset = (iv.g * 256) + iv.b;\n" - " l.num_endpoints = iv.a;\n" - " if (l.num_endpoints == 255) {\n" - " l.num_endpoints = 0;\n" - " l.side = -1;\n" - " } else if (l.num_endpoints == 0)\n" - " l.side = +1;\n" - " } else { /* single line encoded */\n" - " l.num_endpoints = -1;\n" - /*" l.line_distance = float(((iv.r - 128) * 256 + iv.g) - 0x4000) / float (0x1FFF)\n" - " * max (float (nominal_size.x), float (nominal_size.y));\n" - " l.line_angle = float(-((iv.b * 256 + iv.a) - 0x8000)) / float (0x7FFF) * 3.14159265358979;\n"*/ - /*" l.line_distance = float(((iv.r - 128) * 256 + iv.g) - 16384) / 8191.0 \n" - " * max (float (nominal_size.x), float (nominal_size.y));\n" - " l.line_angle = float(-((iv.b * 256 + iv.a) - 32768)) / 32767. * 3.14159;\n"*/ - " l.line_distance = ( float(iv.r)/32. + 0.01*float(iv.g)/82.0 - 6.) \n" - " * max (float (nominal_size.x), float (nominal_size.y));\n" - " l.line_angle = ( -float(iv.b)/40.74 - float( iv.a )*0.0001 )-3.142;\n" - " }\n" - " return l;\n" - "}\n"; diff --git a/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-sdf-glsl.h b/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-sdf-glsl.h deleted file mode 100644 index 37b1b13..0000000 --- a/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-sdf-glsl.h +++ /dev/null @@ -1,151 +0,0 @@ -static const char* glyphy_sdf_glsl = - "/*\n" - " * Copyright 2012 Google, Inc. All Rights Reserved.\n" - " *\n" - " * Licensed under the Apache License, Version 2.0 (the \"License\");\n" - " * you may not use this file except in compliance with the License.\n" - " * You may obtain a copy of the License at\n" - " *\n" - " * http://www.apache.org/licenses/LICENSE-2.0\n" - " *\n" - " * Unless required by applicable law or agreed to in writing, software\n" - " * distributed under the License is distributed on an \"AS IS\" BASIS,\n" - " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" - " * See the License for the specific language governing permissions and\n" - " * limitations under the License.\n" - " *\n" - " * Google Author(s): Behdad Esfahbod, Maysum Panju\n" - " */\n" - "\n" - "#ifndef GLYPHY_TEXTURE1D_FUNC\n" - "#define GLYPHY_TEXTURE1D_FUNC glyphy_texture1D_func\n" - "#endif\n" - "#ifndef GLYPHY_TEXTURE1D_EXTRA_DECLS\n" - "#define GLYPHY_TEXTURE1D_EXTRA_DECLS\n" - "#endif\n" - "#ifndef GLYPHY_TEXTURE1D_EXTRA_ARGS\n" - "#define GLYPHY_TEXTURE1D_EXTRA_ARGS\n" - "#endif\n" - "\n" - "#ifndef GLYPHY_SDF_TEXTURE1D_FUNC\n" - "#define GLYPHY_SDF_TEXTURE1D_FUNC GLYPHY_TEXTURE1D_FUNC\n" - "#endif\n" - "#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS\n" - "#define GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS GLYPHY_TEXTURE1D_EXTRA_DECLS\n" - "#endif\n" - "#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS\n" - "#define GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS GLYPHY_TEXTURE1D_EXTRA_ARGS\n" - "#endif\n" - "#ifndef GLYPHY_SDF_TEXTURE1D\n" - "#define GLYPHY_SDF_TEXTURE1D(offset) GLYPHY_RGBA(GLYPHY_SDF_TEXTURE1D_FUNC (offset GLYPHY_TEXTURE1D_EXTRA_ARGS))\n" - "#endif\n" - "\n" - "#ifndef GLYPHY_MAX_NUM_ENDPOINTS\n" - "#define GLYPHY_MAX_NUM_ENDPOINTS 32\n" - "#endif\n" - "\n" - "glyphy_arc_list_t\n" - "glyphy_arc_list (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)\n" - "{\n" - " int cell_offset = glyphy_arc_list_offset (p, nominal_size);\n" - " vec4 arc_list_data = GLYPHY_SDF_TEXTURE1D (cell_offset);\n" - " return glyphy_arc_list_decode (arc_list_data, nominal_size);\n" - "}\n" - "\n" - "float\n" - "glyphy_sdf (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)\n" - "{\n" - " glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS);\n" - "\n" - " /* Short-circuits */\n" - " if (arc_list.num_endpoints == 0) {\n" - " /* far-away cell */\n" - " return GLYPHY_INFINITY * float(arc_list.side);\n" - " } if (arc_list.num_endpoints == -1) {\n" - " /* single-line */\n" - " float angle = arc_list.line_angle;\n" - " vec2 n = vec2 (cos (angle), sin (angle));\n" - " return dot (p - (vec2(nominal_size) * .5), n) - arc_list.line_distance;\n" - " }\n" - "\n" - " float side = float(arc_list.side);\n" - " float min_dist = GLYPHY_INFINITY;\n" - " glyphy_arc_t closest_arc;\n" - "\n" - " glyphy_arc_endpoint_t endpoint_prev, endpoint;\n" - " endpoint_prev = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset), nominal_size);\n" - " for (int i = 1; i < GLYPHY_MAX_NUM_ENDPOINTS; i++)\n" - " {\n" - " if (i >= arc_list.num_endpoints) {\n" - " break;\n" - " }\n" - " endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size);\n" - " glyphy_arc_t a = glyphy_arc_t (endpoint_prev.p, endpoint.p, endpoint.d);\n" - " endpoint_prev = endpoint;\n" - " if (glyphy_isinf (a.d)) continue;\n" - "\n" - " if (glyphy_arc_wedge_contains (a, p))\n" - " {\n" - " float sdist = glyphy_arc_wedge_signed_dist (a, p);\n" - " float udist = abs (sdist) * (1. - GLYPHY_EPSILON);\n" - " if (udist <= min_dist) {\n" - " min_dist = udist;\n" - " side = sign (sdist);" - " }\n" - " } else {\n" - " float udist = min (distance (p, a.p0), distance (p, a.p1));\n" - " if (udist < min_dist) {\n" - " min_dist = udist;\n" - " side = 0.; /* unsure */\n" - " closest_arc = a;\n" - " } else if (side == 0. && udist == min_dist) {\n" - " /* If this new distance is the same as the current minimum,\n" - " * compare extended distances. Take the sign from the arc\n" - " * with larger extended distance. */\n" - " float old_ext_dist = glyphy_arc_extended_dist (closest_arc, p);\n" - " float new_ext_dist = glyphy_arc_extended_dist (a, p);\n" - "\n" - " float ext_dist = abs (new_ext_dist) <= abs (old_ext_dist) ?\n" - " old_ext_dist : new_ext_dist;\n" - "\n" - "#ifdef GLYPHY_SDF_PSEUDO_DISTANCE\n" - " /* For emboldening and stuff: */\n" - " min_dist = abs (ext_dist);\n" - "#endif\n" - " side = sign (ext_dist);\n" - " }\n" - " }\n" - " }\n" - "\n" - " if (side == 0.) {\n" - " // Technically speaking this should not happen, but it does. So try to fix it.\n" - " float ext_dist = glyphy_arc_extended_dist (closest_arc, p);\n" - " side = sign (ext_dist);\n" - " }\n" - "\n" - " return min_dist * side;\n" - "}\n" - "\n" - "float\n" - "glyphy_point_dist (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)\n" - "{\n" - " glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS);\n" - "\n" - " float side = float(arc_list.side);\n" - " float min_dist = GLYPHY_INFINITY;\n" - "\n" - " if (arc_list.num_endpoints == 0)\n" - " return min_dist;\n" - "\n" - " glyphy_arc_endpoint_t endpoint;\n" - " for (int i = 0; i < GLYPHY_MAX_NUM_ENDPOINTS; i++)\n" - " {\n" - " if (i >= arc_list.num_endpoints) {\n" - " break;\n" - " }\n" - " endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size);\n" - " if (glyphy_isinf (endpoint.d)) continue;\n" - " min_dist = min (min_dist, distance (p, endpoint.p));\n" - " }\n" - " return min_dist;\n" - "}\n"; diff --git a/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-shader.cpp b/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-shader.cpp index 4be2524..6ff571a 100644 --- a/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-shader.cpp +++ b/dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-shader.cpp @@ -22,163 +22,10 @@ #include // INTERNAL INCLUDES -#include -#include +#include using namespace Dali; -namespace -{ -const char* const ENABLE_EXTENSION_PREFIX = - "#extension GL_OES_standard_derivatives : enable\n" - "precision highp float;\n" - "precision highp int;\n"; - -const char* const VERTEX_SHADER_MAIN = - "uniform mediump mat4 uProjection;\n" - "uniform mediump mat4 uModelView;\n" - "uniform mediump mat4 uMvpMatrix;\n" - "uniform bool uTextureMapped;\n" - "uniform mediump vec4 uCustomTextureCoords;\n" - "attribute highp vec2 aTexCoord;\n" - "varying mediump vec2 vTexCoord;\n" - "uniform mat3 uModelViewIT;\n" - "attribute mediump vec3 aNormal;\n" - "varying mediump vec3 vNormal;\n" - "attribute mediump vec2 aPosition;\n" - "varying mediump vec4 vVertex;\n" - "attribute mediump vec4 aColor;\n" - "varying mediump vec4 vColor;\n" - "varying vec4 v_glyph;\n" - "\n" - "vec4\n" - "glyph_vertex_transcode (vec2 v)\n" - "{\n" - " ivec2 g = ivec2 (v);\n" - " ivec2 corner = ivec2 (mod (v, 2.));\n" - " g /= 2;\n" - " ivec2 nominal_size = ivec2 (mod (vec2(g), 64.));\n" - " return vec4 (corner * nominal_size, g * 4);\n" - "}\n" - "\n" - "void\n" - "main()\n" - "{\n" - " gl_Position = uMvpMatrix * vec4 (aPosition, 0.0, 1.0);\n" - " v_glyph = glyph_vertex_transcode (aTexCoord);\n" - " vColor = aColor;\n" - "}\n"; - -const char* const FRAGMENT_SHADER_PREFIX = - "struct Material\n" - "{\n" - " mediump float mOpacity;\n" - " mediump float mShininess;\n" - " lowp vec4 mAmbient;\n" - " lowp vec4 mDiffuse;\n" - " lowp vec4 mSpecular;\n" - " lowp vec4 mEmissive;\n" - "};\n" - "uniform sampler2D sTexture;\n" - "uniform sampler2D sOpacityTexture;\n" - "uniform sampler2D sNormalMapTexture;\n" - "uniform sampler2D sEffect;\n" - "varying mediump vec2 vTexCoord;\n" - "uniform Material uMaterial;\n" - "uniform lowp vec4 uColor;\n" - "varying highp vec4 vVertex;\n" - "varying highp vec3 vNormal;\n" - "varying mediump vec4 vColor;\n" - "uniform vec4 u_atlas_info;\n" - "\n" - "#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos\n" - "#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos\n" - "#define GLYPHY_DEMO_EXTRA_ARGS , sTexture, uu_atlas_info, gi.atlas_pos\n" - "\n" - "vec4\n" - "glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS)\n" - "{\n" - " ivec2 item_geom = _atlas_info.zw;\n" - " vec2 pos = (vec2 (_atlas_pos.xy * item_geom +\n" - " ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +\n" - " + vec2 (.5, .5)) / vec2(_atlas_info.xy);\n" - " return texture2D (_tex, pos);\n" - "}\n"; - -static const char* FRAGMENT_SHADER_MAIN = - "uniform float u_contrast;\n" - "uniform float u_gamma_adjust;\n" - "uniform float u_outline_thickness;\n" - "uniform float u_outline;\n" - "uniform float u_boldness;\n" - "\n" - "varying vec4 v_glyph;\n" - "\n" - "\n" - "#define SQRT2_2 0.70711 /* 1 / sqrt(2.) */\n" - "#define SQRT2 1.41421\n" - "\n" - "struct glyph_info_t {\n" - " ivec2 nominal_size;\n" - " ivec2 atlas_pos;\n" - "};\n" - "\n" - "glyph_info_t\n" - "glyph_info_decode (vec4 v)\n" - "{\n" - " glyph_info_t gi;\n" - " gi.nominal_size = (ivec2 (mod (v.zw, 256.)) + 2) / 4;\n" - " gi.atlas_pos = ivec2 (v_glyph.zw) / 256;\n" - " return gi;\n" - "}\n" - "\n" - "\n" - "float\n" - "antialias (float d)\n" - "{\n" - " return smoothstep (-.75, +.75, d);\n" - "}\n" - "\n" - "vec4\n" - "source_over (const vec4 src, const vec4 dst)\n" - "{\n" - " // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators_srcover\n" - " float alpha = src.a + (dst.a * (1. - src.a));\n" - " return vec4 (((src.rgb * src.a) + (dst.rgb * dst.a * (1. - src.a))) / alpha, alpha);\n" - "}\n" - "\n" - "void\n" - "main()\n" - "{\n" - " vec2 p = v_glyph.xy;\n" - " glyph_info_t gi = glyph_info_decode (v_glyph);\n" - "\n" - " /* isotropic antialiasing */\n" - " vec2 dpdx = dFdx (p);\n" - " vec2 dpdy = dFdy (p);\n" - " float m = length (vec2 (length (dpdx), length (dpdy))) * SQRT2_2;\n" - "\n" - " vec4 color = vec4( vColor.rgb * uColor.rgb, vColor.a * uColor.a );\n" - "\n" - " ivec4 uu_atlas_info = ivec4( u_atlas_info );" - " float gsdist = glyphy_sdf (p, gi.nominal_size GLYPHY_DEMO_EXTRA_ARGS);\n" - " float sdist = gsdist / m * u_contrast;\n" - "\n" - " sdist -= u_boldness * 10.;\n" - " if ( glyphy_iszero( u_outline ) )\n" - " sdist = abs (sdist) - u_outline_thickness * .5;\n" - " if (sdist > 1.)\n" - " discard;\n" - " float alpha = antialias (-sdist);\n" - " if (u_gamma_adjust != 1.)\n" - " alpha = pow (alpha, 1./u_gamma_adjust);\n" - " color = vec4 (color.rgb,color.a * alpha);\n" - "\n" - " gl_FragColor = color;\n" - "}\n"; - -} // namespace - namespace Dali { namespace Toolkit @@ -203,14 +50,14 @@ GlyphyShader GlyphyShader::New(const Dali::Vector4& atlasInfo) std::ostringstream vertexShaderStringStream; std::ostringstream fragmentShaderStringStream; - vertexShaderStringStream << ENABLE_EXTENSION_PREFIX << VERTEX_SHADER_MAIN; + vertexShaderStringStream << SHADER_GLYPHY_SHADER_EXTENTION_PREFIX_DEF.data() << SHADER_GLYPHY_SHADER_MAIN_VERT.data(); - fragmentShaderStringStream << ENABLE_EXTENSION_PREFIX - << FRAGMENT_SHADER_PREFIX - << glyphy_common_glsl + fragmentShaderStringStream << SHADER_GLYPHY_SHADER_EXTENTION_PREFIX_DEF.data() + << SHADER_GLYPHY_SHADER_FRAGMENT_PREFIX_FRAG.data() + << SHADER_GLYPHY_COMMON_GLSL_SHADER_DEF.data() << "#define GLYPHY_SDF_PSEUDO_DISTANCE 1\n" - << glyphy_sdf_glsl - << FRAGMENT_SHADER_MAIN; + << SHADER_GLYPHY_SDF_GLSL_SHADER_DEF.data() + << SHADER_GLYPHY_SHADER_MAIN_FRAG.data(); Shader shaderEffectCustom = Shader::New(vertexShaderStringStream.str(), fragmentShaderStringStream.str(), -- 2.7.4