// REFERENCE A PROPERTY //
//
virtual public void ReferenceAProperty(BaseProperty property, BaseModule originalModule, BaseProperty originalProperty)
{
if (originalModule != null)
{
property.dataMode = BaseProperty.eDataMode.Reference;
property.reference = ScriptableObject.CreateInstance <PropertyReference>();
property.reference.Initialize(originalModule, originalProperty);
}
}
// COPY STACK //
//
public void CopyStack(BaseStack originalStack)
{
modules.Clear();
foreach (var item in originalStack.modules)
{
BaseModule m = ScriptableObject.CreateInstance(item.GetType()) as BaseModule;
m.Initialize(this, ownerBlueprint);
m.CopyProperties(item, ownerBlueprint);
modules.Add(m);
}
}
// MOVE DOWN SELECTED MODULE //
//
void MoveDownSelectedModule()
{
int selectedIndex = modules.FindIndex(delegate(BaseModule bm) { return(bm == selectedModule); });
if (selectedIndex != -1 && selectedIndex < modules.Count - 1)
{
BaseModule tempModule = modules[selectedIndex + 1];
modules[selectedIndex + 1] = selectedModule;
modules[selectedIndex] = tempModule;
}
ownerBlueprint.ownerEmitter.SoftReset();
}
// COPY PROPERTIES //
//
override public void CopyProperties(BaseModule originalModule, AmpsBlueprint theOwnerBlueprint)
{
base.CopyProperties(originalModule, theOwnerBlueprint);
MeshRenderModule om = originalModule as MeshRenderModule;
if (om != null)
{
//meshCount.CopyProperty(om.meshCount, theOwnerBlueprint);
inputMeshes = new MeshProperty[om.inputMeshes.Length];
for (int i = 0; i < om.inputMeshes.Length; i++)
{
inputMeshes[i] = ScriptableObject.CreateInstance <MeshProperty>();
inputMeshes[i].Initialize("Mesh " + i);
AddProperty(inputMeshes[i], false);
inputMeshes[i].CopyProperty(om.inputMeshes[i], theOwnerBlueprint);
}
}
}
// REFERENCE PROPERTIES //
//
virtual public void ReferenceProperties(BaseModule originalModule)
{
isEnabled = originalModule.isEnabled;
ownerBlueprint = originalModule.ownerBlueprint;
for (int i = 0; i < properties.Count; i++)
{
if (properties[i].allowDataModeReference)
{
ReferenceAProperty(properties[i], originalModule, originalModule.properties[i]);
}
//else properties[i].CopyProperty(originalModule.properties[i], ownerBlueprint);
}
//if (originalModule != null)
//{
// isEnabled = originalModule.isEnabled;
// moduleName.value = originalModule.moduleName.value + "(ref)";
// ownerBlueprint = originalModule.ownerBlueprint;
//}
}
// DUPLICATE SELECTED MODULE //
//
// Called from a GenericMenu in ShowModules().
public void DuplicateSelectedModule()
{
int selectedIndex = modules.FindIndex(delegate(BaseModule bm) { return(bm == selectedModule); });
if (ownerBlueprint.ownerEmitter.selectedStack.stackFunction == AmpsHelpers.eStackFunction.MultiFunction)
{
BaseMultiFunctionModule duplicateModule = ScriptableObject.CreateInstance(selectedModule.GetType()) as BaseMultiFunctionModule;
duplicateModule.Initialize(this, ownerBlueprint);
duplicateModule.CopyProperties(selectedModule);
modules.Insert(selectedIndex + 1, duplicateModule);
}
else
{
BaseModule duplicateModule = ScriptableObject.CreateInstance(selectedModule.GetType()) as BaseGenericModule;
duplicateModule.Initialize(this, ownerBlueprint);
duplicateModule.CopyProperties(selectedModule);
modules.Insert(selectedIndex + 1, duplicateModule);
}
selectedModule = modules[selectedIndex + 1];
ownerBlueprint.ownerEmitter.SoftReset();
}
// COPY PROPERTIES //
//
virtual public void CopyProperties(BaseModule originalModule, AmpsBlueprint theOwnerBlueprint)
{
name = type;
isEnabled = originalModule.isEnabled;
ownerStack = originalModule.ownerStack;
if (theOwnerBlueprint != null)
{
ownerBlueprint = theOwnerBlueprint;
}
else
{
ownerBlueprint = originalModule.ownerBlueprint;
}
properties.RemoveAll(item => item == null);
for (int i = 0; i < properties.Count; i++)
{
properties[i].CopyProperty(originalModule.properties[i], theOwnerBlueprint);
}
}
//============================================================================//
#region Module management
// DELETE MODULE FROM ASSET //
//
public void DeleteModuleFromAsset(BaseModule theModule)
{
for (int i = 0; i < theModule.properties.Count; i++)
{
if (theModule.properties[i].GetType() == typeof(ScalarProperty))
{
ScalarProperty sp = theModule.properties[i] as ScalarProperty;
UnityEngine.Object.DestroyImmediate(sp.curve, true);
UnityEngine.Object.DestroyImmediate(sp.curveMin, true);
UnityEngine.Object.DestroyImmediate(sp.curveMax, true);
}
if (theModule.properties[i].GetType() == typeof(VectorProperty))
{
VectorProperty vp = theModule.properties[i] as VectorProperty;
UnityEngine.Object.DestroyImmediate(vp.curve, true);
UnityEngine.Object.DestroyImmediate(vp.curveMin, true);
UnityEngine.Object.DestroyImmediate(vp.curveMax, true);
}
if (theModule.properties[i].GetType() == typeof(ColorProperty))
{
ColorProperty cp = theModule.properties[i] as ColorProperty;
UnityEngine.Object.DestroyImmediate(cp.curve, true);
UnityEngine.Object.DestroyImmediate(cp.curveMin, true);
UnityEngine.Object.DestroyImmediate(cp.curveMax, true);
}
if (string.IsNullOrEmpty(AssetDatabase.GetAssetPath(theModule.properties[i].reference)) == false)
{
UnityEngine.Object.DestroyImmediate(theModule.properties[i].reference, true);
}
UnityEngine.Object.DestroyImmediate(theModule.properties[i], true);
}
UnityEngine.Object.DestroyImmediate(theModule, true);
AssetDatabase.SaveAssets();
ownerBlueprint.ownerEmitter.SoftReset();
}
// REMOVE SELECTED MODULE //
//
// Called from a GenericMenu in ShowModules().
public void RemoveSelectedModule()
{
int selectedIndex = modules.FindIndex(delegate(BaseModule bm) { return(bm == selectedModule); });
DeleteModuleFromAsset(selectedModule);
selectedModule.Delete();
modules.Remove(selectedModule);
if (modules.Count > 0)
{
if (selectedIndex >= modules.Count)
{
selectedModule = modules[selectedIndex - 1];
}
else
{
selectedModule = modules[selectedIndex];
}
}
else
{
selectedModule = null;
}
ownerBlueprint.ownerEmitter.SoftReset();
}
public void Initialize(BaseModule m, BaseProperty p)
{
module = m;
property = p;
name = "PropertyReference";
}
// SHOW MODULE //
//
virtual public void ShowModule(ref BaseModule selectedModule, out AmpsHelpers.eModuleOperations operation)
{
GUIStyle actualStyle;
operation = AmpsHelpers.eModuleOperations.NoOperation;
if (selectedModule == this)
{
actualStyle = GUI.skin.GetStyle("moduleBoxSelected");
}
else
{
actualStyle = GUI.skin.GetStyle("moduleBoxNormal");
}
GUILayout.BeginVertical(actualStyle); //--------------------------------//
GUILayout.BeginHorizontal("moduleHeader"); //----------------//
isEnabled = GUILayout.Toggle(isEnabled, "", "toggle");
GUILayout.FlexibleSpace();
GUILayout.Label(type, "moduleName");
GUILayout.FlexibleSpace();
if (GUILayout.Button("", "optionButton"))
{
operation = AmpsHelpers.eModuleOperations.ShowOptions;
selectedModule = this;
}
GUILayout.EndHorizontal(); //----------------\\
GUILayout.BeginHorizontal(); //----------------//
GUILayout.BeginVertical(); //--------//
GUILayout.Space(8);
GUILayout.BeginHorizontal(); //----//
if (implementsVisualization)
{
isVisualizationEnabled = GUILayout.Toggle(isVisualizationEnabled, "", "visualizationToggle");
}
GUILayout.Label(moduleName.value, "moduleDescription");
GUILayout.EndHorizontal(); //----\\
GUILayout.EndVertical(); //--------\\
GUILayout.BeginVertical("moduleSidebar", GUILayout.Width(17)); //--------//
if (GUILayout.Button("", "moveUpButton"))
{
operation = AmpsHelpers.eModuleOperations.MoveUp;
selectedModule = this;
}
if (GUILayout.Button("", "moveDownButton"))
{
operation = AmpsHelpers.eModuleOperations.MoveDown;
selectedModule = this;
}
GUILayout.EndVertical(); //--------\\
GUILayout.EndHorizontal(); //----------------\\
GUILayout.EndVertical(); //--------------------------------\\
// Get the rectangle which was drawn last.
moduleRect = GUILayoutUtility.GetLastRect();
if (Event.current.type == EventType.MouseDown && moduleRect.Contains(Event.current.mousePosition))
{
shouldSelectThis = true;
}
if (Event.current.type == EventType.Layout && shouldSelectThis)
{
selectedModule = this;
shouldSelectThis = false;
}
}
// COPY PROPERTIES //
//
virtual public void CopyProperties(BaseModule originalModule)
{
CopyProperties(originalModule, null);
}
// SHOW MODULES //
//
public void ShowModules(out bool shouldRepaint)
{
shouldRepaint = false;
AmpsHelpers.eModuleOperations moduleOperation;
bool isInfoModulePresent = false; // A constantly updating info module makes debugging easier.
if (modules.Count > 0)
{
if (selectedModule == null)
{
selectedModule = modules[0]; // Deleting/replacing Blueprints can cause it to be null.
}
// We store current selection so we can tell if a module selected itself,
// in which case we need to repaint the UI.
BaseModule previousSelection = selectedModule;
foreach (BaseModule m in modules)
{
// We pass selectedModule so the module can switch draw styles if it recognizes
// itself, but can also change the selection to itself from inside.
// ModuleOperation is defined by which button the user clicked.
m.ShowModule(ref selectedModule, out moduleOperation);
switch (moduleOperation)
{
case AmpsHelpers.eModuleOperations.NoOperation:
break;
case AmpsHelpers.eModuleOperations.ShowOptions:
GenericMenu moduleOptionsMenu = new GenericMenu();
moduleOptionsMenu.AddItem(new GUIContent(AmpsHelpers.formatEnumString(AmpsHelpers.eModuleOperations.Duplicate.ToString())),
false,
DuplicateSelectedModule);
moduleOptionsMenu.AddSeparator("");
moduleOptionsMenu.AddItem(new GUIContent(AmpsHelpers.formatEnumString(AmpsHelpers.eModuleOperations.Remove.ToString())),
false,
RemoveSelectedModule);
moduleOptionsMenu.ShowAsContext();
break;
case AmpsHelpers.eModuleOperations.MoveUp:
MoveUpSelectedModule();
break;
case AmpsHelpers.eModuleOperations.MoveDown:
MoveDownSelectedModule();
break;
}
if (m.GetType() == typeof(InfoModule) && m.isEnabled)
{
isInfoModulePresent = true;
}
}
if (isInfoModulePresent)
{
shouldRepaint = true;
}
if (selectedModule != previousSelection)
{
shouldRepaint = true;
GUI.FocusControl(AmpsHelpers.stringControlName);
}
}
}
