983 lines
51 KiB
C#
983 lines
51 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
namespace GPUInstancer
|
|
{
|
|
[CustomEditor(typeof(GPUInstancerPrefabManager))]
|
|
[CanEditMultipleObjects]
|
|
public class GPUInstancerPrefabManagerEditor : GPUInstancerManagerEditor
|
|
{
|
|
private GPUInstancerPrefabManager _prefabManager;
|
|
|
|
protected SerializedProperty prop_enableMROnManagerDisable;
|
|
|
|
protected override void OnEnable()
|
|
{
|
|
base.OnEnable();
|
|
|
|
wikiHash = "#The_Prefab_Manager";
|
|
|
|
_prefabManager = (target as GPUInstancerPrefabManager);
|
|
|
|
prop_enableMROnManagerDisable = serializedObject.FindProperty("enableMROnManagerDisable");
|
|
}
|
|
|
|
protected override void OnDisable()
|
|
{
|
|
base.OnDisable();
|
|
//if (!Application.isPlaying && _prefabManager.gpuiSimulator != null && _prefabManager.gpuiSimulator.simulateAtEditor)
|
|
// _prefabManager.gpuiSimulator.StopSimulation();
|
|
}
|
|
|
|
public override void OnInspectorGUI()
|
|
{
|
|
serializedObject.Update();
|
|
|
|
base.OnInspectorGUI();
|
|
|
|
DrawSceneSettingsBox();
|
|
|
|
DrawPrefabGlobalInfoBox();
|
|
|
|
DrawRegisteredPrefabsBox();
|
|
foreach (GPUInstancerPrefabPrototype prototype in _prefabManager.prototypeList)
|
|
{
|
|
if (prototype == null)
|
|
continue;
|
|
|
|
CheckPrefabRigidbodies(prototype);
|
|
}
|
|
|
|
DrawGPUInstancerPrototypesBox();
|
|
|
|
HandlePickerObjectSelection();
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
|
|
base.InspectorGUIEnd();
|
|
}
|
|
|
|
public override void ShowObjectPicker()
|
|
{
|
|
base.ShowObjectPicker();
|
|
|
|
EditorGUIUtility.ShowObjectPicker<GameObject>(null, false, "t:prefab", pickerControlID);
|
|
}
|
|
|
|
public override void AddPickerObject(UnityEngine.Object pickerObject, GPUInstancerPrototype overridePrototype = null)
|
|
{
|
|
base.AddPickerObject(pickerObject, overridePrototype);
|
|
|
|
AddPickerObject(_prefabManager, pickerObject, overridePrototype);
|
|
}
|
|
|
|
public static GPUInstancerPrefabPrototype AddPickerObject(GPUInstancerPrefabManager _prefabManager, UnityEngine.Object pickerObject, GPUInstancerPrototype overridePrototype = null)
|
|
{
|
|
if (pickerObject == null)
|
|
return null;
|
|
|
|
if (pickerObject is GPUInstancerPrefabPrototype)
|
|
{
|
|
GPUInstancerPrefabPrototype prefabPrototype = (GPUInstancerPrefabPrototype)pickerObject;
|
|
if (prefabPrototype.prefabObject != null)
|
|
{
|
|
pickerObject = prefabPrototype.prefabObject;
|
|
}
|
|
}
|
|
|
|
if (!(pickerObject is GameObject))
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
if (PrefabUtility.GetPrefabAssetType(pickerObject) == PrefabAssetType.Model)
|
|
#else
|
|
if (PrefabUtility.GetPrefabType(pickerObject) == PrefabType.ModelPrefab)
|
|
#endif
|
|
EditorUtility.DisplayDialog(GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_TITLE, GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_3D, GPUInstancerConstants.TEXT_OK);
|
|
else
|
|
EditorUtility.DisplayDialog(GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_TITLE, GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING, GPUInstancerConstants.TEXT_OK);
|
|
return null;
|
|
}
|
|
|
|
GameObject prefabObject = (GameObject)pickerObject;
|
|
|
|
#if UNITY_2018_3_OR_NEWER
|
|
PrefabAssetType prefabType = PrefabUtility.GetPrefabAssetType(pickerObject);
|
|
|
|
if (prefabType == PrefabAssetType.Regular || prefabType == PrefabAssetType.Variant)
|
|
{
|
|
if (PrefabUtility.IsPartOfNonAssetPrefabInstance(prefabObject))
|
|
prefabObject = GPUInstancerUtility.GetOutermostPrefabAssetRoot(prefabObject);
|
|
}
|
|
else
|
|
{
|
|
if (prefabType == PrefabAssetType.Model)
|
|
EditorUtility.DisplayDialog(GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_TITLE, GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_3D, GPUInstancerConstants.TEXT_OK);
|
|
else
|
|
EditorUtility.DisplayDialog(GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_TITLE, GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING, GPUInstancerConstants.TEXT_OK);
|
|
return null;
|
|
}
|
|
if (prefabType == PrefabAssetType.Variant)
|
|
{
|
|
GameObject correspondingPrefab = GPUInstancerUtility.GetCorrespongingPrefabOfVariant(prefabObject);
|
|
PrefabAssetType correspondingPrefabType = PrefabUtility.GetPrefabAssetType(correspondingPrefab);
|
|
if (correspondingPrefabType != PrefabAssetType.Model
|
|
&& prefabObject.GetComponent<GPUInstancerPrefab>() == null
|
|
&& !EditorUtility.DisplayDialog("Variant Prefab Warning",
|
|
"Prefab is a Variant. Do you wish to add the Variant as a prototype or the corresponding Prefab?" +
|
|
"\n\nIt is recommended to add the Prefab, if you do not have different renderers for the Variant.",
|
|
"Add Variant",
|
|
"Add Prefab"))
|
|
{
|
|
prefabObject = GPUInstancerUtility.GetCorrespongingPrefabOfVariant(prefabObject);
|
|
}
|
|
}
|
|
#else
|
|
PrefabType prefabType = PrefabUtility.GetPrefabType(pickerObject);
|
|
|
|
if (prefabType != PrefabType.Prefab)
|
|
{
|
|
bool instanceFound = false;
|
|
if (prefabType == PrefabType.PrefabInstance)
|
|
{
|
|
#if UNITY_2018_2_OR_NEWER
|
|
GameObject newPrefabObject = (GameObject)PrefabUtility.GetCorrespondingObjectFromSource(prefabObject);
|
|
#else
|
|
GameObject newPrefabObject = (GameObject)PrefabUtility.GetPrefabParent(prefabObject);
|
|
#endif
|
|
if (PrefabUtility.GetPrefabType(newPrefabObject) == PrefabType.Prefab)
|
|
{
|
|
while (newPrefabObject.transform.parent != null)
|
|
newPrefabObject = newPrefabObject.transform.parent.gameObject;
|
|
prefabObject = newPrefabObject;
|
|
instanceFound = true;
|
|
}
|
|
}
|
|
if (!instanceFound)
|
|
{
|
|
if (prefabType == PrefabType.ModelPrefab)
|
|
EditorUtility.DisplayDialog(GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_TITLE, GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_3D, GPUInstancerConstants.TEXT_OK);
|
|
else
|
|
EditorUtility.DisplayDialog(GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING_TITLE, GPUInstancerConstants.TEXT_PREFAB_TYPE_WARNING, GPUInstancerConstants.TEXT_OK);
|
|
return null;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (_prefabManager.prefabList.Contains(prefabObject))
|
|
{
|
|
return prefabObject.GetComponent<GPUInstancerPrefab>().prefabPrototype;
|
|
}
|
|
|
|
GPUInstancerPrefab prefabScript = prefabObject.GetComponent<GPUInstancerPrefab>();
|
|
if(prefabScript != null && prefabScript.prefabPrototype != null && prefabScript.prefabPrototype.prefabObject != prefabObject)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.RemoveComponentFromPrefab<GPUInstancerPrefab>(prefabObject);
|
|
#else
|
|
DestroyImmediate(prefabScript, true);
|
|
#endif
|
|
prefabScript = null;
|
|
}
|
|
|
|
if (prefabScript == null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
prefabScript = GPUInstancerUtility.AddComponentToPrefab<GPUInstancerPrefab>(prefabObject);
|
|
#else
|
|
prefabScript = prefabObject.AddComponent<GPUInstancerPrefab>();
|
|
#endif
|
|
}
|
|
if (prefabScript == null)
|
|
return null;
|
|
|
|
if (prefabScript.prefabPrototype != null && _prefabManager.prototypeList.Contains(prefabScript.prefabPrototype))
|
|
{
|
|
return prefabScript.prefabPrototype;
|
|
}
|
|
|
|
Undo.RecordObject(_prefabManager, "Add prototype");
|
|
|
|
if (!_prefabManager.prefabList.Contains(prefabObject))
|
|
{
|
|
_prefabManager.prefabList.Add(prefabObject);
|
|
_prefabManager.GeneratePrototypes();
|
|
}
|
|
|
|
if (prefabScript.prefabPrototype != null)
|
|
{
|
|
if (_prefabManager.registeredPrefabs == null)
|
|
_prefabManager.registeredPrefabs = new List<RegisteredPrefabsData>();
|
|
|
|
RegisteredPrefabsData data = _prefabManager.registeredPrefabs.Find(d => d.prefabPrototype == prefabScript.prefabPrototype);
|
|
if (data == null)
|
|
{
|
|
data = new RegisteredPrefabsData(prefabScript.prefabPrototype);
|
|
_prefabManager.registeredPrefabs.Add(data);
|
|
}
|
|
|
|
GPUInstancerPrefab[] scenePrefabInstances = FindObjectsOfType<GPUInstancerPrefab>();
|
|
foreach (GPUInstancerPrefab prefabInstance in scenePrefabInstances)
|
|
if (prefabInstance.prefabPrototype == prefabScript.prefabPrototype)
|
|
data.registeredPrefabs.Add(prefabInstance);
|
|
}
|
|
return prefabScript.prefabPrototype;
|
|
}
|
|
|
|
public override void DrawSettingContents()
|
|
{
|
|
EditorGUILayout.Space();
|
|
|
|
DrawCameraDataFields();
|
|
|
|
DrawCullingSettings(_prefabManager.prototypeList);
|
|
|
|
DrawFloatingOriginFields();
|
|
|
|
DrawLayerMaskFields();
|
|
}
|
|
|
|
public override void DrawLayerMaskFields()
|
|
{
|
|
base.DrawLayerMaskFields();
|
|
EditorGUI.BeginDisabledGroup(Application.isPlaying);
|
|
EditorGUILayout.PropertyField(prop_enableMROnManagerDisable, GPUInstancerEditorConstants.Contents.enableMROnManagerDisable);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_enableMROnManagerDisable);
|
|
EditorGUI.EndDisabledGroup();
|
|
}
|
|
|
|
public void DrawPrefabGlobalInfoBox()
|
|
{
|
|
//if (_prefabManager.prefabList == null)
|
|
// return;
|
|
|
|
//EditorGUI.BeginDisabledGroup(Application.isPlaying);
|
|
//EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
|
|
//GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_prefabGlobal, GPUInstancerEditorConstants.Styles.boldLabel);
|
|
|
|
//EditorGUILayout.EndVertical();
|
|
//EditorGUI.EndDisabledGroup();
|
|
}
|
|
|
|
public static void SetRenderersEnabled(GPUInstancerPrefabPrototype prefabPrototype, bool enabled)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GameObject prefabContents = GPUInstancerUtility.LoadPrefabContents(prefabPrototype.prefabObject);
|
|
#else
|
|
GameObject prefabContents = prefabPrototype.prefabObject;
|
|
#endif
|
|
MeshRenderer[] meshRenderers = prefabContents.GetComponentsInChildren<MeshRenderer>(true);
|
|
if (meshRenderers != null && meshRenderers.Length > 0)
|
|
for (int mr = 0; mr < meshRenderers.Length; mr++)
|
|
meshRenderers[mr].enabled = enabled;
|
|
|
|
BillboardRenderer[] billboardRenderers = prefabContents.GetComponentsInChildren<BillboardRenderer>(true);
|
|
if (billboardRenderers != null && billboardRenderers.Length > 0)
|
|
for (int mr = 0; mr < billboardRenderers.Length; mr++)
|
|
billboardRenderers[mr].enabled = enabled;
|
|
|
|
LODGroup lodGroup = prefabContents.GetComponent<LODGroup>();
|
|
if (lodGroup != null)
|
|
lodGroup.enabled = enabled;
|
|
|
|
if (prefabPrototype.hasRigidBody)
|
|
{
|
|
Rigidbody rigidbody = prefabContents.GetComponent<Rigidbody>();
|
|
|
|
if (enabled || prefabPrototype.autoUpdateTransformData)
|
|
{
|
|
if (rigidbody == null)
|
|
{
|
|
GPUInstancerPrefabPrototype.RigidbodyData rigidbodyData = prefabPrototype.rigidbodyData;
|
|
if (rigidbodyData != null)
|
|
{
|
|
rigidbody = prefabPrototype.prefabObject.AddComponent<Rigidbody>();
|
|
rigidbody.useGravity = rigidbodyData.useGravity;
|
|
rigidbody.angularDrag = rigidbodyData.angularDrag;
|
|
rigidbody.mass = rigidbodyData.mass;
|
|
rigidbody.constraints = rigidbodyData.constraints;
|
|
rigidbody.detectCollisions = true;
|
|
rigidbody.drag = rigidbodyData.drag;
|
|
rigidbody.isKinematic = rigidbodyData.isKinematic;
|
|
rigidbody.interpolation = rigidbodyData.interpolation;
|
|
}
|
|
}
|
|
}
|
|
else if (rigidbody != null && !prefabPrototype.autoUpdateTransformData)
|
|
DestroyImmediate(rigidbody, true);
|
|
}
|
|
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.UnloadPrefabContents(prefabPrototype.prefabObject, prefabContents, true);
|
|
#endif
|
|
EditorUtility.SetDirty(prefabPrototype.prefabObject);
|
|
prefabPrototype.meshRenderersDisabled = !enabled;
|
|
EditorUtility.SetDirty(prefabPrototype);
|
|
}
|
|
|
|
#if UNITY_2018_1_OR_NEWER
|
|
public void SerializeTransforms(GPUInstancerPrefabPrototype prefabPrototype)
|
|
{
|
|
if (_prefabManager == null || _prefabManager.registeredPrefabs == null)
|
|
return;
|
|
RegisteredPrefabsData registeredPrefabsData = _prefabManager.registeredPrefabs.Find(rpd => rpd.prefabPrototype == prefabPrototype);
|
|
if (registeredPrefabsData == null || registeredPrefabsData.registeredPrefabs == null || registeredPrefabsData.registeredPrefabs.Count == 0)
|
|
return;
|
|
string transformString = "";
|
|
foreach (GPUInstancerPrefab prefabInstance in registeredPrefabsData.registeredPrefabs)
|
|
{
|
|
transformString += GPUInstancerUtility.Matrix4x4ToString(prefabInstance.transform.localToWorldMatrix) + "\n";
|
|
}
|
|
transformString = transformString.Substring(0, transformString.Length - 2);
|
|
TextAsset textAsset = new TextAsset(transformString);
|
|
|
|
string assetPath = GPUInstancerConstants.GetDefaultPath() + GPUInstancerConstants.PROTOTYPES_SERIALIZED_PATH + prefabPrototype.name + ".asset";
|
|
if (!System.IO.Directory.Exists(GPUInstancerConstants.GetDefaultPath() + GPUInstancerConstants.PROTOTYPES_SERIALIZED_PATH))
|
|
{
|
|
System.IO.Directory.CreateDirectory(GPUInstancerConstants.GetDefaultPath() + GPUInstancerConstants.PROTOTYPES_SERIALIZED_PATH);
|
|
}
|
|
AssetDatabase.CreateAsset(textAsset, assetPath);
|
|
AssetDatabase.SaveAssets();
|
|
prefabPrototype.isTransformsSerialized = true;
|
|
prefabPrototype.serializedTransformData = textAsset;
|
|
prefabPrototype.serializedTransformDataCount = registeredPrefabsData.registeredPrefabs.Count;
|
|
|
|
foreach (GPUInstancerPrefab prefabInstance in registeredPrefabsData.registeredPrefabs)
|
|
{
|
|
DestroyImmediate(prefabInstance.gameObject);
|
|
}
|
|
registeredPrefabsData.registeredPrefabs.Clear();
|
|
}
|
|
|
|
public void DeserializeTransforms(GPUInstancerPrefabPrototype prefabPrototype)
|
|
{
|
|
if (_prefabManager == null || _prefabManager.registeredPrefabs == null)
|
|
return;
|
|
RegisteredPrefabsData registeredPrefabsData = _prefabManager.registeredPrefabs.Find(rpd => rpd.prefabPrototype == prefabPrototype);
|
|
if (registeredPrefabsData == null || registeredPrefabsData.registeredPrefabs == null)
|
|
return;
|
|
|
|
string matrixStr;
|
|
System.IO.StringReader strReader = new System.IO.StringReader(prefabPrototype.serializedTransformData.text);
|
|
Matrix4x4 matrix;
|
|
GameObject parent = new GameObject(prefabPrototype.prefabObject.name + " Instances");
|
|
parent.transform.position = Vector3.zero;
|
|
parent.transform.rotation = Quaternion.identity;
|
|
parent.transform.localScale = Vector3.one;
|
|
while (true)
|
|
{
|
|
matrixStr = strReader.ReadLine();
|
|
if (!string.IsNullOrEmpty(matrixStr))
|
|
{
|
|
matrix = GPUInstancerUtility.Matrix4x4FromString(matrixStr);
|
|
GameObject prefabInstance = (GameObject)PrefabUtility.InstantiatePrefab(prefabPrototype.prefabObject);
|
|
prefabInstance.transform.SetMatrix4x4ToTransform(matrix);
|
|
registeredPrefabsData.registeredPrefabs.Add(prefabInstance.GetComponent<GPUInstancerPrefab>());
|
|
prefabInstance.transform.parent = parent.transform;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
DestroyImmediate(prefabPrototype.serializedTransformData, true);
|
|
|
|
prefabPrototype.isTransformsSerialized = false;
|
|
prefabPrototype.serializedTransformData = null;
|
|
prefabPrototype.serializedTransformDataCount = 0;
|
|
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
|
|
public void SerializeAdditionalTransforms()
|
|
{
|
|
if (_prefabManager == null || _prefabManager.registeredPrefabs == null)
|
|
return;
|
|
|
|
foreach(GPUInstancerPrefabPrototype prefabPrototype in _prefabManager.prototypeList)
|
|
{
|
|
if (!prefabPrototype.isTransformsSerialized)
|
|
continue;
|
|
|
|
RegisteredPrefabsData registeredPrefabsData = _prefabManager.registeredPrefabs.Find(rpd => rpd.prefabPrototype == prefabPrototype);
|
|
if (registeredPrefabsData == null || registeredPrefabsData.registeredPrefabs == null || registeredPrefabsData.registeredPrefabs.Count == 0)
|
|
continue;
|
|
string transformString = prefabPrototype.serializedTransformData.text + "\n";
|
|
foreach (GPUInstancerPrefab prefabInstance in registeredPrefabsData.registeredPrefabs)
|
|
{
|
|
transformString += GPUInstancerUtility.Matrix4x4ToString(prefabInstance.transform.localToWorldMatrix) + "\n";
|
|
}
|
|
transformString = transformString.Substring(0, transformString.Length - 2);
|
|
TextAsset textAsset = new TextAsset(transformString);
|
|
|
|
string assetPath = GPUInstancerConstants.GetDefaultPath() + GPUInstancerConstants.PROTOTYPES_SERIALIZED_PATH + prefabPrototype.name + ".asset";
|
|
if (!System.IO.Directory.Exists(GPUInstancerConstants.GetDefaultPath() + GPUInstancerConstants.PROTOTYPES_SERIALIZED_PATH))
|
|
{
|
|
System.IO.Directory.CreateDirectory(GPUInstancerConstants.GetDefaultPath() + GPUInstancerConstants.PROTOTYPES_SERIALIZED_PATH);
|
|
}
|
|
AssetDatabase.CreateAsset(textAsset, assetPath);
|
|
AssetDatabase.SaveAssets();
|
|
prefabPrototype.isTransformsSerialized = true;
|
|
prefabPrototype.serializedTransformData = textAsset;
|
|
prefabPrototype.serializedTransformDataCount += registeredPrefabsData.registeredPrefabs.Count;
|
|
|
|
foreach (GPUInstancerPrefab prefabInstance in registeredPrefabsData.registeredPrefabs)
|
|
{
|
|
DestroyImmediate(prefabInstance.gameObject);
|
|
}
|
|
registeredPrefabsData.registeredPrefabs.Clear();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public override void DrawAddPrototypeHelpText()
|
|
{
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addprototypeprefab);
|
|
}
|
|
|
|
public static void CheckPrefabRigidbodies(GPUInstancerPrefabPrototype prototype)
|
|
{
|
|
if (prototype.prefabObject != null && !prototype.meshRenderersDisabled)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
Rigidbody rigidbody = prototype.prefabObject.GetComponent<Rigidbody>();
|
|
if (rigidbody != null)
|
|
{
|
|
prototype.hasRigidBody = true;
|
|
if (prototype.rigidbodyData == null)
|
|
prototype.rigidbodyData = new GPUInstancerPrefabPrototype.RigidbodyData();
|
|
prototype.rigidbodyData.useGravity = rigidbody.useGravity;
|
|
prototype.rigidbodyData.angularDrag = rigidbody.angularDrag;
|
|
prototype.rigidbodyData.mass = rigidbody.mass;
|
|
prototype.rigidbodyData.constraints = rigidbody.constraints;
|
|
prototype.rigidbodyData.drag = rigidbody.drag;
|
|
prototype.rigidbodyData.isKinematic = rigidbody.isKinematic;
|
|
prototype.rigidbodyData.interpolation = rigidbody.interpolation;
|
|
}
|
|
else
|
|
{
|
|
prototype.hasRigidBody = false;
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
EditorUtility.SetDirty(prototype);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void DrawRegisteredPrefabsBoxButtons()
|
|
{
|
|
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.registerPrefabsInScene, GPUInstancerEditorConstants.Colors.darkBlue, Color.white, FontStyle.Bold, Rect.zero,
|
|
() =>
|
|
{
|
|
Undo.RecordObject(_prefabManager, "Register prefabs in scene");
|
|
_prefabManager.RegisterPrefabsInScene();
|
|
#if UNITY_2018_1_OR_NEWER
|
|
SerializeAdditionalTransforms();
|
|
#endif
|
|
});
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_registerPrefabsInScene);
|
|
|
|
if (!Application.isPlaying && !GPUInstancerConstants.gpuiSettings.disableInstanceCountWarning)
|
|
{
|
|
bool hasLowInstanceCounts = false;
|
|
if (!Application.isPlaying && _prefabManager.registeredPrefabs.Count > 0)
|
|
{
|
|
foreach (RegisteredPrefabsData rpd in _prefabManager.registeredPrefabs)
|
|
{
|
|
int count = rpd.prefabPrototype.isTransformsSerialized ? rpd.prefabPrototype.serializedTransformDataCount : rpd.registeredPrefabs.Count;
|
|
if (count > 0 && count < 100)
|
|
hasLowInstanceCounts = true;
|
|
}
|
|
}
|
|
|
|
if (hasLowInstanceCounts)
|
|
{
|
|
GUILayout.Space(5);
|
|
EditorGUILayout.HelpBox(GPUInstancerEditorConstants.WARNINGTEXT_instanceCounts, MessageType.Warning);
|
|
DrawWikiButton(GUILayoutUtility.GetRect(40, 20), "GPU_Instancer:BestPractices", "#Instance_Counts", "More Information on Instance Counts", GPUInstancerEditorConstants.Colors.green);
|
|
GUILayout.Space(5);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void DrawRegisteredPrefabsBoxList()
|
|
{
|
|
if (!Application.isPlaying && _prefabManager.registeredPrefabs.Count > 0)
|
|
{
|
|
Color defaultColor = GPUInstancerEditorConstants.Styles.label.normal.textColor;
|
|
foreach (RegisteredPrefabsData rpd in _prefabManager.registeredPrefabs)
|
|
{
|
|
int count = rpd.prefabPrototype.isTransformsSerialized ? rpd.prefabPrototype.serializedTransformDataCount : rpd.registeredPrefabs.Count;
|
|
if (count > 0 && count < 100)
|
|
GPUInstancerEditorConstants.Styles.label.normal.textColor = Color.cyan;
|
|
else
|
|
GPUInstancerEditorConstants.Styles.label.normal.textColor = defaultColor;
|
|
if (prototypeSelection.ContainsKey(rpd.prefabPrototype))
|
|
prototypeSelection[rpd.prefabPrototype] = EditorGUILayout.ToggleLeft(rpd.prefabPrototype.ToString() + " Instance Count: " +
|
|
count, prototypeSelection[rpd.prefabPrototype], GPUInstancerEditorConstants.Styles.label);
|
|
}
|
|
|
|
GPUInstancerEditorConstants.Styles.label.normal.textColor = defaultColor;
|
|
}
|
|
else
|
|
{
|
|
base.DrawRegisteredPrefabsBoxList();
|
|
}
|
|
}
|
|
|
|
public override bool DrawGPUInstancerPrototypeInfo(List<GPUInstancerPrototype> selectedPrototypeList)
|
|
{
|
|
return DrawGPUInstancerPrototypeInfo(selectedPrototypeList, (string t) => { DrawHelpText(t); });
|
|
}
|
|
|
|
public static bool DrawGPUInstancerPrototypeInfo(List<GPUInstancerPrototype> selectedPrototypeList, UnityAction<string> DrawHelpText)
|
|
{
|
|
GPUInstancerPrefabPrototype prototype0 = (GPUInstancerPrefabPrototype)selectedPrototypeList[0];
|
|
#region Determine Multiple Values
|
|
bool hasChanged = false;
|
|
bool enableRuntimeModificationsMixed = false;
|
|
bool enableRuntimeModifications = prototype0.enableRuntimeModifications;
|
|
bool hasRigidBodyMixed = false;
|
|
bool hasRigidBody = prototype0.hasRigidBody;
|
|
bool autoUpdateTransformDataMixed = false;
|
|
bool autoUpdateTransformData = prototype0.autoUpdateTransformData;
|
|
bool startWithRigidBodyMixed = false;
|
|
bool startWithRigidBody = prototype0.startWithRigidBody;
|
|
bool addRemoveInstancesAtRuntimeMixed = false;
|
|
bool addRemoveInstancesAtRuntime = prototype0.addRemoveInstancesAtRuntime;
|
|
bool extraBufferSizeMixed = false;
|
|
int extraBufferSize = prototype0.extraBufferSize;
|
|
bool addRuntimeHandlerScriptMixed = false;
|
|
bool addRuntimeHandlerScript = prototype0.addRuntimeHandlerScript;
|
|
bool meshRenderersDisabledMixed = false;
|
|
bool meshRenderersDisabled = prototype0.meshRenderersDisabled;
|
|
for (int i = 1; i < selectedPrototypeList.Count; i++)
|
|
{
|
|
GPUInstancerPrefabPrototype prototypeI = (GPUInstancerPrefabPrototype)selectedPrototypeList[i];
|
|
if (!enableRuntimeModificationsMixed && enableRuntimeModifications != prototypeI.enableRuntimeModifications)
|
|
enableRuntimeModificationsMixed = true;
|
|
if (!hasRigidBodyMixed && hasRigidBody != prototypeI.hasRigidBody)
|
|
hasRigidBodyMixed = true;
|
|
if (!autoUpdateTransformDataMixed && autoUpdateTransformData != prototypeI.autoUpdateTransformData)
|
|
autoUpdateTransformDataMixed = true;
|
|
if (!startWithRigidBodyMixed && startWithRigidBody != prototypeI.startWithRigidBody)
|
|
startWithRigidBodyMixed = true;
|
|
if (!addRemoveInstancesAtRuntimeMixed && addRemoveInstancesAtRuntime != prototypeI.addRemoveInstancesAtRuntime)
|
|
addRemoveInstancesAtRuntimeMixed = true;
|
|
if (!extraBufferSizeMixed && extraBufferSize != prototypeI.extraBufferSize)
|
|
extraBufferSizeMixed = true;
|
|
if (!addRuntimeHandlerScriptMixed && addRuntimeHandlerScript != prototypeI.addRuntimeHandlerScript)
|
|
addRuntimeHandlerScriptMixed = true;
|
|
if (!meshRenderersDisabledMixed && meshRenderersDisabled != prototypeI.meshRenderersDisabled)
|
|
meshRenderersDisabledMixed = true;
|
|
}
|
|
#endregion Determine Multiple Values
|
|
|
|
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
|
|
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_prefabRuntimeSettings, GPUInstancerEditorConstants.Styles.boldLabel);
|
|
|
|
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_enableRuntimeModifications, enableRuntimeModifications, enableRuntimeModificationsMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).enableRuntimeModifications = v);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_enableRuntimeModifications);
|
|
|
|
EditorGUI.BeginDisabledGroup(enableRuntimeModificationsMixed || !enableRuntimeModifications);
|
|
|
|
EditorGUI.BeginDisabledGroup(hasRigidBodyMixed || !hasRigidBody || autoUpdateTransformDataMixed || autoUpdateTransformData);
|
|
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_startWithRigidBody, startWithRigidBody, startWithRigidBodyMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).startWithRigidBody = v);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_startWithRigidBody);
|
|
EditorGUI.EndDisabledGroup();
|
|
|
|
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_addRemoveInstancesAtRuntime, addRemoveInstancesAtRuntime, addRemoveInstancesAtRuntimeMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).addRemoveInstancesAtRuntime = v);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addRemoveInstancesAtRuntime);
|
|
|
|
EditorGUI.BeginDisabledGroup(addRemoveInstancesAtRuntimeMixed || !addRemoveInstancesAtRuntime);
|
|
hasChanged |= MultiIntSlider(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_extraBufferSize, extraBufferSize, 0, GPUInstancerConstants.gpuiSettings.MAX_PREFAB_EXTRA_BUFFER_SIZE, extraBufferSizeMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).extraBufferSize = v);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_extraBufferSize);
|
|
|
|
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_addRuntimeHandlerScript, addRuntimeHandlerScript, addRuntimeHandlerScriptMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).addRuntimeHandlerScript = v);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addRuntimeHandlerScript);
|
|
|
|
if (!addRemoveInstancesAtRuntimeMixed && addRemoveInstancesAtRuntime && !addRuntimeHandlerScriptMixed && !Application.isPlaying)
|
|
{
|
|
if (addRuntimeHandlerScript)
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in selectedPrototypeList)
|
|
{
|
|
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prefabPrototype.prefabObject.GetComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
if (prefabRuntimeHandler == null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.AddComponentToPrefab<GPUInstancerPrefabRuntimeHandler>(prefabPrototype.prefabObject);
|
|
#else
|
|
prefabPrototype.prefabObject.AddComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
#endif
|
|
EditorUtility.SetDirty(prefabPrototype.prefabObject);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in selectedPrototypeList)
|
|
{
|
|
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prefabPrototype.prefabObject.GetComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
if(prefabRuntimeHandler != null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.RemoveComponentFromPrefab<GPUInstancerPrefabRuntimeHandler>(prefabPrototype.prefabObject);
|
|
#else
|
|
DestroyImmediate(prefabRuntimeHandler, true);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
EditorGUI.EndDisabledGroup();
|
|
|
|
if(!meshRenderersDisabledMixed && !meshRenderersDisabled)
|
|
{
|
|
hasChanged |= MultiToggle(selectedPrototypeList, GPUInstancerEditorConstants.TEXT_autoUpdateTransformData, autoUpdateTransformData, autoUpdateTransformDataMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).autoUpdateTransformData = v);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_autoUpdateTransformData);
|
|
}
|
|
EditorGUI.EndDisabledGroup();
|
|
|
|
if (!enableRuntimeModificationsMixed && !enableRuntimeModifications)
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in selectedPrototypeList)
|
|
{
|
|
if (prefabPrototype.addRemoveInstancesAtRuntime)
|
|
prefabPrototype.addRemoveInstancesAtRuntime = false;
|
|
if (prefabPrototype.startWithRigidBody)
|
|
prefabPrototype.startWithRigidBody = false;
|
|
if (prefabPrototype.autoUpdateTransformData)
|
|
{
|
|
prefabPrototype.autoUpdateTransformData = false;
|
|
if (prefabPrototype.meshRenderersDisabled)
|
|
SetRenderersEnabled(prefabPrototype, !prefabPrototype.meshRenderersDisabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in selectedPrototypeList)
|
|
{
|
|
if ((!prefabPrototype.enableRuntimeModifications || !prefabPrototype.addRemoveInstancesAtRuntime) && prefabPrototype.extraBufferSize > 0)
|
|
prefabPrototype.extraBufferSize = 0;
|
|
|
|
if ((!prefabPrototype.enableRuntimeModifications || !prefabPrototype.addRemoveInstancesAtRuntime) && prefabPrototype.addRuntimeHandlerScript)
|
|
{
|
|
prefabPrototype.addRuntimeHandlerScript = false;
|
|
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prefabPrototype.prefabObject.GetComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
if (prefabRuntimeHandler != null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.RemoveComponentFromPrefab<GPUInstancerPrefabRuntimeHandler>(prefabPrototype.prefabObject);
|
|
#else
|
|
DestroyImmediate(prefabRuntimeHandler, true);
|
|
#endif
|
|
EditorUtility.SetDirty(prefabPrototype.prefabObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
|
|
return hasChanged;
|
|
}
|
|
|
|
public override void DrawGPUInstancerPrototypeInfo(GPUInstancerPrototype selectedPrototype)
|
|
{
|
|
DrawGPUInstancerPrototypeInfo(selectedPrototype, (string t) => { DrawHelpText(t); });
|
|
}
|
|
|
|
public static void DrawGPUInstancerPrototypeInfo(GPUInstancerPrototype selectedPrototype, UnityAction<string> DrawHelpText)
|
|
{
|
|
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
|
|
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_prefabRuntimeSettings, GPUInstancerEditorConstants.Styles.boldLabel);
|
|
|
|
GPUInstancerPrefabPrototype prototype = (GPUInstancerPrefabPrototype)selectedPrototype;
|
|
prototype.enableRuntimeModifications = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_enableRuntimeModifications, prototype.enableRuntimeModifications);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_enableRuntimeModifications);
|
|
|
|
EditorGUI.BeginDisabledGroup(!prototype.enableRuntimeModifications);
|
|
|
|
EditorGUI.BeginDisabledGroup(!prototype.hasRigidBody || prototype.autoUpdateTransformData);
|
|
prototype.startWithRigidBody = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_startWithRigidBody, prototype.startWithRigidBody);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_startWithRigidBody);
|
|
EditorGUI.EndDisabledGroup();
|
|
|
|
prototype.addRemoveInstancesAtRuntime = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_addRemoveInstancesAtRuntime, prototype.addRemoveInstancesAtRuntime);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addRemoveInstancesAtRuntime);
|
|
|
|
EditorGUI.BeginDisabledGroup(!prototype.addRemoveInstancesAtRuntime);
|
|
prototype.extraBufferSize = EditorGUILayout.IntSlider(GPUInstancerEditorConstants.TEXT_extraBufferSize, prototype.extraBufferSize, 0, GPUInstancerConstants.gpuiSettings.MAX_PREFAB_EXTRA_BUFFER_SIZE);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_extraBufferSize);
|
|
|
|
prototype.addRuntimeHandlerScript = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_addRuntimeHandlerScript, prototype.addRuntimeHandlerScript);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addRuntimeHandlerScript);
|
|
|
|
if (prototype.addRemoveInstancesAtRuntime && !Application.isPlaying)
|
|
{
|
|
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prototype.prefabObject.GetComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
if (prototype.addRuntimeHandlerScript && prefabRuntimeHandler == null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.AddComponentToPrefab<GPUInstancerPrefabRuntimeHandler>(prototype.prefabObject);
|
|
#else
|
|
prototype.prefabObject.AddComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
#endif
|
|
EditorUtility.SetDirty(prototype.prefabObject);
|
|
}
|
|
else if (!prototype.addRuntimeHandlerScript && prefabRuntimeHandler != null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.RemoveComponentFromPrefab<GPUInstancerPrefabRuntimeHandler>(prototype.prefabObject);
|
|
#else
|
|
DestroyImmediate(prefabRuntimeHandler, true);
|
|
#endif
|
|
EditorUtility.SetDirty(prototype.prefabObject);
|
|
}
|
|
}
|
|
EditorGUI.EndDisabledGroup();
|
|
|
|
bool autoUpdateTransformData = prototype.autoUpdateTransformData;
|
|
prototype.autoUpdateTransformData = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_autoUpdateTransformData, prototype.autoUpdateTransformData);
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_autoUpdateTransformData);
|
|
#if !GPUI_BURST
|
|
if (prototype.autoUpdateTransformData)
|
|
EditorGUILayout.HelpBox("It is recommended to use the Burst Compiler with Auto Update Transform Data feature. You can download it from the Package Manager Window.", MessageType.Warning);
|
|
#endif
|
|
if (autoUpdateTransformData != prototype.autoUpdateTransformData && prototype.meshRenderersDisabled)
|
|
SetRenderersEnabled(prototype, !prototype.meshRenderersDisabled);
|
|
EditorGUI.EndDisabledGroup();
|
|
|
|
if (!prototype.enableRuntimeModifications)
|
|
{
|
|
if (prototype.addRemoveInstancesAtRuntime)
|
|
prototype.addRemoveInstancesAtRuntime = false;
|
|
if (prototype.startWithRigidBody)
|
|
prototype.startWithRigidBody = false;
|
|
if (prototype.autoUpdateTransformData)
|
|
{
|
|
prototype.autoUpdateTransformData = false;
|
|
if (prototype.meshRenderersDisabled)
|
|
SetRenderersEnabled(prototype, !prototype.meshRenderersDisabled);
|
|
}
|
|
}
|
|
|
|
if ((!prototype.enableRuntimeModifications || !prototype.addRemoveInstancesAtRuntime) && prototype.extraBufferSize > 0)
|
|
prototype.extraBufferSize = 0;
|
|
|
|
if ((!prototype.enableRuntimeModifications || !prototype.addRemoveInstancesAtRuntime) && prototype.addRuntimeHandlerScript)
|
|
{
|
|
prototype.addRuntimeHandlerScript = false;
|
|
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prototype.prefabObject.GetComponent<GPUInstancerPrefabRuntimeHandler>();
|
|
if (prefabRuntimeHandler != null)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GPUInstancerUtility.RemoveComponentFromPrefab<GPUInstancerPrefabRuntimeHandler>(prototype.prefabObject);
|
|
#else
|
|
DestroyImmediate(prefabRuntimeHandler, true);
|
|
#endif
|
|
EditorUtility.SetDirty(prototype.prefabObject);
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
public override void DrawGPUInstancerPrototypeActions()
|
|
{
|
|
if (Application.isPlaying)
|
|
return;
|
|
GUILayout.Space(10);
|
|
//GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_actions, GPUInstancerEditorConstants.Styles.boldLabel, false);
|
|
|
|
DrawDeleteButton(false);
|
|
DrawDeleteButton(true);
|
|
}
|
|
|
|
public override void DrawGPUInstancerPrototypeAdvancedActions()
|
|
{
|
|
if (Application.isPlaying)
|
|
return;
|
|
|
|
GUILayout.Space(10);
|
|
|
|
EditorGUILayout.BeginVertical();
|
|
// title
|
|
Rect foldoutRect = GUILayoutUtility.GetRect(0, 20, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
|
|
foldoutRect.x += 12;
|
|
showAdvancedBox = EditorGUI.Foldout(foldoutRect, showAdvancedBox, GPUInstancerEditorConstants.TEXT_advancedActions, true, GPUInstancerEditorConstants.Styles.foldout);
|
|
|
|
//GUILayout.Space(10);
|
|
|
|
if (showAdvancedBox)
|
|
{
|
|
bool showSimulator = false;
|
|
foreach (GPUInstancerPrefabPrototype prototype in _prefabManager.prototypeList)
|
|
{
|
|
if (prototype == null)
|
|
continue;
|
|
|
|
if (prototype.isTransformsSerialized || prototype.meshRenderersDisabled)
|
|
showSimulator = true;
|
|
}
|
|
|
|
EditorGUILayout.HelpBox(GPUInstancerEditorConstants.HELPTEXT_advancedActions, MessageType.Warning);
|
|
|
|
if (_prefabManager.selectedPrototypeList != null && _prefabManager.selectedPrototypeList.Count > 0)
|
|
{
|
|
GPUInstancerPrefabPrototype prototype0 = (GPUInstancerPrefabPrototype)_prefabManager.selectedPrototypeList[0];
|
|
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in _prefabManager.selectedPrototypeList)
|
|
{
|
|
if (prefabPrototype.isTransformsSerialized && prefabPrototype.serializedTransformData == null)
|
|
{
|
|
prefabPrototype.isTransformsSerialized = false;
|
|
}
|
|
}
|
|
|
|
#region Determine Multiple Values
|
|
bool meshRenderersDisabledMixed = false;
|
|
bool meshRenderersDisabled = prototype0.meshRenderersDisabled;
|
|
//bool meshRenderersDisabledSimulationMixed = false;
|
|
//bool meshRenderersDisabledSimulation = prototype0.meshRenderersDisabledSimulation;
|
|
bool isTransformsSerializedMixed = false;
|
|
bool isTransformsSerialized = prototype0.isTransformsSerialized;
|
|
for (int i = 1; i < _prefabManager.selectedPrototypeList.Count; i++)
|
|
{
|
|
GPUInstancerPrefabPrototype prototypeI = (GPUInstancerPrefabPrototype)_prefabManager.selectedPrototypeList[i];
|
|
if (!meshRenderersDisabledMixed && meshRenderersDisabled != prototypeI.meshRenderersDisabled)
|
|
meshRenderersDisabledMixed = true;
|
|
if (!isTransformsSerializedMixed && isTransformsSerialized != prototypeI.isTransformsSerialized)
|
|
isTransformsSerializedMixed = true;
|
|
}
|
|
#endregion Determine Multiple Values
|
|
|
|
if (!meshRenderersDisabledMixed && meshRenderersDisabled)
|
|
{
|
|
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.enableMeshRenderers, GPUInstancerEditorConstants.Colors.green, Color.white, FontStyle.Bold, Rect.zero,
|
|
() =>
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in _prefabManager.selectedPrototypeList)
|
|
{
|
|
SetRenderersEnabled(prefabPrototype, true);
|
|
}
|
|
GUIUtility.ExitGUI();
|
|
});
|
|
//MultiToggle(_prefabManager.selectedPrototypeList, GPUInstancerEditorConstants.TEXT_disableMeshRenderersSimulation, meshRenderersDisabledSimulation, meshRenderersDisabledSimulationMixed, (p, v) => ((GPUInstancerPrefabPrototype)p).meshRenderersDisabledSimulation = v);
|
|
}
|
|
else if (!meshRenderersDisabledMixed && !meshRenderersDisabled)
|
|
{
|
|
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.disableMeshRenderers, GPUInstancerEditorConstants.Colors.lightBlue, Color.white, FontStyle.Bold, Rect.zero,
|
|
() =>
|
|
{
|
|
if (EditorUtility.DisplayDialog(GPUInstancerEditorConstants.TEXT_disableMeshRenderers, GPUInstancerEditorConstants.TEXT_disableMeshRenderersAreYouSure, "Yes", "No"))
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in _prefabManager.selectedPrototypeList)
|
|
{
|
|
SetRenderersEnabled(prefabPrototype, false);
|
|
}
|
|
}
|
|
GUIUtility.ExitGUI();
|
|
});
|
|
}
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_disableMeshRenderers);
|
|
|
|
#if UNITY_2018_1_OR_NEWER
|
|
if (!isTransformsSerializedMixed && isTransformsSerialized)
|
|
{
|
|
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.deserializeRegisteredInstances, GPUInstancerEditorConstants.Colors.green, Color.white, FontStyle.Bold, Rect.zero,
|
|
() =>
|
|
{
|
|
Undo.RecordObject(_prefabManager, "DeserializeTransforms");
|
|
EditorUtility.DisplayProgressBar(GPUInstancerEditorConstants.TEXT_prefabInstanceSerialization, "Deserializing instances...", 0.1f);
|
|
try
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in _prefabManager.selectedPrototypeList)
|
|
{
|
|
DeserializeTransforms(prefabPrototype);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError(e);
|
|
}
|
|
EditorUtility.ClearProgressBar();
|
|
GUIUtility.ExitGUI();
|
|
});
|
|
}
|
|
else if (!isTransformsSerializedMixed && !isTransformsSerialized)
|
|
{
|
|
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.serializeRegisteredInstances, GPUInstancerEditorConstants.Colors.lightBlue, Color.white, FontStyle.Bold, Rect.zero,
|
|
() =>
|
|
{
|
|
if (EditorUtility.DisplayDialog(GPUInstancerEditorConstants.TEXT_prefabInstanceSerialization, GPUInstancerEditorConstants.TEXT_prefabInstanceSerializationAreYouSure, GPUInstancerEditorConstants.TEXT_prefabInstanceSerializationYes, "No"))
|
|
{
|
|
Undo.RecordObject(_prefabManager, "SerializeTransforms");
|
|
EditorUtility.DisplayProgressBar(GPUInstancerEditorConstants.TEXT_prefabInstanceSerialization, "Serializing instances... This might take a while.", 0.1f);
|
|
try
|
|
{
|
|
foreach (GPUInstancerPrefabPrototype prefabPrototype in _prefabManager.selectedPrototypeList)
|
|
{
|
|
SerializeTransforms(prefabPrototype);
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Debug.LogError(e);
|
|
}
|
|
EditorUtility.ClearProgressBar();
|
|
GUIUtility.ExitGUI();
|
|
}
|
|
});
|
|
}
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_prefabInstanceSerialization);
|
|
#endif
|
|
|
|
if (showSimulator)
|
|
{
|
|
if (_prefabManager.gpuiSimulator != null)
|
|
{
|
|
if (_prefabManager.gpuiSimulator.simulateAtEditor)
|
|
{
|
|
if (_prefabManager.gpuiSimulator.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, () =>
|
|
{
|
|
_prefabManager.gpuiSimulator.StopSimulation();
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GPUInstancerEditorConstants.DrawColoredButton(new GUIContent("Simulate at Scene Camera [Experimental]"), GPUInstancerEditorConstants.Colors.green, Color.white,
|
|
FontStyle.Bold, Rect.zero, () =>
|
|
{
|
|
_prefabManager.gpuiSimulator.StartSimulation();
|
|
});
|
|
}
|
|
}
|
|
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_simulator);
|
|
}
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
public override float GetMaxDistance(GPUInstancerPrototype selectedPrototype)
|
|
{
|
|
return GPUInstancerConstants.gpuiSettings.MAX_PREFAB_DISTANCE;
|
|
}
|
|
}
|
|
} |