/// <summary> /// Get the total number of unique stencil layers of a given resolution within a list of LBFilter. /// NOTE: Assumes that stencil, stencilLayer and stencilLayerResolution has already been cached in the LBFilter. /// </summary> /// <param name="lbFilterList"></param> /// <param name="resolution"></param> /// <returns></returns> public static int GetNumStencilLayersByResolution(List <LBFilter> lbFilterList, int resolution) { int numUniqueLayers = 0; LBFilter lbFilter = null; int numLBFilters = lbFilterList == null ? 0 : lbFilterList.Count; if (numLBFilters > 0) { // Create with some initial capacity List <string> stencilLayerGUIDList = new List <string>(10); for (int fIdx = 0; fIdx < numLBFilters; fIdx++) { lbFilter = lbFilterList[fIdx]; // Is this a valid stencil layer with the correct resolution? if (lbFilter != null && lbFilter.filterType == LBFilter.FilterType.StencilLayer && !string.IsNullOrEmpty(lbFilter.lbStencilGUID) && !string.IsNullOrEmpty(lbFilter.lbStencilLayerGUID) && lbFilter.stencilLayerResolution == resolution) { //Debug.Log("[DEBUG] GetNumStencilLayersByResolution " + lbFilter.lbStencilLayer.LayerName + " " + lbFilter.stencilLayerResolution + " GUID: " + lbFilter.lbStencilLayerGUID + " " + lbFilter.lbStencilLayer.GUID); // If it doesn't already exist, add it to the list of unique Stencil Layer GUIDs if (!stencilLayerGUIDList.Exists(guid => guid == lbFilter.lbStencilLayerGUID)) { numUniqueLayers++; stencilLayerGUIDList.Add(lbFilter.lbStencilLayerGUID); //Debug.Log(" [DEBUG] GetNumStencilLayersByResolution - Adding " + lbFilter.lbStencilLayerGUID + " resolution: " + resolution); } } } } return(numUniqueLayers); }
/// <summary> /// Preload the stencils for ALL groups /// </summary> public void PreloadStencilData() { isStencilLayerFiltersToApply = new bool[numActiveGroups]; for (int i = 0; i < numActiveGroups; i++) { // Are there any Stencil Layer filters for this group? isStencilLayerFiltersToApply[i] = LBFilter.Contains(activeGroupList[i].filterList, LBFilter.FilterType.StencilLayer); if (isStencilLayerFiltersToApply[i]) { // Preload the stencil data if (activeGroupList[i].filterList != null) { foreach (LBFilter lbFilter in activeGroupList[i].filterList) { if (lbFilter != null) { // Currently all stencil filters are AND // Is this a valid Stencil Filter? if (lbFilter.filterType == LBFilter.FilterType.StencilLayer && !string.IsNullOrEmpty(lbFilter.lbStencilGUID) && !string.IsNullOrEmpty(lbFilter.lbStencilLayerGUID)) { // If the temporary class instance isn't defined, look it up and validate it is in the current landscape if (lbFilter.lbStencil == null) { lbFilter.lbStencil = LBStencil.GetStencilInLandscape(lbGroupParams.landscape, lbFilter.lbStencilGUID, lbGroupParams.showErrors); } if (lbFilter.lbStencil != null) { // Find the Stencil Layer for this Layer Filter and populate the temporary class instance lbFilter.lbStencilLayer = lbFilter.lbStencil.GetStencilLayerByGUID(lbFilter.lbStencilLayerGUID); // Load the USHORT data if (lbFilter.lbStencilLayer != null) { if (lbFilter.lbStencilLayer.layerArray == null) { lbFilter.lbStencilLayer.AllocLayerArray(); lbFilter.lbStencilLayer.UnCompressToUShort(); } } } } } } } } } // Stencil LBLayerFilter temp variables stencilLayerPosN = new Vector2(); }
/// <summary> /// Constructor to create a clone of a LBFilter instance /// </summary> /// <param name="lbFilter"></param> public LBFilter(LBFilter lbFilter) { this.filterType = lbFilter.filterType; this.filterMode = lbFilter.filterMode; this.areaRect = lbFilter.areaRect; this.showAreaHighlighter = lbFilter.showAreaHighlighter; this.minProximity = lbFilter.minProximity; this.layerMask = lbFilter.layerMask; this.filterByTag = lbFilter.filterByTag; this.terrainTexture = new LBTerrainTexture(lbFilter.terrainTexture); this.lbStencilGUID = lbFilter.lbStencilGUID; this.lbStencilLayerGUID = lbFilter.lbStencilLayerGUID; this.lbBiome = lbFilter.lbBiome; this.cutOff = lbFilter.cutOff; }
/// <summary> /// Find the first LBTerrainTexture that has the same GUID or Texture2D image as the Texture filter. /// Update the filter. NOTE: If there are multiple uses of the same texture, this may sometimes /// get the wrong texture. The only way to correct this is to fully populate the LBFilter will /// all the LBTerrainTexture attributes (like Normalmap, smoothness, metallic etc). /// </summary> /// <param name="lbFilterList"></param> /// <param name="lbTerrainTextureList"></param> public static void UpdateTextures(List <LBFilter> lbFilterList, List <LBTerrainTexture> lbTerrainTextureList, bool showErrors) { if (lbTerrainTextureList == null) { if (showErrors) { Debug.LogWarning("ERROR LBFilter.UpdateTextures - List of available textures cannot be null"); } } else if (lbTerrainTextureList.Count < 1) { if (showErrors) { Debug.Log("INFO LBFilter.UpdateTextures - List of available textures is empty"); } } else if (lbFilterList != null) { for (int f = 0; f < lbFilterList.Count; f++) { LBFilter lbFilter = lbFilterList[f]; if (lbFilter != null) { if (lbFilter.filterType == FilterType.Texture) { // Find the first matching texture using GUID or only the Texture2D image. NOTE: this may be incorrect for // landscapes with the same Texture2D used multiple times in the Texturing tab. // Before LB 2.3.2 GUID may have been incorrect. int textureIndex = lbTerrainTextureList.FindIndex(ftx => (!string.IsNullOrEmpty(lbFilter.terrainTexture.GUID) && ftx.GUID == lbFilter.terrainTexture.GUID) || ftx.texture == lbFilter.terrainTexture.texture); if (textureIndex >= 0) { //Debug.Log("UpdateTextures Found: " + lbFilter.terrainTexture.texture.name); lbFilter.terrainTexture = new LBTerrainTexture(lbTerrainTextureList[textureIndex]); // Set the GUID to the original terrainTexture GUID lbFilter.terrainTexture.GUID = lbTerrainTextureList[textureIndex].GUID; } else { if (showErrors) { Debug.LogWarning("ERROR LBFilter.UpdateTextures - could not find a match for " + (lbFilter.terrainTexture != null && lbFilter.terrainTexture.texture != null ? lbFilter.terrainTexture.texture.name : "filter " + (f + 1).ToString())); } } } } } } }
/// <summary> /// Create an LBFilter for Stencil Layer using the LBStencil instance and the name of the layer /// </summary> /// <param name="lbStencil"></param> /// <param name="layerName"></param> /// <param name="showErrors"></param> /// <returns></returns> public static LBFilter CreateFilter(LBStencil lbStencil, string layerName, bool showErrors) { LBFilter lbFilter = null; if (lbStencil == null) { if (showErrors) { Debug.LogWarning("LBFilter.CreateFilter - stencil is null"); } } else if (string.IsNullOrEmpty(layerName)) { if (showErrors) { Debug.LogWarning("LBFilter.CreateFilter - layerName is an empty string"); } } else { lbFilter = new LBFilter(LBFilter.FilterType.StencilLayer, FilterMode.AND); if (lbFilter == null) { if (showErrors) { Debug.LogWarning("LBFilter.CreateFilter - could not create LBFilter for " + lbStencil.stencilName + "." + layerName); } } else { lbFilter.lbStencilGUID = lbStencil.GUID; // Find the new stencil layer LBStencilLayer lbStencilLayer = lbStencil.GetStencilLayerByName(layerName); if (lbStencilLayer != null) { lbFilter.lbStencilLayerGUID = lbStencilLayer.GUID; } else { lbFilter = null; } } } return(lbFilter); }
/// <summary> /// Create an LBFilter for Stencil Layer using the LBStencil instance GUID and the GUID of the stencil layer /// </summary> /// <param name="lbStencilGUID"></param> /// <param name="lbStencilLayerGUID"></param> /// <param name="showErrors"></param> /// <returns></returns> public static LBFilter CreateFilter(string lbStencilGUID, string lbStencilLayerGUID, bool showErrors) { LBFilter lbFilter = null; if (string.IsNullOrEmpty(lbStencilGUID)) { if (showErrors) { Debug.LogWarning("LBFilter.CreateFilter - lbStencilGUID is an empty string"); } } else if (string.IsNullOrEmpty(lbStencilLayerGUID)) { if (showErrors) { Debug.LogWarning("LBFilter.CreateFilter - lbStencilLayerGUID is an empty string"); } } else { lbFilter = new LBFilter(FilterType.StencilLayer, FilterMode.AND); if (lbFilter == null) { if (showErrors) { Debug.LogWarning("LBFilter.CreateFilter - could not create LBFilter"); } } else { lbFilter.lbStencilGUID = lbStencilGUID; lbFilter.lbStencilLayerGUID = lbStencilLayerGUID; } } return(lbFilter); }
public string ScriptGrass(int GrassIdx, string EndOfLineMarker = "\n") { // Create a new instance of StringBuilder and give it an estimated capacity System.Text.StringBuilder sb = new System.Text.StringBuilder(1000); string eol = " "; // We always need a space between lines OR a end of line marker like "\n" if (EndOfLineMarker.Length > 0) { eol = EndOfLineMarker; } string grInst = "lbTerrainGrass" + (GrassIdx + 1); string grInstAbrev = "Grs" + (GrassIdx + 1); sb.Append("// Grass Code generated from Landscape Builder 2 at " + System.DateTime.Now.ToShortTimeString() + " on " + System.DateTime.Now.ToLongDateString() + eol + eol); sb.Append("// BEGIN Public variables to populate in the editor - Uncomment and add these to top of class " + eol); sb.Append("//[Header(\"Grass" + (GrassIdx + 1) + "\")] " + eol); sb.Append("//public Texture2D texture" + grInstAbrev + "; " + eol); sb.Append("//public GameObject meshPrefab" + grInstAbrev + "; " + eol); sb.Append("//public Texture2D map" + grInstAbrev + "; " + eol); sb.Append("// END Public variables" + eol + eol); sb.Append("#region LBTerrainGrass" + (GrassIdx + 1) + eol); sb.Append("LBTerrainGrass " + grInst + " = new LBTerrainGrass(); " + eol); sb.Append("if (" + grInst + " != null)" + eol); sb.Append("{" + eol); sb.Append("\t" + grInst + ".texture = texture" + grInstAbrev + "; " + eol); sb.Append("\t" + grInst + ".textureName = " + (string.IsNullOrEmpty(textureName) ? "\"\"" : "\"" + textureName + "\"") + "; " + eol); sb.Append("\t" + grInst + ".minHeight = " + minHeight + "f; " + eol); sb.Append("\t" + grInst + ".maxHeight = " + maxHeight + "f; " + eol); sb.Append("\t" + grInst + ".minWidth = " + minHeight + "f; " + eol); sb.Append("\t" + grInst + ".maxWidth = " + maxHeight + "f; " + eol); sb.Append("\t" + grInst + ".healthyColour = new Color(" + healthyColour.r + "f," + healthyColour.g + "f," + healthyColour.b + "f," + healthyColour.a + "f); " + eol); sb.Append("\t" + grInst + ".dryColour = new Color(" + dryColour.r + "f," + dryColour.g + "f," + dryColour.b + "f," + dryColour.a + "f); " + eol); sb.Append("\t" + grInst + ".noiseSpread = " + noiseSpread + "f; " + eol); sb.Append("\t" + grInst + ".minPopulatedHeight = " + minPopulatedHeight + "f; " + eol); sb.Append("\t" + grInst + ".maxPopulatedHeight = " + maxPopulatedHeight + "f; " + eol); sb.Append("\t" + grInst + ".minInclination = " + minInclination + "f; " + eol); sb.Append("\t" + grInst + ".maxInclination = " + maxInclination + "f; " + eol); sb.Append("\t" + grInst + ".influence = " + influence + "f; " + eol); sb.Append("\t" + grInst + ".minDensity = " + minDensity + "; " + eol); sb.Append("\t" + grInst + ".density = " + density + "; " + eol); sb.Append("\t" + grInst + ".detailRenderMode = DetailRenderMode." + detailRenderMode + "; " + eol); sb.Append("\t" + grInst + ".grassPlacingMode = LBTerrainGrass.GrassPlacingMode." + grassPlacingMode + "; " + eol); sb.Append("\t" + grInst + ".grassPatchFadingMode = LBTerrainGrass.GrassPatchFadingMode." + grassPatchFadingMode + "; " + eol); sb.Append("\t" + grInst + ".isCurvatureConcave = " + isCurvatureConcave.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".curvatureDistance = " + curvatureDistance + "f; " + eol); sb.Append("\t" + grInst + ".curvatureMinHeightDiff = " + curvatureMinHeightDiff + "f; " + eol); sb.Append("\t" + grInst + ".map = map" + grInstAbrev + "; " + eol); sb.Append("\t" + grInst + ".mapColour = new Color(" + mapColour.r + "f," + mapColour.g + "f," + mapColour.b + "f," + mapColour.a + "f); " + eol); sb.Append("\t" + grInst + ".mapTolerance = " + mapTolerance + "; " + eol); sb.Append("\t" + grInst + ".mapInverse = " + mapInverse.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".mapToleranceBlendCurve = LBMap.GetDefaultToleranceBlendCurve; " + eol); sb.Append("\t" + grInst + ".mapIsPath = " + mapIsPath.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".isDisabled = " + isDisabled.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".showGrass = " + showGrass.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".useNoise = " + useNoise.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".noiseTileSize = " + noiseTileSize + "f; " + eol); sb.Append("\t" + grInst + ".grassPlacementCutoff = " + grassPlacementCutoff + "f; " + eol); sb.Append("\t" + grInst + ".noiseOctaves = " + noiseOctaves + "; " + eol); sb.Append("\t" + grInst + ".useMeshPrefab = " + useMeshPrefab.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".meshPrefab = meshPrefab" + grInstAbrev + "; " + eol); sb.Append("\t" + grInst + ".meshPrefabName = " + (string.IsNullOrEmpty(meshPrefabName) ? "\"\"" : "\"" + meshPrefabName + "\"") + "; " + eol); sb.Append("\t" + grInst + ".showPrefabPreview = " + showPrefabPreview.ToString().ToLower() + "; " + eol); sb.Append("\t" + grInst + ".GUID = " + (string.IsNullOrEmpty(GUID) ? "\"\"" : "\"" + GUID + "\"") + "; " + eol); sb.Append("\t" + grInst + ".filterList = new List<LBFilter>(); " + eol); if (filterList != null) { // Create a unique variable if (filterList.Exists(f => f.filterType == LBFilter.FilterType.StencilLayer)) { sb.Append("\tLBFilter lbFilter" + grInstAbrev + " = null; " + eol); } for (int tf = 0; tf < filterList.Count; tf++) { LBFilter lbFilter = filterList[tf]; if (lbFilter != null) { if (lbFilter.filterType == LBFilter.FilterType.StencilLayer) { sb.Append("\tlbFilter" + grInstAbrev + " = LBFilter.CreateFilter(\"" + lbFilter.lbStencilGUID + "\", \"" + lbFilter.lbStencilLayerGUID + "\", false); " + eol); sb.Append("\tif (lbFilter" + grInstAbrev + " != null) " + eol); sb.Append("\t{ " + eol); sb.Append("\t\tlbFilter" + grInstAbrev + ".filterMode = LBFilter.FilterMode." + lbFilter.filterMode + ";" + eol); sb.Append("\t\t" + grInst + ".filterList.Add(lbFilter" + grInstAbrev + "); " + eol); sb.Append("\t} " + eol); sb.Append(eol); } else { sb.Append("\t// Currently we do not output non-Stencil filters for runtime Grass. Contact support or post in our Unity forum if you need this feature." + eol); } } } } sb.Append("\t" + grInst + ".lbTerrainDataList = null; " + eol); sb.Append("\t// NOTE Add the new Grass to the landscape meta-data"); sb.Append(eol); sb.Append("\tlandscape.terrainGrassList.Add(" + grInst + ");"); sb.Append(eol); sb.Append("}" + eol); sb.Append("#endregion" + eol); sb.Append("// END OF CODE SEGMENT" + eol); return(sb.ToString()); }
/// <summary> /// Constructor to create a clone of a LBTerrainGrass instance /// </summary> /// <param name="lbTerrainGrass"></param> public LBTerrainGrass(LBTerrainGrass lbTerrainGrass) { this.texture = lbTerrainGrass.texture; if (lbTerrainGrass.textureName == null) { this.textureName = string.Empty; } else { this.textureName = lbTerrainGrass.textureName; } this.minHeight = lbTerrainGrass.minHeight; this.maxHeight = lbTerrainGrass.maxHeight; this.minWidth = lbTerrainGrass.minWidth; this.maxWidth = lbTerrainGrass.maxWidth; this.healthyColour = lbTerrainGrass.healthyColour; this.dryColour = lbTerrainGrass.dryColour; this.noiseSpread = lbTerrainGrass.noiseSpread; this.minPopulatedHeight = lbTerrainGrass.minPopulatedHeight; this.maxPopulatedHeight = lbTerrainGrass.maxPopulatedHeight; this.minInclination = lbTerrainGrass.minInclination; this.maxInclination = lbTerrainGrass.maxInclination; this.influence = lbTerrainGrass.influence; this.minDensity = lbTerrainGrass.minDensity; this.density = lbTerrainGrass.density; this.detailRenderMode = lbTerrainGrass.detailRenderMode; this.isCurvatureConcave = lbTerrainGrass.isCurvatureConcave; this.curvatureDistance = lbTerrainGrass.curvatureDistance; this.curvatureMinHeightDiff = lbTerrainGrass.curvatureMinHeightDiff; this.grassPlacingMode = lbTerrainGrass.grassPlacingMode; this.grassPatchFadingMode = lbTerrainGrass.grassPatchFadingMode; this.map = lbTerrainGrass.map; this.mapColour = lbTerrainGrass.mapColour; this.mapTolerance = lbTerrainGrass.mapTolerance; this.mapInverse = lbTerrainGrass.mapInverse; this.mapToleranceBlendCurve = lbTerrainGrass.mapToleranceBlendCurve; this.mapIsPath = lbTerrainGrass.mapIsPath; this.isDisabled = lbTerrainGrass.isDisabled; if (lbTerrainGrass.filterList != null) { this.filterList = LBFilter.CopyList(lbTerrainGrass.filterList); } else { this.filterList = new List <LBFilter>(); } this.showGrass = lbTerrainGrass.showGrass; this.useNoise = lbTerrainGrass.useNoise; this.noiseTileSize = lbTerrainGrass.noiseTileSize; this.noiseOctaves = lbTerrainGrass.noiseOctaves; this.grassPlacementCutoff = lbTerrainGrass.grassPlacementCutoff; if (lbTerrainGrass.lbTerrainDataList == null) { this.lbTerrainDataList = null; } else { this.lbTerrainDataList = new List <LBTerrainData>(lbTerrainGrass.lbTerrainDataList); } this.useMeshPrefab = lbTerrainGrass.useMeshPrefab; this.meshPrefab = lbTerrainGrass.meshPrefab; if (lbTerrainGrass.meshPrefabName == null) { this.meshPrefabName = string.Empty; } else { this.meshPrefabName = lbTerrainGrass.meshPrefabName; } this.showPrefabPreview = lbTerrainGrass.showPrefabPreview; this.GUID = lbTerrainGrass.GUID; }
/// <summary> /// Constructor for cloning a layer /// </summary> /// <param name="lbLandscapeMesh"></param> public LBLandscapeMesh(LBLandscapeMesh lbLandscapeMesh) { this.mesh = lbLandscapeMesh.mesh; this.materials = new List <Material>(lbLandscapeMesh.materials); this.offset = lbLandscapeMesh.offset; this.maxMeshes = lbLandscapeMesh.maxMeshes; this.minProximity = lbLandscapeMesh.minProximity; this.randomiseYRotation = lbLandscapeMesh.randomiseYRotation; this.fixedYRotation = lbLandscapeMesh.fixedYRotation; this.XRotation = lbLandscapeMesh.XRotation; this.ZRotation = lbLandscapeMesh.ZRotation; this.isTerrainAligned = lbLandscapeMesh.isTerrainAligned; this.minScale = lbLandscapeMesh.minScale; this.maxScale = lbLandscapeMesh.maxScale; this.minHeight = lbLandscapeMesh.minHeight; this.maxHeight = lbLandscapeMesh.maxHeight; this.minInclination = lbLandscapeMesh.minInclination; this.maxInclination = lbLandscapeMesh.maxInclination; this.meshPlacingMode = lbLandscapeMesh.meshPlacingMode; this.map = lbLandscapeMesh.map; this.mapColour = lbLandscapeMesh.mapColour; this.mapTolerance = lbLandscapeMesh.mapTolerance; this.mapToleranceBlendCurve = new AnimationCurve(lbLandscapeMesh.mapToleranceBlendCurve.keys); this.mapIsPath = lbLandscapeMesh.mapIsPath; this.useNoise = lbLandscapeMesh.useNoise; this.noiseTileSize = lbLandscapeMesh.noiseTileSize; this.noiseOffset = lbLandscapeMesh.noiseOffset; this.meshPlacementCutoff = lbLandscapeMesh.meshPlacementCutoff; this.isClustered = lbLandscapeMesh.isClustered; this.clusterDistance = lbLandscapeMesh.clusterDistance; this.clusterDensity = lbLandscapeMesh.clusterDensity; this.clusterResolution = lbLandscapeMesh.clusterResolution; this.removeGrass = lbLandscapeMesh.removeGrass; this.minGrassProximity = lbLandscapeMesh.minGrassProximity; this.showMesh = lbLandscapeMesh.showMesh; this.isDisabled = lbLandscapeMesh.isDisabled; this.usePrefab = lbLandscapeMesh.usePrefab; this.prefab = lbLandscapeMesh.prefab; this.isCombineMesh = lbLandscapeMesh.isCombineMesh; this.isCreateCollider = lbLandscapeMesh.isCreateCollider; this.isRemoveEmptyGameObjects = lbLandscapeMesh.isRemoveEmptyGameObjects; this.minTreeProximity = lbLandscapeMesh.minTreeProximity; this.isTerrainFlattened = lbLandscapeMesh.isTerrainFlattened; this.flattenDistance = lbLandscapeMesh.flattenDistance; this.flattenBlendRate = lbLandscapeMesh.flattenBlendRate; this.flattenHeightOffset = lbLandscapeMesh.flattenHeightOffset; if (lbLandscapeMesh.filterList != null) { this.filterList = LBFilter.CopyList(lbLandscapeMesh.filterList); } else { this.filterList = new List <LBFilter>(); } this.isKeepPrefabConnection = lbLandscapeMesh.isKeepPrefabConnection; if (lbLandscapeMesh.prefabName == null) { this.prefabName = string.Empty; } else { this.prefabName = lbLandscapeMesh.prefabName; } }
/// <summary> /// Update the landscape to the current version /// v2.0.2 Upgrades the Texture, Grass, and Tree list to include any missing GUIDs. /// v2.1.5 Updates Groups to include any missing GUIDs /// v2.3.2 Update Texture Filters for Grass and Trees to NOT cutOff value of 0.1 /// </summary> /// <param name="OldVersion"></param> /// <param name="NewVersion"></param> /// <param name="landscapeToUpdate"></param> /// <param name="isSilentUpdate"></param> /// <returns></returns> public static bool LandscapeUpdate(string OldVersion, string NewVersion, ref LBLandscape landscapeToUpdate, bool isSilentUpdate = false) { bool isSuccessful = false; if (landscapeToUpdate == null) { #if UNITY_EDITOR if (!isSilentUpdate) { Debug.LogError("LBUpdate LandscapeUpdate - no landscape to update"); } #endif } else { //Debug.Log("LBUpdate LandscapeUpdate - upgrading " + landscapeToUpdate.gameObject.name + " from version " + OldVersion + " to " + NewVersion); landscapeToUpdate.LastUpdatedVersion = NewVersion; int majorVersion = landscapeToUpdate.GetLastUpdateMajorVersion; int minorVersion = landscapeToUpdate.GetLastUpdateMinorVersion; int patchVersion = landscapeToUpdate.GetLastUpdatePatchVersion; // Before a Landscape is imported, it doesn't have a grass list, so check first. if (landscapeToUpdate.terrainGrassList != null) { // Update any Grass types that don't have a GUID List <LBTerrainGrass> updateableGrassList = landscapeToUpdate.terrainGrassList.FindAll(grs => string.IsNullOrEmpty(grs.GUID)); int numGrassToUpdate = updateableGrassList == null ? 0 : updateableGrassList.Count; for (int gIdx = 0; gIdx < numGrassToUpdate; gIdx++) { updateableGrassList[gIdx].GUID = System.Guid.NewGuid().ToString(); } // Has landscape been created before 2.3.2? // For Texture NOT filters, reset cutOff to default of 0.1 to mimic pre-2.3.2 behaviour. // Fix Texture filter GUIDs if (majorVersion == 1 || (majorVersion == 2 && minorVersion <= 3 && (minorVersion < 3 || patchVersion < 2))) { numGrassToUpdate = landscapeToUpdate.terrainGrassList == null ? 0 : landscapeToUpdate.terrainGrassList.Count; for (int gIdx = 0; gIdx < numGrassToUpdate; gIdx++) { if (LBFilter.Contains(landscapeToUpdate.terrainGrassList[gIdx].filterList, LBFilter.FilterType.Texture)) { LBFilter.UpdateTextures(landscapeToUpdate.terrainGrassList[gIdx].filterList, landscapeToUpdate.terrainTexturesList, !isSilentUpdate); foreach (LBFilter lbFilter in landscapeToUpdate.terrainGrassList[gIdx].filterList) { if (lbFilter != null && lbFilter.filterType == LBFilter.FilterType.Texture && lbFilter.filterMode == LBFilter.FilterMode.NOT && lbFilter.cutOff == 0.5f) { lbFilter.cutOff = 0.1f; } } } } } } // Before a Landscape is imported, it doesn't have a texture list, so check first. if (landscapeToUpdate.terrainTexturesList != null) { // Update any Texture types that don't have a GUID List <LBTerrainTexture> updateableTextureList = landscapeToUpdate.terrainTexturesList.FindAll(tx => string.IsNullOrEmpty(tx.GUID)); int numTexturesToUpdate = (updateableTextureList == null ? 0 : updateableTextureList.Count); for (int txIdx = 0; txIdx < numTexturesToUpdate; txIdx++) { updateableTextureList[txIdx].GUID = System.Guid.NewGuid().ToString(); } } // Before a Landscape is imported, it doesn't have a tree list, so check first. if (landscapeToUpdate.terrainTreesList != null) { // Update any Tree types that don't have a GUID List <LBTerrainTree> updateableTreeList = landscapeToUpdate.terrainTreesList.FindAll(tr => string.IsNullOrEmpty(tr.GUID)); int numTreesToUpdate = updateableTreeList == null ? 0 : updateableTreeList.Count; for (int trIdx = 0; trIdx < numTreesToUpdate; trIdx++) { updateableTreeList[trIdx].GUID = System.Guid.NewGuid().ToString(); } // Has landscape been created before 2.3.2? // For Texture NOT filters, reset cutOff to default of 0.1 to mimic pre-2.3.2 behaviour. if (majorVersion == 1 || (majorVersion == 2 && minorVersion <= 3 && (minorVersion < 3 || patchVersion < 2))) { numTreesToUpdate = landscapeToUpdate.terrainTreesList == null ? 0 : landscapeToUpdate.terrainTreesList.Count; for (int trIdx = 0; trIdx < numTreesToUpdate; trIdx++) { if (LBFilter.Contains(landscapeToUpdate.terrainTreesList[trIdx].filterList, LBFilter.FilterType.Texture)) { LBFilter.UpdateTextures(landscapeToUpdate.terrainTreesList[trIdx].filterList, landscapeToUpdate.terrainTexturesList, !isSilentUpdate); foreach (LBFilter lbFilter in landscapeToUpdate.terrainTreesList[trIdx].filterList) { if (lbFilter != null && lbFilter.filterType == LBFilter.FilterType.Texture && lbFilter.filterMode == LBFilter.FilterMode.NOT && lbFilter.cutOff == 0.5f) { lbFilter.cutOff = 0.1f; } } } } } } // To use SubGroups, Groups need to have a unique identifier if (landscapeToUpdate.lbGroupList != null) { // Update any Groups that don't have a GUID List <LBGroup> updateableGroupList = landscapeToUpdate.lbGroupList.FindAll(grp => string.IsNullOrEmpty(grp.GUID)); int numGroupsToUpdate = updateableGroupList == null ? 0 : updateableGroupList.Count; for (int gpIdx = 0; gpIdx < numGroupsToUpdate; gpIdx++) { updateableGroupList[gpIdx].GUID = System.Guid.NewGuid().ToString(); } } #if UNITY_EDITOR if (!isSilentUpdate) { Debug.Log("LBUpdate LandscapeUpdate - upgraded " + landscapeToUpdate.gameObject.name + " from version " + OldVersion + " to " + NewVersion); } #endif isSuccessful = true; } return(isSuccessful); }
/// <summary> /// Script out the Tree for use in a runtime script. /// TreeIdx is the zero-based position in the terrainTreesList /// </summary> /// <param name="TreeIdx"></param> /// <param name="EndOfLineMarker"></param> /// <returns></returns> public string ScriptTree(int TreeIdx, string EndOfLineMarker = "\n") { // Create a new instance of StringBuilder and give it an estimated capacity System.Text.StringBuilder sb = new System.Text.StringBuilder(1000); string eol = " "; // We always need a space between lines OR a end of line marker like "\n" if (EndOfLineMarker.Length > 0) { eol = EndOfLineMarker; } string treeInst = "lbTerrainTree" + (TreeIdx + 1); string treeInstAbrev = "Tree" + (TreeIdx + 1); sb.Append("// Tree Code generated from Landscape Builder 2 at " + System.DateTime.Now.ToShortTimeString() + " on " + System.DateTime.Now.ToLongDateString() + eol + eol); sb.Append("// BEGIN Public variables to populate in the editor - Uncomment and add these to top of class " + eol); sb.Append("//[Header(\"Tree" + (TreeIdx + 1) + "\")] " + eol); sb.Append("//public GameObject prefab" + treeInstAbrev + "; " + eol); sb.Append("//public Texture2D map" + treeInstAbrev + "; " + eol); sb.Append("// END Public variables" + eol + eol); sb.Append("#region LBTerrainTree" + (TreeIdx + 1) + eol); sb.Append("LBTerrainTree " + treeInst + " = new LBTerrainTree(); " + eol); sb.Append("if (" + treeInst + " != null)" + eol); sb.Append("{" + eol); sb.Append("\t" + treeInst + ".maxTreesPerSqrKm = " + maxTreesPerSqrKm + "; " + eol); sb.Append("\t" + treeInst + ".bendFactor = " + bendFactor + "f; " + eol); sb.Append("\t" + treeInst + ".prefab = prefab" + treeInstAbrev + "; " + eol); sb.Append("\t" + treeInst + ".minScale = " + minScale + "f; " + eol); sb.Append("\t" + treeInst + ".maxScale = " + maxScale + "f; " + eol); sb.Append("\t" + treeInst + ".treeScalingMode = LBTerrainTree.TreeScalingMode." + treeScalingMode + "; " + eol); sb.Append("\t" + treeInst + ".lockWidthToHeight = " + lockWidthToHeight.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".minProximity = " + minProximity + "f; " + eol); sb.Append("\t" + treeInst + ".minHeight = " + minHeight + "f; " + eol); sb.Append("\t" + treeInst + ".maxHeight = " + maxHeight + "f; " + eol); sb.Append("\t" + treeInst + ".minInclination = " + minInclination + "f; " + eol); sb.Append("\t" + treeInst + ".maxInclination = " + maxInclination + "f; " + eol); sb.Append("\t" + treeInst + ".treePlacingMode = LBTerrainTree.TreePlacingMode." + treePlacingMode + "; " + eol); sb.Append("\t" + treeInst + ".isCurvatureConcave = " + isCurvatureConcave.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".curvatureDistance = " + curvatureDistance + "f; " + eol); sb.Append("\t" + treeInst + ".curvatureMinHeightDiff = " + curvatureMinHeightDiff + "f; " + eol); sb.Append("\t" + treeInst + ".map = map" + treeInstAbrev + "; " + eol); sb.Append("\t" + treeInst + ".mapColour = new Color(" + mapColour.r + "f, " + mapColour.g + "f, " + mapColour.b + "f, " + mapColour.a + "f); " + eol); sb.Append("\t" + treeInst + ".mapTolerance = " + mapTolerance + "; " + eol); sb.Append("\t" + treeInst + ".mapInverse = " + mapInverse.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".useNoise = " + useNoise.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".noiseTileSize = " + noiseTileSize + "f; " + eol); sb.Append("\t" + treeInst + ".noiseOffset = " + noiseOffset + "f; " + eol); sb.Append("\t" + treeInst + ".treePlacementCutoff = " + treePlacementCutoff + "f; " + eol); sb.Append("\t" + treeInst + ".mapToleranceBlendCurve = LBMap.GetDefaultToleranceBlendCurve; " + eol); sb.Append("\t" + treeInst + ".mapIsPath = " + mapIsPath.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".isDisabled = " + isDisabled.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".offsetY = " + offsetY + "f; " + eol); sb.Append("\t" + treeInst + ".showTree = " + showTree.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".isTinted = " + isTinted.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".maxTintStrength = " + maxTintStrength + "f; " + eol); sb.Append("\t" + treeInst + ".tintColour = new Color(" + tintColour.r + "f, " + tintColour.g + "f, " + tintColour.b + "f, " + tintColour.a + "f); " + eol); sb.Append("\t" + treeInst + ".prefabName = " + (string.IsNullOrEmpty(prefabName) ? "\"\"" : "\"" + prefabName + "\"") + "; " + eol); sb.Append("\t" + treeInst + ".showPrefabPreview = " + showPrefabPreview.ToString().ToLower() + "; " + eol); sb.Append("\t" + treeInst + ".GUID = " + (string.IsNullOrEmpty(GUID) ? "\"\"" : "\"" + GUID + "\"") + "; " + eol); sb.Append("\t" + treeInst + ".filterList = new List<LBFilter>(); " + eol); if (filterList != null) { // Create a unique variable if (filterList.Exists(f => f.filterType == LBFilter.FilterType.StencilLayer)) { sb.Append("\tLBFilter lbFilter" + treeInstAbrev + " = null; " + eol); } for (int tf = 0; tf < filterList.Count; tf++) { LBFilter lbFilter = filterList[tf]; if (lbFilter != null) { if (lbFilter.filterType == LBFilter.FilterType.StencilLayer) { sb.Append("\tlbFilter" + treeInstAbrev + " = LBFilter.CreateFilter(\"" + lbFilter.lbStencilGUID + "\", \"" + lbFilter.lbStencilLayerGUID + "\", false); " + eol); sb.Append("\tif (lbFilter" + treeInstAbrev + " != null) " + eol); sb.Append("\t{ " + eol); sb.Append("\t\tlbFilter" + treeInstAbrev + ".filterMode = LBFilter.FilterMode." + lbFilter.filterMode + ";" + eol); sb.Append("\t\t" + treeInst + ".filterList.Add(lbFilter" + treeInstAbrev + "); " + eol); sb.Append("\t} " + eol); sb.Append(eol); } else { sb.Append("\t// Currently we do not output non-Stencil filters for runtime Trees. Contact support or post in our Unity forum if you need this feature." + eol); } } } } sb.Append("\t" + treeInst + ".lbTerrainDataList = null; " + eol); sb.Append("\t// NOTE Add the new Tree to the landscape meta-data"); sb.Append(eol); sb.Append("\tlandscape.terrainTreesList.Add(" + treeInst + ");"); sb.Append(eol); sb.Append("}" + eol); sb.Append("#endregion" + eol); sb.Append("// END OF CODE SEGMENT" + eol); return(sb.ToString()); }
/// <summary> /// Clone Constructor /// </summary> /// <param name="lbTerrainTree"></param> public LBTerrainTree(LBTerrainTree lbTerrainTree) { this.maxTreesPerSqrKm = lbTerrainTree.maxTreesPerSqrKm; this.bendFactor = lbTerrainTree.bendFactor; this.prefab = lbTerrainTree.prefab; this.minScale = lbTerrainTree.minScale; this.maxScale = lbTerrainTree.maxScale; this.treeScalingMode = lbTerrainTree.treeScalingMode; this.lockWidthToHeight = lbTerrainTree.lockWidthToHeight; this.minProximity = lbTerrainTree.minProximity; this.minHeight = lbTerrainTree.minHeight; this.maxHeight = lbTerrainTree.maxHeight; this.minInclination = lbTerrainTree.minInclination; this.maxInclination = lbTerrainTree.maxInclination; this.treePlacingMode = lbTerrainTree.treePlacingMode; this.isCurvatureConcave = lbTerrainTree.isCurvatureConcave; this.curvatureDistance = lbTerrainTree.curvatureDistance; this.curvatureMinHeightDiff = lbTerrainTree.curvatureMinHeightDiff; this.map = lbTerrainTree.map; this.mapColour = lbTerrainTree.mapColour; this.mapTolerance = lbTerrainTree.mapTolerance; this.mapInverse = lbTerrainTree.mapInverse; this.useNoise = lbTerrainTree.useNoise; this.noiseTileSize = lbTerrainTree.noiseTileSize; this.noiseOffset = lbTerrainTree.noiseOffset; this.treePlacementCutoff = lbTerrainTree.treePlacementCutoff; this.mapToleranceBlendCurve = lbTerrainTree.mapToleranceBlendCurve; this.mapIsPath = lbTerrainTree.mapIsPath; this.isDisabled = lbTerrainTree.isDisabled; this.offsetY = lbTerrainTree.offsetY; this.showTree = lbTerrainTree.showTree; if (lbTerrainTree.filterList != null) { this.filterList = LBFilter.CopyList(lbTerrainTree.filterList); } else { this.filterList = new List <LBFilter>(); } this.isTinted = lbTerrainTree.isTinted; this.maxTintStrength = lbTerrainTree.maxTintStrength; this.tintColour = lbTerrainTree.tintColour; if (lbTerrainTree.lbTerrainDataList == null) { this.lbTerrainDataList = null; } else { this.lbTerrainDataList = new List <LBTerrainData>(lbTerrainTree.lbTerrainDataList); } if (lbTerrainTree.prefabName == null) { this.prefabName = string.Empty; } else { this.prefabName = lbTerrainTree.prefabName; } this.showPrefabPreview = lbTerrainTree.showPrefabPreview; this.GUID = lbTerrainTree.GUID; }