void TileBuilder::applyStyling(const Feature& _feature, const SceneLayer& _layer) {
// If no rules matched the feature, return immediately
if (!m_ruleSet.match(_feature, _layer, m_styleContext)) { return; }
uint32_t selectionColor = 0;
bool added = false;
// For each matched rule, find the style to be used and
// build the feature with the rule's parameters
for (auto& rule : m_ruleSet.matchedRules()) {
StyleBuilder* style = getStyleBuilder(rule.getStyleName());
if (!style) {
LOGN("Invalid style %s", rule.getStyleName().c_str());
continue;
}
// Apply defaul draw rules defined for this style
style->style().applyDefaultDrawRules(rule);
if (!m_ruleSet.evaluateRuleForContext(rule, m_styleContext)) {
continue;
}
bool interactive = false;
if (rule.get(StyleParamKey::interactive, interactive) && interactive) {
if (selectionColor == 0) {
selectionColor = m_scene->featureSelection()->nextColorIdentifier();
}
rule.selectionColor = selectionColor;
rule.featureSelection = m_scene->featureSelection().get();
} else {
rule.selectionColor = 0;
}
// build outline explicitly with outline style
const auto& outlineStyleName = rule.findParameter(StyleParamKey::outline_style);
if (outlineStyleName) {
auto& styleName = outlineStyleName.value.get<std::string>();
auto* outlineStyle = getStyleBuilder(styleName);
if (!outlineStyle) {
LOGN("Invalid style %s", styleName.c_str());
} else {
rule.isOutlineOnly = true;
outlineStyle->addFeature(_feature, rule);
rule.isOutlineOnly = false;
}
}
// build feature with style
added |= style->addFeature(_feature, rule);
}
if (added && (selectionColor != 0)) {
m_selectionFeatures[selectionColor] = std::make_shared<Properties>(_feature.props);
}
}
void DrawRuleMergeSet::apply(const Feature& _feature, const SceneLayer& _layer,
StyleContext& _ctx, TileBuilder& _builder) {
// If no rules matched the feature, return immediately
if (!match(_feature, _layer, _ctx)) { return; }
// For each matched rule, find the style to be used and
// build the feature with the rule's parameters
for (auto& rule : m_matchedRules) {
StyleBuilder* style = _builder.getStyleBuilder(rule.getStyleName());
if (!style) {
LOGE("Invalid style %s", rule.getStyleName().c_str());
continue;
}
bool visible;
if (rule.get(StyleParamKey::visible, visible) && !visible) {
continue;
}
bool valid = true;
for (size_t i = 0; i < StyleParamKeySize; ++i) {
if (!rule.active[i]) {
rule.params[i].param = nullptr;
continue;
}
auto*& param = rule.params[i].param;
// Evaluate JS functions and Stops
if (param->function >= 0) {
// Copy param into 'evaluated' and point param to the evaluated StyleParam.
m_evaluated[i] = *param;
param = &m_evaluated[i];
if (!_ctx.evalStyle(param->function, param->key, m_evaluated[i].value)) {
if (StyleParam::isRequired(param->key)) {
valid = false;
break;
} else {
rule.active[i] = false;
}
}
} else if (param->stops) {
m_evaluated[i] = *param;
param = &m_evaluated[i];
Stops::eval(*param->stops, param->key, _ctx.getGlobalZoom(),
m_evaluated[i].value);
}
}
if (valid) {
// build outline explicitly with outline style
const auto& outlineStyleName = rule.findParameter(StyleParamKey::outline_style);
if (outlineStyleName) {
auto& styleName = outlineStyleName.value.get<std::string>();
auto* outlineStyle = _builder.getStyleBuilder(styleName);
if (!outlineStyle) {
LOGE("Invalid style %s", styleName.c_str());
} else {
rule.isOutlineOnly = true;
outlineStyle->addFeature(_feature, rule);
rule.isOutlineOnly = false;
}
}
// build feature with style
style->addFeature(_feature, rule);
}
}
}
