diff options
Diffstat (limited to 'iosApp/WhirlyGlobeMaplyComponent.xcframework/ios-arm64/WhirlyGlobeMaplyComponent.framework/Headers/MaplySharedAttributes.h')
| -rw-r--r-- | iosApp/WhirlyGlobeMaplyComponent.xcframework/ios-arm64/WhirlyGlobeMaplyComponent.framework/Headers/MaplySharedAttributes.h | 406 |
1 files changed, 406 insertions, 0 deletions
diff --git a/iosApp/WhirlyGlobeMaplyComponent.xcframework/ios-arm64/WhirlyGlobeMaplyComponent.framework/Headers/MaplySharedAttributes.h b/iosApp/WhirlyGlobeMaplyComponent.xcframework/ios-arm64/WhirlyGlobeMaplyComponent.framework/Headers/MaplySharedAttributes.h new file mode 100644 index 0000000..00bd24d --- /dev/null +++ b/iosApp/WhirlyGlobeMaplyComponent.xcframework/ios-arm64/WhirlyGlobeMaplyComponent.framework/Headers/MaplySharedAttributes.h @@ -0,0 +1,406 @@ +/* + * MaplySharedAttributes.h + * WhirlyGlobe-MaplyComponent + * + * Created by Steve Gifford on 9/19/12. + * Copyright 2011-2022 mousebird consulting + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#import <Foundation/Foundation.h> + +/// Use this hint to turn the zbuffer on or off. Pass in an NSNumber boolean. Takes effect on the next frame. +extern NSString* const kMaplyRenderHintZBuffer; +#define kWGRenderHintZBuffer kMaplyRenderHintZBuffer +/// Use this hint to turn culling optimization on or off. Pass in an NSNumber boolean. +extern NSString* const kMaplyRenderHintCulling; +#define kWGRenderHintCulling kMaplyRenderHintCulling +/// These are options for lighting modes, basically different default shader programs. Only works with OpenGL ES 2.0 mode. +/// Accepted values are: none,regular +extern NSString* const kMaplyRendererLightingMode; +#define kWGRendererLightingMode kMaplyRendererLightingMode + +/// These are used for all object descriptions. + +/// If the z buffer is on, this will let you resolve. Takes an NSNumber boolean +extern NSString* const kMaplyDrawOffset; +#define kWGDrawOffset kMaplyDrawOffset +/// This helps decide what order things are drawn in. Useful when the z buffer is off or you're using transparency. +/// Takes an NSNumber int. +extern NSString* const kMaplyDrawPriority; +#define kWGDrawPriority kMaplyDrawPriority +/// Minimum point at which a feature is visible. Takes an NSNumber float. The radius of the globe is 1.0 +extern NSString* const kMaplyMinVis; +#define kWGMinVis kMaplyMinVis +/// Maximum point at which a feature is visible. Takes an NSNumber float. The radius of the globe is 1.0 +extern NSString* const kMaplyMaxVis; +#define kWGMaxVis kMaplyMaxVis +/// Minimum distance from the viewer at which to display geometry. +extern NSString* const kMaplyViewerMinDist; +/// Maximum distance from the viewer at which to display geometry. +extern NSString* const kMaplyViewerMaxDist; +/// Center to use when evaluating distance to viewable geometry (X) +extern NSString* const kMaplyViewableCenterX; +/// Center to use when evaluating distance to viewable geometry (Y) +extern NSString* const kMaplyViewableCenterY; +/// Center to use when evaluating distance to viewable geometry (Z) +extern NSString* const kMaplyViewableCenterZ; +/// The amount of time for a feature to fade in or out. Takes an NSNumber float for seconds. +extern NSString* const kMaplyFade; +#define kWGFade kMaplyFade +/// Fade the feature in over time. +extern NSString* const kMaplyFadeIn; +/// Fade the feature out over time +extern NSString* const kMaplyFadeOut; +/// When to start fading out +extern NSString* const kMaplyFadeOutTime; +/// Enable or disable an object. This can be used to create an object disabled. +extern NSString* const kMaplyEnable; +/// If set, we'll enable the objects only between the start and end time +extern NSString* const kMaplyEnableStart; +/// If set, we'll enable the objects only between the start and end time +extern NSString* const kMaplyEnableEnd; +/// Request a given object take the z buffer into account +extern NSString* const kMaplyZBufferRead; +/// Have a given object write itself to the z buffer +extern NSString* const kMaplyZBufferWrite; +/// Set the render target if the given geometry type supports it +extern NSString* const kMaplyRenderTarget; +/// The the UUID of the object +extern NSString* const kMaplyUUID; +/// The representation of the UUID this object embodies +extern NSString* const kMaplyRepresentation; + +/// Assign a shader program to a particular feature. Use the shader program's name +extern NSString* const kMaplyShader; +/// An NSDictionary containing uniforms to apply to a shader before drawing +extern NSString* const kMaplyShaderUniforms; + +/// Keep drawing for this number of frames after we'd normally stop +extern NSString* const kMaplyExtraFrames; + +/// Stars, moon, stars, atmosphere +extern const int kMaplyStarsDrawPriorityDefault; +extern const int kMaplySunDrawPriorityDefault; +extern const int kMaplyMoonDrawPriorityDefault; +extern const int kMaplyAtmosphereDrawPriorityDefault; +/// Where we start image layer draw priorities +extern const int kMaplyImageLayerDrawPriorityDefault; +/// We'll start filling in features right around here +extern const int kMaplyFeatureDrawPriorityBase; +extern const int kMaplyStickerDrawPriorityDefault; +extern const int kMaplyMarkerDrawPriorityDefault; +extern const int kMaplyVectorDrawPriorityDefault; +extern const int kMaplyParticleSystemDrawPriorityDefault ; +extern const int kMaplyLabelDrawPriorityDefault; +extern const int kMaplyLoftedPolysDrawPriorityDefault; +extern const int kMaplyShapeDrawPriorityDefault; +extern const int kMaplyBillboardDrawPriorityDefault; +extern const int kMaplyModelDrawPriorityDefault; +extern const int kMaplyMaxDrawPriorityDefault; + +#define kWGMarkerDrawPriorityDefault kMaplyMarkerDrawPriorityDefault +#define kWGVectorDrawPriorityDefault kMaplyVectorDrawPriorityDefault +#define kWGStickerDrawPriorityDefault kMaplyStickerDrawPriorityDefault + +/// These are used just for the screen and regular labels + +/// Color of the text being rendered. Takes a UIColor. +extern NSString* const kMaplyTextColor; +#define kWGTextColor kMaplyTextColor +/// Background color for the text. Takes a UIColor. +extern NSString* const kMaplyBackgroundColor; +#define kWGBackgroundColor kMaplyBackgroundColor +/// Font to use in rendering text. Takes a UIFont. +extern NSString* const kMaplyFont; +#define kWGFont kMaplyFont +/// Default height of the text. If for screen space, this in points. If for 3D, remember that +// the radius of the globe is 1.0. Expects an NSNumber float. +extern NSString* const kMaplyLabelHeight; +#define kWGLabelHeight kMaplyLabelHeight +/// Default width of the text. See height for more info and, in general, use height instead. +extern NSString* const kMaplyLabelWidth; +#define kWGLabelWidth kMaplyLabelWidth +/// Justification for label placement. This takes an NSString with one of: +/// middle, left, right +extern NSString* const kMaplyJustify; +#define kWGJustify kMaplyJustify +/// If set, we'll draw a shadow behind each label with this as the stroke size +extern NSString* const kMaplyShadowSize; +#define kWGShadowSize kMaplyShadowSize +/// If shadow size is being used, we can control the shadow color like so +extern NSString* const kMaplyShadowColor; +#define kWGShadowColor kMaplyShadowColor +/// If outline is being used, we can control the color +extern NSString* const kMaplyTextOutlineSize; +/// Vertical line spacing. Defaults to the Font's line spacing +extern NSString* const kMaplyTextLineSpacing; +/// If outline is being used, we can control the stroke size +extern NSString* const kMaplyTextOutlineColor; +/// When creating textures, we may pass in the size +extern NSString* const kMaplyTexSizeX; +/// When creating textures, we may pass in the size +extern NSString* const kMaplyTexSizeY; + +/// How to justify multi-line text +extern NSString* const kMaplyTextJustify; +/// Justify text to the right +extern NSString* const kMaplyTextJustifyRight; +/// Justify text to the left +extern NSString* const kMaplyTextJustifyLeft; +/// Justify text to the center +extern NSString* const kMaplyTextJustifyCenter; + +/// Controls how text is laid out along a line or polygon. Set a number (- for left or inside, + for right or outside) +extern NSString* const kMaplyTextLayoutOffset; +/// If laying out along a line (or polygon), the amount of screen space to leave between labels +extern NSString* const kMaplyTextLayoutSpacing; +/// Layout as many labels as possible along a line (or polygon). Set a number (0 for no repeat, -1 for as many as possible, or a number of instances) +extern NSString* const kMaplyTextLayoutRepeat; +/// Turn on debugging lines for the layout engine +extern NSString* const kMaplyTextLayoutDebug; + +/// These are used for screen and regular markers. +extern NSString* const kMaplyClusterGroup; + +/// Color is used for the polygon generated for a marker. It will combine with the image, +/// if there is one or it will be visible if there is no texture. Takes a UIColor +extern NSString* const kMaplyColor; +#define kWGColor kMaplyColor + +/// Width is used by the vector layer for line widths +extern NSString* const kMaplyVecWidth; +#define kWGVecWidth kMaplyVecWidth + +/// If filled is set, we draw the areals as filled polygons +extern NSString* const kMaplyFilled; +#define kWGFilled kMaplyFilled + +/// If set, the texture to apply to the feature +extern NSString* const kMaplyVecTexture; +/// The format of the image given by kMaplyVecTexture, default MaplyImage4Layer8Bit +extern NSString* const kMaplyVecTextureFormat; +/// X scale for textures applied to vectors +extern NSString* const kMaplyVecTexScaleX; +/// Y scale for textures applied to vectors +extern NSString* const kMaplyVecTexScaleY; + +/// The projection to use when generating texture coordinates +extern NSString* const kMaplyVecTextureProjection; +/// Tangent plane projection for texture coordinates +extern NSString* const kMaplyProjectionTangentPlane; +/// Screen space "projection" for texture coordinates +extern NSString* const kMaplyProjectionScreen; +/// No projection for texture coordinates +extern NSString* const kMaplyProjectionNone; + +/// If set to true we'll centered any drawables we create for features +/// This fixes the jittering problem when zoomed in close +extern NSString* const kMaplyVecCentered; + +/// Center of the feature, to use for texture calculations +extern NSString* const kMaplyVecCenterX; +extern NSString* const kMaplyVecCenterY; + +/// For wide vectors, we can widen them in screen space or display space +extern NSString* const kMaplyWideVecCoordType; + +/// Widened vectors are widened in real space. The width is in meters. +extern NSString* const kMaplyWideVecCoordTypeReal; +/// Widened vectors are widened in screen space. The width is in pixels. +extern NSString* const kMaplyWideVecCoordTypeScreen; + +/// Controls the wide vector implementation. Basic implementation by default. +extern NSString* const kMaplyWideVecImpl; + +/// Default/old implementation of the wide vectors +extern NSString* const kMaplyWideVecImplDefault; + +/// Performance implementation of the wide vectors +extern NSString* const kMaplyWideVecImplPerf; + +/// For wide vectors we can control the line joins +/// See: http://www.w3.org/TR/SVG/painting.html#StrokeLinejoinProperty +extern NSString* const kMaplyWideVecJoinType; + +/// Widened vectors are joined with miters +extern NSString* const kMaplyWideVecMiterJoin; +// Note: Not yet implemented +/// Widened vectors are joined with a curve +//extern NSString* const kMaplyWideVecRoundJoin @"round" +/// Widened vectors are joined with a bevel +extern NSString* const kMaplyWideVecBevelJoin; + +/// Number of pixels to use in blending the edges of the wide vectors +extern NSString* const kMaplyWideVecEdgeFalloff; + +/// For wide vectors we can control the ends +/// See: http://www.w3.org/TR/SVG/painting.html#StrokeLinecapProperty +//extern NSString* const kMaplyWideVecLineCapType @"wideveclinecaptype" + +// Note: These are not currently implemented + +/// Widened vector ends are flush +//extern NSString* const kMaplyWideVecButtCap; +/// Widened vector ends are round (e.g. hot dog roads) +//extern NSString* const kMaplyWideVecRoundCap; +/// Widened vector ends are extended a bit and then flush +//extern NSString* const kMaplyWideVecSquareCap; + +/// Miter joins will turn to bevel joins past this number of degrees +extern NSString* const kMaplyWideVecMiterLimit; + +/// This is the length you'd like the texture to start repeating after. +/// It's real world coordinates for kMaplyWideVecCoordTypeReal and pixel size for kMaplyWideVecCoordTypeScreen +extern NSString* const kMaplyWideVecTexRepeatLen; + +/// Offset to left (negative) or right (positive) of the centerline +extern NSString* const kMaplyWideVecOffset; + +/// Close any un-closed areal features when drawing lines for them +extern NSString* const kMaplyVecCloseAreals; + +/// If set we'll break up a vector feature to the given epsilon on a globe surface +extern NSString* const kMaplySubdivEpsilon; +/// If subdiv epsilon is set we'll look for a subdivision type. Default is simple. +extern NSString* const kMaplySubdivType; +/// Subdivide the vector edges along a great circle +extern NSString* const kMaplySubdivGreatCircle; +/// Subdivide the vector edges along a great circle with ellipsoidal math +extern NSString* const kMaplySubdivGreatCirclePrecise; +/// Subdivide into a fixed number of segmenets +extern NSString* const kMaplySubdivStatic; +/// Subdivide the vectors edges along lat/lon +extern NSString* const kMaplySubdivSimple; +/// Clip features along a grid of the given size +extern NSString* const kMaplySubdivGrid; +/// Used to turn off selection in vectors +extern NSString* const kMaplySelectable; + +/// These are used for stickers + +/// Sampling size along one dimension +extern NSString* const kMaplySampleX; +#define kWGSampleX kMaplySampleX +/// Sampling size along one dimension +extern NSString* const kMaplySampleY; +#define kWGSampleY kMaplySampleY +/// Images to use when changing a sticker +extern NSString* const kMaplyStickerImages; +/// Image format to use for the new images +extern NSString* const kMaplyStickerImageFormat; + +/// These are used for billboards + +/// Billboard orientation +extern NSString* const kMaplyBillboardOrient; +/// Billboards are oriented toward the eye, but rotate on the ground +extern NSString* const kMaplyBillboardOrientGround; +/// Billboards are oriented only towards the eye +extern NSString* const kMaplyBillboardOrientEye; + +/// These are used for lofted polygons + +/// Height above the ground +extern NSString* const kMaplyLoftedPolyHeight; +/// Boolean that turns on/off top (on by default) +extern NSString* const kMaplyLoftedPolyTop; +/// Boolean that turns on/off sides (on by default) +extern NSString* const kMaplyLoftedPolySide; +/// If present, we'll start the lofted poly above 0 height +extern NSString* const kMaplyLoftedPolyBase; +/// Grid size we used to chop the lofted polygons up (10 degress by default) +extern NSString* const kMaplyLoftedPolyGridSize; +/// If set to @(YES) this will draw an outline around the top of the lofted poly in lines +extern NSString* const kMaplyLoftedPolyOutline; +/// If set to @(YES) this will draw an outline around the bottom of the lofted poly in lines +extern NSString* const kMaplyLoftedPolyOutlineBottom; +/// If the outline is one this is the outline's color +extern NSString* const kMaplyLoftedPolyOutlineColor; +/// This is the outline's width if it's turned on +extern NSString* const kMaplyLoftedPolyOutlineWidth; +/// Draw priority of the lines created for the lofted poly outline +extern NSString* const kMaplyLoftedPolyOutlineDrawPriority; +/// If set and we're drawing an outline, this will create lines up the sides +extern NSString* const kMaplyLoftedPolyOutlineSide; + +/// These are used for shapes + +/// Samples (x) to use when converting shape to polygons +extern NSString* const kMaplyShapeSampleX; +/// Samples (y) to use when converting shape to polygons +extern NSString* const kMaplyShapeSampleY; +/// If set to true, we'll tessellate a shape using the opposite vertex ordering +extern NSString* const kMaplyShapeInsideOut; +/// Center for the shape geometry +extern NSString* const kMaplyShapeCenterX; +extern NSString* const kMaplyShapeCenterY; +extern NSString* const kMaplyShapeCenterZ; + +/// These are used by active vector objects +extern NSString* const kMaplyVecHeight; +extern NSString* const kMaplyVecMinSample; + +/// These are used by the particle systems +extern NSString* const kMaplyPointSize; +extern const float kMaplyPointSizeDefault; + +/// These are used by the texture +extern NSString* const kMaplyTexFormat; +extern NSString* const kMaplyTexMinFilter; +extern NSString* const kMaplyTexMagFilter; +extern NSString* const kMaplyMinFilterNearest; +extern NSString* const kMaplyMinFilterLinear; +extern NSString* const kMaplyTexAtlas; +extern NSString* const kMaplyTexWrapX; +extern NSString* const kMaplyTexWrapY; +extern NSString* const kMaplyTexMipmap; + +/// These are the various shader programs we set up by default +extern NSString* const kMaplyShaderDefaultTri; +extern NSString* const kMaplyDefaultTriangleShader; +extern NSString* const kMaplyShaderTriExp; + +extern NSString* const kMaplyShaderDefaultModelTri; + +extern NSString* const kMaplyShaderDefaultTriNoLighting; +extern NSString* const kMaplyNoLightTriangleShader; +extern NSString* const kMaplyShaderNoLightTriangleExp; +extern NSString* const kMaplyShaderDefaultMarker; + +extern NSString* const kMaplyShaderDefaultTriScreenTex; + +extern NSString* const kMaplyShaderDefaultTriMultiTex; +extern NSString* const kMaplyShaderDefaultTriMultiTexRamp; +extern NSString* const kMaplyShaderDefaultTriNightDay; + +extern NSString* const kMaplyShaderDefaultLine; +extern NSString* const kMaplyDefaultLineShader; + +extern NSString* const kMaplyShaderDefaultLineNoBackface; +extern NSString* const kMaplyNoBackfaceLineShader; + +extern NSString* const kMaplyShaderBillboardGround; +extern NSString* const kMaplyShaderBillboardEye; + +extern NSString* const kMaplyShaderDefaultWideVector; +extern NSString* const kMaplyShaderWideVectorPerformance; +extern NSString* const kMaplyShaderWideVectorExp; + +extern NSString* const kMaplyScreenSpaceDefaultMotionProgram; +extern NSString* const kMaplyScreenSpaceDefaultProgram; +extern NSString* const kMaplyScreenSpaceMaskProgram; +extern NSString* const kMaplyScreenSpaceExpProgram; + +extern NSString* const kMaplyShaderParticleSystemPointDefault; |