public void DrawDebugBox(GPUInstancerEditorSimulator simulator = null)
{
if (!Application.isPlaying)
{
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
Rect foldoutRect = GUILayoutUtility.GetRect(0, 20, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
foldoutRect.x += 12;
showDebugBox = EditorGUI.Foldout(foldoutRect, showDebugBox, GPUInstancerEditorConstants.TEXT_debug, true, GPUInstancerEditorConstants.Styles.foldout);
if (showDebugBox)
{
if (simulator != null)
{
if (simulator.simulateAtEditor)
{
if (simulator.initializingInstances)
{
EditorGUI.BeginDisabledGroup(true);
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.simulateAtEditorPrep, GPUInstancerEditorConstants.Colors.darkBlue, Color.white,
FontStyle.Bold, Rect.zero, null);
EditorGUI.EndDisabledGroup();
}
else
{
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.simulateAtEditorStop, Color.red, Color.white,
FontStyle.Bold, Rect.zero, () =>
{
simulator.StopSimulation();
});
}
}
else
{
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.simulateAtEditor, GPUInstancerEditorConstants.Colors.green, Color.white,
FontStyle.Bold, Rect.zero, () =>
{
simulator.StartSimulation();
});
}
}
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_simulator);
_manager.keepSimulationLive = EditorGUILayout.Toggle("Keep Simulation Live", _manager.keepSimulationLive);
if (_manager.keepSimulationLive)
{
_manager.updateSimulation = EditorGUILayout.Toggle(new GUIContent("Update Simulation On Change", "Update Simulation On Change"), _manager.updateSimulation);
EditorGUILayout.HelpBox("Simulation is kept alive. The simulation might not show every change on terrain details. Changing some prototype settings during the simulation can also cause errors. Please stop and start the simulation again to solve these issues.", MessageType.Warning);
}
}
EditorGUILayout.EndVertical();
}
}
public virtual void OnDisable() // could also be OnDestroy, but OnDestroy seems to be too late to prevent buffer leaks.
{
if (activeManagerList != null)
{
activeManagerList.Remove(this);
}
ClearInstancingData();
#if UNITY_EDITOR
if (gpuiSimulator != null)
{
gpuiSimulator.ClearEditorUpdates();
gpuiSimulator = null;
}
#endif
}
public static bool DrawGPUInstancerPrototypeInfo(List <GPUInstancerPrototype> selectedPrototypeList, UnityAction <string> DrawHelpText, Object component, UnityAction OnEditorDataChanged,
GPUInstancerEditorSimulator simulator, GPUInstancerTerrainSettings terrainSettings)
{
GPUInstancerTreePrototype prototype0 = (GPUInstancerTreePrototype)selectedPrototypeList[0];
#region Determine Multiple Values
bool hasChanged = false;
bool isApplyRotationMixed = false;
bool isApplyRotation = prototype0.isApplyRotation;
bool isApplyPrefabScaleMixed = false;
bool isApplyPrefabScale = prototype0.isApplyPrefabScale;
bool isApplyTerrainHeightMixed = false;
bool isApplyTerrainHeight = prototype0.isApplyTerrainHeight;
for (int i = 1; i < selectedPrototypeList.Count; i++)
{
GPUInstancerTreePrototype prototypeI = (GPUInstancerTreePrototype)selectedPrototypeList[i];
if (!isApplyRotationMixed && isApplyRotation != prototypeI.isApplyRotation)
{
isApplyRotationMixed = true;
}
if (!isApplyPrefabScaleMixed && isApplyPrefabScale != prototypeI.isApplyPrefabScale)
{
isApplyPrefabScaleMixed = true;
}
if (!isApplyTerrainHeightMixed && isApplyTerrainHeight != prototypeI.isApplyTerrainHeight)
{
isApplyTerrainHeightMixed = true;
}
}
#endregion Determine Multiple Values
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_treeSettings, GPUInstancerEditorConstants.Styles.boldLabel);
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_useRandomTreeRotation, isApplyRotation, isApplyRotationMixed, (p, v) => ((GPUInstancerTreePrototype)p).isApplyRotation = v);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_useRandomTreeRotation);
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_useTerrainHeight, isApplyTerrainHeight, isApplyTerrainHeightMixed, (p, v) => ((GPUInstancerTreePrototype)p).isApplyTerrainHeight = v);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_useTerrainHeight);
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_usePrefabScale, isApplyPrefabScale, isApplyPrefabScaleMixed, (p, v) => ((GPUInstancerTreePrototype)p).isApplyPrefabScale = v);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_usePrefabScale);
EditorGUILayout.EndVertical();
return(hasChanged);
}
public static void DrawGPUInstancerPrototypeInfo(GPUInstancerPrototype selectedPrototype, UnityAction <string> DrawHelpText, Object component, UnityAction OnEditorDataChanged,
GPUInstancerEditorSimulator simulator, GPUInstancerTerrainSettings terrainSettings)
{
GPUInstancerTreePrototype treePrototype = (GPUInstancerTreePrototype)selectedPrototype;
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_treeSettings, GPUInstancerEditorConstants.Styles.boldLabel);
treePrototype.isApplyRotation = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_useRandomTreeRotation, treePrototype.isApplyRotation);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_useRandomTreeRotation);
treePrototype.isApplyTerrainHeight = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_useTerrainHeight, treePrototype.isApplyTerrainHeight);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_useTerrainHeight);
treePrototype.isApplyPrefabScale = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_usePrefabScale, treePrototype.isApplyPrefabScale);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_usePrefabScale);
EditorGUILayout.EndVertical();
}
public void DrawDebugBox(GPUInstancerEditorSimulator simulator = null)
{
if (!Application.isPlaying)
{
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_debug, GPUInstancerEditorConstants.Styles.boldLabel);
if (simulator != null)
{
if (simulator.simulateAtEditor)
{
if (simulator.initializingInstances)
{
EditorGUI.BeginDisabledGroup(true);
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.simulateAtEditorPrep, GPUInstancerEditorConstants.Colors.darkBlue, Color.white,
FontStyle.Bold, Rect.zero, null);
EditorGUI.EndDisabledGroup();
}
else
{
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.simulateAtEditorStop, Color.red, Color.white,
FontStyle.Bold, Rect.zero, () =>
{
simulator.StopSimulation();
});
}
}
else
{
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.simulateAtEditor, GPUInstancerEditorConstants.Colors.green, Color.white,
FontStyle.Bold, Rect.zero, () =>
{
simulator.StartSimulation();
});
}
}
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_simulator);
EditorGUILayout.EndVertical();
}
}
public virtual void OnDisable() // could also be OnDestroy, but OnDestroy seems to be too late to prevent buffer leaks.
{
if (activeManagerList != null)
{
activeManagerList.Remove(this);
}
ClearInstancingData();
#if UNITY_EDITOR
if (gpuiSimulator != null)
{
gpuiSimulator.ClearEditorUpdates();
gpuiSimulator = null;
}
#endif
if (floatingOriginHandler != null && floatingOriginHandler.gPUIManagers != null && floatingOriginHandler.gPUIManagers.Contains(this))
{
floatingOriginHandler.gPUIManagers.Remove(this);
}
}
public virtual void OnEnable()
{
#if UNITY_EDITOR
if (gpuiSimulator == null)
{
gpuiSimulator = new GPUInstancerEditorSimulator(this);
}
#endif
if (Application.isPlaying && cameraData.mainCamera == null)
{
InitializeCameraData();
if (cameraData.mainCamera == null)
{
Debug.LogWarning(GPUInstancerConstants.ERRORTEXT_cameraNotFound);
}
}
if (activeManagerList != null && !activeManagerList.Contains(this))
{
activeManagerList.Add(this);
}
if (Application.isPlaying && SystemInfo.supportsComputeShaders)
{
if (shaderBindings == null)
{
Debug.LogWarning("No shader bindings file was supplied. Instancing will terminate!");
}
if (runtimeDataList == null || runtimeDataList.Count == 0)
{
InitializeRuntimeDataAndBuffers();
}
isInitial = true;
}
}
public virtual void OnEnable()
{
#if UNITY_EDITOR
if (gpuiSimulator == null)
{
gpuiSimulator = new GPUInstancerEditorSimulator(this);
}
#endif
if (!Application.isPlaying)
{
return;
}
if (cameraData.mainCamera == null)
{
InitializeCameraData();
if (cameraData.mainCamera == null)
{
Debug.LogWarning(GPUInstancerConstants.ERRORTEXT_cameraNotFound);
}
}
if (activeManagerList != null && !activeManagerList.Contains(this))
{
activeManagerList.Add(this);
}
if (SystemInfo.supportsComputeShaders)
{
if (GPUInstancerConstants.gpuiSettings == null || GPUInstancerConstants.gpuiSettings.shaderBindings == null)
{
Debug.LogWarning("No shader bindings file was supplied. Instancing will terminate!");
}
if (runtimeDataList == null || runtimeDataList.Count == 0)
{
InitializeRuntimeDataAndBuffers();
}
isInitial = true;
}
if (useFloatingOriginHandler && floatingOriginTransform != null)
{
if (floatingOriginHandler == null)
{
floatingOriginHandler = floatingOriginTransform.gameObject.GetComponent <GPUInstancerFloatingOriginHandler>();
if (floatingOriginHandler == null)
{
floatingOriginHandler = floatingOriginTransform.gameObject.AddComponent <GPUInstancerFloatingOriginHandler>();
}
}
if (floatingOriginHandler.gPUIManagers == null)
{
floatingOriginHandler.gPUIManagers = new List <GPUInstancerManager>();
}
if (!floatingOriginHandler.gPUIManagers.Contains(this))
{
floatingOriginHandler.gPUIManagers.Add(this);
}
}
}
public static void DrawGPUInstancerPrototypeInfo(GPUInstancerPrototype selectedPrototype, UnityAction <string> DrawHelpText, UnityEngine.Object component, UnityAction OnEditorDataChanged,
GPUInstancerShaderBindings shaderBindings, GPUInstancerEditorSimulator simulator, GPUInstancerTerrainSettings terrainSettings, int detailLayer)
{
GPUInstancerDetailPrototype prototype = (GPUInstancerDetailPrototype)selectedPrototype;
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_detailProperties, GPUInstancerEditorConstants.Styles.boldLabel);
EditorGUI.BeginChangeCheck();
prototype.detailDensity = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_detailDensity, prototype.detailDensity, 0.0f, terrainSettings.detailDensity);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_detailDensity);
prototype.detailScale = EditorGUILayout.Vector4Field(GPUInstancerEditorConstants.TEXT_detailScale, prototype.detailScale);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_detailScale);
prototype.noiseSpread = EditorGUILayout.FloatField(GPUInstancerEditorConstants.TEXT_noiseSpread, prototype.noiseSpread);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_noiseSpread);
prototype.useCustomHealthyDryNoiseTexture = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_useCustomHealthyDryNoiseTexture, prototype.useCustomHealthyDryNoiseTexture);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_useCustomHealthyDryNoiseTexture);
if (prototype.useCustomHealthyDryNoiseTexture)
{
prototype.healthyDryNoiseTexture = (Texture2D)EditorGUILayout.ObjectField(GPUInstancerEditorConstants.TEXT_healthyDryNoiseTexture, prototype.healthyDryNoiseTexture, typeof(Texture2D), false);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_healthyDryNoiseTexture);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(component, "Editor data changed.");
if (OnEditorDataChanged != null)
{
OnEditorDataChanged();
}
EditorUtility.SetDirty(prototype);
}
EditorGUI.BeginChangeCheck();
if (!prototype.usePrototypeMesh)
{
prototype.useCustomMaterialForTextureDetail = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_useCustomMaterialForTextureDetail, prototype.useCustomMaterialForTextureDetail);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_useCustomMaterialForTextureDetail);
if (prototype.useCustomMaterialForTextureDetail)
{
prototype.textureDetailCustomMaterial = (Material)EditorGUILayout.ObjectField(GPUInstancerEditorConstants.TEXT_textureDetailCustomMaterial, prototype.textureDetailCustomMaterial, typeof(Material), false);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_textureDetailCustomMaterial);
prototype.isBillboard = false;
}
else
{
prototype.textureDetailCustomMaterial = null;
}
}
EditorGUILayout.EndVertical();
if (!prototype.usePrototypeMesh && !prototype.isBillboard)
{
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_crossQuads, GPUInstancerEditorConstants.Styles.boldLabel);
prototype.useCrossQuads = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_crossQuads, prototype.useCrossQuads);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_crossQuads);
if (prototype.useCrossQuads)
{
prototype.quadCount = EditorGUILayout.IntSlider(GPUInstancerEditorConstants.TEXT_quadCount, prototype.quadCount, 2, 4);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_quadCount);
if (!prototype.useCustomMaterialForTextureDetail)
{
prototype.billboardDistance = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_billboardDistance, prototype.billboardDistance, 0.5f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_billboardDistance);
prototype.billboardDistanceDebug = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_billboardDistanceDebug, prototype.billboardDistanceDebug);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_billboardDistanceDebug);
if (prototype.billboardDistanceDebug)
{
prototype.billboardDistanceDebugColor = EditorGUILayout.ColorField(GPUInstancerEditorConstants.TEXT_billboardDistanceDebugColor, prototype.billboardDistanceDebugColor);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_billboardDistanceDebugColor);
}
prototype.billboardFaceCamPos = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_CQBillboardFaceCamPos, prototype.billboardFaceCamPos);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_CQBillboardFaceCamPos);
}
}
else
{
prototype.quadCount = 1;
}
EditorGUILayout.EndVertical();
}
else
{
prototype.useCrossQuads = false;
}
if (EditorGUI.EndChangeCheck())
{
if (!prototype.usePrototypeMesh && prototype.useCustomMaterialForTextureDetail && prototype.textureDetailCustomMaterial != null)
{
if (!shaderBindings.IsShadersInstancedVersionExists(prototype.textureDetailCustomMaterial.shader.name))
{
Shader instancedShader;
if (GPUInstancerUtility.IsShaderInstanced(prototype.textureDetailCustomMaterial.shader))
{
instancedShader = prototype.textureDetailCustomMaterial.shader;
}
else
{
instancedShader = GPUInstancerUtility.CreateInstancedShader(prototype.textureDetailCustomMaterial.shader, shaderBindings);
}
if (instancedShader != null)
{
shaderBindings.AddShaderInstance(prototype.textureDetailCustomMaterial.shader.name, instancedShader);
}
else
{
Debug.LogWarning("Can not create instanced version for shader: " + prototype.textureDetailCustomMaterial.shader.name + ". Standard Shader will be used instead.");
}
}
}
EditorUtility.SetDirty(prototype);
}
if (!prototype.usePrototypeMesh && !prototype.useCustomMaterialForTextureDetail)
{
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_foliageShaderProperties, GPUInstancerEditorConstants.Styles.boldLabel);
EditorGUI.BeginChangeCheck();
prototype.isBillboard = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_isBillboard, prototype.isBillboard);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_isBillboard);
if (prototype.isBillboard)
{
prototype.billboardFaceCamPos = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_billboardFaceCamPos, prototype.billboardFaceCamPos);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_billboardFaceCamPos);
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(prototype);
if (simulator != null && simulator.simulateAtEditor && !simulator.initializingInstances)
{
GPUInstancerUtility.UpdateDetailInstanceRuntimeDataList(simulator.gpuiManager.runtimeDataList, terrainSettings, false, detailLayer);
}
}
EditorGUI.BeginChangeCheck();
prototype.detailHealthyColor = EditorGUILayout.ColorField(GPUInstancerEditorConstants.TEXT_detailHealthyColor, prototype.detailHealthyColor);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_detailHealthyColor);
prototype.detailDryColor = EditorGUILayout.ColorField(GPUInstancerEditorConstants.TEXT_detailDryColor, prototype.detailDryColor);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_detailDryColor);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(component, "Editor data changed.");
if (OnEditorDataChanged != null)
{
OnEditorDataChanged();
}
if (simulator != null && simulator.simulateAtEditor && !simulator.initializingInstances)
{
GPUInstancerUtility.UpdateDetailInstanceRuntimeDataList(simulator.gpuiManager.runtimeDataList, terrainSettings, false, detailLayer);
}
EditorUtility.SetDirty(prototype);
}
EditorGUI.BeginChangeCheck();
prototype.ambientOcclusion = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_ambientOcclusion, prototype.ambientOcclusion, 0f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_ambientOcclusion);
prototype.gradientPower = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_gradientPower, prototype.gradientPower, 0f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_gradientPower);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_windSettings, GPUInstancerEditorConstants.Styles.boldLabel);
prototype.windIdleSway = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_windIdleSway, prototype.windIdleSway, 0f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_windIdleSway);
prototype.windWavesOn = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_windWavesOn, prototype.windWavesOn);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_windWavesOn);
if (prototype.windWavesOn)
{
prototype.windWaveTintColor = EditorGUILayout.ColorField(GPUInstancerEditorConstants.TEXT_windWaveTintColor, prototype.windWaveTintColor);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_windWaveTintColor);
prototype.windWaveSize = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_windWaveSize, prototype.windWaveSize, 0f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_windWaveSize);
prototype.windWaveTint = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_windWaveTint, prototype.windWaveTint, 0f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_windWaveTint);
prototype.windWaveSway = EditorGUILayout.Slider(GPUInstancerEditorConstants.TEXT_windWaveSway, prototype.windWaveSway, 0f, 1f);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_windWaveSway);
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(prototype);
if (simulator != null && simulator.simulateAtEditor && !simulator.initializingInstances)
{
GPUInstancerUtility.UpdateDetailInstanceRuntimeDataList(simulator.gpuiManager.runtimeDataList, terrainSettings, false, detailLayer);
}
}
EditorGUILayout.EndVertical();
}
}