public Handle <Sampler> Create(SamplerCreation args)
{
var handle = _resourcePool.CreateResource();
if (!handle.IsValid())
{
throw new InvalidOperationException("Failed to Create a Sampler Handle");
}
Logger.Trace <SamplerManager>($"Creating sampler with filter {args.Filter} and comparison func {args.ComparisonFunc}");
var sampler = _resourcePool.GetResourcePointer(handle);
sampler->Handle = handle;
sampler->Filter = args.Filter;
sampler->AddressU = args.AddressU;
sampler->AddressV = args.AddressV;
sampler->AddressW = args.AddressW;
sampler->ComparisonFunc = args.ComparisonFunc;
var desc = new D3D11_SAMPLER_DESC
{
Filter = (D3D11_FILTER)args.Filter,
AddressU = (D3D11_TEXTURE_ADDRESS_MODE)args.AddressU,
AddressV = (D3D11_TEXTURE_ADDRESS_MODE)args.AddressV,
AddressW = (D3D11_TEXTURE_ADDRESS_MODE)args.AddressW,
ComparisonFunc = (D3D11_COMPARISON_FUNC)args.ComparisonFunc
};
Common.CheckAndThrow(_device->CreateSamplerState(&desc, &sampler->SamplerState), nameof(ID3D11Device.CreateSamplerState));
return(handle);
}
public virtual void GetDesc(
out D3D11_SAMPLER_DESC pDesc
)
{
var fp = GetFunctionPointer(7);
if (m_GetDescFunc == null)
{
m_GetDescFunc = (GetDescFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(GetDescFunc));
}
m_GetDescFunc(m_ptr, out pDesc);
}
public virtual int CreateSamplerState(
ref D3D11_SAMPLER_DESC pSamplerDesc,
out ID3D11SamplerState ppSamplerState
)
{
var fp = GetFunctionPointer(23);
if (m_CreateSamplerStateFunc == null)
{
m_CreateSamplerStateFunc = (CreateSamplerStateFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(CreateSamplerStateFunc));
}
ppSamplerState = new ID3D11SamplerState();
return(m_CreateSamplerStateFunc(m_ptr, ref pSamplerDesc, out ppSamplerState.PtrForNew));
}
private void Init()
{
// this code is ported from https://gist.github.com/d7samurai/261c69490cce0620d0bfc93003cd1052
var fac = DXGIFunctions.CreateDXGIFactory2();
var flags = D3D11_CREATE_DEVICE_FLAG.D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#if DEBUG
flags |= D3D11_CREATE_DEVICE_FLAG.D3D11_CREATE_DEVICE_DEBUG;
#endif
var d3D11Device = D3D11Functions.D3D11CreateDevice(null, D3D_DRIVER_TYPE.D3D_DRIVER_TYPE_HARDWARE, flags, out _deviceContext);
var mt = d3D11Device.As <ID3D11Multithread>();
mt?.SetMultithreadProtected(true);
var desc = new DXGI_SWAP_CHAIN_DESC1();
desc.Format = DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
desc.SampleDesc.Count = 1;
desc.BufferUsage = Constants.DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.BufferCount = 2;
// note: this causes a warning in debug
// DXGI WARNING: IDXGIFactory::CreateSwapChain: Blt-model swap effects (DXGI_SWAP_EFFECT_DISCARD and DXGI_SWAP_EFFECT_SEQUENTIAL) are legacy swap effects that are predominantly superceded by their flip-model counterparts (DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL and DXGI_SWAP_EFFECT_FLIP_DISCARD). Please consider updating your application to leverage flip-model swap effects to benefit from modern presentation enhancements. More information is available at http://aka.ms/dxgiflipmodel. [ MISCELLANEOUS WARNING #294: ]
_swapChain = fac.CreateSwapChainForHwnd <IDXGISwapChain1>(d3D11Device, Handle, desc);
var frameBuffer = _swapChain.GetBuffer <ID3D11Texture2D>(0);
_renderTargetView = d3D11Device.CreateRenderTargetView(frameBuffer);
frameBuffer.Object.GetDesc(out var depthBufferDesc);
_width = depthBufferDesc.Width;
_height = depthBufferDesc.Height;
depthBufferDesc.Format = DXGI_FORMAT.DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.BindFlags = (uint)D3D11_BIND_FLAG.D3D11_BIND_DEPTH_STENCIL;
var depthBuffer = d3D11Device.CreateTexture2D <ID3D11Texture2D>(depthBufferDesc);
_depthBufferView = d3D11Device.CreateDepthStencilView(depthBuffer);
var vsBlob = D3D11Functions.D3DCompileFromFile("shaders.hlsl", "vs_main", "vs_5_0");
_vertexShader = d3D11Device.CreateVertexShader(vsBlob);
var inputElements = new D3D11_INPUT_ELEMENT_DESC[] {
new D3D11_INPUT_ELEMENT_DESC {
SemanticName = "POS", Format = DXGI_FORMAT.DXGI_FORMAT_R32G32B32_FLOAT
},
new D3D11_INPUT_ELEMENT_DESC {
SemanticName = "NOR", Format = DXGI_FORMAT.DXGI_FORMAT_R32G32B32_FLOAT, AlignedByteOffset = unchecked ((uint)Constants.D3D11_APPEND_ALIGNED_ELEMENT)
},
new D3D11_INPUT_ELEMENT_DESC {
SemanticName = "TEX", Format = DXGI_FORMAT.DXGI_FORMAT_R32G32_FLOAT, AlignedByteOffset = unchecked ((uint)Constants.D3D11_APPEND_ALIGNED_ELEMENT)
},
new D3D11_INPUT_ELEMENT_DESC {
SemanticName = "COL", Format = DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_FLOAT, AlignedByteOffset = unchecked ((uint)Constants.D3D11_APPEND_ALIGNED_ELEMENT)
},
};
_inputLayout = d3D11Device.CreateInputLayout(inputElements, vsBlob);
var psBlob = D3D11Functions.D3DCompileFromFile("shaders.hlsl", "ps_main", "ps_5_0");
_pixelShader = d3D11Device.CreatePixelShader(psBlob);
var rasterizerDesc = new D3D11_RASTERIZER_DESC();
rasterizerDesc.FillMode = D3D11_FILL_MODE.D3D11_FILL_SOLID;
rasterizerDesc.CullMode = D3D11_CULL_MODE.D3D11_CULL_BACK;
_rasterizerState = d3D11Device.CreateRasterizerState(rasterizerDesc);
var samplerDesc = new D3D11_SAMPLER_DESC();
samplerDesc.Filter = D3D11_FILTER.D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_MODE.D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_MODE.D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_MODE.D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.BorderColor = new float[4];
samplerDesc.BorderColor[0] = 1;
samplerDesc.BorderColor[1] = 1;
samplerDesc.BorderColor[2] = 1;
samplerDesc.BorderColor[3] = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_FUNC.D3D11_COMPARISON_NEVER;
_samplerState = d3D11Device.CreateSamplerState(samplerDesc);
var depthStencilDesc = new D3D11_DEPTH_STENCIL_DESC();
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK.D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_FUNC.D3D11_COMPARISON_LESS;
_depthStencilState = d3D11Device.CreateDepthStencilState(depthStencilDesc);
var blendDesc = new D3D11_BLEND_DESC();
blendDesc.RenderTarget = new D3D11_RENDER_TARGET_BLEND_DESC[8];
blendDesc.RenderTarget[0].BlendEnable = true;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND.D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND.D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP.D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND.D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND.D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP.D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].RenderTargetWriteMask = (byte)(D3D11_COLOR_WRITE_ENABLE.D3D11_COLOR_WRITE_ENABLE_ALL);
_blendState = d3D11Device.CreateBlendState(blendDesc);
var constantBufferDesc = new D3D11_BUFFER_DESC();
constantBufferDesc.ByteWidth = (uint)Marshal.SizeOf <VS_CONSTANT_BUFFER>();
constantBufferDesc.Usage = D3D11_USAGE.D3D11_USAGE_DYNAMIC;
constantBufferDesc.BindFlags = (uint)D3D11_BIND_FLAG.D3D11_BIND_CONSTANT_BUFFER;
constantBufferDesc.CPUAccessFlags = (uint)D3D11_CPU_ACCESS_FLAG.D3D11_CPU_ACCESS_WRITE;
if ((constantBufferDesc.ByteWidth % 16) != 0)
{
throw new InvalidOperationException("Constant buffer size must be a multiple of 16.");
}
_constantBuffer = d3D11Device.CreateBuffer(constantBufferDesc);
var vertexBufferDesc = new D3D11_BUFFER_DESC();
var gc = GCHandle.Alloc(Data.VertexData, GCHandleType.Pinned);
vertexBufferDesc.ByteWidth = (uint)Data.VertexData.SizeOf();
vertexBufferDesc.Usage = D3D11_USAGE.D3D11_USAGE_IMMUTABLE;
vertexBufferDesc.BindFlags = (uint)D3D11_BIND_FLAG.D3D11_BIND_VERTEX_BUFFER;
var vertexData = new D3D11_SUBRESOURCE_DATA();
vertexData.pSysMem = gc.AddrOfPinnedObject();
_vertexBuffer = d3D11Device.CreateBuffer(vertexBufferDesc, vertexData);
gc.Free();
var indexBufferDesc = new D3D11_BUFFER_DESC();
gc = GCHandle.Alloc(Data.IndexData, GCHandleType.Pinned);
indexBufferDesc.ByteWidth = (uint)Data.IndexData.SizeOf();
indexBufferDesc.Usage = D3D11_USAGE.D3D11_USAGE_IMMUTABLE;
indexBufferDesc.BindFlags = (uint)D3D11_BIND_FLAG.D3D11_BIND_INDEX_BUFFER;
var indexData = new D3D11_SUBRESOURCE_DATA();
indexData.pSysMem = gc.AddrOfPinnedObject();
_indexBuffer = d3D11Device.CreateBuffer(indexBufferDesc, indexData);
gc.Free();
var textureDesc = new D3D11_TEXTURE2D_DESC();
textureDesc.Width = 20;
textureDesc.Height = 20;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
textureDesc.SampleDesc.Count = 1;
textureDesc.Usage = D3D11_USAGE.D3D11_USAGE_IMMUTABLE;
textureDesc.BindFlags = (uint)D3D11_BIND_FLAG.D3D11_BIND_SHADER_RESOURCE;
gc = GCHandle.Alloc(Data.TextureData, GCHandleType.Pinned);
var textureData = new D3D11_SUBRESOURCE_DATA();
textureData.pSysMem = gc.AddrOfPinnedObject();
textureData.SysMemPitch = 20 * 4; // 4 bytes per pixel
gc.Free();
var texture = d3D11Device.CreateTexture2D <ID3D11Texture2D>(textureDesc, textureData);
_shaderResourceView = d3D11Device.CreateShaderResourceView(texture);
}
static void InitializeDirect3D()
{
var desc = new DXGI_SWAP_CHAIN_DESC
{
BufferDesc = new DXGI_MODE_DESC
{
Width = WIDTH,
Height = HEIGHT,
Format = DXGI_FORMAT_R8G8B8A8_UNORM,
},
SampleDesc = new DXGI_SAMPLE_DESC
{
Count = 1
},
BufferCount = 1,
Windowed = TRUE,
OutputWindow = form.Handle,
BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT,
Flags = (uint)DXGI_SWAP_CHAIN_FLAG.DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH
};
uint creationFlags = 0;
#if DEBUG
creationFlags |= (uint)D3D11_CREATE_DEVICE_FLAG.D3D11_CREATE_DEVICE_DEBUG;
#endif
fixed(IDXGISwapChain **swapchain = &_swapchain)
fixed(ID3D11Device **device = &_d3dDevice)
fixed(ID3D11DeviceContext **context = &_d3dctx)
{
ThrowIfFailed(D3D11CreateDeviceAndSwapChain(null,
D3D_DRIVER_TYPE_HARDWARE,
IntPtr.Zero,
creationFlags,
null,
0,
D3D11_SDK_VERSION,
&desc,
swapchain,
device,
null,
context));
}
ID3D10Multithread *pMultithread;
var iid = IID_ID3D10Multithread;
ThrowIfFailed(_d3dDevice->QueryInterface(&iid, (void **)&pMultithread));
pMultithread->SetMultithreadProtected(TRUE);
pMultithread->Release();
var viewport = new D3D11_VIEWPORT
{
Height = HEIGHT,
Width = WIDTH
};
_d3dctx->RSSetViewports(1, &viewport);
fixed(ID3D11Device **device = &_d3deviceVLC)
fixed(ID3D11DeviceContext **context = &_d3dctxVLC)
{
ThrowIfFailed(D3D11CreateDevice(null,
D3D_DRIVER_TYPE_HARDWARE,
IntPtr.Zero,
creationFlags | (uint)D3D11_CREATE_DEVICE_FLAG.D3D11_CREATE_DEVICE_VIDEO_SUPPORT, /* needed for hardware decoding */
null, 0,
D3D11_SDK_VERSION,
device, null, context));
}
using ComPtr <ID3D11Resource> pBackBuffer = null;
iid = IID_ID3D11Texture2D;
ThrowIfFailed(_swapchain->GetBuffer(0, &iid, (void **)pBackBuffer.GetAddressOf()));
fixed(ID3D11RenderTargetView **swapchainRenderTarget = &_swapchainRenderTarget)
ThrowIfFailed(_d3dDevice->CreateRenderTargetView(pBackBuffer.Get(), null, swapchainRenderTarget));
pBackBuffer.Dispose();
fixed(ID3D11RenderTargetView **swapchainRenderTarget = &_swapchainRenderTarget)
_d3dctx->OMSetRenderTargets(1, swapchainRenderTarget, null);
ID3DBlob *VS, PS, pErrBlob;
using ComPtr <ID3DBlob> vertexShaderBlob = null;
fixed(byte *shader = Encoding.ASCII.GetBytes(DefaultShaders.HLSL))
fixed(byte *vshader = Encoding.ASCII.GetBytes("VShader"))
fixed(byte *vs4 = Encoding.ASCII.GetBytes("vs_4_0"))
fixed(byte *pshader = Encoding.ASCII.GetBytes("PShader"))
fixed(byte *ps4 = Encoding.ASCII.GetBytes("ps_4_0"))
{
var result = D3DCompile(shader, (nuint)DefaultShaders.HLSL.Length, null, null, null, (sbyte *)vshader, (sbyte *)vs4, 0, 0, &VS, &pErrBlob);
if (FAILED(result) && pErrBlob != null)
{
var errorMessage = Encoding.ASCII.GetString((byte *)pErrBlob->GetBufferPointer(), (int)pErrBlob->GetBufferSize());
Debug.WriteLine(errorMessage);
ThrowIfFailed(result);
}
result = D3DCompile(shader, (nuint)DefaultShaders.HLSL.Length, null, null, null, (sbyte *)pshader, (sbyte *)ps4, 0, 0, &PS, &pErrBlob);
if (FAILED(result) && pErrBlob != null)
{
var errorMessage = Encoding.ASCII.GetString((byte *)pErrBlob->GetBufferPointer(), (int)pErrBlob->GetBufferSize());
Debug.WriteLine(errorMessage);
ThrowIfFailed(result);
}
}
fixed(ID3D11VertexShader **vertexShader = &pVS)
fixed(ID3D11PixelShader **pixelShader = &pPS)
{
ThrowIfFailed(_d3dDevice->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), null, vertexShader));
ThrowIfFailed(_d3dDevice->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), null, pixelShader));
}
fixed(byte *position = Encoding.ASCII.GetBytes("POSITION"))
fixed(byte *textcoord = Encoding.ASCII.GetBytes("TEXCOORD"))
fixed(ID3D11InputLayout **shadersInputLayout = &pShadersInputLayout)
{
var inputElementDescs = stackalloc D3D11_INPUT_ELEMENT_DESC[2];
{
inputElementDescs[0] = new D3D11_INPUT_ELEMENT_DESC
{
SemanticName = (sbyte *)position,
SemanticIndex = 0,
Format = DXGI_FORMAT_R32G32B32_FLOAT,
InputSlot = 0,
AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT,
InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA,
InstanceDataStepRate = 0
};
inputElementDescs[1] = new D3D11_INPUT_ELEMENT_DESC
{
SemanticName = (sbyte *)textcoord,
SemanticIndex = 0,
Format = DXGI_FORMAT_R32G32_FLOAT,
InputSlot = 0,
AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT,
InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA,
InstanceDataStepRate = 0
};
}
ThrowIfFailed(_d3dDevice->CreateInputLayout(inputElementDescs, 2, VS->GetBufferPointer(), VS->GetBufferSize(), shadersInputLayout));
}
var ourVerticles = new ShaderInput[4];
ourVerticles[0] = new ShaderInput
{
position = new Position
{
x = BORDER_LEFT,
y = BORDER_BOTTOM,
z = 0.0f
},
texture = new Texture {
x = 0.0f, y = 1.0f
}
};
ourVerticles[1] = new ShaderInput
{
position = new Position
{
x = BORDER_RIGHT,
y = BORDER_BOTTOM,
z = 0.0f
},
texture = new Texture {
x = 1.0f, y = 1.0f
}
};
ourVerticles[2] = new ShaderInput
{
position = new Position
{
x = BORDER_RIGHT,
y = BORDER_TOP,
z = 0.0f
},
texture = new Texture {
x = 1.0f, y = 0.0f
}
};
ourVerticles[3] = new ShaderInput
{
position = new Position
{
x = BORDER_LEFT,
y = BORDER_TOP,
z = 0.0f
},
texture = new Texture {
x = 0.0f, y = 0.0f
}
};
var verticlesSize = (uint)sizeof(ShaderInput) * 4;
var bd = new D3D11_BUFFER_DESC
{
Usage = D3D11_USAGE_DYNAMIC,
ByteWidth = verticlesSize,
BindFlags = (uint)D3D11_BIND_VERTEX_BUFFER,
CPUAccessFlags = (uint)D3D11_CPU_ACCESS_WRITE
};
pVertexBuffer = CreateBuffer(bd);
vertexBufferStride = Marshal.SizeOf(ourVerticles[0]);
D3D11_MAPPED_SUBRESOURCE ms;
ID3D11Resource *res;
iid = IID_ID3D11Resource;
ThrowIfFailed(pVertexBuffer->QueryInterface(&iid, (void **)&res));
ThrowIfFailed(_d3dctx->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &ms));
for (var i = 0; i < ourVerticles.Length; i++)
{
Marshal.StructureToPtr(ourVerticles[i], (IntPtr)ms.pData + (i * vertexBufferStride), false);
}
//Buffer.MemoryCopy(ms.pData, ourVerticles, verticlesSize, verticlesSize);
_d3dctx->Unmap(res, 0);
quadIndexCount = 6;
var bufferDesc = new D3D11_BUFFER_DESC
{
Usage = D3D11_USAGE_DYNAMIC,
ByteWidth = sizeof(ushort) * quadIndexCount,
BindFlags = (uint)D3D11_BIND_INDEX_BUFFER,
CPUAccessFlags = (uint)D3D11_CPU_ACCESS_WRITE
};
pIndexBuffer = CreateBuffer(bufferDesc);
ThrowIfFailed(pIndexBuffer->QueryInterface(&iid, (void **)&res));
ThrowIfFailed(_d3dctx->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &ms));
Marshal.WriteInt16((IntPtr)ms.pData, 0 * sizeof(ushort), 3);
Marshal.WriteInt16((IntPtr)ms.pData, 1 * sizeof(ushort), 1);
Marshal.WriteInt16((IntPtr)ms.pData, 2 * sizeof(ushort), 0);
Marshal.WriteInt16((IntPtr)ms.pData, 3 * sizeof(ushort), 2);
Marshal.WriteInt16((IntPtr)ms.pData, 4 * sizeof(ushort), 1);
Marshal.WriteInt16((IntPtr)ms.pData, 5 * sizeof(ushort), 3);
_d3dctx->Unmap(res, 0);
_d3dctx->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_d3dctx->IASetInputLayout(pShadersInputLayout);
uint offset = 0;
var vv = (uint)vertexBufferStride;
fixed(ID3D11Buffer **buffer = &pVertexBuffer)
_d3dctx->IASetVertexBuffers(0, 1, buffer, &vv, &offset);
_d3dctx->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
_d3dctx->VSSetShader(pVS, null, 0);
_d3dctx->PSSetShader(pPS, null, 0);
var samplerDesc = new D3D11_SAMPLER_DESC
{
Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT,
AddressU = D3D11_TEXTURE_ADDRESS_CLAMP,
AddressV = D3D11_TEXTURE_ADDRESS_CLAMP,
AddressW = D3D11_TEXTURE_ADDRESS_CLAMP,
ComparisonFunc = D3D11_COMPARISON_ALWAYS,
MinLOD = 0,
MaxLOD = D3D11_FLOAT32_MAX
};
fixed(ID3D11SamplerState **ss = &samplerState)
{
ThrowIfFailed(_d3dDevice->CreateSamplerState(&samplerDesc, ss));
_d3dctx->PSSetSamplers(0, 1, ss);
}
fixed(RTL_CRITICAL_SECTION *sl = &sizeLock)
InitializeCriticalSection(sl);
}
