public static void DrawToggleField(FieldInfo _field, DIVisualComponent comp)
{
#if UNITY_EDITOR
bool result = EditorGUILayout.Toggle(_field.Name, (bool)_field.GetValue(comp));
_field.SetValue(comp, result);
#endif
}
public override void PropertyDrawer(FieldInfo field, DIVisualComponent comp)
{
base.PropertyDrawer(field, comp);
GetString _string = field.GetValue(comp) as GetString;
DrawGetString(_string);
}
public static void DrawEnumPopup(FieldInfo _field, DIVisualComponent comp)
{
#if UNITY_EDITOR
var result = EditorGUILayout.EnumPopup(_field.Name, (System.Enum)_field.GetValue(comp));
_field.SetValue(comp, result);
#endif
}
public static void DrawObjectField(FieldInfo _field, DIVisualComponent comp)
{
#if UNITY_EDITOR
UnityEngine.Object result = EditorGUILayout.ObjectField(_field.Name, (UnityEngine.Object)_field.GetValue(comp), _field.FieldType, true) as UnityEngine.Object;
_field.SetValue(comp, result);
#endif
}
public override void PropertyDrawer(FieldInfo field, DIVisualComponent comp)
{
EditorGUILayout.LabelField(field.Name, EditorStyles.boldLabel);
GetVariableBase _base = field.GetValue(comp) as GetVariableBase;
DrawBaseVariable(_base);
}
public static void DrawStringField(FieldInfo _field, DIVisualComponent comp)
{
#if UNITY_EDITOR
string result = EditorGUILayout.TextField(_field.Name, (string)_field.GetValue(comp));
_field.SetValue(comp, result);
#endif
}
public static void DrawFloatField(FieldInfo _field, DIVisualComponent comp)
{
#if UNITY_EDITOR
float result = EditorGUILayout.FloatField(_field.Name, (float)_field.GetValue(comp));
_field.SetValue(comp, result);
#endif
}
public static void DrawConnectLine(this DIVisualComponent self, float percentageFromLeft, DIVisualComponent nextComponent)
{
#if UNITY_EDITOR
Vector2 fromPos = self.position.position + Vector2.right * self.position.width * percentageFromLeft + Vector2.up * self.position.height;
Vector2 toPos = nextComponent.position.position + Vector2.right * nextComponent.position.width / 2;
if (DIVisualScriptingData.bezierLine)
{
UnityEditor.Handles.DrawBezier(fromPos, toPos, fromPos + Vector2.up * 50, toPos + Vector2.down * 50, Color.black, null, 2);
}
else
{
int midLine = (int)((toPos.y - fromPos.y) / 2);
if (midLine < 0)
{
midLine = 20;
}
Vector2 midPoint = fromPos + Vector2.up * midLine;
Color _color = Handles.color;
Handles.color = Color.black;
Handles.DrawAAPolyLine(2, new Vector3[4] {
fromPos, midPoint, new Vector2(toPos.x, midPoint.y), toPos
});
Handles.color = _color;
}
UnityEditor.Handles.Label(fromPos - Vector2.right * 7, UnityEditor.EditorGUIUtility.Load("radio on") as Texture);
UnityEditor.Handles.Label(toPos - Vector2.right * 7 + Vector2.down * 12, UnityEditor.EditorGUIUtility.Load("radio on") as Texture);
#endif
}
public static void DrawIntField(FieldInfo _fieldInt, DIVisualComponent comp)
{
#if UNITY_EDITOR
int result = EditorGUILayout.IntField(_fieldInt.Name, (int)_fieldInt.GetValue(comp));
_fieldInt.SetValue(comp, result);
#endif
}
public static void DrawGameObjectField(FieldInfo _field, DIVisualComponent comp)
{
#if UNITY_EDITOR
GameObject result = EditorGUILayout.ObjectField(_field.Name, (GameObject)_field.GetValue(comp), typeof(GameObject), true) as GameObject;
_field.SetValue(comp, result);
#endif
}
/// <summary>
/// Save current component
/// </summary>
/// <param name="self"></param>
/// <param name="rootParent">null for saving, not null for export</param>
/// <param name="previous">previous comp</param>
/// <param name="autoAssignNextComponentOfPrevious">jadi result.previous.next akan diassign otomatis, jika component hasil dari percabangan (ex : branch, if) atur ke false untuk menonaktifkan automatisasi</param>
public static DIVisualComponent _SaveComponent(this DIVisualComponent self, UnityEngine.Object rootParent, DIVisualComponent previous, bool autoAssignNextComponentOfPrevious = true)
{
#if UNITY_EDITOR
string debug = "";
self.name = string.IsNullOrEmpty(self.windowName) ? self.GetType().ToString() : self.windowName;
self.name += " - " + DIVisualScriptingData.inspectRootField.Name;
DIVisualComponent result = null;
//export
if (rootParent != null)
{
debug += "Export ";
result = Object.Instantiate(self);
result.previous = previous;
if (autoAssignNextComponentOfPrevious)
{
result.previous.next = result;
}
result.name = self.name;
AssetDatabase.AddObjectToAsset(result, rootParent);
debug += " - New";
}
//Save to scene
else
{
if (UnityEditor.AssetDatabase.IsSubAsset(self) || UnityEditor.AssetDatabase.IsMainAsset(self))
{
result = Object.Instantiate(self);
result.name = self.name;
result.next = self.next;
if (previous != null)
{
result.previous = previous;
if (autoAssignNextComponentOfPrevious)
{
result.previous.next = result;
}
}
result.position = self.position;
}
else
{
result = self;
}
debug += "Saved";
}
debug += " - " + self.name;
#if DI_DEBUG
Debug.Log(debug);
#endif
if (result.next != null)
{
result.next.SaveComponent(rootParent, result);
}
return(result);
#endif
}
public static void DrawField(FieldInfo _fieldInfo, DIVisualComponent comp, bool ignoreNotSupportedType)
{
#if UNITY_EDITOR
if (_fieldInfo.FieldType == typeof(int))
{
DrawIntField(_fieldInfo, comp);
}
else if (_fieldInfo.FieldType == typeof(float))
{
DrawFloatField(_fieldInfo, comp);
}
else if (_fieldInfo.FieldType == typeof(string))
{
DrawStringField(_fieldInfo, comp);
}
else if (_fieldInfo.FieldType == typeof(bool))
{
DrawToggleField(_fieldInfo, comp);
}
else if (_fieldInfo.FieldType.BaseType == typeof(System.Enum))
{
DrawEnumPopup(_fieldInfo, comp);
}
else if (_fieldInfo.FieldType == typeof(GameObject))
{
DrawGameObjectField(_fieldInfo, comp);
}
else if (_fieldInfo.FieldType.IsSubclassOf(typeof(UnityEngine.Object)))
{
DrawObjectField(_fieldInfo, comp);
}
/* TODO : Array or List Property Drawer
* else if (typeof(IList).IsAssignableFrom(_fieldInfo.FieldType)) {
* EditorGUILayout.HelpBox("Array are not supported", MessageType.Warning);
* DrawList(_fieldInfo, comp);
* }
*/
else
{
bool founded = false;
foreach (DIAttributeData.VSCustomPropertyDrawerAttributeData att in DIAttributeData.Instance.propertyDrawers)
{
if (_fieldInfo.FieldType == att.att.type)
{
att.type.GetMethod("PropertyDrawer").Invoke(att.instance, new object[2] {
_fieldInfo, comp
});
founded = true;
}
}
if (!founded && !ignoreNotSupportedType)
{
EditorGUILayout.HelpBox(_fieldInfo.FieldType + " : are not supported", MessageType.Warning);
}
}
#endif
}
DIVisualComponent AddBranch()
{
DIVisualComponent comp = (DIVisualComponent.CreateInstance <DIVisualComponent>());
comp.previous = this;
comp.position = position;
comp.position.position += Vector2.up * (position.height + 45);
return(comp);
}
void RemoveBranch(int index)
{
DIVisualComponent removedComp = splitedComponent[index];
if (removedComp != null)
{
removedComp.FindChildAndDestroy();
}
splitedComponent.RemoveAt(index);
}
void RemoveBranch()
{
DIVisualComponent removedComp = splitedComponent[splitedComponent.Count - 1];
if (removedComp != null)
{
removedComp.FindChildAndDestroy();
}
splitedComponent.RemoveAt(splitedComponent.Count - 1);
}
/// <summary>
/// Change the current component without delete existing
/// </summary>
public void changeThisComponent(DIVisualComponent withThis)
{
withThis.position = position;
//Set next Component neighbor
if (next != null)
{
withThis.next = next;
next.previous = withThis;
}
//if previous not null, set the previous component next to new component
if (previous != null)
{
withThis.previous = previous;
if (previous.next == this)
{
previous.next = withThis;
}
else
{
//use refelection to get real field name, because on previous component not always connected to next, like DICompare, can connected to true event
foreach (FieldInfo info in previous.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
{
//looping with fieldinfo of previous component
//if fieldInfo is DIVisualComponent
if (info.FieldType == typeof(DIVisualComponent) || info.FieldType.IsSubclassOf(typeof(DIVisualComponent)))
{
//Cast as DIVC
DIVisualComponent target = info.GetValue(previous) as DIVisualComponent;
//Check if target is same with this component
if (target == this)
{
//true means FieldInfo connected with this
//so we need to set the field info with the newComp
info.SetValue(previous, withThis);
break;
}
}
else if (info.FieldType == typeof(List <DIVisualComponent>))
{
List <DIVisualComponent> comps = info.GetValue(previous) as List <DIVisualComponent>;
for (int i = 0; i < comps.Count; i++)
{
if (comps[i] == this)
{
comps[i] = withThis;
break;
}
}
}
}
}
}
}
void ComponentTypePopup()
{
_tempReplaceComp = this.ComponentChooser();
if (_tempReplaceComp != null)
{
if (_tempReplaceComp.GetType() != GetType())
{
DIVisualScriptingData.atTheEnd += changeThisComponentWithDestroy;
}
}
}
public static DIVisualComponent ComponentChooser(this DIVisualComponent self)
{
#if UNITY_EDITOR
int i = EditorGUILayout.Popup(0, DIAttributeData.Instance.componentPathPopup.ToArray());
if (i != 0)
{
DIVisualComponent next = ScriptableObject.CreateInstance(DIAttributeData.Instance.componentsWithAttribute[i - 1]) as DIVisualComponent;
return(next);
}
#endif
return(null);
}
public override DIVisualComponent SaveComponent(Object rootParent, DIVisualComponent previous, bool autoAssignNextComponentOfPrevious = true)
{
FloatCompare result = base.SaveComponent(rootParent, previous, autoAssignNextComponentOfPrevious) as FloatCompare;
if (trueEvent != null)
{
result.trueEvent = trueEvent.SaveComponent(rootParent, result, false);
}
if (falseEvent != null)
{
result.falseEvent = falseEvent.SaveComponent(rootParent, result, false);
}
return(result);
}
/// <summary>
/// Create button to connect other Visual Component
/// </summary>
/// <param name="comp">Component will be connected as child, null to make creation mode, not null to insert mode</param>
/// <param name="nextStr">Next button name</param>
/// <param name="insertStr">Insert button name</param>
protected void ConnectButtonFunc(ref DIVisualComponent comp, string nextStr, string insertStr, GUIStyle style = null)
{
if (style == null)
{
style = new GUIStyle(GUI.skin.button);
}
if (comp == null)
{
if (GUILayout.Button(nextStr, style))
{
//DIVisualScriptingWindow.Window.inspectTarget.start.components.Add(DIVisualComponent.CreateInstance<DIVisualComponent>());
comp = (DIVisualComponent.CreateInstance <DIVisualComponent>());
comp.previous = this;
comp.position = position;
comp.position.position += Vector2.up * (position.height + 45);
}
}
else
{
if (GUILayout.Button(insertStr, style))
{
//DIVisualScriptingWindow.Window.inspectTarget.start.components.Add(DIVisualComponent.CreateInstance<DIVisualComponent>());
DIVisualComponent _backupNext = comp;
comp = (DIVisualComponent.CreateInstance <DIVisualComponent>());
comp.previous = this;
comp.position = position;
comp.position.position += Vector2.up * (position.height + 45);
comp.next = _backupNext;
comp.next.previous = comp;
if (_backupNext.position.y == comp.position.y)
{
_backupNext.position.y += 40;
}
}
}
}
public override DIVisualComponent SaveComponent(UnityEngine.Object rootParent, DIVisualComponent previous = null, bool autoAssignNextComponentOfPrevious = true)
{
DIBranch _branch = base.SaveComponent(rootParent, previous, autoAssignNextComponentOfPrevious) as DIBranch;
for (int i = 0; i < splitedComponent.Count; i++)
{
if (splitedComponent[i] != null)
{
//splitedComponent[i].SaveComponent(rootParent, this);
_branch.splitedComponent[i] = splitedComponent[i].SaveComponent(rootParent, _branch, false);
}
else
{
RemoveBranch(i);
}
}
return(_branch);
}
public override void PropertyDrawer(FieldInfo field, DIVisualComponent comp)
{
base.PropertyDrawer(field, comp);
GetInt _int = field.GetValue(comp) as GetInt;
if (_int.getFrom != GetFrom.Exact)
{
if (_int.targetObj == null)
{
return;
}
var fieldInfos = _int.targetObj.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance).ToList();
for (int i = 0; i < fieldInfos.Count; i++)
{
if (fieldInfos[i].FieldType == typeof(int) || fieldInfos[i].FieldType == typeof(DIVariableInt) ||
(typeof(IList).IsAssignableFrom(fieldInfos[i].FieldType) &&
(fieldInfos[i].FieldType == typeof(int[]) || fieldInfos[i].FieldType == typeof(DIVariableInt[]) ||
(fieldInfos[i].FieldType == typeof(List <int>) || fieldInfos[i].FieldType == typeof(List <DIVariableInt>))
)))
{
//DO NOTHING
}
else
{
fieldInfos.RemoveAt(i);
i -= 1;
}
}
var fieldInfoName = fieldInfos.Select(i => i.Name).ToList();
if (fieldInfoName.Count == 0)
{
fieldInfoName.Add("");
}
int fieldIdx = fieldInfoName.IndexOf(_int.fieldName);
if (fieldIdx < 0)
{
fieldIdx = 0;
}
fieldIdx = EditorGUILayout.Popup("Field", fieldIdx, fieldInfoName.ToArray());
_int.fieldName = fieldInfoName[fieldIdx];
if (fieldInfos.Count == 0)
{
return;
}
if (typeof(IList).IsAssignableFrom(fieldInfos[fieldIdx].FieldType))
{
if (_int.indexArray > ((IList)fieldInfos[fieldIdx].GetValue(_int.targetObj)).Count)
{
_int.indexArray = ((IList)fieldInfos[fieldIdx].GetValue(_int.targetObj)).Count - 1;
}
List <string> fieldArrayNames = new List <string>();
var fieldArray = ((IList)fieldInfos[fieldIdx].GetValue(_int.targetObj));
//If regular, just show index
if (fieldInfos[fieldIdx].FieldType == typeof(int[]) || (fieldInfos[fieldIdx].FieldType == typeof(List <int>)))
{
for (int i = 0; i < fieldArray.Count; i++)
{
fieldArrayNames.Add("Index - " + i.ToString());
}
if (fieldArrayNames.Count == 0)
{
fieldArrayNames.Add("");
}
_int.indexArray = EditorGUILayout.Popup("Index", _int.indexArray, fieldArrayNames.ToArray());
}
//if DIVar show varname
else if (fieldInfos[fieldIdx].FieldType == typeof(DIVariableInt[]) || fieldInfos[fieldIdx].FieldType == typeof(List <DIVariableInt>))
{
for (int i = 0; i < fieldArray.Count; i++)
{
fieldArrayNames.Add(((DIVariableInt)fieldArray[i]).varName);
}
if (fieldArrayNames.Count == 0)
{
fieldArrayNames.Add("");
}
_int.indexArray = EditorGUILayout.Popup("Index", _int.indexArray, fieldArrayNames.ToArray());
}
}
else
{
_int.indexArray = -1;
}
}
//Exact value
else
{
_int.exactValue = EditorGUILayout.IntField("Value", _int.exactValue);
}
}
public override void PropertyDrawer(FieldInfo field, DIVisualComponent comp)
{
GetMethod _method = field.GetValue(comp) as GetMethod;
//shifting to left
_method.bindingFlags = (BindingFlags)((int)_method.bindingFlags << 1);
_method.bindingFlags = (System.Reflection.BindingFlags)EditorGUILayout.MaskField(new GUIContent("Binding Flags"), (int)_method.bindingFlags, System.Enum.GetNames(typeof(BindingFlags)));
//shifting to right, to the right value
_method.bindingFlags = (BindingFlags)((int)_method.bindingFlags >> 1);
GameObject oldGo = _method.target;
_method.target = EditorGUILayout.ObjectField("Target", _method.target, typeof(GameObject), true) as GameObject;
if (oldGo != _method.target)
{
_method.monoscript = null;
}
if (_method.target != null)
{
//Draw Monobehaviour
var monoBehaviours = _method.target.GetComponents <MonoBehaviour>().ToList();
List <string> monoBehaviourNames = new List <string>();
for (int i = 0; i < monoBehaviours.Count; i++)
{
monoBehaviourNames.Add("(" + i.ToString() + ")" + monoBehaviours[i].ToString().Replace(_method.target.name, ""));
}
int monoscriptIdx = monoBehaviours.IndexOf(_method.monoscript);
if (monoscriptIdx < 0)
{
monoscriptIdx = 0;
}
if (monoBehaviourNames.Count == 0)
{
monoBehaviourNames.Add("");
}
monoscriptIdx = EditorGUILayout.Popup("Script", monoscriptIdx, monoBehaviourNames.ToArray());
if (monoBehaviours.Count != 0)
{
_method.monoscript = monoBehaviours[monoscriptIdx];
}
}
if (_method.monoscript != null)
{
//draw method
var methodNames = _method.monoscript.GetType().GetMethods(_method.bindingFlags).Select(i => i.Name).ToList();
int methodIdx = methodNames.IndexOf(_method.methodName);
if (methodIdx == -1)
{
methodIdx = 0;
}
if (methodNames.Count == 0)
{
methodNames.Add("");
}
methodIdx = EditorGUILayout.Popup("Method", methodIdx, methodNames.ToArray());
_method.methodName = methodNames[methodIdx];
}
field.SetValue(comp, _method);
}
public override DIVisualComponent SaveComponent(Object rootParent, DIVisualComponent previous = null, bool autoAssignNextComponentOfPrevious = true)
{
return(base.SaveComponent(rootParent, previous, autoAssignNextComponentOfPrevious));
}
void DoubleClickGenerateRoot()
{
if (Event.current.clickCount >= 2)
{
DIVisualScriptingData.inspectRootField.SetValue(DIVisualScriptingData.inspectTarget, DIVisualComponent.CreateInstance <DIRootComponent>() as DIRootComponent);
inspectRoot.position.position = Event.current.mousePosition;
}
}
public virtual void PropertyDrawer(FieldInfo field, DIVisualComponent comp)
{
}
/// <summary>
/// Function to show component window
/// </summary>
/// <param name="component"></param>
public static void ShowWindow(this DIVisualComponent component)
{
#if UNITY_EDITOR
UnityEditor.EditorGUI.BeginChangeCheck();
UnityEditor.Undo.RecordObject(component, "Undo Visual Scripting");
DIVisualScriptingData.currentWindowControl += 1;
//Draw Window
if (!component.isRemoveAction)
{
component.position = GUILayout.Window(DIVisualScriptingData.currentWindowControl, component.position, component.BuildWindow, component.windowName, GUILayout.Width(200), GUILayout.Height(20));
}
else
{
component.position = GUILayout.Window(DIVisualScriptingData.currentWindowControl, component.position, component.RemoveAction, component.windowName, GUILayout.Width(200), GUILayout.Height(20));
}
//normalize the value, because window only accept pixel, floating number will blur the content
component.position = new Rect((int)component.position.x, (int)component.position.y, (int)component.position.width, (int)component.position.height);
if (AssetDatabase.IsMainAsset((UnityEngine.Object)(DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget)))
||
AssetDatabase.IsSubAsset((UnityEngine.Object)(DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget))))
{
GUI.Box(new Rect(component.position.x - 4, component.position.y - 4, component.position.width + 8, component.position.height + 8), MakeTexture((int)component.position.width + 8, (int)component.position.height + 8, Color.red), GUIStyle.none);
}
#region DEPRECATED
/* Draw Box when new component Added
* if (!Application.isPlaying && (DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget) as DIRootComponent).saveState != DIRootComponent.SaveState.Scene)
* {
* //If not subasset,
* if (!AssetDatabase.IsSubAsset(component) &&
* //and the inspectorRoot is sub asset, means this asset is child of prefab
* (AssetDatabase.IsSubAsset((DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget) as DIRootComponent))
* //or if not main asset, that means prefab too
|| AssetDatabase.IsMainAsset((DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget) as DIRootComponent)))
|| )
|| {
|| //check again if inspectRoot doesn't have next and inspectRoot is Main Asset
|| if (AssetDatabase.IsMainAsset((DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget) as DIRootComponent)) && (DIVisualScriptingData.inspectRootField.GetValue(DIVisualScriptingData.inspectTarget) as DIRootComponent) == component && component.next == null)
|| {
|| //Do not draw anything
|| }
|| else
|| //then mark it with box, so we now if this component not saved yet
|| GUI.Box(new Rect(component.position.x - 4, component.position.y - 4, component.position.width + 8, component.position.height + 8), MakeTexture((int)component.position.width + 8, (int)component.position.height + 8, Color.red), GUIStyle.none);
|| }
||}*/
#endregion
/* TO DO : Debugging window when application.isplaying
* else if (isRunning) {
* //Draw blue rect for indicating current component is running
* GUI.Box(new Rect(_comp.position.x - 4, _comp.position.y - 4, _comp.position.width + 8, _comp.position.height + 8), DI.DIEditorHelper.MakeTexture((int)_comp.position.width + 8, (int)_comp.position.height + 8, Color.blue), GUIStyle.none);
* }*/
//Create side button
Rect removeBtnRect = new Rect(component.position.x + component.position.width, component.position.y, 15, 15);
if (GUI.Button(removeBtnRect, DIVisualScriptingData.removeTex, GUIStyle.none))
{
//Show Popup yes or no
component.isRemoveAction = true;
}
Rect minimizeBtnRect = new Rect(component.position.x - 15, component.position.y, 15, 15);
if (GUI.Button(minimizeBtnRect, component.isMinimize ? DIVisualScriptingData.maximizeTex : DIVisualScriptingData.minimizeTex, GUIStyle.none))
{
//Show Popup yes or no
component.isMinimize = !component.isMinimize;
}
//Show next window
if (component.next != null)
{
component.next.ShowWindow();
}
//function can be overriding to draw custom things
component.LateShowWindow();
if (UnityEditor.EditorGUI.EndChangeCheck())
{
UnityEditor.EditorUtility.SetDirty(component);
}
#endif
}
//TO DO : Supported List / array
/*
* public static void DrawList(FieldInfo _field, DIVisualComponent comp)
* {
#if UNITY_EDITOR
* EditorGUILayout.LabelField(_field.Name, EditorStyles.boldLabel);
* var list = ((IList)_field.GetValue(comp));
* EGLBeginHorizontal();
* GUI.enabled = false;
* EditorGUILayout.IntField("Size", list.Count);
* GUI.enabled = true;
* if (GUILayout.Button("+"))
* list.Add(null);
* if (GUILayout.Button("-"))
* list.RemoveAt(list.Count - 1);
* EGLEndHorizontal();
* System.Type type = null;
* for (int i = 0; i < list.Count; i++) {
* if (type == null)
* type = list[i].GetType();
* if (type == typeof(int))
* DrawIntField(i.ToString(), (int)list[i]);
* else if (type == typeof(float))
* DrawFloatField(i.ToString(), (float)list[i]);
* else if (type == typeof(string))
* DrawStringField(i.ToString(), (string)list[i]);
* else if (type == typeof(bool))
* DrawToggleField(i.ToString(), (bool)list[i]);
* else if (type == typeof(System.Enum))
* DrawEnumPopup(i.ToString(), (System.Enum)list[i]);
* else if (type == typeof(GameObject))
* DrawGameObjectField(i.ToString(), (GameObject)list[i]);
* else if (type == typeof(Object))
* DrawObjectField(i.ToString(), (Object)list[i]);
* else {
* EditorGUILayout.HelpBox("Type : " + type.ToString() + " not Supported!", MessageType.Warning);
* }
* }
#endif
* }
*
* public static int DrawIntField(string label, int value)
* {
#if UNITY_EDITOR
* return EditorGUILayout.IntField(label, value);
#endif
* }
* public static string DrawStringField(string label, string value)
* {
#if UNITY_EDITOR
* return EditorGUILayout.TextField(label, value);
#endif
* }
* public static float DrawFloatField(string label, float value)
* {
#if UNITY_EDITOR
* return EditorGUILayout.FloatField(label, value);
#endif
* }
* public static System.Enum DrawEnumPopup(string label, System.Enum selected)
* {
#if UNITY_EDITOR
* return EditorGUILayout.EnumPopup(label, selected);
#endif
* }
* public static bool DrawToggleField(string label, bool value)
* {
#if UNITY_EDITOR
* return EditorGUILayout.Toggle(label, value);
#endif
* }
* public static GameObject DrawGameObjectField(string label, GameObject value)
* {
#if UNITY_EDITOR
* return EditorGUILayout.ObjectField(label, value, typeof(GameObject), true) as GameObject;
#endif
* }
* public static Object DrawObjectField(string label, Object value)
* {
#if UNITY_EDITOR
* return EditorGUILayout.ObjectField(label, value, typeof(UnityEngine.Object), true) as UnityEngine.Object;
#endif
* }*/
public static FieldInfo[] GatherFieldInfos(DIVisualComponent comp)
{
return(comp.GetType().GetFields(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance));
}
/// <summary>
/// Save Component to disk or scene
/// </summary>
/// <param name="rootParent">Root, can be .asset / prefab / null</param>
/// <param name="previous">fill only if you want to duplicate mode</param>
/// <param name="autoAssignNextComponentOfPrevious">jadi result.previous.next akan diassign otomatis, jika component hasil dari percabangan (ex : branch, if) atur ke false untuk menonaktifkan automatisasi</param>
public virtual DIVisualComponent SaveComponent(UnityEngine.Object rootParent, DIVisualComponent previous, bool autoAssignNextComponentOfPrevious = true)
{
return(this._SaveComponent(rootParent, previous, autoAssignNextComponentOfPrevious));
}
