private void RenderOthers(List <RenderCore> list, RenderType filter, IRenderContext context, IDeviceContextPool deviceContextPool,
ref RenderParameter parameter,
CommandList[] commandsArray, int idx)
{
var deviceContext = deviceContextPool.Get();
SetRenderTargets(deviceContext, ref parameter);
bool hasValue = false;
for (int i = 0; i < list.Count; ++i)
{
if (list[i].RenderType == filter)
{
list[i].Render(context, deviceContext);
hasValue = true;
}
}
if (hasValue)
{
commandsArray[idx] = deviceContext.DeviceContext.FinishCommandList(true);
}
else
{
commandsArray[idx] = null;
}
deviceContextPool.Put(deviceContext);
}
/// <summary>
/// Sets the render targets.
/// </summary>
/// <param name="parameter">The parameter.</param>
public void SetRenderTargets(ref RenderParameter parameter)
{
ImmediateContext.SetRenderTargets(parameter.DepthStencilView, parameter.RenderTargetView);
ImmediateContext.SetViewport(ref parameter.ViewportRegion);
ImmediateContext.SetScissorRectangle(parameter.ScissorRegion.Left, parameter.ScissorRegion.Top,
parameter.ScissorRegion.Right, parameter.ScissorRegion.Bottom);
}
/// <summary>
/// Renders the scene.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
public override void RenderScene(IRenderContext context, List <RenderCore> renderables, ref RenderParameter parameter)
{
if (scheduler.ScheduleAndRun(renderables, deferredContextPool, context, parameter, RenderType.Opaque, commandList))
{
RenderParameter param = parameter;
renderOthersTask = Task.Run(() =>
{
RenderOthers(renderables, RenderType.Particle, context, deferredContextPool, ref param, postCommandList, 0);
RenderOthers(renderables, RenderType.Transparent, context, deferredContextPool, ref param, postCommandList, 1);
});
foreach (var command in commandList.OrderBy(x => x.Key))
{
ImmediateContext.DeviceContext.ExecuteCommandList(command.Value, true);
command.Value.Dispose();
}
commandList.Clear();
renderOthersTask.Wait();
renderOthersTask = null;
for (int i = 0; i < postCommandList.Length; ++i)
{
if (postCommandList[i] != null)
{
ImmediateContext.DeviceContext.ExecuteCommandList(postCommandList[i], true);
RemoveAndDispose(ref postCommandList[i]);
}
}
}
else
{
base.RenderScene(context, renderables, ref parameter);
}
}
/// <summary>
/// Renders the scene.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="testFrustum"></param>
/// <returns>Number of node has been rendered</returns>
public virtual int RenderOpaque(RenderContext context, FastList <SceneNode> renderables,
ref RenderParameter parameter, bool testFrustum)
{
var renderedCount = 0;
var count = renderables.Count;
var frustum = context.BoundingFrustum;
if (!testFrustum)
{
for (var i = 0; i < count; ++i)
{
renderables[i].Render(context, ImmediateContext);
++renderedCount;
}
}
else
{
for (var i = 0; i < count; ++i)
{
if (!renderables[i].TestViewFrustum(ref frustum))
{
continue;
}
renderables[i].Render(context, ImmediateContext);
++renderedCount;
}
}
return(renderedCount);
}
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <param name="pool"></param>
/// <param name="context"></param>
/// <param name="parameter"></param>
/// <param name="filterType"></param>
/// <param name="outputCommands"></param>
/// <returns></returns>
public bool ScheduleAndRun(List <RenderCore> items, IDeviceContextPool pool,
IRenderContext context, RenderParameter parameter, RenderType filterType, List <KeyValuePair <int, CommandList> > outputCommands)
{
outputCommands.Clear();
if (items.Count > schedulerParams.MinimumDrawCalls)
{
var partitionParams = Partitioner.Create(0, items.Count, items.Count / schedulerParams.MaxNumberOfTasks + 1);
Parallel.ForEach(partitionParams, (range, state) =>
{
var deferred = pool.Get();
SetRenderTargets(deferred, ref parameter);
for (int i = range.Item1; i < range.Item2; ++i)
{
if (items[i].RenderType == filterType)
{
items[i].Render(context, deferred);
}
}
var command = deferred.DeviceContext.FinishCommandList(true);
pool.Put(deferred);
lock (outputCommands)
{
outputCommands.Add(new KeyValuePair <int, CommandList>(range.Item1, command));
}
});
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// <see cref="DX11RenderHostBase.OnRender(TimeSpan)"/>
/// </summary>
/// <param name="time">The time.</param>
protected override void OnRender(TimeSpan time)
{
var renderParameter = new RenderParameter()
{
RenderTargetView = RenderTargetBufferView,
DepthStencilView = DepthStencilBufferView,
ScissorRegion = new Rectangle(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
ViewportRegion = new ViewportF(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
RenderLight = RenderConfiguration.RenderLights,
UpdatePerFrameData = RenderConfiguration.UpdatePerFrameData
};
renderer.SetRenderTargets(ref renderParameter);
renderer.UpdateGlobalVariables(RenderContext, lightNodes, ref renderParameter);
renderer.RenderPreProc(RenderContext, preProcNodes, ref renderParameter);
numRendered += renderer.RenderOpaque(RenderContext, opaqueNodes, ref renderParameter);
numRendered += renderer.RenderOpaque(RenderContext, particleNodes, ref renderParameter);
numRendered += renderer.RenderTransparent(RenderContext, transparentNodes, ref renderParameter);
getPostEffectCoreTask?.Wait();
getPostEffectCoreTask = null;
renderer.RenderPostProc(RenderContext, postProcNodes, ref renderParameter);
renderer.RenderPostProc(RenderContext, screenSpacedNodes, ref renderParameter);
numRendered += preProcNodes.Count + postProcNodes.Count + screenSpacedNodes.Count;
renderer.RenderToBackBuffer(RenderContext, ref renderParameter);
}
private void SetRenderTargets(DeviceContextProxy context, ref RenderParameter parameter)
{
context.SetRenderTargets(parameter.DepthStencilView, parameter.RenderTargetView);
context.SetViewport(ref parameter.ViewportRegion);
context.SetScissorRectangle(parameter.ScissorRegion.Left, parameter.ScissorRegion.Top,
parameter.ScissorRegion.Right, parameter.ScissorRegion.Bottom);
}
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <param name="pool"></param>
/// <param name="context"></param>
/// <param name="parameter"></param>
/// <param name="outputCommands"></param>
/// <param name="numRendered"></param>
/// <returns></returns>
public bool ScheduleAndRun(List <SceneNode> items, IDeviceContextPool pool,
RenderContext context, RenderParameter parameter, List <KeyValuePair <int, CommandList> > outputCommands, out int numRendered)
{
outputCommands.Clear();
int totalCount = 0;
numRendered = 0;
Exception exception = null;
if (items.Count > schedulerParams.MinimumDrawCalls)
{
var frustum = context.BoundingFrustum;
var partitionParams = Partitioner.Create(0, items.Count, items.Count / schedulerParams.MaxNumberOfTasks + 1);
Parallel.ForEach(partitionParams, (range, state) =>
{
try
{
int counter = 0;
var deferred = pool.Get();
SetRenderTargets(deferred, ref parameter);
for (int i = range.Item1; i < range.Item2; ++i)
{
if (context.EnableBoundingFrustum && !items[i].TestViewFrustum(ref frustum))
{
continue;
}
items[i].RenderCore.Render(context, deferred);
++counter;
}
var command = deferred.FinishCommandList(true);
pool.Put(deferred);
lock (outputCommands)
{
outputCommands.Add(new KeyValuePair <int, CommandList>(range.Item1, command));
totalCount += counter;
}
}
catch (Exception ex)
{
exception = ex;
}
});
numRendered = totalCount;
if (exception != null)
{
throw exception;
}
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Renders to back buffer.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderToBackBuffer(RenderContext context, ref RenderParameter parameter)
{
var buffer = context.RenderHost.RenderBuffer;
if (parameter.IsMSAATexture)
{
ImmediateContext.ResolveSubresource(parameter.CurrentTargetTexture, 0, buffer.BackBuffer.Resource, 0, buffer.Format);
}
else
{
ImmediateContext.CopyResource(parameter.CurrentTargetTexture, buffer.BackBuffer.Resource);
}
}
/// <summary>
/// Renders to ping pong buffer.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderToPingPongBuffer(RenderContext context, ref RenderParameter parameter)
{
var buffer = context.RenderHost.RenderBuffer;
buffer.FullResPPBuffer.Initialize();
if (parameter.IsMSAATexture)
{
ImmediateContext.ResolveSubresource(parameter.CurrentTargetTexture, 0, buffer.FullResPPBuffer.CurrentTexture, 0, buffer.Format);
}
else
{
ImmediateContext.CopyResource(parameter.CurrentTargetTexture, buffer.FullResPPBuffer.CurrentTexture);
}
}
/// <summary>
/// Renders the screen spaced.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="start">Start index in renderables</param>
/// <param name="count">Number of renderables to render.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderScreenSpaced(RenderContext context, FastList <SceneNode> renderables, int start, int count,
ref RenderParameter parameter)
{
if (count > 0)
{
var buffer = context.RenderHost.RenderBuffer;
var depthStencilBuffer = parameter.IsMSAATexture ? buffer.DepthStencilBuffer : buffer.DepthStencilBufferNoMSAA;
ImmediateContext.SetRenderTargets(depthStencilBuffer, parameter.RenderTargetView);
for (var i = start; i < start + count; ++i)
{
renderables[i].Render(context, ImmediateContext);
}
}
}
/// <summary>
/// <see cref="DX11RenderHostBase.OnRender(TimeSpan)"/>
/// </summary>
/// <param name="time">The time.</param>
protected override void OnRender(TimeSpan time)
{
var renderParameter = new RenderParameter()
{
RenderTargetView = new global::SharpDX.Direct3D11.RenderTargetView[] { RenderTargetBufferView },
DepthStencilView = DepthStencilBufferView,
CurrentTargetTexture = RenderBuffer.ColorBuffer.Resource,
IsMSAATexture = RenderBuffer.ColorBufferSampleDesc.Count > 1,
ScissorRegion = new Rectangle(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
ViewportRegion = new ViewportF(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
RenderLight = RenderConfiguration.RenderLights,
UpdatePerFrameData = RenderConfiguration.UpdatePerFrameData
};
renderer.SetRenderTargets(ref renderParameter);
renderer.UpdateGlobalVariables(RenderContext, lightNodes, ref renderParameter);
for (int i = 0; i < needUpdateCores.Count; ++i)
{
needUpdateCores[i].Update(RenderContext, renderer.ImmediateContext);
}
renderer.RenderPreProc(RenderContext, preProcNodes, ref renderParameter);
numRendered += renderer.RenderOpaque(RenderContext, opaqueNodes, ref renderParameter);
numRendered += renderer.RenderOpaque(RenderContext, particleNodes, ref renderParameter);
numRendered += renderer.RenderTransparent(RenderContext, transparentNodes, ref renderParameter);
getPostEffectCoreTask?.Wait();
getPostEffectCoreTask = null;
if (RenderConfiguration.FXAALevel != FXAALevel.None || postProcNodes.Count > 0)
{
renderer.RenderToPingPongBuffer(RenderContext, ref renderParameter);
renderParameter.IsMSAATexture = false;
renderer.RenderPostProc(RenderContext, postProcNodes, ref renderParameter);
renderParameter.CurrentTargetTexture = RenderBuffer.FullResPPBuffer.CurrentTexture;
renderParameter.RenderTargetView = new global::SharpDX.Direct3D11.RenderTargetView[] { RenderBuffer.FullResPPBuffer.CurrentRTV };
}
renderer.RenderScreenSpaced(RenderContext, screenSpacedNodes, ref renderParameter);
renderer.RenderToBackBuffer(RenderContext, ref renderParameter);
numRendered += preProcNodes.Count + postProcNodes.Count + screenSpacedNodes.Count;
if (ShowRenderDetail != RenderDetail.None)
{
getTriangleCountTask?.Wait();
renderStatistics.NumModel3D = perFrameFlattenedScene.Count;
renderStatistics.NumCore3D = numRendered;
}
}
/// <summary>
/// Renders the scene.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
/// <returns>Number of node has been rendered</returns>
public override int RenderOpaque(RenderContext context, List <SceneNode> renderables, ref RenderParameter parameter)
{
if (scheduler.ScheduleAndRun(renderables, deferredContextPool, context, parameter, commandList, out int counter))
{
RenderParameter param = parameter;
foreach (var command in commandList.OrderBy(x => x.Key))
{
ImmediateContext.ExecuteCommandList(command.Value, true);
command.Value.Dispose();
}
commandList.Clear();
return(counter);
}
else
{
return(base.RenderOpaque(context, renderables, ref parameter));
}
}
/// <summary>
/// Renders the screen spaced.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="start">Start index in renderables</param>
/// <param name="count">Number of renderables to render.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderScreenSpaced(RenderContext context, FastList <SceneNode> renderables, int start, int count,
ref RenderParameter parameter)
{
if (count > 0)
{
var hasMSAA = context.RenderHost.RenderBuffer.ColorBufferSampleDesc.Count == 1;
var buffer = context.RenderHost.RenderBuffer;
var depthStencilBuffer = hasMSAA ? buffer.DepthStencilBuffer : context.GetOffScreenDS(OffScreenTextureSize.Full, Format.D32_Float_S8X24_UInt);
ImmediateContext.SetRenderTargets(depthStencilBuffer, parameter.RenderTargetView);
for (var i = start; i < start + count; ++i)
{
renderables[i].Render(context, ImmediateContext);
}
if (!hasMSAA)
{
depthStencilBuffer.Dispose();
}
}
}
/// <summary>
/// Renders to back buffer.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderToBackBuffer(RenderContext context, ref RenderParameter parameter)
{
if (context.RenderHost.FeatureLevel >= global::SharpDX.Direct3D.FeatureLevel.Level_11_0 &&
context.RenderHost.RenderConfiguration.FXAALevel != FXAALevel.None)
{
postFXAACore.FXAALevel = context.RenderHost.RenderConfiguration.FXAALevel;
postFXAACore.Render(context, ImmediateContext);
}
ImmediateContext.Flush();
var buffer = context.RenderHost.RenderBuffer;
if (parameter.IsMSAATexture)
{
ImmediateContext.ResolveSubresource(parameter.CurrentTargetTexture, 0, buffer.BackBuffer.Resource, 0, buffer.Format);
}
else
{
ImmediateContext.CopyResource(parameter.CurrentTargetTexture, buffer.BackBuffer.Resource);
}
}
private void menuFileExport_Click(object sender, EventArgs e)
{
if (mesh != null)
{
FormExport export = new FormExport();
string file = settings.OfdDirectory;
if (!file.EndsWith("\\"))
{
file += "\\";
}
file += settings.CurrentFile;
export.ImageName = Path.ChangeExtension(file, ".png");
if (export.ShowDialog() == DialogResult.OK)
{
int format = export.ImageFormat;
int size = export.ImageSize;
if (format == 1)
{
EpsImage eps = new EpsImage();
eps.Export(this.mesh, export.ImageName, size);
}
else if (format == 2)
{
SvgImage svg = new SvgImage();
svg.Export(this.mesh, export.ImageName, size);
}
else
{
RasterImage img = new RasterImage();
img.ColorScheme = RenderParameter.LightScheme();
img.Export(this.mesh, export.ImageName, size);
}
}
}
}
/// <summary>
/// <see cref="DX11RenderHostBase.OnRender(TimeSpan)"/>
/// </summary>
/// <param name="time">The time.</param>
protected override void OnRender(TimeSpan time)
{
var renderParameter = new RenderParameter()
{
RenderTargetView = RenderTargetBufferView,
DepthStencilView = DepthStencilBufferView,
ScissorRegion = new Rectangle(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
ViewportRegion = new ViewportF(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
RenderLight = RenderConfiguration.RenderLights,
UpdatePerFrameData = RenderConfiguration.UpdatePerFrameData
};
renderer.SetRenderTargets(ref renderParameter);
renderer.UpdateGlobalVariables(RenderContext, lightRenderables, ref renderParameter);
renderer.RenderPreProc(RenderContext, preProcRenderCores, ref renderParameter);
renderer.RenderScene(RenderContext, generalRenderCores, ref renderParameter);
getPostEffectCoreTask?.Wait();
getPostEffectCoreTask = null;
renderer.RenderPostProc(RenderContext, postProcRenderCores, ref renderParameter);
renderer.RenderPostProc(RenderContext, screenSpacedRenderCores, ref renderParameter);
}
public virtual void RenderToBackBuffer(RenderContext context, ref RenderParameter parameter)
{
var buffer = context.RenderHost.RenderBuffer;
if (context.RenderHost.RenderConfiguration.FXAALevel == FXAALevel.None || buffer.ColorBufferSampleDesc.Count > 1)
{
ImmediateContext.DeviceContext.Flush();
switch (buffer.ColorBufferSampleDesc.Count)
{
case 1:
ImmediateContext.DeviceContext.CopyResource(buffer.ColorBuffer.Resource, buffer.BackBuffer.Resource);
break;
default:
ImmediateContext.DeviceContext.ResolveSubresource(buffer.ColorBuffer.Resource, 0, buffer.BackBuffer.Resource, 0, Format.B8G8R8A8_UNorm);
break;
}
}
else
{
postFXAACore.FXAALevel = context.RenderHost.RenderConfiguration.FXAALevel;
postFXAACore.Render(context, ImmediateContext);
}
}
/// <summary>
/// Renders to ping pong buffer.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderToPingPongBuffer(RenderContext context, ref RenderParameter parameter)
{
var buffer = context.RenderHost.RenderBuffer;
buffer.FullResPPBuffer.Initialize();
if (context.RenderHost.FeatureLevel < global::SharpDX.Direct3D.FeatureLevel.Level_11_0 ||
context.RenderHost.RenderConfiguration.FXAALevel == FXAALevel.None || parameter.IsMSAATexture)
{
if (parameter.IsMSAATexture)
{
ImmediateContext.ResolveSubresource(parameter.CurrentTargetTexture, 0, buffer.FullResPPBuffer.CurrentTexture, 0, buffer.Format);
}
else
{
ImmediateContext.CopyResource(parameter.CurrentTargetTexture, buffer.FullResPPBuffer.CurrentTexture);
}
}
else
{
ImmediateContext.CopyResource(parameter.CurrentTargetTexture, buffer.FullResPPBuffer.CurrentTexture);
postFXAACore.FXAALevel = context.RenderHost.RenderConfiguration.FXAALevel;
postFXAACore.Render(context, ImmediateContext);
}
}
/// <summary>
/// <see cref="DX11RenderHostBase.OnRender(TimeSpan)"/>
/// </summary>
/// <param name="time">The time.</param>
protected override void OnRender(TimeSpan time)
{
var renderParameter = new RenderParameter()
{
RenderTargetView = new global::SharpDX.Direct3D11.RenderTargetView[] { RenderTargetBufferView },
DepthStencilView = DepthStencilBufferView,
CurrentTargetTexture = RenderBuffer.ColorBuffer.Resource,
IsMSAATexture = RenderBuffer.ColorBufferSampleDesc.Count > 1,
ScissorRegion = new Rectangle(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
ViewportRegion = new ViewportF(0, 0, RenderBuffer.TargetWidth, RenderBuffer.TargetHeight),
RenderLight = RenderConfiguration.RenderLights,
UpdatePerFrameData = RenderConfiguration.UpdatePerFrameData
};
renderer.SetRenderTargets(ref renderParameter);
renderer.UpdateGlobalVariables(RenderContext, lightNodes, ref renderParameter);
for (var i = 0; i < needUpdateCores.Count; ++i)
{
needUpdateCores[i].Update(RenderContext, renderer.ImmediateContext);
}
renderer.RenderPreProc(RenderContext, preProcNodes, ref renderParameter);
numRendered += renderer.RenderOpaque(RenderContext, opaqueNodesInFrustum, ref renderParameter, false);
numRendered += renderer.RenderOpaque(RenderContext, particleNodes, ref renderParameter, true);
numRendered += renderer.RenderTransparent(RenderContext, transparentNodesInFrustum, ref renderParameter);
getPostEffectCoreTask?.Wait();
getPostEffectCoreTask = null;
if (RenderConfiguration.FXAALevel != FXAALevel.None ||
postEffectNodes.Count > 0 || globalEffectNodes.Count > 0)
{
renderer.RenderToPingPongBuffer(RenderContext, ref renderParameter);
renderParameter.IsMSAATexture = false;
renderParameter.CurrentTargetTexture = RenderBuffer.FullResPPBuffer.CurrentTexture;
renderParameter.RenderTargetView[0] = RenderBuffer.FullResPPBuffer.CurrentRTV;
}
if (postEffectNodes.Count > 0)
{
renderer.RenderPostProc(RenderContext, postEffectNodes, ref renderParameter);
renderParameter.CurrentTargetTexture = RenderBuffer.FullResPPBuffer.CurrentTexture;
renderParameter.RenderTargetView[0] = RenderBuffer.FullResPPBuffer.CurrentRTV;
}
if (globalEffectNodes.Count > 0)
{
renderer.RenderPostProc(RenderContext, globalEffectNodes, ref renderParameter);
renderParameter.CurrentTargetTexture = RenderBuffer.FullResPPBuffer.CurrentTexture;
renderParameter.RenderTargetView[0] = RenderBuffer.FullResPPBuffer.CurrentRTV;
}
if (screenSpacedNodes.Count > 0)
{
var start = 0;
while (start < screenSpacedNodes.Count)
{
if (screenSpacedNodes[start].AffectsGlobalVariable)
{
nodesWithPostEffect.Clear();
var i = start + 1;
for (; i < screenSpacedNodes.Count; ++i)
{
if (screenSpacedNodes[i].AffectsGlobalVariable)
{
break;
}
if (screenSpacedNodes[i].HasAnyPostEffect)
{
nodesWithPostEffect.Add(screenSpacedNodes[i]);
}
}
renderer.RenderScreenSpaced(RenderContext, screenSpacedNodes, start, i - start, ref renderParameter);
renderer.RenderPostProc(RenderContext, postEffectNodes, ref renderParameter);
RenderContext.RestoreGlobalTransform();
start = i;
}
else
{
++start;
}
}
}
renderer.RenderToBackBuffer(RenderContext, ref renderParameter);
numRendered += preProcNodes.Count + postEffectNodes.Count + screenSpacedNodes.Count;
if (ShowRenderDetail != RenderDetail.None)
{
getTriangleCountTask?.Wait();
renderStatistics.NumModel3D = perFrameFlattenedScene.Count;
renderStatistics.NumCore3D = numRendered;
}
}
/// <summary>
/// Renders the scene.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
/// <returns>Number of node has been rendered</returns>
public virtual int RenderOpaque(RenderContext context, List <SceneNode> renderables, ref RenderParameter parameter)
{
int renderedCount = 0;
int count = renderables.Count;
var frustum = context.BoundingFrustum;
for (int i = 0; i < count; ++i)
{
if (context.EnableBoundingFrustum && !renderables[i].TestViewFrustum(ref frustum))
{
continue;
}
renderables[i].RenderCore.Render(context, ImmediateContext);
++renderedCount;
}
return(renderedCount);
}
/// <summary>
/// Renders the screenspaced node's post proc.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="screenSpacedWithPostEffects"></param>
/// <param name="nodesWithPostEffects"></param>
/// <param name="postProcNodes"></param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderScreenSpacedPostProc(RenderContext context,
FastList <SceneNode> screenSpacedWithPostEffects,
FastList <SceneNode> nodesWithPostEffects,
FastList <SceneNode> postProcNodes, ref RenderParameter parameter)
{
var i = 0;
while (i < screenSpacedWithPostEffects.Count)
{
if (screenSpacedWithPostEffects[i].AffectsGlobalVariable)
{
context.RestoreGlobalTransform();
screenSpacedWithPostEffects[i].Render(context, ImmediateContext);
nodesWithPostEffects.Clear();
while (++i < screenSpacedWithPostEffects.Count &&
!screenSpacedWithPostEffects[i].AffectsGlobalVariable)
{
nodesWithPostEffects.Add(screenSpacedWithPostEffects[i]);
}
RenderPostProc(context, postProcNodes, ref parameter);
continue;
}
++i;
}
}
/// <summary>
/// Renders the post proc.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderPostProc(RenderContext context, FastList <SceneNode> renderables, ref RenderParameter parameter)
{
var count = renderables.Count;
for (var i = 0; i < count; ++i)
{
renderables[i].Render(context, ImmediateContext);
}
}
/// <summary>
/// Renders the pre proc.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderPreProc(RenderContext context, FastList <SceneNode> renderables, ref RenderParameter parameter)
{
var count = renderables.Count;
for (var i = 0; i < count; ++i)
{
renderables[i].Render(context, ImmediateContext);
}
if (context.SSAOEnabled)
{
preSSAOCore.Radius = context.RenderHost.RenderConfiguration.SSAORadius;
preSSAOCore.Quality = context.RenderHost.RenderConfiguration.SSAOQuality;
preSSAOCore.Render(context, ImmediateContext);
}
}
/// <summary>
/// Renders the pre proc.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderPreProc(RenderContext context, List <SceneNode> renderables, ref RenderParameter parameter)
{
int count = renderables.Count;
for (int i = 0; i < count; ++i)
{
renderables[i].RenderCore.Render(context, ImmediateContext);
}
}
/// <summary>
/// Renders the transparent.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
/// <returns></returns>
public virtual int RenderTransparent(RenderContext context, FastList <SceneNode> renderables, ref RenderParameter parameter)
{
if (renderables.Count == 0)
{
return(0);
}
if (context.RenderHost.RenderConfiguration.OITRenderType != OITRenderType.None &&
context.RenderHost.FeatureLevel >= global::SharpDX.Direct3D.FeatureLevel.Level_11_0)
{
switch (context.RenderHost.RenderConfiguration.OITRenderType)
{
case OITRenderType.SinglePassWeighted:
oitWeightedCore.ExternRenderParameter = parameter;
oitWeightedCore.Render(context, ImmediateContext);
return(oitWeightedCore.RenderCount);
case OITRenderType.DepthPeeling:
oitDepthPeelingCore.ExternRenderParameter = parameter;
oitDepthPeelingCore.PeelingIteration = context.OITDepthPeelingIteration;
oitDepthPeelingCore.Render(context, ImmediateContext);
return(oitDepthPeelingCore.RenderCount);
}
}
var renderedCount = 0;
var count = renderables.Count;
for (var i = 0; i < count; ++i)
{
renderables[i].Render(context, ImmediateContext);
++renderedCount;
}
return(renderedCount);
}
/// <summary>
/// Updates the global variables. Such as light buffer and global transformation buffer
/// </summary>
/// <param name="context">The context.</param>
/// <param name="lights">The lights.</param>
/// <param name="parameter">The parameter.</param>
public virtual void UpdateGlobalVariables(RenderContext context, FastList <SceneNode> lights, ref RenderParameter parameter)
{
ImmediateContext.Reset();
if (parameter.RenderLight)
{
context.LightScene.LightModels.ResetLightCount();
var count = lights.Count;
for (var i = 0; i < count && i < Constants.MaxLights; ++i)
{
lights[i].Render(context, ImmediateContext);
}
}
if (parameter.UpdatePerFrameData)
{
context.UpdatePerFrameData(ImmediateContext);
}
}
/// <summary>
/// Renders the screen spaced.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderScreenSpaced(RenderContext context, FastList <SceneNode> renderables, ref RenderParameter parameter)
{
int count = renderables.Count;
if (count > 0)
{
var buffer = context.RenderHost.RenderBuffer;
bool useDefault = parameter.RenderTargetView[0] == buffer.ColorBuffer.RenderTargetView;
var depthStencilBuffer = useDefault ? buffer.DepthStencilBuffer : context.GetOffScreenDS(OffScreenTextureSize.Full, Format.D32_Float_S8X24_UInt);
ImmediateContext.SetRenderTargets(depthStencilBuffer, parameter.RenderTargetView);
for (int i = 0; i < count; ++i)
{
renderables[i].Render(context, ImmediateContext);
}
if (!useDefault)
{
depthStencilBuffer.Dispose();
}
}
}
/// <summary>
/// Renders the transparent.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
/// <returns></returns>
public virtual int RenderTransparent(RenderContext context, FastList <SceneNode> renderables, ref RenderParameter parameter)
{
if (context.RenderHost.RenderConfiguration.EnableOITRendering &&
context.RenderHost.FeatureLevel >= global::SharpDX.Direct3D.FeatureLevel.Level_11_0)
{
transparentRenderCore.ExternRenderParameter = parameter;
transparentRenderCore.Render(context, ImmediateContext);
return(transparentRenderCore.RenderCount);
}
else
{
int renderedCount = 0;
var frustum = context.BoundingFrustum;
int count = renderables.Count;
for (int i = 0; i < count; ++i)
{
renderables[i].Render(context, ImmediateContext);
++renderedCount;
}
return(renderedCount);
}
}
/// <summary>
/// Renders the screen spaced.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="renderables">The renderables.</param>
/// <param name="parameter">The parameter.</param>
public virtual void RenderScreenSpaced(RenderContext context, List <SceneNode> renderables, ref RenderParameter parameter)
{
int count = renderables.Count;
if (count > 0)
{
var buffer = context.RenderHost.RenderBuffer;
bool useDefault = parameter.RenderTargetView[0] == buffer.ColorBuffer.RenderTargetView;
var depthStencilBuffer = useDefault ? buffer.DepthStencilBuffer : buffer.FullResDepthStencilPool.Get(Format.D32_Float_S8X24_UInt);
ImmediateContext.SetRenderTargets(depthStencilBuffer, parameter.RenderTargetView);
for (int i = 0; i < count; ++i)
{
renderables[i].RenderCore.Render(context, ImmediateContext);
}
if (!useDefault)
{
buffer.FullResDepthStencilPool.Put(Format.D32_Float_S8X24_UInt, depthStencilBuffer);
}
}
}
