public void Update(IGameContext gameContext, IUpdateContext updateContext)
{
if (gameContext.World == null)
{
return;
}
UpdateFrames();
if (gameContext.World != _currentWorld || _shadowWorld == null)
{
if (_shadowWorld != null)
{
_shadowWorld.Dispose();
}
_shadowWorld = _networkFactory.CreateShadowWorld();
_currentWorld = gameContext.World;
_shadowWorld.OnMessageRecievedStatisticsAction += OnMessageRecievedStatisticsAction;
}
if (_dispatcherChanged.ContainsKey(gameContext.World) &&
_dispatcherChanged[gameContext.World])
{
_shadowWorld.Dispatcher = _dispatchers[gameContext.World];
_dispatcherChanged[gameContext.World] = false;
_currentDispatchers[0] = _shadowWorld.Dispatcher;
}
using (_profiler.Measure("net-step"))
{
_shadowWorld.Update(gameContext, updateContext);
}
}
private async Task <T> SearchContentItems <T>(ContentItemReference item, bool preview)
{
using (_profiler.Measure(nameof(GetContentItem)))
{
var query = new QueryBuilder <T>().LocaleIs(item.Locale);
return(await _factory.GetContentsClient(preview).GetEntry(item.Id, query));
}
}
public void Update(IGameContext gameContext, IUpdateContext updateContext)
{
if (gameContext.World != _currentWorld || _shadowWorld == null)
{
if (_shadowWorld != null)
{
_shadowWorld.Dispose();
}
_shadowWorld = _physicsFactory.CreateShadowWorld();
_currentWorld = gameContext.World;
}
using (_profiler.Measure("phys-step"))
{
_shadowWorld.Update(gameContext, updateContext);
}
}
public static void Run(IRunner caller, IProfiler profiler, int repetitionsCount, IChartBuilder builder)
{
var result = profiler.Measure(caller, repetitionsCount);
var chart = builder.Build(result);
var form = new Form {
ClientSize = new Size(800, 600)
};
chart.Dock = DockStyle.Fill;
form.Controls.Add(chart);
Application.Run(form);
}
private ContentSearchResult ConvertToContentSearchResult(ContentItemData entry, ContentType contentType, PublishingTarget target)
{
using (_profiler.Measure(nameof(ConvertToContentSearchResult)))
{
return(new ContentSearchResult
{
Item = new ContentItemResult
{
Value = ConvertToContentItem(entry, contentType, target),
},
});
}
}
public void Render(IGameContext gameContext, IRenderContext renderContext)
{
try
{
renderContext.Render(gameContext);
// NOTE: We MUST clear the depth buffer because OpenGL will not do it for us.
renderContext.GraphicsDevice.Clear(
ClearOptions.DepthBuffer,
Microsoft.Xna.Framework.Color.Transparent,
renderContext.GraphicsDevice.Viewport.MaxDepth,
0);
_primary = _renderTargetBackBufferUtilities.UpdateRenderTarget(_primary, gameContext);
_secondary = _renderTargetBackBufferUtilities.UpdateRenderTarget(_secondary, gameContext);
if (_primary == null || _secondary == null)
{
// These are null if the window is minimized or invalid, in which case we don't
// render anything anyway.
return;
}
var standardRenderPasses = _standardRenderPasses.ToArray();
var postProcessingRenderPasses = _postProcessingRenderPasses.ToArray();
IRenderPass previousPass = null;
IRenderPass nextPass = null;
var entities = gameContext.World.GetEntitiesForWorld(gameContext.Hierarchy).ToArray();
#if !DISABLE_PIPELINE_TARGETS
renderContext.PushRenderTarget(_primary);
#endif
for (var i = 0; i < standardRenderPasses.Length; i++)
{
var pass = standardRenderPasses[i];
using (_profiler.Measure("r-" + pass.GetType().Name))
{
_isFirstRenderPass = previousPass == null;
_renderPass = pass;
SetupRenderPassViewport(renderContext, pass);
pass.BeginRenderPass(gameContext, renderContext, previousPass, null);
previousPass = pass;
RenderPass(gameContext, renderContext, pass, entities);
if (i < standardRenderPasses.Length - 1)
{
nextPass = standardRenderPasses[i + 1];
}
else if (_transientStandardRenderPasses.Count > 0)
{
nextPass = _transientStandardRenderPasses[0];
}
else if (postProcessingRenderPasses.Length > 0)
{
nextPass = postProcessingRenderPasses[0];
}
else if (_transientPostProcessingRenderPasses.Count > 0)
{
nextPass = _transientPostProcessingRenderPasses[0];
}
else
{
nextPass = null;
}
pass.EndRenderPass(gameContext, renderContext, nextPass);
}
}
var loop = 100;
while (_transientStandardRenderPasses.Count > 0 && loop-- >= 0)
{
var transientStandardRenderPasses = _transientStandardRenderPasses.ToArray();
_transientStandardRenderPasses.Clear();
for (var i = 0; i < transientStandardRenderPasses.Length; i++)
{
var pass = transientStandardRenderPasses[i];
using (_profiler.Measure("r-" + pass.GetType().Name))
{
_isFirstRenderPass = previousPass == null;
_renderPass = pass;
SetupRenderPassViewport(renderContext, pass);
pass.BeginRenderPass(gameContext, renderContext, previousPass, null);
previousPass = pass;
RenderPass(gameContext, renderContext, pass, entities);
if (i < transientStandardRenderPasses.Length - 1)
{
nextPass = transientStandardRenderPasses[i + 1];
}
else if (_transientStandardRenderPasses.Count > 0)
{
nextPass = _transientStandardRenderPasses[0];
}
else if (postProcessingRenderPasses.Length > 0)
{
nextPass = postProcessingRenderPasses[0];
}
else if (_transientPostProcessingRenderPasses.Count > 0)
{
nextPass = _transientPostProcessingRenderPasses[0];
}
else
{
nextPass = null;
}
pass.EndRenderPass(gameContext, renderContext, nextPass);
}
}
}
if (loop < 0)
{
throw new InvalidOperationException(
"Exceeded the number of AppendTransientRenderPass iterations (100). Ensure you " +
"are not unconditionally calling AppendTransientRenderPass within another render pass.");
}
#if !DISABLE_PIPELINE_TARGETS
renderContext.PopRenderTarget();
#endif
if (postProcessingRenderPasses.Length == 0 && _transientPostProcessingRenderPasses.Count == 0)
{
// Blit the primary render target to the backbuffer and return.
#if !DISABLE_PIPELINE_TARGETS
_graphicsBlit.Blit(renderContext, _primary);
#endif
return;
}
var currentSource = _primary;
var currentDest = _secondary;
#if !DISABLE_PIPELINE_TARGETS
renderContext.PushRenderTarget(currentDest);
#endif
for (var i = 0; i < postProcessingRenderPasses.Length; i++)
{
var pass = postProcessingRenderPasses[i];
using (_profiler.Measure("r-" + pass.GetType().Name))
{
_isFirstRenderPass = previousPass == null;
_renderPass = pass;
pass.BeginRenderPass(gameContext, renderContext, previousPass, currentSource);
previousPass = pass;
if (i < postProcessingRenderPasses.Length - 1)
{
nextPass = postProcessingRenderPasses[i + 1];
}
else if (_transientPostProcessingRenderPasses.Count > 0)
{
nextPass = _transientPostProcessingRenderPasses[0];
}
else
{
nextPass = null;
}
pass.EndRenderPass(gameContext, renderContext, nextPass);
var temp = currentSource;
currentSource = currentDest;
currentDest = temp;
#if !DISABLE_PIPELINE_TARGETS
renderContext.PopRenderTarget();
renderContext.PushRenderTarget(currentDest);
#endif
// NOTE: This does not clear the new destination render target; it is expected that
// post-processing effects will fully overwrite the destination.
}
}
loop = 100;
while (_transientPostProcessingRenderPasses.Count > 0 && loop-- >= 0)
{
var transientPostProcessingRenderPasses = _transientPostProcessingRenderPasses.ToArray();
_transientPostProcessingRenderPasses.Clear();
for (var i = 0; i < transientPostProcessingRenderPasses.Length; i++)
{
var pass = transientPostProcessingRenderPasses[i];
using (_profiler.Measure("r-" + pass.GetType().Name))
{
_isFirstRenderPass = previousPass == null;
_renderPass = pass;
pass.BeginRenderPass(gameContext, renderContext, previousPass, currentSource);
previousPass = pass;
if (i < transientPostProcessingRenderPasses.Length - 1)
{
nextPass = transientPostProcessingRenderPasses[i + 1];
}
else if (_transientPostProcessingRenderPasses.Count > 0)
{
nextPass = _transientPostProcessingRenderPasses[0];
}
else
{
nextPass = null;
}
pass.EndRenderPass(gameContext, renderContext, nextPass);
var temp = currentSource;
currentSource = currentDest;
currentDest = temp;
#if !DISABLE_PIPELINE_TARGETS
renderContext.PopRenderTarget();
renderContext.PushRenderTarget(currentDest);
#endif
// NOTE: This does not clear the new destination render target; it is expected that
// post-processing effects will fully overwrite the destination.
}
}
}
if (loop < 0)
{
throw new InvalidOperationException(
"Exceeded the number of AppendTransientRenderPass iterations (100). Ensure you " +
"are not unconditionally calling AppendTransientRenderPass within another render pass.");
}
#if !DISABLE_PIPELINE_TARGETS
renderContext.PopRenderTarget();
_graphicsBlit.Blit(renderContext, currentSource);
#endif
}
finally
{
_renderPass = null;
_isFirstRenderPass = false;
}
}
public void FlushRequests(IGameContext gameContext, IRenderContext renderContext)
{
LastBatchCount = 0;
LastApplyCount = 0;
LastBatchSaveCount = 0;
if (renderContext.IsCurrentRenderPass <I3DBatchedRenderPass>())
{
using (_profiler.Measure("render-flush"))
{
foreach (var kv in _requestLookup)
{
if (_requestInstances[kv.Key].Count == 0)
{
continue;
}
LastBatchCount++;
LastBatchSaveCount += (ulong)(_requestInstances[kv.Key].Count - 1);
var request = kv.Value;
int pc;
SetupForRequest(renderContext, request, out pc, false);
request.Effect.NativeEffect.Parameters["View"]?.SetValue(renderContext.View);
request.Effect.NativeEffect.Parameters["Projection"]?.SetValue(renderContext.Projection);
#if PLATFORM_WINDOWS
var allowInstancedCalls = true;
#else
var allowInstancedCalls = false;
#endif
if (allowInstancedCalls &&
request.Effect.NativeEffect.Techniques[request.TechniqueName + "Batched"] != null)
{
#if PLATFORM_WINDOWS
if (_vertexBuffer == null ||
_requestInstances[kv.Key].Count > _vertexBufferLastInstanceCount)
{
_vertexBuffer?.Dispose();
_vertexBuffer = new VertexBuffer(
renderContext.GraphicsDevice,
_vertexDeclaration,
_requestInstances[kv.Key].Count,
BufferUsage.WriteOnly);
_vertexBufferLastInstanceCount = _requestInstances[kv.Key].Count;
}
var matrices = _requestInstances[kv.Key];
_vertexBuffer.SetData(matrices.ToArray(), 0, matrices.Count);
renderContext.GraphicsDevice.SetVertexBuffers(
new VertexBufferBinding(request.MeshVertexBuffer),
new VertexBufferBinding(_vertexBuffer, 0, 1));
foreach (var pass in request.Effect.NativeEffect.Techniques[request.TechniqueName + "Batched"].Passes)
{
pass.Apply();
renderContext.GraphicsDevice.DrawInstancedPrimitives(
request.PrimitiveType,
0,
0,
pc,
matrices.Count);
}
#endif
}
else
{
// If there's less than 5 instances, just push the draw calls to the GPU.
if (_requestInstances[kv.Key].Count <= 5 || !request.SupportsComputingInstancesToCustomBuffers)
{
renderContext.GraphicsDevice.SetVertexBuffer(request.MeshVertexBuffer);
foreach (var instance in _requestInstances[kv.Key])
{
request.Effect.NativeEffect.Parameters["World"]?.SetValue(instance);
foreach (var pass in request.Effect.NativeEffect.Techniques[request.TechniqueName].Passes)
{
pass.Apply();
LastApplyCount++;
renderContext.GraphicsDevice.DrawIndexedPrimitives(
request.PrimitiveType,
0,
0,
pc);
}
}
}
else
{
var buffersNeedComputing = false;
var vertexBuffer = _renderAutoCache.AutoCache("renderbatcher-" + kv.Key, new object[]
{
_requestInstances[kv.Key].Count,
request.MeshVertexBuffer.VertexCount,
request.MeshVertexBuffer.VertexDeclaration
}, gameContext, () =>
{
buffersNeedComputing = true;
return(new VertexBuffer(
renderContext.GraphicsDevice,
request.MeshVertexBuffer.VertexDeclaration,
_requestInstances[kv.Key].Count * request.MeshVertexBuffer.VertexCount,
BufferUsage.WriteOnly));
});
var indexBuffer = _renderAutoCache.AutoCache("renderbatcher-" + kv.Key, new object[]
{
_requestInstances[kv.Key].Count,
request.MeshVertexBuffer.VertexCount,
}, gameContext, () =>
{
buffersNeedComputing = true;
return(new IndexBuffer(
renderContext.GraphicsDevice,
IndexElementSize.ThirtyTwoBits,
_requestInstances[kv.Key].Count * request.MeshIndexBuffer.IndexCount,
BufferUsage.WriteOnly));
});
if (buffersNeedComputing)
{
// Compute a pre-transformed vertex and index buffer for rendering.
request.ComputeInstancesToCustomBuffers(
_requestInstances[kv.Key],
vertexBuffer,
indexBuffer);
}
renderContext.GraphicsDevice.SetVertexBuffer(vertexBuffer);
renderContext.GraphicsDevice.Indices = indexBuffer;
request.Effect.NativeEffect.Parameters["World"]?.SetValue(Matrix.Identity);
foreach (
var pass in
request.Effect.NativeEffect.Techniques[request.TechniqueName].Passes
)
{
pass.Apply();
renderContext.GraphicsDevice.DrawIndexedPrimitives(
request.PrimitiveType,
0,
0,
pc * _requestInstances[kv.Key].Count);
}
}
}
_requestInstances[kv.Key].Clear();
}
_requestLookup.Clear();
_requestInstances.Clear();
}
}
}
