diff options
Diffstat (limited to 'platform/darwin/src')
| -rw-r--r-- | platform/darwin/src/MGLFillExtrusionStyleLayer.h | 364 | ||||
| -rw-r--r-- | platform/darwin/src/MGLFillExtrusionStyleLayer.mm | 335 | ||||
| -rw-r--r-- | platform/darwin/src/MGLStyle.mm | 4 | ||||
| -rw-r--r-- | platform/darwin/src/MGLStyleLayer.h.ejs | 2 |
4 files changed, 704 insertions, 1 deletions
diff --git a/platform/darwin/src/MGLFillExtrusionStyleLayer.h b/platform/darwin/src/MGLFillExtrusionStyleLayer.h new file mode 100644 index 0000000000..84f6bedde4 --- /dev/null +++ b/platform/darwin/src/MGLFillExtrusionStyleLayer.h @@ -0,0 +1,364 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make darwin-style-code`. + +#import "MGLFoundation.h" +#import "MGLStyleValue.h" +#import "MGLVectorStyleLayer.h" + +NS_ASSUME_NONNULL_BEGIN + +/** + Controls the translation reference point. + + Values of this type are used in the `MGLFillExtrusionStyleLayer.fillExtrusionTranslationAnchor` + property. + */ +typedef NS_ENUM(NSUInteger, MGLFillExtrusionTranslationAnchor) { + /** + The fill extrusion is translated relative to the map. + */ + MGLFillExtrusionTranslationAnchorMap, + /** + The fill extrusion is translated relative to the viewport. + */ + MGLFillExtrusionTranslationAnchorViewport, +}; + +/** + An `MGLFillExtrusionStyleLayer` is a style layer that renders one or more 3D + extruded polygons on the map. + + Use a fill-extrusion style layer to configure the visual appearance of polygon + or multipolygon features in vector tiles loaded by an `MGLVectorSource` object + or `MGLPolygon`, `MGLPolygonFeature`, `MGLMultiPolygon`, or + `MGLMultiPolygonFeature` instances in an `MGLShapeSource` object. + + You can access an existing fill-extrusion style layer using the + `-[MGLStyle layerWithIdentifier:]` method if you know its identifier; + otherwise, find it using the `MGLStyle.layers` property. You can also create a + new fill-extrusion style layer and add it to the style using a method such as + `-[MGLStyle addLayer:]`. + + ### Example + + ```swift + let layer = MGLFillExtrusionStyleLayer(identifier: "buildings", source: buildings) + layer.sourceLayerIdentifier = "building" + layer.fillExtrusionHeight = MGLStyleValue(interpolationMode: .identity, sourceStops: nil, attributeName: "height", options: nil) + layer.fillExtrusionBase = MGLStyleValue(interpolationMode: .identity, sourceStops: nil, attributeName: "min_height", options: nil) + layer.predicate = NSPredicate(format: "extrude == TRUE") + mapView.style?.addLayer(layer) + ``` + */ +MGL_EXPORT +@interface MGLFillExtrusionStyleLayer : MGLVectorStyleLayer + +/** + Returns a fill-extrusion style layer initialized with an identifier and source. + + After initializing and configuring the style layer, add it to a map view’s + style using the `-[MGLStyle addLayer:]` or + `-[MGLStyle insertLayer:belowLayer:]` method. + + @param identifier A string that uniquely identifies the source in the style to + which it is added. + @param source The source from which to obtain the data to style. If the source + has not yet been added to the current style, the behavior is undefined. + @return An initialized foreground style layer. + */ +- (instancetype)initWithIdentifier:(NSString *)identifier source:(MGLSource *)source; + +#pragma mark - Accessing the Paint Attributes + +/** + The height with which to extrude the base of this layer. Must be less than or + equal to `fillExtrusionHeight`. + + This property is measured in meters. + + The default value of this property is an `MGLStyleValue` object containing an + `NSNumber` object containing the float `0`. Set this property to `nil` to reset + it to the default value. + + This property is only applied to the style if `fillExtrusionHeight` is + non-`nil`. Otherwise, it is ignored. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLSourceStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + * `MGLInterpolationModeIdentity` + * `MGLCompositeStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSNumber *> *fillExtrusionBase; + +/** + The transition affecting any changes to this layer’s `fillExtrusionBase` property. + + This property corresponds to the `fill-extrusion-base-transition` property in the style JSON file format. +*/ +@property (nonatomic) MGLTransition fillExtrusionBaseTransition; + +#if TARGET_OS_IPHONE +/** + The base color of this layer. The extrusion's surfaces will be shaded + differently based on this color in combination with the `light` settings. If + this color is specified with an alpha component, the alpha component will be + ignored; use `fillExtrusionOpacity` to set layer opacityco. + + The default value of this property is an `MGLStyleValue` object containing + `UIColor.blackColor`. Set this property to `nil` to reset it to the default + value. + + This property is only applied to the style if `fillExtrusionPattern` is set to + `nil`. Otherwise, it is ignored. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLSourceStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + * `MGLInterpolationModeIdentity` + * `MGLCompositeStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + */ +@property (nonatomic, null_resettable) MGLStyleValue<UIColor *> *fillExtrusionColor; +#else +/** + The base color of this layer. The extrusion's surfaces will be shaded + differently based on this color in combination with the `light` settings. If + this color is specified with an alpha component, the alpha component will be + ignored; use `fillExtrusionOpacity` to set layer opacityco. + + The default value of this property is an `MGLStyleValue` object containing + `NSColor.blackColor`. Set this property to `nil` to reset it to the default + value. + + This property is only applied to the style if `fillExtrusionPattern` is set to + `nil`. Otherwise, it is ignored. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLSourceStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + * `MGLInterpolationModeIdentity` + * `MGLCompositeStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSColor *> *fillExtrusionColor; +#endif + +/** + The transition affecting any changes to this layer’s `fillExtrusionColor` property. + + This property corresponds to the `fill-extrusion-color-transition` property in the style JSON file format. +*/ +@property (nonatomic) MGLTransition fillExtrusionColorTransition; + +/** + The height with which to extrude this layer. + + This property is measured in meters. + + The default value of this property is an `MGLStyleValue` object containing an + `NSNumber` object containing the float `0`. Set this property to `nil` to reset + it to the default value. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLSourceStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + * `MGLInterpolationModeIdentity` + * `MGLCompositeStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSNumber *> *fillExtrusionHeight; + +/** + The transition affecting any changes to this layer’s `fillExtrusionHeight` property. + + This property corresponds to the `fill-extrusion-height-transition` property in the style JSON file format. +*/ +@property (nonatomic) MGLTransition fillExtrusionHeightTransition; + +/** + The opacity of the entire fill extrusion layer. This is rendered on a + per-layer, not per-feature, basis, and data-driven styling is not available. + + The default value of this property is an `MGLStyleValue` object containing an + `NSNumber` object containing the float `1`. Set this property to `nil` to reset + it to the default value. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSNumber *> *fillExtrusionOpacity; + +/** + The transition affecting any changes to this layer’s `fillExtrusionOpacity` property. + + This property corresponds to the `fill-extrusion-opacity-transition` property in the style JSON file format. +*/ +@property (nonatomic) MGLTransition fillExtrusionOpacityTransition; + +/** + Name of image in style images to use for drawing image fill-extrusions. For + seamless patterns, image width and height must be a factor of two (2, 4, 8, + ..., 512). + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of + `MGLInterpolationModeInterval` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSString *> *fillExtrusionPattern; + +/** + The transition affecting any changes to this layer’s `fillExtrusionPattern` property. + + This property corresponds to the `fill-extrusion-pattern-transition` property in the style JSON file format. +*/ +@property (nonatomic) MGLTransition fillExtrusionPatternTransition; + +#if TARGET_OS_IPHONE +/** + The geometry's offset. + + This property is measured in points. + + The default value of this property is an `MGLStyleValue` object containing an + `NSValue` object containing a `CGVector` struct set to 0 points rightward and 0 + points downward. Set this property to `nil` to reset it to the default value. + + This attribute corresponds to the <a + href="https://www.mapbox.com/mapbox-gl-style-spec/#paint-fill-extrusion-translate"><code>fill-extrusion-translate</code></a> + layout property in the Mapbox Style Specification. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSValue *> *fillExtrusionTranslation; +#else +/** + The geometry's offset. + + This property is measured in points. + + The default value of this property is an `MGLStyleValue` object containing an + `NSValue` object containing a `CGVector` struct set to 0 points rightward and 0 + points upward. Set this property to `nil` to reset it to the default value. + + This attribute corresponds to the <a + href="https://www.mapbox.com/mapbox-gl-style-spec/#paint-fill-extrusion-translate"><code>fill-extrusion-translate</code></a> + layout property in the Mapbox Style Specification. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSValue *> *fillExtrusionTranslation; +#endif + +/** + The transition affecting any changes to this layer’s `fillExtrusionTranslation` property. + + This property corresponds to the `fill-extrusion-translate-transition` property in the style JSON file format. +*/ +@property (nonatomic) MGLTransition fillExtrusionTranslationTransition; + +@property (nonatomic, null_resettable) MGLStyleValue<NSValue *> *fillExtrusionTranslate __attribute__((unavailable("Use fillExtrusionTranslation instead."))); + +/** + Controls the translation reference point. + + The default value of this property is an `MGLStyleValue` object containing an + `NSValue` object containing `MGLFillExtrusionTranslationAnchorMap`. Set this + property to `nil` to reset it to the default value. + + This property is only applied to the style if `fillExtrusionTranslation` is + non-`nil`. Otherwise, it is ignored. + + This attribute corresponds to the <a + href="https://www.mapbox.com/mapbox-gl-style-spec/#paint-fill-extrusion-translate-anchor"><code>fill-extrusion-translate-anchor</code></a> + layout property in the Mapbox Style Specification. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of + `MGLInterpolationModeInterval` + */ +@property (nonatomic, null_resettable) MGLStyleValue<NSValue *> *fillExtrusionTranslationAnchor; + +@property (nonatomic, null_resettable) MGLStyleValue<NSValue *> *fillExtrusionTranslateAnchor __attribute__((unavailable("Use fillExtrusionTranslationAnchor instead."))); + +@end + +/** + Methods for wrapping an enumeration value for a style layer attribute in an + `MGLFillExtrusionStyleLayer` object and unwrapping its raw value. + */ +@interface NSValue (MGLFillExtrusionStyleLayerAdditions) + +#pragma mark Working with Fill extrusion Style Layer Attribute Values + +/** + Creates a new value object containing the given `MGLFillExtrusionTranslationAnchor` enumeration. + + @param fillExtrusionTranslationAnchor The value for the new object. + @return A new value object that contains the enumeration value. + */ ++ (instancetype)valueWithMGLFillExtrusionTranslationAnchor:(MGLFillExtrusionTranslationAnchor)fillExtrusionTranslationAnchor; + +/** + The `MGLFillExtrusionTranslationAnchor` enumeration representation of the value. + */ +@property (readonly) MGLFillExtrusionTranslationAnchor MGLFillExtrusionTranslationAnchorValue; + +@end + +NS_ASSUME_NONNULL_END diff --git a/platform/darwin/src/MGLFillExtrusionStyleLayer.mm b/platform/darwin/src/MGLFillExtrusionStyleLayer.mm new file mode 100644 index 0000000000..b00ed8e09f --- /dev/null +++ b/platform/darwin/src/MGLFillExtrusionStyleLayer.mm @@ -0,0 +1,335 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make darwin-style-code`. + +#import "MGLSource.h" +#import "NSPredicate+MGLAdditions.h" +#import "NSDate+MGLAdditions.h" +#import "MGLStyleLayer_Private.h" +#import "MGLStyleValue_Private.h" +#import "MGLFillExtrusionStyleLayer.h" + +#include <mbgl/style/transition_options.hpp> +#include <mbgl/style/layers/fill_extrusion_layer.hpp> + +namespace mbgl { + + MBGL_DEFINE_ENUM(MGLFillExtrusionTranslationAnchor, { + { MGLFillExtrusionTranslationAnchorMap, "map" }, + { MGLFillExtrusionTranslationAnchorViewport, "viewport" }, + }); + +} + +@interface MGLFillExtrusionStyleLayer () + +@property (nonatomic, readonly) mbgl::style::FillExtrusionLayer *rawLayer; + +@end + +@implementation MGLFillExtrusionStyleLayer + +- (instancetype)initWithIdentifier:(NSString *)identifier source:(MGLSource *)source +{ + auto layer = std::make_unique<mbgl::style::FillExtrusionLayer>(identifier.UTF8String, source.identifier.UTF8String); + return self = [super initWithPendingLayer:std::move(layer)]; +} + +- (mbgl::style::FillExtrusionLayer *)rawLayer +{ + return (mbgl::style::FillExtrusionLayer *)super.rawLayer; +} + +- (NSString *)sourceIdentifier +{ + MGLAssertStyleLayerIsValid(); + + return @(self.rawLayer->getSourceID().c_str()); +} + +- (NSString *)sourceLayerIdentifier +{ + MGLAssertStyleLayerIsValid(); + + auto layerID = self.rawLayer->getSourceLayer(); + return layerID.empty() ? nil : @(layerID.c_str()); +} + +- (void)setSourceLayerIdentifier:(NSString *)sourceLayerIdentifier +{ + MGLAssertStyleLayerIsValid(); + + self.rawLayer->setSourceLayer(sourceLayerIdentifier.UTF8String ?: ""); +} + +- (void)setPredicate:(NSPredicate *)predicate +{ + MGLAssertStyleLayerIsValid(); + + self.rawLayer->setFilter(predicate ? predicate.mgl_filter : mbgl::style::NullFilter()); +} + +- (NSPredicate *)predicate +{ + MGLAssertStyleLayerIsValid(); + + return [NSPredicate mgl_predicateWithFilter:self.rawLayer->getFilter()]; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setFillExtrusionBase:(MGLStyleValue<NSNumber *> *)fillExtrusionBase { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<float, NSNumber *>().toDataDrivenPropertyValue(fillExtrusionBase); + self.rawLayer->setFillExtrusionBase(mbglValue); +} + +- (MGLStyleValue<NSNumber *> *)fillExtrusionBase { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionBase(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<float, NSNumber *>().toDataDrivenStyleValue(self.rawLayer->getDefaultFillExtrusionBase()); + } + return MGLStyleValueTransformer<float, NSNumber *>().toDataDrivenStyleValue(propertyValue); +} + +- (void)setFillExtrusionBaseTransition:(MGLTransition )transition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions options { { MGLDurationFromTimeInterval(transition.duration) }, { MGLDurationFromTimeInterval(transition.delay) } }; + self.rawLayer->setFillExtrusionBaseTransition(options); +} + +- (MGLTransition)fillExtrusionBaseTransition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions transitionOptions = self.rawLayer->getFillExtrusionBaseTransition(); + MGLTransition transition; + transition.duration = MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero())); + transition.delay = MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero())); + + return transition; +} + +- (void)setFillExtrusionColor:(MGLStyleValue<MGLColor *> *)fillExtrusionColor { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<mbgl::Color, MGLColor *>().toDataDrivenPropertyValue(fillExtrusionColor); + self.rawLayer->setFillExtrusionColor(mbglValue); +} + +- (MGLStyleValue<MGLColor *> *)fillExtrusionColor { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionColor(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<mbgl::Color, MGLColor *>().toDataDrivenStyleValue(self.rawLayer->getDefaultFillExtrusionColor()); + } + return MGLStyleValueTransformer<mbgl::Color, MGLColor *>().toDataDrivenStyleValue(propertyValue); +} + +- (void)setFillExtrusionColorTransition:(MGLTransition )transition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions options { { MGLDurationFromTimeInterval(transition.duration) }, { MGLDurationFromTimeInterval(transition.delay) } }; + self.rawLayer->setFillExtrusionColorTransition(options); +} + +- (MGLTransition)fillExtrusionColorTransition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions transitionOptions = self.rawLayer->getFillExtrusionColorTransition(); + MGLTransition transition; + transition.duration = MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero())); + transition.delay = MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero())); + + return transition; +} + +- (void)setFillExtrusionHeight:(MGLStyleValue<NSNumber *> *)fillExtrusionHeight { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<float, NSNumber *>().toDataDrivenPropertyValue(fillExtrusionHeight); + self.rawLayer->setFillExtrusionHeight(mbglValue); +} + +- (MGLStyleValue<NSNumber *> *)fillExtrusionHeight { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionHeight(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<float, NSNumber *>().toDataDrivenStyleValue(self.rawLayer->getDefaultFillExtrusionHeight()); + } + return MGLStyleValueTransformer<float, NSNumber *>().toDataDrivenStyleValue(propertyValue); +} + +- (void)setFillExtrusionHeightTransition:(MGLTransition )transition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions options { { MGLDurationFromTimeInterval(transition.duration) }, { MGLDurationFromTimeInterval(transition.delay) } }; + self.rawLayer->setFillExtrusionHeightTransition(options); +} + +- (MGLTransition)fillExtrusionHeightTransition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions transitionOptions = self.rawLayer->getFillExtrusionHeightTransition(); + MGLTransition transition; + transition.duration = MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero())); + transition.delay = MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero())); + + return transition; +} + +- (void)setFillExtrusionOpacity:(MGLStyleValue<NSNumber *> *)fillExtrusionOpacity { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<float, NSNumber *>().toInterpolatablePropertyValue(fillExtrusionOpacity); + self.rawLayer->setFillExtrusionOpacity(mbglValue); +} + +- (MGLStyleValue<NSNumber *> *)fillExtrusionOpacity { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionOpacity(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(self.rawLayer->getDefaultFillExtrusionOpacity()); + } + return MGLStyleValueTransformer<float, NSNumber *>().toStyleValue(propertyValue); +} + +- (void)setFillExtrusionOpacityTransition:(MGLTransition )transition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions options { { MGLDurationFromTimeInterval(transition.duration) }, { MGLDurationFromTimeInterval(transition.delay) } }; + self.rawLayer->setFillExtrusionOpacityTransition(options); +} + +- (MGLTransition)fillExtrusionOpacityTransition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions transitionOptions = self.rawLayer->getFillExtrusionOpacityTransition(); + MGLTransition transition; + transition.duration = MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero())); + transition.delay = MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero())); + + return transition; +} + +- (void)setFillExtrusionPattern:(MGLStyleValue<NSString *> *)fillExtrusionPattern { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<std::string, NSString *>().toPropertyValue(fillExtrusionPattern); + self.rawLayer->setFillExtrusionPattern(mbglValue); +} + +- (MGLStyleValue<NSString *> *)fillExtrusionPattern { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionPattern(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<std::string, NSString *>().toStyleValue(self.rawLayer->getDefaultFillExtrusionPattern()); + } + return MGLStyleValueTransformer<std::string, NSString *>().toStyleValue(propertyValue); +} + +- (void)setFillExtrusionPatternTransition:(MGLTransition )transition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions options { { MGLDurationFromTimeInterval(transition.duration) }, { MGLDurationFromTimeInterval(transition.delay) } }; + self.rawLayer->setFillExtrusionPatternTransition(options); +} + +- (MGLTransition)fillExtrusionPatternTransition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions transitionOptions = self.rawLayer->getFillExtrusionPatternTransition(); + MGLTransition transition; + transition.duration = MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero())); + transition.delay = MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero())); + + return transition; +} + +- (void)setFillExtrusionTranslation:(MGLStyleValue<NSValue *> *)fillExtrusionTranslation { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toInterpolatablePropertyValue(fillExtrusionTranslation); + self.rawLayer->setFillExtrusionTranslate(mbglValue); +} + +- (MGLStyleValue<NSValue *> *)fillExtrusionTranslation { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionTranslate(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(self.rawLayer->getDefaultFillExtrusionTranslate()); + } + return MGLStyleValueTransformer<std::array<float, 2>, NSValue *>().toStyleValue(propertyValue); +} + +- (void)setFillExtrusionTranslationTransition:(MGLTransition )transition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions options { { MGLDurationFromTimeInterval(transition.duration) }, { MGLDurationFromTimeInterval(transition.delay) } }; + self.rawLayer->setFillExtrusionTranslateTransition(options); +} + +- (MGLTransition)fillExtrusionTranslationTransition { + MGLAssertStyleLayerIsValid(); + + mbgl::style::TransitionOptions transitionOptions = self.rawLayer->getFillExtrusionTranslateTransition(); + MGLTransition transition; + transition.duration = MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero())); + transition.delay = MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero())); + + return transition; +} + +- (void)setFillExtrusionTranslate:(MGLStyleValue<NSValue *> *)fillExtrusionTranslate { +} + +- (MGLStyleValue<NSValue *> *)fillExtrusionTranslate { + return self.fillExtrusionTranslation; +} + +- (void)setFillExtrusionTranslationAnchor:(MGLStyleValue<NSValue *> *)fillExtrusionTranslationAnchor { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLFillExtrusionTranslationAnchor>().toEnumPropertyValue(fillExtrusionTranslationAnchor); + self.rawLayer->setFillExtrusionTranslateAnchor(mbglValue); +} + +- (MGLStyleValue<NSValue *> *)fillExtrusionTranslationAnchor { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getFillExtrusionTranslateAnchor(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLFillExtrusionTranslationAnchor>().toEnumStyleValue(self.rawLayer->getDefaultFillExtrusionTranslateAnchor()); + } + return MGLStyleValueTransformer<mbgl::style::TranslateAnchorType, NSValue *, mbgl::style::TranslateAnchorType, MGLFillExtrusionTranslationAnchor>().toEnumStyleValue(propertyValue); +} + +- (void)setFillExtrusionTranslateAnchor:(MGLStyleValue<NSValue *> *)fillExtrusionTranslateAnchor { +} + +- (MGLStyleValue<NSValue *> *)fillExtrusionTranslateAnchor { + return self.fillExtrusionTranslationAnchor; +} + +@end + +@implementation NSValue (MGLFillExtrusionStyleLayerAdditions) + ++ (NSValue *)valueWithMGLFillExtrusionTranslationAnchor:(MGLFillExtrusionTranslationAnchor)fillExtrusionTranslationAnchor { + return [NSValue value:&fillExtrusionTranslationAnchor withObjCType:@encode(MGLFillExtrusionTranslationAnchor)]; +} + +- (MGLFillExtrusionTranslationAnchor)MGLFillExtrusionTranslationAnchorValue { + MGLFillExtrusionTranslationAnchor fillExtrusionTranslationAnchor; + [self getValue:&fillExtrusionTranslationAnchor]; + return fillExtrusionTranslationAnchor; +} + +@end diff --git a/platform/darwin/src/MGLStyle.mm b/platform/darwin/src/MGLStyle.mm index a4cf8d9cce..81b6446e7f 100644 --- a/platform/darwin/src/MGLStyle.mm +++ b/platform/darwin/src/MGLStyle.mm @@ -3,6 +3,7 @@ #import "MGLMapView_Private.h" #import "MGLStyleLayer.h" #import "MGLFillStyleLayer.h" +#import "MGLFillExtrusionStyleLayer.h" #import "MGLLineStyleLayer.h" #import "MGLCircleStyleLayer.h" #import "MGLSymbolStyleLayer.h" @@ -28,6 +29,7 @@ #include <mbgl/util/default_styles.hpp> #include <mbgl/style/image.hpp> #include <mbgl/style/layers/fill_layer.hpp> +#include <mbgl/style/layers/fill_extrusion_layer.hpp> #include <mbgl/style/layers/line_layer.hpp> #include <mbgl/style/layers/symbol_layer.hpp> #include <mbgl/style/layers/raster_layer.hpp> @@ -332,6 +334,8 @@ static NSURL *MGLStyleURL_emerald; if (auto fillLayer = rawLayer->as<mbgl::style::FillLayer>()) { return [[MGLFillStyleLayer alloc] initWithRawLayer:fillLayer]; + } else if (auto fillExtrusionLayer = rawLayer->as<mbgl::style::FillExtrusionLayer>()) { + return [[MGLFillExtrusionStyleLayer alloc] initWithRawLayer:fillExtrusionLayer]; } else if (auto lineLayer = rawLayer->as<mbgl::style::LineLayer>()) { return [[MGLLineStyleLayer alloc] initWithRawLayer:lineLayer]; } else if (auto symbolLayer = rawLayer->as<mbgl::style::SymbolLayer>()) { diff --git a/platform/darwin/src/MGLStyleLayer.h.ejs b/platform/darwin/src/MGLStyleLayer.h.ejs index e29ea4611d..df42621c6d 100644 --- a/platform/darwin/src/MGLStyleLayer.h.ejs +++ b/platform/darwin/src/MGLStyleLayer.h.ejs @@ -161,7 +161,7 @@ which it is added. */ @interface NSValue (MGL<%- camelize(type) %>StyleLayerAdditions) -#pragma mark Working with <%- camelize(type) %> Style Layer Attribute Values +#pragma mark Working with <%- camelize(unhyphenate(type)) %> Style Layer Attribute Values <% for (let property of enumProperties) { -%> /** |