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); }