// ======================================================================
// General Queries
// ----------------------------------------------------------------------
public static iCS_EngineObject[] GetChildPorts(iCS_IVisualScriptData vsd, iCS_EngineObject node)
{
List <iCS_EngineObject> childPorts = new List <iCS_EngineObject>();
FilterWith(p => p.IsPort && p.ParentId == node.InstanceId, childPorts.Add, vsd);
return(childPorts.ToArray());
}
// ======================================================================
// Connection Queries
// ----------------------------------------------------------------------
// Returns the immediate source of the port.
public static iCS_EngineObject GetProducerPort(iCS_IVisualScriptData vsd, iCS_EngineObject port)
{
if (port == null || port.SourceId == -1)
{
return(null);
}
return(vsd.EngineObjects[port.SourceId]);
}
// =======================================================================
// General Iterations
// -----------------------------------------------------------------------
// Executes for each valid engine object
public static void ForEach(Action <iCS_EngineObject> fnc, iCS_IVisualScriptData vsd)
{
P.forEach(o => { if (IsValid(o, vsd))
{
fnc(o);
}
}, vsd.EngineObjects);
}
// ----------------------------------------------------------------------
public static bool IsRelayPort(iCS_IVisualScriptData vsd, iCS_EngineObject port)
{
if (port == null)
{
return(false);
}
return(HasASource(vsd, port) && HasADestination(vsd, port));
}
// ----------------------------------------------------------------------
// Save the navigation state of the given IStorage.
public void SaveState(iCS_IVisualScriptData storage)
{
DisplayRoot = storage.DisplayRoot;
ShowDisplayRootNode = storage.ShowDisplayRootNode;
ScrollPosition = storage.ScrollPosition;
GuiScale = storage.GuiScale;
SelectedObject = storage.SelectedObject;
}
// ======================================================================
// Tree Navigation Queries
// ----------------------------------------------------------------------
public static iCS_EngineObject GetParent(iCS_IVisualScriptData vsd, iCS_EngineObject child)
{
if (child == null || child.ParentId == -1)
{
return(null);
}
return(vsd.EngineObjects[child.ParentId]);
}
// ----------------------------------------------------------------------
public static iCS_EngineObject GetParentNode(iCS_IVisualScriptData vsd, iCS_EngineObject child)
{
var parentNode = GetParent(vsd, child);
while (parentNode != null && !parentNode.IsNode)
{
parentNode = GetParent(vsd, parentNode);
}
return(parentNode);
}
// ----------------------------------------------------------------------
public static void CopyEditorDataFromTo(iCS_IVisualScriptData from, iCS_IVisualScriptData to)
{
to.ShowDisplayRootNode = from.ShowDisplayRootNode;
to.ScrollPosition = from.ScrollPosition;
to.GuiScale = from.GuiScale;
to.SelectedObject = from.SelectedObject;
to.SelectedObjectPosition = from.SelectedObjectPosition;
to.DisplayRoot = from.DisplayRoot;
// Copy navigation history
to.NavigationHistory.CopyFrom(from.NavigationHistory);
}
// ----------------------------------------------------------------------
// Reloads the navigation state of the given IStorage from the forward
// history.
public void ReloadFromForwardHistory(iCS_IVisualScriptData storage)
{
if (!HasForwardHistory)
{
return;
}
var backwardMemento = new iCS_NavigationMemento(storage);
myMementos[myCursor].RestoreState(storage);
myMementos[myCursor] = backwardMemento;
++myCursor;
}
// ----------------------------------------------------------------------
// Restores the navigation state into the given IStorage.
public void RestoreState(iCS_IVisualScriptData storage)
{
if (!iCS_VisualScriptData.IsValidEngineObject(storage, DisplayRoot))
{
return;
}
storage.ShowDisplayRootNode = ShowDisplayRootNode;
storage.ScrollPosition = ScrollPosition;
storage.GuiScale = GuiScale;
storage.DisplayRoot = DisplayRoot;
storage.SelectedObject = SelectedObject;
return;
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// VISUAL SCRIPT DATA UTILITY SECTION
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// ======================================================================
// Initialize / Destroy
// ----------------------------------------------------------------------
public static void DestroyEngineObject(iCS_IVisualScriptData vsd, iCS_EngineObject toDelete)
{
// -- Disconnect all connected ports --
if (toDelete.IsPort)
{
int id = toDelete.InstanceId;
if (id != -1)
{
FilterWith(o => o.IsPort && o.SourceId == id, p => p.SourceId = -1, vsd);
}
}
// -- Destroy the instance --
toDelete.DestroyInstance();
}
// ----------------------------------------------------------------------
public static void AddEngineObject(iCS_IVisualScriptData vsd, iCS_EngineObject toAdd)
{
// Try to find an available empty slot.
int emptySlot = P.findFirst(o => o.InstanceId == -1, (i, o) => i, -1, vsd.EngineObjects);
// Grow engine object array if no free slot exists.
if (emptySlot != -1)
{
toAdd.InstanceId = emptySlot;
vsd.EngineObjects[emptySlot] = toAdd;
return;
}
toAdd.InstanceId = P.length(vsd.EngineObjects);
vsd.EngineObjects.Add(toAdd);
}
// ----------------------------------------------------------------------
// Saves the navigation state of the given IStorage.
public void Save(iCS_IVisualScriptData storage)
{
// Erase previous forward history.
if (HasForwardHistory)
{
myMementos.RemoveRange(myCursor, myMementos.Count - myCursor);
}
// Save new memento.
myMementos.Add(new iCS_NavigationMemento(storage));
// Limit the size the the navigation history
if (myMementos.Count > kMaxHistory)
{
myMementos.RemoveRange(0, myMementos.Count - kMaxHistory);
}
myCursor = myMementos.Count;
}
// ----------------------------------------------------------------------
/// Returns the relative name of the object reference by the visual script.
public static string GetRelativeName(iCS_IVisualScriptData vsd, iCS_EngineObject obj)
{
if (obj == null)
{
return("");
}
string fullName = "";
for (; obj != null; obj = GetParentNode(vsd, obj))
{
if (!obj.IsBehaviour)
{
fullName = obj.RawName + (string.IsNullOrEmpty(fullName) ? "" : "/" + fullName);
}
}
return(fullName);
}
// ----------------------------------------------------------------------
public static void CopyDataFromTo(iCS_IVisualScriptData from, iCS_IVisualScriptData to)
{
to.IsEditorScript = from.IsEditorScript;
to.CSharpFileName = from.CSharpFileName;
to.BaseTypeOverride = from.BaseTypeOverride;
to.BaseType = from.BaseType;
to.SourceFileGUID = from.SourceFileGUID;
to.MajorVersion = from.MajorVersion;
to.MinorVersion = from.MinorVersion;
to.BugFixVersion = from.BugFixVersion;
to.UndoRedoId = from.UndoRedoId;
// Resize destination engine object array.
var fromEngineObjects = from.EngineObjects;
var toEngineObjects = to.EngineObjects;
int fromLen = fromEngineObjects.Count;
int toLen = toEngineObjects.Count;
if (toLen > fromLen)
{
toEngineObjects.RemoveRange(fromLen, toLen - fromLen);
}
toEngineObjects.Capacity = fromLen;
// Copy engine objects.
for (int i = 0; i < fromLen; ++i)
{
var fromObj = fromEngineObjects[i];
if (fromObj == null)
{
fromObj = iCS_EngineObject.CreateInvalidInstance();
}
if (toEngineObjects.Count <= i)
{
toEngineObjects.Add(fromObj.Clone());
}
else if (toEngineObjects[i] == null)
{
toEngineObjects[i] = fromObj.Clone();
}
else
{
toEngineObjects[i] = fromObj.CopyTo(toEngineObjects[i]);
}
}
}
// ----------------------------------------------------------------------
// Returns the list of consumer ports.
public static iCS_EngineObject[] GetConsumerPorts(iCS_IVisualScriptData vsd, iCS_EngineObject port)
{
if (port == null)
{
return(new iCS_EngineObject[0]);
}
var consumerPorts = new List <iCS_EngineObject>();
var engineObjects = vsd.EngineObjects;
foreach (var obj in engineObjects)
{
if (obj.IsPort && GetProducerPort(vsd, obj) == port)
{
consumerPorts.Add(obj);
}
}
return(consumerPorts.ToArray());
}
// ----------------------------------------------------------------------
// Returns the endport source of a connection.
public static iCS_EngineObject GetSegmentProducerPort(iCS_IVisualScriptData vsd, iCS_EngineObject port)
{
if (port == null || port.InstanceId == -1)
{
return(null);
}
int linkLength = 0;
for (iCS_EngineObject sourcePort = GetProducerPort(vsd, port); sourcePort != null; sourcePort = GetProducerPort(vsd, port))
{
port = sourcePort;
if (++linkLength > 100)
{
Debug.LogWarning("iCanScript: Circular port connection detected on: " + GetParentNode(vsd, port).RawName + "." + port.RawName);
return(null);
}
}
return(IsValid(port, vsd) ? port : null);
}
// ----------------------------------------------------------------------
public void CopyEditorDataTo(iCS_IVisualScriptData to)
{
CopyEditorDataFromTo(this, to);
}
// ======================================================================
// Queries
// ----------------------------------------------------------------------
public static bool IsValidEngineObject(iCS_IVisualScriptData vsd, int id)
{
var engineObjects = vsd.EngineObjects;
return(id >= 0 && id < engineObjects.Count && engineObjects[id].InstanceId != -1);
}
// ======================================================================
// Duplication Utilities
// ----------------------------------------------------------------------
public static void CopyFromTo(iCS_IVisualScriptData from, iCS_IVisualScriptData to)
{
CopyDataFromTo(from, to);
CopyEditorDataFromTo(from, to);
}
// ----------------------------------------------------------------------
public static bool HasADestination(iCS_IVisualScriptData vsd, iCS_EngineObject port)
{
return(P.length(GetConsumerPorts(vsd, port)) != 0);
}
// ----------------------------------------------------------------------
public static bool HasASource(iCS_IVisualScriptData vsd, iCS_EngineObject port)
{
var source = GetProducerPort(vsd, port);
return(source != null && source != port);
}
// =======================================================================
// Simple Queries
// -----------------------------------------------------------------------
// Returns 'true' if the given engine object is valid.
public static bool IsValid(iCS_EngineObject obj, iCS_IVisualScriptData vsd)
{
int id = obj.InstanceId;
return(id >= 0 && id < vsd.EngineObjects.Count);
}
// -----------------------------------------------------------------------
// Invokes the given action if the given condition has passed the test.
public static void FilterWith(Func <iCS_EngineObject, bool> cond, Action <iCS_EngineObject> action, iCS_IVisualScriptData vsd)
{
ForEach(o => { if (cond(o))
{
action(o);
}
}, vsd);
}
// ----------------------------------------------------------------------
/// Returns the full name of the object including the name of the game object.
public static string GetFullName(iCS_IVisualScriptData vsd, UnityEngine.Object host, iCS_EngineObject obj)
{
return("/" + host.name + "/" + GetRelativeName(vsd, obj));
}
public iCS_VisualScriptData(/*UnityEngine.Object host, */ iCS_IVisualScriptData vsd)
{
// HostObject= host;
iCS_VisualScriptData.CopyFromTo(vsd, this);
}
// ======================================================================
// Duplication Utilities
// ----------------------------------------------------------------------
public void CopyTo(iCS_IVisualScriptData to)
{
CopyFromTo(this, to);
}
// ======================================================================
// Respond to Unity drag & drop protocol.
// ----------------------------------------------------------------------
// TODO: Need to revise valid drop node.
void DragAndDropUpdated()
{
iCS_EditorObject objectUnderMouse = GetObjectAtMousePosition();
if (objectUnderMouse != null)
{
UnityEngine.Object draggedObject = GetDraggedObject();
if (objectUnderMouse.IsInputPort)
{
if (GetValidDragAndDropObjectForPort(objectUnderMouse, draggedObject) != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Link;
return;
}
}
if (objectUnderMouse.IsNode)
{
var draggedLibrary = GetDraggedLibrary(draggedObject);
var draggedEngineObject = draggedLibrary != null ? draggedLibrary.EngineObjects[0] : null;
// -- Don't accept to drag an object directly under Behaviour --
if (objectUnderMouse.IsBehaviour)
{
if (draggedEngineObject != null &&
iCS_AllowedChildren.CanAddChildNode(draggedEngineObject.RawName, draggedEngineObject, objectUnderMouse, IStorage))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
}
else
{
DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
}
return;
}
// -- Don't accept to drag object outside the root node --
if (objectUnderMouse == DisplayRoot && IStorage.ShowDisplayRootNode)
{
if (!DisplayRoot.GlobalRect.Contains(GraphMousePosition))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
return;
}
}
if (draggedObject is Texture && objectUnderMouse.IsIconizedOnDisplay)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
return;
}
if (draggedObject is GameObject)
{
if (objectUnderMouse.IsKindOfPackage)
{
var library = GetDraggedLibrary(draggedObject);
if (library == null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
return;
}
iCS_IVisualScriptData storage = library;
if (storage.EngineObjects.Count > 0)
{
var engineObject = storage.EngineObjects[0];
if (iCS_AllowedChildren.CanAddChildNode(engineObject.RawName, engineObject.ObjectType, objectUnderMouse, IStorage))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
return;
}
}
}
}
}
}
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
}
// ======================================================================
// Duplication Utilities
// ----------------------------------------------------------------------
public static void CopyFromTo(iCS_IVisualScriptData from, iCS_IVisualScriptData to)
{
iCS_VisualScriptData.CopyFromTo(from, to);
}
// ----------------------------------------------------------------------
// Creates a new memento and saves the navigation state of the given
// IStorage.
public iCS_NavigationMemento(iCS_IVisualScriptData storage)
{
SaveState(storage);
}
