public static void Trigger <TArgs>(EventHook hook, TArgs args)
{
HashSet <Action <TArgs> > handlers = null;
if (events.TryGetValue(hook, out var potentialHandlers))
{
foreach (var potentialHandler in potentialHandlers)
{
if (potentialHandler is Action <TArgs> handler)
{
if (handlers == null)
{
handlers = HashSetPool <Action <TArgs> > .New();
}
handlers.Add(handler);
}
}
}
if (handlers != null)
{
foreach (var handler in handlers)
{
if (!potentialHandlers.Contains(handler))
{
continue;
}
handler.Invoke(args);
}
handlers.Free();
}
}
public void FloodCollect(int _x, int _y, ref List <GridObject> ret, Func <GridObject, bool> comparator)
{
void InnerFunc(int x, int y, ref List <GridObject> found, HashSet <pair <int, int> > searched)
{
var current = new pair <int, int>(x, y);
if (searched.Contains(current))
{
return;
}
searched.Add(current);
var obj = ObjectAt(x, y);
if (obj == null)
{
return;
}
if (comparator == null || comparator.Invoke(obj))
{
found.Add(obj);
InnerFunc(x + 1, y, ref found, searched);
InnerFunc(x - 1, y, ref found, searched);
InnerFunc(x, y + 1, ref found, searched);
InnerFunc(x, y - 1, ref found, searched);
}
}
var search = HashSetPool <pair <int, int> > .New();
InnerFunc(_x, _y, ref ret, search);
search.Free();
}
public static void RefreshSelectionToolbar()
{
var sceneViews = SceneView.sceneViews.OfType <SceneView>().ToListPooled();
var sceneViewsToRemove = HashSetPool <SceneView> .New();
try
{
// Don't pick prefabs
selectionToolbarTargets = Selection.transforms.Select(t => t.gameObject).ToArray();
if (selectionToolbarTargets.Length > 0)
{
// Update controls for each open scene view
foreach (var sceneView in sceneViews)
{
var toolbar = ObjectToolbarProvider.GetToolbar(selectionToolbarTargets);
var toolbarControl = toolbarControlProvider.GetControl(toolbar, sceneView);
selectionToolbarControls[sceneView] = toolbarControl;
if (sceneView == SceneView.lastActiveSceneView)
{
ShortcutsIntegration.primaryToolbar = toolbarControl;
}
}
}
else
{
selectionToolbarControls.Clear();
ShortcutsIntegration.primaryToolbar = null;
}
// Remove toolbars for closed scene views
foreach (var selectionToolbarControl in selectionToolbarControls)
{
if (!sceneViews.Contains(selectionToolbarControl.Key))
{
sceneViewsToRemove.Add(selectionToolbarControl.Key);
}
}
foreach (var sceneViewToRemove in sceneViewsToRemove)
{
selectionToolbarControls.Remove(sceneViewToRemove);
}
SceneView.RepaintAll();
}
finally
{
sceneViews.Free();
sceneViewsToRemove.Free();
}
}
public static HashSet <T> ToHashSetPooled <T>(this IEnumerable <T> source)
{
var hashSet = HashSetPool <T> .New();
foreach (var item in source)
{
hashSet.Add(item);
}
return(hashSet);
}
protected override void UpdateTools(IList <ITool> tools)
{
if (mainTool != null)
{
tools.Add(mainTool);
}
var materialSets = ListPool <List <Material> > .New();
foreach (var target in targets)
{
var materialSet = ListPool <Material> .New();
target.GetSharedMaterials(materialSet);
materialSets.Add(materialSet);
}
var sharedMaterials = HashSetPool <Material> .New();
var isFirst = true;
foreach (var materialSet in materialSets)
{
if (isFirst)
{
sharedMaterials.UnionWith(materialSet);
isFirst = false;
}
else
{
sharedMaterials.IntersectWith(materialSet);
}
materialSet.Free();
}
foreach (var material in sharedMaterials)
{
if (material == null)
{
continue;
}
var materialTool = EditorToolProvider.GetEditorTool(material);
tools.Add(materialTool);
}
materialSets.Free();
}
// Active state detection happens twice:
//
// 1. Before the enumeration, because any state
// that becomes active during an update shouldn't
// be updated until the next update
//
// 2. Inside the update method, because a state
// that was active during enumeration and no longer
// is shouldn't be updated.
private HashSet <IState> GetActiveStatesNoAlloc(GraphPointer pointer)
{
var activeStates = HashSetPool <IState> .New();
foreach (var state in states)
{
var stateData = pointer.GetElementData <State.Data>(state);
if (stateData.isActive)
{
activeStates.Add(state);
}
}
return(activeStates);
}
public static void Trigger <TArgs>(EventTarget target, TArgs args)
{
HashSet <Action <TArgs> > handlers = null;
if (events.TryGetValue(target, out var potentialHandlers))
{
foreach (var potentialHandler in potentialHandlers)
{
if (potentialHandler is Action <TArgs> handler)
{
if (handlers == null)
{
handlers = HashSetPool <Action <TArgs> > .New();
}
handlers.Add(handler);
}
}
}
if (handlers == null || handlers.Count == 0)
{
if (OpenWarning)
{
if (target.target == null)
{
IcLog.Warning($"Global Event: {target.name} No Any Handle.");
}
else
{
IcLog.Warning($"{target.name}---:---{target.target} No Any Handle.");
}
return;
}
}
if (handlers != null)
{
foreach (var handler in handlers)
{
handler.Invoke(args);
}
handlers.Free();
}
}
private static void PooledHashSet_Simple_Impl(HashSetPool <string> pool)
{
for (var i = 0; i < 100; i++)
{
using var obj = i % 2 == 0 ? pool.New() : PooledHashSet <string> .New(pool);
var set = obj.HashSet;
Assert.AreEqual(0, set.Count);
set.Add("qux");
set.Add("foo");
set.Add("bar");
set.Add("baz");
Assert.IsTrue(set.SetEquals(exp));
}
}
public IEnumerable <GridObject> IterateUniqueBlocks()
{
HashSet <GridObject> objs = HashSetPool <GridObject> .New();
foreach (var gridObject in objects)
{
if (objs.Contains(gridObject))
{
continue;
}
yield return(gridObject);
foreach (var bound in gridObject.BoundedTo)
{
objs.Add(bound);
}
objs.Add(gridObject);
}
objs.Free();
}
private static HashSet <TEvent> EventsToTrigger <TEvent>(FlowMachine target) where TEvent : MachineEvent
{
// Avoiding ToHashSetPooled because IEnumerable allocates memory,
// whereas HashSet has a struct enumerator. Using HashSet instead
// of array to avoid iterating twice for the count.
var toTrigger = HashSetPool <TEvent> .New();
if (events.ContainsKey(target))
{
foreach (var @event in events[target])
{
if (@event is TEvent)
{
toTrigger.Add((TEvent)@event);
}
}
}
return(toTrigger);
}
private static void Update()
{
var now = DateTime.UtcNow;
var stillOpen = HashSetPool <EditorWindow> .New();
foreach (var window in watched)
{
if (window.IsDestroyed())
{
lastCloseTimes.Add(window, now);
}
else
{
stillOpen.Add(window);
}
}
watched.IntersectWith(stillOpen);
stillOpen.Free();
}
private void FreeInvalid()
{
if (DateTime.UtcNow > lastFreeTime + freeInterval)
{
var toRemove = HashSetPool <Key> .New();
foreach (var controlByKey in controlsByKeys)
{
if (!controlByKey.Value.toolbar.isValid)
{
toRemove.Add(controlByKey.Key);
}
}
foreach (var tr in toRemove)
{
controlsByKeys.Remove(tr);
}
toRemove.Free();
lastFreeTime = DateTime.UtcNow;
}
}
public static void PickAllNonAlloc(List <ProbeHit> hits, ProbeFilter filter, SceneView sceneView, Vector2 guiPosition, int limit = DefaultLimit)
{
var screenPosition = HandleUtility.GUIPointToScreenPixelCoordinate(guiPosition);
var ray3D = HandleUtility.GUIPointToWorldRay(guiPosition);
var worldPosition = sceneView.camera.ScreenToWorldPoint(screenPosition);
var layerMask = PeekPlugin.Configuration.probeLayerMask;
var raycastHits = ArrayPool <RaycastHit> .New(limit);
var overlapHits = ArrayPool <Collider2D> .New(limit);
var handleHits = HashSetPool <GameObject> .New();
var ancestorHits = HashSetPool <ProbeHit> .New();
#if PROBUILDER_4_OR_NEWER
var proBuilderHits = ListPool <ProbeHit> .New();
#endif
var gameObjectHits = DictionaryPool <GameObject, ProbeHit> .New();
try
{
// Raycast (3D)
if (filter.raycast)
{
var raycastHitCount = Physics.RaycastNonAlloc(ray3D, raycastHits, Mathf.Infinity, layerMask);
for (var i = 0; i < raycastHitCount; i++)
{
var raycastHit = raycastHits[i];
#if UNITY_2019_2_OR_NEWER
if (SceneVisibilityManager.instance.IsHidden(raycastHit.transform.gameObject))
{
continue;
}
#endif
var gameObject = raycastHit.transform.gameObject;
if (!gameObjectHits.TryGetValue(gameObject, out var hit))
{
hit = new ProbeHit(gameObject);
}
hit.point = raycastHit.point;
hit.distance = raycastHit.distance;
gameObjectHits[gameObject] = hit;
}
}
// Overlap (2D)
if (filter.overlap)
{
var overlapHitCount = Physics2D.OverlapPointNonAlloc(worldPosition, overlapHits, layerMask);
for (var i = 0; i < overlapHitCount; i++)
{
var overlapHit = overlapHits[i];
#if UNITY_2019_2_OR_NEWER
if (SceneVisibilityManager.instance.IsHidden(overlapHit.transform.gameObject))
{
continue;
}
#endif
var gameObject = overlapHit.transform.gameObject;
if (!gameObjectHits.TryGetValue(gameObject, out var hit))
{
hit = new ProbeHit(gameObject);
}
hit.distance = hit.distance ?? Vector3.Distance(overlapHit.transform.position, worldPosition);
gameObjectHits[gameObject] = hit;
}
}
// Handles (Editor Default)
if (filter.handles && canPickHandles)
{
PickAllHandlesNonAlloc(handleHits, guiPosition, limit);
foreach (var handleHit in handleHits)
{
var gameObject = handleHit;
if (!gameObjectHits.TryGetValue(gameObject, out var hit))
{
hit = new ProbeHit(gameObject);
}
hit.distance = hit.distance ?? Vector3.Distance(handleHit.transform.position, worldPosition);
gameObjectHits[gameObject] = hit;
}
}
// Ancestors
foreach (var gameObjectHit in gameObjectHits)
{
var gameObject = gameObjectHit.Key;
var hit = gameObjectHit.Value;
var parent = gameObject.transform.parent;
int depth = 0;
while (parent != null)
{
var parentGameObject = parent.gameObject;
var parentHit = new ProbeHit(parentGameObject);
parentHit.groupGameObject = gameObject;
parentHit.distance = hit.distance ?? Vector3.Distance(parentHit.transform.position, worldPosition);
parentHit.groupOrder = 1000 + depth;
ancestorHits.Add(parentHit);
parent = parent.parent;
depth++;
}
}
#if PROBUILDER_4_OR_NEWER
// ProBuilder
if (filter.proBuilder && ProBuilderEditor.instance != null)
{
var proBuilderMeshes = ListPool <ProBuilderMesh> .New();
try
{
foreach (var gameObjectHit in gameObjectHits.Values)
{
var proBuilderMesh = gameObjectHit.gameObject.GetComponent <ProBuilderMesh>();
if (proBuilderMesh != null)
{
proBuilderMeshes.Add(proBuilderMesh);
}
}
PickProBuilderElementsNonAlloc(proBuilderHits, proBuilderMeshes, sceneView, guiPosition);
}
finally
{
proBuilderMeshes.Free();
}
}
#endif
// Prepare final hits
hits.Clear();
// Add hits
foreach (var gameObjectHit in gameObjectHits.Values)
{
hits.Add(gameObjectHit);
}
foreach (var ancestorHit in ancestorHits)
{
hits.Add(ancestorHit);
}
#if PROBUILDER_4_OR_NEWER
foreach (var proBuilderHit in proBuilderHits)
{
hits.Add(proBuilderHit);
}
#endif
// Sort by distance
hits.Sort(compareHits);
}
finally
{
raycastHits.Free();
overlapHits.Free();
handleHits.Free();
ancestorHits.Free();
#if PROBUILDER_4_OR_NEWER
proBuilderHits.Free();
#endif
gameObjectHits.Free();
}
}
public override void Prewarm()
{
base.Prewarm();
UnityAPI.Await
(
() =>
{
if (PeekPlugin.Configuration.createPrimitives)
{
var primitivePaths = EditorMainMenu
.GetSubmenus("GameObject")
.Where(mi => !(createMenuBlacklist.Contains(mi) || PeekPlugin.Configuration.createMenuBlacklist.Contains(mi)))
.ToArray();
var primitiveFolders = HashSetPool <string> .New();
foreach (var primitivePath in primitivePaths)
{
var primitiveOption = CreateGameObjectOption.Primitive(primitivePath);
var primitiveFolder = primitiveOption.primitiveFolder;
primitiveOptions.Add(primitiveOption);
if (!primitiveFolders.Contains(primitiveFolder))
{
primitiveFolderOptions.Add(new MenuFolderOption(primitiveFolder));
primitiveFolders.Add(primitiveFolder);
}
}
primitiveFolders.Free();
}
if (PeekPlugin.Configuration.createPrefabs)
{
foreach (var prefabResult in AssetDatabaseUtility.FindAssets("t:prefab"))
{
assetOptions.Add(CreateGameObjectOption.Prefab(prefabResult));
}
}
if (PeekPlugin.Configuration.createModels)
{
foreach (var modelResult in AssetDatabaseUtility.FindAssets("t:model"))
{
assetOptions.Add(CreateGameObjectOption.Model(modelResult));
}
}
if (PeekPlugin.Configuration.createSprites)
{
foreach (var spriteResult in AssetDatabaseUtility.FindAssets("t:sprite"))
{
assetOptions.Add(CreateGameObjectOption.Sprite(spriteResult));
}
}
var assetFolders = HashSetPool <string> .New();
foreach (var assetOption in assetOptions)
{
var assetFolder = assetOption.assetFolder;
if (!assetFolders.Contains(assetFolder))
{
assetFolderOptions.Add(new AssetFolderOption(assetFolder));
assetFolders.Add(assetFolder);
}
}
assetFolders.Free();
}
);
}
private void DrawHandle()
{
// Trying to be very speed / memory efficient in this method
if (!e.IsRepaint)
{
return;
}
var color = Color.white;
var highlight = false;
var invalid = false;
var willDisconnect = false;
var connections = HashSetPool <IUnitConnection> .New();
GetConnectionsNoAlloc(connections);
var isConnected = connections.Count > 0;
if (isConnected)
{
foreach (var connection in connections)
{
if (connection is InvalidConnection)
{
invalid = true;
}
var sourceWidget = canvas.Widget <IUnitPortWidget>(connection.source);
var destinationWidget = canvas.Widget <IUnitPortWidget>(connection.destination);
if (sourceWidget.isMouseOver || destinationWidget.isMouseOver)
{
highlight = true;
}
if (sourceWidget.willDisconnect || destinationWidget.willDisconnect)
{
willDisconnect = true;
}
}
}
if (isMouseOver)
{
highlight = true;
}
if (willDisconnect)
{
color = UnitConnectionStyles.disconnectColor;
}
else if (highlight)
{
color = UnitConnectionStyles.highlightColor;
}
else if (invalid)
{
color = UnitConnectionStyles.invalidColor;
}
else if (canvas.isCreatingConnection && (canvas.connectionSource == port || canvas.connectionSource.CanValidlyConnectTo(port)))
{
color = this.color;
}
else if (isConnected)
{
Color?resolvedColor = null;
foreach (var connection in connections)
{
var connectionColor = canvas.Widget <IUnitConnectionWidget>(connection).color;
if (resolvedColor == null)
{
resolvedColor = connectionColor;
}
else if (resolvedColor != connectionColor)
{
resolvedColor = this.color;
break;
}
}
color = resolvedColor.Value;
}
if (colorIfActive)
{
foreach (var connection in connections)
{
var connectionEditorData = reference.GetElementDebugData <IUnitConnectionDebugData>(connection);
if (EditorApplication.isPaused)
{
if (EditorTimeBinding.frame == connectionEditorData.lastInvokeFrame)
{
color = UnitConnectionStyles.activeColor;
break;
}
}
else
{
color = Color.Lerp(UnitConnectionStyles.activeColor, color, (EditorTimeBinding.time - connectionEditorData.lastInvokeTime) / UnitWidget <IUnit> .Styles.invokeFadeDuration);
}
}
}
var handlePosition = this.handlePosition;
if (highlight)
{
var widthExpansion = handlePosition.width * (Styles.highlightScaling - 1);
var heightExpansion = handlePosition.height * (Styles.highlightScaling - 1);
handlePosition.width += widthExpansion;
handlePosition.height += heightExpansion;
handlePosition.x -= widthExpansion / 2;
handlePosition.y -= heightExpansion / 2;
}
if (highlight ||
isConnected ||
canvas.connectionSource == port ||
canvas.isCreatingConnection && canvas.connectionSource.CanValidlyConnectTo(port))
{
using (LudiqGUI.color.Override(color.WithAlphaMultiplied(LudiqGUI.color.value.a * 0.85f))) // Full color is a bit hard on the eyes
{
if (handleTextureConnected != null)
{
GUI.DrawTexture(handlePosition, handleTextureConnected);
}
}
}
else
{
if (handleTextureUnconnected != null)
{
GUI.DrawTexture(handlePosition, handleTextureUnconnected);
}
}
HashSetPool <IUnitConnection> .Free(connections);
}