/// <summary>
/// Initializes a new instance of the <see cref="RenderContext"/> class.
/// </summary>
/// <param name="renderHost">The render host.</param>
public RenderContext(IRenderHost renderHost)
{
this.RenderHost = renderHost;
this.IsDeferredPass = false;
cbuffer = renderHost.EffectsManager.ConstantBufferPool.Register(DefaultBufferNames.GlobalTransformCB, GlobalTransformStruct.SizeInBytes);
LightScene = Collect(new Light3DSceneShared(renderHost.EffectsManager.ConstantBufferPool));
SharedResource = Collect(new ContextSharedResource());
OITWeightPower = 3;
OITWeightDepthSlope = 1;
OITWeightMode = OITWeightMode.Linear2;
}
/// <summary>
/// Called when [render].
/// </summary>
/// <param name="lightScene">The light scene.</param>
/// <param name="index">The index.</param>
protected override void OnRender(Light3DSceneShared lightScene, int index)
{
base.OnRender(lightScene, index);
lightScene.LightModels.Lights[index].LightDir = Vector3.TransformNormal(direction, ModelMatrix).Normalized().ToVector4(0);
lightScene.LightModels.Lights[index].LightSpot = new Vector4((float)Math.Cos(outerAngle / 360.0f * Math.PI), (float)Math.Cos(innerAngle / 360.0f * Math.PI), fallOff, 0);
}
/// <summary>
/// Called when [render].
/// </summary>
/// <param name="lightScene">The light scene.</param>
/// <param name="idx">The index.</param>
protected override void OnRender(Light3DSceneShared lightScene, int idx)
{
lightScene.LightModels.AmbientLight = Color;
}
/// <summary>
/// Called when [render].
/// </summary>
/// <param name="lightScene">The light scene.</param>
/// <param name="idx">The index.</param>
protected virtual void OnRender(Light3DSceneShared lightScene, int idx)
{
lightScene.LightModels.Lights[idx].LightColor = Color;
lightScene.LightModels.Lights[idx].LightType = (int)LightType;
}
/// <summary>
/// Determines whether this instance can render the specified light scene.
/// </summary>
/// <param name="lightScene">The light scene.</param>
/// <returns>
/// <c>true</c> if this instance can render the specified light scene; otherwise, <c>false</c>.
/// </returns>
protected virtual bool CanRender(Light3DSceneShared lightScene)
{
return(IsAttached && lightScene.LightModels.LightCount < Constants.MaxLights);
}
private void Render(TimeSpan timeStamp)
{
var device = this.device;
if (device == null)
{
return;
}
if (swapChain == null)
{
return;
}
if (renderRenderable != null)
{
// ---------------------------------------------------------------------------
// this part is done only if the scene is not attached
// it is an attach and init pass for all elements in the scene-graph
if (!sceneAttached)
{
try
{
Light3DSceneShared.Reset();
sceneAttached = true;
ClearColor = renderRenderable.BackgroundColor;
IsShadowMapEnabled = renderRenderable.IsShadowMappingEnabled;
RenderTechnique = renderRenderable.RenderTechnique == null ? RenderTechniquesManager?.RenderTechniques[DefaultRenderTechniqueNames.Blinn] : renderRenderable.RenderTechnique;
if (renderContext != null)
{
renderContext.Dispose();
}
renderContext = new RenderContext(this, EffectsManager.GetEffect(RenderTechnique), device.ImmediateContext);
renderContext.EnableBoundingFrustum = EnableRenderFrustum;
if (EnableSharingModelMode && SharedModelContainer != null)
{
SharedModelContainer.CurrentRenderHost = this;
renderRenderable.Attach(SharedModelContainer);
}
else
{
renderRenderable.Attach(this);
}
RenderTechniquesManager.RenderTechniques.TryGetValue(DeferredRenderTechniqueNames.GBuffer, out gbuffer);
RenderTechniquesManager.RenderTechniques.TryGetValue(DeferredRenderTechniqueNames.Deferred, out deferred);
if (RenderTechnique == deferred)
{
deferredRenderer.InitBuffers(this, Format.R32G32B32A32_Float);
}
else if (RenderTechnique == gbuffer)
{
deferredRenderer.InitBuffers(this, Format.B8G8R8A8_UNorm);
}
SetDefaultRenderTargets(false);
}
catch (Exception ex)
{
//MessageBox.Show("DPFCanvas: Error attaching element: " + string.Format(ex.Message), "Error");
Debug.WriteLine("DPFCanvas: Error attaching element: " + string.Format(ex.Message), "Error");
throw;
}
}
renderContext.TimeStamp = timeStamp;
// ---------------------------------------------------------------------------
// this part is per frame
// ---------------------------------------------------------------------------
if (EnableSharingModelMode && SharedModelContainer != null)
{
SharedModelContainer.CurrentRenderHost = this;
}
ClearRenderTarget();
if (RenderTechnique == deferred)
{
// set G-Buffer
deferredRenderer.SetGBufferTargets(renderContext);
// render G-Buffer pass
renderRenderable.Render(renderContext);
// call deferred render
deferredRenderer.RenderDeferred(renderContext, renderRenderable);
}
else if (RenderTechnique == gbuffer)
{
// set G-Buffer
deferredRenderer.SetGBufferTargets(targetWidth / 2, targetHeight / 2, renderContext);
// render G-Buffer pass
renderRenderable.Render(renderContext);
// reset render targets and run lighting pass
#if DoubleBuffer
deferredRenderer.RenderGBufferOutput(renderContext, ref backBuffer);
#else
this.deferredRenderer.RenderGBufferOutput(renderContext, ref this.backBuffer);
#endif
}
else
{
renderRenderable.Render(renderContext);
}
#if DoubleBuffer
device.ImmediateContext.ResolveSubresource(colorBuffer, 0, backBuffer, 0, Format.B8G8R8A8_UNorm);
#endif
}
}
protected override void OnRender(Light3DSceneShared lightScene, int index)
{
base.OnRender(lightScene, index);
lightScene.LightModels.Lights[index].LightDir = -Vector3.TransformNormal(direction, ModelMatrix).Normalized().ToVector4(0);
}
/// <summary>
/// Called when [render].
/// </summary>
/// <param name="lightScene">The light scene.</param>
/// <param name="index">The index.</param>
protected override void OnRender(Light3DSceneShared lightScene, int index)
{
base.OnRender(lightScene, index);
lightScene.LightModels.Lights[index].LightPos = (position + ModelMatrix.Row4.ToVector3()).ToVector4();
lightScene.LightModels.Lights[index].LightAtt = attenuation.ToVector4(range);
}
protected override bool OnAttach(IRenderHost host)
{
Light3DSceneShared = host.Light3DSceneShared;
return(base.OnAttach(host));
}
