/// <summary>
/// Creates an effect with on technique and one pass.
/// </summary>
/// <param name="vs">VertexShader to use.</param>
/// <param name="ps">PixelShader to use.</param>
public ShaderEffect(IVertexShader vs, IPixelShader ps)
{
Pass pass = new Pass("Pass1", vs, ps);
Technique technique = new Technique("Technique1", pass);
techniques.Add(technique);
}
public static void Render <TVertexShaderIn, TPixelShaderIn>(
TVertexShaderIn[] vertices,
int[] indices,
MemoryResources resources,
InputAssembler inputAssembler,
OutputMerger outputMerger,
IVertexShader <TVertexShaderIn, TPixelShaderIn> vertexShader,
IGeometryProcessor <TPixelShaderIn> geometryProcessor,
IRasterizer <TPixelShaderIn> rasterizer,
IPixelShader <TPixelShaderIn> pixelShader,
Bitmap output)
where TVertexShaderIn : struct, IVertexShaderInput
where TPixelShaderIn : struct, IPixelShaderInput
{
if (vertices.Length == 0 || indices.Length == 0)
{
return;
}
(vertices, indices) = inputAssembler.Assemble(vertices, indices);
var vertexShaderOutput = new TPixelShaderIn[vertices.Length];
for (var i = 0; i < vertices.Length; ++i)
{
vertexShaderOutput[i] = vertexShader.Transform(resources, vertices[i]);
}
(vertexShaderOutput, indices) = geometryProcessor.Process(vertexShaderOutput, indices);
var pixelShaderOutput = rasterizer.Rasterize(resources, vertexShaderOutput, indices, pixelShader, outputMerger, output.Width, output.Height, _outputBuffer, _wBuffer);
Helper.SetPixels(pixelShaderOutput, output);
}
public override void Build(IDevice device)
{
_indexBuffer = device.CreateIndexBuffer(new int[] { 0, 3, 1, 3, 2, 1 });
_vertexBuffer = device.CreateVertexBuffer(CreateCube());
using var pixelShaderBlob = new Blob(device.TEMPORARYCompiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferPixelShader.hlsl", "main", "ps_5_0"));
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
using var vertexShaderBlob = new Blob(device.TEMPORARYCompiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferVertexShader.hlsl", "main", "vs_5_0"));
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(2).Append("POSITION", VertexLayoutTypes.Position2D).Append("TEXCOORD", VertexLayoutTypes.Position2D), vertexShaderBlob);
_sampler = device.CreateSampler();
}
public RenderMeshPass(IDevice device, ID3DCompiler compiler)
{
using var vertexShaderBlob = new Blob(compiler.CompileShaderFromFile(@"F:\Git\GameDev\src\Titan.D3D11.Bindings\VertexShader.hlsl", "main", "vs_5_0"));
using var pixelShaderBlob = new Blob(compiler.CompileShaderFromFile(@"F:\Git\GameDev\src\Titan.D3D11.Bindings\PixelShader.hlsl", "main", "ps_5_0"));
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(4).Append("Position", VertexLayoutTypes.Position3D).Append("Normal", VertexLayoutTypes.Position3D).Append("Texture", VertexLayoutTypes.Texture2D).Append("Color", VertexLayoutTypes.Float4Color), vertexShaderBlob);
_perFrameConstantBuffer = device.CreateConstantBuffer <PerFrameContantBuffer>(BufferUsage.Dynamic, BufferAccessFlags.Write);
_lightsConstantBuffer = device.CreateConstantBuffer <LightsConstantBuffer>(BufferUsage.Dynamic, BufferAccessFlags.Write);
_perObjectConstantBuffer = device.CreateConstantBuffer <PerObjectContantBuffer>(BufferUsage.Dynamic, BufferAccessFlags.Write);
_sampler = device.CreateSampler();
}
public RenderToBackbufferPass(IDevice device, ID3DCompiler compiler)
{
_backBuffer = device.BackBuffer;
_depthStencil = device.DepthStencil;
_indexBuffer = device.CreateIndexBuffer(new int[] { 0, 3, 1, 3, 2, 1 });
_vertexBuffer = device.CreateVertexBuffer(CreateCube());
using var pixelShaderBlob = new Blob(compiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferPixelShader.hlsl", "main", "ps_5_0"));
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
using var vertexShaderBlob = new Blob(compiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferVertexShader.hlsl", "main", "vs_5_0"));
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(2).Append("POSITION", VertexLayoutTypes.Position2D).Append("TEXCOORD", VertexLayoutTypes.Position2D), vertexShaderBlob);
_sampler = device.CreateSampler();
}
public SpriteBatchRenderer(IDevice device, IBlobReader blobReader, ICameraFactory cameraFactory)
{
_device = device;
_context = _device.ImmediateContext;
_camera = cameraFactory.CreateOrhographicCamera();
_buffer = device.CreateVertexBuffer <Vertex2D>(MaxVertices, BufferUsage.Dynamic, BufferAccessFlags.Write);
_indices = device.CreateIndexBuffer(CreateIndices());
_sampler = device.CreateSampler(true);
_blendState = device.CreateBlendState();
_cameraBuffer = device.CreateConstantBuffer(new Camera {
Transform = _camera.ViewProjection
});
using var vertexShaderBlob = blobReader.ReadFromFile("Shaders/VertexShader2D.cso");
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
using var pixelShaderBlob = blobReader.ReadFromFile("Shaders/PixelShader2D.cso");
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(3).Append("Position", VertexLayoutTypes.Position2D).Append("Textures", VertexLayoutTypes.Texture2D).Append("Color", VertexLayoutTypes.Float4Color), vertexShaderBlob);
}
public Color4[,] Rasterize(MemoryResources resources, TPixelShaderInput[] vertices, int[] indices,
IPixelShader <TPixelShaderInput> pixelShader, OutputMerger outputMerger,
int outputWidth, int outputHeight, Color4[,] outputBuffer, float[,] wBuffer)
{
for (var i = 0; i < indices.Length; i += 3)
{
var a = vertices[indices[i]];
var b = vertices[indices[i + 1]];
var c = vertices[indices[i + 2]];
var tri = new Triangle <TPixelShaderInput> {
A = a,
B = b,
C = c
};
RasterizeTriangle(tri, resources, pixelShader, outputMerger, outputWidth, outputHeight, outputBuffer, wBuffer);
}
return(outputBuffer);
}
/// <summary>
/// Creates a new instance of an <see cref="EffectEntity"/>.
/// </summary>
/// <param name="vs">Vertex shader to use.</param>
/// <param name="ps">Pixel shader to use.</param>
public EffectEntity(IVertexShader vs, IPixelShader ps)
{
throw new NotImplementedException("So far ;-)!");
//this.effect = new Effect.XmlEffect(vs, ps);
}
public void SetPixelShader(IPixelShader shader)
{
_deviceContext.PixelShader.Set(((PixelShaderBox)shader).Shader);
}
private void RasterizeTriangle(Triangle <TPixelShaderInput> tri, MemoryResources resources, IPixelShader <TPixelShaderInput> pixelShader, OutputMerger outputMerger, int outputWidth, int outputHeight, Color4[,] colorBuffer, float[,] wBuffer)
{
var posA = tri.A.TransformedPosition;
var posB = tri.B.TransformedPosition;
var posC = tri.C.TransformedPosition;
var bitmapCoordA = MapNdcToScreen(posA.X, posA.Y, outputWidth, outputHeight);
var bitmapCoordB = MapNdcToScreen(posB.X, posB.Y, outputWidth, outputHeight);
var bitmapCoordC = MapNdcToScreen(posC.X, posC.Y, outputWidth, outputHeight);
// Triangle bounds (in [-1, 1] space)
var boundsLeft = Math.Min(bitmapCoordA.X, Math.Min(bitmapCoordB.X, bitmapCoordC.X));
var boundsTop = Math.Min(bitmapCoordA.Y, Math.Min(bitmapCoordB.Y, bitmapCoordC.Y));
var boundsRight = Math.Max(bitmapCoordA.X, Math.Max(bitmapCoordB.X, bitmapCoordC.X));
var boundsBottom = Math.Max(bitmapCoordA.Y, Math.Max(bitmapCoordB.Y, bitmapCoordC.Y));
if (boundsLeft == boundsRight || boundsTop == boundsBottom)
{
return;
}
for (var j = boundsTop; j <= boundsBottom; ++j)
{
if (j < 0 || outputHeight <= j)
{
continue;
}
for (var i = boundsLeft; i <= boundsRight; ++i)
{
if (i < 0 || outputWidth <= i)
{
continue;
}
if (!Helper.PointInTriangle(new Point(i, j), bitmapCoordA, bitmapCoordB, bitmapCoordC))
{
continue;
}
var pixCoord = MapScreenToNdc(i, j, outputWidth, outputHeight);
var interpolated = InterpolatePoint(tri.A, tri.B, tri.C, pixCoord, out var outOfRange);
//if (outOfRange) {
// continue;
//}
var pos = interpolated.TransformedPosition;
if (pos.Z < -1 || 1 < pos.Z || pos.Y < -1 || 1 < pos.Y || pos.X < -1 || 1 < pos.X)
{
continue;
}
var depthTestPassed = outputMerger.IsDepthTestPassed(pos.W, wBuffer[i, j]);
if (!depthTestPassed && colorBuffer[i, j].Alpha.Equals(1))
{
continue;
}
var pixel = pixelShader.Transform(resources, interpolated, out var discarded);
if (discarded)
{
continue;
}
pixel = Color4.Premultiply(pixel);
if (depthTestPassed)
{
wBuffer[i, j] = pos.W;
colorBuffer[i, j] = outputMerger.Blend(colorBuffer[i, j], pixel);
}
else if (colorBuffer[i, j].Alpha < 1)
{
colorBuffer[i, j] = outputMerger.Blend(pixel, colorBuffer[i, j]);
}
}
}
}
