Updated Interfaces and methods to reflect new methods for setting and…

… creating new layers. LayerFilter now extends MapboxDataProperty; CoreVectorLayerProperties registers and unregisters LayerFilters.PropertyHasChanged, called from VectorLayerVisualizer.SetProperties and VectorLayerVisualizer.UpdateVector. Property drawer for filter business now sets LayerFilters.PropertyHasChanged directly.

sdkproject/Assets/ApiFilterTest.cs

@@ -26,7 +26,6 @@ public class ApiFilterTest : MonoBehaviour
 	void Start()
 	{
 		_abstractMap = FindObjectOfType<AbstractMap>();
-		//_layers = _abstractMap.VectorData.GetAllFeatureLayers().ToArray();
 	}
 
 	private VectorSubLayerProperties[] GetLayers()
@@ -51,36 +50,6 @@ private void DebugFilterInfo(LayerFilter layerFilter)
 		Debug.Log("Min/Max : " + layerFilter.Min + ", " + layerFilter.Max);
 	}
 
-	[ContextMenu("Add Filter")]
-	public void AddFilters()
-	{
-		VectorSubLayerProperties[] layers = GetLayers();
-		for (int i = 0; i < layers.Length; i++)
-		{
-			VectorSubLayerProperties vectorSubLayerProperties = layers[i];
-			vectorSubLayerProperties.Filtering.AddFilter();
-		}
-	}
-
-	[ContextMenu("Add Filter With Everything")]
-	public void AddFiltersWithEverything()
-	{
-		VectorSubLayerProperties[] layers = GetLayers();
-		for (int i = 0; i < layers.Length; i++)
-		{
-			VectorSubLayerProperties vectorSubLayerProperties = layers[i];
-			LayerFilterBundle layerFilterBundle = new LayerFilterBundle()
-			{
-				key = Key,
-				layerFilterOperationType = layerFilterOperationType,
-				propertyValue = property,
-				min = min,
-				max = max
-			};
-			vectorSubLayerProperties.Filtering.AddFilter(layerFilterBundle);
-		}
-	}
-
 	[ContextMenu("Check Filter ALL")]
 	public void CheckFilterAll()
 	{
@@ -281,8 +250,8 @@ public void CheckFilterNumValueIsGreater()
 		}
 	}
 
-	[ContextMenu("Set Filter Keys")]
-	public void SetFilterKeys()
+	[ContextMenu("Set String Contains")]
+	public void SetStringContains()
 	{
 		VectorSubLayerProperties[] layers = GetLayers();
 		for (int i = 0; i < layers.Length; i++)
@@ -291,13 +260,13 @@ public void SetFilterKeys()
 			if (filters.Length != 0)
 			{
 				LayerFilter layerFilter = filters[i];
-				layerFilter.SetKey(Key);
+				layerFilter.SetStringContains(Key, property);
 			}
 		}
 	}
 
-	[ContextMenu("Set Filter Operators")]
-	public void SetFilterOperators()
+	[ContextMenu("Set Number Is Equal")]
+	public void SetNumberIsEqual()
 	{
 		VectorSubLayerProperties[] layers = GetLayers();
 		for (int i = 0; i < layers.Length; i++)
@@ -306,28 +275,28 @@ public void SetFilterOperators()
 			if (filters.Length != 0)
 			{
 				LayerFilter layerFilter = filters[i]; 
-				layerFilter.SetFilterOperationType(layerFilterOperationType);
+				layerFilter.SetNumberIsEqual(Key, min);
 			}
 		}
 	}
 
-	[ContextMenu("Set Filter Equals")]
-	public void SetFilterEquals()
+	[ContextMenu("Set Number Is Less Than")]
+	public void SetNumberIsLessThan()
 	{
 		VectorSubLayerProperties[] layers = GetLayers();
 		for (int i = 0; i < layers.Length; i++)
 		{
 			LayerFilter[] filters = layers[i].Filtering.GetAllFilters().ToArray();
 			if (filters.Length != 0)
 			{
-				LayerFilter layerFilter = filters[i];
-				layerFilter.SetIsEqual(min);
+				LayerFilter layerFilter = filters[i]; 
+				layerFilter.SetNumberIsLessThan(Key, min);
 			}
 		}
 	}
 
-	[ContextMenu("Set Filter Less Than")]
-	public void SetFilterLessThan()
+	[ContextMenu("Set Number Is Greater Than")]
+	public void SetNumberIsGreaterThan()
 	{
 		VectorSubLayerProperties[] layers = GetLayers();
 		for (int i = 0; i < layers.Length; i++)
@@ -336,13 +305,13 @@ public void SetFilterLessThan()
 			if (filters.Length != 0)
 			{
 				LayerFilter layerFilter = filters[i];
-				layerFilter.SetIsLessThan(min);
+				layerFilter.SetNumberIsGreaterThan(Key, min);
 			}
 		}
 	}
 
-	[ContextMenu("Set Filter Greater Than")]
-	public void SetFilterGreaterThan()
+	[ContextMenu("Set Number Is In Range")]
+	public void SetNumberIsInRange()
 	{
 		VectorSubLayerProperties[] layers = GetLayers();
 		for (int i = 0; i < layers.Length; i++)
@@ -351,23 +320,48 @@ public void SetFilterGreaterThan()
 			if (filters.Length != 0)
 			{
 				LayerFilter layerFilter = filters[i];
-				layerFilter.SetIsGreaterThan(min);
+				layerFilter.SetNumberIsInRange(Key, min, max);
 			}
 		}
 	}
 
-	[ContextMenu("Set Filter In Range")]
-	public void SetFilterInRange()
+	[ContextMenu("Add String Filter Contains")]
+	public void AddStringFilterContains()
 	{
 		VectorSubLayerProperties[] layers = GetLayers();
 		for (int i = 0; i < layers.Length; i++)
 		{
-			LayerFilter[] filters = layers[i].Filtering.GetAllFilters().ToArray();
-			if (filters.Length != 0)
-			{
-				LayerFilter layerFilter = filters[i];
-				layerFilter.SetIsInRange(min, max);
-			}
+			layers[i].Filtering.AddStringFilterContains(Key, property);
+		}
+	}
+
+	[ContextMenu("Add Numeric Filter Equals")]
+	public void AddNumericFilterEquals()
+	{
+		VectorSubLayerProperties[] layers = GetLayers();
+		for (int i = 0; i < layers.Length; i++)
+		{
+			layers[i].Filtering.AddNumericFilterEquals(Key, min);
+		}
+	}
+
+	[ContextMenu("Add Numeric Filter Is Less Than")]
+	public void AddNumericFilterLessThan()
+	{
+		VectorSubLayerProperties[] layers = GetLayers();
+		for (int i = 0; i < layers.Length; i++)
+		{
+			layers[i].Filtering.AddNumericFilterLessThan(Key, min);
+		}
+	}
+
+	[ContextMenu("Add Numeric Filter Is Greater Than")]
+	public void AddNumericFilterGreaterThan()
+	{
+		VectorSubLayerProperties[] layers = GetLayers();
+		for (int i = 0; i < layers.Length; i++)
+		{
+			layers[i].Filtering.AddNumericFilterGreaterThan(Key, min);
 		}
 	}
-}
+}

sdkproject/Assets/Mapbox/Unity/Editor/PropertyDrawers/VectorFilterOptionsDrawer.cs

@@ -39,6 +39,7 @@ bool showFilters
 		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
 		{
 			objectId = property.serializedObject.targetObject.GetInstanceID().ToString();
+			VectorFilterOptions options = (VectorFilterOptions)EditorHelper.GetTargetObjectOfProperty(property);
 
 			showFilters = EditorGUILayout.Foldout(showFilters, new GUIContent { text = "Filters", tooltip = "Filter features in a vector layer based on criterion specified.  " });
 			if (showFilters)
@@ -47,10 +48,7 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
 
 				for (int i = 0; i < propertyFilters.arraySize; i++)
 				{
-					if(DrawLayerFilter(property, propertyFilters, i))
-					{
-						EditorHelper.CheckForModifiedProperty(property);
-					}
+					DrawLayerFilter(property, propertyFilters, i, options);
 				}
 				if (propertyFilters.arraySize > 0)
 				{
@@ -68,7 +66,7 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
 				EditorGUI.BeginChangeCheck();
 				if (GUILayout.Button(new GUIContent("Add New Empty"), (GUIStyle)"minibutton"))
 				{
-					propertyFilters.arraySize++;
+					options.AddFilter();
 				}
 				if (EditorGUI.EndChangeCheck())
 				{
@@ -84,10 +82,10 @@ public override float GetPropertyHeight(SerializedProperty property, GUIContent
 			return lineHeight;
 		}
 
-		private bool DrawLayerFilter(SerializedProperty originalProperty, SerializedProperty propertyFilters, int index)
+		private void DrawLayerFilter(SerializedProperty originalProperty, SerializedProperty propertyFilters, int index, VectorFilterOptions vectorFilterOptions)
 		{
-			bool hasChanged = false;
 			var property = propertyFilters.GetArrayElementAtIndex(index);
+
 			var filterOperatorProp = property.FindPropertyRelative("filterOperator");
 
 			EditorGUILayout.BeginVertical();
@@ -96,7 +94,6 @@ private bool DrawLayerFilter(SerializedProperty originalProperty, SerializedProp
 
 			EditorGUILayout.LabelField(new GUIContent { text = "Key", tooltip = "Name of the property to use as key. This property is case sensitive." }, GUILayout.MaxWidth(150));
 
-
 			switch ((LayerFilterOperationType)filterOperatorProp.enumValueIndex)
 			{
 				case LayerFilterOperationType.IsEqual:
@@ -124,16 +121,15 @@ private bool DrawLayerFilter(SerializedProperty originalProperty, SerializedProp
 
 			var selectedLayerName = originalProperty.FindPropertyRelative("_selectedLayerName").stringValue;
 
-			if(DrawPropertyDropDown(originalProperty, property))
-			{
-				hasChanged = true;
-			}
+			LayerFilter layerFilter = (LayerFilter)EditorHelper.GetTargetObjectOfProperty(property);
+
+			DrawPropertyDropDown(originalProperty, property, layerFilter);
 
 			EditorGUI.BeginChangeCheck();
 			filterOperatorProp.enumValueIndex = EditorGUILayout.Popup(filterOperatorProp.enumValueIndex, filterOperatorProp.enumDisplayNames, GUILayout.MaxWidth(150));
 			if (EditorGUI.EndChangeCheck())
 			{
-				hasChanged = true;
+				layerFilter.HasChanged = true;
 			}
 
 			EditorGUI.BeginChangeCheck();
@@ -156,29 +152,21 @@ private bool DrawLayerFilter(SerializedProperty originalProperty, SerializedProp
 			}
 			if (EditorGUI.EndChangeCheck())
 			{
-				hasChanged = true;
+				layerFilter.HasChanged = true;
 			}
 
-			EditorGUI.BeginChangeCheck();
 			if (GUILayout.Button(new GUIContent(" X "), (GUIStyle)"minibuttonright", GUILayout.Width(30)))
 			{
-				propertyFilters.DeleteArrayElementAtIndex(index);
-			}
-			if (EditorGUI.EndChangeCheck())
-			{
-				hasChanged = true;
+				vectorFilterOptions.DeleteFilter(index);
 			}
 
 			EditorGUILayout.EndHorizontal();
 
 			EditorGUILayout.EndVertical();
-
-			return hasChanged;
 		}
 
-		private bool DrawPropertyDropDown(SerializedProperty originalProperty, SerializedProperty filterProperty)
+		private void DrawPropertyDropDown(SerializedProperty originalProperty, SerializedProperty filterProperty, LayerFilter layerFilter)
 		{
-			bool hasChanged = false;
 
 			var selectedLayerName = originalProperty.FindPropertyRelative("_selectedLayerName").stringValue;
 			AbstractMap mapObject = (AbstractMap)originalProperty.serializedObject.targetObject;
@@ -187,7 +175,7 @@ private bool DrawPropertyDropDown(SerializedProperty originalProperty, Serialize
 			if (string.IsNullOrEmpty(selectedLayerName) || !tileJsonData.PropertyDisplayNames.ContainsKey(selectedLayerName))
 			{
 				DrawWarningMessage();
-				return false;
+				return;
 			}
 
 			var parsedString = "no property selected";
@@ -219,7 +207,7 @@ private bool DrawPropertyDropDown(SerializedProperty originalProperty, Serialize
 				_propertyIndex = EditorGUILayout.Popup(_propertyIndex, _propertyNameContent, GUILayout.MaxWidth(150));
 				if (EditorGUI.EndChangeCheck())
 				{
-					hasChanged = true;
+					layerFilter.HasChanged = true;
 				}
 
 				//set new string values based on selection
@@ -258,7 +246,7 @@ private bool DrawPropertyDropDown(SerializedProperty originalProperty, Serialize
 				_propertyIndex = EditorGUILayout.Popup(_propertyIndex, _propertyNameContent, GUILayout.MaxWidth(150));
 				if (EditorGUI.EndChangeCheck())
 				{
-					hasChanged = true;
+					layerFilter.HasChanged = true;
 				}
 
 				//set new string values based on the offset
@@ -270,11 +258,9 @@ private bool DrawPropertyDropDown(SerializedProperty originalProperty, Serialize
 			filterProperty.FindPropertyRelative("Key").stringValue = parsedString;
 			if (EditorGUI.EndChangeCheck())
 			{
-				hasChanged = true;
+				layerFilter.HasChanged = true;
 			}
 			filterProperty.FindPropertyRelative("KeyDescription").stringValue = descriptionString;
-
-			return hasChanged;
 		}
 
 		private void DrawWarningMessage()

sdkproject/Assets/Mapbox/Unity/LayerProperties/CoreVectorLayerProperties.cs

@@ -47,21 +47,126 @@ public class VectorFilterOptions : MapboxDataProperty, ISubLayerFiltering
 		[Tooltip("Operator to combine filters. ")]
 		public LayerFilterCombinerOperationType combinerType = LayerFilterCombinerOperationType.All;
 
-		public virtual void AddFilter(LayerFilterOperationType filterOperation = LayerFilterOperationType.Contains)
+		public override bool HasChanged
+		{
+			set
+			{
+				if (value == true)
+				{
+					OnPropertyHasChanged(new VectorLayerUpdateArgs { property = this });
+				}
+			}
+		}
+
+		public void UnRegisterFilters()
+		{
+			for (int i = 0; i < filters.Count; i++)
+			{
+				filters[i].PropertyHasChanged -= OnLayerFilterChanged;
+			}
+		}
+
+		public void RegisterFilters()
+		{
+			for (int i = 0; i < filters.Count; i++)
+			{
+				filters[i].PropertyHasChanged += OnLayerFilterChanged;
+			}
+		}
+
+		private void OnLayerFilterChanged(object sender, System.EventArgs eventArgs)
+		{
+			HasChanged = true;
+		}
+
+		private void AddFilterToList(LayerFilter layerFilter)
+		{
+			filters.Add(layerFilter);
+			HasChanged = true;
+		}
+
+		public virtual LayerFilter AddStringFilterContains(string key, string property)
 		{
-			filters.Add(new LayerFilter(filterOperation));
+			LayerFilter layerFilter = new LayerFilter()
+			{
+				Key = key,
+				filterOperator = LayerFilterOperationType.Contains,
+				PropertyValue = property
+			};
+			AddFilterToList(layerFilter);
+			return layerFilter;
+
 		}
 
-		public virtual void AddFilter(LayerFilterBundle layerFilterBundle)
+		public virtual LayerFilter AddNumericFilterEquals(string key, float value)
 		{
-			filters.Add(new LayerFilter(layerFilterBundle));
+			LayerFilter layerFilter = new LayerFilter()
+			{
+				Key = key,
+				filterOperator = LayerFilterOperationType.IsEqual,
+				Min = value
+			};
+			AddFilterToList(layerFilter);
+			return layerFilter;
+		}
+
+		public virtual LayerFilter AddNumericFilterLessThan(string key, float value)
+		{
+			LayerFilter layerFilter = new LayerFilter()
+			{
+				Key = key,
+				filterOperator = LayerFilterOperationType.IsLess,
+				Min = value
+			};
+			AddFilterToList(layerFilter);
+			return layerFilter;
+		}
+
+		public virtual LayerFilter AddNumericFilterGreaterThan(string key, float value)
+		{
+			LayerFilter layerFilter = new LayerFilter()
+			{
+				Key = key,
+				filterOperator = LayerFilterOperationType.IsGreater,
+				Min = value
+			};
+			AddFilterToList(layerFilter);
+			return layerFilter;
+		}
+
+		public virtual LayerFilter AddNumericFilterInRange(string key, float min, float max)
+		{
+			LayerFilter layerFilter = new LayerFilter()
+			{
+				Key = key,
+				filterOperator = LayerFilterOperationType.IsInRange,
+				Min = min,
+				Max = max
+			};
+			AddFilterToList(layerFilter);
+			return layerFilter;
+		}
+
+		public void AddFilter()
+		{
+			AddFilterToList(new LayerFilter());
+		}
+
+		public virtual void DeleteFilter(LayerFilter layerFilter)
+		{
+			layerFilter.PropertyHasChanged -= OnLayerFilterChanged;
+			if(filters.Contains(layerFilter))
+			{
+				filters.Remove(layerFilter);
+				HasChanged = true;
+			}
 		}
 
 		public virtual void DeleteFilter(int index)
 		{
 			if (index < filters.Count && filters[index] != null)
 			{
-				filters.RemoveAt(index);
+				DeleteFilter(filters[index]);
 			}
 		}
 

sdkproject/Assets/Mapbox/Unity/MeshGeneration/Filters/TypeFilter.cs

@@ -290,17 +290,8 @@ protected override bool PropertyComparer(object property)
 		}
 	}
 
-	public class LayerFilterBundle
-	{
-		public string key;
-		public LayerFilterOperationType layerFilterOperationType;
-		public string propertyValue;
-		public float min;
-		public float max;
-	}
-
 	[Serializable]
-	public class LayerFilter : ISubLayerFilteringOptions
+	public class LayerFilter : MapboxDataProperty, ISubLayerFilteringOptions
 	{
 		[Tooltip("Name of the property to use as key. This property is case sensitive.")]
 		public string Key;
@@ -315,18 +306,10 @@ public class LayerFilter : ISubLayerFilteringOptions
 		[Tooltip("Filter operator to apply. ")]
 		public LayerFilterOperationType filterOperator;
 		private char[] _delimiters = new char[] { ',' };
-		public LayerFilter(LayerFilterOperationType filterOperation)
-		{
-			filterOperator = filterOperation;
-		}
 
-		public LayerFilter(LayerFilterBundle layerFilterBundle)
+		public LayerFilter(LayerFilterOperationType filterOperation = LayerFilterOperationType.Contains)
 		{
-			Key = layerFilterBundle.key;
-			filterOperator = layerFilterBundle.layerFilterOperationType;
-			PropertyValue = layerFilterBundle.propertyValue;
-			Min = layerFilterBundle.min;
-			Max = layerFilterBundle.max;;
+			filterOperator = filterOperation;
 		}
 
 		public ILayerFeatureFilterComparer GetFilterComparer()
@@ -365,106 +348,158 @@ public ILayerFeatureFilterComparer GetFilterComparer()
 			return filterComparer;
 		}
 
-		public virtual void SetKey(string key = "")
-		{
-			Key = key;
-		}
-
-		public virtual void SetFilterOperationType(LayerFilterOperationType layerFilterOperationType)
-		{
-			switch (layerFilterOperationType)
-			{
-				case (LayerFilterOperationType.Contains):
-					SetContains();
-					break;
-				case (LayerFilterOperationType.IsEqual):
-					SetIsEqual();
-					break;
-				case (LayerFilterOperationType.IsLess):
-					SetIsLessThan();
-					break;
-				case (LayerFilterOperationType.IsGreater):
-					SetIsGreaterThan();
-					break;
-				case (LayerFilterOperationType.IsInRange):
-					SetIsInRange();
-					break;
-				default:
-					break;
-			}
-		}
-
-		public virtual void SetContains(string property = "")
+		/// <summary>
+		/// Sets the string contains.
+		/// </summary>
+		/// <param name="key">Key.</param>
+		/// <param name="property">Property.</param>
+		public virtual void SetStringContains(string key, string property)
 		{
 			filterOperator = LayerFilterOperationType.Contains;
-			PropertyValue = string.IsNullOrEmpty(property) ? PropertyValue : property;
+			Key = key;
+			PropertyValue = property;
+			HasChanged = true;
 		}
 
-		public virtual void SetIsEqual(float? value = null)
+		/// <summary>
+		/// Sets the number is equal.
+		/// </summary>
+		/// <param name="key">Key.</param>
+		/// <param name="value">Value.</param>
+		public virtual void SetNumberIsEqual(string key, float value)
 		{
 			filterOperator = LayerFilterOperationType.IsEqual;
-			Min = (value == null) ? Min : (float)value;
+			Key = key;
+			Min = value;
+			HasChanged = true;
 		}
 
-		public virtual void SetIsLessThan(float? value = null)
+		/// <summary>
+		/// Sets the number is less than.
+		/// </summary>
+		/// <param name="key">Key.</param>
+		/// <param name="value">Value.</param>
+		public virtual void SetNumberIsLessThan(string key, float value)
 		{
 			filterOperator = LayerFilterOperationType.IsLess;
-			Min = (value == null) ? Min : (float)value;
+			Key = key;
+			Min = value;
+			HasChanged = true;
 		}
 
-		public virtual void SetIsGreaterThan(float? value = null)
+		/// <summary>
+		/// Sets the number is greater than.
+		/// </summary>
+		/// <param name="key">Key.</param>
+		/// <param name="value">Value.</param>
+		public virtual void SetNumberIsGreaterThan(string key, float value)
 		{
 			filterOperator = LayerFilterOperationType.IsGreater;
-			Min = (value == null) ? Min : (float)value;
+			Key = key;
+			Min = value;
+			HasChanged = true;
 		}
 
-		public virtual void SetIsInRange(float? min = null, float? max = null)
+		/// <summary>
+		/// Sets the number is in range.
+		/// </summary>
+		/// <param name="key">Key.</param>
+		/// <param name="min">Minimum.</param>
+		/// <param name="max">Max.</param>
+		public virtual void SetNumberIsInRange(string key, float min, float max)
 		{
 			filterOperator = LayerFilterOperationType.IsInRange;
-			Min = (min == null) ? Min : (float)min;
-			Max = (max == null) ? Max : (float)max;
+			Key = key;
+			Min = min;
+			Max = max;
+			HasChanged = true;
 		}
 
+		/// <summary>
+		/// Returns true if filter key contains a given string.
+		/// </summary>
+		/// <returns><c>true</c>, if key contains was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="key">Key.</param>
 		public virtual bool FilterKeyContains(string key)
 		{
 			return Key.Contains(key);
 		}
 
+		/// <summary>
+		/// Returns true if filter key matches a given string exactly.
+		/// </summary>
+		/// <returns><c>true</c>, if key matches exact was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="key">Key.</param>
 		public virtual bool FilterKeyMatchesExact(string key)
 		{
 			return Key == key;
 		}
 
+		/// <summary>
+		/// Returns true if filter uses a given operation type.
+		/// </summary>
+		/// <returns><c>true</c>, if uses operation type was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="layerFilterOperationType">Layer filter operation type.</param>
 		public virtual bool FilterUsesOperationType(LayerFilterOperationType layerFilterOperationType)
 		{
 			return filterOperator == layerFilterOperationType;
 		}
 
+		/// <summary>
+		/// Returns true if filter property contains a given string.
+		/// </summary>
+		/// <returns><c>true</c>, if property contains was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="property">Property.</param>
 		public virtual bool FilterPropertyContains(string property)
 		{
 			return PropertyValue.Contains(property);
 		}
 
+		/// <summary>
+		/// Returns true if filter property matches a given string exactly.
+		/// </summary>
+		/// <returns><c>true</c>, if property matches exact was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="property">Property.</param>
 		public virtual bool FilterPropertyMatchesExact(string property)
 		{
 			return PropertyValue == property;
 		}
 
+		/// <summary>
+		/// Returns true if filter number value is equal to a given number.
+		/// </summary>
+		/// <returns><c>true</c>, if number value equals was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="value">Value.</param>
 		public virtual bool FilterNumberValueEquals(float value)
 		{
 			return Mathf.Approximately(Min, value);
 		}
 
+		/// <summary>
+		/// Returns true if filter number value is greater than a given number.
+		/// </summary>
+		/// <returns><c>true</c>, if number value is greater than was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="value">Value.</param>
 		public virtual bool FilterNumberValueIsGreaterThan(float value)
 		{
 			return Min > value;
 		}
 
+		/// <summary>
+		/// Returns true if filter number value is less than a given number.
+		/// </summary>
+		/// <returns><c>true</c>, if number value is less than was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="value">Value.</param>
 		public virtual bool FilterNumberValueIsLessThan(float value)
 		{
 			return Min < value;
 		}
 
+		/// <summary>
+		/// Returns true if filter range values contain a given number.
+		/// </summary>
+		/// <returns><c>true</c>, if is in range value contains was filtered, <c>false</c> otherwise.</returns>
+		/// <param name="value">Value.</param>
 		public virtual bool FilterIsInRangeValueContains(float value)
 		{
 			return Min < value && value < Max;

sdkproject/Assets/Mapbox/Unity/MeshGeneration/LayerVisualizers/VectorLayerVisualizer.cs

@@ -135,6 +135,8 @@ private void UpdateVector(object sender, System.EventArgs eventArgs)
 
 			_layerProperties.extrusionOptions.PropertyHasChanged -= UpdateVector;
 			_layerProperties.coreOptions.PropertyHasChanged -= UpdateVector;
+			_layerProperties.filterOptions.PropertyHasChanged -= UpdateVector;
+			_layerProperties.filterOptions.UnRegisterFilters();
 			_layerProperties.materialOptions.PropertyHasChanged -= UpdateVector;
 
 			OnUpdateLayerVisualizer(layerUpdateArgs);
@@ -300,7 +302,9 @@ public override void SetProperties(VectorSubLayerProperties properties)
 			}
 
 			_layerProperties.coreOptions.PropertyHasChanged += UpdateVector;
+			_layerProperties.filterOptions.PropertyHasChanged += UpdateVector;
 
+			_layerProperties.filterOptions.RegisterFilters();
 			if (_layerProperties.MeshModifiers != null)
 			{
 				_defaultStack.MeshModifiers.AddRange(_layerProperties.MeshModifiers);

sdkproject/Assets/Mapbox/Unity/SourceLayers/ILayer.cs

@@ -58,8 +58,11 @@ public interface ISubLayerPolygonGeometryOptions
 
 	public interface ISubLayerFiltering
 	{
-		void AddFilter(LayerFilterOperationType filterOperation = LayerFilterOperationType.Contains);
-		void AddFilter(LayerFilterBundle layerFilterBundle);
+		LayerFilter AddStringFilterContains(string key, string property);
+		LayerFilter AddNumericFilterEquals(string key, float value);
+		LayerFilter AddNumericFilterLessThan(string key, float value);
+		LayerFilter AddNumericFilterGreaterThan(string key, float value);
+		LayerFilter AddNumericFilterInRange(string key, float min, float max);
 
 		LayerFilter GetFilter(int index);
 		void DeleteFilter(int index);
@@ -84,13 +87,12 @@ public interface ISubLayerFilteringOptions
 		bool FilterNumberValueIsLessThan(float value);
 		bool FilterIsInRangeValueContains(float value);
 
-		void SetKey(string key = "");
-		void SetFilterOperationType(LayerFilterOperationType layerFilterOperationType);
-		void SetContains(string property = "");
-		void SetIsEqual(float? value = null);
-		void SetIsLessThan(float? value = null);
-		void SetIsGreaterThan(float? value = null);
-		void SetIsInRange(float? min = null, float? max = null);
+		void SetStringContains(string key, string property);
+		void SetNumberIsEqual(string key, float value);
+		void SetNumberIsLessThan(string key, float value);
+		void SetNumberIsGreaterThan(string key, float value);
+		void SetNumberIsInRange(string key, float min, float max);
+
 	}
 
 	public interface ISubLayerModeling :