public override void Render(RenderContext renderContext)
{
/// --- check to render the model
{
if (!this.IsRendering)
return;
if (this.Visibility != System.Windows.Visibility.Visible)
return;
//if (renderContext.IsShadowPass)
// if (!this.IsThrowingShadow)
// return;
}
foreach (var c in this.Children)
{
var model = c as ITransformable;
if (model != null)
{
// push matrix
model.PushMatrix(this.modelMatrix);
// render model
c.Render(renderContext);
// pop matrix
model.PopMatrix();
}
else
{
c.Render(renderContext);
}
}
}
public override void Render(RenderContext context)
{
if (renderHost.RenderTechnique == renderHost.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.Deferred) ||
renderHost.RenderTechnique == renderHost.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.GBuffer))
{
return;
}
if (this.IsRendering)
{
/// --- turn-on the light
lightColors[lightIndex] = this.Color;
}
else
{
// --- turn-off the light
lightColors[lightIndex] = new global::SharpDX.Color4(0, 0, 0, 0);
}
/// --- Set lighting parameters
lightPositions[lightIndex] = this.Position.ToVector4();
lightAtt[lightIndex] = new Vector4((float)this.Attenuation.X, (float)this.Attenuation.Y, (float)this.Attenuation.Z, (float)this.Range);
/// --- Update lighting variables
this.vLightPos.Set(lightPositions);
this.vLightColor.Set(lightColors);
this.vLightAtt.Set(lightAtt);
this.iLightType.Set(lightTypes);
}
public override void Render(RenderContext context)
{
base.Render(context);
foreach (var c in this.Children)
{
c.Render(context);
}
}
public override void Render(RenderContext renderContext)
{
/// --- check to render the model
{
if (!this.IsRendering)
return;
if (this.Geometry == null)
return;
if (this.Visibility != System.Windows.Visibility.Visible)
return;
if (renderContext.IsShadowPass)
if (!this.IsThrowingShadow)
return;
}
if (renderContext.Camera is ProjectionCamera)
{
var c = renderContext.Camera as ProjectionCamera;
var width = ((float)renderContext.Canvas.ActualWidth);
var height = ((float) renderContext.Canvas.ActualHeight);
var viewport = new Vector4(width, height, 0, 0);
this.vViewport.Set(ref viewport);
}
/// --- set constant paramerers
var worldMatrix = this.modelMatrix * renderContext.worldMatrix;
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- check shadowmaps
//this.hasShadowMap = this.renderHost.IsShadowMapEnabled;
//this.effectMaterial.bHasShadowMapVariable.Set(this.hasShadowMap);
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
/// --- set rasterstate
this.Device.ImmediateContext.Rasterizer.State = this.rasterState;
/// --- bind buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, BillboardVertex.SizeInBytes, 0));
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(Device.ImmediateContext);
/// --- draw
this.Device.ImmediateContext.Draw(Geometry.Positions.Count, 0);
}
public static SharpDX.RectangleF Project(this SharpDX.BoundingBox bounds, Helix.RenderContext context)
{
var corners = bounds.GetCorners();
for (int i = 0; i < corners.Length; i++)
{
corners[i] = SharpDX.Vector3.Project(corners[i], 0, 0, context.ActualWidth, context.ActualHeight, 0, 1, context.GlobalTransform.ViewProjection);
}
return(new SharpDX.RectangleF
{
Left = corners.Min(v => v.X),
Top = corners.Min(v => v.Y),
Right = corners.Max(v => v.X),
Bottom = corners.Max(v => v.Y),
});
}
public override void Render(RenderContext context)
{
var manager = renderHost.RenderTechniquesManager;
if (renderHost.RenderTechnique == manager.RenderTechniques.Get(DeferredRenderTechniqueNames.Deferred) ||
renderHost.RenderTechnique == manager.RenderTechniques.Get(DeferredRenderTechniqueNames.GBuffer))
{
return;
}
if (this.IsRendering)
{
/// --- set lighting parameters
lightColors[lightIndex] = this.Color;
}
else
{
// --- turn-off the light
lightColors[lightIndex] = new global::SharpDX.Color4(0, 0, 0, 0);
}
/// --- set lighting parameters
lightDirections[lightIndex] = -this.Direction.ToVector4();
/// --- update lighting variables
this.vLightDir.Set(lightDirections);
this.vLightColor.Set(lightColors);
this.iLightType.Set(lightTypes);
/// --- if shadow-map enabled
if (this.renderHost.IsShadowMapEnabled)
{
/// update shader
this.mLightView.SetMatrix(lightViewMatrices);
this.mLightProj.SetMatrix(lightProjMatrices);
}
}
public override void Render(RenderContext renderContext)
{
var position = this.totalModelMatrix.TranslationVector;
base.Render(renderContext);
}
/// <summary>
///
/// </summary>
public override void Render(RenderContext renderContext)
{
/// --- do not render, if not enabled
if (!this.IsRendering)
return;
if (this.Geometry == null)
return;
if (this.Visibility != System.Windows.Visibility.Visible)
return;
#if DEFERRED
if (renderHost.RenderTechnique == Techniques.RenderDeferred || renderHost.RenderTechnique == Techniques.RenderGBuffer)
return;
#endif
if (renderContext.IsShadowPass)
if (!this.IsThrowingShadow)
return;
/// --- since these values are changed only per window resize, we set them only once here
if (renderContext.Camera is ProjectionCamera)
{
var c = renderContext.Camera as ProjectionCamera;
// viewport: W,H,0,0
var viewport = new Vector4((float)renderContext.Canvas.ActualWidth, (float)renderContext.Canvas.ActualHeight, 0, 0);
var ar = viewport.X / viewport.Y;
this.vViewport.Set(ref viewport);
}
/// --- set transform paramerers
var worldMatrix = this.modelMatrix * renderContext.worldMatrix;
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- set effect per object const vars
var pointParams = new Vector4((float)this.Size.Width, (float)this.Size.Height, (float)this.Figure, (float)this.FigureRatio);
this.vPointParams.Set(pointParams);
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
/// --- set rasterstate
this.Device.ImmediateContext.Rasterizer.State = this.rasterState;
/// --- bind buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0,
new VertexBufferBinding(this.vertexBuffer, Geometry3D.PointsVertex.SizeInBytes, 0));
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(this.Device.ImmediateContext);
this.Device.ImmediateContext.Draw(this.Geometry.Positions.Count, 0);
}
public override void Render(RenderContext context)
{
#if DEFERRED
if (renderHost.RenderTechnique == Techniques.RenderDeferred || renderHost.RenderTechnique == Techniques.RenderGBuffer)
{
return;
}
#endif
if (this.IsRendering)
{
/// --- turn-on the light
lightColors[lightIndex] = this.Color;
}
else
{
// --- turn-off the light
lightColors[lightIndex] = new global::SharpDX.Color4(0, 0, 0, 0);
}
/// --- Set lighting parameters
lightPositions[lightIndex] = this.Position.ToVector4();
lightDirections[lightIndex] = this.Direction.ToVector4();
lightSpots[lightIndex] = new Vector4((float)Math.Cos(this.OuterAngle / 360.0 * Math.PI), (float)Math.Cos(this.InnerAngle / 360.0 * Math.PI), (float)this.Falloff, 0);
lightAtt[lightIndex] = new Vector4((float)this.Attenuation.X, (float)this.Attenuation.Y, (float)this.Attenuation.Z, (float)this.Range);
/// --- Update lighting variables
this.vLightPos.Set(lightPositions);
this.vLightDir.Set(lightDirections);
this.vLightSpot.Set(lightSpots);
this.vLightColor.Set(lightColors);
this.vLightAtt.Set(lightAtt);
this.iLightType.Set(lightTypes);
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void Render(RenderContext context)
{
foreach (var item in this.children)
{
var element = item as Element3D;
if (element != null)
{
if (!element.IsAttached)
{
element.Attach(this.renderHost);
}
var model = item as ITransformable;
if (model != null)
{
// push matrix
model.PushMatrix(this.modelMatrix);
// render model
element.Render(context);
// pop matrix
model.PopMatrix();
}
else
{
element.Render(context);
}
}
}
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void Render(RenderContext context)
{
base.Render(context);
// you mean like this?
foreach (var c in this.Children)
{
var model = c as ITransformable;
if (model != null)
{
// push matrix
model.PushMatrix(this.modelMatrix);
// render model
c.Render(context);
// pop matrix
model.PopMatrix();
}
else
{
c.Render(context);
}
}
}
/// <summary>
///
/// </summary>
public override void Render(RenderContext renderContext)
{
/// --- do not render, if not enabled
if (!this.IsRendering)
{
return;
}
if (this.Geometry == null)
{
return;
}
if (this.Visibility != System.Windows.Visibility.Visible)
{
return;
}
if (renderHost.RenderTechnique == renderHost.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.Deferred) ||
renderHost.RenderTechnique == renderHost.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.GBuffer))
{
return;
}
if (renderContext.IsShadowPass)
{
if (!this.IsThrowingShadow)
{
return;
}
}
/// --- since these values are changed only per window resize, we set them only once here
if (renderContext.Camera is ProjectionCamera)
{
var c = renderContext.Camera as ProjectionCamera;
// viewport: W,H,0,0
var viewport = new Vector4((float)renderContext.Canvas.ActualWidth, (float)renderContext.Canvas.ActualHeight, 0, 0);
var ar = viewport.X / viewport.Y;
this.vViewport.Set(ref viewport);
}
/// --- set transform paramerers
var worldMatrix = this.modelMatrix * renderContext.worldMatrix;
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- set effect per object const vars
var pointParams = new Vector4((float)this.Size.Width, (float)this.Size.Height, (float)this.Figure, (float)this.FigureRatio);
this.vPointParams.Set(pointParams);
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
/// --- set rasterstate
this.Device.ImmediateContext.Rasterizer.State = this.rasterState;
/// --- bind buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0,
new VertexBufferBinding(this.vertexBuffer, VertexSizeInBytes, 0));
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(this.Device.ImmediateContext);
this.Device.ImmediateContext.Draw(this.Geometry.Positions.Count, 0);
}
public override void Render(RenderContext renderContext)
{
/// --- check to render the model
{
if (!this.IsRendering)
{
return;
}
if (this.Geometry == null)
{
return;
}
if (this.Visibility != System.Windows.Visibility.Visible)
{
return;
}
if (renderContext.IsShadowPass)
{
if (!this.IsThrowingShadow)
{
return;
}
}
}
if (renderContext.Camera is ProjectionCamera)
{
var c = renderContext.Camera as ProjectionCamera;
var width = ((float)renderContext.Canvas.ActualWidth);
var height = ((float)renderContext.Canvas.ActualHeight);
var viewport = new Vector4(width, height, 0, 0);
this.vViewport.Set(ref viewport);
}
/// --- set constant paramerers
var worldMatrix = this.modelMatrix * renderContext.worldMatrix;
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- check shadowmaps
//this.hasShadowMap = this.renderHost.IsShadowMapEnabled;
//this.effectMaterial.bHasShadowMapVariable.Set(this.hasShadowMap);
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
/// --- set rasterstate
this.Device.ImmediateContext.Rasterizer.State = this.rasterState;
/// --- bind buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, BillboardVertex.SizeInBytes, 0));
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(Device.ImmediateContext);
/// --- draw
this.Device.ImmediateContext.Draw(Geometry.Positions.Count, 0);
}
/// <summary>
///
/// </summary>
public override void Render(RenderContext renderContext)
{
/// --- do not render, if not enabled
if (!this.IsRendering)
return;
if (this.Geometry == null)
return;
if (this.Visibility != System.Windows.Visibility.Visible)
return;
#if DEFERRED
if (renderHost.RenderTechnique == Techniques.RenderDeferred || renderHost.RenderTechnique == Techniques.RenderGBuffer)
return;
#endif
if (renderContext.IsShadowPass)
if (!this.IsThrowingShadow)
return;
/// --- since these values are changed only per window resize, we set them only once here
//if (this.isResized || renderContext.Camera != this.lastCamera)
{
//this.isResized = false;
//this.lastCamera = renderContext.Camera;
if (renderContext.Camera is ProjectionCamera)
{
var c = renderContext.Camera as ProjectionCamera;
// viewport: W,H,0,0
var viewport = new Vector4((float)renderContext.Canvas.ActualWidth, (float)renderContext.Canvas.ActualHeight, 0, 0);
var ar = viewport.X / viewport.Y;
this.vViewport.Set(ref viewport);
// Actually, we don't really need vFrustum because we already know the depth of the projected line.
//var fov = 100.0; // this is a fake value, since the line shader does not use it!
//var zn = c.NearPlaneDistance > 0 ? c.NearPlaneDistance : 0.1;
//var zf = c.FarPlaneDistance + 0.0;
// frustum: FOV,AR,N,F
//var frustum = new Vector4((float)fov, (float)ar, (float)zn, (float)zf);
//this.vFrustum.Set(ref frustum);
}
}
/// --- set transform paramerers
var worldMatrix = this.modelMatrix * renderContext.worldMatrix;
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- set effect per object const vars
var lineParams = new Vector4((float)this.Thickness, (float)this.Smoothness, 0, 0);
this.vLineParams.Set(lineParams);
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.SetIndexBuffer(this.indexBuffer, Format.R32_UInt, 0);
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineList;
/// --- check instancing
this.hasInstances = (this.Instances != null)&&(this.Instances.Any());
this.bHasInstances.Set(this.hasInstances);
/// --- set rasterstate
this.Device.ImmediateContext.Rasterizer.State = this.rasterState;
if (this.hasInstances)
{
/// --- update instance buffer
if (this.isChanged)
{
this.instanceBuffer = Buffer.Create(this.Device, this.instanceArray, new BufferDescription(Matrix.SizeInBytes * this.instanceArray.Length, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0));
DataStream stream;
Device.ImmediateContext.MapSubresource(this.instanceBuffer, MapMode.WriteDiscard, global::SharpDX.Direct3D11.MapFlags.None, out stream);
stream.Position = 0;
stream.WriteRange(this.instanceArray, 0, this.instanceArray.Length);
Device.ImmediateContext.UnmapSubresource(this.instanceBuffer, 0);
stream.Dispose();
this.isChanged = false;
}
/// --- INSTANCING: need to set 2 buffers
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new[]
{
new VertexBufferBinding(this.vertexBuffer, LinesVertex.SizeInBytes, 0),
new VertexBufferBinding(this.instanceBuffer, Matrix.SizeInBytes, 0),
});
/// --- render the geometry
for (int i = 0; i < this.effectTechnique.Description.PassCount; i++)
{
this.effectTechnique.GetPassByIndex(i).Apply(Device.ImmediateContext);
this.Device.ImmediateContext.DrawIndexedInstanced(this.Geometry.Indices.Count, this.instanceArray.Length, 0, 0, 0);
}
}
else
{
/// --- bind buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, LinesVertex.SizeInBytes, 0));
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(this.Device.ImmediateContext);
this.Device.ImmediateContext.DrawIndexed(this.Geometry.Indices.Count, 0, 0);
}
}
/// <summary>
///
/// </summary>
public override void Render(RenderContext renderContext)
{
/// --- check if to render the model
{
if (!this.IsRendering)
return;
if (this.Geometry == null)
return;
if (this.Visibility != System.Windows.Visibility.Visible)
return;
if (renderContext.IsShadowPass)
if (!this.IsThrowingShadow)
return;
}
/// --- set model transform paramerers
this.effectTransforms.mWorld.SetMatrix(ref this.modelMatrix);
/// --- set material props
if (phongMaterial != null)
{
/// --- set material lighting-params
this.effectMaterial.vMaterialDiffuseVariable.Set(phongMaterial.DiffuseColor);
this.effectMaterial.vMaterialAmbientVariable.Set(phongMaterial.AmbientColor);
this.effectMaterial.vMaterialEmissiveVariable.Set(phongMaterial.EmissiveColor);
this.effectMaterial.vMaterialSpecularVariable.Set(phongMaterial.SpecularColor);
this.effectMaterial.vMaterialReflectVariable.Set(phongMaterial.ReflectiveColor);
this.effectMaterial.sMaterialShininessVariable.Set(phongMaterial.SpecularShininess);
/// --- set samplers boolean flags
this.effectMaterial.bHasDiffuseMapVariable.Set(phongMaterial.DiffuseMap != null && this.RenderDiffuseMap);
this.effectMaterial.bHasNormalMapVariable.Set(phongMaterial.NormalMap != null && this.RenderNormalMap);
this.effectMaterial.bHasDisplacementMapVariable.Set(phongMaterial.DisplacementMap != null && this.RenderDisplacementMap);
/// --- set samplers
if (phongMaterial.DiffuseMap != null)
{
this.effectMaterial.texDiffuseMapVariable.SetResource(this.texDiffuseMapView);
}
if (phongMaterial.NormalMap != null)
{
this.effectMaterial.texNormalMapVariable.SetResource(this.texNormalMapView);
}
if (phongMaterial.DisplacementMap != null)
{
this.effectMaterial.texDisplacementMapVariable.SetResource(this.texDisplacementMapView);
}
}
/// --- set primitive type
if (this.renderTechnique == Techniques.RenderPNTriangs)
{
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PatchListWith3ControlPoints;
}
else if (this.renderTechnique == Techniques.RenderPNQuads)
{
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PatchListWith4ControlPoints;
}
else
{
throw new System.Exception("Technique not supported by PatchGeometryModel3D");
}
/// --- set vertex layout
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
/// --- set index buffer
this.Device.ImmediateContext.InputAssembler.SetIndexBuffer(this.indexBuffer, Format.R32_UInt, 0);
/// --- set vertex buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, DefaultVertex.SizeInBytes, 0));
/// --- apply chosen pass
this.shaderPass.Apply(Device.ImmediateContext);
/// --- render the geometry
this.Device.ImmediateContext.DrawIndexed(this.Geometry.Indices.Count, 0, 0);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
public override void Render(RenderContext context)
{
foreach (var c in this.Children)
{
var model = c as ITransformable;
if (model != null)
{
// apply transform
model.Transform = this.Transform;
//model.PushMatrix(this.modelMatrix);
// render model
c.Render(context);
//model.PopMatrix();
}
else
{
c.Render(context);
}
}
}
public override void Render(RenderContext renderContext)
{
if (!IsRendering)
{
return;
}
if (Geometry == null)
{
return;
}
if (Visibility != Visibility.Visible)
{
return;
}
if (renderContext.IsShadowPass)
{
if (!IsThrowingShadow)
{
return;
}
}
/// --- set constant paramerers
var worldMatrix = modelMatrix * renderContext.WorldMatrix;
effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- check shadowmaps
hasShadowMap = renderHost.IsShadowMapEnabled;
effectMaterial.bHasShadowMapVariable.Set(hasShadowMap);
/// --- set material params
if (phongMaterial != null)
{
effectMaterial.vMaterialDiffuseVariable.Set(phongMaterial.DiffuseColor);
effectMaterial.vMaterialAmbientVariable.Set(phongMaterial.AmbientColor);
effectMaterial.vMaterialEmissiveVariable.Set(phongMaterial.EmissiveColor);
effectMaterial.vMaterialSpecularVariable.Set(phongMaterial.SpecularColor);
effectMaterial.vMaterialReflectVariable.Set(phongMaterial.ReflectiveColor);
effectMaterial.sMaterialShininessVariable.Set(phongMaterial.SpecularShininess);
/// --- has samples
effectMaterial.bHasDiffuseMapVariable.Set(phongMaterial.DiffuseMap != null);
effectMaterial.bHasNormalMapVariable.Set(phongMaterial.NormalMap != null);
/// --- set samplers
if (phongMaterial.DiffuseMap != null)
{
effectMaterial.texDiffuseMapVariable.SetResource(texDiffuseMapView);
}
if (phongMaterial.NormalMap != null)
{
effectMaterial.texNormalMapVariable.SetResource(texNormalMapView);
}
}
/// --- check instancing
hasInstances = (Instances != null) && (Instances.Any());
if (bHasInstances != null)
{
bHasInstances.Set(hasInstances);
}
/// --- set context
Device.ImmediateContext.InputAssembler.InputLayout = vertexLayout;
Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
Device.ImmediateContext.InputAssembler.SetIndexBuffer(indexBuffer, Format.R32_UInt, 0);
/// --- set rasterstate
Device.ImmediateContext.Rasterizer.State = rasterState;
if (hasInstances)
{
/// --- update instance buffer
if (isChanged)
{
instanceBuffer = Buffer.Create(Device, instanceArray, new BufferDescription(Matrix.SizeInBytes * instanceArray.Length, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0));
DataStream stream;
Device.ImmediateContext.MapSubresource(instanceBuffer, MapMode.WriteDiscard, MapFlags.None, out stream);
stream.Position = 0;
stream.WriteRange(instanceArray, 0, instanceArray.Length);
Device.ImmediateContext.UnmapSubresource(instanceBuffer, 0);
stream.Dispose();
isChanged = false;
}
/// --- INSTANCING: need to set 2 buffers
Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new[]
{
new VertexBufferBinding(vertexBuffer, DynamoMeshVertex.SizeInBytes, 0),
new VertexBufferBinding(instanceBuffer, Matrix.SizeInBytes, 0),
});
/// --- render the geometry
effectTechnique.GetPassByIndex(0).Apply(Device.ImmediateContext);
/// --- draw
Device.ImmediateContext.DrawIndexedInstanced(Geometry.Indices.Count, instanceArray.Length, 0, 0, 0);
}
else
{
/// --- bind buffer
Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, DynamoMeshVertex.SizeInBytes, 0));
/// --- render the geometry
effectTechnique.GetPassByIndex(0).Apply(Device.ImmediateContext);
/// --- draw
Device.ImmediateContext.DrawIndexed(Geometry.Indices.Count, 0, 0);
}
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public virtual void Render(RenderContext context)
{
foreach (var item in this.children)
{
var element = item as Element3D;
if (element != null)
{
//var model = item as ITransformable;
//if (model != null)
//{
// // push matrix
// model.PushMatrix(this.modelMatrix);
// // render model
// element.Render(context);
// // pop matrix
// model.PopMatrix();
//}
//else
if (!element.IsAttached)
{
element.Attach(this.renderHost);
}
{
element.Render(context);
}
}
}
}
/// <summary>
/// Renders the element in the specified context.
/// </summary>
/// <param name="context">The context.</param>
public virtual void Render(RenderContext context)
{
}
public override void Render(RenderContext context)
{
if (!this.renderHost.IsShadowMapEnabled)
{
return;
}
/// --- set rasterizes state here with proper shadow-bias, as depth-bias and slope-bias in the rasterizer
this.Device.ImmediateContext.Rasterizer.SetViewport(0, 0, width, height, 0.0f, 1.0f);
this.Device.ImmediateContext.OutputMerger.SetTargets(depthViewSM);
this.Device.ImmediateContext.ClearDepthStencilView(depthViewSM, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
var root = context.Canvas.Renderable.Items;
foreach (var item in root)
{
var light = item as Light3D;
if (light != null)
{
Camera lightCamera = null;
//if (light is PointLightBase3D)
//{
// var plight = (PointLightBase3D)light;
// lightCamera = new PerspectiveCamera()
// {
// Position = plight.Position,
// LookDirection = plight.Direction,
// UpDirection = Vector3.UnitY.ToVector3D(),
// };
//}
// else
if (light is DirectionalLight3D)
{
var dlight = (DirectionalLight3D)light;
var dir = light.Direction.Normalized();
var pos = -50 * light.Direction;
//lightCamera = new PerspectiveCamera()
//{
// LookDirection = dir.ToVector3D(),
// Position = (System.Windows.Media.Media3D.Point3D)(pos.ToVector3D()),
// UpDirection = Vector3.UnitZ.ToVector3D(),
// NearPlaneDistance = 1,
// FarPlaneDistance = 100,
// FieldOfView = 10,
//};
lightCamera = new OrthographicCamera()
{
LookDirection = dir.ToVector3D(),
Position = (System.Windows.Media.Media3D.Point3D)(pos.ToVector3D()),
UpDirection = Vector3.UnitZ.ToVector3D(),
Width = 100,
NearPlaneDistance = 1,
FarPlaneDistance = 500,
};
}
if (lightCamera != null)
{
var sceneCamera = context.Camera;
light.LightViewMatrix = CameraExtensions.GetViewMatrix(lightCamera);
light.LightProjectionMatrix = CameraExtensions.GetProjectionMatrix(lightCamera, context.Canvas.ActualWidth / context.Canvas.ActualHeight);
this.shadowPassContext.IsShadowPass = true;
this.shadowPassContext.Camera = lightCamera;
foreach (var e in root)
{
var smodel = e as IThrowingShadow;
if (smodel != null)
{
if (smodel.IsThrowingShadow)
{
var model = smodel as IRenderable;
model.Render(this.shadowPassContext);
}
}
}
context.Camera = sceneCamera;
}
}
}
this.texShadowMapVariable.SetResource(this.texShadowMapView);
//this.texShadowMapVariable.SetResource(this.texColorMapView);
this.vShadowMapInfoVariable.Set(new Vector4((float)this.Intensity, (float)this.FactorPCF, (float)this.Bias, 0));
this.vShadowMapSizeVariable.Set(new Vector2(width, height));
//System.Console.WriteLine("ShadowMap rendered!");
context.Canvas.SetDefaultRenderTargets();
}
public override void Attach(IRenderHost host)
{
this.width = (int)(Resolution.X + 0.5f); //faktor* oneK;
this.height = (int)(this.Resolution.Y + 0.5f); // faktor* oneK;
base.renderTechnique = Techniques.RenderColors;
base.Attach(host);
if (!host.IsShadowMapEnabled)
{
return;
}
// gen shadow map
this.depthBufferSM = new Texture2D(Device, new Texture2DDescription()
{
Format = Format.R32_Typeless, //!!!! because of depth and shader resource
//Format = global::SharpDX.DXGI.Format.B8G8R8A8_UNorm,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource, //!!!!
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
});
this.colorBufferSM = new Texture2D(this.Device, new Texture2DDescription
{
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.B8G8R8A8_UNorm,
Width = width,
Height = height,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
});
this.renderTargetSM = new RenderTargetView(this.Device, colorBufferSM)
{
};
this.depthViewSM = new DepthStencilView(Device, depthBufferSM, new DepthStencilViewDescription()
{
Format = Format.D32_Float,
Dimension = DepthStencilViewDimension.Texture2D,
Texture2D = new DepthStencilViewDescription.Texture2DResource()
{
MipSlice = 0
}
});
this.texShadowMapView = new ShaderResourceView(Device, depthBufferSM, new ShaderResourceViewDescription()
{
Format = Format.R32_Float,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource()
{
MipLevels = 1,
MostDetailedMip = 0,
}
}); //!!!!
this.texColorMapView = new ShaderResourceView(this.Device, colorBufferSM, new ShaderResourceViewDescription()
{
Format = Format.B8G8R8A8_UNorm,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource()
{
MipLevels = 1,
MostDetailedMip = 0,
}
});
this.texShadowMapVariable = effect.GetVariableByName("texShadowMap").AsShaderResource();
this.vShadowMapInfoVariable = effect.GetVariableByName("vShadowMapInfo").AsVector();
this.vShadowMapSizeVariable = effect.GetVariableByName("vShadowMapSize").AsVector();
this.shadowPassContext = new RenderContext((DPFCanvas)host, this.effect);
}
public override void Render(RenderContext context)
{
if (!this.IsRendering) return;
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = Direct3D.PrimitiveTopology.TriangleList;
this.Device.ImmediateContext.InputAssembler.SetIndexBuffer(this.indexBuffer, Format.R32_UInt, 0);
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, CubeVertex.SizeInBytes, 0));
this.Device.ImmediateContext.Rasterizer.State = rasterState;
this.Device.ImmediateContext.OutputMerger.DepthStencilState = depthStencilState;
/// --- set constant paramerers
var worldMatrix = Matrix.Translation(((PerspectiveCamera)context.Camera).Position.ToVector3());
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(Device.ImmediateContext);
this.Device.ImmediateContext.DrawIndexed(this.geometry.Indices.Count, 0, 0);
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void Render(RenderContext context)
{
if (!this.IsRendering)
return;
if (this.Visibility != System.Windows.Visibility.Visible)
return;
base.Render(context);
// you mean like this?
foreach (var c in this.Children)
{
var model = c as ITransformable;
if (model != null)
{
// push matrix
model.PushMatrix(this.modelMatrix);
// render model
c.Render(context);
// pop matrix
model.PopMatrix();
}
else
{
c.Render(context);
}
}
}
/// <summary>
///
/// </summary>
public override void Render(RenderContext renderContext)
{
/// --- check to render the model
{
if (!this.IsRendering)
return;
if (this.Geometry == null
|| this.Geometry.Positions == null || this.Geometry.Positions.Count == 0
|| this.Geometry.Indices == null || this.Geometry.Indices.Count == 0)
{ return; }
if (this.Visibility != System.Windows.Visibility.Visible)
return;
if (renderContext.IsShadowPass)
if (!this.IsThrowingShadow)
return;
}
/// --- set constant paramerers
var worldMatrix = this.modelMatrix * renderContext.worldMatrix;
this.effectTransforms.mWorld.SetMatrix(ref worldMatrix);
/// --- check shadowmaps
this.hasShadowMap = this.renderHost.IsShadowMapEnabled;
this.effectMaterial.bHasShadowMapVariable.Set(this.hasShadowMap);
/// --- set material params
if (phongMaterial != null)
{
this.effectMaterial.vMaterialDiffuseVariable.Set(phongMaterial.DiffuseColor);
this.effectMaterial.vMaterialAmbientVariable.Set(phongMaterial.AmbientColor);
this.effectMaterial.vMaterialEmissiveVariable.Set(phongMaterial.EmissiveColor);
this.effectMaterial.vMaterialSpecularVariable.Set(phongMaterial.SpecularColor);
this.effectMaterial.vMaterialReflectVariable.Set(phongMaterial.ReflectiveColor);
this.effectMaterial.sMaterialShininessVariable.Set(phongMaterial.SpecularShininess);
/// --- has samples
this.effectMaterial.bHasDiffuseMapVariable.Set(phongMaterial.DiffuseMap != null);
this.effectMaterial.bHasNormalMapVariable.Set(phongMaterial.NormalMap != null);
/// --- set samplers
if (phongMaterial.DiffuseMap != null)
{
this.effectMaterial.texDiffuseMapVariable.SetResource(this.texDiffuseMapView);
}
if (phongMaterial.NormalMap != null)
{
this.effectMaterial.texNormalMapVariable.SetResource(this.texNormalMapView);
}
}
/// --- check instancing
this.hasInstances = (this.Instances != null) && (this.Instances.Any());
if (this.bHasInstances != null)
{
this.bHasInstances.Set(this.hasInstances);
}
/// --- set context
this.Device.ImmediateContext.InputAssembler.InputLayout = this.vertexLayout;
this.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
this.Device.ImmediateContext.InputAssembler.SetIndexBuffer(this.indexBuffer, Format.R32_UInt, 0);
/// --- set rasterstate
this.Device.ImmediateContext.Rasterizer.State = this.rasterState;
if (this.hasInstances)
{
/// --- update instance buffer
if (this.isChanged)
{
this.instanceBuffer = Buffer.Create(this.Device, this.instanceArray, new BufferDescription(Matrix.SizeInBytes * this.instanceArray.Length, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0));
DataStream stream;
Device.ImmediateContext.MapSubresource(this.instanceBuffer, MapMode.WriteDiscard, global::SharpDX.Direct3D11.MapFlags.None, out stream);
stream.Position = 0;
stream.WriteRange(this.instanceArray, 0, this.instanceArray.Length);
Device.ImmediateContext.UnmapSubresource(this.instanceBuffer, 0);
stream.Dispose();
this.isChanged = false;
}
/// --- INSTANCING: need to set 2 buffers
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new[]
{
new VertexBufferBinding(this.vertexBuffer, VertexSizeInBytes, 0),
new VertexBufferBinding(this.instanceBuffer, Matrix.SizeInBytes, 0),
});
/// --- render the geometry
this.effectTechnique.GetPassByIndex(0).Apply(Device.ImmediateContext);
/// --- draw
this.Device.ImmediateContext.DrawIndexedInstanced(this.Geometry.Indices.Count, this.instanceArray.Length, 0, 0, 0);
}
else
{
/// --- bind buffer
this.Device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, VertexSizeInBytes, 0));
/// --- render the geometry
///
var pass = this.effectTechnique.GetPassByIndex(0);
pass.Apply(Device.ImmediateContext);
/// --- draw
this.Device.ImmediateContext.DrawIndexed(this.Geometry.Indices.Count, 0, 0);
}
}
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), deferredContext);
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);
}
}
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;
renderContext.DeviceContext = deferredContext;
// ---------------------------------------------------------------------------
// this part is per frame
// ---------------------------------------------------------------------------
if (EnableSharingModelMode && SharedModelContainer != null)
{
SharedModelContainer.CurrentRenderHost = this;
ClearRenderTarget();
}
else
{
SetDefaultRenderTargets(true);
}
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
}
}
