#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 uniforms; static const std::array attributes; static constexpr std::array instanceAttributes{}; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(lineUBOCount + 0)]]; uchar4 data [[attribute(lineUBOCount + 1)]]; #if !defined(HAS_UNIFORM_u_color) float4 color [[attribute(lineUBOCount + 2)]]; #endif #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(lineUBOCount + 3)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(lineUBOCount + 4)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(lineUBOCount + 5)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(lineUBOCount + 6)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(lineUBOCount + 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 }; struct alignas(16) LineDrawableUBO { float4x4 matrix; float ratio; float pad1, pad2, pad3; }; struct alignas(16) LineInterpolationUBO { float color_t; float blur_t; float opacity_t; float gapwidth_t; float offset_t; float width_t; float pad1, pad2; }; FragmentStage vertex vertexMain(thread const VertexStage vertx [[stage_in]], device const GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LineDrawableUBO& drawable [[buffer(idLineDrawableUBO)]], device const LineInterpolationUBO& interp [[buffer(idLineInterpolationUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]]) { #if defined(HAS_UNIFORM_u_gapwidth) const auto exprGapWidth = (props.expressionMask & LineExpressionMask::GapWidth); const auto gapwidth = (exprGapWidth ? expr.gapwidth.eval(paintParams.zoom) : 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 exprOffset = (props.expressionMask & LineExpressionMask::Offset); const auto offset = (exprOffset ? expr.offset.eval(paintParams.zoom) : 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 exprWidth = (props.expressionMask & LineExpressionMask::Width); const auto width = exprWidth ? expr.width.eval(paintParams.zoom) : 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 = drawable.matrix * float4(dist / drawable.ratio, 0.0, 0.0); const float4 position = drawable.matrix * float4(pos + offset2 / drawable.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 * paintParams.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 GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]]) { #if defined(OVERDRAW_INSPECTOR) return half4(1.0); #endif #if defined(HAS_UNIFORM_u_color) const auto exprColor = (props.expressionMask & LineExpressionMask::Color); const auto color = exprColor ? expr.color.evalColor(paintParams.zoom) : props.color; #else const float4 color = in.color; #endif #if defined(HAS_UNIFORM_u_blur) const auto exprBlur = (props.expressionMask & LineExpressionMask::Blur); const float blur = exprBlur ? expr.blur.eval(paintParams.zoom) : props.blur; #else const float blur = in.blur; #endif #if defined(HAS_UNIFORM_u_opacity) const auto exprOpacity = (props.expressionMask & LineExpressionMask::Opacity); const float opacity = exprOpacity ? expr.opacity.eval(paintParams.zoom) : 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 = "LineGradientShader"; static constexpr auto vertexMainFunction = "vertexMain"; static constexpr auto fragmentMainFunction = "fragmentMain"; static const std::array uniforms; static const std::array attributes; static constexpr std::array instanceAttributes{}; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(lineUBOCount + 0)]]; uchar4 data [[attribute(lineUBOCount + 1)]]; #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(lineUBOCount + 2)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(lineUBOCount + 3)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(lineUBOCount + 4)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(lineUBOCount + 5)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(lineUBOCount + 6)]]; #endif }; struct FragmentStage { float4 position [[position, invariant]]; float2 width2; half2 normal; half gamma_scale; float lineprogress; #if !defined(HAS_UNIFORM_u_blur) half blur; #endif #if !defined(HAS_UNIFORM_u_opacity) half opacity; #endif }; struct alignas(16) LineGradientDrawableUBO { float4x4 matrix; float ratio; float pad1, pad2, pad3; }; struct alignas(16) LineGradientInterpolationUBO { float blur_t; float opacity_t; float gapwidth_t; float offset_t; float width_t; float pad1, pad2, pad3; }; FragmentStage vertex vertexMain(thread const VertexStage vertx [[stage_in]], device const GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LineGradientDrawableUBO& drawable [[buffer(idLineDrawableUBO)]], device const LineGradientInterpolationUBO& interp [[buffer(idLineInterpolationUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]]) { #if !defined(HAS_UNIFORM_u_blur) const auto blur = unpack_mix_float(vertx.blur, interp.blur_t); #endif #if !defined(HAS_UNIFORM_u_opacity) const auto opacity = unpack_mix_float(vertx.opacity, interp.opacity_t); #endif #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 float v_lineprogress = (floor(float(vertx.data.z) / 4.0) + vertx.data.w * 64.0) * 2.0 / MAX_LINE_DISTANCE; 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 = drawable.matrix * float4(dist / drawable.ratio, 0.0, 0.0); const float4 position = drawable.matrix * float4(pos + offset2 / drawable.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 * paintParams.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), .lineprogress = v_lineprogress, #if !defined(HAS_UNIFORM_u_blur) .blur = half(blur), #endif #if !defined(HAS_UNIFORM_u_opacity) .opacity = half(opacity), #endif }; } half4 fragment fragmentMain(FragmentStage in [[stage_in]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]], texture2d gradientTexture [[texture(0)]]) { #if defined(OVERDRAW_INSPECTOR) return half4(1.0); #endif #if defined(HAS_UNIFORM_u_blur) const float blur = props.blur; #else const float blur = float(in.blur); #endif #if defined(HAS_UNIFORM_u_opacity) const float opacity = props.opacity; #else const float opacity = float(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); // For gradient lines, v_lineprogress is the ratio along the entire line, // scaled to [0, 2^15), and the gradient ramp is stored in a texture. constexpr sampler sampler2d(coord::normalized, filter::linear); const float4 color = gradientTexture.sample(sampler2d, float2(in.lineprogress, 0.5)); 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 uniforms; static const std::array attributes; static constexpr std::array instanceAttributes{}; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(lineUBOCount + 0)]]; uchar4 data [[attribute(lineUBOCount + 1)]]; #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(lineUBOCount + 2)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(lineUBOCount + 3)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(lineUBOCount + 4)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(lineUBOCount + 5)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(lineUBOCount + 6)]]; #endif #if !defined(HAS_UNIFORM_u_pattern_from) ushort4 pattern_from [[attribute(lineUBOCount + 7)]]; #endif #if !defined(HAS_UNIFORM_u_pattern_to) ushort4 pattern_to [[attribute(lineUBOCount + 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) LinePatternDrawableUBO { float4x4 matrix; float4 scale; float2 texsize; float ratio; float fade; }; 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 GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LinePatternDrawableUBO& drawable [[buffer(idLineDrawableUBO)]], device const LinePatternInterpolationUBO& interp [[buffer(idLineInterpolationUBO)]], device const LinePatternTilePropertiesUBO& tileProps [[buffer(idLineTilePropertiesUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]]) { #if defined(HAS_UNIFORM_u_gapwidth) const auto exprGapWidth = (props.expressionMask & LineExpressionMask::GapWidth); const auto gapwidth = (exprGapWidth ? expr.gapwidth.eval(paintParams.zoom) : 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 exprOffset = (props.expressionMask & LineExpressionMask::Offset); const auto offset = (exprOffset ? expr.offset.eval(paintParams.zoom) : 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 exprWidth = (props.expressionMask & LineExpressionMask::Width); const auto width = exprWidth ? expr.width.eval(paintParams.zoom) : 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 = drawable.matrix * float4(dist / drawable.ratio, 0.0, 0.0); const float4 position = drawable.matrix * float4(pos + offset2 / drawable.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 * paintParams.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 GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LinePatternDrawableUBO& drawable [[buffer(idLineDrawableUBO)]], device const LinePatternTilePropertiesUBO& tileProps [[buffer(idLineTilePropertiesUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]], 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 auto exprBlur = (props.expressionMask & LineExpressionMask::Blur); const float blur = exprBlur ? expr.blur.eval(paintParams.zoom) : props.blur; #else const float blur = in.blur; #endif #if defined(HAS_UNIFORM_u_opacity) const auto exprOpacity = (props.expressionMask & LineExpressionMask::Opacity); const float opacity = exprOpacity ? expr.opacity.eval(paintParams.zoom) : props.opacity; #else const float 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 = drawable.scale.x; const float tileZoomRatio = drawable.scale.y; const float fromScale = drawable.scale.z; const float toScale = drawable.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 / drawable.texsize, pattern_br_a / drawable.texsize, float2(x_a, y_a)); const float2 pos_b = mix(pattern_tl_b / drawable.texsize, pattern_br_b / drawable.texsize, float2(x_b, y_b)); const float4 color = mix(image0.sample(image0_sampler, pos_a), image0.sample(image0_sampler, pos_b), drawable.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 uniforms; static const std::array attributes; static constexpr std::array instanceAttributes{}; static const std::array textures; static constexpr auto source = R"( struct VertexStage { short2 pos_normal [[attribute(lineUBOCount + 0)]]; uchar4 data [[attribute(lineUBOCount + 1)]]; #if !defined(HAS_UNIFORM_u_color) float4 color [[attribute(lineUBOCount + 2)]]; #endif #if !defined(HAS_UNIFORM_u_blur) float2 blur [[attribute(lineUBOCount + 3)]]; #endif #if !defined(HAS_UNIFORM_u_opacity) float2 opacity [[attribute(lineUBOCount + 4)]]; #endif #if !defined(HAS_UNIFORM_u_gapwidth) float2 gapwidth [[attribute(lineUBOCount + 5)]]; #endif #if !defined(HAS_UNIFORM_u_offset) float2 offset [[attribute(lineUBOCount + 6)]]; #endif #if !defined(HAS_UNIFORM_u_width) float2 width [[attribute(lineUBOCount + 7)]]; #endif #if !defined(HAS_UNIFORM_u_floorwidth) float2 floorwidth [[attribute(lineUBOCount + 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) LineSDFDrawableUBO { 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) 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 GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LineSDFDrawableUBO& drawable [[buffer(idLineDrawableUBO)]], device const LineSDFInterpolationUBO& interp [[buffer(idLineInterpolationUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]]) { #if defined(HAS_UNIFORM_u_gapwidth) const auto exprGapWidth = (props.expressionMask & LineExpressionMask::GapWidth); const auto gapwidth = (exprGapWidth ? expr.gapwidth.eval(paintParams.zoom) : 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 exprOffset = (props.expressionMask & LineExpressionMask::Offset); const auto offset = (exprOffset ? expr.offset.eval(paintParams.zoom) : 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 exprWidth = (props.expressionMask & LineExpressionMask::Width); const auto width = exprWidth ? expr.width.eval(paintParams.zoom) : props.width; #else const auto width = unpack_mix_float(vertx.width, interp.width_t); #endif #if defined(HAS_UNIFORM_u_floorwidth) const auto exprFloorWidth = (props.expressionMask & LineExpressionMask::FloorWidth); const auto floorwidth = exprFloorWidth ? expr.floorwidth.eval(paintParams.zoom) : 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 = drawable.matrix * float4(dist / drawable.ratio, 0.0, 0.0); const float4 position = drawable.matrix * float4(pos + offset2 / drawable.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 * paintParams.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 * drawable.patternscale_a.x / floorwidth, (normal.y * drawable.patternscale_a.y + drawable.tex_y_a) * 2.0), .tex_b = float2(linesofar * drawable.patternscale_b.x / floorwidth, (normal.y * drawable.patternscale_b.y + drawable.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 GlobalPaintParamsUBO& paintParams [[buffer(idGlobalPaintParamsUBO)]], device const LineSDFDrawableUBO& drawable [[buffer(idLineDrawableUBO)]], device const LineEvaluatedPropsUBO& props [[buffer(idLineEvaluatedPropsUBO)]], device const LineExpressionUBO& expr [[buffer(idLineExpressionUBO)]], 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 auto exprColor = (props.expressionMask & LineExpressionMask::Color); const auto color = exprColor ? expr.color.evalColor(paintParams.zoom) : props.color; #else const float4 color = in.color; #endif #if defined(HAS_UNIFORM_u_blur) const auto exprBlur = (props.expressionMask & LineExpressionMask::Blur); const float blur = exprBlur ? expr.blur.eval(paintParams.zoom) : props.blur; #else const float blur = in.blur; #endif #if defined(HAS_UNIFORM_u_opacity) const auto exprOpacity = (props.expressionMask & LineExpressionMask::Opacity); const float opacity = exprOpacity ? expr.opacity.eval(paintParams.zoom) : props.opacity; #else const float opacity = in.opacity; #endif #if defined(HAS_UNIFORM_u_floorwidth) const auto exprFloorWidth = (props.expressionMask & LineExpressionMask::FloorWidth); const auto floorwidth = exprFloorWidth ? expr.floorwidth.eval(paintParams.zoom) : props.floorwidth; #else const auto 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, drawable.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 - drawable.sdfgamma / floorwidth, 0.5 + drawable.sdfgamma / floorwidth, sdfdist); return half4(color * (alpha * opacity)); } )"; }; } // namespace shaders } // namespace mbgl