private void Awake()
{
// Disable self if mod not enabled
if (!DaggerfallUnity.Settings.UncannyValley_RealGrass)
{
gameObject.SetActive(false);
return;
}
//Subscribe to the onPromoteTerrainData
DaggerfallTerrain.OnPromoteTerrainData += AddGrass;
//Create a holder for our grass
detailPrototype = new DetailPrototype[1];
detailPrototype[0] = new DetailPrototype();
//All the settings
detailPrototype[0].minHeight = 0.65f;
detailPrototype[0].minWidth = 0.65f;
detailPrototype[0].maxHeight = 1.0f;
detailPrototype[0].maxWidth = 1.0f;
detailPrototype[0].noiseSpread = 0.4f;
detailPrototype[0].healthyColor = new Color(0.70f, 0.70f, 0.70f);
detailPrototype[0].dryColor = new Color(0.70f, 0.70f, 0.70f);
detailPrototype[0].renderMode = UnityEngine.DetailRenderMode.GrassBillboard;
}
public void SetPreviewGrassTexture()
{
TC_Settings localSettings = TC_Settings.instance;
if (localSettings.hasMasterTerrain)
{
if (selectIndex < localSettings.masterTerrain.terrainData.detailPrototypes.Length && selectIndex >= 0)
{
DetailPrototype detailPrototype = localSettings.masterTerrain.terrainData.detailPrototypes[selectIndex];
if (detailPrototype.usePrototypeMesh)
{
#if UNITY_EDITOR
preview.tex = UnityEditor.AssetPreview.GetAssetPreview(detailPrototype.prototype);
#endif
}
else
{
preview.tex = detailPrototype.prototypeTexture;
}
if (preview.tex != null)
{
name = Mathw.CutString(preview.tex.name, TC.nodeLabelLength);
}
}
else
{
active = false;
}
}
else
{
preview.tex = null;
}
}
protected override bool DrawWizardGUI()
{
EditorGUI.BeginChangeCheck();
Rect r = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
m_DetailTexture = EditorGUI.ObjectField(r, "Detail Texture", m_DetailTexture, typeof(Texture2D), !TerrainDataIsPersistent) as Texture2D;
m_AlignToGround = EditorGUILayout.Slider(DetailWizardSharedStyles.Instance.alignToGround, m_AlignToGround, 0, 100);
m_PositionOrderliness = EditorGUILayout.Slider(DetailWizardSharedStyles.Instance.positionOrderliness, m_PositionOrderliness, 0, 100);
m_MinWidth = EditorGUILayout.FloatField("Min Width", m_MinWidth);
m_MaxWidth = EditorGUILayout.FloatField("Max Width", m_MaxWidth);
m_MinHeight = EditorGUILayout.FloatField("Min Height", m_MinHeight);
m_MaxHeight = EditorGUILayout.FloatField("Max Height", m_MaxHeight);
m_NoiseSeed = EditorGUILayout.IntField(DetailWizardSharedStyles.Instance.noiseSeed, m_NoiseSeed);
m_NoiseSpread = EditorGUILayout.FloatField(DetailWizardSharedStyles.Instance.noiseSpread, m_NoiseSpread);
GUI.enabled = terrainData.detailScatterMode == DetailScatterMode.CoverageMode;
m_DetailDensity = EditorGUILayout.Slider(DetailWizardSharedStyles.Instance.detailDensity, m_DetailDensity, 0, 5);
GUI.enabled = true;
m_HoleEdgePadding = EditorGUILayout.Slider(DetailWizardSharedStyles.Instance.holeEdgePadding, m_HoleEdgePadding, 0, 100);
m_HealthyColor = EditorGUILayout.ColorField("Healthy Color", m_HealthyColor);
m_DryColor = EditorGUILayout.ColorField("Dry Color", m_DryColor);
m_Billboard = EditorGUILayout.Toggle("Billboard", m_Billboard);
m_UseDensityScaling = EditorGUILayout.Toggle(DetailWizardSharedStyles.Instance.useDensityScaling, m_UseDensityScaling);
if (!DetailPrototype.IsModeSupportedByRenderPipeline(ComputeRenderMode(m_Billboard), false, out var message))
{
EditorGUILayout.LabelField(EditorGUIUtility.TempContent(message, EditorGUIUtility.GetHelpIcon(MessageType.Error)), DetailWizardSharedStyles.Instance.helpBoxBig);
}
return(EditorGUI.EndChangeCheck());
}
public void UpdateProperties(GrassPrefab item)
{
foreach (Terrain terrain in terrains)
{
//Note only works when creating these copies :/
DetailPrototype[] detailPrototypes = terrain.terrainData.detailPrototypes;
DetailPrototype detailPrototype = GetGrassPrototype(item, terrain);
//Could have been removed
if (detailPrototype == null)
{
continue;
}
UpdateGrassItem(item, detailPrototype);
detailPrototypes[item.index] = detailPrototype;
terrain.terrainData.detailPrototypes = detailPrototypes;
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(terrain);
UnityEditor.EditorUtility.SetDirty(terrain.terrainData);
#endif
}
}
/// <summary>
/// Deep-copies an array of detail prototype instances
/// </summary>
/// <param name="original">Prototypes to clone</param>
/// <returns>Cloned array</returns>
static DetailPrototype[] CloneDetailPrototypes(DetailPrototype[] original)
{
DetailPrototype[] protoDuplicate = new DetailPrototype[original.Length];
for (int n = 0; n < original.Length; n++)
{
protoDuplicate[n] = new DetailPrototype
{
bendFactor = original[n].bendFactor,
dryColor = original[n].dryColor,
healthyColor = original[n].healthyColor,
maxHeight = original[n].maxHeight,
maxWidth = original[n].maxWidth,
minHeight = original[n].minHeight,
minWidth = original[n].minWidth,
noiseSpread = original[n].noiseSpread,
prototype = original[n].prototype,
prototypeTexture = original[n].prototypeTexture,
renderMode = original[n].renderMode,
usePrototypeMesh = original[n].usePrototypeMesh,
};
}
return(protoDuplicate);
}
private void DoApply()
{
if ((UnityEngine.Object) this.terrainData == (UnityEngine.Object)null)
{
return;
}
DetailPrototype[] detailPrototypeArray1 = this.m_Terrain.terrainData.detailPrototypes;
if (this.m_PrototypeIndex == -1)
{
DetailPrototype[] detailPrototypeArray2 = new DetailPrototype[detailPrototypeArray1.Length + 1];
Array.Copy((Array)detailPrototypeArray1, 0, (Array)detailPrototypeArray2, 0, detailPrototypeArray1.Length);
this.m_PrototypeIndex = detailPrototypeArray1.Length;
detailPrototypeArray1 = detailPrototypeArray2;
detailPrototypeArray1[this.m_PrototypeIndex] = new DetailPrototype();
}
detailPrototypeArray1[this.m_PrototypeIndex].prototype = (GameObject)null;
detailPrototypeArray1[this.m_PrototypeIndex].prototypeTexture = this.m_DetailTexture;
detailPrototypeArray1[this.m_PrototypeIndex].minWidth = this.m_MinWidth;
detailPrototypeArray1[this.m_PrototypeIndex].maxWidth = this.m_MaxWidth;
detailPrototypeArray1[this.m_PrototypeIndex].minHeight = this.m_MinHeight;
detailPrototypeArray1[this.m_PrototypeIndex].maxHeight = this.m_MaxHeight;
detailPrototypeArray1[this.m_PrototypeIndex].noiseSpread = this.m_NoiseSpread;
detailPrototypeArray1[this.m_PrototypeIndex].healthyColor = this.m_HealthyColor;
detailPrototypeArray1[this.m_PrototypeIndex].dryColor = this.m_DryColor;
detailPrototypeArray1[this.m_PrototypeIndex].renderMode = !this.m_Billboard ? DetailRenderMode.Grass : DetailRenderMode.GrassBillboard;
detailPrototypeArray1[this.m_PrototypeIndex].usePrototypeMesh = false;
this.m_Terrain.terrainData.detailPrototypes = detailPrototypeArray1;
EditorUtility.SetDirty((UnityEngine.Object) this.m_Terrain);
}
public static int FindDetailPrototype(Terrain terrain, Terrain sourceTerrain, int sourceDetail)
{
if (sourceDetail == PaintDetailsTool.kInvalidDetail ||
sourceDetail >= sourceTerrain.terrainData.detailPrototypes.Length)
{
return(PaintDetailsTool.kInvalidDetail);
}
if (terrain == sourceTerrain)
{
return(sourceDetail);
}
DetailPrototype sourceDetailPrototype = sourceTerrain.terrainData.detailPrototypes[sourceDetail];
for (int i = 0; i < terrain.terrainData.detailPrototypes.Length; ++i)
{
if (sourceDetailPrototype.Equals(terrain.terrainData.detailPrototypes[i]))
{
return(i);
}
}
return(PaintDetailsTool.kInvalidDetail);
}
private static DetailPrototype CopyDetailPrototype(GISTerrainLoaderSO_Grass Source_item)
{
var detailPrototype = new DetailPrototype();
detailPrototype.renderMode = DetailRenderMode.GrassBillboard;
detailPrototype.prototypeTexture = Source_item.DetailTexture;
detailPrototype.minWidth = Source_item.MinWidth;
detailPrototype.maxWidth = Source_item.MaxWidth * GrassScaleFactor;
detailPrototype.minHeight = Source_item.MinHeight;
detailPrototype.maxHeight = Source_item.MaxHeight * GrassScaleFactor; detailPrototype.noiseSpread = Source_item.Noise;
detailPrototype.healthyColor = Source_item.HealthyColor;
detailPrototype.dryColor = Source_item.DryColor;
if (Source_item.BillBoard)
{
detailPrototype.renderMode = DetailRenderMode.GrassBillboard;
}
else
{
detailPrototype.renderMode = DetailRenderMode.Grass;
}
return(detailPrototype);
}
internal void InitializeDefaults(Terrain terrain, int index)
{
this.m_Terrain = terrain;
this.m_PrototypeIndex = index;
DetailPrototype detailPrototype = this.m_PrototypeIndex != -1 ? this.m_Terrain.terrainData.detailPrototypes[this.m_PrototypeIndex] : new DetailPrototype();
this.m_Detail = detailPrototype.prototype;
this.m_NoiseSpread = detailPrototype.noiseSpread;
this.m_MinWidth = detailPrototype.minWidth;
this.m_MaxWidth = detailPrototype.maxWidth;
this.m_MinHeight = detailPrototype.minHeight;
this.m_MaxHeight = detailPrototype.maxHeight;
this.m_HealthyColor = detailPrototype.healthyColor;
this.m_DryColor = detailPrototype.dryColor;
switch (detailPrototype.renderMode)
{
case DetailRenderMode.GrassBillboard:
Debug.LogError((object)"Detail meshes can't be rendered as billboards");
this.m_RenderMode = DetailMeshRenderMode.Grass;
break;
case DetailRenderMode.VertexLit:
this.m_RenderMode = DetailMeshRenderMode.VertexLit;
break;
case DetailRenderMode.Grass:
this.m_RenderMode = DetailMeshRenderMode.Grass;
break;
}
this.OnWizardUpdate();
}
void Prototypes()
{
Splats = new SplatPrototype[2];
Splats [0] = new SplatPrototype();
Splats [0].texture = splat0;
Splats [0].tileSize = new Vector2(SplatSize0, SplatSize0);
Splats [1] = new SplatPrototype();
Splats [1].texture = splat1;
Splats [1].tileSize = new Vector2(SplatSize1, SplatSize1);
Details = new DetailPrototype[3];
Details [0] = new DetailPrototype();
Details [0].prototypeTexture = detail0;
Details [0].renderMode = DetailRenderMode.GrassBillboard;
Details [0].healthyColor = Color.green;
Details [0].dryColor = Color.grey;
Details [1] = new DetailPrototype();
Details [1].prototypeTexture = detail1;
Details [1].renderMode = DetailRenderMode.GrassBillboard;
Details [1].healthyColor = Color.green;
Details [1].dryColor = Color.grey;
Details [2] = new DetailPrototype();
Details [2].prototypeTexture = detail2;
Details [2].renderMode = DetailRenderMode.GrassBillboard;
Details [2].healthyColor = Color.green;
Details [2].dryColor = Color.grey;
}
public override void OnEnterToolMode()
{
detailOpacity = EditorPrefs.GetFloat("TerrainDetailOpacity", 1.0f);
detailStrength = EditorPrefs.GetFloat("TerrainDetailStrength", 0.8f);
selectedDetail = EditorPrefs.GetInt("TerrainSelectedDetail", 0);
m_TargetTerrain = null;
if (Selection.activeGameObject != null)
{
m_TargetTerrain = Selection.activeGameObject.GetComponent <Terrain>();
}
if (m_TargetTerrain != null && m_TargetTerrain.terrainData != null)
{
var prototypes = m_TargetTerrain.terrainData.detailPrototypes;
if (m_LastSelectedDetailPrototype != null)
{
for (int i = 0; i < prototypes.Length; ++i)
{
if (m_LastSelectedDetailPrototype.Equals(prototypes[i]))
{
selectedDetail = i;
break;
}
}
}
selectedDetail = prototypes.Length > 0 ? Mathf.Clamp(selectedDetail, 0, prototypes.Length) : kInvalidDetail;
}
else
{
selectedDetail = kInvalidDetail;
}
m_LastSelectedDetailPrototype = null;
}
public override void OnEnterToolMode()
{
Terrain terrain = null;
if (Selection.activeGameObject != null)
{
terrain = Selection.activeGameObject.GetComponent <Terrain>();
}
if (terrain != null &&
terrain.terrainData != null &&
m_LastSelectedDetailPrototype != null)
{
for (int i = 0; i < terrain.terrainData.detailPrototypes.Length; ++i)
{
if (m_LastSelectedDetailPrototype.Equals(terrain.terrainData.detailPrototypes[i]))
{
selectedDetail = i;
break;
}
}
}
m_TargetTerrain = terrain;
m_LastSelectedDetailPrototype = null;
}
/*public byte[] EncodeAnimationCurve(AnimationCurve iAnimationCurve)
* {
* var keyBytes = EncodeArray(iAnimationCurve.keys);
* var keyBytesLenght = keyBytes.Length;
* var result = new byte[keyBytesLenght + 8];
* Buffer.BlockCopy(BitConverter.GetBytes((int)iAnimationCurve.preWrapMode), 0, result, 0, 4);
* Buffer.BlockCopy(BitConverter.GetBytes((int)iAnimationCurve.postWrapMode), 0, result, 4, 4);
* Buffer.BlockCopy(keyBytes, 0, result, 8, keyBytesLenght);
* return result;
* }
*
* public byte[] EncodeAnimationClip(AnimationClip iAnimationClip)
* {
* var result = new byte[0];
#if UNITY_EDITOR
* var curves = AnimationUtility.GetAllCurves(iAnimationClip);
*
#endif
*
* return result;
* }*/
Hashtable DetailPrototype(DetailPrototype obj)
{
var table = new Hashtable();
table.Add("prototype", obj.prototype);
return(table);
}
private void DoApply()
{
if (base.terrainData != null)
{
DetailPrototype[] detailPrototypes = base.m_Terrain.terrainData.detailPrototypes;
if (this.m_PrototypeIndex == -1)
{
DetailPrototype[] destinationArray = new DetailPrototype[detailPrototypes.Length + 1];
Array.Copy(detailPrototypes, 0, destinationArray, 0, detailPrototypes.Length);
this.m_PrototypeIndex = detailPrototypes.Length;
detailPrototypes = destinationArray;
detailPrototypes[this.m_PrototypeIndex] = new DetailPrototype();
}
detailPrototypes[this.m_PrototypeIndex].prototype = null;
detailPrototypes[this.m_PrototypeIndex].prototypeTexture = this.m_DetailTexture;
detailPrototypes[this.m_PrototypeIndex].minWidth = this.m_MinWidth;
detailPrototypes[this.m_PrototypeIndex].maxWidth = this.m_MaxWidth;
detailPrototypes[this.m_PrototypeIndex].minHeight = this.m_MinHeight;
detailPrototypes[this.m_PrototypeIndex].maxHeight = this.m_MaxHeight;
detailPrototypes[this.m_PrototypeIndex].noiseSpread = this.m_NoiseSpread;
detailPrototypes[this.m_PrototypeIndex].healthyColor = this.m_HealthyColor;
detailPrototypes[this.m_PrototypeIndex].dryColor = this.m_DryColor;
detailPrototypes[this.m_PrototypeIndex].renderMode = !this.m_Billboard ? DetailRenderMode.Grass : DetailRenderMode.GrassBillboard;
detailPrototypes[this.m_PrototypeIndex].usePrototypeMesh = false;
base.m_Terrain.terrainData.detailPrototypes = detailPrototypes;
EditorUtility.SetDirty(base.m_Terrain);
}
}
void CreateProtoTypes()
{
if (_AddTrees)
{
_treeData = new TreePrototype[_Trees.Length];
for (int i = 0; i < _Trees.Length; i++)
{
_treeData[i] = new TreePrototype();
_treeData[i].prefab = _Trees[i];
}
}
if (_AddTexture)
{
_TerrainTexture[0] = new SplatPrototype();
_TerrainTexture[0].texture = _TerTexture;
}
if (_AddGrass)
{
_detailData = new DetailPrototype[1];
_detailData[0] = new DetailPrototype();
_detailData[0].prototypeTexture = _Grass;
_detailData[0].renderMode = DetailRenderMode.GrassBillboard;
}
}
/// <summary>
/// Converts a Terrain Grass list to a Detail Prototype list
/// </summary>
/// <returns>The detail prototype list.</returns>
/// <param name="terrainGrassList">Terrain grass list.</param>
public static List <DetailPrototype> ToDetailPrototypeList(List <LBTerrainGrass> terrainGrassList)
{
if (terrainGrassList != null)
{
List <DetailPrototype> detailPrototypeList = new List <DetailPrototype>();
for (int i = 0; i < terrainGrassList.Count; i++)
{
DetailPrototype temp = new DetailPrototype();
// NOTE: Texture will be null if a mesh is being used
temp.prototypeTexture = terrainGrassList[i].texture;
temp.minHeight = terrainGrassList[i].minHeight;
temp.maxHeight = terrainGrassList[i].maxHeight;
temp.minWidth = terrainGrassList[i].minWidth;
temp.maxWidth = terrainGrassList[i].maxWidth;
temp.dryColor = terrainGrassList[i].dryColour;
temp.healthyColor = terrainGrassList[i].healthyColour;
temp.noiseSpread = terrainGrassList[i].noiseSpread;
temp.renderMode = terrainGrassList[i].detailRenderMode;
// Used when using a mesh prefab instead of a texture for the grass
temp.usePrototypeMesh = terrainGrassList[i].useMeshPrefab;
temp.prototype = terrainGrassList[i].meshPrefab;
detailPrototypeList.Add(temp);
}
return(detailPrototypeList);
}
else
{
return(null);
}
}
private void UpdateGrassItem(GrassPrefab item, DetailPrototype d)
{
d.healthyColor = item.mainColor;
d.dryColor = item.secondairyColor;
d.minHeight = item.minMaxHeight.x;
d.maxHeight = item.minMaxHeight.y;
d.minWidth = item.minMaxWidth.x;
d.maxWidth = item.minMaxWidth.y;
d.noiseSpread = item.noiseSize;
d.prototype = item.prefab;
d.prototypeTexture = item.billboard;
if (item.type == GrassType.Mesh && item.prefab)
{
d.renderMode = DetailRenderMode.Grass; //Actually mesh
d.usePrototypeMesh = true;
d.prototype = item.prefab;
d.prototypeTexture = null;
}
if (item.type == GrassType.Billboard && item.billboard)
{
d.renderMode = DetailRenderMode.GrassBillboard;
d.usePrototypeMesh = false;
d.prototypeTexture = item.billboard;
d.prototype = null;
}
}
private static void ScaleGrassDetail(DetailPrototype reference, DetailPrototype prototype, GrassDetail detail)
{
prototype.minHeight = reference.minHeight * detail.HeightModifier;
prototype.maxHeight = reference.maxHeight * detail.HeightModifier;
prototype.minWidth = reference.minWidth * detail.WidthModifier;
prototype.maxWidth = reference.maxWidth * detail.WidthModifier;
}
private DetailPrototype[] GetDetailPrototypes()
{
var detailPrototypes = new DetailPrototype[_detailsData.Count];
for (var i = 0; i < _detailsData.Count; i++)
{
var item = _detailsData.GetObjectAt(i);
detailPrototypes[i] = new DetailPrototype
{
prototype = item.Prototype,
prototypeTexture = item.PrototypeTexture,
healthyColor = item.HealthyColor,
dryColor = item.DryColor,
minHeight = item.HeightRange.x,
maxHeight = item.HeightRange.y,
minWidth = item.WidthRange.x,
maxWidth = item.WidthRange.y,
noiseSpread = item.NoiseSpread
};
if (detailPrototypes[i].prototype)
{
detailPrototypes[i].usePrototypeMesh = true;
detailPrototypes[i].renderMode = DetailRenderMode.VertexLit;
}
else
{
detailPrototypes[i].usePrototypeMesh = false;
detailPrototypes[i].renderMode = DetailRenderMode.GrassBillboard;
}
}
return(detailPrototypes);
}
private void DoApply()
{
if (base.terrainData == null)
{
return;
}
DetailPrototype[] array = this.m_Terrain.terrainData.detailPrototypes;
if (this.m_PrototypeIndex == -1)
{
DetailPrototype[] array2 = new DetailPrototype[array.Length + 1];
Array.Copy(array, 0, array2, 0, array.Length);
this.m_PrototypeIndex = array.Length;
array = array2;
array[this.m_PrototypeIndex] = new DetailPrototype();
}
array[this.m_PrototypeIndex].prototype = null;
array[this.m_PrototypeIndex].prototypeTexture = this.m_DetailTexture;
array[this.m_PrototypeIndex].minWidth = this.m_MinWidth;
array[this.m_PrototypeIndex].maxWidth = this.m_MaxWidth;
array[this.m_PrototypeIndex].minHeight = this.m_MinHeight;
array[this.m_PrototypeIndex].maxHeight = this.m_MaxHeight;
array[this.m_PrototypeIndex].noiseSpread = this.m_NoiseSpread;
array[this.m_PrototypeIndex].healthyColor = this.m_HealthyColor;
array[this.m_PrototypeIndex].dryColor = this.m_DryColor;
array[this.m_PrototypeIndex].renderMode = ((!this.m_Billboard) ? DetailRenderMode.Grass : DetailRenderMode.GrassBillboard);
array[this.m_PrototypeIndex].usePrototypeMesh = false;
this.m_Terrain.terrainData.detailPrototypes = array;
EditorUtility.SetDirty(this.m_Terrain);
}
/// <summary>
/// Load assets for Desert, which doesn't support seasons.
/// </summary>
public void UpdateClimateDesert()
{
if (!NeedsUpdate(UpdateType.Desert, ClimateBases.Desert))
{
return;
}
SetGrass(desertGrass, desertGrass);
sizeColor.RefreshDesert();
DetailPrototype detailPrototype = DetailPrototypes[Grass];
detailPrototype.healthyColor = Color.white;
detailPrototype.dryColor = new Color(0.89f, 0.67f, 0.67f);
detailPrototype.noiseSpread = 0.8f;
if (options.WaterPlants)
{
ResetColor(DetailPrototypes[WaterPlants]);
DetailPrototypes[WaterPlants].prototype = LoadGameObject(plantsDesert);
}
if (options.TerrainStones)
{
DetailPrototypes[Rocks].prototype = LoadGameObject(rock);
DetailPrototypes[Rocks].healthyColor = Color.white;
DetailPrototypes[Rocks].dryColor = new Color(0.85f, 0.85f, 0.85f);
}
}
void DoApply()
{
if (terrainData == null)
{
return;
}
DetailPrototype[] prototypes = m_Terrain.terrainData.detailPrototypes;
if (m_PrototypeIndex == -1)
{
// Add a new detailprototype to the prototype arrays
DetailPrototype[] newarray = new DetailPrototype[prototypes.Length + 1];
System.Array.Copy(prototypes, 0, newarray, 0, prototypes.Length);
m_PrototypeIndex = prototypes.Length;
prototypes = newarray;
prototypes[m_PrototypeIndex] = new DetailPrototype();
}
prototypes[m_PrototypeIndex].prototype = null;
prototypes[m_PrototypeIndex].prototypeTexture = m_DetailTexture;
prototypes[m_PrototypeIndex].minWidth = m_MinWidth;
prototypes[m_PrototypeIndex].maxWidth = m_MaxWidth;
prototypes[m_PrototypeIndex].minHeight = m_MinHeight;
prototypes[m_PrototypeIndex].maxHeight = m_MaxHeight;
prototypes[m_PrototypeIndex].noiseSpread = m_NoiseSpread;
prototypes[m_PrototypeIndex].healthyColor = m_HealthyColor;
prototypes[m_PrototypeIndex].dryColor = m_DryColor;
prototypes[m_PrototypeIndex].renderMode = m_Billboard ? DetailRenderMode.GrassBillboard : DetailRenderMode.Grass;
prototypes[m_PrototypeIndex].usePrototypeMesh = false;
m_Terrain.terrainData.detailPrototypes = prototypes;
EditorUtility.SetDirty(m_Terrain);
}
internal void InitializeDefaults(Terrain terrain, int index)
{
this.m_Terrain = terrain;
this.m_PrototypeIndex = index;
DetailPrototype detailPrototype;
if (this.m_PrototypeIndex == -1)
{
detailPrototype = new DetailPrototype();
detailPrototype.renderMode = DetailRenderMode.GrassBillboard;
}
else
{
detailPrototype = this.m_Terrain.terrainData.detailPrototypes[this.m_PrototypeIndex];
}
this.m_DetailTexture = detailPrototype.prototypeTexture;
this.m_MinWidth = detailPrototype.minWidth;
this.m_MaxWidth = detailPrototype.maxWidth;
this.m_MinHeight = detailPrototype.minHeight;
this.m_MaxHeight = detailPrototype.maxHeight;
this.m_NoiseSpread = detailPrototype.noiseSpread;
this.m_HealthyColor = detailPrototype.healthyColor;
this.m_DryColor = detailPrototype.dryColor;
this.m_Billboard = (detailPrototype.renderMode == DetailRenderMode.GrassBillboard);
this.OnWizardUpdate();
}
private static void HandleGrass(Scene scene, Terrain t, string tree, bool close)
{
DetailPrototype[] old = t.terrainData.detailPrototypes;
DetailPrototype[] ts = new DetailPrototype[old.Length];
for (int i = 0; i < ts.Length; i++)
{
ts[i] = new DetailPrototype();
ts[i].bendFactor = old[i].bendFactor;
if (grassDic[scene.name][i].prototypeTexture != null && grassDic[scene.name][i].prototypeTexture.name.Contains(tree))
{
if (close)
{
ts[i].prototypeTexture = null;
}
else
{
ts[i].prototypeTexture = grassDic[scene.name][i].prototypeTexture;
}
}
else
{
ts[i].prototypeTexture = old[i].prototypeTexture;
}
}
t.terrainData.detailPrototypes = ts;
}
internal void InitializeDefaults(Terrain terrain, int index)
{
m_Terrain = terrain;
m_PrototypeIndex = index;
DetailPrototype prototype;
if (m_PrototypeIndex == -1)
{
prototype = new DetailPrototype();
prototype.renderMode = DetailRenderMode.GrassBillboard;
}
else
{
prototype = m_Terrain.terrainData.detailPrototypes[m_PrototypeIndex];
}
m_DetailTexture = prototype.prototypeTexture;
m_MinWidth = prototype.minWidth;
m_MaxWidth = prototype.maxWidth;
m_MinHeight = prototype.minHeight;
m_MaxHeight = prototype.maxHeight;
m_NoiseSpread = prototype.noiseSpread;
m_HealthyColor = prototype.healthyColor;
m_DryColor = prototype.dryColor;
m_Billboard = prototype.renderMode == DetailRenderMode.GrassBillboard;
OnWizardUpdate();
}
// sets the settings of detail layers
//findme ref: used https://gamedev.stackexchange.com/questions/43929/unity-how-to-apply-programmatical-changes-to-the-terrain-splatprototype
// findme note: Requires SimpleJSON to parse data.
// Built in JSONUtility is fast but can't cope with JSON arrays or jagged arrays (as created by itself when parsing Vector 3!)
// findme fix: object properties (height etc) not updating. don't know why.
void addDetailmaps(string dataJson, int layer)
{
DetailPrototype newDetail = terrain.terrainData.detailPrototypes[layer];
JSONNode arr = JSON.Parse(dataJson);
newDetail.dryColor = HexToColor(arr[0]["drycolor"]);
newDetail.healthyColor = HexToColor(arr[0]["healthycolor"]);
newDetail.maxHeight = (float)arr[0]["maxheight"];
newDetail.minHeight = (float)arr[0]["minheight"];
newDetail.minWidth = (float)arr[0]["minwidth"];
newDetail.maxWidth = (float)arr[0]["maxwidth"];
newDetail.noiseSpread = (float)arr[0]["noisespread"];
newDetail.bendFactor = (float)arr[0]["bendfactor"];
if (arr [0] ["prototypetexturename"] != "")
{
newDetail.prototypeTexture.name = arr[0]["prototypetexturename"];
}
if (arr [0] ["detailprototypename"] != "")
{
newDetail.prototype.name = arr[0]["detailprototypename"];
}
terrain.terrainData.detailPrototypes[layer] = newDetail;
terrain.Flush();
}
void CreateProtoTypes()
{
m_treeProtoTypes = new TreePrototype[terrainTrees.Length];
for (int i = 0; i < terrainTrees.Length; i++)
{
m_treeProtoTypes[i] = new TreePrototype();
m_treeProtoTypes[i].prefab = terrainTrees[i];
}
m_detailProtoTypes = new DetailPrototype[details.Length];
for (int i = 0; i < details.Length; i++)
{
Texture2D tex = new Texture2D(1, 1, TextureFormat.ARGB32, false);
Color c = new Color(i * .5f, i * .25f, i * .1f, i * .1f);
tex.SetPixel(0, 0, c);
tex.Apply();
DetailPrototype prot = new DetailPrototype();
prot.prototypeTexture = details[i].texture;
prot.renderMode = DetailRenderMode.Grass;
prot.healthyColor = m_grassHealthyColor;
prot.dryColor = m_grassDryColor;
prot.minHeight = details[i].Height.x + detailMaster.Height.x;
prot.maxHeight = details[i].Height.y + detailMaster.Height.y;
prot.minWidth = details[i].Width.x + detailMaster.Width.y;
prot.maxWidth = details[i].Width.x + detailMaster.Width.y;
if (i + detailBillboards - details.Length >= 0)
{
prot.renderMode = DetailRenderMode.GrassBillboard;
}
m_detailProtoTypes[i] = prot;
}
}
public void GetGrass()
{
if (!CheckValidUnityTerrain())
{
return;
}
detailPrototypes.Clear();
for (int i = 0; i < terrain.terrainData.detailPrototypes.Length; i++)
{
DetailPrototype s = terrain.terrainData.detailPrototypes[i];
TC_DetailPrototype d = new TC_DetailPrototype();
d.minHeight = s.minHeight / grassScaleMulti;
d.minWidth = s.minWidth / grassScaleMulti;
d.maxHeight = s.maxHeight / grassScaleMulti;
d.maxWidth = s.maxWidth / grassScaleMulti;
d.bendFactor = s.bendFactor;
d.dryColor = s.dryColor;
d.healthyColor = s.healthyColor;
d.noiseSpread = s.noiseSpread;
d.usePrototypeMesh = s.usePrototypeMesh;
d.prototype = s.prototype;
d.prototypeTexture = s.prototypeTexture;
d.renderMode = s.renderMode;
detailPrototypes.Add(d);
}
}
//Creating various prototypes (needed)
void Prototypes()
{
//Ground textures
splats = new SplatPrototype[2];
splats[0] = new SplatPrototype();
splats[0].texture = splat0;
splats[0].tileSize = new Vector2(splat0Size, splat0Size);
splats[1] = new SplatPrototype();
splats[1].texture = splat1;
splats[1].tileSize = new Vector2(splat1Size, splat1Size);
//Grass textures
details = new DetailPrototype[3];
details[0] = new DetailPrototype();
details[0].prototypeTexture = detail0;
details[0].renderMode = DetailRenderMode.GrassBillboard;
details[0].healthyColor = Color.green;
details[0].dryColor = Color.grey;
details[1] = new DetailPrototype();
details[1].prototypeTexture = detail1;
details[1].renderMode = DetailRenderMode.GrassBillboard;
details[1].healthyColor = Color.green;
details[1].dryColor = Color.grey;
details[2] = new DetailPrototype();
details[2].prototypeTexture = detail2;
details[2].renderMode = DetailRenderMode.GrassBillboard;
details[2].healthyColor = Color.green;
details[2].dryColor = Color.grey;
}
public static void ClearGrass()
{
Terrain t = Terrain.activeTerrain;
TerrainData td = t.terrainData;
DetailPrototype[] detailPrototypes = new DetailPrototype[0];
td.detailPrototypes = detailPrototypes;
}
