public static IAddressableObservable <TApi> ToObservable <TApi>(this AssetReferenceGameObject reference)
where TApi : class
{
var observable = ClassPool.Spawn <AddressableObservable <AssetReference, GameObject, TApi> >();
observable.Initialize(reference);
return(observable);
}
public static IEnumerator WaitForEndOfFrame(this object source)
{
var waitForEndFrame = ClassPool.Spawn <WaitForEndOfFrame>().Initialize();
yield return(waitForEndFrame);
waitForEndFrame.Despawn();
}
public static IAddressableObservable <TData> ToObservable <TData>(this AssetReferenceT <TData> reference)
where TData : Object
{
var observable = ClassPool.Spawn <AddressableObservable <AssetReferenceT <TData>, TData, TData> >();
observable.Initialize(reference);
return(observable);
}
public static IEnumerator WaitForSeconds(this object source, float delay)
{
var waitForSeconds = ClassPool.
Spawn <WaitForSecondRoutine>().
Initialize(delay);
yield return(waitForSeconds);
waitForSeconds.Despawn();
}
private IEnumerable <IUnityBuildCommand> FilterActiveCommands(IEnumerable <BuildCommandStep> commands)
{
var commandsBuffer = ClassPool.Spawn <List <IUnityBuildCommand> >();
foreach (var command in commands)
{
commandsBuffer.AddRange(command.GetCommands());
}
return(commandsBuffer);
}
public static void UpdatePorts(this INode node, NodeGraph data)
{
var portList = ClassPool.Spawn <List <INodePort> >();
node.Initialize(data);
portList.AddRange(node.Ports);
node.UpdateNodePorts();
portList.Despawn();
}
public void CloseAll()
{
var buffer = ClassPool.Spawn <List <IView> >();
buffer.AddRange(_views);
_views.Clear();
foreach (var view in buffer)
{
view.Close();
}
buffer.Despawn();
}
private void CreatePortConnections()
{
var portsConnections = ClassPool.Spawn <List <NodePortConnection> >();
foreach (var nodeItem in uniNodes)
{
var nodeView = nodeItem.Value;
var node = nodeView.SourceNode;
foreach (var outputPortView in nodeView.outputPorts)
{
var portData = outputPortView.portData;
var sourcePort = node.GetPort(portData.displayName);
foreach (var connection in sourcePort.Connections)
{
if (!uniNodes.TryGetValue(connection.NodeId, out var connectionNode))
{
continue;
}
var targetNode = connectionNode.SourceNode;
var port = targetNode.GetPort(connection.PortName);
if (port.Direction != PortIO.Input)
{
continue;
}
var inputPortView = connectionNode.GetPort(nameof(connectionNode.inputs), connection.PortName);
portsConnections.Add(new NodePortConnection()
{
source = inputPortView,
target = outputPortView
});
}
}
}
foreach (var nodePortConnection in portsConnections)
{
var inputPortView = nodePortConnection.source;
var outputPortView = nodePortConnection.target;
Connect(inputPortView, outputPortView);
}
portsConnections.Despawn();
}
protected override async UniTask OnContextActivate(IContext context)
{
var results = ClassPool.Spawn <List <AsyncContextDataSource> >();
await sources.LoadAssetsTaskAsync(results, LifeTime);
foreach (var dataSource in results)
{
await dataSource.RegisterAsync(context);
}
results.Despawn();
Complete();
}
private void ValidateGraph()
{
var removed = ClassPool.Spawn <List <BaseNode> >();
foreach (var node in nodes)
{
if (node is UniBaseNode uniBaseNode && !uniNodes.ContainsKey(uniBaseNode.sourceId))
{
removed.Add(node);
}
}
removed.ForEach(RemoveNode);
removed.Despawn();
uniExposedParameters.RemoveAll(x => x == null);
}
public void ClearConnections()
{
var removedConnections = ClassPool.Spawn <List <PortConnection> >();
removedConnections.AddRange(connections);
foreach (var connection in removedConnections)
{
if (connection.Port == null)
{
continue;
}
Disconnect(connection.Port);
}
connections.Clear();
removedConnections.Despawn();
}
/// <summary> Checks all connections for invalid references, and removes them. </summary>
public void VerifyConnections()
{
var removedConnections = ClassPool.Spawn <List <PortConnection> >();
for (var i = connections.Count - 1; i >= 0; i--)
{
var connection = connections[i];
var targetPort = connection.Port;
if (targetPort != null)
{
continue;
}
removedConnections.Add(connection);
}
removedConnections.ForEach(x => connections.Remove(x));
removedConnections.Despawn();
}
public override void Validate()
{
_allNodes?.Clear();
OnInnerValidate();
var nodeItems = ClassPool.Spawn <List <INode> >();
nodeItems.AddRange(serializableNodes);
nodeItems.AddRange(nodes);
foreach (var nodeItem in nodeItems)
{
nodeItem.SetUpData(this);
nodeItem.Validate();
}
nodeItems.Despawn();
}
private EcsWorld ActivateWorld(ILifeTime lifeTime)
{
if (_world != null)
{
return(_world);
}
var world = CreateWorld();
world.InitializeWorld();
var destroyAction = ClassPool.Spawn <DisposableAction>();
destroyAction.Initialize(world.Destroy);
lifeTime.AddDispose(destroyAction);
return(world);
}
private List <UiViewReference> FindItemsByType(Type type, bool strongMatching)
{
var result = ClassPool.Spawn <List <UiViewReference> >();
if (strongMatching)
{
if (views.TryGetValue(type, out var items))
{
result.AddRange(items);
}
return(result);
}
foreach (var view in views)
{
var viewType = view.Key;
if (type.IsAssignableFrom(viewType))
{
result.AddRange(view.Value);
}
}
return(result);
}
