public override void UpdateBuffers(ID3D11Device device, ID3D11DeviceContext deviceContext)
{
if (bIsUpdatedNeeded)
{
//todo: implement this!
}
}
public static Result D3D11On12CreateDevice(
IUnknown d3d12Device,
DeviceCreationFlags flags,
FeatureLevel[] featureLevels,
IUnknown[] commandQueues,
int nodeMask,
out ID3D11Device device,
out ID3D11DeviceContext immediateContext,
out FeatureLevel chosenFeatureLevel)
{
Result result = D3D11On12CreateDevice(d3d12Device,
flags,
featureLevels, featureLevels.Length,
commandQueues, commandQueues.Length,
nodeMask,
out device, out immediateContext, out chosenFeatureLevel);
if (result.Failure)
{
return(result);
}
if (immediateContext != null)
{
device.AddRef();
device.ImmediateContext__ = immediateContext;
immediateContext.Device__ = device;
}
return(result);
}
public void RenderPrimitives(ID3D11Device InDevice, ID3D11DeviceContext InDeviceContext, Camera InCamera)
{
foreach (PrimitiveBatch Batch in Batches.Values)
{
Batch.RenderBatch(InDevice, InDeviceContext, InCamera);
}
}
public D3D11ResourceFactory(D3D11GraphicsDevice gd)
: base(gd.Features)
{
_gd = gd;
_device = gd.Device;
_cache = new D3D11ResourceCache(_device);
}
private static Result RawD3D11CreateDeviceNoContext(
IntPtr adapterPtr,
DriverType driverType,
DeviceCreationFlags flags,
FeatureLevel[] featureLevels,
out ID3D11Device?device,
out FeatureLevel featureLevel)
{
device = default;
fixed(void *featureLevelsPtr = &featureLevels[0])
fixed(void *featureLevelPtr = &featureLevel)
{
IntPtr devicePtr = IntPtr.Zero;
Result result = D3D11CreateDevice_(
(void *)adapterPtr,
(int)driverType,
null,
(int)flags,
featureLevels != null && featureLevels.Length > 0 ? featureLevelsPtr : null,
featureLevels?.Length ?? 0,
SdkVersion,
&devicePtr,
featureLevelPtr,
null);
if (result.Success && devicePtr != IntPtr.Zero)
{
device = new ID3D11Device(devicePtr);
}
return(result);
}
}
public IntPtr GetPtr(ID3D11Device device)
{
if (!m_buffer)
{
var desc = new D3D11_BUFFER_DESC
{
ByteWidth = (uint)m_bytes.Length,
Usage = D3D11_USAGE._DEFAULT,
BindFlags = (uint)m_bind,
};
if (MemoryMarshal.TryGetArray(m_bytes, out ArraySegment <byte> bytes))
{
using (var pin = PinPtr.Create(bytes))
{
var data = new D3D11_SUBRESOURCE_DATA
{
pSysMem = pin.Ptr
};
device.CreateBuffer(ref desc, ref data,
out m_buffer).ThrowIfFailed();
}
}
}
return(m_buffer.Ptr);
}
public void Render(ID3D11Device device, ID3D11DeviceContext deviceContext, Camera camera)
{
if (bIsReady)
{
if (currentCell != -1)
{
cells[currentCell].Render(device, deviceContext, camera);
}
foreach (var cell in cells)
{
cell.Render(device, deviceContext, camera);
}
/*cellBoundingBox.Render(device, deviceContext, camera);
* currentCell = GetCell(camera.Position);
* //cells[currentCell].Render(device, deviceContext, camera);
* //Debug.WriteLine(cells[currentCell].BoundingBox.ToString());
* if (previousCell != currentCell)
* {
* BoundingBox newBounds = cells[currentCell].BoundingBox;
* newBounds.Minimum.Z = gridBounds.Minimum.Z;
* newBounds.Maximum.Z = gridBounds.Maximum.Z;
*
* cellBoundingBox.Update(newBounds);
* cellBoundingBox.UpdateBuffers(device, deviceContext);
* previousCell = currentCell;
* }
* boundingBox.Render(device, deviceContext, camera);
*/
}
}
public static IComObject <ID3D11InputLayout> CreateInputLayout(this ID3D11Device device, D3D11_INPUT_ELEMENT_DESC[] inputElements, ID3D10Blob blob)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
if (blob == null)
{
throw new ArgumentNullException(nameof(blob));
}
if (inputElements == null)
{
throw new ArgumentNullException(nameof(inputElements));
}
if (inputElements.Length == 0)
{
throw new ArgumentException(null, nameof(inputElements));
}
device.CreateInputLayout(inputElements, inputElements.Length, blob.GetBufferPointer(), blob.GetBufferSize(), out var layout).ThrowOnError();
return(new ComObject <ID3D11InputLayout>(layout));
}
public override void Render(ID3D11Device device, ID3D11DeviceContext deviceContext, Camera camera)
{
if (!DoRender)
{
return;
}
//if (!camera.CheckBBoxFrustum(Transform.TranslationVector, BoundingBox))
// return;
VertexBufferView VertexBufferView = new VertexBufferView(vertexBuffer, Unsafe.SizeOf <VertexLayouts.NormalLayout.Vertex>(), 0);
deviceContext.IASetVertexBuffers(0, VertexBufferView);
deviceContext.IASetIndexBuffer(indexBuffer, Vortice.DXGI.Format.R32_UInt, 0);
deviceContext.IASetPrimitiveTopology(PrimitiveTopology.TriangleList);
deviceContext.PSSetShaderResource(2, AOTexture);
for (int i = 0; i != LODs[0].ModelParts.Length; i++)
{
ModelPart Segment = LODs[0].ModelParts[i];
Segment.Shader.SetShaderParameters(device, deviceContext, new MaterialParameters(Segment.Material, SelectionColour.Normalize()));
Segment.Shader.SetSceneVariables(deviceContext, Transform, camera);
Segment.Shader.Render(deviceContext, PrimitiveTopology.TriangleList, (int)(Segment.NumFaces * 3), Segment.StartIndex);
}
}
public void Initialise(ID3D11Device device, ID3D11DeviceContext deviceContext)
{
foreach (KeyValuePair <int, IRenderer> entry in assets)
{
entry.Value.InitBuffers(device, deviceContext);
}
}
public override void InitBuffers(ID3D11Device d3d, ID3D11DeviceContext d3dContext)
{
vertexBuffer = d3d.CreateBuffer(BindFlags.VertexBuffer, LODs[0].Vertices, 0, ResourceUsage.Default, CpuAccessFlags.None);
indexBuffer = d3d.CreateBuffer(BindFlags.IndexBuffer, LODs[0].Indices, 0, ResourceUsage.Default, CpuAccessFlags.None);
InitTextures(d3d, d3dContext);
}
public virtual void SetShaderParameters(ID3D11Device device, ID3D11DeviceContext deviceContext, MaterialParameters matParams)
{
if (!previousEditorParams.Equals(matParams.SelectionColour))
{
var editorParams = new EditorParameterBuffer()
{
selectionColour = matParams.SelectionColour
};
ConstantBufferFactory.UpdatePixelBuffer(deviceContext, ConstantEditorParamsBuffer, 1, editorParams);
previousEditorParams = editorParams.selectionColour;
}
//experiments with samplers; currently the toolkit doesn't not support any types.
/*SamplerStateDescription samplerDesc = new SamplerStateDescription()
* {
* Filter = Filter.Anisotropic,
* AddressU = (material != null) ? (TextureAddressMode)material.Samplers["S000"].SamplerStates[0] : TextureAddressMode.Wrap,
* AddressV = (material != null) ? (TextureAddressMode)material.Samplers["S000"].SamplerStates[1] : TextureAddressMode.Wrap,
* AddressW = (material != null) ? (TextureAddressMode)material.Samplers["S000"].SamplerStates[2] : TextureAddressMode.Wrap,
* MipLodBias = 0,
* MaximumAnisotropy = 16,
* ComparisonFunction = Comparison.Always,
* BorderColor = new Color4(0, 0, 0, 0),
* MinimumLod = 0,
* MaximumLod = float.MaxValue
* };
*
* SamplerState = new SamplerState(device, samplerDesc);*/
}
public BaseShader(ID3D11Device Dx11Device, ShaderInitParams InitParams)
{
if (!Init(Dx11Device, InitParams))
{
MessageBox.Show("Failed to construct shader!", "Toolkit");
}
}
public static IComObject <ID3D11InputLayout> CreateInputLayout(this ID3D11Device device, D3D11_INPUT_ELEMENT_DESC[] inputElements, IntPtr shaderBytecodeWithInputSignature, IntPtr bytecodeLength)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
if (inputElements == null)
{
throw new ArgumentNullException(nameof(inputElements));
}
if (inputElements.Length == 0)
{
throw new ArgumentException(null, nameof(inputElements));
}
foreach (var element in inputElements)
{
if (element.SemanticName == null)
{
throw new ArgumentException(null, nameof(inputElements));
}
}
device.CreateInputLayout(inputElements, inputElements.Length, shaderBytecodeWithInputSignature, bytecodeLength, out var layout).ThrowOnError();
return(new ComObject <ID3D11InputLayout>(layout));
}
public override void InitBuffers(ID3D11Device d3d, ID3D11DeviceContext context)
{
if (vertices.Length != 0)
{
vertexBuffer = d3d.CreateBuffer(BindFlags.VertexBuffer, vertices, 0, ResourceUsage.Dynamic, CpuAccessFlags.Write);
}
}
public void Setup(ID3D11Device device, ID3D11DeviceContext context)
{
if (!m_vertexAttributes.Any())
{
return;
}
if (!m_inputLayout)
{
var hr = device.CreateVertexShader(m_vs_blob.GetBufferPointer(), m_vs_blob.GetBufferSize(), null, out m_vs);
hr.ThrowIfFailed();
hr = device.CreatePixelShader(m_ps_blob.GetBufferPointer(), m_ps_blob.GetBufferSize(), null, out m_ps);
hr.ThrowIfFailed();
hr = device.CreateInputLayout(ref m_layout[0], (uint)m_layout.Length,
m_vs_blob.GetBufferPointer(), m_vs_blob.GetBufferSize(), out m_inputLayout);
hr.ThrowIfFailed();
}
// setup shader pipeline
Span <IntPtr> classes = stackalloc IntPtr[] { };
context.VSSetShader(m_vs, ref MemoryMarshal.GetReference(classes), (uint)classes.Length);
context.PSSetShader(m_ps, ref MemoryMarshal.GetReference(classes), (uint)classes.Length);
context.IASetInputLayout(m_inputLayout);
}
public static Result D3D11CreateDevice(IntPtr adapterPtr, DriverType driverType, DeviceCreationFlags flags, FeatureLevel[] featureLevels,
out ID3D11Device device, out FeatureLevel featureLevel, out ID3D11DeviceContext immediateContext)
{
Result result = D3D11CreateDevice(adapterPtr, driverType, IntPtr.Zero,
(int)flags,
featureLevels,
(featureLevels != null) ? featureLevels.Length : 0,
SdkVersion,
out device,
out featureLevel,
out immediateContext);
if (result.Failure)
{
return(result);
}
#if TEST
if (immediateContext != null)
{
device.AddRef();
device.ImmediateContext__ = immediateContext;
immediateContext.Device__ = device;
}
#endif
return(result);
}
public override void Render(ID3D11Device device, ID3D11DeviceContext deviceContext, Camera camera)
{
if (DoRender != false)
{
BBox.Render(device, deviceContext, camera);
Path.Render(device, deviceContext, camera);
}
}
public void Render(ID3D11Device device, ID3D11DeviceContext deviceContext, Camera camera)
{
/*foreach (KeyValuePair<int, IRenderer> entry in assets)
* {
* entry.Value.UpdateBuffers(device, deviceContext);
* entry.Value.Render(device, deviceContext, camera);
* }*/
}
public override void UpdateBuffers(ID3D11Device device, ID3D11DeviceContext deviceContext)
{
if (bIsUpdatedNeeded)
{
SetupShaders();
InitTextures(device, deviceContext);
bIsUpdatedNeeded = false;
}
}
public bool Init(ID3D11Device device)
{
// construct default shader
ShaderInitParams DefaultInitParams = new ShaderInitParams();
DefaultInitParams.Elements = VertexLayouts.NormalLayout.GetLayout();
DefaultInitParams.PixelShaderFile = new ShaderInitParams.ShaderFileEntryPoint("LightPS.hlsl", "LightPixelShader", "ps_4_0");
DefaultInitParams.VertexShaderFile = new ShaderInitParams.ShaderFileEntryPoint("LightVS.hlsl", "LightVertexShader", "vs_4_0");
DefaultShader OurDefaultShader = new DefaultShader(device, DefaultInitParams);
// construct debug shader
ShaderInitParams DebugInitParams = new ShaderInitParams();
DebugInitParams.Elements = VertexLayouts.BasicLayout.GetLayout();
DebugInitParams.PixelShaderFile = new ShaderInitParams.ShaderFileEntryPoint("DebugPS.hlsl", "DebugPixelShader", "ps_4_0");
DebugInitParams.VertexShaderFile = new ShaderInitParams.ShaderFileEntryPoint("DebugVS.hlsl", "DebugVertexShader", "vs_4_0");
DebugShader OurDebugShader = new DebugShader(device, DebugInitParams);
// construct collision shader
ShaderInitParams CollisionInitParams = new ShaderInitParams();
CollisionInitParams.Elements = VertexLayouts.CollisionLayout.GetLayout();
CollisionInitParams.PixelShaderFile = new ShaderInitParams.ShaderFileEntryPoint("CollisionPS.hlsl", "CollisionShader", "ps_4_0");
CollisionInitParams.VertexShaderFile = new ShaderInitParams.ShaderFileEntryPoint("CollisionVS.hlsl", "CollisionShader", "vs_4_0");
CollisionShader OurCollisionShader = new CollisionShader(device, CollisionInitParams);
// construct shader_601151254 shader
ShaderInitParams Shader601151254_InitParams = new ShaderInitParams();
Shader601151254_InitParams.Elements = VertexLayouts.NormalLayout.GetLayout();
Shader601151254_InitParams.PixelShaderFile = new ShaderInitParams.ShaderFileEntryPoint("LightPS.hlsl", "PS_601151254", "ps_4_0");
Shader601151254_InitParams.VertexShaderFile = new ShaderInitParams.ShaderFileEntryPoint("LightVS.hlsl", "LightVertexShader", "vs_4_0");
Shader_601151254 OurShader601151254 = new Shader_601151254(device, Shader601151254_InitParams);
// construct shader_50760736 shader
ShaderInitParams Shader_50760736_InitParams = new ShaderInitParams();
Shader_50760736_InitParams.Elements = VertexLayouts.NormalLayout.GetLayout();
Shader_50760736_InitParams.PixelShaderFile = new ShaderInitParams.ShaderFileEntryPoint("LightPS.hlsl", "PS_50760736", "ps_4_0");
Shader_50760736_InitParams.VertexShaderFile = new ShaderInitParams.ShaderFileEntryPoint("LightVS.hlsl", "LightVertexShader", "vs_4_0");
Shader_50760736 OurShader50760736 = new Shader_50760736(device, Shader_50760736_InitParams);
shaders = new Dictionary <ulong, BaseShader>();
shaders.Add(0, OurDefaultShader);
shaders.Add(1, OurDebugShader);
shaders.Add(2, OurCollisionShader);
shaders.Add(601151254, OurShader601151254);
shaders.Add(50760736, OurShader50760736);
return(true);
}
public override void Render(ID3D11Device device, ID3D11DeviceContext deviceContext, Camera camera)
{
if (!DoRender)
{
return;
}
instance.SetTransform(Transform);
instance.Render(device, deviceContext, camera);
}
public static IComObject <ID3D11VertexShader> CreateVertexShader(this ID3D11Device device, IntPtr shaderBytecode, int bytecodeLength, ID3D11ClassLinkage classLinkage = null)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
device.CreateVertexShader(shaderBytecode, (IntPtr)bytecodeLength, classLinkage, out var shader).ThrowOnError();
return(new ComObject <ID3D11VertexShader>(shader));
}
public override void UpdateBuffers(ID3D11Device device, ID3D11DeviceContext deviceContext)
{
if (vertexBuffer != null)
{
vertexBuffer.Dispose();
vertexBuffer = null;
}
InitBuffers(device, deviceContext);
bIsUpdatedNeeded = false;
}
public static IComObject <ID3D11DeviceContext> GetImmediateContext(this ID3D11Device obj)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
obj.GetImmediateContext(out var value);
return(value != null ? new ComObject <ID3D11DeviceContext>(value) : null);
}
public static IComObject <ID3D11RasterizerState> CreateRasterizerState(this ID3D11Device device, D3D11_RASTERIZER_DESC desc)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
device.CreateRasterizerState(ref desc, out var state).ThrowOnError();
return(new ComObject <ID3D11RasterizerState>(state));
}
public Device(ID3D11Device device, ID3D11RenderTargetView renderTarget, ID3D11DepthStencilView depthStencilView, ID3DCompiler compiler)
{
_device = device ?? throw new ArgumentNullException(nameof(device));
_renderTarget = renderTarget ?? throw new ArgumentNullException(nameof(renderTarget));
_depthStencilView = depthStencilView ?? throw new ArgumentNullException(nameof(depthStencilView));
ImmediateContext = new DeviceContext(device.Context, false);
BackBuffer = new RenderTarget(renderTarget);
DepthStencil = new DepthStencil(depthStencilView);
TEMPORARYCompiler = compiler;
}
public static IComObject <ID3D11BlendState> CreateBlendState(this ID3D11Device device, D3D11_BLEND_DESC desc)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
device.CreateBlendState(ref desc, out var state).ThrowOnError();
return(new ComObject <ID3D11BlendState>(state));
}
public static IComObject <ID3D11DepthStencilState> CreateDepthStencilState(this ID3D11Device device, D3D11_DEPTH_STENCIL_DESC desc)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
device.CreateDepthStencilState(ref desc, out var state).ThrowOnError();
return(new ComObject <ID3D11DepthStencilState>(state));
}
public static IComObject <T> CreateTexture2D <T>(this ID3D11Device device, D3D11_TEXTURE2D_DESC desc, D3D11_SUBRESOURCE_DATA[] initialData = null) where T : ID3D11Texture2D
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
device.CreateTexture2D(ref desc, initialData, out var texture).ThrowOnError();
return(new ComObject <T>((T)texture));
}
