Values makeValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, const RenderTile& tile, const TransformState& state, const std::array<float, 2>& pixelsToGLUnits, Args&&... args) { return Values { uniforms::u_matrix::Value{ tile.translatedMatrix(properties.get<LineTranslate>(), properties.get<LineTranslateAnchor>(), state) }, uniforms::u_ratio::Value{ 1.0f / tile.id.pixelsToTileUnits(1.0, state.getZoom()) }, uniforms::u_gl_units_to_pixels::Value{{{ 1.0f / pixelsToGLUnits[0], 1.0f / pixelsToGLUnits[1] }}}, std::forward<Args>(args)... }; }
void Painter::renderCircle(PaintParameters& parameters, CircleBucket& bucket, const CircleLayer& layer, const RenderTile& tile) { if (pass == RenderPass::Opaque) { return; } const CirclePaintProperties::Evaluated& properties = layer.impl->paint.evaluated; const bool scaleWithMap = properties.get<CirclePitchScale>() == CirclePitchScaleType::Map; parameters.programs.circle.draw( context, gl::Triangles(), depthModeForSublayer(0, gl::DepthMode::ReadOnly), frame.mapMode == MapMode::Still ? stencilModeForClipping(tile.clip) : gl::StencilMode::disabled(), colorModeForRenderPass(), CircleProgram::UniformValues { uniforms::u_matrix::Value{ tile.translatedMatrix(properties.get<CircleTranslate>(), properties.get<CircleTranslateAnchor>(), state) }, uniforms::u_opacity::Value{ properties.get<CircleOpacity>() }, uniforms::u_color::Value{ properties.get<CircleColor>() }, uniforms::u_radius::Value{ properties.get<CircleRadius>() }, uniforms::u_blur::Value{ properties.get<CircleBlur>() }, uniforms::u_stroke_color::Value{ properties.get<CircleStrokeColor>() }, uniforms::u_stroke_width::Value{ properties.get<CircleStrokeWidth>() }, uniforms::u_stroke_opacity::Value{ properties.get<CircleStrokeOpacity>() }, uniforms::u_scale_with_map::Value{ scaleWithMap }, uniforms::u_extrude_scale::Value{ scaleWithMap ? std::array<float, 2> {{ pixelsToGLUnits[0] * state.getAltitude(), pixelsToGLUnits[1] * state.getAltitude() }} : pixelsToGLUnits } }, *bucket.vertexBuffer, *bucket.indexBuffer, bucket.segments ); }
void Painter::renderSDF(SymbolBucket& bucket, const RenderTile& tile, float sdfFontSize, std::array<float, 2> texsize, SDFShader& sdfShader, void (SymbolBucket::*drawSDF)(SDFShader&, gl::ObjectStore&, bool), // Layout AlignmentType rotationAlignment, AlignmentType pitchAlignment, float layoutSize, // Paint float opacity, Color color, Color haloColor, float haloWidth, float haloBlur, std::array<float, 2> translate, TranslateAnchorType translateAnchor, float paintSize) { mat4 vtxMatrix = tile.translatedMatrix(translate, translateAnchor, state); // If layerStyle.size > bucket.info.fontSize then labels may collide float fontSize = paintSize; float fontScale = fontSize / sdfFontSize; bool rotateWithMap = rotationAlignment == AlignmentType::Map; bool pitchWithMap = pitchAlignment == AlignmentType::Map; std::array<float, 2> extrudeScale; float gammaScale; if (pitchWithMap) { gammaScale = 1.0 / std::cos(state.getPitch()); extrudeScale.fill(tile.id.pixelsToTileUnits(1, state.getZoom()) * fontScale); } else { gammaScale = 1.0; extrudeScale = {{ pixelsToGLUnits[0] * fontScale * state.getAltitude(), pixelsToGLUnits[1] * fontScale * state.getAltitude() }}; } config.program = sdfShader.getID(); sdfShader.u_matrix = vtxMatrix; sdfShader.u_extrude_scale = extrudeScale; sdfShader.u_texsize = texsize; sdfShader.u_rotate_with_map = rotateWithMap; sdfShader.u_pitch_with_map = pitchWithMap; sdfShader.u_texture = 0; sdfShader.u_pitch = state.getPitch() * util::DEG2RAD; sdfShader.u_bearing = -1.0f * state.getAngle(); sdfShader.u_aspect_ratio = (state.getWidth() * 1.0f) / (state.getHeight() * 1.0f); // adjust min/max zooms for variable font sies float zoomAdjust = std::log(fontSize / layoutSize) / std::log(2); sdfShader.u_zoom = (state.getZoom() - zoomAdjust) * 10; // current zoom level frameHistory.bind(store, config, 1); sdfShader.u_fadetexture = 1; // The default gamma value has to be adjust for the current pixelratio so that we're not // drawing blurry font on retina screens. const float gamma = 0.105 * sdfFontSize / fontSize / frame.pixelRatio; const float sdfPx = 8.0f; const float blurOffset = 1.19f; const float haloOffset = 6.0f; // We're drawing in the translucent pass which is bottom-to-top, so we need // to draw the halo first. if (haloColor.a > 0.0f && haloWidth > 0.0f) { sdfShader.u_gamma = (haloBlur * blurOffset / fontScale / sdfPx + gamma) * gammaScale; sdfShader.u_color = haloColor; sdfShader.u_opacity = opacity; sdfShader.u_buffer = (haloOffset - haloWidth / fontScale) / sdfPx; setDepthSublayer(0); (bucket.*drawSDF)(sdfShader, store, isOverdraw()); } // Then, we draw the text/icon over the halo if (color.a > 0.0f) { sdfShader.u_gamma = gamma * gammaScale; sdfShader.u_color = color; sdfShader.u_opacity = opacity; sdfShader.u_buffer = (256.0f - 64.0f) / 256.0f; setDepthSublayer(1); (bucket.*drawSDF)(sdfShader, store, isOverdraw()); } }
void Painter::renderSymbol(PaintParameters& parameters, SymbolBucket& bucket, const SymbolLayer& layer, const RenderTile& tile) { // Abort early. if (pass == RenderPass::Opaque) { return; } const auto& paint = layer.impl->paint; const auto& layout = bucket.layout; config.depthMask = GL_FALSE; // TODO remove the `true ||` when #1673 is implemented const bool drawAcrossEdges = (frame.mapMode == MapMode::Continuous) && (true || !(layout.textAllowOverlap || layout.iconAllowOverlap || layout.textIgnorePlacement || layout.iconIgnorePlacement)); // Disable the stencil test so that labels aren't clipped to tile boundaries. // // Layers with features that may be drawn overlapping aren't clipped. These // layers are sorted in the y direction, and to draw the correct ordering near // tile edges the icons are included in both tiles and clipped when drawing. if (drawAcrossEdges) { config.stencilTest = GL_FALSE; } else { config.stencilOp.reset(); config.stencilTest = GL_TRUE; } if (bucket.hasIconData()) { if (layout.iconRotationAlignment == AlignmentType::Map) { config.depthFunc.reset(); config.depthTest = GL_TRUE; } else { config.depthTest = GL_FALSE; } bool sdf = bucket.sdfIcons; const float angleOffset = layout.iconRotationAlignment == AlignmentType::Map ? state.getAngle() : 0; const float fontSize = layer.impl->iconSize; const float fontScale = fontSize / 1.0f; SpriteAtlas* activeSpriteAtlas = layer.impl->spriteAtlas; const bool iconScaled = fontScale != 1 || frame.pixelRatio != activeSpriteAtlas->getPixelRatio() || bucket.iconsNeedLinear; const bool iconTransformed = layout.iconRotationAlignment == AlignmentType::Map || angleOffset != 0 || state.getPitch() != 0; activeSpriteAtlas->bind(sdf || state.isChanging() || iconScaled || iconTransformed, store, config, 0); if (sdf) { renderSDF(bucket, tile, 1.0f, {{ float(activeSpriteAtlas->getWidth()) / 4.0f, float(activeSpriteAtlas->getHeight()) / 4.0f }}, parameters.shaders.sdfIcon, &SymbolBucket::drawIcons, layout.iconRotationAlignment, // icon-pitch-alignment is not yet implemented // and we simply inherit the rotation alignment layout.iconRotationAlignment, layout.iconSize, paint.iconOpacity, paint.iconColor, paint.iconHaloColor, paint.iconHaloWidth, paint.iconHaloBlur, paint.iconTranslate, paint.iconTranslateAnchor, layer.impl->iconSize); } else { mat4 vtxMatrix = tile.translatedMatrix(paint.iconTranslate, paint.iconTranslateAnchor, state); std::array<float, 2> extrudeScale; const bool alignedWithMap = layout.iconRotationAlignment == AlignmentType::Map; if (alignedWithMap) { extrudeScale.fill(tile.id.pixelsToTileUnits(1, state.getZoom()) * fontScale); } else { extrudeScale = {{ pixelsToGLUnits[0] * fontScale * state.getAltitude(), pixelsToGLUnits[1] * fontScale * state.getAltitude() }}; } auto& iconShader = parameters.shaders.icon; config.program = iconShader.getID(); iconShader.u_matrix = vtxMatrix; iconShader.u_extrude_scale = extrudeScale; iconShader.u_texsize = {{ float(activeSpriteAtlas->getWidth()) / 4.0f, float(activeSpriteAtlas->getHeight()) / 4.0f }}; iconShader.u_rotate_with_map = alignedWithMap; iconShader.u_texture = 0; // adjust min/max zooms for variable font sies float zoomAdjust = std::log(fontSize / layout.iconSize) / std::log(2); iconShader.u_zoom = (state.getZoom() - zoomAdjust) * 10; // current zoom level iconShader.u_opacity = paint.iconOpacity; frameHistory.bind(store, config, 1); iconShader.u_fadetexture = 1; setDepthSublayer(0); bucket.drawIcons(iconShader, store, isOverdraw()); } } if (bucket.hasTextData()) { if (layout.textRotationAlignment == AlignmentType::Map) { config.depthFunc.reset(); config.depthTest = GL_TRUE; } else { config.depthTest = GL_FALSE; } glyphAtlas->bind(store, config, 0); renderSDF(bucket, tile, 24.0f, {{ float(glyphAtlas->width) / 4, float(glyphAtlas->height) / 4 }}, parameters.shaders.sdfGlyph, &SymbolBucket::drawGlyphs, layout.textRotationAlignment, layout.textPitchAlignment, layout.textSize, paint.textOpacity, paint.textColor, paint.textHaloColor, paint.textHaloWidth, paint.textHaloBlur, paint.textTranslate, paint.textTranslateAnchor, layer.impl->textSize); } if (bucket.hasCollisionBoxData()) { config.stencilOp.reset(); config.stencilTest = GL_TRUE; auto& collisionBoxShader = shaders->collisionBox; config.program = collisionBoxShader.getID(); collisionBoxShader.u_matrix = tile.matrix; // TODO: This was the overscaled z instead of the canonical z. collisionBoxShader.u_scale = std::pow(2, state.getZoom() - tile.id.canonical.z); collisionBoxShader.u_zoom = state.getZoom() * 10; collisionBoxShader.u_maxzoom = (tile.id.canonical.z + 1) * 10; config.lineWidth = 1.0f; setDepthSublayer(0); bucket.drawCollisionBoxes(collisionBoxShader, store); } }