API tools faq
paste
Advertisement
Guest User

TerrainToolkitEditor.cs | Editado por By UsuarioESP2013

a guest
Feb 6th, 2016
117
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 56.38 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. ---------------------- Unity Terrain Toolkit ----------------------
  3. --
  4. -- Unity Summer of Code 2009
  5. -- Terrain Toolkit for Unity (Version 1.0.2)
  6. -- All code by Sándor Moldán.
  7. --
  8. -- TerrainToolkitEditor.cs
  9. --
  10. -------------------------------------------------------------------
  11. */
  12.  
  13. using UnityEngine;
  14. using UnityEditor;
  15. using System;
  16. using System.Collections;
  17. using System.Collections.Generic;
  18.  
  19. // -------------------------------------------------------------------------------------------------------- EDITOR
  20.  
  21. [CustomEditor(typeof(TerrainToolkit))]
  22. public class TerrainToolkitEditor : Editor {
  23.  
  24. private bool showAdvancedSettings;
  25. private bool showInterfaceSettings;
  26. private string dragControl = "";
  27. private bool assignTexture = false;
  28. int i;
  29. int n;
  30.  
  31. public override void OnInspectorGUI() {
  32. EditorGUIUtility.LookLikeControls();
  33. TerrainToolkit terrain = (TerrainToolkit) target as TerrainToolkit;
  34. if (!terrain.gameObject) {
  35. return;
  36. }
  37. Terrain terComponent = (Terrain) terrain.GetComponent(typeof(Terrain));
  38. if (!terrain.guiSkin) {
  39. /*
  40. terrain.guiSkin = (GUISkin) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/TerrainErosionEditorSkin.guiskin", typeof(GUISkin));
  41. terrain.createIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/createIcon.png", typeof(Texture2D));
  42. terrain.erodeIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/erodeIcon.png", typeof(Texture2D));
  43. terrain.textureIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/textureIcon.png", typeof(Texture2D));
  44. terrain.mooreIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/mooreIcon.png", typeof(Texture2D));
  45. terrain.vonNeumannIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/vonNeumannIcon.png", typeof(Texture2D));
  46. terrain.mountainsIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/mountainsIcon.png", typeof(Texture2D));
  47. terrain.hillsIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/hillsIcon.png", typeof(Texture2D));
  48. terrain.plateausIcon = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Editor/Resources/plateausIcon.png", typeof(Texture2D));
  49. terrain.defaultTexture = (Texture2D) Resources.LoadAssetAtPath("Assets/TerrainToolkit/Textures/default.jpg", typeof(Texture2D));
  50. */
  51. }
  52. if (!terrain.presetsInitialised) {
  53. terrain.addPresets();
  54. }
  55. if (terComponent == null) {
  56. EditorGUILayout.Separator();
  57. EditorGUILayout.BeginHorizontal();
  58. GUI.skin = terrain.guiSkin;
  59. GUILayout.Label("The GameObject that Terrain Toolkit is attached to", "errorText");
  60. EditorGUILayout.EndHorizontal();
  61. EditorGUILayout.BeginHorizontal();
  62. GUILayout.Label("does not have a Terrain component.", "errorText");
  63. EditorGUILayout.EndHorizontal();
  64. EditorGUILayout.Separator();
  65. EditorGUILayout.BeginHorizontal();
  66. GUILayout.Label("Please attach a Terrain component.", "errorText");
  67. GUI.skin = null;
  68. EditorGUIUtility.LookLikeControls();
  69. EditorGUILayout.EndHorizontal();
  70. return;
  71. }
  72. if (terrain.heightBlendPoints == null) {
  73. terrain.heightBlendPoints = new List<float>();
  74. }
  75. Rect buttonRect;
  76. EditorGUILayout.Separator();
  77. EditorGUILayout.BeginHorizontal();
  78. GUIContent[] toolbarOptions = new GUIContent[3];
  79. toolbarOptions[0] = new GUIContent("Create", terrain.createIcon);
  80. toolbarOptions[1] = new GUIContent("Erode", terrain.erodeIcon);
  81. toolbarOptions[2] = new GUIContent("Texture", terrain.textureIcon);
  82. terrain.toolModeInt = GUILayout.Toolbar(terrain.toolModeInt, toolbarOptions);
  83. EditorGUILayout.EndHorizontal();
  84. switch (terrain.toolModeInt) {
  85. // -------------------------------------------------------------------------------------------------------- GENERATOR TOOLS
  86. case 0:
  87. EditorGUILayout.Separator();
  88. EditorGUILayout.BeginHorizontal();
  89. string[] generatorOptions = new string[5];
  90. generatorOptions[0] = "Voronoi";
  91. generatorOptions[1] = "Fractal";
  92. generatorOptions[2] = "Perlin";
  93. generatorOptions[3] = "Smooth";
  94. generatorOptions[4] = "Normalise";
  95. terrain.generatorTypeInt = GUILayout.Toolbar(terrain.generatorTypeInt, generatorOptions);
  96. EditorGUILayout.EndHorizontal();
  97. EditorGUILayout.Separator();
  98. switch (terrain.generatorTypeInt) {
  99. case 0:
  100. // Voronoi...
  101. EditorGUILayout.BeginHorizontal();
  102. if (GUI.changed) {
  103. EditorUtility.SetDirty(terrain);
  104. }
  105. GUI.changed = false;
  106. EditorGUILayout.PrefixLabel("Preset");
  107. string[] voronoiPresetNames = new string[terrain.voronoiPresets.Count + 1];
  108. int[] voronoiPresetInts = new int[terrain.voronoiPresets.Count + 1];
  109. voronoiPresetNames[0] = "None";
  110. TerrainToolkit.voronoiPresetData voronoiPreset;
  111. for (i = 1; i <= terrain.voronoiPresets.Count; i++) {
  112. voronoiPreset = (TerrainToolkit.voronoiPresetData) terrain.voronoiPresets[i - 1];
  113. voronoiPresetNames[i] = voronoiPreset.presetName;
  114. voronoiPresetInts[i] = i;
  115. }
  116. terrain.voronoiPresetId = EditorGUILayout.IntPopup(terrain.voronoiPresetId, voronoiPresetNames, voronoiPresetInts);
  117. EditorGUILayout.EndHorizontal();
  118. EditorGUILayout.Separator();
  119. if (GUI.changed && terrain.voronoiPresetId > 0) {
  120. voronoiPreset = (TerrainToolkit.voronoiPresetData) terrain.voronoiPresets[terrain.voronoiPresetId - 1];
  121. terrain.setVoronoiPreset(voronoiPreset);
  122. }
  123. if (GUI.changed) {
  124. EditorUtility.SetDirty(terrain);
  125. }
  126. GUI.changed = false;
  127. Rect featureRect = EditorGUILayout.BeginHorizontal();
  128. featureRect.x = 110;
  129. featureRect.width = 120;
  130. featureRect.height = 20;
  131. EditorGUILayout.PrefixLabel("Feature type");
  132. GUIContent[] featureStates = new GUIContent[3];
  133. featureStates[0] = new GUIContent(terrain.mountainsIcon);
  134. featureStates[1] = new GUIContent(terrain.hillsIcon);
  135. featureStates[2] = new GUIContent(terrain.plateausIcon);
  136. terrain.voronoiTypeInt = GUI.Toolbar(featureRect, terrain.voronoiTypeInt, featureStates);
  137. EditorGUILayout.EndHorizontal();
  138. EditorGUILayout.Separator();
  139. EditorGUILayout.BeginHorizontal();
  140. EditorGUILayout.PrefixLabel("Cells");
  141. terrain.voronoiCells = (int) EditorGUILayout.Slider(terrain.voronoiCells, 2, 100);
  142. EditorGUILayout.EndHorizontal();
  143. EditorGUILayout.BeginHorizontal();
  144. EditorGUILayout.PrefixLabel("Features");
  145. terrain.voronoiFeatures = EditorGUILayout.Slider(terrain.voronoiFeatures, 0.0f, 1.0f);
  146. EditorGUILayout.EndHorizontal();
  147. EditorGUILayout.BeginHorizontal();
  148. EditorGUILayout.PrefixLabel("Scale");
  149. terrain.voronoiScale = EditorGUILayout.Slider(terrain.voronoiScale, 0.0f, 1.0f);
  150. EditorGUILayout.EndHorizontal();
  151. EditorGUILayout.BeginHorizontal();
  152. EditorGUILayout.PrefixLabel("Blend");
  153. terrain.voronoiBlend = EditorGUILayout.Slider(terrain.voronoiBlend, 0.0f, 1.0f);
  154. EditorGUILayout.EndHorizontal();
  155. if (GUI.changed) {
  156. terrain.voronoiPresetId = 0;
  157. }
  158. EditorGUILayout.Separator();
  159. buttonRect = EditorGUILayout.BeginHorizontal();
  160. buttonRect.x = buttonRect.width / 2 - 100;
  161. buttonRect.width = 200;
  162. buttonRect.height = 18;
  163. GUI.skin = terrain.guiSkin;
  164. if (GUI.Button(buttonRect, "Generate Voronoi Features")) {
  165. // Undo...
  166. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  167. if (ter == null) {
  168. return;
  169. }
  170. TerrainData terData = ter.terrainData;
  171. Undo.RegisterUndo(terData, "Terrain Generator");
  172. TerrainToolkit.GeneratorProgressDelegate generatorProgressDelegate = new TerrainToolkit.GeneratorProgressDelegate(updateGeneratorProgress);
  173. terrain.generateTerrain(generatorProgressDelegate);
  174. EditorUtility.ClearProgressBar();
  175. GUIUtility.ExitGUI();
  176. }
  177. GUI.skin = null;
  178. EditorGUIUtility.LookLikeControls();
  179. EditorGUILayout.EndHorizontal();
  180. break;
  181. case 1:
  182. // Diamond square...
  183. EditorGUILayout.BeginHorizontal();
  184. if (GUI.changed) {
  185. EditorUtility.SetDirty(terrain);
  186. }
  187. GUI.changed = false;
  188. EditorGUILayout.PrefixLabel("Preset");
  189. string[] fractalPresetNames = new string[terrain.fractalPresets.Count + 1];
  190. int[] fractalPresetInts = new int[terrain.fractalPresets.Count + 1];
  191. fractalPresetNames[0] = "None";
  192. TerrainToolkit.fractalPresetData fractalPreset;
  193. for (i = 1; i <= terrain.fractalPresets.Count; i++) {
  194. fractalPreset = (TerrainToolkit.fractalPresetData) terrain.fractalPresets[i - 1];
  195. fractalPresetNames[i] = fractalPreset.presetName;
  196. fractalPresetInts[i] = i;
  197. }
  198. terrain.fractalPresetId = EditorGUILayout.IntPopup(terrain.fractalPresetId, fractalPresetNames, fractalPresetInts);
  199. EditorGUILayout.EndHorizontal();
  200. EditorGUILayout.Separator();
  201. if (GUI.changed && terrain.fractalPresetId > 0) {
  202. fractalPreset = (TerrainToolkit.fractalPresetData) terrain.fractalPresets[terrain.fractalPresetId - 1];
  203. terrain.setFractalPreset(fractalPreset);
  204. }
  205. if (GUI.changed) {
  206. EditorUtility.SetDirty(terrain);
  207. }
  208. GUI.changed = false;
  209. EditorGUILayout.BeginHorizontal();
  210. EditorGUILayout.PrefixLabel("Delta");
  211. terrain.diamondSquareDelta = EditorGUILayout.Slider(terrain.diamondSquareDelta, 0.0f, 1.0f);
  212. EditorGUILayout.EndHorizontal();
  213. EditorGUILayout.BeginHorizontal();
  214. EditorGUILayout.PrefixLabel("Blend");
  215. terrain.diamondSquareBlend = EditorGUILayout.Slider(terrain.diamondSquareBlend, 0.0f, 1.0f);
  216. EditorGUILayout.EndHorizontal();
  217. EditorGUILayout.Separator();
  218. if (GUI.changed) {
  219. terrain.fractalPresetId = 0;
  220. }
  221. buttonRect = EditorGUILayout.BeginHorizontal();
  222. buttonRect.x = buttonRect.width / 2 - 100;
  223. buttonRect.width = 200;
  224. buttonRect.height = 18;
  225. GUI.skin = terrain.guiSkin;
  226. if (GUI.Button(buttonRect, "Generate Fractal Terrain")) {
  227. // Undo...
  228. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  229. if (ter == null) {
  230. return;
  231. }
  232. TerrainData terData = ter.terrainData;
  233. Undo.RegisterUndo(terData, "Terrain Generator");
  234. TerrainToolkit.GeneratorProgressDelegate generatorProgressDelegate = new TerrainToolkit.GeneratorProgressDelegate(updateGeneratorProgress);
  235. terrain.generateTerrain(generatorProgressDelegate);
  236. EditorUtility.ClearProgressBar();
  237. GUIUtility.ExitGUI();
  238. }
  239. GUI.skin = null;
  240. EditorGUIUtility.LookLikeControls();
  241. EditorGUILayout.EndHorizontal();
  242. break;
  243. case 2:
  244. // Perlin...
  245. EditorGUILayout.BeginHorizontal();
  246. if (GUI.changed) {
  247. EditorUtility.SetDirty(terrain);
  248. }
  249. GUI.changed = false;
  250. EditorGUILayout.PrefixLabel("Preset");
  251. string[] perlinPresetNames = new string[terrain.perlinPresets.Count + 1];
  252. int[] perlinPresetInts = new int[terrain.perlinPresets.Count + 1];
  253. perlinPresetNames[0] = "None";
  254. TerrainToolkit.perlinPresetData perlinPreset;
  255. for (i = 1; i <= terrain.perlinPresets.Count; i++) {
  256. perlinPreset = (TerrainToolkit.perlinPresetData) terrain.perlinPresets[i - 1];
  257. perlinPresetNames[i] = perlinPreset.presetName;
  258. perlinPresetInts[i] = i;
  259. }
  260. terrain.perlinPresetId = EditorGUILayout.IntPopup(terrain.perlinPresetId, perlinPresetNames, perlinPresetInts);
  261. EditorGUILayout.EndHorizontal();
  262. EditorGUILayout.Separator();
  263. if (GUI.changed && terrain.perlinPresetId > 0) {
  264. perlinPreset = (TerrainToolkit.perlinPresetData) terrain.perlinPresets[terrain.perlinPresetId - 1];
  265. terrain.setPerlinPreset(perlinPreset);
  266. }
  267. if (GUI.changed) {
  268. EditorUtility.SetDirty(terrain);
  269. }
  270. GUI.changed = false;
  271. EditorGUILayout.BeginHorizontal();
  272. EditorGUILayout.PrefixLabel("Frequency");
  273. terrain.perlinFrequency = EditorGUILayout.IntSlider(terrain.perlinFrequency, 1, 16);
  274. EditorGUILayout.EndHorizontal();
  275. EditorGUILayout.BeginHorizontal();
  276. EditorGUILayout.PrefixLabel("Amplitude");
  277. terrain.perlinAmplitude = EditorGUILayout.Slider(terrain.perlinAmplitude, 0.0f, 1.0f);
  278. EditorGUILayout.EndHorizontal();
  279. EditorGUILayout.BeginHorizontal();
  280. EditorGUILayout.PrefixLabel("Octaves");
  281. terrain.perlinOctaves = EditorGUILayout.IntSlider(terrain.perlinOctaves, 1, 12);
  282. EditorGUILayout.EndHorizontal();
  283. EditorGUILayout.BeginHorizontal();
  284. EditorGUILayout.PrefixLabel("Blend");
  285. terrain.perlinBlend = EditorGUILayout.Slider(terrain.perlinBlend, 0.0f, 1.0f);
  286. EditorGUILayout.EndHorizontal();
  287. EditorGUILayout.Separator();
  288. if (GUI.changed) {
  289. terrain.perlinPresetId = 0;
  290. }
  291. buttonRect = EditorGUILayout.BeginHorizontal();
  292. buttonRect.x = buttonRect.width / 2 - 100;
  293. buttonRect.width = 200;
  294. buttonRect.height = 18;
  295. GUI.skin = terrain.guiSkin;
  296. if (GUI.Button(buttonRect, "Generate Perlin Terrain")) {
  297. // Undo...
  298. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  299. if (ter == null) {
  300. return;
  301. }
  302. TerrainData terData = ter.terrainData;
  303. Undo.RegisterUndo(terData, "Terrain Generator");
  304. TerrainToolkit.GeneratorProgressDelegate generatorProgressDelegate = new TerrainToolkit.GeneratorProgressDelegate(updateGeneratorProgress);
  305. terrain.generateTerrain(generatorProgressDelegate);
  306. EditorUtility.ClearProgressBar();
  307. GUIUtility.ExitGUI();
  308. }
  309. GUI.skin = null;
  310. EditorGUIUtility.LookLikeControls();
  311. EditorGUILayout.EndHorizontal();
  312. break;
  313. case 3:
  314. // Smooth...
  315. EditorGUILayout.BeginHorizontal();
  316. EditorGUILayout.PrefixLabel("Iterations");
  317. terrain.smoothIterations = (int) EditorGUILayout.Slider(terrain.smoothIterations, 1, 5);
  318. EditorGUILayout.EndHorizontal();
  319. EditorGUILayout.BeginHorizontal();
  320. EditorGUILayout.PrefixLabel("Blend");
  321. terrain.smoothBlend = EditorGUILayout.Slider(terrain.smoothBlend, 0.0f, 1.0f);
  322. EditorGUILayout.EndHorizontal();
  323. EditorGUILayout.Separator();
  324. buttonRect = EditorGUILayout.BeginHorizontal();
  325. buttonRect.x = buttonRect.width / 2 - 100;
  326. buttonRect.width = 200;
  327. buttonRect.height = 18;
  328. GUI.skin = terrain.guiSkin;
  329. if (GUI.Button(buttonRect, "Smooth Terrain")) {
  330. // Undo...
  331. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  332. if (ter == null) {
  333. return;
  334. }
  335. TerrainData terData = ter.terrainData;
  336. Undo.RegisterUndo(terData, "Smooth Terrain");
  337. TerrainToolkit.GeneratorProgressDelegate generatorProgressDelegate = new TerrainToolkit.GeneratorProgressDelegate(updateGeneratorProgress);
  338. terrain.generateTerrain(generatorProgressDelegate);
  339. EditorUtility.ClearProgressBar();
  340. GUIUtility.ExitGUI();
  341. }
  342. GUI.skin = null;
  343. EditorGUIUtility.LookLikeControls();
  344. EditorGUILayout.EndHorizontal();
  345. break;
  346. case 4:
  347. // Normalise...
  348. EditorGUILayout.BeginHorizontal();
  349. EditorGUILayout.PrefixLabel("Minimum height");
  350. terrain.normaliseMin = EditorGUILayout.Slider(terrain.normaliseMin, 0.0f, 1.0f);
  351. EditorGUILayout.EndHorizontal();
  352. EditorGUILayout.BeginHorizontal();
  353. EditorGUILayout.PrefixLabel("Maximum height");
  354. terrain.normaliseMax = EditorGUILayout.Slider(terrain.normaliseMax, 0.0f, 1.0f);
  355. EditorGUILayout.EndHorizontal();
  356. EditorGUILayout.BeginHorizontal();
  357. EditorGUILayout.PrefixLabel("Blend");
  358. terrain.normaliseBlend = EditorGUILayout.Slider(terrain.normaliseBlend, 0.0f, 1.0f);
  359. EditorGUILayout.EndHorizontal();
  360. EditorGUILayout.Separator();
  361. buttonRect = EditorGUILayout.BeginHorizontal();
  362. buttonRect.x = buttonRect.width / 2 - 100;
  363. buttonRect.width = 200;
  364. buttonRect.height = 18;
  365. GUI.skin = terrain.guiSkin;
  366. if (GUI.Button(buttonRect, "Normalise Terrain")) {
  367. // Undo...
  368. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  369. if (ter == null) {
  370. return;
  371. }
  372. TerrainData terData = ter.terrainData;
  373. Undo.RegisterUndo(terData, "Normalise Terrain");
  374. TerrainToolkit.GeneratorProgressDelegate generatorProgressDelegate = new TerrainToolkit.GeneratorProgressDelegate(updateGeneratorProgress);
  375. terrain.generateTerrain(generatorProgressDelegate);
  376. EditorUtility.ClearProgressBar();
  377. GUIUtility.ExitGUI();
  378. }
  379. GUI.skin = null;
  380. EditorGUIUtility.LookLikeControls();
  381. EditorGUILayout.EndHorizontal();
  382. break;
  383. }
  384. EditorGUILayout.Separator();
  385. EditorGUILayout.Separator();
  386. EditorGUILayout.Separator();
  387. EditorGUILayout.Separator();
  388. EditorGUILayout.Separator();
  389. drawAdvancedSettingsGUI();
  390. break;
  391. // -------------------------------------------------------------------------------------------------------- EROSION TOOLS
  392. case 1:
  393. EditorGUILayout.Separator();
  394. EditorGUILayout.BeginHorizontal();
  395. string[] erosionOptions = new string[4];
  396. erosionOptions[0] = "Thermal";
  397. erosionOptions[1] = "Hydraulic";
  398. erosionOptions[2] = "Tidal";
  399. erosionOptions[3] = "Wind";
  400. terrain.erosionTypeInt = GUILayout.Toolbar(terrain.erosionTypeInt, erosionOptions);
  401. EditorGUILayout.EndHorizontal();
  402. EditorGUILayout.Separator();
  403. EditorGUILayout.BeginHorizontal();
  404. GUI.skin = terrain.guiSkin;
  405. GUILayout.Label("Filters");
  406. GUI.skin = null;
  407. EditorGUIUtility.LookLikeControls();
  408. EditorGUILayout.EndHorizontal();
  409. switch (terrain.erosionTypeInt) {
  410. case 0:
  411. // Thermal...
  412. EditorGUILayout.BeginHorizontal();
  413. if (GUI.changed) {
  414. EditorUtility.SetDirty(terrain);
  415. }
  416. GUI.changed = false;
  417. EditorGUILayout.PrefixLabel("Preset");
  418. string[] thermalErosionPresetNames = new string[terrain.thermalErosionPresets.Count + 1];
  419. int[] thermalErosionPresetInts = new int[terrain.thermalErosionPresets.Count + 1];
  420. thermalErosionPresetNames[0] = "None";
  421. TerrainToolkit.thermalErosionPresetData thermalErosionPreset;
  422. for (i = 1; i <= terrain.thermalErosionPresets.Count; i++) {
  423. thermalErosionPreset = (TerrainToolkit.thermalErosionPresetData) terrain.thermalErosionPresets[i - 1];
  424. thermalErosionPresetNames[i] = thermalErosionPreset.presetName;
  425. thermalErosionPresetInts[i] = i;
  426. }
  427. terrain.thermalErosionPresetId = EditorGUILayout.IntPopup(terrain.thermalErosionPresetId, thermalErosionPresetNames, thermalErosionPresetInts);
  428. EditorGUILayout.EndHorizontal();
  429. EditorGUILayout.Separator();
  430. if (GUI.changed && terrain.thermalErosionPresetId > 0) {
  431. thermalErosionPreset = (TerrainToolkit.thermalErosionPresetData) terrain.thermalErosionPresets[terrain.thermalErosionPresetId - 1];
  432. terrain.setThermalErosionPreset(thermalErosionPreset);
  433. }
  434. if (GUI.changed) {
  435. EditorUtility.SetDirty(terrain);
  436. }
  437. GUI.changed = false;
  438. EditorGUILayout.BeginHorizontal();
  439. EditorGUILayout.PrefixLabel("Iterations");
  440. terrain.thermalIterations = (int) EditorGUILayout.Slider(terrain.thermalIterations, 1, 250);
  441. EditorGUILayout.EndHorizontal();
  442. EditorGUILayout.BeginHorizontal();
  443. EditorGUILayout.PrefixLabel("Minimum slope");
  444. terrain.thermalMinSlope = EditorGUILayout.Slider(terrain.thermalMinSlope, 0.01f, 89.99f);
  445. EditorGUILayout.EndHorizontal();
  446. EditorGUILayout.BeginHorizontal();
  447. EditorGUILayout.PrefixLabel("Falloff");
  448. terrain.thermalFalloff = EditorGUILayout.Slider(terrain.thermalFalloff, 0.0f, 1.0f);
  449. EditorGUILayout.EndHorizontal();
  450. EditorGUILayout.Separator();
  451. if (GUI.changed) {
  452. terrain.thermalErosionPresetId = 0;
  453. }
  454. buttonRect = EditorGUILayout.BeginHorizontal();
  455. buttonRect.x = buttonRect.width / 2 - 100;
  456. buttonRect.width = 200;
  457. buttonRect.height = 18;
  458. GUI.skin = terrain.guiSkin;
  459. if (GUI.Button(buttonRect, "Apply thermal erosion")) {
  460. // Undo
  461. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  462. if (ter == null) {
  463. return;
  464. }
  465. TerrainData terData = ter.terrainData;
  466. Undo.RegisterUndo(terData, "Terrain Erosion");
  467. // Start time...
  468. DateTime startTime = DateTime.Now;
  469. TerrainToolkit.ErosionProgressDelegate erosionProgressDelegate = new TerrainToolkit.ErosionProgressDelegate(updateErosionProgress);
  470. terrain.erodeAllTerrain(erosionProgressDelegate);
  471. EditorUtility.ClearProgressBar();
  472. TimeSpan processTime = DateTime.Now - startTime;
  473. Debug.Log("Process complete in: "+processTime.ToString());
  474. GUIUtility.ExitGUI();
  475. }
  476. GUI.skin = null;
  477. EditorGUIUtility.LookLikeControls();
  478. EditorGUILayout.EndHorizontal();
  479. EditorGUILayout.Separator();
  480. EditorGUILayout.Separator();
  481. break;
  482. case 1:
  483. // Hydraulic...
  484. Rect toggleRect = EditorGUILayout.BeginHorizontal();
  485. toggleRect.x = 110;
  486. toggleRect.width = 180;
  487. toggleRect.height = 20;
  488. EditorGUILayout.PrefixLabel("Type");
  489. string[] toggleStates = new string[3];
  490. toggleStates[0] = "Fast";
  491. toggleStates[1] = "Full";
  492. toggleStates[2] = "Velocity";
  493. terrain.hydraulicTypeInt = GUI.Toolbar(toggleRect, terrain.hydraulicTypeInt, toggleStates);
  494. EditorGUILayout.EndHorizontal();
  495. EditorGUILayout.Separator();
  496. switch (terrain.hydraulicTypeInt) {
  497. case 0:
  498. // Fast...
  499. EditorGUILayout.BeginHorizontal();
  500. if (GUI.changed) {
  501. EditorUtility.SetDirty(terrain);
  502. }
  503. GUI.changed = false;
  504. EditorGUILayout.PrefixLabel("Preset");
  505. string[] fastHydraulicErosionPresetNames = new string[terrain.fastHydraulicErosionPresets.Count + 1];
  506. int[] fastHydraulicErosionPresetInts = new int[terrain.fastHydraulicErosionPresets.Count + 1];
  507. fastHydraulicErosionPresetNames[0] = "None";
  508. TerrainToolkit.fastHydraulicErosionPresetData fastHydraulicErosionPreset;
  509. for (i = 1; i <= terrain.fastHydraulicErosionPresets.Count; i++) {
  510. fastHydraulicErosionPreset = (TerrainToolkit.fastHydraulicErosionPresetData) terrain.fastHydraulicErosionPresets[i - 1];
  511. fastHydraulicErosionPresetNames[i] = fastHydraulicErosionPreset.presetName;
  512. fastHydraulicErosionPresetInts[i] = i;
  513. }
  514. terrain.fastHydraulicErosionPresetId = EditorGUILayout.IntPopup(terrain.fastHydraulicErosionPresetId, fastHydraulicErosionPresetNames, fastHydraulicErosionPresetInts);
  515. EditorGUILayout.EndHorizontal();
  516. EditorGUILayout.Separator();
  517. if (GUI.changed && terrain.fastHydraulicErosionPresetId > 0) {
  518. fastHydraulicErosionPreset = (TerrainToolkit.fastHydraulicErosionPresetData) terrain.fastHydraulicErosionPresets[terrain.fastHydraulicErosionPresetId - 1];
  519. terrain.setFastHydraulicErosionPreset(fastHydraulicErosionPreset);
  520. }
  521. if (GUI.changed) {
  522. EditorUtility.SetDirty(terrain);
  523. }
  524. GUI.changed = false;
  525. EditorGUILayout.BeginHorizontal();
  526. EditorGUILayout.PrefixLabel("Iterations");
  527. terrain.hydraulicIterations = (int) EditorGUILayout.Slider(terrain.hydraulicIterations, 1, 250);
  528. EditorGUILayout.EndHorizontal();
  529. EditorGUILayout.BeginHorizontal();
  530. EditorGUILayout.PrefixLabel("Maximum slope");
  531. terrain.hydraulicMaxSlope = EditorGUILayout.Slider(terrain.hydraulicMaxSlope, 0.0f, 89.99f);
  532. EditorGUILayout.EndHorizontal();
  533. EditorGUILayout.BeginHorizontal();
  534. EditorGUILayout.PrefixLabel("Falloff");
  535. terrain.hydraulicFalloff = EditorGUILayout.Slider(terrain.hydraulicFalloff, 0.0f, 1.0f);
  536. EditorGUILayout.EndHorizontal();
  537. if (GUI.changed) {
  538. terrain.fastHydraulicErosionPresetId = 0;
  539. }
  540. break;
  541. case 1:
  542. // Full...
  543. EditorGUILayout.BeginHorizontal();
  544. if (GUI.changed) {
  545. EditorUtility.SetDirty(terrain);
  546. }
  547. GUI.changed = false;
  548. EditorGUILayout.PrefixLabel("Preset");
  549. string[] fullHydraulicErosionPresetNames = new string[terrain.fullHydraulicErosionPresets.Count + 1];
  550. int[] fullHydraulicErosionPresetInts = new int[terrain.fullHydraulicErosionPresets.Count + 1];
  551. fullHydraulicErosionPresetNames[0] = "None";
  552. TerrainToolkit.fullHydraulicErosionPresetData fullHydraulicErosionPreset;
  553. for (i = 1; i <= terrain.fullHydraulicErosionPresets.Count; i++) {
  554. fullHydraulicErosionPreset = (TerrainToolkit.fullHydraulicErosionPresetData) terrain.fullHydraulicErosionPresets[i - 1];
  555. fullHydraulicErosionPresetNames[i] = fullHydraulicErosionPreset.presetName;
  556. fullHydraulicErosionPresetInts[i] = i;
  557. }
  558. terrain.fullHydraulicErosionPresetId = EditorGUILayout.IntPopup(terrain.fullHydraulicErosionPresetId, fullHydraulicErosionPresetNames, fullHydraulicErosionPresetInts);
  559. EditorGUILayout.EndHorizontal();
  560. EditorGUILayout.Separator();
  561. if (GUI.changed && terrain.fullHydraulicErosionPresetId > 0) {
  562. fullHydraulicErosionPreset = (TerrainToolkit.fullHydraulicErosionPresetData) terrain.fullHydraulicErosionPresets[terrain.fullHydraulicErosionPresetId - 1];
  563. terrain.setFullHydraulicErosionPreset(fullHydraulicErosionPreset);
  564. }
  565. if (GUI.changed) {
  566. EditorUtility.SetDirty(terrain);
  567. }
  568. GUI.changed = false;
  569. EditorGUILayout.BeginHorizontal();
  570. EditorGUILayout.PrefixLabel("Iterations");
  571. terrain.hydraulicIterations = (int) EditorGUILayout.Slider(terrain.hydraulicIterations, 1, 250);
  572. EditorGUILayout.EndHorizontal();
  573. EditorGUILayout.BeginHorizontal();
  574. EditorGUILayout.PrefixLabel("Rainfall");
  575. terrain.hydraulicRainfall = EditorGUILayout.Slider(terrain.hydraulicRainfall, 0, 1);
  576. EditorGUILayout.EndHorizontal();
  577. EditorGUILayout.BeginHorizontal();
  578. EditorGUILayout.PrefixLabel("Evaporation");
  579. terrain.hydraulicEvaporation = EditorGUILayout.Slider(terrain.hydraulicEvaporation, 0, 1);
  580. EditorGUILayout.EndHorizontal();
  581. EditorGUILayout.BeginHorizontal();
  582. EditorGUILayout.PrefixLabel("Solubility");
  583. terrain.hydraulicSedimentSolubility = EditorGUILayout.Slider(terrain.hydraulicSedimentSolubility, 0, 1);
  584. EditorGUILayout.EndHorizontal();
  585. EditorGUILayout.BeginHorizontal();
  586. EditorGUILayout.PrefixLabel("Saturation");
  587. terrain.hydraulicSedimentSaturation = EditorGUILayout.Slider(terrain.hydraulicSedimentSaturation, 0, 1);
  588. EditorGUILayout.EndHorizontal();
  589. if (GUI.changed) {
  590. terrain.fullHydraulicErosionPresetId = 0;
  591. }
  592. break;
  593. case 2:
  594. // Velocity...
  595. EditorGUILayout.BeginHorizontal();
  596. if (GUI.changed) {
  597. EditorUtility.SetDirty(terrain);
  598. }
  599. GUI.changed = false;
  600. EditorGUILayout.PrefixLabel("Preset");
  601. string[] velocityHydraulicErosionPresetNames = new string[terrain.velocityHydraulicErosionPresets.Count + 1];
  602. int[] velocityHydraulicErosionPresetInts = new int[terrain.velocityHydraulicErosionPresets.Count + 1];
  603. velocityHydraulicErosionPresetNames[0] = "None";
  604. TerrainToolkit.velocityHydraulicErosionPresetData velocityHydraulicErosionPreset;
  605. for (i = 1; i <= terrain.velocityHydraulicErosionPresets.Count; i++) {
  606. velocityHydraulicErosionPreset = (TerrainToolkit.velocityHydraulicErosionPresetData) terrain.velocityHydraulicErosionPresets[i - 1];
  607. velocityHydraulicErosionPresetNames[i] = velocityHydraulicErosionPreset.presetName;
  608. velocityHydraulicErosionPresetInts[i] = i;
  609. }
  610. terrain.velocityHydraulicErosionPresetId = EditorGUILayout.IntPopup(terrain.velocityHydraulicErosionPresetId, velocityHydraulicErosionPresetNames, velocityHydraulicErosionPresetInts);
  611. EditorGUILayout.EndHorizontal();
  612. EditorGUILayout.Separator();
  613. if (GUI.changed && terrain.velocityHydraulicErosionPresetId > 0) {
  614. velocityHydraulicErosionPreset = (TerrainToolkit.velocityHydraulicErosionPresetData) terrain.velocityHydraulicErosionPresets[terrain.velocityHydraulicErosionPresetId - 1];
  615. terrain.setVelocityHydraulicErosionPreset(velocityHydraulicErosionPreset);
  616. }
  617. if (GUI.changed) {
  618. EditorUtility.SetDirty(terrain);
  619. }
  620. GUI.changed = false;
  621. EditorGUILayout.BeginHorizontal();
  622. EditorGUILayout.PrefixLabel("Iterations");
  623. terrain.hydraulicIterations = (int) EditorGUILayout.Slider(terrain.hydraulicIterations, 1, 250);
  624. EditorGUILayout.EndHorizontal();
  625. EditorGUILayout.BeginHorizontal();
  626. EditorGUILayout.PrefixLabel("Rainfall");
  627. terrain.hydraulicVelocityRainfall = EditorGUILayout.Slider(terrain.hydraulicVelocityRainfall, 0, 1);
  628. EditorGUILayout.EndHorizontal();
  629. EditorGUILayout.BeginHorizontal();
  630. EditorGUILayout.PrefixLabel("Evaporation");
  631. terrain.hydraulicVelocityEvaporation = EditorGUILayout.Slider(terrain.hydraulicVelocityEvaporation, 0, 1);
  632. EditorGUILayout.EndHorizontal();
  633. EditorGUILayout.BeginHorizontal();
  634. EditorGUILayout.PrefixLabel("Solubility");
  635. terrain.hydraulicVelocitySedimentSolubility = EditorGUILayout.Slider(terrain.hydraulicVelocitySedimentSolubility, 0, 1);
  636. EditorGUILayout.EndHorizontal();
  637. EditorGUILayout.BeginHorizontal();
  638. EditorGUILayout.PrefixLabel("Saturation");
  639. terrain.hydraulicVelocitySedimentSaturation = EditorGUILayout.Slider(terrain.hydraulicVelocitySedimentSaturation, 0, 1);
  640. EditorGUILayout.EndHorizontal();
  641. EditorGUILayout.BeginHorizontal();
  642. EditorGUILayout.PrefixLabel("Velocity");
  643. terrain.hydraulicVelocity = EditorGUILayout.Slider(terrain.hydraulicVelocity, 0, 10);
  644. EditorGUILayout.EndHorizontal();
  645. EditorGUILayout.BeginHorizontal();
  646. EditorGUILayout.PrefixLabel("Momentum");
  647. terrain.hydraulicMomentum = EditorGUILayout.Slider(terrain.hydraulicMomentum, 0, 10);
  648. EditorGUILayout.EndHorizontal();
  649. EditorGUILayout.BeginHorizontal();
  650. EditorGUILayout.PrefixLabel("Entropy");
  651. terrain.hydraulicEntropy = EditorGUILayout.Slider(terrain.hydraulicEntropy, 0, 1);
  652. EditorGUILayout.EndHorizontal();
  653. EditorGUILayout.BeginHorizontal();
  654. EditorGUILayout.PrefixLabel("Downcutting");
  655. terrain.hydraulicDowncutting = EditorGUILayout.Slider(terrain.hydraulicDowncutting, 0, 1);
  656. EditorGUILayout.EndHorizontal();
  657. if (GUI.changed) {
  658. terrain.velocityHydraulicErosionPresetId = 0;
  659. }
  660. break;
  661. }
  662. EditorGUILayout.Separator();
  663. buttonRect = EditorGUILayout.BeginHorizontal();
  664. buttonRect.x = buttonRect.width / 2 - 100;
  665. buttonRect.width = 200;
  666. buttonRect.height = 18;
  667. GUI.skin = terrain.guiSkin;
  668. if (GUI.Button(buttonRect, "Apply hydraulic erosion")) {
  669. // Undo
  670. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  671. if (ter == null) {
  672. return;
  673. }
  674. TerrainData terData = ter.terrainData;
  675. Undo.RegisterUndo(terData, "Terrain Erosion");
  676. // Start time...
  677. DateTime startTime = DateTime.Now;
  678. TerrainToolkit.ErosionProgressDelegate erosionProgressDelegate = new TerrainToolkit.ErosionProgressDelegate(updateErosionProgress);
  679. terrain.erodeAllTerrain(erosionProgressDelegate);
  680. EditorUtility.ClearProgressBar();
  681. TimeSpan processTime = DateTime.Now - startTime;
  682. Debug.Log("Process complete in: "+processTime.ToString());
  683. GUIUtility.ExitGUI();
  684. }
  685. GUI.skin = null;
  686. EditorGUIUtility.LookLikeControls();
  687. EditorGUILayout.EndHorizontal();
  688. EditorGUILayout.Separator();
  689. EditorGUILayout.Separator();
  690. break;
  691. case 2:
  692. // Tidal...
  693. EditorGUILayout.BeginHorizontal();
  694. if (GUI.changed) {
  695. EditorUtility.SetDirty(terrain);
  696. }
  697. GUI.changed = false;
  698. EditorGUILayout.PrefixLabel("Preset");
  699. string[] tidalErosionPresetNames = new string[terrain.tidalErosionPresets.Count + 1];
  700. int[] tidalErosionPresetInts = new int[terrain.tidalErosionPresets.Count + 1];
  701. tidalErosionPresetNames[0] = "None";
  702. TerrainToolkit.tidalErosionPresetData tidalErosionPreset;
  703. for (i = 1; i <= terrain.tidalErosionPresets.Count; i++) {
  704. tidalErosionPreset = (TerrainToolkit.tidalErosionPresetData) terrain.tidalErosionPresets[i - 1];
  705. tidalErosionPresetNames[i] = tidalErosionPreset.presetName;
  706. tidalErosionPresetInts[i] = i;
  707. }
  708. terrain.tidalErosionPresetId = EditorGUILayout.IntPopup(terrain.tidalErosionPresetId, tidalErosionPresetNames, tidalErosionPresetInts);
  709. EditorGUILayout.EndHorizontal();
  710. EditorGUILayout.Separator();
  711. if (GUI.changed && terrain.tidalErosionPresetId > 0) {
  712. tidalErosionPreset = (TerrainToolkit.tidalErosionPresetData) terrain.tidalErosionPresets[terrain.tidalErosionPresetId - 1];
  713. terrain.setTidalErosionPreset(tidalErosionPreset);
  714. }
  715. if (GUI.changed) {
  716. EditorUtility.SetDirty(terrain);
  717. }
  718. GUI.changed = false;
  719. EditorGUILayout.BeginHorizontal();
  720. EditorGUILayout.PrefixLabel("Iterations");
  721. terrain.tidalIterations = (int) EditorGUILayout.Slider(terrain.tidalIterations, 1, 250);
  722. EditorGUILayout.EndHorizontal();
  723. EditorGUILayout.Separator();
  724. EditorGUILayout.BeginHorizontal();
  725. EditorGUILayout.PrefixLabel("Sea level");
  726. terrain.tidalSeaLevel = EditorGUILayout.FloatField(terrain.tidalSeaLevel);
  727. EditorGUILayout.EndHorizontal();
  728. EditorGUILayout.BeginHorizontal();
  729. EditorGUILayout.PrefixLabel("Tidal range");
  730. terrain.tidalRangeAmount = EditorGUILayout.FloatField(terrain.tidalRangeAmount);
  731. EditorGUILayout.EndHorizontal();
  732. EditorGUILayout.BeginHorizontal();
  733. EditorGUILayout.PrefixLabel("Cliff limit");
  734. terrain.tidalCliffLimit = EditorGUILayout.Slider(terrain.tidalCliffLimit, 0.0f, 90.0f);
  735. EditorGUILayout.EndHorizontal();
  736. EditorGUILayout.Separator();
  737. if (GUI.changed) {
  738. terrain.tidalErosionPresetId = 0;
  739. }
  740. buttonRect = EditorGUILayout.BeginHorizontal();
  741. buttonRect.x = buttonRect.width / 2 - 100;
  742. buttonRect.width = 200;
  743. buttonRect.height = 18;
  744. GUI.skin = terrain.guiSkin;
  745. if (GUI.Button(buttonRect, "Apply tidal erosion")) {
  746. // Undo
  747. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  748. if (ter == null) {
  749. return;
  750. }
  751. TerrainData terData = ter.terrainData;
  752. Undo.RegisterUndo(terData, "Terrain Erosion");
  753. // Start time...
  754. DateTime startTime = DateTime.Now;
  755. TerrainToolkit.ErosionProgressDelegate erosionProgressDelegate = new TerrainToolkit.ErosionProgressDelegate(updateErosionProgress);
  756. terrain.erodeAllTerrain(erosionProgressDelegate);
  757. EditorUtility.ClearProgressBar();
  758. TimeSpan processTime = DateTime.Now - startTime;
  759. Debug.Log("Process complete in: "+processTime.ToString());
  760. GUIUtility.ExitGUI();
  761. }
  762. GUI.skin = null;
  763. EditorGUIUtility.LookLikeControls();
  764. EditorGUILayout.EndHorizontal();
  765. EditorGUILayout.Separator();
  766. EditorGUILayout.Separator();
  767. break;
  768. case 3:
  769. // Wind...
  770. EditorGUILayout.BeginHorizontal();
  771. if (GUI.changed) {
  772. EditorUtility.SetDirty(terrain);
  773. }
  774. GUI.changed = false;
  775. EditorGUILayout.PrefixLabel("Preset");
  776. string[] windErosionPresetNames = new string[terrain.windErosionPresets.Count + 1];
  777. int[] windErosionPresetInts = new int[terrain.windErosionPresets.Count + 1];
  778. windErosionPresetNames[0] = "None";
  779. TerrainToolkit.windErosionPresetData windErosionPreset;
  780. for (i = 1; i <= terrain.windErosionPresets.Count; i++) {
  781. windErosionPreset = (TerrainToolkit.windErosionPresetData) terrain.windErosionPresets[i - 1];
  782. windErosionPresetNames[i] = windErosionPreset.presetName;
  783. windErosionPresetInts[i] = i;
  784. }
  785. terrain.windErosionPresetId = EditorGUILayout.IntPopup(terrain.windErosionPresetId, windErosionPresetNames, windErosionPresetInts);
  786. EditorGUILayout.EndHorizontal();
  787. EditorGUILayout.Separator();
  788. if (GUI.changed && terrain.windErosionPresetId > 0) {
  789. windErosionPreset = (TerrainToolkit.windErosionPresetData) terrain.windErosionPresets[terrain.windErosionPresetId - 1];
  790. terrain.setWindErosionPreset(windErosionPreset);
  791. }
  792. if (GUI.changed) {
  793. EditorUtility.SetDirty(terrain);
  794. }
  795. GUI.changed = false;
  796. EditorGUILayout.BeginHorizontal();
  797. EditorGUILayout.PrefixLabel("Iterations");
  798. terrain.windIterations = (int) EditorGUILayout.Slider(terrain.windIterations, 1, 250);
  799. EditorGUILayout.EndHorizontal();
  800. EditorGUILayout.BeginHorizontal();
  801. terrain.windDirection = EditorGUILayout.Slider("Wind direction", terrain.windDirection, 0.0f, 360.0f);
  802. EditorGUILayout.EndHorizontal();
  803. EditorGUILayout.BeginHorizontal();
  804. terrain.windForce = EditorGUILayout.Slider("Wind force", terrain.windForce, 0.0f, 1.0f);
  805. EditorGUILayout.EndHorizontal();
  806. EditorGUILayout.BeginHorizontal();
  807. terrain.windLift = EditorGUILayout.Slider("Lift", terrain.windLift, 0.0f, 0.01f);
  808. EditorGUILayout.EndHorizontal();
  809. EditorGUILayout.BeginHorizontal();
  810. terrain.windGravity = EditorGUILayout.Slider("Gravity", terrain.windGravity, 0.0f, 1.0f);
  811. EditorGUILayout.EndHorizontal();
  812. EditorGUILayout.BeginHorizontal();
  813. terrain.windCapacity = EditorGUILayout.Slider("Capacity", terrain.windCapacity, 0.0f, 1.0f);
  814. EditorGUILayout.EndHorizontal();
  815. EditorGUILayout.BeginHorizontal();
  816. terrain.windEntropy = EditorGUILayout.Slider("Entropy", terrain.windEntropy, 0.0f, 1.0f);
  817. EditorGUILayout.EndHorizontal();
  818. EditorGUILayout.BeginHorizontal();
  819. terrain.windSmoothing = EditorGUILayout.Slider("Smoothing", terrain.windSmoothing, 0.0f, 1.0f);
  820. EditorGUILayout.EndHorizontal();
  821. EditorGUILayout.Separator();
  822. if (GUI.changed) {
  823. terrain.windErosionPresetId = 0;
  824. }
  825. buttonRect = EditorGUILayout.BeginHorizontal();
  826. buttonRect.x = buttonRect.width / 2 - 100;
  827. buttonRect.width = 200;
  828. buttonRect.height = 18;
  829. GUI.skin = terrain.guiSkin;
  830. if (GUI.Button(buttonRect, "Apply wind erosion")) {
  831. // Undo
  832. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  833. if (ter == null) {
  834. return;
  835. }
  836. TerrainData terData = ter.terrainData;
  837. Undo.RegisterUndo(terData, "Terrain Erosion");
  838. // Start time...
  839. DateTime startTime = DateTime.Now;
  840. TerrainToolkit.ErosionProgressDelegate erosionProgressDelegate = new TerrainToolkit.ErosionProgressDelegate(updateErosionProgress);
  841. terrain.erodeAllTerrain(erosionProgressDelegate);
  842. EditorUtility.ClearProgressBar();
  843. TimeSpan processTime = DateTime.Now - startTime;
  844. Debug.Log("Process complete in: "+processTime.ToString());
  845. GUIUtility.ExitGUI();
  846. }
  847. GUI.skin = null;
  848. EditorGUIUtility.LookLikeControls();
  849. EditorGUILayout.EndHorizontal();
  850. EditorGUILayout.Separator();
  851. EditorGUILayout.Separator();
  852. break;
  853. }
  854. if (terrain.erosionTypeInt == 0 || terrain.erosionTypeInt == 2 || (terrain.erosionTypeInt == 1 && terrain.hydraulicTypeInt == 0)) {
  855. EditorGUILayout.Separator();
  856. drawBrushToolsGUI();
  857. } else {
  858. EditorGUILayout.Separator();
  859. EditorGUILayout.Separator();
  860. }
  861. EditorGUILayout.Separator();
  862. drawAdvancedSettingsGUI();
  863. break;
  864. // -------------------------------------------------------------------------------------------------------- TEXTURING TOOLS
  865. case 2:
  866. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  867. if (ter == null) {
  868. return;
  869. }
  870. TerrainData terData = ter.terrainData;
  871. terrain.splatPrototypes = terData.splatPrototypes;
  872. EditorGUILayout.Separator();
  873. float mouseX;
  874. EditorGUILayout.BeginHorizontal();
  875. GUI.skin = terrain.guiSkin;
  876. GUILayout.Label("Texture Slope");
  877. GUI.skin = null;
  878. EditorGUIUtility.LookLikeControls();
  879. EditorGUILayout.EndHorizontal();
  880. Rect gradientRect = EditorGUILayout.BeginHorizontal();
  881. float gradientWidth = gradientRect.width - 55;
  882. gradientRect.width = 15;
  883. gradientRect.height = 19;
  884. GUI.skin = terrain.guiSkin;
  885. // Slope stop 1...
  886. if (dragControl == "slopeStop1" && Event.current.type == EventType.MouseDrag) {
  887. mouseX = Event.current.mousePosition.x - 7;
  888. if (mouseX < 20) {
  889. mouseX = 20;
  890. } else if (mouseX > 19 + gradientWidth * (terrain.slopeBlendMaxAngle / 90)) {
  891. mouseX = 19 + gradientWidth * (terrain.slopeBlendMaxAngle / 90);
  892. }
  893. gradientRect.x = mouseX;
  894. terrain.slopeBlendMinAngle = ((mouseX - 20) / (gradientWidth + 1)) * 90;
  895. } else {
  896. gradientRect.x = 20 + gradientWidth * (terrain.slopeBlendMinAngle / 90);
  897. }
  898. if (Event.current.type == EventType.MouseDown && gradientRect.Contains(Event.current.mousePosition)) {
  899. dragControl = "slopeStop1";
  900. }
  901. if (dragControl == "slopeStop1" && Event.current.type == EventType.MouseUp) {
  902. dragControl = "";
  903. }
  904. GUI.Box(gradientRect, "", "slopeStop1");
  905. // Slope stop 2...
  906. if (dragControl == "slopeStop2" && Event.current.type == EventType.MouseDrag) {
  907. mouseX = Event.current.mousePosition.x - 7;
  908. if (mouseX < 21 + gradientWidth * (terrain.slopeBlendMinAngle / 90)) {
  909. mouseX = 21 + gradientWidth * (terrain.slopeBlendMinAngle / 90);
  910. } else if (mouseX > 21 + gradientWidth) {
  911. mouseX = 21 + gradientWidth;
  912. }
  913. gradientRect.x = mouseX;
  914. terrain.slopeBlendMaxAngle = ((mouseX - 20) / (gradientWidth + 1)) * 90;
  915. } else {
  916. gradientRect.x = 20 + gradientWidth * (terrain.slopeBlendMaxAngle / 90);
  917. }
  918. if (Event.current.type == EventType.MouseDown && gradientRect.Contains(Event.current.mousePosition)) {
  919. dragControl = "slopeStop2";
  920. }
  921. if (dragControl == "slopeStop2" && Event.current.type == EventType.MouseUp) {
  922. dragControl = "";
  923. }
  924. GUI.Box(gradientRect, "", "slopeStop2");
  925. gradientRect.y += 19;
  926. gradientRect.width = gradientWidth * (terrain.slopeBlendMinAngle / 90);
  927. gradientRect.x = 27;
  928. GUI.Box(gradientRect, "", "black");
  929. gradientRect.width = gradientWidth * ((terrain.slopeBlendMaxAngle / 90) - (terrain.slopeBlendMinAngle / 90));
  930. gradientRect.x = 27 + gradientWidth * (terrain.slopeBlendMinAngle / 90);
  931. GUI.Box(gradientRect, "", "blackToWhite");
  932. gradientRect.width = gradientWidth - gradientWidth * (terrain.slopeBlendMaxAngle / 90);
  933. gradientRect.x = 27 + gradientWidth * (terrain.slopeBlendMaxAngle / 90);
  934. GUI.Box(gradientRect, "", "white");
  935. GUI.skin = null;
  936. EditorGUIUtility.LookLikeControls();
  937. EditorGUILayout.EndHorizontal();
  938. EditorGUILayout.Separator();
  939. EditorGUILayout.Separator();
  940. EditorGUILayout.Separator();
  941. EditorGUILayout.Separator();
  942. EditorGUILayout.Separator();
  943. EditorGUILayout.Separator();
  944. EditorGUILayout.BeginHorizontal();
  945. EditorGUILayout.PrefixLabel("Cliff start");
  946. terrain.slopeBlendMinAngle = EditorGUILayout.FloatField(terrain.slopeBlendMinAngle);
  947. EditorGUILayout.EndHorizontal();
  948. EditorGUILayout.BeginHorizontal();
  949. EditorGUILayout.PrefixLabel("Cliff end");
  950. terrain.slopeBlendMaxAngle = EditorGUILayout.FloatField(terrain.slopeBlendMaxAngle);
  951. EditorGUILayout.EndHorizontal();
  952. EditorGUILayout.BeginHorizontal();
  953. GUI.skin = terrain.guiSkin;
  954. GUILayout.Label("Texture Height");
  955. GUI.skin = null;
  956. EditorGUIUtility.LookLikeControls();
  957. EditorGUILayout.EndHorizontal();
  958. gradientRect = EditorGUILayout.BeginHorizontal();
  959. gradientWidth = gradientRect.width - 55;
  960. gradientRect.width = 15;
  961. gradientRect.height = 19;
  962. Rect gradientRect2 = gradientRect;
  963. gradientRect2.y += 19;
  964. GUI.skin = terrain.guiSkin;
  965. string[] gradientStyles = new string[9];
  966. gradientStyles[0] = "red";
  967. gradientStyles[1] = "redToYellow";
  968. gradientStyles[2] = "yellow";
  969. gradientStyles[3] = "yellowToGreen";
  970. gradientStyles[4] = "green";
  971. gradientStyles[5] = "greenToCyan";
  972. gradientStyles[6] = "cyan";
  973. gradientStyles[7] = "cyanToBlue";
  974. gradientStyles[8] = "blue";
  975. List<float> heightBlendPoints = terrain.heightBlendPoints;
  976. int numPoints = heightBlendPoints.Count;
  977. float firstLimit = 1;
  978. if (numPoints > 0) {
  979. firstLimit = (float) heightBlendPoints[0];
  980. } else {
  981. gradientRect.x = 20;
  982. GUI.Box(gradientRect, "", "greyStop");
  983. gradientRect.x = 20 + gradientWidth;
  984. GUI.Box(gradientRect, "", "greyStop");
  985. }
  986. gradientRect2.width = gradientWidth * firstLimit;
  987. gradientRect2.x = 27;
  988. if (terrain.splatPrototypes.Length < 2) {
  989. GUI.Box(gradientRect2, "", "grey");
  990. } else {
  991. GUI.Box(gradientRect2, "", "red");
  992. }
  993. for (i = 0; i < numPoints; i++) {
  994. // Height stop...
  995. float lowerLimit = 0;
  996. float upperLimit = 1;
  997. if (i > 0) {
  998. lowerLimit = (float) heightBlendPoints[i - 1];
  999. }
  1000. if (i < numPoints - 1) {
  1001. upperLimit = (float) heightBlendPoints[i + 1];
  1002. }
  1003. if (dragControl == "heightStop"+i && Event.current.type == EventType.MouseDrag) {
  1004. mouseX = Event.current.mousePosition.x - 7;
  1005. if (mouseX < 20 + gradientWidth * lowerLimit) {
  1006. mouseX = 20 + gradientWidth * lowerLimit;
  1007. } else if (mouseX > 19 + gradientWidth * upperLimit) {
  1008. mouseX = 19 + gradientWidth * upperLimit;
  1009. }
  1010. gradientRect.x = mouseX;
  1011. heightBlendPoints[i] = (mouseX - 20) / (gradientWidth + 1);
  1012. } else {
  1013. gradientRect.x = 20 + gradientWidth * (float) heightBlendPoints[i];
  1014. }
  1015. if (Event.current.type == EventType.MouseDown && gradientRect.Contains(Event.current.mousePosition)) {
  1016. dragControl = "heightStop"+i;
  1017. }
  1018. if (dragControl == "heightStop"+i && Event.current.type == EventType.MouseUp) {
  1019. dragControl = "";
  1020. }
  1021. int stopNum = (int) Mathf.Ceil((float) i / 2) + 1;
  1022. if (i % 2 == 0) {
  1023. GUI.Box(gradientRect, ""+stopNum, "blackStop");
  1024. } else {
  1025. GUI.Box(gradientRect, ""+stopNum, "whiteStop");
  1026. }
  1027. gradientRect2.width = gradientWidth * (upperLimit - (float) heightBlendPoints[i]);
  1028. gradientRect2.x = 27 + gradientWidth * (float) heightBlendPoints[i];
  1029. GUI.Box(gradientRect2, "", gradientStyles[i + 1]);
  1030. }
  1031. GUI.skin = null;
  1032. EditorGUIUtility.LookLikeControls();
  1033. EditorGUILayout.EndHorizontal();
  1034. EditorGUILayout.Separator();
  1035. EditorGUILayout.Separator();
  1036. EditorGUILayout.Separator();
  1037. EditorGUILayout.Separator();
  1038. EditorGUILayout.Separator();
  1039. EditorGUILayout.Separator();
  1040. string startOrEnd = "end";
  1041. for (i = 0; i < numPoints; i++) {
  1042. EditorGUILayout.BeginHorizontal();
  1043. int floatFieldNum = (int) Mathf.Ceil((float) i / 2) + 1;
  1044. EditorGUILayout.PrefixLabel("Texture "+floatFieldNum+" "+startOrEnd);
  1045. heightBlendPoints[i] = EditorGUILayout.FloatField((float) heightBlendPoints[i]);
  1046. EditorGUILayout.EndHorizontal();
  1047. if (startOrEnd == "end") {
  1048. startOrEnd = "start";
  1049. } else {
  1050. startOrEnd = "end";
  1051. }
  1052. }
  1053. terrain.heightBlendPoints = heightBlendPoints;
  1054. EditorGUILayout.BeginHorizontal();
  1055. GUI.skin = terrain.guiSkin;
  1056. GUILayout.Label("Textures");
  1057. GUI.skin = null;
  1058. EditorGUIUtility.LookLikeControls();
  1059. EditorGUILayout.EndHorizontal();
  1060. int nTextures = 0;
  1061. EditorGUILayout.Separator();
  1062. if (GUI.changed) {
  1063. EditorUtility.SetDirty(terrain);
  1064. }
  1065. GUI.changed = false;
  1066. EditorGUILayout.BeginHorizontal();
  1067. foreach (SplatPrototype splatPrototype in terrain.splatPrototypes) {
  1068. EditorGUIUtility.LookLikeControls(80, 0);
  1069. Rect textureRect = EditorGUILayout.BeginHorizontal();
  1070. if (nTextures == 0) {
  1071. splatPrototype.texture = EditorGUILayout.ObjectField("Cliff texture", splatPrototype.texture, typeof(Texture2D)) as Texture2D;
  1072. } else {
  1073. splatPrototype.texture = EditorGUILayout.ObjectField("Texture "+nTextures, splatPrototype.texture, typeof(Texture2D)) as Texture2D;
  1074. }
  1075. GUI.skin = terrain.guiSkin;
  1076. textureRect.x += 146;
  1077. textureRect.width = 18;
  1078. textureRect.height = 18;
  1079. if (GUI.Button(textureRect, "", "deleteButton")) {
  1080. GUI.changed = true;
  1081. terrain.deleteSplatPrototype(terrain.tempTexture, nTextures);
  1082. EditorUtility.SetDirty(terrain);
  1083. }
  1084. GUI.skin = null;
  1085. EditorGUIUtility.LookLikeControls();
  1086. EditorGUILayout.EndHorizontal();
  1087. if (nTextures % 2 == 1) {
  1088. EditorGUILayout.EndHorizontal();
  1089. EditorGUILayout.Separator();
  1090. EditorGUILayout.BeginHorizontal();
  1091. }
  1092. nTextures++;
  1093. if (nTextures > 5) {
  1094. break;
  1095. }
  1096. }
  1097. EditorGUIUtility.LookLikeControls();
  1098. EditorGUILayout.EndHorizontal();
  1099. if (GUI.changed) {
  1100. terData.splatPrototypes = terrain.splatPrototypes;
  1101. }
  1102. if (nTextures == 0 && !assignTexture) {
  1103. EditorGUILayout.BeginHorizontal();
  1104. GUI.skin = terrain.guiSkin;
  1105. GUILayout.Label("No textures have been assigned! Assign a texture.", "errorText");
  1106. GUI.skin = null;
  1107. EditorGUIUtility.LookLikeControls();
  1108. EditorGUILayout.EndHorizontal();
  1109. EditorGUILayout.Separator();
  1110. }
  1111. if (nTextures < 6) {
  1112. EditorGUILayout.Separator();
  1113. buttonRect = EditorGUILayout.BeginHorizontal();
  1114. buttonRect.x = buttonRect.width / 2 - 50;
  1115. buttonRect.width = 100;
  1116. buttonRect.height = 18;
  1117. if (GUI.Button(buttonRect, "Add texture")) {
  1118. terrain.addSplatPrototype(terrain.defaultTexture, nTextures);
  1119. terData.splatPrototypes = terrain.splatPrototypes;
  1120. EditorUtility.SetDirty(terrain);
  1121. }
  1122. EditorGUILayout.EndHorizontal();
  1123. EditorGUILayout.Separator();
  1124. EditorGUILayout.Separator();
  1125. EditorGUILayout.Separator();
  1126. EditorGUILayout.Separator();
  1127. }
  1128. EditorGUILayout.Separator();
  1129. buttonRect = EditorGUILayout.BeginHorizontal();
  1130. buttonRect.x = buttonRect.width / 2 - 100;
  1131. buttonRect.width = 200;
  1132. buttonRect.height = 18;
  1133. GUI.skin = terrain.guiSkin;
  1134. if (nTextures < 2) {
  1135. GUI.Box(buttonRect, "Apply procedural texture", "disabledButton");
  1136. EditorGUILayout.EndHorizontal();
  1137. EditorGUILayout.Separator();
  1138. EditorGUILayout.Separator();
  1139. EditorGUILayout.Separator();
  1140. EditorGUILayout.BeginHorizontal();
  1141. GUILayout.Label("This feature is disabled! You must assign at least 2 textures.", "errorText");
  1142. } else {
  1143. if (GUI.Button(buttonRect, "Apply procedural texture")) {
  1144. // Undo not supported!
  1145. TerrainToolkit.TextureProgressDelegate textureProgressDelegate = new TerrainToolkit.TextureProgressDelegate(updateTextureProgress);
  1146. terrain.textureTerrain(textureProgressDelegate);
  1147. EditorUtility.ClearProgressBar();
  1148. GUIUtility.ExitGUI();
  1149. }
  1150. }
  1151. GUI.skin = null;
  1152. EditorGUIUtility.LookLikeControls();
  1153. EditorGUILayout.EndHorizontal();
  1154. EditorGUILayout.Separator();
  1155. EditorGUILayout.Separator();
  1156. EditorGUILayout.Separator();
  1157. EditorGUILayout.Separator();
  1158. EditorGUILayout.Separator();
  1159. drawAdvancedSettingsGUI();
  1160. // If the user has added or removed textures in the Terrain component, correct the number of blend points...
  1161. if (Event.current.type == EventType.Repaint) {
  1162. if (numPoints % 2 != 0) {
  1163. terrain.deleteAllBlendPoints();
  1164. }
  1165. int correctNumPoints = (nTextures - 2) * 2;
  1166. if (nTextures < 3) {
  1167. correctNumPoints = 0;
  1168. }
  1169. if (numPoints < correctNumPoints) {
  1170. terrain.addBlendPoints();
  1171. } else if (numPoints > correctNumPoints) {
  1172. terrain.deleteBlendPoints();
  1173. }
  1174. }
  1175. break;
  1176. }
  1177. if (GUI.changed) {
  1178. EditorUtility.SetDirty(terrain);
  1179. }
  1180. }
  1181.  
  1182. public void OnSceneGUI() {
  1183. TerrainToolkit terrain = (TerrainToolkit) target as TerrainToolkit;
  1184. if (Event.current.type == EventType.MouseDown) {
  1185. terrain.isBrushPainting = true;
  1186. }
  1187. if (Event.current.type == EventType.MouseUp) {
  1188. terrain.isBrushPainting = false;
  1189. }
  1190. if (Event.current.shift) {
  1191. if (!terrain.isBrushPainting) {
  1192. // Undo...
  1193. Terrain ter = (Terrain) terrain.GetComponent(typeof(Terrain));
  1194. if (ter == null) {
  1195. return;
  1196. }
  1197. TerrainData terData = ter.terrainData;
  1198. Undo.RegisterUndo(terData, "Terrain Erosion Brush");
  1199. }
  1200. terrain.isBrushPainting = true;
  1201. } else {
  1202. terrain.isBrushPainting = false;
  1203. }
  1204. terrain.isBrushHidden = false;
  1205. if (terrain.isBrushOn) {
  1206. Vector2 mouse = Event.current.mousePosition;
  1207. mouse.y = Camera.current.pixelHeight - mouse.y + 20;
  1208. Ray ray = Camera.current.ScreenPointToRay(mouse);
  1209. RaycastHit hit;
  1210. if (Physics.Raycast(ray, out hit, Mathf.Infinity)) {
  1211. if (hit.transform.GetComponent("TerrainToolkit")) {
  1212. terrain.brushPosition = hit.point;
  1213. if (terrain.isBrushPainting) {
  1214. // Paint...
  1215. terrain.paint();
  1216. }
  1217. }
  1218. } else {
  1219. terrain.isBrushHidden = true;
  1220. }
  1221. }
  1222. }
  1223.  
  1224. private void drawBrushToolsGUI() {
  1225. TerrainToolkit terrain = (TerrainToolkit) target as TerrainToolkit;
  1226. EditorGUILayout.Separator();
  1227. EditorGUILayout.Separator();
  1228. EditorGUILayout.BeginHorizontal();
  1229. GUI.skin = terrain.guiSkin;
  1230. GUILayout.Label("Brushes");
  1231. GUI.skin = null;
  1232. EditorGUIUtility.LookLikeControls();
  1233. EditorGUILayout.EndHorizontal();
  1234. Rect toggleRect = EditorGUILayout.BeginHorizontal();
  1235. toggleRect.x = 110;
  1236. toggleRect.width = 80;
  1237. toggleRect.height = 20;
  1238. EditorGUILayout.PrefixLabel("Brush");
  1239. string[] brushStates = new string[2];
  1240. brushStates[0] = "Off";
  1241. brushStates[1] = "On";
  1242. int brushInt = 0;
  1243. if (terrain.isBrushOn) {
  1244. brushInt = 1;
  1245. }
  1246. brushInt = GUI.Toolbar(toggleRect, brushInt, brushStates);
  1247. bool brushBool = false;
  1248. if (brushInt == 1) {
  1249. brushBool = true;
  1250. }
  1251. terrain.isBrushOn = brushBool;
  1252. EditorGUILayout.EndHorizontal();
  1253. EditorGUILayout.Separator();
  1254. EditorGUILayout.BeginHorizontal();
  1255. GUILayout.Label(" HINTS:");
  1256. EditorGUILayout.EndHorizontal();
  1257. EditorGUILayout.BeginHorizontal();
  1258. GUILayout.Label(" 1. Hold down the SHIFT key to use the brush");
  1259. EditorGUILayout.EndHorizontal();
  1260. EditorGUILayout.BeginHorizontal();
  1261. GUILayout.Label(" 2. Use the brush PRESET for best results");
  1262. EditorGUILayout.EndHorizontal();
  1263. EditorGUILayout.Separator();
  1264. EditorGUILayout.BeginHorizontal();
  1265. EditorGUILayout.PrefixLabel("Brush size");
  1266. terrain.brushSize = EditorGUILayout.Slider(terrain.brushSize, 1, 100);
  1267. EditorGUILayout.EndHorizontal();
  1268. EditorGUILayout.BeginHorizontal();
  1269. EditorGUILayout.PrefixLabel("Opacity");
  1270. terrain.brushOpacity = EditorGUILayout.Slider(terrain.brushOpacity, 0, 1);
  1271. EditorGUILayout.EndHorizontal();
  1272. EditorGUILayout.BeginHorizontal();
  1273. EditorGUILayout.PrefixLabel("Softness");
  1274. terrain.brushSoftness = EditorGUILayout.Slider(terrain.brushSoftness, 0, 1);
  1275. EditorGUILayout.EndHorizontal();
  1276. }
  1277.  
  1278. private void drawAdvancedSettingsGUI() {
  1279. TerrainToolkit terrain = (TerrainToolkit) target as TerrainToolkit;
  1280. EditorGUILayout.BeginHorizontal();
  1281. showAdvancedSettings = EditorGUILayout.Foldout(showAdvancedSettings, "Advanced settings");
  1282. EditorGUILayout.EndHorizontal();
  1283. if (showAdvancedSettings) {
  1284. EditorGUILayout.Separator();
  1285. EditorGUILayout.BeginHorizontal();
  1286. GUILayout.Label("Cell neighbourhood");
  1287. EditorGUILayout.EndHorizontal();
  1288. EditorGUILayout.BeginHorizontal();
  1289. GUIContent[] neighbourhoodOptions = new GUIContent[2];
  1290. neighbourhoodOptions[0] = new GUIContent("Moore", terrain.mooreIcon);
  1291. neighbourhoodOptions[1] = new GUIContent("Von Neumann", terrain.vonNeumannIcon);
  1292. terrain.neighbourhoodInt = GUILayout.Toolbar(terrain.neighbourhoodInt, neighbourhoodOptions);
  1293. EditorGUILayout.EndHorizontal();
  1294. EditorGUILayout.Separator();
  1295. EditorGUILayout.BeginHorizontal();
  1296. GUILayout.Label("Use difference maps in brush mode");
  1297. EditorGUILayout.EndHorizontal();
  1298. Rect toggleRect = EditorGUILayout.BeginHorizontal();
  1299. toggleRect.x = 110;
  1300. toggleRect.width = 80;
  1301. toggleRect.height = 20;
  1302. string[] diffMapStates = new string[2];
  1303. diffMapStates[0] = "Off";
  1304. diffMapStates[1] = "On";
  1305. int diffMapInt = 0;
  1306. if (terrain.useDifferenceMaps) {
  1307. diffMapInt = 1;
  1308. }
  1309. diffMapInt = GUI.Toolbar(toggleRect, diffMapInt, diffMapStates);
  1310. bool diffMapBool = false;
  1311. if (diffMapInt == 1) {
  1312. diffMapBool = true;
  1313. }
  1314. terrain.useDifferenceMaps = diffMapBool;
  1315. EditorGUILayout.EndHorizontal();
  1316. EditorGUILayout.Separator();
  1317. EditorGUILayout.Separator();
  1318. EditorGUILayout.Separator();
  1319. EditorGUILayout.Separator();
  1320. EditorGUILayout.Separator();
  1321. EditorGUILayout.BeginHorizontal();
  1322. if (GUILayout.Button("Reload Presets")) {
  1323. terrain.presetsInitialised = false;
  1324. }
  1325. EditorGUILayout.EndHorizontal();
  1326. EditorGUILayout.Separator();
  1327. }
  1328. }
  1329.  
  1330. public void updateErosionProgress(string titleString, string displayString, int iteration, int nIterations, float percentComplete) {
  1331. EditorUtility.DisplayProgressBar(titleString, displayString+" Iteration "+iteration+" of "+nIterations+". Please wait.", percentComplete);
  1332. }
  1333.  
  1334. public void updateTextureProgress(string titleString, string displayString, float percentComplete) {
  1335. EditorUtility.DisplayProgressBar(titleString, displayString, percentComplete);
  1336. }
  1337.  
  1338. public void updateGeneratorProgress(string titleString, string displayString, float percentComplete) {
  1339. EditorUtility.DisplayProgressBar(titleString, displayString, percentComplete);
  1340. }
  1341. }
  1342.  
  1343. // -------------------------------------------------------------------------------------------------------- END
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!