protected void DefaultUpdateInputOutput(GraphicsDevice graphics, D3DRenderComponent render,
VertexLayoutConstructor layconst, DisposableSetter <InputLayout> inputLayout, RenderableComponent renderable)
{
var context = graphics.ImmediateContext;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(render.VertexBuffer.Get(),
layconst.VertexSize, 0));
context.InputAssembler.SetIndexBuffer(render.IndexBuffer.Get(), SharpDX.DXGI.Format.R32_UInt, 0);
context.InputAssembler.InputLayout = inputLayout.Get();
context.InputAssembler.PrimitiveTopology = renderable.PrimitiveTopology;
context.OutputMerger.SetDepthStencilState(render.DepthStencilState.Get(), 0);
context.OutputMerger.SetBlendState(render.BlendingState.Get(),
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
}
public void RenderEach(GraphicsDevice graphics, TProperties props, GraphicEntity en)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
if (!en.TryGetComponent <D3DRenderComponent>(out var render))
{
render = new D3DRenderComponent();
en.AddComponent(render);
}
var renderable = en.GetComponent <RenderableComponent>();
var color = en.GetComponent <MaterialColorComponent>();
var geo = ContextState.GetGeometryPool().GetGeometry <IGeometryData>(en);
if (!render.DepthStencilState.HasValue)
{
render.DepthStencilState.Set(new DepthStencilState(graphics.D3DDevice,
renderable.DepthStencilStateDefinition.Description));
}
if (!render.BlendingState.HasValue)
{
render.BlendingState.Set(new BlendState(graphics.D3DDevice, renderable.BlendStateDescription));
}
{
graphics.ClearAllShader();
context.VertexShader.Set(vertexShader.Get());
context.GeometryShader.Set(null);
context.PixelShader.Set(pixelShader.Get());
if (en.Contains <FlatShadingGeometryComponent>())
{
context.GeometryShader.Set(flatShadingGS.Get());
}
else if (en.Contains <WireframeGeometryComponent>())
{
context.GeometryShader.Set(wireframeGS.Get());
context.PixelShader.Set(wireframePS.Get());
}
}
var topology = renderable.PrimitiveTopology;
if (geo.IsModified || (!render.VertexBuffer.HasValue && !render.IndexBuffer.HasValue))
{
Vertex[] vertex = null;
switch (geo.Topology)
{
case GeometryPrimitiveTopologies.TriangleList:
topology = PrimitiveTopology.TriangleList;
vertex = new Vertex[geo.Positions.Length];
for (var index = 0; index < vertex.Length; index++)
{
vertex[index] = new Vertex(geo.Positions[index], geo.Normals[index]);
}
break;
}
render.VertexBuffer.Set(graphics.CreateBuffer(BindFlags.VertexBuffer, vertex));
render.IndexBuffer.Set(graphics.CreateBuffer(BindFlags.IndexBuffer, geo.Indices.ToArray()));
geo.IsModified = false;
}
if (!render.VertexBuffer.HasValue && !render.IndexBuffer.HasValue)
{
throw RenderTechniqueException.NoVertexAndIndexBuffers;
}
if (color.IsValid)
{
var material = MaterialStructBuffer.From(color);
if (render.MaterialBuffer.HasValue)
{
var buff = render.MaterialBuffer.Get();
graphics.UpdateDynamicBuffer(ref material, buff);
}
else
{
var buff = graphics.CreateDynamicBuffer(ref material, Unsafe.SizeOf <MaterialStructBuffer>());
render.MaterialBuffer.Set(buff);
}
}
UpdateTransformWorld(graphics, render, en);
if (!render.TransformWorldBuffer.HasValue)
{
throw RenderTechniqueException.NoWorldTransformBuffers;
}
{//Update constant buffers
context.VertexShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, props.Game);
context.VertexShader.SetConstantBuffer(TransforStructBuffer.RegisterResourceSlot, render.TransformWorldBuffer.Get());
context.PixelShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, props.Game);
context.PixelShader.SetConstantBuffer(LightStructBuffer.RegisterResourceSlot, props.Lights);
if (render.MaterialBuffer.HasValue)
{
context.PixelShader.SetConstantBuffer(MaterialStructBuffer.RegisterResourceSlot, render.MaterialBuffer.Get());
}
}
{
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(render.VertexBuffer.Get(),
layconst.VertexSize, 0));
context.InputAssembler.SetIndexBuffer(render.IndexBuffer.Get(), SharpDX.DXGI.Format.R32_UInt, 0);
context.InputAssembler.InputLayout = inputLayout.Get();
context.InputAssembler.PrimitiveTopology = topology;
context.OutputMerger.SetDepthStencilState(
render.DepthStencilState.Get(),
renderable.DepthStencilStateDefinition.StencilRef);
context.OutputMerger.SetBlendState(render.BlendingState.Get(),
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
}
var rasterizerDesc = renderable.RasterizerStateDescription;
using (var rasterizerState = graphics.CreateRasterizerState(rasterizerDesc)) {
context.Rasterizer.State = rasterizerState;
graphics.ImmediateContext.DrawIndexed(geo.Indices.Length, 0, 0);
}
}
protected override void Rendering(GraphicsDevice graphics, TProperties game)
{
var context = graphics.ImmediateContext;
var device = graphics.D3DDevice;
if (!VS_FS.IsCompiled)
{
VS_FS.Compile(graphics.Compilator);
var vertexShaderByteCode = VS_FS.VertexShader.ReadCompiledBytes();
var inputSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
inputLayout.Set(new InputLayout(device, inputSignature, layconst.ConstuctElements()));
vertexShader.Set(new VertexShader(device, vertexShaderByteCode));
pixelShader.Set(new PixelShader(device, VS_FS.PixelShader.ReadCompiledBytes()));
}
if (!GS_ScreenFixed.IsCompiled)
{
GS_ScreenFixed.Compile(graphics.Compilator);
gsScreenFixed.Set(new GeometryShader(device, GS_ScreenFixed.GeometryShader.ReadCompiledBytes()));
}
if (!GS_SizeFixed.IsCompiled)
{
GS_SizeFixed.Compile(graphics.Compilator);
gsSizeFixed.Set(new GeometryShader(device, GS_SizeFixed.GeometryShader.ReadCompiledBytes()));
}
foreach (var en in entities)
{
var renderable = en.GetComponent <RenderableComponent>();
var billboard = en.GetComponent <BillboardTextComponent>();
var transform = en.GetComponent <TransformComponent>();
if (!en.TryGetComponent <D3DRenderComponent>(out var render))
{
render = new D3DRenderComponent();
en.AddComponent(render);
}
if (!en.TryGetComponent <InternalBillboardRenderedTextComponent>(out var renderedText) ||
!renderedText.IsRendered(billboard))
{
renderedText = new InternalBillboardRenderedTextComponent();
renderedText.Render(billboard);
en.UpdateComponent(renderedText);
var image = renderedText.RenderedBitmapText;
var v = new Vertex()
{
Position = billboard.Position.ToVector4(),
ImageSize = new Vector3(
new Vector2(image.Width, image.Height) * renderedText.Scale,
0)
};
render.VertexBuffer.Set(graphics.CreateBuffer(BindFlags.VertexBuffer, new[] { v }));
render.TextureResources.Set(new[] { ConvertToResource(image, graphics.TexturedLoader) });
if (!render.SampleState.HasValue)
{
render.SampleState.Set(graphics.CreateSampler(SamplerStateDescriptions.Default));
}
}
if (!render.BlendingState.HasValue)
{
render.BlendingState.Set(new BlendState(graphics.D3DDevice, renderable.BlendStateDescription));
}
if (!render.DepthStencilState.HasValue)
{
render.DepthStencilState.Set(new DepthStencilState(graphics.D3DDevice,
renderable.DepthStencilStateDefinition.Description));
}
base.UpdateTransformWorld(graphics, render, en);
graphics.ClearAllShader();
{
context.VertexShader.Set(vertexShader.Get());
context.VertexShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, game.Game);
context.VertexShader.SetConstantBuffer(TransforStructBuffer.RegisterResourceSlot,
render.TransformWorldBuffer.Get());
switch (billboard.SizeMode)
{
case BillboardSizeModes.SceenFixed:
context.GeometryShader.Set(gsScreenFixed.Get());
break;
case BillboardSizeModes.SizeFixed:
context.GeometryShader.Set(gsSizeFixed.Get());
break;
}
context.GeometryShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, game.Game);
context.PixelShader.Set(pixelShader.Get());
context.PixelShader.SetShaderResources(0, render.TextureResources.Get());
context.PixelShader.SetSampler(0, render.SampleState.Get());
}
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(render.VertexBuffer.Get(),
layconst.VertexSize, 0));
context.InputAssembler.SetIndexBuffer(null, Format.R32_UInt, 0);
context.InputAssembler.InputLayout = inputLayout.Get();
context.InputAssembler.PrimitiveTopology = renderable.PrimitiveTopology;
context.OutputMerger.SetDepthStencilState(render.DepthStencilState.Get(), 0);
context.OutputMerger.SetBlendState(render.BlendingState.Get(),
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
using (var rasterizerState = graphics.CreateRasterizerState(renderable.RasterizerStateDescription)) {
context.Rasterizer.State = rasterizerState;
graphics.ImmediateContext.Draw(1, 0);
}
}
}
protected override void Rendering(GraphicsDevice graphics, TProperties game)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
if (!pass.IsCompiled)
{
pass.Compile(graphics.Compilator);
var vertexShaderByteCode = pass.VertexShader.ReadCompiledBytes();
inputLayout.Set(graphics.CreateInputLayout(vertexShaderByteCode, layconst.ConstuctElements()));
vertexShader.Set(new VertexShader(device, vertexShaderByteCode));
pixelShader.Set(new PixelShader(device, pass.PixelShader.ReadCompiledBytes()));
}
{ //clear shaders off prev. technique
graphics.ClearAllShader();
//all shaders shared for all entity with LineVertexRenderComponent
context.VertexShader.Set(vertexShader.Get());
context.PixelShader.Set(pixelShader.Get());
//Update constant buffers ones becase shaders will not changed
context.VertexShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, game.Game);
//shared for all entity
context.InputAssembler.InputLayout = inputLayout.Get();
}
foreach (var en in entities)
{
if (!en.TryGetComponent <D3DRenderComponent>(out var d3drender))
{
d3drender = new D3DRenderComponent();
en.AddComponent(d3drender);
}
en.TryGetComponent <ColorComponent>(out var color);
var renderable = en.GetComponent <RenderableComponent>();
var transform = en.GetComponent <TransformComponent>();
var geoId = en.GetComponent <GeometryPoolComponent>();
var geo = ContextState.GetGeometryPool().GetGeometry <IGeometryData>(geoId);
if (!d3drender.DepthStencilState.HasValue)
{
d3drender.DepthStencilState.Set(
new DepthStencilState(graphics.D3DDevice, renderable.DepthStencilStateDefinition.Description));
}
if (!d3drender.BlendingState.HasValue)
{
d3drender.BlendingState.Set(new BlendState(graphics.D3DDevice, renderable.BlendStateDescription));
}
UpdateTransformWorld(graphics, d3drender, en);
if (geo.IsModified)
{
var pos = geo.Positions;
var vertex = new Vertex[pos.Length];
for (var i = 0; i < pos.Length; i++)
{
var c = color.IsValid ? color.Color : geo.Colors[i];
vertex[i] = new Vertex(pos[i], c);
}
d3drender.VertexBuffer.Set(graphics.CreateBuffer(BindFlags.VertexBuffer, vertex));
geo.IsModified = false;
}
context.VertexShader.SetConstantBuffer(TransforStructBuffer.RegisterResourceSlot,
d3drender.TransformWorldBuffer.Get());
{
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(d3drender.VertexBuffer.Get(),
layconst.VertexSize, 0));
context.InputAssembler.PrimitiveTopology = renderable.PrimitiveTopology;
context.OutputMerger.SetDepthStencilState(d3drender.DepthStencilState.Get(), 0);
context.OutputMerger.SetBlendState(d3drender.BlendingState.Get(),
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
}
using (var rasterizerState = graphics.CreateRasterizerState(renderable.RasterizerStateDescription)) {
context.Rasterizer.State = rasterizerState;
context.Draw(geo.Positions.Length, 0);
}
}
}
public void RenderEach(GraphicsDevice graphics, TProperties game, GraphicEntity en)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
if (!en.TryGetComponent <D3DRenderComponent>(out var render))
{
render = new D3DRenderComponent();
en.AddComponent(render);
}
var renderable = en.GetComponent <RenderableComponent>();
var geo = ContextState.GetGeometryPool().GetGeometry <IGeometryData>(en);
//optional
var hasColor = en.TryGetComponent <MaterialColorComponent>(out var color);
var hasTexture = en.TryGetComponent <D3DTexturedMaterialSamplerComponent>(out var texture);
if (!render.DepthStencilState.HasValue)
{
render.DepthStencilState.Set(new DepthStencilState(graphics.D3DDevice,
renderable.DepthStencilStateDefinition.Description));
}
if (!render.BlendingState.HasValue)
{
render.BlendingState.Set(new BlendState(graphics.D3DDevice, renderable.BlendStateDescription));
}
UpdateTransformWorld(graphics, render, en);
if (geo.IsModified)
{
var vertex = new Vertex[geo.Positions.Length];
for (var index = 0; index < vertex.Length; index++)
{
vertex[index] = new Vertex(
geo.Positions[index], geo.Normals[index], geo.TexCoor[index]);
}
render.VertexBuffer.Set(graphics.CreateBuffer(BindFlags.VertexBuffer, vertex));
render.IndexBuffer.Set(graphics.CreateBuffer(BindFlags.IndexBuffer, geo.Indices.ToArray()));
geo.IsModified = false;
}
if (hasColor)
{
var material = MaterialStructBuffer.From(color);
if (render.MaterialBuffer.HasValue)
{
var buff = render.MaterialBuffer.Get();
graphics.UpdateDynamicBuffer(ref material, buff);
}
else
{
var buff = graphics.CreateDynamicBuffer(ref material, Unsafe.SizeOf <MaterialStructBuffer>());
render.MaterialBuffer.Set(buff);
}
}
if (hasTexture && texture.IsModified)
{
render.TextureResources.Set(ConvertToResources(texture, graphics.TexturedLoader));
render.SampleState.Set(graphics.CreateSampler(texture.SampleDescription));
texture.IsModified = false;
}
{
graphics.ClearAllShader();
context.VertexShader.Set(vertexShader.Get());
if (en.Contains <FlatShadingGeometryComponent>())
{
context.GeometryShader.Set(flatShadingGS.Get());
}
context.PixelShader.Set(pixelShader.Get());
context.VertexShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, game.Game);
context.VertexShader.SetConstantBuffer(TransforStructBuffer.RegisterResourceSlot,
render.TransformWorldBuffer.Get());
context.PixelShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, game.Game);
context.PixelShader.SetConstantBuffer(LightStructBuffer.RegisterResourceSlot, game.Lights);
if (render.MaterialBuffer.HasValue)
{
context.PixelShader.SetConstantBuffer(MaterialStructBuffer.RegisterResourceSlot,
render.MaterialBuffer.Get());
}
if (render.TextureResources.HasValue && render.SampleState.HasValue)
{
context.PixelShader.SetShaderResources(0, render.TextureResources.Get());
context.PixelShader.SetSampler(0, render.SampleState.Get());
}
}
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(render.VertexBuffer.Get(),
layconst.VertexSize, 0));
context.InputAssembler.SetIndexBuffer(render.IndexBuffer.Get(), SharpDX.DXGI.Format.R32_UInt, 0);
context.InputAssembler.InputLayout = inputLayout.Get();
context.InputAssembler.PrimitiveTopology = renderable.PrimitiveTopology;
context.OutputMerger.SetDepthStencilState(render.DepthStencilState.Get(), 0);
context.OutputMerger.SetBlendState(render.BlendingState.Get(),
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
using (var rasterizerState = graphics.CreateRasterizerState(renderable.RasterizerStateDescription)) {
context.Rasterizer.State = rasterizerState;
graphics.ImmediateContext.DrawIndexed(geo.Indices.Length, 0, 0);
}
}
void RenderingQuard(GraphicsDevice graphics, TProperties props)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
context.ResolveSubresource(colorTargetTex2D.Get(), 0, colorTargetNoMSAA.Get().Resource, 0, colorDesc.Format);
context.ResolveSubresource(alphaTargetTex2D.Get(), 0, alphaTargetNoMSAA.Get().Resource, 0, alphaDesc.Format);
context.VertexShader.Set(vertexShaderQuard.Get());
context.PixelShader.Set(pixelShaderQuard.Get());
context.PixelShader.SetShaderResources(10, new[] {
colorTargetNoMSAA.Get(), alphaTargetNoMSAA.Get()
});
context.PixelShader.SetSampler(0, targetSampler.Get());
var inputSignature = ShaderSignature.GetInputSignature(quardPass.VertexShader.ReadCompiledBytes());
context.InputAssembler.InputLayout = new InputLayout(device, inputSignature,
new[] { new InputElement("SV_VERTEXID", 0, Format.R32_UInt, 0) });
context.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleStrip;
var BSAlphaBlend = new BlendStateDescription();
BSAlphaBlend.RenderTarget[0] = new RenderTargetBlendDescription()
{
AlphaBlendOperation = BlendOperation.Add,
BlendOperation = BlendOperation.Add,
SourceBlend = BlendOption.SourceAlpha,
DestinationBlend = BlendOption.InverseSourceAlpha,
SourceAlphaBlend = BlendOption.SourceAlpha,
DestinationAlphaBlend = BlendOption.DestinationAlpha,
IsBlendEnabled = true,
RenderTargetWriteMask = ColorWriteMaskFlags.All
};
var DSSNoDepthNoStencil = new DepthStencilStateDescription()
{
IsDepthEnabled = false,
IsStencilEnabled = false,
DepthWriteMask = DepthWriteMask.Zero,
DepthComparison = Comparison.Always,
FrontFace = new DepthStencilOperationDescription()
{
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Keep,
PassOperation = StencilOperation.Keep,
Comparison = Comparison.Always
},
BackFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Keep,
PassOperation = StencilOperation.Keep
},
StencilReadMask = 0,
StencilWriteMask = 0
};
context.OutputMerger.SetDepthStencilState(new DepthStencilState(device, DSSNoDepthNoStencil), 0);
context.OutputMerger.SetBlendState(new BlendState(device, BSAlphaBlend),
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
//context.OutputMerger.SetTargets(quardTargetView.Get());
var rester = new RasterizerStateDescription2 {
CullMode = CullMode.None,
FillMode = FillMode.Solid,
DepthBias = 0,
DepthBiasClamp = 0,
SlopeScaledDepthBias = 0,
IsFrontCounterClockwise = false,
IsMultisampleEnabled = false,
IsAntialiasedLineEnabled = false,
IsDepthClipEnabled = false,
IsScissorEnabled = true
};
using (var rasterizerState = graphics.CreateRasterizerState(rester)) {
context.Rasterizer.State = rasterizerState;
graphics.ImmediateContext.Draw(4, 0);
}
}
protected override void Rendering(GraphicsDevice graphics, TProperties game)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
if (!pass.IsCompiled)
{
pass.Compile(graphics.Compilator);
var vertexShaderByteCode = pass.VertexShader.ReadCompiledBytes();
vertexShader.Set(new VertexShader(device, vertexShaderByteCode));
pixelShader.Set(new PixelShader(device, pass.PixelShader.ReadCompiledBytes()));
}
if (!depthStencilState.HasValue)
{
depthStencilState.Set(new DepthStencilState(graphics.D3DDevice,
D3DDepthStencilDefinition.DepthDisabled.Description));
}
//SharpDX.Direct3D11.Device.FromPointer<SharpDX.Direct3D11.Device>(System.IntPtr.Zero);
//var d = new D3DLab.CUDA.TestCudaLib();
//d.SetDevice(graphics.D3DDevice);
//var text = graphics.CreateTexture2D(new GraphicSurfaceSize(256, 256));
//d.SetTexture(text.NativePointer);
//d.SetTexture(text);
foreach (var en in entities)
{
if (en.TryGetComponent <BackgroundRenderComponent>(out var render))
{
if (en.TryGetComponent <MemoryTexturedMaterialComponent>(out var texture) && texture.IsModified)
{
render.TextureResources.Set(ConvertToResources(texture, graphics.TexturedLoader));
render.SampleState.Set(graphics.CreateSampler(SamplerStateDescriptions.Default));
texture.IsModified = false;
}
//if (en.TryGetComponent<MaterialColorComponent>(out var color) && color.IsValid) {
//}
graphics.ClearAllShader();
graphics.SetVertexShader(vertexShader);
graphics.SetPixelShader(pixelShader);
graphics.DisableIndexVertexBuffers();
if (render.TextureResources.HasValue && render.SampleState.HasValue)
{
context.PixelShader.SetShaderResources(0, render.TextureResources.Get());
context.PixelShader.SetSampler(0, render.SampleState.Get());
}
context.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleStrip;
context.OutputMerger.SetDepthStencilState(depthStencilState.Get());
using (var rasterizerState = graphics.CreateRasterizerState(rasterizerStateDescription)) {
context.Rasterizer.State = rasterizerState;
context.Draw(4, 0);
}
break; //support only one BackgroundRenderComponent
}
}
}
void RenderingAlfa(IEnumerable <GraphicEntity> entities, GraphicsDevice graphics, TProperties props)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
context.ClearRenderTargetView(colorTargetView.Get(), SharpDX.Color.Zero);
context.ClearRenderTargetView(alphaTargetView.Get(), SharpDX.Color.White);
//context.SetRenderTargets(context.RenderHost.DepthStencilBufferView,
// new RenderTargetView[] { colorTargetView, alphaTargetView });
context.OutputMerger.SetTargets(colorTargetView.Get(), alphaTargetView.Get());
foreach (var en in entities)
{
var render = en.GetComponent <D3DRenderComponent>();
var geo = en.GetComponent <GeometryComponent>();
var color = en.GetComponent <MaterialColorComponent>();
var transform = en.GetComponent <TransformComponent>();
if (!render.DepthStencilState.HasValue)
{
render.DepthStencilState.Set(new DepthStencilState(graphics.D3DDevice, depthStencilStateDesc));
}
if (!render.BlendingState.HasValue)
{
render.BlendingState.Set(new BlendState(graphics.D3DDevice, blendStateDesc));
}
{
context.VertexShader.Set(vertexShader.Get());
context.PixelShader.Set(pixelShader.Get());
}
if (geo.IsModified || (!render.VertexBuffer.HasValue && !render.IndexBuffer.HasValue))
{
var vertex = new Vertex[geo.Positions.Length];
for (var index = 0; index < vertex.Length; index++)
{
vertex[index] = new Vertex(geo.Positions[index], geo.Normals[index]);
}
render.VertexBuffer.Set(graphics.CreateBuffer(BindFlags.VertexBuffer, vertex));
render.IndexBuffer.Set(graphics.CreateBuffer(BindFlags.IndexBuffer, geo.Indices.ToArray()));
geo.IsModified = false;
}
if (!render.VertexBuffer.HasValue && !render.IndexBuffer.HasValue)
{
throw RenderTechniqueException.NoVertexAndIndexBuffers;
}
if (color.IsValid)
{
var material = MaterialStructBuffer.From(color);
if (render.MaterialBuffer.HasValue)
{
var buff = render.MaterialBuffer.Get();
graphics.UpdateDynamicBuffer(ref material, buff);
}
else
{
var buff = graphics.CreateDynamicBuffer(ref material, Unsafe.SizeOf <MaterialStructBuffer>());
render.MaterialBuffer.Set(buff);
}
}
UpdateTransformWorld(graphics, render, en);
if (!render.TransformWorldBuffer.HasValue)
{
throw RenderTechniqueException.NoWorldTransformBuffers;
}
{//Update constant buffers
context.VertexShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, props.Game);
context.VertexShader.SetConstantBuffer(TransforStructBuffer.RegisterResourceSlot, render.TransformWorldBuffer.Get());
context.PixelShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, props.Game);
context.PixelShader.SetConstantBuffer(LightStructBuffer.RegisterResourceSlot, props.Lights);
if (render.MaterialBuffer.HasValue)
{
context.PixelShader.SetConstantBuffer(MaterialStructBuffer.RegisterResourceSlot, render.MaterialBuffer.Get());
}
}
{
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(render.VertexBuffer.Get(),
layconst.VertexSize, 0));
context.InputAssembler.SetIndexBuffer(render.IndexBuffer.Get(), SharpDX.DXGI.Format.R32_UInt, 0);
context.InputAssembler.InputLayout = inputLayout.Get();
context.InputAssembler.PrimitiveTopology = render.PrimitiveTopology;
context.OutputMerger.SetDepthStencilState(render.DepthStencilState.Get(), 0);
context.OutputMerger.SetBlendState(render.BlendingState.Get(), new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
}
var stated = render.RasterizerStateDescription.GetDescription();
using (var rasterizerState = graphics.CreateRasterizerState(stated)) {
context.Rasterizer.State = rasterizerState;
graphics.ImmediateContext.DrawIndexed(geo.Indices.Length, 0, 0);
}
}
}
protected override void Rendering(GraphicsDevice graphics, TProperties props)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
if (!pass.IsCompiled)
{
pass.Compile(graphics.Compilator);
var vertexShaderByteCode = pass.VertexShader.ReadCompiledBytes();
var inputSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
inputLayout.Set(new InputLayout(device, inputSignature, layconst.ConstuctElements()));
vertexShader.Set(new VertexShader(device, vertexShaderByteCode));
pixelShader.Set(new PixelShader(device, pass.PixelShader.ReadCompiledBytes()));
}
if (!quardPass.IsCompiled)
{
quardPass.Compile(graphics.Compilator);
//var inputSignature = ShaderSignature.GetInputSignature(quardPass.VertexShader.ReadCompiledBytes());
//inputLayoutQuard = new InputLayout(device, inputSignature, null);
vertexShaderQuard.Set(new VertexShader(device, quardPass.VertexShader.ReadCompiledBytes()));
pixelShaderQuard.Set(new PixelShader(device, quardPass.PixelShader.ReadCompiledBytes()));
}
//clear shaders off prev. technique
graphics.ClearAllShader();
if (!colorTargetTex2D.HasValue)
{
colorDesc.BindFlags = alphaDesc.BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource;
colorDesc.SampleDescription =
alphaDesc.SampleDescription =
new SampleDescription(1, 0);
colorDesc.Width = alphaDesc.Width = (int)graphics.Size.Width;
colorDesc.Height = alphaDesc.Height = (int)graphics.Size.Height;
colorTargetTex2D.Set(new Texture2D(device, colorDesc));
alphaTargetTex2D.Set(new Texture2D(device, alphaDesc));
{
colorTargetNoMSAATexture2D.Set(new Texture2D(device, colorDesc));
alphaTargetNoMSAATexture2D.Set(new Texture2D(device, alphaDesc));
colorTargetNoMSAA.Set(new ShaderResourceView(device, colorTargetNoMSAATexture2D.Get()));
alphaTargetNoMSAA.Set(new ShaderResourceView(device, alphaTargetNoMSAATexture2D.Get()));
}
targetSampler.Set(new SamplerState(device, LinearSamplerWrapAni1));
colorTargetView.Set(new RenderTargetView(device, colorTargetTex2D.Get()));
alphaTargetView.Set(new RenderTargetView(device, alphaTargetTex2D.Get()));
var d = colorDesc;
d.BindFlags = BindFlags.RenderTarget;
quardTargetView.Set(new RenderTargetView(device, new Texture2D(device, d)));
}
//RenderingAlfa(entities, graphics, props);
RenderingQuard(graphics, props);
}
protected override void Rendering(GraphicsDevice graphics, TProperties props)
{
var device = graphics.D3DDevice;
var context = graphics.ImmediateContext;
if (!pass.IsCompiled)
{
pass.Compile(graphics.Compilator);
var vertexShaderByteCode = pass.VertexShader.ReadCompiledBytes();
var inputSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
inputLayout.Set(new InputLayout(device, inputSignature, layconst.ConstuctElements()));
vertexShader.Set(new VertexShader(device, vertexShaderByteCode));
pixelShader.Set(new PixelShader(device, pass.PixelShader.ReadCompiledBytes()));
}
DepthStencilState depthStencilState = null;
BlendState blendingState = null;
try {
depthStencilState = new DepthStencilState(graphics.D3DDevice, D3DDepthStencilDefinition.DepthDisabled.Description);
blendingState = new BlendState(graphics.D3DDevice, D3DBlendStateDescriptions.BlendStateEnabled);
foreach (var en in entities)
{
if (!en.Contains <BlackAndWhiteRenderComponent>())
{
continue;
}
var geo = en.GetComponent <GeometryComponent>();
var renderable = en.GetComponent <RenderableComponent>();
var transform = en.GetComponent <TransformComponent>();
graphics.ClearAllShader();
graphics.SetVertexShader(vertexShader);
graphics.SetPixelShader(pixelShader);
SharpDX.Direct3D11.Buffer vertexBuffer = null;
SharpDX.Direct3D11.Buffer indexBuffer = null;
SharpDX.Direct3D11.Buffer transformWorldBuffer = null;
try {
var vertex = new Vertex[geo.Positions.Length];
for (var index = 0; index < vertex.Length; index++)
{
vertex[index] = new Vertex(geo.Positions[index]);
}
vertexBuffer = graphics.CreateBuffer(BindFlags.VertexBuffer, vertex);
indexBuffer = graphics.CreateBuffer(BindFlags.IndexBuffer, geo.Indices.ToArray());
transformWorldBuffer = CreateTransformWorldBuffer(graphics, ref transform);
context.VertexShader.SetConstantBuffer(GameStructBuffer.RegisterResourceSlot, props.Game);
context.VertexShader.SetConstantBuffer(TransforStructBuffer.RegisterResourceSlot, transformWorldBuffer);
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, layconst.VertexSize, 0));
context.InputAssembler.SetIndexBuffer(indexBuffer, SharpDX.DXGI.Format.R32_UInt, 0);
context.InputAssembler.InputLayout = inputLayout.Get();
context.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.OutputMerger.SetBlendState(blendingState,
new SharpDX.Mathematics.Interop.RawColor4(0, 0, 0, 0), -1);
using (var rasterizerState = graphics.CreateRasterizerState(rasterizerStateDescription)) {
context.Rasterizer.State = rasterizerState;
context.DrawIndexed(geo.Indices.Length, 0, 0);
}
} finally {
vertexBuffer?.Dispose();
indexBuffer?.Dispose();
transformWorldBuffer?.Dispose();
}
}
} finally {
depthStencilState?.Dispose();
blendingState?.Dispose();
blendingState = null;
depthStencilState = null;
}
}
public void SetPixelShader(DisposableSetter <PixelShader> shader)
{
ImmediateContext.PixelShader.Set(shader.Get());
resourseHash.RegisterShader(ImmediateContext.PixelShader.GetHashCode());
}
public void RegisterConstantBuffer(CommonShaderStage stage, int slot, DisposableSetter <SharpDX.Direct3D11.Buffer> buff)
{
RegisterConstantBuffer(stage, slot, buff.Get());
}
