// height in meters
public static void AssignBuildings(Building type, float min, float max, AbstractMap map, bool combineMesh = false)
{
if (type == Building.Road)
{
return;
}
VectorSubLayerProperties vectorSubLayerProperties = new VectorSubLayerProperties();
vectorSubLayerProperties.colliderOptions.colliderType = ColliderType.MeshCollider;
vectorSubLayerProperties.coreOptions.combineMeshes = false;
vectorSubLayerProperties.coreOptions.geometryType = VectorPrimitiveType.Polygon;
vectorSubLayerProperties.coreOptions.layerName = "building";
vectorSubLayerProperties.coreOptions.snapToTerrain = true;
vectorSubLayerProperties.coreOptions.combineMeshes = combineMesh;
vectorSubLayerProperties.extrusionOptions.extrusionType = ExtrusionType.PropertyHeight;
vectorSubLayerProperties.extrusionOptions.extrusionScaleFactor = 1.3203f;
vectorSubLayerProperties.extrusionOptions.propertyName = "height";
vectorSubLayerProperties.extrusionOptions.extrusionGeometryType = ExtrusionGeometryType.RoofAndSide;
vectorSubLayerProperties.moveFeaturePositionTo = PositionTargetType.CenterOfVertices;
vectorSubLayerProperties.coreOptions.sublayerName = type.ToString();
string atlasPath = "Atlases/" + type.ToString() + "BuildingAtlas";
AtlasInfo atlasInfo = Resources.Load(atlasPath) as AtlasInfo;
Material material = Resources.Load(Constants.buildingMaterialPath) as Material;
GeometryMaterialOptions materialOptions = new GeometryMaterialOptions();
materialOptions.SetDefaultMaterialOptions();
materialOptions.customStyleOptions.texturingType = UvMapType.Atlas;
materialOptions.customStyleOptions.materials[0].Materials[0] = material;
materialOptions.customStyleOptions.materials[1].Materials[0] = material;
materialOptions.customStyleOptions.atlasInfo = atlasInfo;
materialOptions.SetStyleType(StyleTypes.Custom);
vectorSubLayerProperties.materialOptions = materialOptions;
vectorSubLayerProperties.buildingsWithUniqueIds = true;
if (min < 100)
{
vectorSubLayerProperties.filterOptions.AddNumericFilterInRange("height", min, max);
vectorSubLayerProperties.filterOptions.AddNumericFilterEquals("height", max);
}
else
{
vectorSubLayerProperties.filterOptions.AddNumericFilterGreaterThan("height", min);
}
map.VectorData.AddFeatureSubLayer(vectorSubLayerProperties);
}
public SubLayerSimpleStyle(GeometryMaterialOptions materialOptions)
{
_materialOptions = materialOptions;
}
public SubLayerFantasyStyle(GeometryMaterialOptions materialOptions)
{
_materialOptions = materialOptions;
}
/// <summary>
/// Sets the sub layer properties for the newly added layer
/// </summary>
/// <param name="subLayer">Sub layer.</param>
void SetSubLayerProps(SerializedProperty subLayer)
{
subLayer.FindPropertyRelative("coreOptions.sublayerName").stringValue = subLayerProperties.coreOptions.sublayerName;
subLayer.FindPropertyRelative("presetFeatureType").enumValueIndex = (int)subLayerProperties.presetFeatureType;
// Set defaults here because SerializedProperty copies the previous element.
var subLayerCoreOptions = subLayer.FindPropertyRelative("coreOptions");
CoreVectorLayerProperties coreOptions = subLayerProperties.coreOptions;
subLayerCoreOptions.FindPropertyRelative("isActive").boolValue = coreOptions.isActive;
subLayerCoreOptions.FindPropertyRelative("layerName").stringValue = coreOptions.layerName;
subLayerCoreOptions.FindPropertyRelative("geometryType").enumValueIndex = (int)coreOptions.geometryType;
subLayerCoreOptions.FindPropertyRelative("snapToTerrain").boolValue = coreOptions.snapToTerrain;
subLayerCoreOptions.FindPropertyRelative("combineMeshes").boolValue = coreOptions.combineMeshes;
subLayerCoreOptions.FindPropertyRelative("lineWidth").floatValue = coreOptions.lineWidth;
var subLayerExtrusionOptions = subLayer.FindPropertyRelative("extrusionOptions");
var extrusionOptions = subLayerProperties.extrusionOptions;
subLayerExtrusionOptions.FindPropertyRelative("extrusionType").enumValueIndex = (int)extrusionOptions.extrusionType;
subLayerExtrusionOptions.FindPropertyRelative("extrusionGeometryType").enumValueIndex = (int)extrusionOptions.extrusionGeometryType;
subLayerExtrusionOptions.FindPropertyRelative("propertyName").stringValue = extrusionOptions.propertyName;
subLayerExtrusionOptions.FindPropertyRelative("extrusionScaleFactor").floatValue = extrusionOptions.extrusionScaleFactor;
var subLayerFilterOptions = subLayer.FindPropertyRelative("filterOptions");
var filterOptions = subLayerProperties.filterOptions;
subLayerFilterOptions.FindPropertyRelative("filters").ClearArray();
subLayerFilterOptions.FindPropertyRelative("combinerType").enumValueIndex = (int)filterOptions.combinerType;
//Add any future filter related assignments here
var subLayerGeometryMaterialOptions = subLayer.FindPropertyRelative("materialOptions");
var materialOptions = subLayerProperties.materialOptions;
subLayerGeometryMaterialOptions.FindPropertyRelative("style").enumValueIndex = (int)materialOptions.style;
GeometryMaterialOptions geometryMaterialOptionsReference = MapboxDefaultStyles.GetDefaultAssets();
var mats = subLayerGeometryMaterialOptions.FindPropertyRelative("materials");
mats.arraySize = 2;
var topMatArray = mats.GetArrayElementAtIndex(0).FindPropertyRelative("Materials");
var sideMatArray = mats.GetArrayElementAtIndex(1).FindPropertyRelative("Materials");
if (topMatArray.arraySize == 0)
{
topMatArray.arraySize = 1;
}
if (sideMatArray.arraySize == 0)
{
sideMatArray.arraySize = 1;
}
var topMat = topMatArray.GetArrayElementAtIndex(0);
var sideMat = sideMatArray.GetArrayElementAtIndex(0);
var atlas = subLayerGeometryMaterialOptions.FindPropertyRelative("atlasInfo");
var palette = subLayerGeometryMaterialOptions.FindPropertyRelative("colorPalette");
topMat.objectReferenceValue = geometryMaterialOptionsReference.materials[0].Materials[0];
sideMat.objectReferenceValue = geometryMaterialOptionsReference.materials[1].Materials[0];
atlas.objectReferenceValue = geometryMaterialOptionsReference.atlasInfo;
palette.objectReferenceValue = geometryMaterialOptionsReference.colorPalette;
subLayer.FindPropertyRelative("buildingsWithUniqueIds").boolValue = subLayerProperties.buildingsWithUniqueIds;
subLayer.FindPropertyRelative("moveFeaturePositionTo").enumValueIndex = (int)subLayerProperties.moveFeaturePositionTo;
subLayer.FindPropertyRelative("MeshModifiers").ClearArray();
subLayer.FindPropertyRelative("GoModifiers").ClearArray();
var subLayerColliderOptions = subLayer.FindPropertyRelative("colliderOptions");
subLayerColliderOptions.FindPropertyRelative("colliderType").enumValueIndex = (int)subLayerProperties.colliderOptions.colliderType;
}
public override void SetProperties(ModifierProperties properties)
{
_options = (GeometryMaterialOptions)properties;
}
public SubLayerLightStyle(GeometryMaterialOptions materialOptions)
{
_materialOptions = materialOptions;
}
public override void SetProperties(ModifierProperties properties)
{
_options = (GeometryMaterialOptions)properties;
_options.PropertyHasChanged += UpdateModifier;
}
public void SetProperties(VectorSubLayerProperties properties, LayerPerformanceOptions performanceOptions)
{
List <MeshModifier> defaultMeshModifierStack = new List <MeshModifier>();
List <GameObjectModifier> defaultGOModifierStack = new List <GameObjectModifier>();
_layerProperties = properties;
_performanceOptions = performanceOptions;
Active = _layerProperties.coreOptions.isActive;
if (properties.coreOptions.groupFeatures)
{
_defaultStack = ScriptableObject.CreateInstance <MergedModifierStack>();
}
else
{
_defaultStack = ScriptableObject.CreateInstance <ModifierStack>();
((ModifierStack)_defaultStack).moveFeaturePositionTo = _layerProperties.moveFeaturePositionTo;
}
_defaultStack.MeshModifiers = new List <MeshModifier>();
_defaultStack.GoModifiers = new List <GameObjectModifier>();
switch (properties.coreOptions.geometryType)
{
case VectorPrimitiveType.Point:
case VectorPrimitiveType.Custom:
// Let the user add anything that they want
if (_layerProperties.coreOptions.snapToTerrain == true)
{
defaultMeshModifierStack.Add(CreateInstance <SnapTerrainModifier>());
}
break;
case VectorPrimitiveType.Line:
var lineMeshMod = CreateInstance <LineMeshModifier>();
lineMeshMod.Width = _layerProperties.coreOptions.lineWidth;
defaultMeshModifierStack.Add(lineMeshMod);
if (_layerProperties.extrusionOptions.extrusionType != Map.ExtrusionType.None)
{
var heightMod = CreateInstance <HeightModifier>();
heightMod.SetProperties(_layerProperties.extrusionOptions);
defaultMeshModifierStack.Add(heightMod);
}
if (_layerProperties.coreOptions.snapToTerrain == true)
{
defaultMeshModifierStack.Add(CreateInstance <SnapTerrainModifier>());
}
//collider modifier options
if (_layerProperties.colliderOptions.colliderType != ColliderType.None)
{
var lineColliderMod = CreateInstance <ColliderModifier>();
lineColliderMod.SetProperties(_layerProperties.colliderOptions);
defaultGOModifierStack.Add(lineColliderMod);
}
var lineStyleMod = CreateInstance <MaterialModifier>();
lineStyleMod.SetProperties(MapboxDefaultStyles.GetGeometryMaterialOptions(_layerProperties.materialOptions));
defaultGOModifierStack.Add(lineStyleMod);
break;
case VectorPrimitiveType.Polygon:
if (_layerProperties.coreOptions.snapToTerrain == true)
{
defaultMeshModifierStack.Add(CreateInstance <SnapTerrainModifier>());
}
defaultMeshModifierStack.Add(CreateInstance <PolygonMeshModifier>());
GeometryMaterialOptions geometryMaterialOptions = MapboxDefaultStyles.GetGeometryMaterialOptions(_layerProperties.materialOptions);
UVModifierOptions uvModOptions = new UVModifierOptions();
uvModOptions.texturingType = geometryMaterialOptions.texturingType;
uvModOptions.atlasInfo = geometryMaterialOptions.atlasInfo;
uvModOptions.style = geometryMaterialOptions.style;
var uvMod = CreateInstance <UvModifier>();
uvMod.SetProperties(uvModOptions);
defaultMeshModifierStack.Add(uvMod);
if (_layerProperties.extrusionOptions.extrusionType != Map.ExtrusionType.None)
{
//replace materialOptions with styleOptions
if (geometryMaterialOptions.texturingType == UvMapType.Atlas || geometryMaterialOptions.texturingType == UvMapType.AtlasWithColorPalette)
{
var atlasMod = CreateInstance <TextureSideWallModifier>();
GeometryExtrusionWithAtlasOptions atlasOptions = new GeometryExtrusionWithAtlasOptions(_layerProperties.extrusionOptions, uvModOptions);
atlasMod.SetProperties(atlasOptions);
defaultMeshModifierStack.Add(atlasMod);
}
else
{
var heightMod = CreateInstance <HeightModifier>();
heightMod.SetProperties(_layerProperties.extrusionOptions);
defaultMeshModifierStack.Add(heightMod);
}
}
//collider modifier options
if (_layerProperties.colliderOptions.colliderType != ColliderType.None)
{
var polyColliderMod = CreateInstance <ColliderModifier>();
polyColliderMod.SetProperties(_layerProperties.colliderOptions);
defaultGOModifierStack.Add(polyColliderMod);
}
var styleMod = CreateInstance <MaterialModifier>();
styleMod.SetProperties(geometryMaterialOptions);
defaultGOModifierStack.Add(styleMod);
if (geometryMaterialOptions.texturingType == UvMapType.AtlasWithColorPalette)
{
var colorPaletteMod = CreateInstance <MapboxStylesColorModifier>();
colorPaletteMod.m_scriptablePalette = geometryMaterialOptions.colorPalette;
defaultGOModifierStack.Add(colorPaletteMod);
}
break;
default:
break;
}
_defaultStack.MeshModifiers.AddRange(defaultMeshModifierStack);
_defaultStack.GoModifiers.AddRange(defaultGOModifierStack);
//Add any additional modifiers that were added.
_defaultStack.MeshModifiers.AddRange(_layerProperties.MeshModifiers);
_defaultStack.GoModifiers.AddRange(_layerProperties.GoModifiers);
}
public void SetProperties(VectorSubLayerProperties properties)
{
List <MeshModifier> defaultMeshModifierStack = new List <MeshModifier>();
List <GameObjectModifier> defaultGOModifierStack = new List <GameObjectModifier>();
_layerProperties = properties;
_performanceOptions = properties.performanceOptions;
Active = _layerProperties.coreOptions.isActive;
if (properties.coreOptions.combineMeshes)
{
_defaultStack = ScriptableObject.CreateInstance <MergedModifierStack>();
}
else
{
_defaultStack = ScriptableObject.CreateInstance <ModifierStack>();
((ModifierStack)_defaultStack).moveFeaturePositionTo = _layerProperties.moveFeaturePositionTo;
}
_defaultStack.MeshModifiers = new List <MeshModifier>();
_defaultStack.GoModifiers = new List <GameObjectModifier>();
switch (properties.coreOptions.geometryType)
{
case VectorPrimitiveType.Point:
case VectorPrimitiveType.Custom:
// Let the user add anything that they want
if (_layerProperties.coreOptions.snapToTerrain == true)
{
defaultMeshModifierStack.Add(CreateInstance <SnapTerrainModifier>());
}
break;
case VectorPrimitiveType.Line:
var lineMeshMod = CreateInstance <LineMeshModifier>();
lineMeshMod.Width = _layerProperties.coreOptions.lineWidth;
defaultMeshModifierStack.Add(lineMeshMod);
if (_layerProperties.extrusionOptions.extrusionType != Map.ExtrusionType.None)
{
var heightMod = CreateInstance <HeightModifier>();
heightMod.SetProperties(_layerProperties.extrusionOptions);
defaultMeshModifierStack.Add(heightMod);
}
if (_layerProperties.coreOptions.snapToTerrain == true)
{
defaultMeshModifierStack.Add(CreateInstance <SnapTerrainModifier>());
}
//collider modifier options
if (_layerProperties.colliderOptions.colliderType != ColliderType.None)
{
var lineColliderMod = CreateInstance <ColliderModifier>();
lineColliderMod.SetProperties(_layerProperties.colliderOptions);
defaultGOModifierStack.Add(lineColliderMod);
}
var lineStyleMod = CreateInstance <MaterialModifier>();
lineStyleMod.SetProperties(MapboxDefaultStyles.GetGeometryMaterialOptions(_layerProperties.materialOptions));
defaultGOModifierStack.Add(lineStyleMod);
break;
case VectorPrimitiveType.Polygon:
if (_layerProperties.coreOptions.snapToTerrain == true)
{
defaultMeshModifierStack.Add(CreateInstance <SnapTerrainModifier>());
}
defaultMeshModifierStack.Add(CreateInstance <PolygonMeshModifier>());
GeometryMaterialOptions geometryMaterialOptions = MapboxDefaultStyles.GetGeometryMaterialOptions(_layerProperties.materialOptions);
UVModifierOptions uvModOptions = new UVModifierOptions();
uvModOptions.texturingType = geometryMaterialOptions.texturingType;
uvModOptions.atlasInfo = geometryMaterialOptions.atlasInfo;
uvModOptions.style = geometryMaterialOptions.style;
var uvMod = CreateInstance <UvModifier>();
uvMod.SetProperties(uvModOptions);
defaultMeshModifierStack.Add(uvMod);
if (_layerProperties.extrusionOptions.extrusionType != Map.ExtrusionType.None)
{
//replace materialOptions with styleOptions
if (geometryMaterialOptions.texturingType == UvMapType.Atlas || geometryMaterialOptions.texturingType == UvMapType.AtlasWithColorPalette)
{
var atlasMod = CreateInstance <TextureSideWallModifier>();
GeometryExtrusionWithAtlasOptions atlasOptions = new GeometryExtrusionWithAtlasOptions(_layerProperties.extrusionOptions, uvModOptions);
atlasMod.SetProperties(atlasOptions);
defaultMeshModifierStack.Add(atlasMod);
}
else
{
var heightMod = CreateInstance <HeightModifier>();
heightMod.SetProperties(_layerProperties.extrusionOptions);
defaultMeshModifierStack.Add(heightMod);
}
}
//collider modifier options
if (_layerProperties.colliderOptions.colliderType != ColliderType.None)
{
var polyColliderMod = CreateInstance <ColliderModifier>();
polyColliderMod.SetProperties(_layerProperties.colliderOptions);
defaultGOModifierStack.Add(polyColliderMod);
}
var styleMod = CreateInstance <MaterialModifier>();
styleMod.SetProperties(geometryMaterialOptions);
defaultGOModifierStack.Add(styleMod);
if (geometryMaterialOptions.texturingType == UvMapType.AtlasWithColorPalette)
{
var colorPaletteMod = CreateInstance <MapboxStylesColorModifier>();
colorPaletteMod.m_scriptablePalette = geometryMaterialOptions.colorPalette;
defaultGOModifierStack.Add(colorPaletteMod);
}
break;
default:
break;
}
_defaultStack.MeshModifiers.AddRange(defaultMeshModifierStack);
_defaultStack.GoModifiers.AddRange(defaultGOModifierStack);
//Add any additional modifiers that were added.
_defaultStack.MeshModifiers.AddRange(_layerProperties.MeshModifiers);
_defaultStack.GoModifiers.AddRange(_layerProperties.GoModifiers);
//Adding filters from the types dropdown
//if ((MapboxSpecialLayerParameters.LayerNameTypeProperty.ContainsKey(properties.coreOptions.layerName)) && !string.IsNullOrEmpty(properties.selectedTypes))
//{
// LayerFilter filter = new LayerFilter(LayerFilterOperationType.Contains);
// filter.Key = MapboxSpecialLayerParameters.LayerNameTypeProperty[properties.coreOptions.layerName];
// filter.PropertyValue = properties.selectedTypes;
// //if (properties.coreOptions.layerName == properties.roadLayer)
// //{
// // filter.Key = properties.roadLayer_TypeProperty;
// // filter.PropertyValue = properties.selectedTypes;
// //}
// //else if (properties.coreOptions.layerName == "landuse")
// //{
// // filter.Key = properties.landuseLayer_TypeProperty;
// // filter.PropertyValue = properties.selectedTypes;
// //}
// properties.filterOptions.filters.Add(filter);
//}
}
public void DrawUI(SerializedProperty property)
{
objectId = property.serializedObject.targetObject.GetInstanceID().ToString();
var serializedMapObject = property.serializedObject;
AbstractMap mapObject = (AbstractMap)serializedMapObject.targetObject;
tileJSONData = mapObject.VectorData.LayerProperty.tileJsonData;
var sourceTypeProperty = property.FindPropertyRelative("_sourceType");
var sourceTypeValue = (VectorSourceType)sourceTypeProperty.enumValueIndex;
var displayNames = sourceTypeProperty.enumDisplayNames;
int count = sourceTypeProperty.enumDisplayNames.Length;
if (!_isGUIContentSet)
{
_sourceTypeContent = new GUIContent[count];
for (int extIdx = 0; extIdx < count; extIdx++)
{
_sourceTypeContent[extIdx] = new GUIContent
{
text = displayNames[extIdx],
tooltip = ((VectorSourceType)extIdx).Description(),
};
}
_isGUIContentSet = true;
}
sourceTypeValue = (VectorSourceType)sourceTypeProperty.enumValueIndex;
var sourceOptionsProperty = property.FindPropertyRelative("sourceOptions");
var layerSourceProperty = sourceOptionsProperty.FindPropertyRelative("layerSource");
var layerSourceId = layerSourceProperty.FindPropertyRelative("Id");
var isActiveProperty = sourceOptionsProperty.FindPropertyRelative("isActive");
switch (sourceTypeValue)
{
case VectorSourceType.MapboxStreets:
case VectorSourceType.MapboxStreetsWithBuildingIds:
var sourcePropertyValue = MapboxDefaultVector.GetParameters(sourceTypeValue);
layerSourceId.stringValue = sourcePropertyValue.Id;
GUI.enabled = false;
if (_isInitialized)
{
LoadEditorTileJSON(property, sourceTypeValue, layerSourceId.stringValue);
}
else
{
_isInitialized = true;
}
if (tileJSONData.PropertyDisplayNames.Count == 0 && tileJSONData.tileJSONLoaded)
{
EditorGUILayout.HelpBox("Invalid Map Id / There might be a problem with the internet connection.", MessageType.Error);
}
GUI.enabled = true;
isActiveProperty.boolValue = true;
break;
case VectorSourceType.Custom:
if (_isInitialized)
{
string test = layerSourceId.stringValue;
LoadEditorTileJSON(property, sourceTypeValue, layerSourceId.stringValue);
}
else
{
_isInitialized = true;
}
if (tileJSONData.PropertyDisplayNames.Count == 0 && tileJSONData.tileJSONLoaded)
{
EditorGUILayout.HelpBox("Invalid Map Id / There might be a problem with the internet connection.", MessageType.Error);
}
isActiveProperty.boolValue = true;
break;
case VectorSourceType.None:
isActiveProperty.boolValue = false;
break;
default:
isActiveProperty.boolValue = false;
break;
}
if (sourceTypeValue != VectorSourceType.None)
{
EditorGUILayout.LabelField(new GUIContent
{
text = "Vector Layer Visualizers",
tooltip = "Visualizers for vector features contained in a layer. "
});
var subLayerArray = property.FindPropertyRelative("vectorSubLayers");
var layersRect = EditorGUILayout.GetControlRect(GUILayout.MinHeight(Mathf.Max(subLayerArray.arraySize + 1, 1) * _lineHeight),
GUILayout.MaxHeight((subLayerArray.arraySize + 1) * _lineHeight));
layerTreeView.Layers = subLayerArray;
layerTreeView.Reload();
layerTreeView.OnGUI(layersRect);
selectedLayers = layerTreeView.GetSelection();
//if there are selected elements, set the selection index at the first element.
//if not, use the Selection index to persist the selection at the right index.
if (selectedLayers.Count > 0)
{
//ensure that selectedLayers[0] isn't out of bounds
if (selectedLayers[0] - layerTreeView.uniqueId > subLayerArray.arraySize - 1)
{
selectedLayers[0] = subLayerArray.arraySize - 1 + layerTreeView.uniqueId;
}
SelectionIndex = selectedLayers[0];
}
else
{
if (SelectionIndex > 0 && (SelectionIndex - layerTreeView.uniqueId <= subLayerArray.arraySize - 1))
{
selectedLayers = new int[1] {
SelectionIndex
};
layerTreeView.SetSelection(selectedLayers);
}
}
GUILayout.Space(EditorGUIUtility.singleLineHeight);
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button(new GUIContent("Add Visualizer"), (GUIStyle)"minibuttonleft"))
{
subLayerArray.arraySize++;
var subLayer = subLayerArray.GetArrayElementAtIndex(subLayerArray.arraySize - 1);
var subLayerName = subLayer.FindPropertyRelative("coreOptions.sublayerName");
subLayerName.stringValue = "Untitled";
// Set defaults here because SerializedProperty copies the previous element.
var subLayerCoreOptions = subLayer.FindPropertyRelative("coreOptions");
subLayerCoreOptions.FindPropertyRelative("isActive").boolValue = true;
subLayerCoreOptions.FindPropertyRelative("layerName").stringValue = "building";
subLayerCoreOptions.FindPropertyRelative("geometryType").enumValueIndex = (int)VectorPrimitiveType.Polygon;
subLayerCoreOptions.FindPropertyRelative("snapToTerrain").boolValue = true;
subLayerCoreOptions.FindPropertyRelative("groupFeatures").boolValue = false;
subLayerCoreOptions.FindPropertyRelative("lineWidth").floatValue = 1.0f;
var subLayerExtrusionOptions = subLayer.FindPropertyRelative("extrusionOptions");
subLayerExtrusionOptions.FindPropertyRelative("extrusionType").enumValueIndex = (int)ExtrusionType.None;
subLayerExtrusionOptions.FindPropertyRelative("extrusionGeometryType").enumValueIndex =
(int)ExtrusionGeometryType.RoofAndSide;
subLayerExtrusionOptions.FindPropertyRelative("propertyName").stringValue = "height";
subLayerExtrusionOptions.FindPropertyRelative("extrusionScaleFactor").floatValue = 1f;
var subLayerFilterOptions = subLayer.FindPropertyRelative("filterOptions");
subLayerFilterOptions.FindPropertyRelative("filters").ClearArray();
subLayerFilterOptions.FindPropertyRelative("combinerType").enumValueIndex =
(int)LayerFilterCombinerOperationType.Any;
var subLayerGeometryMaterialOptions = subLayer.FindPropertyRelative("materialOptions");
subLayerGeometryMaterialOptions.FindPropertyRelative("style").enumValueIndex = (int)StyleTypes.Realistic;
GeometryMaterialOptions geometryMaterialOptionsReference = MapboxDefaultStyles.GetDefaultAssets();
var mats = subLayerGeometryMaterialOptions.FindPropertyRelative("materials");
mats.arraySize = 2;
var topMatArray = mats.GetArrayElementAtIndex(0).FindPropertyRelative("Materials");
var sideMatArray = mats.GetArrayElementAtIndex(1).FindPropertyRelative("Materials");
if (topMatArray.arraySize == 0)
{
topMatArray.arraySize = 1;
}
if (sideMatArray.arraySize == 0)
{
sideMatArray.arraySize = 1;
}
var topMat = topMatArray.GetArrayElementAtIndex(0);
var sideMat = sideMatArray.GetArrayElementAtIndex(0);
var atlas = subLayerGeometryMaterialOptions.FindPropertyRelative("atlasInfo");
var palette = subLayerGeometryMaterialOptions.FindPropertyRelative("colorPalette");
topMat.objectReferenceValue = geometryMaterialOptionsReference.materials[0].Materials[0];
sideMat.objectReferenceValue = geometryMaterialOptionsReference.materials[1].Materials[0];
atlas.objectReferenceValue = geometryMaterialOptionsReference.atlasInfo;
palette.objectReferenceValue = geometryMaterialOptionsReference.colorPalette;
subLayer.FindPropertyRelative("buildingsWithUniqueIds").boolValue = false;
subLayer.FindPropertyRelative("moveFeaturePositionTo").enumValueIndex = (int)PositionTargetType.TileCenter;
subLayer.FindPropertyRelative("MeshModifiers").ClearArray();
subLayer.FindPropertyRelative("GoModifiers").ClearArray();
var subLayerColliderOptions = subLayer.FindPropertyRelative("colliderOptions");
subLayerColliderOptions.FindPropertyRelative("colliderType").enumValueIndex = (int)ColliderType.None;
selectedLayers = new int[1] {
subLayerArray.arraySize - 1 + layerTreeView.uniqueId
};
layerTreeView.SetSelection(selectedLayers);
}
if (GUILayout.Button(new GUIContent("Remove Selected"), (GUIStyle)"minibuttonright"))
{
foreach (var index in selectedLayers.OrderByDescending(i => i))
{
subLayerArray.DeleteArrayElementAtIndex(index - layerTreeView.uniqueId);
}
selectedLayers = new int[0];
layerTreeView.SetSelection(selectedLayers);
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(EditorGUIUtility.singleLineHeight);
if (selectedLayers.Count == 1 && subLayerArray.arraySize != 0)
{
//ensure that selectedLayers[0] isn't out of bounds
if (selectedLayers[0] - layerTreeView.uniqueId > subLayerArray.arraySize - 1)
{
selectedLayers[0] = subLayerArray.arraySize - 1 + layerTreeView.uniqueId;
}
SelectionIndex = selectedLayers[0];
var layerProperty = subLayerArray.GetArrayElementAtIndex(SelectionIndex - layerTreeView.uniqueId);
layerProperty.isExpanded = true;
var subLayerCoreOptions = layerProperty.FindPropertyRelative("coreOptions");
bool isLayerActive = subLayerCoreOptions.FindPropertyRelative("isActive").boolValue;
if (!isLayerActive)
{
GUI.enabled = false;
}
DrawLayerVisualizerProperties(sourceTypeValue, layerProperty, property);
if (!isLayerActive)
{
GUI.enabled = true;
}
}
else
{
GUILayout.Label("Select a visualizer to see properties");
}
}
}
public SubLayerCustomStyle(GeometryMaterialOptions materialOptions)
{
_materialOptions = materialOptions;
}
public SubLayerRealisticStyle(GeometryMaterialOptions materialOptions)
{
_materialOptions = materialOptions;
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
objectId = property.serializedObject.targetObject.GetInstanceID().ToString();
GeometryMaterialOptions materialOptions = (GeometryMaterialOptions)EditorHelper.GetTargetObjectOfProperty(property);
showTexturing = EditorGUILayout.Foldout(showTexturing, new GUIContent {
text = "Texturing", tooltip = "Material options to texture the generated building geometry"
});
if (showTexturing)
{
LoadDefaultStyleIcons();
EditorGUI.BeginProperty(position, label, property);
var styleTypeLabel = new GUIContent {
text = "Style Type", tooltip = "Texturing style for feature; choose from sample style or create your own by choosing Custom. "
};
var styleType = property.FindPropertyRelative("style");
GUIContent[] styleTypeGuiContent = new GUIContent[styleType.enumDisplayNames.Length];
for (int i = 0; i < styleType.enumDisplayNames.Length; i++)
{
styleTypeGuiContent[i] = new GUIContent
{
text = styleType.enumDisplayNames[i]
};
}
styleType.enumValueIndex = EditorGUILayout.Popup(styleTypeLabel, styleType.enumValueIndex, styleTypeGuiContent);
EditorHelper.CheckForModifiedProperty(styleType, materialOptions);
EditorGUI.indentLevel++;
if ((StyleTypes)styleType.enumValueIndex != StyleTypes.Custom)
{
GUILayout.BeginHorizontal();
var style = (StyleTypes)styleType.enumValueIndex;
Texture2D thumbnailTexture = (Texture2D)_styleIconBundles[style].texture;
if ((StyleTypes)styleType.enumValueIndex == StyleTypes.Simple)
{
var samplePaletteType = property.FindPropertyRelative("samplePalettes");
var palette = (SamplePalettes)samplePaletteType.enumValueIndex;
thumbnailTexture = (Texture2D)_paletteIconBundles[palette].texture;
}
string descriptionLabel = EnumExtensions.Description(style);
EditorGUILayout.LabelField(new GUIContent(" ", thumbnailTexture), Constants.GUI.Styles.EDITOR_TEXTURE_THUMBNAIL_STYLE, GUILayout.Height(60), GUILayout.Width(EditorGUIUtility.labelWidth - 60));
EditorGUILayout.TextArea(descriptionLabel, (GUIStyle)"wordWrappedLabel");
GUILayout.EndHorizontal();
switch ((StyleTypes)styleType.enumValueIndex)
{
case StyleTypes.Simple:
var samplePaletteType = property.FindPropertyRelative("samplePalettes");
var samplePaletteTypeLabel = new GUIContent {
text = "Palette Type", tooltip = "Palette type for procedural colorization; choose from sample palettes or create your own by choosing Custom. "
};
GUIContent[] samplePaletteTypeGuiContent = new GUIContent[samplePaletteType.enumDisplayNames.Length];
for (int i = 0; i < samplePaletteType.enumDisplayNames.Length; i++)
{
samplePaletteTypeGuiContent[i] = new GUIContent
{
text = samplePaletteType.enumDisplayNames[i]
};
}
samplePaletteType.enumValueIndex = EditorGUILayout.Popup(samplePaletteTypeLabel, samplePaletteType.enumValueIndex, samplePaletteTypeGuiContent);
EditorHelper.CheckForModifiedProperty(samplePaletteType, materialOptions);
break;
case StyleTypes.Light:
property.FindPropertyRelative("lightStyleOpacity").floatValue = EditorGUILayout.Slider("Opacity", property.FindPropertyRelative("lightStyleOpacity").floatValue, 0.0f, 1.0f);
EditorHelper.CheckForModifiedProperty(property.FindPropertyRelative("lightStyleOpacity"), materialOptions);
break;
case StyleTypes.Dark:
property.FindPropertyRelative("darkStyleOpacity").floatValue = EditorGUILayout.Slider("Opacity", property.FindPropertyRelative("darkStyleOpacity").floatValue, 0.0f, 1.0f);
EditorHelper.CheckForModifiedProperty(property.FindPropertyRelative("darkStyleOpacity"), materialOptions);
break;
case StyleTypes.Color:
property.FindPropertyRelative("colorStyleColor").colorValue = EditorGUILayout.ColorField("Color", property.FindPropertyRelative("colorStyleColor").colorValue);
EditorHelper.CheckForModifiedProperty(property.FindPropertyRelative("colorStyleColor"), materialOptions);
break;
default:
break;
}
}
else
{
var texturingType = property.FindPropertyRelative("texturingType");
int valIndex = texturingType.enumValueIndex == 0 ? 0 : texturingType.enumValueIndex + 1;
var texturingTypeGUI = new GUIContent {
text = "Texturing Type", tooltip = EnumExtensions.Description((UvMapType)valIndex)
};
EditorGUILayout.PropertyField(texturingType, texturingTypeGUI);
EditorHelper.CheckForModifiedProperty(texturingType, materialOptions);
var matList = property.FindPropertyRelative("materials");
if (matList.arraySize == 0)
{
matList.arraySize = 2;
}
GUILayout.Space(-lineHeight);
EditorGUILayout.PropertyField(matList.GetArrayElementAtIndex(0), new GUIContent {
text = "Top Material", tooltip = "Unity material to use for extruded top/roof mesh. "
});
EditorHelper.CheckForModifiedProperty(matList.GetArrayElementAtIndex(0), materialOptions);
GUILayout.Space(-lineHeight);
EditorGUILayout.PropertyField(matList.GetArrayElementAtIndex(1), new GUIContent {
text = "Side Material", tooltip = "Unity material to use for extruded side/wall mesh. "
});
EditorHelper.CheckForModifiedProperty(matList.GetArrayElementAtIndex(1), materialOptions);
if ((UvMapType)texturingType.enumValueIndex + 1 == UvMapType.Atlas)
{
var atlasInfo = property.FindPropertyRelative("atlasInfo");
EditorGUILayout.ObjectField(atlasInfo, new GUIContent {
text = "Altas Info", tooltip = "Atlas information scriptable object, this defines how the texture roof and wall texture atlases will be used. "
});
EditorHelper.CheckForModifiedProperty(atlasInfo, materialOptions);
}
if ((UvMapType)texturingType.enumValueIndex + 1 == UvMapType.AtlasWithColorPalette)
{
var atlasInfo = property.FindPropertyRelative("atlasInfo");
EditorGUILayout.ObjectField(atlasInfo, new GUIContent {
text = "Altas Info", tooltip = "Atlas information scriptable object, this defines how the texture roof and wall texture atlases will be used. "
});
EditorHelper.CheckForModifiedProperty(atlasInfo, materialOptions);
var colorPalette = property.FindPropertyRelative("colorPalette");
EditorGUILayout.ObjectField(colorPalette, new GUIContent {
text = "Color Palette", tooltip = "Color palette scriptable object, allows texture features to be procedurally colored at runtime. Requires materials that use the MapboxPerRenderer shader. "
});
EditorHelper.CheckForModifiedProperty(colorPalette, materialOptions);
EditorGUILayout.LabelField(new GUIContent {
text = "Note: Atlas With Color Palette requires materials that use the MapboxPerRenderer shader."
}, Constants.GUI.Styles.EDITOR_NOTE_STYLE);
}
}
EditorGUI.indentLevel--;
EditorGUI.EndProperty();
}
}
