public void NodeCreated(ValidatedHandle handle) { Commands.Add(new CommandTuple { command = Command.Create, ContainerIndex = CreatedNodes.Count }); CreatedNodes.Add(handle); }
public void NodeDeleted(ValidatedHandle handle, int definitionIndex) { Commands.Add(new CommandTuple { command = Command.Destroy, ContainerIndex = DeletedNodes.Count }); DeletedNodes.Add(new DeletedTuple { Handle = handle, Class = definitionIndex }); }
void AddWriter(ComponentType component) { // TODO: take argument instead. AtomicSafetyManager does not yet support read-only // For now, DFG takes write dependency on every type in the graph component.AccessModeType = ComponentType.AccessMode.ReadWrite; if (!HasReaderOrWriter(component)) { if (component.IsZeroSized) { throw new InvalidNodeDefinitionException($"ECS types on ports cannot be zero-sized ({component})"); } HostSystem.AddReaderWriter(component); m_ActiveComponentTypes.Add(new AtomicSafetyManager.ECSTypeAndSafety { Type = component }); } }
/// <summary> /// Construct a node set. Remember to dispose it. /// <seealso cref="Dispose"/> /// </summary> public NodeSet() { m_NodeDefinitions.Add(s_InvalidDefinitionSlot); var defaultTraits = LLTraitsHandle.Create(); // stuff that needs the first slot to be invalid defaultTraits.Resolve() = new LowLevelNodeTraits(); m_Traits.Add(defaultTraits); m_ForwardingTable.Allocate(); m_ArraySizes.Allocate(); m_ManagedAllocators.Add(new ManagedMemoryAllocator()); // (we don't need a zeroth invalid index for nodes, because they are versioned) RendererModel = RenderExecutionModel.MaximallyParallel; m_RenderGraph = new RenderGraph(this); NodeSetID = ++s_NodeSetCounter; m_Batches = new VersionedList <InputBatch>(Allocator.Persistent, NodeSetID); m_GraphValues = new VersionedList <DataOutputValue>(Allocator.Persistent, NodeSetID); }
GenerateDataPortDeclarations(Type definitionType, Type kernelPortType) { // Offset from the start of the field of the data port to the pointer. A bit of a hack. const int k_PtrOffset = 0; var inputs = new BlitList <InputDeclaration>(0); var outputs = new BlitList <OutputDeclaration>(0); var outputBufferOffsets = new BlitList <BufferOffset>(0); try { var kernelPortValue = definitionType.GetField("s_KernelPorts", BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null); foreach (var potentialPortFieldInfo in kernelPortType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)) { ValidateFieldOnKernelPort(potentialPortFieldInfo); var portType = potentialPortFieldInfo.FieldType; if (!portType.IsConstructedGenericType) { throw new InvalidNodeDefinitionException($"Simulation port definition contains disallowed field {portType}."); } // Acquire the assigned port number of this port declaration var assignedPortNumberField = portType.GetField("Port", BindingFlags.Instance | BindingFlags.NonPublic); var genericPortType = portType.GetGenericTypeDefinition(); var genericsForDeclaration = portType.GetGenericArguments(); bool isPortArray = genericPortType == typeof(PortArray <>); if (isPortArray) { // Extract the specifics of the port type inside the port array. portType = genericsForDeclaration[0]; if (!portType.IsConstructedGenericType) { throw new InvalidNodeDefinitionException($"Simulation port definition contains disallowed field {portType}."); } genericPortType = portType.GetGenericTypeDefinition(); genericsForDeclaration = portType.GetGenericArguments(); } if (genericsForDeclaration.Length < 2) { throw new InvalidNodeDefinitionException($"Simulation port definition contains disallowed type {portType}."); } var dataType = genericsForDeclaration[1]; ValidateDataPortType(potentialPortFieldInfo, dataType); var offsetOfWholePortDeclaration = UnsafeUtility.GetFieldOffset(potentialPortFieldInfo); var portValue = potentialPortFieldInfo.GetValue(kernelPortValue); if (genericPortType == typeof(DataInput <,>)) { if (UnsafeUtility.SizeOf(dataType) > k_MaxInputSize) { throw new InvalidNodeDefinitionException($"Node input data structure types cannot have a sizeof larger than {k_MaxInputSize}"); } inputs.Add( new InputDeclaration( new SimpleType(dataType), offsetOfWholePortDeclaration + k_PtrOffset, (InputPortID)assignedPortNumberField.GetValue(portValue), isPortArray ) ); } else if (genericPortType == typeof(DataOutput <,>)) { SimpleType type; if (IsBufferDefinition(dataType)) { // Compute the simple type of an element inside a buffer if possible type = new SimpleType(dataType.GetGenericArguments()[0]); outputBufferOffsets.Add(new BufferOffset(offsetOfWholePortDeclaration)); } else { // otherwise the entire value (breaks for aggregates) type = new SimpleType(dataType); foreach (var field in WalkTypeInstanceFields(dataType, BindingFlags.Public, IsBufferDefinition)) { outputBufferOffsets.Add(new BufferOffset(offsetOfWholePortDeclaration + UnsafeUtility.GetFieldOffset(field))); } } outputs.Add( new OutputDeclaration( type, offsetOfWholePortDeclaration + k_PtrOffset, (OutputPortID)assignedPortNumberField.GetValue(portValue) ) ); } else { throw new InvalidNodeDefinitionException($"Kernel port definition {kernelPortType} contains other types of fields than DataInput<> and DataOutput<> ({portType})"); } } } catch { inputs.Dispose(); outputs.Dispose(); outputBufferOffsets.Dispose(); throw; } return(inputs, outputs, outputBufferOffsets); }