#pragma once #include #include #include #include namespace mbgl { namespace shaders { template <> struct ShaderSource { static constexpr auto name = "LineShader"; static constexpr auto vertexMainFunction = "vertexMain"; static constexpr auto fragmentMainFunction = "fragmentMain"; static const std::array attributes; static const std::array uniforms; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(0)]]; uchar4 data [[attribute(1)]]; #if !defined(HAS_UNIFORM_u_color) float4 color [[attribute(2)]]; #endif #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(3)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(4)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(5)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(6)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(7)]]; #endif }; struct FragmentStage { float4 position [[position, invariant]]; float2 width2; float2 normal; half gamma_scale; #if !defined(HAS_UNIFORM_u_color) float4 color; #endif #if !defined(HAS_UNIFORM_u_blur) float blur; #endif #if !defined(HAS_UNIFORM_u_opacity) float opacity; #endif }; FragmentStage vertex vertexMain(thread const VertexStage vertx [[stage_in]], device const LineDynamicUBO& dynamic [[buffer(8)]], device const LineUBO& line [[buffer(9)]], device const LinePropertiesUBO& props [[buffer(10)]], device const LineInterpolationUBO& interp [[buffer(11)]]) { #if defined(HAS_UNIFORM_u_gapwidth) const auto gapwidth = props.gapwidth / 2; #else const auto gapwidth = unpack_mix_float(vertx.gapwidth, interp.gapwidth_t) / 2; #endif #if defined(HAS_UNIFORM_u_offset) const auto offset = props.offset * -1; #else const auto offset = unpack_mix_float(vertx.offset, interp.offset_t) * -1; #endif #if defined(HAS_UNIFORM_u_width) const auto width = props.width; #else const auto width = unpack_mix_float(vertx.width, interp.width_t); #endif // the distance over which the line edge fades out. // Retina devices need a smaller distance to avoid aliasing. const float ANTIALIASING = 1.0 / DEVICE_PIXEL_RATIO / 2.0; const float2 a_extrude = float2(vertx.data.xy) - 128.0; const float a_direction = fmod(float(vertx.data.z), 4.0) - 1.0; const float2 pos = floor(float2(vertx.pos_normal) * 0.5); // x is 1 if it's a round cap, 0 otherwise // y is 1 if the normal points up, and -1 if it points down // We store these in the least significant bit of a_pos_normal const float2 normal = float2(vertx.pos_normal) - 2.0 * pos; const float2 v_normal = float2(normal.x, normal.y * 2.0 - 1.0); const float halfwidth = width / 2.0; const float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0); const float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING); // Scale the extrusion vector down to a normal and then up by the line width of this vertex. const float2 dist = outset * a_extrude * LINE_NORMAL_SCALE; // Calculate the offset when drawing a line that is to the side of the actual line. // We do this by creating a vector that points towards the extrude, but rotate // it when we're drawing round end points (a_direction = -1 or 1) since their // extrude vector points in another direction. const float u = 0.5 * a_direction; const float t = 1.0 - abs(u); const float2 offset2 = offset * a_extrude * LINE_NORMAL_SCALE * v_normal.y * float2x2(t, -u, u, t); const float4 projected_extrude = line.matrix * float4(dist / line.ratio, 0.0, 0.0); const float4 position = line.matrix * float4(pos + offset2 / line.ratio, 0.0, 1.0) + projected_extrude; // calculate how much the perspective view squishes or stretches the extrude const float extrude_length_without_perspective = length(dist); const float extrude_length_with_perspective = length(projected_extrude.xy / position.w * dynamic.units_to_pixels); return { .position = position, .width2 = float2(outset, inset), .normal = v_normal, .gamma_scale = half(extrude_length_without_perspective / extrude_length_with_perspective), #if !defined(HAS_UNIFORM_u_color) .color = unpack_mix_color(vertx.color, interp.color_t), #endif #if !defined(HAS_UNIFORM_u_blur) .blur = unpack_mix_float(vertx.blur, interp.blur_t), #endif #if !defined(HAS_UNIFORM_u_opacity) .opacity = unpack_mix_float(vertx.opacity, interp.opacity_t), #endif }; } half4 fragment fragmentMain(FragmentStage in [[stage_in]], device const LineUBO& line [[buffer(9)]], device const LinePropertiesUBO& props [[buffer(10)]]) { #if defined(OVERDRAW_INSPECTOR) return half4(1.0); #endif #if defined(HAS_UNIFORM_u_color) const float4 color = props.color; #else const float4 color = in.color; #endif #if defined(HAS_UNIFORM_u_blur) const float blur = props.blur; #else const float blur = in.blur; #endif #if defined(HAS_UNIFORM_u_opacity) const float opacity = props.opacity; #else const float opacity = in.opacity; #endif // Calculate the distance of the pixel from the line in pixels. const float dist = length(in.normal) * in.width2.x; // Calculate the antialiasing fade factor. This is either when fading in the // line in case of an offset line (v_width2.y) or when fading out (v_width2.x) const float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * in.gamma_scale; const float alpha = clamp(min(dist - (in.width2.y - blur2), in.width2.x - dist) / blur2, 0.0, 1.0); return half4(color * (alpha * opacity)); } )"; }; template <> struct ShaderSource { static constexpr auto name = "LinePatternShader"; static constexpr auto vertexMainFunction = "vertexMain"; static constexpr auto fragmentMainFunction = "fragmentMain"; static const std::array attributes; static const std::array uniforms; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(0)]]; uchar4 data [[attribute(1)]]; #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(2)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(3)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(4)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(5)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(6)]]; #endif #if !defined(HAS_UNIFORM_u_pattern_from) ushort4 pattern_from [[attribute(7)]]; #endif #if !defined(HAS_UNIFORM_u_pattern_to) ushort4 pattern_to [[attribute(8)]]; #endif }; struct FragmentStage { float4 position [[position, invariant]]; float2 width2; float linesofar; half2 normal; half gamma_scale; #if !defined(HAS_UNIFORM_u_blur) half blur; #endif #if !defined(HAS_UNIFORM_u_opacity) half opacity; #endif #if !defined(HAS_UNIFORM_u_pattern_from) half4 pattern_from; #endif #if !defined(HAS_UNIFORM_u_pattern_to) half4 pattern_to; #endif }; struct alignas(16) LinePatternUBO { float4x4 matrix; float4 scale; float2 texsize; float ratio; float fade; }; struct alignas(16) LinePatternPropertiesUBO { float blur; float opacity; float offset; float gapwidth; float width; float pad1, pad2, pad3; }; struct alignas(16) LinePatternInterpolationUBO { float blur_t; float opacity_t; float offset_t; float gapwidth_t; float width_t; float pattern_from_t; float pattern_to_t; float pad1; }; struct alignas(16) LinePatternTilePropertiesUBO { float4 pattern_from; float4 pattern_to; }; FragmentStage vertex vertexMain(thread const VertexStage vertx [[stage_in]], device const LineDynamicUBO& dynamic [[buffer(9)]], device const LinePatternUBO& line [[buffer(10)]], device const LinePatternPropertiesUBO& props [[buffer(11)]], device const LinePatternInterpolationUBO& interp [[buffer(12)]], device const LinePatternTilePropertiesUBO& tileProps [[buffer(13)]]) { #if defined(HAS_UNIFORM_u_gapwidth) const auto gapwidth = props.gapwidth / 2; #else const auto gapwidth = unpack_mix_float(vertx.gapwidth, interp.gapwidth_t) / 2; #endif #if defined(HAS_UNIFORM_u_offset) const auto offset = props.offset * -1; #else const auto offset = unpack_mix_float(vertx.offset, interp.offset_t) * -1; #endif #if defined(HAS_UNIFORM_u_width) const auto width = props.width; #else const auto width = unpack_mix_float(vertx.width, interp.width_t); #endif // the distance over which the line edge fades out. // Retina devices need a smaller distance to avoid aliasing. const float ANTIALIASING = 1.0 / DEVICE_PIXEL_RATIO / 2.0; const float LINE_DISTANCE_SCALE = 2.0; const float2 a_extrude = float2(vertx.data.xy) - 128.0; const float a_direction = fmod(float(vertx.data.z), 4.0) - 1.0; const float linesofar = (floor(vertx.data.z / 4.0) + vertx.data.w * 64.0) * LINE_DISTANCE_SCALE; const float2 pos = floor(float2(vertx.pos_normal) * 0.5); // x is 1 if it's a round cap, 0 otherwise // y is 1 if the normal points up, and -1 if it points down // We store these in the least significant bit of a_pos_normal const float2 normal = float2(vertx.pos_normal) - 2.0 * pos; const float2 v_normal = float2(normal.x, normal.y * 2.0 - 1.0); const float halfwidth = width / 2.0; const float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0); const float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING); // Scale the extrusion vector down to a normal and then up by the line width of this vertex. const float2 dist = outset * a_extrude * LINE_NORMAL_SCALE; // Calculate the offset when drawing a line that is to the side of the actual line. // We do this by creating a vector that points towards the extrude, but rotate // it when we're drawing round end points (a_direction = -1 or 1) since their // extrude vector points in another direction. const float u = 0.5 * a_direction; const float t = 1.0 - abs(u); const float2 offset2 = offset * a_extrude * LINE_NORMAL_SCALE * v_normal.y * float2x2(t, -u, u, t); const float4 projected_extrude = line.matrix * float4(dist / line.ratio, 0.0, 0.0); const float4 position = line.matrix * float4(pos + offset2 / line.ratio, 0.0, 1.0) + projected_extrude; // calculate how much the perspective view squishes or stretches the extrude const float extrude_length_without_perspective = length(dist); const float extrude_length_with_perspective = length(projected_extrude.xy / position.w * dynamic.units_to_pixels); return { .position = position, .width2 = float2(outset, inset), .normal = half2(v_normal), .gamma_scale = half(extrude_length_without_perspective / extrude_length_with_perspective), .linesofar = linesofar, #if !defined(HAS_UNIFORM_u_blur) .blur = half(unpack_mix_float(vertx.blur, interp.blur_t)), #endif #if !defined(HAS_UNIFORM_u_opacity) .opacity = half(unpack_mix_float(vertx.opacity, interp.opacity_t)), #endif #if !defined(HAS_UNIFORM_u_pattern_from) .pattern_from = half4(vertx.pattern_from), #endif #if !defined(HAS_UNIFORM_u_pattern_to) .pattern_to = half4(vertx.pattern_to), #endif }; } half4 fragment fragmentMain(FragmentStage in [[stage_in]], device const LinePatternUBO& line [[buffer(10)]], device const LinePatternPropertiesUBO& props [[buffer(11)]], device const LinePatternTilePropertiesUBO& tileProps [[buffer(13)]], texture2d image0 [[texture(0)]], sampler image0_sampler [[sampler(0)]]) { #if defined(OVERDRAW_INSPECTOR) return half4(1.0); #endif #if defined(HAS_UNIFORM_u_blur) const half blur = props.blur; #else const half blur = in.blur; #endif #if defined(HAS_UNIFORM_u_opacity) const half opacity = props.opacity; #else const half opacity = in.opacity; #endif #if defined(HAS_UNIFORM_u_pattern_from) const auto pattern_from = float4(tileProps.pattern_from); #else const auto pattern_from = float4(in.pattern_from); #endif #if defined(HAS_UNIFORM_u_pattern_to) const auto pattern_to = float4(tileProps.pattern_to); #else const auto pattern_to = float4(in.pattern_to); #endif const float2 pattern_tl_a = pattern_from.xy; const float2 pattern_br_a = pattern_from.zw; const float2 pattern_tl_b = pattern_to.xy; const float2 pattern_br_b = pattern_to.zw; const float pixelRatio = line.scale.x; const float tileZoomRatio = line.scale.y; const float fromScale = line.scale.z; const float toScale = line.scale.w; const float2 display_size_a = float2((pattern_br_a.x - pattern_tl_a.x) / pixelRatio, (pattern_br_a.y - pattern_tl_a.y) / pixelRatio); const float2 display_size_b = float2((pattern_br_b.x - pattern_tl_b.x) / pixelRatio, (pattern_br_b.y - pattern_tl_b.y) / pixelRatio); const float2 pattern_size_a = float2(display_size_a.x * fromScale / tileZoomRatio, display_size_a.y); const float2 pattern_size_b = float2(display_size_b.x * toScale / tileZoomRatio, display_size_b.y); // Calculate the distance of the pixel from the line in pixels. const float dist = length(in.normal) * in.width2.x; // Calculate the antialiasing fade factor. This is either when fading in // the line in case of an offset line (in.width2.y) or when fading out // (in.width2.x) const float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * in.gamma_scale; const float alpha = clamp(min(dist - (in.width2.y - blur2), in.width2.x - dist) / blur2, 0.0, 1.0); const float x_a = glMod(in.linesofar / pattern_size_a.x, 1.0); const float x_b = glMod(in.linesofar / pattern_size_b.x, 1.0); // in.normal.y is 0 at the midpoint of the line, -1 at the lower edge, 1 at the upper edge // we clamp the line width outset to be between 0 and half the pattern height plus padding (2.0) // to ensure we don't sample outside the designated symbol on the sprite sheet. // 0.5 is added to shift the component to be bounded between 0 and 1 for interpolation of // the texture coordinate const float y_a = 0.5 + (in.normal.y * clamp(in.width2.x, 0.0, (pattern_size_a.y + 2.0) / 2.0) / pattern_size_a.y); const float y_b = 0.5 + (in.normal.y * clamp(in.width2.x, 0.0, (pattern_size_b.y + 2.0) / 2.0) / pattern_size_b.y); const float2 pos_a = mix(pattern_tl_a / line.texsize, pattern_br_a / line.texsize, float2(x_a, y_a)); const float2 pos_b = mix(pattern_tl_b / line.texsize, pattern_br_b / line.texsize, float2(x_b, y_b)); const float4 color = mix(image0.sample(image0_sampler, pos_a), image0.sample(image0_sampler, pos_b), line.fade); return half4(color * alpha * opacity); } )"; }; template <> struct ShaderSource { static constexpr auto name = "LineSDFShader"; static constexpr auto vertexMainFunction = "vertexMain"; static constexpr auto fragmentMainFunction = "fragmentMain"; static const std::array attributes; static const std::array uniforms; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(0)]]; uchar4 data [[attribute(1)]]; #if !defined(HAS_UNIFORM_u_color) float4 color [[attribute(2)]]; #endif #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(3)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(4)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(5)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(6)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(7)]]; #endif #if !defined(HAS_UNIFORM_u_floorwidth) float2 floorwidth [[attribute(8)]]; #endif }; struct FragmentStage { float4 position [[position, invariant]]; float2 width2; float2 normal; float2 tex_a; float2 tex_b; half gamma_scale; #if !defined(HAS_UNIFORM_u_color) float4 color; #endif #if !defined(HAS_UNIFORM_u_blur) float blur; #endif #if !defined(HAS_UNIFORM_u_opacity) float opacity; #endif #if !defined(HAS_UNIFORM_u_floorwidth) float floorwidth; #endif }; struct alignas(16) LineSDFUBO { float4x4 matrix; float2 patternscale_a; float2 patternscale_b; float ratio; float tex_y_a; float tex_y_b; float sdfgamma; float mix; float pad1, pad2, pad3; }; struct alignas(16) LineSDFPropertiesUBO { float4 color; float blur; float opacity; float gapwidth; float offset; float width; float floorwidth; float pad1, pad2; }; struct alignas(16) LineSDFInterpolationUBO { float color_t; float blur_t; float opacity_t; float gapwidth_t; float offset_t; float width_t; float floorwidth_t; float pad1; }; FragmentStage vertex vertexMain(thread const VertexStage vertx [[stage_in]], device const LineDynamicUBO& dynamic [[buffer(9)]], device const LineSDFUBO& line [[buffer(10)]], device const LineSDFPropertiesUBO& props [[buffer(11)]], device const LineSDFInterpolationUBO& interp [[buffer(12)]]) { #if defined(HAS_UNIFORM_u_gapwidth) const auto gapwidth = props.gapwidth / 2; #else const auto gapwidth = unpack_mix_float(vertx.gapwidth, interp.gapwidth_t) / 2; #endif #if defined(HAS_UNIFORM_u_offset) const auto offset = props.offset * -1; #else const auto offset = unpack_mix_float(vertx.offset, interp.offset_t) * -1; #endif #if defined(HAS_UNIFORM_u_width) const auto width = props.width; #else const auto width = unpack_mix_float(vertx.width, interp.width_t); #endif #if defined(HAS_UNIFORM_u_floorwidth) const auto floorwidth = props.floorwidth; #else const auto floorwidth = unpack_mix_float(vertx.floorwidth, interp.floorwidth_t); #endif // the distance over which the line edge fades out. // Retina devices need a smaller distance to avoid aliasing. const float ANTIALIASING = 1.0 / DEVICE_PIXEL_RATIO / 2.0; const float LINE_DISTANCE_SCALE = 2.0; const float2 a_extrude = float2(vertx.data.xy) - 128.0; const float a_direction = fmod(float(vertx.data.z), 4.0) - 1.0; float linesofar = (floor(vertx.data.z / 4.0) + vertx.data.w * 64.0) * LINE_DISTANCE_SCALE; const float2 pos = floor(float2(vertx.pos_normal) * 0.5); // x is 1 if it's a round cap, 0 otherwise // y is 1 if the normal points up, and -1 if it points down // We store these in the least significant bit of a_pos_normal const float2 normal = float2(vertx.pos_normal) - 2.0 * pos; const float2 v_normal = float2(normal.x, normal.y * 2.0 - 1.0); const float halfwidth = width / 2.0; const float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0); const float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING); // Scale the extrusion vector down to a normal and then up by the line width of this vertex. const float2 dist = outset * a_extrude * LINE_NORMAL_SCALE; // Calculate the offset when drawing a line that is to the side of the actual line. // We do this by creating a vector that points towards the extrude, but rotate // it when we're drawing round end points (a_direction = -1 or 1) since their // extrude vector points in another direction. const float u = 0.5 * a_direction; const float t = 1.0 - abs(u); const float2 offset2 = offset * a_extrude * LINE_NORMAL_SCALE * v_normal.y * float2x2(t, -u, u, t); const float4 projected_extrude = line.matrix * float4(dist / line.ratio, 0.0, 0.0); const float4 position = line.matrix * float4(pos + offset2 / line.ratio, 0.0, 1.0) + projected_extrude; // calculate how much the perspective view squishes or stretches the extrude const float extrude_length_without_perspective = length(dist); const float extrude_length_with_perspective = length(projected_extrude.xy / position.w * dynamic.units_to_pixels); return { .position = position, .width2 = float2(outset, inset), .normal = v_normal, .gamma_scale = half(extrude_length_without_perspective / extrude_length_with_perspective), .tex_a = float2(linesofar * line.patternscale_a.x / floorwidth, (normal.y * line.patternscale_a.y + line.tex_y_a) * 2.0), .tex_b = float2(linesofar * line.patternscale_b.x / floorwidth, (normal.y * line.patternscale_b.y + line.tex_y_b) * 2.0), #if !defined(HAS_UNIFORM_u_color) .color = unpack_mix_color(vertx.color, interp.color_t), #endif #if !defined(HAS_UNIFORM_u_blur) .blur = unpack_mix_float(vertx.blur, interp.blur_t), #endif #if !defined(HAS_UNIFORM_u_opacity) .opacity = unpack_mix_float(vertx.opacity, interp.opacity_t), #endif #if !defined(HAS_UNIFORM_u_floorwidth) .floorwidth = floorwidth, #endif }; } half4 fragment fragmentMain(FragmentStage in [[stage_in]], device const LineSDFUBO& line [[buffer(10)]], device const LineSDFPropertiesUBO& props [[buffer(11)]], texture2d image0 [[texture(0)]], sampler image0_sampler [[sampler(0)]]) { #if defined(OVERDRAW_INSPECTOR) return half4(1.0); #endif #if defined(HAS_UNIFORM_u_color) const float4 color = props.color; #else const float4 color = in.color; #endif #if defined(HAS_UNIFORM_u_blur) const float blur = props.blur; #else const float blur = in.blur; #endif #if defined(HAS_UNIFORM_u_opacity) const float opacity = props.opacity; #else const float opacity = in.opacity; #endif #if defined(HAS_UNIFORM_u_floorwidth) const float floorwidth = props.floorwidth; #else const float floorwidth = in.floorwidth; #endif // Calculate the antialiasing fade factor. This is either when fading in the // line in case of an offset line (`v_width2.y`) or when fading out (`v_width2.x`) const float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * in.gamma_scale; const float sdfdist_a = image0.sample(image0_sampler, in.tex_a).a; const float sdfdist_b = image0.sample(image0_sampler, in.tex_b).a; const float sdfdist = mix(sdfdist_a, sdfdist_b, line.mix); const float dist = length(in.normal) * in.width2.x; const float alpha = clamp(min(dist - (in.width2.y - blur2), in.width2.x - dist) / blur2, 0.0, 1.0) * smoothstep(0.5 - line.sdfgamma / floorwidth, 0.5 + line.sdfgamma / floorwidth, sdfdist); return half4(color * (alpha * opacity)); } )"; }; template <> struct ShaderSource { static constexpr auto name = "LineBasicShader"; static constexpr auto vertexMainFunction = "vertexMain"; static constexpr auto fragmentMainFunction = "fragmentMain"; static const std::array attributes; static const std::array uniforms; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(0)]]; uchar4 data [[attribute(1)]]; }; struct FragmentStage { float4 position [[position, invariant]]; float width2; float2 normal; half gamma_scale; }; FragmentStage vertex vertexMain(thread const VertexStage vertx [[stage_in]], device const LineBasicUBO& line [[buffer(2)]], device const LineBasicPropertiesUBO& props [[buffer(3)]]) { // the distance over which the line edge fades out. // Retina devices need a smaller distance to avoid aliasing. const float ANTIALIASING = 1.0 / DEVICE_PIXEL_RATIO / 2.0; const float2 a_extrude = float2(vertx.data.xy) - 128.0; const float2 pos = floor(float2(vertx.pos_normal) * 0.5); // x is 1 if it's a round cap, 0 otherwise // y is 1 if the normal points up, and -1 if it points down // We store these in the least significant bit of a_pos_normal const float2 normal = float2(vertx.pos_normal) - 2.0 * pos; const float2 v_normal = float2(normal.x, normal.y * 2.0 - 1.0); const float halfwidth = props.width / 2.0; const float outset = halfwidth + (halfwidth == 0.0 ? 0.0 : ANTIALIASING); // Scale the extrusion vector down to a normal and then up by the line width of this vertex. const float2 dist = outset * a_extrude * LINE_NORMAL_SCALE; const float4 projected_extrude = line.matrix * float4(dist / line.ratio, 0.0, 0.0); const float4 position = line.matrix * float4(pos, 0.0, 1.0) + projected_extrude; // calculate how much the perspective view squishes or stretches the extrude const float extrude_length_without_perspective = length(dist); const float extrude_length_with_perspective = length(projected_extrude.xy / position.w * line.units_to_pixels); return { .position = position, .width2 = outset, .normal = v_normal, .gamma_scale = half(extrude_length_without_perspective / extrude_length_with_perspective), }; } half4 fragment fragmentMain(FragmentStage in [[stage_in]], device const LineBasicUBO& line [[buffer(2)]], device const LineBasicPropertiesUBO& props [[buffer(3)]]) { // Calculate the distance of the pixel from the line in pixels. const float dist = length(in.normal) * in.width2; // Calculate the antialiasing fade factor. This is either when fading in the // line in case of an offset line (`v_width2.y`) or when fading out (`v_width2.x`) const float blur2 = (1.0 / DEVICE_PIXEL_RATIO) * in.gamma_scale; const float alpha = clamp(min(dist + blur2, in.width2 - dist) / blur2, 0.0, 1.0); return half4(props.color * (alpha * props.opacity)); } )"; }; } // namespace shaders } // namespace mbgl