public NetworkPipeline CreatePipeline(params Type[] stages)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (m_Pipelines.Length > 255)
{
throw new InvalidOperationException("Cannot create more than 255 pipelines on a single driver");
}
#endif
var receiveCap = 0;
var sharedCap = 0;
var sendCap = 0;
var headerCap = 0;
var pipeline = new PipelineImpl();
pipeline.FirstStageIndex = m_StageList.Length;
pipeline.NumStages = stages.Length;
for (int i = 0; i < stages.Length; i++)
{
var stageId = m_StageCollection.GetStageId(stages[i]);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (stageId < 0)
{
throw new InvalidOperationException("Trying to create pipeline with invalid stage " + stages[i]);
}
#endif
m_StageList.Add(stageId);
receiveCap += m_StageCollection.GetReceiveCapacity(stageId);
sendCap += m_StageCollection.GetSendCapacity(stageId);
headerCap += m_StageCollection.GetHeaderCapacity(stageId);
sharedCap += m_StageCollection.GetSharedStateCapacity(stageId);
}
// Make sure all data buffers are 4-byte aligned
receiveCap = (receiveCap + 3) & (~3);
sendCap = (sendCap + 3) & (~3);
sharedCap = (sharedCap + 3) & (~3);
pipeline.receiveBufferOffset = sizePerConnection[RecveiveSizeOffset];
sizePerConnection[RecveiveSizeOffset] = sizePerConnection[RecveiveSizeOffset] + receiveCap;
pipeline.sendBufferOffset = sizePerConnection[SendSizeOffset];
sizePerConnection[SendSizeOffset] = sizePerConnection[SendSizeOffset] + sendCap;
pipeline.sharedBufferOffset = sizePerConnection[SharedSizeOffset];
sizePerConnection[SharedSizeOffset] = sizePerConnection[SharedSizeOffset] + sharedCap;
pipeline.headerCapacity = headerCap;
m_Pipelines.Add(pipeline);
return(new NetworkPipeline {
Id = m_Pipelines.Length
});
}
private void ProcessSendStage(int startStage, int internalBufferOffset, int internalSharedBufferOffset,
PipelineImpl p, ref NativeList <int> resumeQ, ref NetworkPipelineContext ctx, ref InboundBufferVec inboundBuffer, ref bool needsUpdate)
{
bool needsResume = false;
ctx.internalProcessBuffer = Unsafe_GetSliceFromReadOnlyArray(sendBuffer, internalBufferOffset,
m_StageCollection.GetSendCapacity(m_StageList[p.FirstStageIndex + startStage]));
ctx.internalSharedProcessBuffer =
Unsafe_GetSliceFromReadOnlyArray(sharedBuffer, internalSharedBufferOffset,
m_StageCollection.GetSharedStateCapacity(m_StageList[p.FirstStageIndex + startStage]));
inboundBuffer = m_StageCollection.InvokeSend(m_StageList[p.FirstStageIndex + startStage], ctx,
inboundBuffer, ref needsResume, ref needsUpdate);
if (needsResume)
{
resumeQ.Add(startStage);
}
}
private unsafe void ProcessSendStage(int startStage, int internalBufferOffset, int internalSharedBufferOffset,
PipelineImpl p, ref NativeList <int> resumeQ, ref NetworkPipelineContext ctx, ref InboundSendBuffer inboundBuffer, ref NetworkPipelineStage.Requests requests)
{
var pipelineStage = m_StageCollection[m_StageList[p.FirstStageIndex + startStage]];
ctx.staticInstanceBuffer = (byte *)m_StaticInstanceBuffer.GetUnsafeReadOnlyPtr() + pipelineStage.StaticStateStart;
ctx.staticInstanceBufferLength = pipelineStage.StaticStateCapcity;
ctx.internalProcessBuffer = (byte *)sendBuffer.GetUnsafeReadOnlyPtr() + internalBufferOffset;
ctx.internalProcessBufferLength = pipelineStage.SendCapacity;
ctx.internalSharedProcessBuffer = (byte *)sharedBuffer.GetUnsafeReadOnlyPtr() + internalSharedBufferOffset;
ctx.internalSharedProcessBufferLength = pipelineStage.SharedStateCapacity;
requests = NetworkPipelineStage.Requests.None;
pipelineStage.Send.Ptr.Invoke(ref ctx, ref inboundBuffer, ref requests);
if ((requests & NetworkPipelineStage.Requests.Resume) != 0)
{
resumeQ.Add(startStage);
}
}
