CodeWalker/Rendering/Utils/GpuBuffers.cs

565 lines
20 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SharpDX.DXGI;
using Device = SharpDX.Direct3D11.Device;
using Buffer = SharpDX.Direct3D11.Buffer;
using MapFlags = SharpDX.Direct3D11.MapFlags;
using SharpDX.Direct3D11;
using SharpDX;
using SharpDX.Direct3D;
namespace CodeWalker.Rendering
{
public class GpuVarsBuffer<T> where T:struct //shader vars buffer helper!
{
public int Size;
public Buffer Buffer;
public T Vars;
public bool Flag;//for external use
public GpuVarsBuffer(Device device)
{
Size = System.Runtime.InteropServices.Marshal.SizeOf<T>();// (sizeof(T));
Buffer = new Buffer(device, Size, ResourceUsage.Dynamic, BindFlags.ConstantBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0);// //DXUtility::CreateShaderVarsBuffer(Size, name);
}
public void Dispose()
{
if (Buffer != null)
{
Buffer.Dispose();
Buffer = null;
}
}
public void Update(DeviceContext context)
{
try
{
var dataBox = context.MapSubresource(Buffer, 0, MapMode.WriteDiscard, MapFlags.None);
Utilities.Write(dataBox.DataPointer, ref Vars);
context.UnmapSubresource(Buffer, 0);
}
catch { } //not much we can do about this except ignore it..
}
public void SetVSCBuffer(DeviceContext context, int slot)
{
context.VertexShader.SetConstantBuffer(slot, Buffer);
}
public void SetPSCBuffer(DeviceContext context, int slot)
{
context.PixelShader.SetConstantBuffer(slot, Buffer);
}
}
public class GpuABuffer<T> where T : struct //Dynamic GPU buffer of items updated by CPU, for array of structs used as a constant buffer
{
public int StructSize;
public int StructCount;
public int BufferSize;
public Buffer Buffer;
public GpuABuffer(Device device, int count)
{
StructCount = count;
StructSize = System.Runtime.InteropServices.Marshal.SizeOf<T>();
BufferSize = StructCount * StructSize;
Buffer = new Buffer(device, BufferSize, ResourceUsage.Dynamic, BindFlags.ConstantBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0);
}
public void Dispose()
{
if (Buffer != null)
{
Buffer.Dispose();
Buffer = null;
}
}
public void Update(DeviceContext context, T[] data)
{
var dataBox = context.MapSubresource(Buffer, 0, MapMode.WriteDiscard, MapFlags.None);
Utilities.Write(dataBox.DataPointer, data, 0, Math.Min(data.Length, StructCount));
context.UnmapSubresource(Buffer, 0);
}
public void SetVSCBuffer(DeviceContext context, int slot)
{
context.VertexShader.SetConstantBuffer(slot, Buffer);
}
public void SetPSCBuffer(DeviceContext context, int slot)
{
context.PixelShader.SetConstantBuffer(slot, Buffer);
}
}
public class GpuSBuffer<T> where T : struct //for static struct data as resource view
{
public int StructSize;
public int StructCount;
public int BufferSize;
public Buffer Buffer;
public ShaderResourceView SRV;
public GpuSBuffer(Device device, T[] data)
{
StructCount = data.Length;
StructSize = System.Runtime.InteropServices.Marshal.SizeOf<T>();// (sizeof(T));
BufferSize = StructCount * StructSize;
//var ds = new DataStream(new DataPointer()
Buffer = Buffer.Create<T>(device, BindFlags.ShaderResource, data, BufferSize, ResourceUsage.Default, CpuAccessFlags.None, ResourceOptionFlags.BufferStructured, StructSize);
//Buffer = new Buffer(device, BufferSize, ResourceUsage.Default, BindFlags.ShaderResource, CpuAccessFlags.None, ResourceOptionFlags.BufferStructured, StructSize);
SRV = DXUtility.CreateShaderResourceView(device, Buffer, SharpDX.DXGI.Format.Unknown, SharpDX.Direct3D.ShaderResourceViewDimension.Buffer, 0, 0, StructCount, 0);
}
public void Dispose()
{
if (SRV != null)
{
SRV.Dispose();
SRV = null;
}
if (Buffer != null)
{
Buffer.Dispose();
Buffer = null;
}
}
}
public class GpuCBuffer<T> where T : struct //Dynamic GPU buffer of items updated by CPU
{
public int StructSize;
public int StructCount;
public int BufferSize;
public int CurrentCount;
public Buffer Buffer;
public ShaderResourceView SRV;
public List<T> Data;
public T[] DataArray;
public GpuCBuffer(Device device, int count)
{
StructCount = count;
StructSize = System.Runtime.InteropServices.Marshal.SizeOf<T>();// (sizeof(T));
BufferSize = StructCount * StructSize;
//Buffer = Buffer.Create<T>(device, BindFlags.ShaderResource, null, BufferSize, ResourceUsage.Dynamic, CpuAccessFlags.Write, ResourceOptionFlags.BufferStructured, StructSize);
Buffer = new Buffer(device, BufferSize, ResourceUsage.Dynamic, BindFlags.ShaderResource, CpuAccessFlags.Write, ResourceOptionFlags.BufferStructured, StructSize);
SRV = DXUtility.CreateShaderResourceView(device, Buffer, SharpDX.DXGI.Format.Unknown, SharpDX.Direct3D.ShaderResourceViewDimension.Buffer, 0, 0, StructCount, 0);
Data = new List<T>(count);
DataArray = new T[count];
}
public void Dispose()
{
if (SRV != null)
{
SRV.Dispose();
SRV = null;
}
if (Buffer != null)
{
Buffer.Dispose();
Buffer = null;
}
}
public void Clear()
{
Data.Clear();
CurrentCount = 0;
}
public bool Add(T item)
{
if (CurrentCount < StructCount)
{
Data.Add(item);
CurrentCount++;
return true;
}
return false;
}
public void Update(DeviceContext context)
{
for (int i = 0; i < CurrentCount; i++)
{
DataArray[i] = Data[i];
}
var dataBox = context.MapSubresource(Buffer, 0, MapMode.WriteDiscard, MapFlags.None);
Utilities.Write(dataBox.DataPointer, DataArray, 0, CurrentCount);
context.UnmapSubresource(Buffer, 0);
}
public void Update(DeviceContext context, T[] data)
{
var dataBox = context.MapSubresource(Buffer, 0, MapMode.WriteDiscard, MapFlags.None);
Utilities.Write(dataBox.DataPointer, data, 0, data.Length);
context.UnmapSubresource(Buffer, 0);
}
public void SetVSResource(DeviceContext context, int slot)
{
context.VertexShader.SetShaderResource(slot, SRV);
}
public void SetPSResource(DeviceContext context, int slot)
{
context.PixelShader.SetShaderResource(slot, SRV);
}
}
public class GpuBuffer<T> where T : struct //Dynamic GPU buffer of items updated by compute shader
{
public int StructSize;
public int StructCount;
public int ItemTotalSize;
public int ItemCount;
public int Size;
public Buffer Buffer;
public ShaderResourceView SRV;
public UnorderedAccessView UAV;
public GpuBuffer(Device device, int itemSize, int itemCount)
{
StructSize = System.Runtime.InteropServices.Marshal.SizeOf<T>();// sizeof(T)),
StructCount = itemCount * itemSize;
ItemTotalSize = itemSize * StructSize;
ItemCount = itemCount;
Size = StructSize * itemSize * itemCount;
Buffer = DXUtility.CreateBuffer(device, Size, ResourceUsage.Default, BindFlags.ShaderResource | BindFlags.UnorderedAccess, 0, ResourceOptionFlags.BufferStructured, StructSize);
SRV = DXUtility.CreateShaderResourceView(device, Buffer, Format.Unknown, ShaderResourceViewDimension.Buffer, 0, 0, StructCount, 0);
UAV = DXUtility.CreateUnorderedAccessView(device, Buffer, Format.Unknown, UnorderedAccessViewDimension.Buffer, 0, StructCount, 0, 0);
}
public void Dispose()
{
if (UAV != null)
{
UAV.Dispose();
UAV = null;
}
if (SRV != null)
{
SRV.Dispose();
SRV = null;
}
if (Buffer != null)
{
Buffer.Dispose();
Buffer = null;
}
}
}
public class GpuTexture //texture and render targets (depth, MS).
{
public Texture2D Texture;
public Texture2D TextureMS;
public Texture2D Depth;
public Texture2D DepthMS;
public RenderTargetView RTV;
public DepthStencilView DSV;
public RenderTargetView MSRTV;
public DepthStencilView MSDSV;
public ShaderResourceView SRV;
public int VramUsage;
public bool Multisampled;
public bool UseDepth;
public void Init(Device device, int w, int h, Format f, int sc, int sq, bool depth, Format df)
{
VramUsage = 0;
Multisampled = (sc > 1);
UseDepth = depth;
ResourceUsage u = ResourceUsage.Default;
BindFlags b = BindFlags.RenderTarget | BindFlags.ShaderResource;
RenderTargetViewDimension rtvd = RenderTargetViewDimension.Texture2D;
ShaderResourceViewDimension srvd = ShaderResourceViewDimension.Texture2D;// D3D11_SRV_DIMENSION_TEXTURE2D;
int fs = DXUtility.ElementSize(f);
int wh = w * h;
BindFlags db = BindFlags.DepthStencil;// D3D11_BIND_DEPTH_STENCIL;
DepthStencilViewDimension dsvd = DepthStencilViewDimension.Texture2D;
Texture = DXUtility.CreateTexture2D(device, w, h, 1, 1, f, 1, 0, u, b, 0, 0);
RTV = DXUtility.CreateRenderTargetView(device, Texture, f, rtvd, 0, 0, 0);
SRV = DXUtility.CreateShaderResourceView(device, Texture, f, srvd, 1, 0, 0, 0);
VramUsage += (wh * fs);
if (Multisampled)
{
b = BindFlags.RenderTarget;
rtvd = RenderTargetViewDimension.Texture2DMultisampled;
dsvd = DepthStencilViewDimension.Texture2DMultisampled;
TextureMS = DXUtility.CreateTexture2D(device, w, h, 1, 1, f, sc, sq, u, b, 0, 0);
MSRTV = DXUtility.CreateRenderTargetView(device, TextureMS, f, rtvd, 0, 0, 0);
VramUsage += (wh * fs) * sc;
if (depth)
{
DepthMS = DXUtility.CreateTexture2D(device, w, h, 1, 1, df, sc, sq, u, db, 0, 0);
MSDSV = DXUtility.CreateDepthStencilView(device, DepthMS, df, dsvd);
VramUsage += (wh * DXUtility.ElementSize(df)) * sc;
}
}
else
{
if (depth)
{
Depth = DXUtility.CreateTexture2D(device, w, h, 1, 1, df, sc, sq, u, db, 0, 0);
DSV = DXUtility.CreateDepthStencilView(device, Depth, df, dsvd);
VramUsage += (wh * DXUtility.ElementSize(df));
}
}
}
public void Dispose()
{
if (SRV != null)
{
SRV.Dispose();
SRV = null;
}
if (MSDSV != null)
{
MSDSV.Dispose();
MSDSV = null;
}
if (MSRTV != null)
{
MSRTV.Dispose();
MSRTV = null;
}
if (DSV != null)
{
DSV.Dispose();
DSV = null;
}
if (RTV != null)
{
RTV.Dispose();
RTV = null;
}
if (DepthMS != null)
{
DepthMS.Dispose();
DepthMS = null;
}
if (Depth != null)
{
Depth.Dispose();
Depth = null;
}
if (TextureMS != null)
{
TextureMS.Dispose();
TextureMS = null;
}
if (Texture != null)
{
Texture.Dispose();
Texture = null;
}
}
public GpuTexture(Device device, int w, int h, Format f, int sc, int sq, bool depth, Format df)
{
Init(device, w, h, f, sc, sq, depth, df);
}
public GpuTexture(Device device, int w, int h, Format f, int sc, int sq)
{
Init(device, w, h, f, sc, sq, false, Format.Unknown);
}
public GpuTexture(Device device, int w, int h, Format f)
{
Init(device, w, h, f, 1, 0, false, Format.Unknown);
}
public void Clear(DeviceContext context, Color4 colour)
{
if (Multisampled)
{
context.ClearRenderTargetView(MSRTV, colour);
if (UseDepth)
{
context.ClearDepthStencilView(MSDSV, DepthStencilClearFlags.Depth, 0.0f, 0);
}
}
else
{
context.ClearRenderTargetView(RTV, colour);
if (UseDepth)
{
context.ClearDepthStencilView(DSV, DepthStencilClearFlags.Depth, 0.0f, 0);
}
}
}
public void ClearDepth(DeviceContext context)
{
if (!UseDepth) return;
if (Multisampled)
{
context.ClearDepthStencilView(MSDSV, DepthStencilClearFlags.Depth, 0.0f, 0);
}
else
{
context.ClearDepthStencilView(DSV, DepthStencilClearFlags.Depth, 0.0f, 0);
}
}
public void SetRenderTarget(DeviceContext context)
{
if (Multisampled)
{
context.OutputMerger.SetRenderTargets(UseDepth ? MSDSV : null, MSRTV);
}
else
{
context.OutputMerger.SetRenderTargets(UseDepth ? DSV : null, RTV);
}
}
}
public class GpuMultiTexture //multiple texture and render targets (depth).
{
public Texture2D[] Textures;
public Texture2D Depth;
public RenderTargetView[] RTVs;
public DepthStencilView DSV;
public ShaderResourceView[] SRVs;
public ShaderResourceView DepthSRV;
public int VramUsage;
public bool UseDepth;
public int Count;
public bool Multisampled;
public int MultisampleCount;
public void Init(Device device, int w, int h, int count, Format f, bool depth, Format df, int multisamplecount)
{
Count = count;
VramUsage = 0;
UseDepth = depth;
MultisampleCount = multisamplecount;
Multisampled = (multisamplecount > 1);
ResourceUsage u = ResourceUsage.Default;
BindFlags b = BindFlags.RenderTarget | BindFlags.ShaderResource;
int fs = DXUtility.ElementSize(f);
int wh = w * h;
BindFlags db = BindFlags.DepthStencil | BindFlags.ShaderResource;// D3D11_BIND_DEPTH_STENCIL;
RenderTargetViewDimension rtvd = RenderTargetViewDimension.Texture2D;
ShaderResourceViewDimension srvd = ShaderResourceViewDimension.Texture2D;// D3D11_SRV_DIMENSION_TEXTURE2D;
DepthStencilViewDimension dsvd = DepthStencilViewDimension.Texture2D;
if (Multisampled)
{
rtvd = RenderTargetViewDimension.Texture2DMultisampled;
srvd = ShaderResourceViewDimension.Texture2DMultisampled;
dsvd = DepthStencilViewDimension.Texture2DMultisampled;
}
Textures = new Texture2D[count];
RTVs = new RenderTargetView[count];
SRVs = new ShaderResourceView[count];
for (int i = 0; i < count; i++)
{
Textures[i] = DXUtility.CreateTexture2D(device, w, h, 1, 1, f, multisamplecount, 0, u, b, 0, 0);
RTVs[i] = DXUtility.CreateRenderTargetView(device, Textures[i], f, rtvd, 0, 0, 0);
SRVs[i] = DXUtility.CreateShaderResourceView(device, Textures[i], f, srvd, 1, 0, 0, 0);
VramUsage += (wh * fs) * multisamplecount;
}
if (depth)
{
Format dtexf = Format.R32_Typeless;
Format dsrvf = Format.R32_Float;
switch (df)
{
case Format.D16_UNorm:
dtexf = Format.R16_Typeless;
dsrvf = Format.R16_UNorm;
break;
case Format.D24_UNorm_S8_UInt:
dtexf = Format.R24G8_Typeless;
dsrvf = Format.R24_UNorm_X8_Typeless;
break;
case Format.D32_Float:
dtexf = Format.R32_Typeless;
dsrvf = Format.R32_Float;
break;
case Format.D32_Float_S8X24_UInt:
dtexf = Format.R32G8X24_Typeless;//is this right? who uses this anyway??
dsrvf = Format.R32_Float_X8X24_Typeless;
break;
}
Depth = DXUtility.CreateTexture2D(device, w, h, 1, 1, dtexf, multisamplecount, 0, u, db, 0, 0);
DSV = DXUtility.CreateDepthStencilView(device, Depth, df, dsvd);
DepthSRV = DXUtility.CreateShaderResourceView(device, Depth, dsrvf, srvd, 1, 0, 0, 0);
VramUsage += (wh * DXUtility.ElementSize(df)) * multisamplecount;
}
}
public void Dispose()
{
for (int i = 0; i < Count; i++)
{
SRVs[i].Dispose();
RTVs[i].Dispose();
Textures[i].Dispose();
}
SRVs = null;
RTVs = null;
Textures = null;
if (DSV != null)
{
DSV.Dispose();
DSV = null;
}
if (DepthSRV != null)
{
DepthSRV.Dispose();
DepthSRV = null;
}
if (Depth != null)
{
Depth.Dispose();
Depth = null;
}
}
public GpuMultiTexture(Device device, int w, int h, int count, Format f, bool depth, Format df, int msc = 1)
{
Init(device, w, h, count, f, depth, df, msc);
}
public GpuMultiTexture(Device device, int w, int h, int count, Format f, int msc = 1)
{
Init(device, w, h, count, f, false, Format.Unknown, msc);
}
public void Clear(DeviceContext context, Color4 colour)
{
for (int i = 0; i < Count; i++)
{
context.ClearRenderTargetView(RTVs[i], colour);
}
if (UseDepth)
{
context.ClearDepthStencilView(DSV, DepthStencilClearFlags.Depth, 0.0f, 0);
}
}
public void ClearDepth(DeviceContext context)
{
if (!UseDepth) return;
context.ClearDepthStencilView(DSV, DepthStencilClearFlags.Depth, 0.0f, 0);
}
public void SetRenderTargets(DeviceContext context)
{
context.OutputMerger.SetRenderTargets(UseDepth ? DSV : null, RTVs);
}
}
}