public ObjRenderer(Form1 F)
: base(F.Device)
{
P = F;
PortalRoomManager.Equals(null, null);
S = new Sorter();
string s0 = Environment.CurrentDirectory + "/resources/shaders/ambient_fast.fx";
SB_V = ShaderBytecode.CompileFromFile(s0, "VS_STATIC", "vs_4_0", ManagedSettings.ShaderCompileFlags, EffectFlags.None);
SB_P = ShaderBytecode.CompileFromFile(s0, "PS", "ps_4_0", ManagedSettings.ShaderCompileFlags, EffectFlags.None);
VS = new VertexShader(F.Device.HadrwareDevice(), SB_V);
PS = new PixelShader(F.Device.HadrwareDevice(), SB_P);
IL = new InputLayout(Device.HadrwareDevice(), SB_V, StaticVertex.ies);
BufferDescription desc = new BufferDescription
{
Usage = ResourceUsage.Default,
SizeInBytes = 2 * 64,
BindFlags = BindFlags.ConstantBuffer
};
cBuf = new SlimDX.Direct3D11.Buffer(Device.HadrwareDevice(), desc);
dS = new DataStream(2 * 64, true, true);
BufferDescription desc2 = new BufferDescription
{
Usage = ResourceUsage.Default,
SizeInBytes = 64,
BindFlags = BindFlags.ConstantBuffer
};
cBuf2 = new SlimDX.Direct3D11.Buffer(Device.HadrwareDevice(), desc2);
dS2 = new DataStream(64, true, true);
}
public ShaderPipelineState(DX11RenderContext renderContext)
{
var context = renderContext.CurrentDeviceContext;
this.VertexShader = context.VertexShader.Get();
this.HullShader = context.HullShader.Get();
this.DomainShader = context.DomainShader.Get();
this.GeometryShader = context.GeometryShader.Get();
this.PixelShader = context.PixelShader.Get();
}
public unsafe EarthBaseEffect(RenderSystem rs)
: base(false, EarthBaseEffectFactory.Name)
{
this.renderSys = rs;
FileLocation fl = FileSystem.Instance.Locate("earthbase.cvs", GameFileLocs.Effect);
vtxShader = LoadVertexShader(renderSys, fl);
fl = FileSystem.Instance.Locate("earthbase.cps", GameFileLocs.Effect);
pixShader = LoadPixelShader(renderSys, fl);
}
public unsafe CityLinkEffect(RenderSystem rs)
: base(rs, CityLinkEffectFactory.Name, false)
{
this.renderSys = rs;
FileLocation fl = FileSystem.Instance.Locate("citylink.cvs", GameFileLocs.Effect);
vtxShader = LoadVertexShader(renderSys, fl);
fl = FileSystem.Instance.Locate("citylink.cps", GameFileLocs.Effect);
pixShader = LoadPixelShader(renderSys, fl);
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderBase" /> class.
/// </summary>
/// <param name="device">The device.</param>
/// <param name="vertexShaderPath">The vertex shader file path.</param>
/// <param name="pixelShaderPath">The pixel shader file path.</param>
protected ShaderBase(Device device, string vertexShaderPath, string pixelShaderPath, IInputLayoutProvider inputLayoutMaker)
{
ShaderSignature inputSignature;
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(vertexShaderPath, "VShader", "vs_4_0", ShaderFlags.None, EffectFlags.None))
{
vertexShader = new VertexShader(device, bytecode);
inputSignature = ShaderSignature.GetInputSignature(bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(pixelShaderPath, "PShader", "ps_4_0", ShaderFlags.None, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
inputLayout = inputLayoutMaker.MakeInputLayout(device, inputSignature);
}
public void SetPixelShader(PixelShader pixelShader)
{
#if DEBUG_STATE_MANAGER
var s = device.PixelShader;
if (this.pixelShader != s)
throw new Exception("State inconsistent, " + pixelShader + " != " + s);
#endif
if (this.pixelShader != pixelShader)
{
device.PixelShader = pixelShader;
this.pixelShader = pixelShader;
}
}
public unsafe RigidEffect(RenderSystem rs, string name, bool inst)
: base(inst, name)
{
FileLocation fl = FileSystem.Instance.Locate("shadowMap.cvs", GameFileLocs.Effect);
shdVtxShader = LoadVertexShader(rs, fl);
fl = FileSystem.Instance.Locate("shadowMap.cps", GameFileLocs.Effect);
shdPixShader = LoadPixelShader(rs, fl);
fl = FileSystem.Instance.Locate("normalGen.cvs", GameFileLocs.Effect);
nrmGenVShader = LoadVertexShader(rs, fl);
fl = FileSystem.Instance.Locate("normalGen.cps", GameFileLocs.Effect);
nrmGenPShader = LoadPixelShader(rs, fl);
}
public WaterEffect(RenderSystem renderSystem)
: base(false, WaterEffectFactory.Name)
{
this.renderSystem = renderSystem;
FileLocation fl = FileSystem.Instance.Locate("water.cvs", GameFileLocs.Effect);
vtxShader = LoadVertexShader(renderSystem, fl);
fl = FileSystem.Instance.Locate("water.cps", GameFileLocs.Effect);
pixShader = LoadPixelShader(renderSystem, fl);
fl = FileSystem.Instance.Locate("waterNormalGen.cvs", GameFileLocs.Effect);
nrmGenVS = LoadVertexShader(renderSystem, fl);
fl = FileSystem.Instance.Locate("waterNormalGen.cps", GameFileLocs.Effect);
nrmGenPS = LoadPixelShader(renderSystem, fl);
fl = FileSystem.Instance.Locate("reflection.tex", GameFileLocs.Nature);
reflection = TextureManager.Instance.CreateInstance(fl);
}
protected virtual void Dispose(bool disposable)
{
if (vertexShader != null)
{
vertexShader.Dispose();
vertexShader = null;
}
if (pixelShader != null)
{
pixelShader.Dispose();
pixelShader = null;
}
if (inputLayout != null)
{
inputLayout.Dispose();
vertexShader = null;
}
}
protected override void Dispose(bool disposeManaged)
{
base.Dispose(disposeManaged);
if (Shader != null) { Shader.Dispose(); Shader = null; }
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var form = new Form1();
Device device;
SwapChain swapChain;
ShaderSignature inputSignature;
VertexShader vertexShader;
GeometryShader geometryShader;
PixelShader pixelShader;
var description = new SwapChainDescription()
{
BufferCount = 2,
Usage = Usage.RenderTargetOutput,
OutputHandle = form.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(1, 0),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard
};
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, description, out device, out swapChain);
// create a view of our render target, which is the backbuffer of the swap chain we just created
RenderTargetView renderTarget;
using (var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0))
renderTarget = new RenderTargetView(device, resource);
// setting a viewport is required if you want to actually see anything
var context = device.ImmediateContext;
var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
context.OutputMerger.SetTargets(renderTarget);
context.Rasterizer.SetViewports(viewport);
// load and compile the vertex shader
using (var bytecode = ShaderBytecode.CompileFromFile("Voxel.fx", "VS", "vs_4_0", ShaderFlags.None, EffectFlags.None))
{
inputSignature = ShaderSignature.GetInputSignature(bytecode);
vertexShader = new VertexShader(device, bytecode);
}
using (var bytecode = ShaderBytecode.CompileFromFile("Voxel.fx", "GS", "gs_4_0", ShaderFlags.None, EffectFlags.None))
{
geometryShader = new GeometryShader(device, bytecode);
}
// load and compile the pixel shader
using (var bytecode = ShaderBytecode.CompileFromFile("Voxel.fx", "PS", "ps_4_0", ShaderFlags.None, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
// create test vertex data, making sure to rewind the stream afterward
var vertices = new DataStream(12 * 3, true, true);
vertices.Write(new Vector3(0.0f, 0.5f, 0.5f));
vertices.Write(new Vector3(0.5f, -0.5f, 0.5f));
vertices.Write(new Vector3(-0.5f, -0.5f, 0.5f));
vertices.Position = 0;
// create the vertex layout and buffer
var elements = new[] { new InputElement("POSITION", 0, Format.R32G32B32_Float, 0) };
var layout = new InputLayout(device, inputSignature, elements);
var vertexBuffer = new Buffer(device, vertices, 12 * 3, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
// configure the Input Assembler portion of the pipeline with the vertex data
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, 12, 0));
// set the shaders
context.VertexShader.Set(vertexShader);
// context.GeometryShader.Set(geometryShader);
context.PixelShader.Set(pixelShader);
// prevent DXGI handling of alt+enter, which doesn't work properly with Winforms
using (var factory = swapChain.GetParent<Factory>())
factory.SetWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAltEnter);
// handle alt+enter ourselves
form.KeyDown += (o, e) =>
{
if (e.Alt && e.KeyCode == Keys.Enter)
swapChain.IsFullScreen = !swapChain.IsFullScreen;
};
// handle form size changes
form.Resize += (o, e) =>
{
renderTarget.Dispose();
swapChain.ResizeBuffers(2, 0, 0, Format.R8G8B8A8_UNorm, SwapChainFlags.AllowModeSwitch);
using (var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0))
renderTarget = new RenderTargetView(device, resource);
context.OutputMerger.SetTargets(renderTarget);
};
MessagePump.Run(form, () =>
{
// clear the render target to a soothing blue
context.ClearRenderTargetView(renderTarget, new Color4(0.5f, 0.5f, 1.0f));
// draw the triangle
context.Draw(3, 0);
swapChain.Present(0, PresentFlags.None);
});
// clean up all resources
// anything we missed will show up in the debug output
vertices.Close();
vertexBuffer.Dispose();
layout.Dispose();
inputSignature.Dispose();
vertexShader.Dispose();
geometryShader.Dispose();
pixelShader.Dispose();
renderTarget.Dispose();
swapChain.Dispose();
device.Dispose();
}
/// <summary>
/// Creates an instance of the shader from the included pixel shader.
/// </summary>
static SwirlEffect()
{
pixelShader = new PixelShader();
pixelShader.UriSource = Global.MakePackUri("ShaderSource/Swirl.ps");
}
private void CreatePixelShader()
{
System.Diagnostics.Debug.Assert(Stage == ShaderStage.Pixel);
_pixelShader = new PixelShader(GraphicsDevice._d3dDevice, _shaderBytecode);
}
/// <summary>
/// Creates an instance of the shader from the included pixel shader.
/// </summary>
static BloomEffect()
{
pixelShader = new PixelShader();
pixelShader.UriSource = new Uri(@"pack://application:,,,/Terminal;component/MyEffects/Bloom.ps");
}
protected void LoadPixelShader(RenderSystem rs, ResourceLocation vs)
{
ObjectFactory fac = rs.ObjectFactory;
pixShader = fac.CreatePixelShader(vs);
}
public WorldWaterShader(Device device)
{
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(ShaderFileName, "WaterVertexShader", "vs_4_0", ShaderFlags);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(ShaderFileName, "WaterPixelShader", "ps_4_0", ShaderFlags);
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
Layout = VertexDefinition.WaterVertex.GetInputLayout(device, vertexShaderByteCode);
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
ConstantMatrixBuffer = new Buffer(device, MatrixBufferDesription);
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var translateBufferDesc = new BufferDescription
{
Usage = ResourceUsage.Dynamic, // Updated each frame
SizeInBytes = Utilities.SizeOf <TranslationBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
ConstantTranslationBuffer = new Buffer(device, translateBufferDesc);
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var lightBufferDesc = new BufferDescription
{
Usage = ResourceUsage.Dynamic, // Updated each frame
SizeInBytes = Utilities.SizeOf <LightBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
ConstantLightBuffer = new Buffer(device, lightBufferDesc);
// Create a texture sampler state description.
var samplerDescWrap = new SamplerStateDescription
{
Filter = Filter.MinLinearMagPointMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
MipLodBias = 0,
MaximumAnisotropy = 1,
ComparisonFunction = Comparison.Always,
BorderColor = new Color4(0, 0, 0, 0),
MinimumLod = 0,
MaximumLod = float.MaxValue
};
// Create the texture sampler state.
SamplerStateWrap = new SamplerState(device, samplerDescWrap);
var samplerDescBorder = new SamplerStateDescription
{
Filter = Filter.Anisotropic,
AddressU = TextureAddressMode.MirrorOnce,
AddressV = TextureAddressMode.Border,
AddressW = TextureAddressMode.Border,
MipLodBias = 0,
MaximumAnisotropy = 16,
ComparisonFunction = Comparison.Always,
BorderColor = Color.Transparent,
MinimumLod = 0,
MaximumLod = float.MaxValue
};
// Create the texture sampler state.
SamplerStateBorder = new SamplerState(device, samplerDescBorder);
}
private bool InitializeShader(Device device, IntPtr windowsHandler)
{
try
{
try
{
/*string vsFileName = "../../../sc_instance_shader/" + "InstancedTexture.vs";
* string psFileName = "../../../sc_instance_shader/" + "InstancedTexture.ps";
*
* vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "TextureVertexShader", "vs_4_0", ShaderFlags.None, EffectFlags.None);
* pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "TexturePixelShader", "ps_4_0", ShaderFlags.None, EffectFlags.None);
*/
/*
* if (Program.is_wpf == 1)
* {
* string vsFileName = SCCoreSystems.Properties.Resources.InstancedTexture1;// "../../../_sc_instance_shader/" + "texture.vs";
* string psFileName = SCCoreSystems.Properties.Resources.InstancedTexture;// "../../../_sc_instance_shader/" + "texture.ps";
*
* vertexShaderByteCode = ShaderBytecode.Compile(vsFileName, "TextureVertexShader", "vs_4_0", ShaderFlags.None, SharpDX.D3DCompiler.EffectFlags.None);
* pixelShaderByteCode = ShaderBytecode.Compile(psFileName, "TexturePixelShader", "ps_4_0", ShaderFlags.None, SharpDX.D3DCompiler.EffectFlags.None);
* }
* else
* {
*
* }*/
string vsFileName = SCCoreSystems.Properties.Resources.InstancedTexture1; // "../../../_sc_instance_shader/" + "texture.vs";
string psFileName = SCCoreSystems.Properties.Resources.InstancedTexture; // "../../../_sc_instance_shader/" + "texture.ps";
vertexShaderByteCode = ShaderBytecode.Compile(vsFileName, "TextureVertexShader", "vs_4_0", ShaderFlags.None, SharpDX.D3DCompiler.EffectFlags.None);
pixelShaderByteCode = ShaderBytecode.Compile(psFileName, "TexturePixelShader", "ps_4_0", ShaderFlags.None, SharpDX.D3DCompiler.EffectFlags.None);
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
InputElement[] inputElements = new InputElement[]
{
new InputElement()
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = SharpDX.DXGI.Format.R32G32B32_Float,
Slot = 0,
AlignedByteOffset = 0,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement()
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = SharpDX.DXGI.Format.R32G32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement()
{
SemanticName = "TEXCOORD",
SemanticIndex = 1,
Format = SharpDX.DXGI.Format.R32G32B32_Float,
Slot = 1,
AlignedByteOffset = 0,
Classification = InputClassification.PerInstanceData,
InstanceDataStepRate = 1
}
};
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
BufferDescription matrixBufferDescription = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <DMatrixBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
ConstantMatrixBuffer = new SharpDX.Direct3D11.Buffer(device, matrixBufferDescription);
SamplerStateDescription samplerDesc = new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
MipLodBias = 0,
MaximumAnisotropy = 1,
ComparisonFunction = Comparison.Always,
BorderColor = new Color4(0, 0, 0, 0),
MinimumLod = 0,
MaximumLod = float.MaxValue
};
SamplerState = new SamplerState(device, samplerDesc);
}
catch (Exception ex)
{
MessageBox((IntPtr)0, ex.ToString(), "Oculus Error", 0);
}
return(true);
}
catch (Exception ex)
{
MainWindow.MessageBox((IntPtr)0, "Fail 01" + ex.Message, "Oculus error", 0);
return(false);
}
}
static SmoothMagnify()
{
pixelShader = PixelShaderUtility.LoadPixelShader <SmoothMagnify>();
}
private static void TestManagedDXDevice()
{
Device device;
SwapChain swapChain;
ShaderSignature inputSignature;
VertexShader vertexShader;
PixelShader pixelShader;
var form = new RenderForm("Tutorial 3: Simple Triangle");
var description = new SwapChainDescription()
{
BufferCount = 2,
Usage = Usage.RenderTargetOutput,
OutputHandle = form.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(1, 0),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard
};
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, description, out device, out swapChain);
// create a view of our render target, which is the backbuffer of the swap chain we just created
RenderTargetView renderTarget;
using (var resource = Resource.FromSwapChain <Texture2D>(swapChain, 0))
renderTarget = new RenderTargetView(device, resource);
// setting a viewport is required if you want to actually see anything
var context = device.ImmediateContext;
var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
context.OutputMerger.SetTargets(renderTarget);
context.Rasterizer.SetViewports(viewport);
// load and compile the vertex shader
using (var bytecode = ShaderBytecode.CompileFromFile("triangle.fx", "VShader", "vs_4_0", ShaderFlags.None, EffectFlags.None))
{
inputSignature = ShaderSignature.GetInputSignature(bytecode);
vertexShader = new VertexShader(device, bytecode);
}
// load and compile the pixel shader
using (var bytecode = ShaderBytecode.CompileFromFile("triangle.fx", "PShader", "ps_4_0", ShaderFlags.None, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
// create test vertex data, making sure to rewind the stream afterward
var vertices = new DataStream(12 * 3, true, true);
vertices.Write(new Vector3(0.0f, 0.5f, 0.5f));
vertices.Write(new Vector3(0.5f, -0.5f, 0.5f));
vertices.Write(new Vector3(-0.5f, -0.5f, 0.5f));
vertices.Position = 0;
// create the vertex layout and buffer
var elements = new[] { new InputElement("POSITION", 0, Format.R32G32B32_Float, 0) };
var layout = new InputLayout(device, inputSignature, elements);
var vertexBuffer = new SlimDX.Direct3D11.Buffer(device, vertices, 12 * 3, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
// configure the Input Assembler portion of the pipeline with the vertex data
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, 12, 0));
// set the shaders
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
// prevent DXGI handling of alt+enter, which doesn't work properly with Winforms
using (var factory = swapChain.GetParent <Factory>())
factory.SetWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAltEnter);
// handle alt+enter ourselves
form.KeyDown += (o, e) =>
{
if (e.Alt && e.KeyCode == Keys.Enter)
{
swapChain.IsFullScreen = !swapChain.IsFullScreen;
}
};
// handle form size changes
form.UserResized += (o, e) =>
{
renderTarget.Dispose();
swapChain.ResizeBuffers(2, 0, 0, Format.R8G8B8A8_UNorm, SwapChainFlags.AllowModeSwitch);
using (var resource = Resource.FromSwapChain <Texture2D>(swapChain, 0))
renderTarget = new RenderTargetView(device, resource);
context.OutputMerger.SetTargets(renderTarget);
};
MessagePump.Run(form, () =>
{
// clear the render target to a soothing blue
context.ClearRenderTargetView(renderTarget, new Color4(0.5f, 0.5f, 1.0f));
// draw the triangle
context.Draw(3, 0);
swapChain.Present(0, PresentFlags.None);
});
// clean up all resources
// anything we missed will show up in the debug output
vertices.Close();
vertexBuffer.Dispose();
layout.Dispose();
inputSignature.Dispose();
vertexShader.Dispose();
pixelShader.Dispose();
renderTarget.Dispose();
swapChain.Dispose();
device.Dispose();
}
protected override void CreateDeviceDependentResources(DeviceManager deviceManager)
{
base.CreateDeviceDependentResources(deviceManager);
// Release all resources
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref pixelShader);
RemoveAndDispose(ref depthPixelShader);
RemoveAndDispose(ref lambertShader);
RemoveAndDispose(ref blinnPhongShader);
RemoveAndDispose(ref phongShader);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref perObjectBuffer);
RemoveAndDispose(ref perFrameBuffer);
RemoveAndDispose(ref perMaterialBuffer);
RemoveAndDispose(ref perArmatureBuffer);
RemoveAndDispose(ref depthStencilState);
// Get a reference to the Device1 instance and immediate context
var device = deviceManager.Direct3DDevice;
var context = deviceManager.Direct3DContext;
// Compile and create the vertex shader and input layout
using (var vertexShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\VS.hlsl", "VSMain", "vs_5_0"))
{
vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
// Layout from VertexShader input signature
vertexLayout = ToDispose(new InputLayout(device,
vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
new[]
{
// "SV_Position" = vertex coordinate in object space
new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
// "NORMAL" = the vertex normal
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
// "COLOR"
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 24, 0),
// "UV"
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 28, 0),
// "SkinIndices"
new InputElement("BLENDINDICES", 0, Format.R32G32B32A32_UInt, 36, 0),
// "SkinWeights"
new InputElement("BLENDWEIGHT", 0, Format.R32G32B32A32_Float, 52, 0),
}));
}
// Compile and create the pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\SimplePS.hlsl", "PSMain", "ps_5_0"))
pixelShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the depth vertex and pixel shaders
// This shader is for checking what the depth buffer would look like
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DepthPS.hlsl", "PSMain", "ps_5_0"))
depthPixelShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DiffusePS.hlsl", "PSMain", "ps_5_0"))
lambertShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the blinn phong pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\BlinnPhongPS.hlsl", "PSMain", "ps_5_0"))
blinnPhongShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\PhongPS.hlsl", "PSMain", "ps_5_0"))
phongShader = ToDispose(new PixelShader(device, bytecode));
// IMPORTANT: A constant buffer's size must be a multiple of 16-bytes
// use LayoutKind.Explicit and an explicit Size= to force this for structures
// or alternatively add padding fields and use a LayoutKind.Sequential and Pack=1
// Create the constant buffer that will
// store our worldViewProjection matrix
perObjectBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <ConstantBuffers.PerObject>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per frame constant buffer
// lighting / camera position
perFrameBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerFrame>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per material constant buffer
perMaterialBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerMaterial>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per armature/skeletong constant buffer
perArmatureBuffer = ToDispose(new Buffer(device, ConstantBuffers.PerArmature.Size(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Configure the depth buffer to discard pixels that are
// further than the current pixel.
depthStencilState = ToDispose(new DepthStencilState(device,
new DepthStencilStateDescription()
{
IsDepthEnabled = true, // enable depth?
DepthComparison = Comparison.Less,
DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All,
IsStencilEnabled = false, // enable stencil?
StencilReadMask = 0xff, // 0xff (no mask)
StencilWriteMask = 0xff, // 0xff (no mask)
// Configure FrontFace depth/stencil operations
FrontFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Increment
},
// Configure BackFace depth/stencil operations
BackFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Decrement
},
}));
// Initialize the ImmediateContext pipeline stages
InitializeContext(context);
}
public TerrainShader(Device device)
{
byte[] vspncct = File.ReadAllBytes("Shaders\\TerrainVS_PNCCT.cso");
byte[] vspncctt = File.ReadAllBytes("Shaders\\TerrainVS_PNCCTT.cso");
byte[] vspnccttx = File.ReadAllBytes("Shaders\\TerrainVS_PNCCTTX.cso");
byte[] vspncctttx = File.ReadAllBytes("Shaders\\TerrainVS_PNCCTTTX.cso");
byte[] vspncctx = File.ReadAllBytes("Shaders\\TerrainVS_PNCCTX.cso");
byte[] vspnctttx = File.ReadAllBytes("Shaders\\TerrainVS_PNCTTTX.cso");
byte[] vspncttx = File.ReadAllBytes("Shaders\\TerrainVS_PNCTTX.cso");
byte[] psbytes = File.ReadAllBytes("Shaders\\TerrainPS.cso");
pncctvs = new VertexShader(device, vspncct);
pnccttvs = new VertexShader(device, vspncctt);
pnccttxvs = new VertexShader(device, vspnccttx);
pncctttxvs = new VertexShader(device, vspncctttx);
pncctxvs = new VertexShader(device, vspncctx);
pnctttxvs = new VertexShader(device, vspnctttx);
pncttxvs = new VertexShader(device, vspncttx);
terrainps = new PixelShader(device, psbytes);
VSSceneVars = new GpuVarsBuffer <TerrainShaderVSSceneVars>(device);
VSEntityVars = new GpuVarsBuffer <TerrainShaderVSEntityVars>(device);
VSModelVars = new GpuVarsBuffer <TerrainShaderVSModelVars>(device);
VSGeomVars = new GpuVarsBuffer <TerrainShaderVSGeomVars>(device);
PSSceneVars = new GpuVarsBuffer <TerrainShaderPSSceneVars>(device);
PSGeomVars = new GpuVarsBuffer <TerrainShaderPSGeomVars>(device);
//supported layouts - requires Position, Normal, Colour, Texcoord
layouts.Add(VertexType.PNCCT, new InputLayout(device, vspncct, VertexTypePNCCT.GetLayout()));
layouts.Add(VertexType.PNCCTT, new InputLayout(device, vspncctt, VertexTypePNCCTT.GetLayout()));
layouts.Add(VertexType.PNCTTX, new InputLayout(device, vspncttx, VertexTypePNCTTX.GetLayout()));
layouts.Add(VertexType.PNCTTTX_3, new InputLayout(device, vspnctttx, VertexTypePNCTTTX_3.GetLayout()));
layouts.Add(VertexType.PNCCTX, new InputLayout(device, vspncctx, VertexTypePNCCTX.GetLayout()));
layouts.Add(VertexType.PNCCTTX, new InputLayout(device, vspnccttx, VertexTypePNCCTTX.GetLayout()));
layouts.Add(VertexType.PNCCTTX_2, new InputLayout(device, vspnccttx, VertexTypePNCCTTX_2.GetLayout()));
layouts.Add(VertexType.PNCCTTTX, new InputLayout(device, vspncctttx, VertexTypePNCCTTTX.GetLayout()));
texsampler = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Always,
Filter = Filter.MinMagMipLinear,
MaximumAnisotropy = 1,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0,
});
texsampleranis = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Always,
Filter = Filter.Anisotropic,
MaximumAnisotropy = 8,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0,
});
texsamplertnt = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = Color.White,
ComparisonFunction = Comparison.Always,
Filter = Filter.MinMagMipPoint,
MaximumAnisotropy = 1,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0,
});
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
UpdateDebugInfo();
var bmp = new BufferedBitmap(300, 300);
_view.Render2.Source = bmp.BitmapSource;
_shader = new PixelShader(bmp);
_view.RefreshButton.Click += (o, args) => RenderScene();
_view.IlluminationObjectChanged += o =>
{
_currentObject = o;
UpdateDebugInfo();
};
_view.KeyDown += (o, args) =>
{
var move = Vector3.Zero;
var step = 0.25f;
switch (args.Key)
{
case Key.W:
move = new Vector3(0, step, 0);
break;
case Key.S:
move = new Vector3(0, -step, 0);
break;
case Key.A:
move = new Vector3(-step, 0, 0);
break;
case Key.D:
move = new Vector3(step, 0, 0);
break;
case Key.E:
move = new Vector3(0, 0, step);
break;
case Key.C:
move = new Vector3(0, 0, -step);
break;
case Key.I:
_scenes[_currentObject].Lights[0].AttenuationCutoff += 1;
RenderScene();
break;
case Key.K:
_scenes[_currentObject].Lights[0].AttenuationCutoff -= 1;
RenderScene();
break;
case Key.O:
_scenes[_currentObject].Lights[0].Radius += 1;
RenderScene();
break;
case Key.L:
_scenes[_currentObject].Lights[0].Radius -= 1;
RenderScene();
break;
}
if (move.Length() > 0)
{
_scenes[_currentObject].Lights[0].Position += move;
RenderScene();
UpdateDebugInfo();
}
};
RenderScene();
}
private void InitDevice()
{
// device creation
//device = D3DDevice.CreateDeviceAndSwapChain(
// null,
// DriverType.Hardware,
// null,
// CreateDeviceFlag.Default,
// new []{FeatureLevel.FeatureLevel_10_1},
// new SwapChainDescription {
// BufferCount = 1
// },
// out swapChain);
device = D3DDevice.CreateDeviceAndSwapChain(directControl.Handle, out swapChain);
deviceContext = device.GetImmediateContext();
SetViews();
// Open precompiled vertex shader
// This file was compiled using: fxc Render.hlsl /T vs_4_0 /EVertShader /FoRender.vs
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Microsoft.WindowsAPICodePack.Samples.Direct3D11.Render.vs"))
{
vertexShader = device.CreateVertexShader(stream);
}
deviceContext.VS.SetShader(vertexShader, null);
// input layout is for the vert shader
InputElementDescription inputElementDescription = new InputElementDescription();
inputElementDescription.SemanticName = "POSITION";
inputElementDescription.SemanticIndex = 0;
inputElementDescription.Format = Format.R32G32B32_FLOAT;
inputElementDescription.InputSlot = 0;
inputElementDescription.AlignedByteOffset = 0;
inputElementDescription.InputSlotClass = InputClassification.PerVertexData;
inputElementDescription.InstanceDataStepRate = 0;
InputLayout inputLayout;
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Microsoft.WindowsAPICodePack.Samples.Direct3D11.Render.vs"))
{
inputLayout = device.CreateInputLayout(new [] { inputElementDescription }, stream);
}
deviceContext.IA.SetInputLayout(inputLayout);
// Open precompiled pixel shader
// This file was compiled using: fxc Render.hlsl /T ps_4_0 /EPixShader /FoRender.ps
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Microsoft.WindowsAPICodePack.Samples.Direct3D11.Render.ps"))
{
pixelShader = device.CreatePixelShader(stream);
}
deviceContext.PS.SetShader(pixelShader, null);
// create some geometry to draw (1 triangle)
SimpleVertexArray vertex = new SimpleVertexArray();
// put the vertices into a vertex buffer
BufferDescription bufferDescription = new BufferDescription();
bufferDescription.Usage = Usage.Default;
bufferDescription.ByteWidth = (uint)Marshal.SizeOf(vertex);
bufferDescription.BindFlags = BindFlag.VertexBuffer;
SubresourceData subresourceData = new SubresourceData();
IntPtr vertexData = Marshal.AllocCoTaskMem(Marshal.SizeOf(vertex));
Marshal.StructureToPtr(vertex, vertexData, false);
subresourceData.SysMem = vertexData;
vertexBuffer = device.CreateBuffer(bufferDescription, subresourceData);
deviceContext.IA.SetVertexBuffers(0, new [] { vertexBuffer }, new uint[] { 12 }, new uint[] { 0 });
deviceContext.IA.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
Marshal.FreeCoTaskMem(vertexData);
}
protected override void SetPipelineCore(Pipeline pipeline)
{
if (!pipeline.IsComputePipeline && _graphicsPipeline != pipeline)
{
D3D11Pipeline d3dPipeline = Util.AssertSubtype <Pipeline, D3D11Pipeline>(pipeline);
_graphicsPipeline = d3dPipeline;
Util.ClearArray(_graphicsResourceSets); // Invalidate resource set bindings -- they may be invalid.
Util.ClearArray(_invalidatedGraphicsResourceSets);
BlendState blendState = d3dPipeline.BlendState;
if (_blendState != blendState)
{
_blendState = blendState;
_context.OutputMerger.SetBlendState(blendState);
}
DepthStencilState depthStencilState = d3dPipeline.DepthStencilState;
uint stencilReference = d3dPipeline.StencilReference;
if (_depthStencilState != depthStencilState || _stencilReference != stencilReference)
{
_depthStencilState = depthStencilState;
_stencilReference = stencilReference;
_context.OutputMerger.SetDepthStencilState(depthStencilState, (int)stencilReference);
}
RasterizerState rasterizerState = d3dPipeline.RasterizerState;
if (_rasterizerState != rasterizerState)
{
_rasterizerState = rasterizerState;
_context.Rasterizer.State = rasterizerState;
}
SharpDX.Direct3D.PrimitiveTopology primitiveTopology = d3dPipeline.PrimitiveTopology;
if (_primitiveTopology != primitiveTopology)
{
_primitiveTopology = primitiveTopology;
_context.InputAssembler.PrimitiveTopology = primitiveTopology;
}
InputLayout inputLayout = d3dPipeline.InputLayout;
if (_inputLayout != inputLayout)
{
_inputLayout = inputLayout;
_context.InputAssembler.InputLayout = inputLayout;
}
VertexShader vertexShader = d3dPipeline.VertexShader;
if (_vertexShader != vertexShader)
{
_vertexShader = vertexShader;
_context.VertexShader.Set(vertexShader);
}
GeometryShader geometryShader = d3dPipeline.GeometryShader;
if (_geometryShader != geometryShader)
{
_geometryShader = geometryShader;
_context.GeometryShader.Set(geometryShader);
}
HullShader hullShader = d3dPipeline.HullShader;
if (_hullShader != hullShader)
{
_hullShader = hullShader;
_context.HullShader.Set(hullShader);
}
DomainShader domainShader = d3dPipeline.DomainShader;
if (_domainShader != domainShader)
{
_domainShader = domainShader;
_context.DomainShader.Set(domainShader);
}
PixelShader pixelShader = d3dPipeline.PixelShader;
if (_pixelShader != pixelShader)
{
_pixelShader = pixelShader;
_context.PixelShader.Set(pixelShader);
}
_vertexStrides = d3dPipeline.VertexStrides;
if (_vertexStrides != null)
{
int vertexStridesCount = _vertexStrides.Length;
Util.EnsureArrayMinimumSize(ref _vertexBindings, (uint)vertexStridesCount);
Util.EnsureArrayMinimumSize(ref _vertexOffsets, (uint)vertexStridesCount);
}
Util.EnsureArrayMinimumSize(ref _graphicsResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
Util.EnsureArrayMinimumSize(ref _invalidatedGraphicsResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
}
else if (pipeline.IsComputePipeline && _computePipeline != pipeline)
{
D3D11Pipeline d3dPipeline = Util.AssertSubtype <Pipeline, D3D11Pipeline>(pipeline);
_computePipeline = d3dPipeline;
Util.ClearArray(_computeResourceSets); // Invalidate resource set bindings -- they may be invalid.
Util.ClearArray(_invalidatedComputeResourceSets);
ComputeShader computeShader = d3dPipeline.ComputeShader;
_context.ComputeShader.Set(computeShader);
Util.EnsureArrayMinimumSize(ref _computeResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
Util.EnsureArrayMinimumSize(ref _invalidatedComputeResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
}
}
public RenderObject(Device device)
{
cb.vp = Matrix.Identity;
cb.world = Matrix.Identity;
// load and compile the vertex shader
using (var bytecode = ShaderBytecode.CompileFromFile("simple.fx", "VShader", "vs_4_0", ShaderFlags.None, EffectFlags.None))
{
vsInputSignature = ShaderSignature.GetInputSignature(bytecode);
vertexShader = new VertexShader(device, bytecode);
}
// load and compile the pixel shader
using (var bytecode = ShaderBytecode.CompileFromFile("simple.fx", "PShader", "ps_4_0", ShaderFlags.None, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
// Old school style.
/*
vertexSize = 24;
vertexCount = 3;
var vertexStream = new DataStream(vertexSize * vertexCount, true, true);
vertexStream.Write(new Vector3(0.0f, 5.0f, 0.5f));
vertexStream.Write(new Vector3(1, 0, 0)); // color
vertexStream.Write(new Vector3(5.0f, -5.0f, 0.5f));
vertexStream.Write(new Vector3(0, 1, 0)); // color
vertexStream.Write(new Vector3(-5.0f, -5.0f, 0.5f));
vertexStream.Write(new Vector3(0, 0, 1)); // color
vertexStream.Position = 0;
*/
// Use struct
Vertex[] vertices = new Vertex[] {
new Vertex() { pos = new Vector3(0.0f, 50.0f, 0.5f), col = new Vector3(1, 0, 0), uv = new Vector2(0, 0) },
new Vertex() { pos = new Vector3(50.0f, -50.0f, 0.5f), col = new Vector3(1, 1, 0), uv = new Vector2(1, 0) },
new Vertex() { pos = new Vector3(-50.0f, -50.0f, 0.5f), col = new Vector3(0, 1, 1), uv = new Vector2(1, 1) },
};
vertexSize = Marshal.SizeOf(typeof(Vertex));
vertexCount = vertices.Length;
var vertexStream = new DataStream(vertexSize * vertexCount, true, true);
foreach (var vertex in vertices)
{
vertexStream.Write(vertex);
}
vertexStream.Position = 0;
// create the vertex layout and buffer
var elements = new[] {
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0),
new InputElement("COLOR", 0, Format.R32G32B32_Float, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 0)
};
vertexBufferLayout = new InputLayout(device, vsInputSignature, elements);
vertexBuffer = new Buffer(device, vertexStream, vertexSize * vertexCount, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
vertexStream.Close();
// Setup Constant Buffers
constantBuffer = new Buffer(device, Marshal.SizeOf(typeof(ConstantBuffer)), ResourceUsage.Dynamic, BindFlags.ConstantBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0);
// http://asc-chalmers-project.googlecode.com/svn-history/r26/trunk/Source/AdvGraphicsProject/Program.cs
// Try load a texture
SamplerDescription samplerDescription = new SamplerDescription();
samplerDescription.AddressU = TextureAddressMode.Wrap;
samplerDescription.AddressV = TextureAddressMode.Wrap;
samplerDescription.AddressW = TextureAddressMode.Wrap;
samplerDescription.Filter = Filter.MinPointMagMipLinear;
samplerLinear = SamplerState.FromDescription(device, samplerDescription);
texture = Texture2D.FromFile(device, "Data/cco.png");
textureView = new ShaderResourceView(device, texture);
var desc = new BlendStateDescription()
{
AlphaToCoverageEnable = true,
IndependentBlendEnable = true
};
desc.RenderTargets[0].BlendEnable = false;
desc.RenderTargets[0].BlendOperation = BlendOperation.Add;
desc.RenderTargets[0].BlendOperationAlpha = BlendOperation.Add;
desc.RenderTargets[0].RenderTargetWriteMask = ColorWriteMaskFlags.Alpha;
desc.RenderTargets[0].SourceBlend = BlendOption.SourceAlpha;
desc.RenderTargets[0].DestinationBlend = BlendOption.InverseSourceAlpha;
desc.RenderTargets[0].DestinationBlendAlpha = BlendOption.InverseSourceAlpha;
desc.RenderTargets[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
blendState = BlendState.FromDescription(device, desc);
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
RenderForm form = new RenderForm("Kinect multiple hd faces projected to rgb");
RenderDevice device = new RenderDevice(SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport | DeviceCreationFlags.Debug);
RenderContext context = new RenderContext(device);
DX11SwapChain swapChain = DX11SwapChain.FromHandle(device, form.Handle);
VertexShader vertexShader = ShaderCompiler.CompileFromFile <VertexShader>(device, "ProjectedTextureHdFaceView.fx", "VS_Simple");
VertexShader vertexShaderIndexed = ShaderCompiler.CompileFromFile <VertexShader>(device, "ProjectedTextureHdFaceView.fx", "VS_Indexed");
PixelShader pixelShader = ShaderCompiler.CompileFromFile <PixelShader>(device, "ProjectedTextureHdFaceView.fx", "PS");
int maxFaceCount = Consts.MaxBodyCount;
int faceVertexCount = (int)Microsoft.Kinect.Face.FaceModel.VertexCount;
var vertRgbTempBuffer = new ColorSpacePoint[faceVertexCount];
ColorSpacePoint[] facePoints = new ColorSpacePoint[faceVertexCount * maxFaceCount];
DX11StructuredBuffer lookupBuffer = DX11StructuredBuffer.CreateDynamic <uint>(device, maxFaceCount);
//Note : since in this case we use instancing, we only need a buffer for a single face
HdFaceIndexBuffer faceIndexBuffer = new HdFaceIndexBuffer(device, 1);
DynamicRgbSpaceFaceStructuredBuffer faceRgbBuffer = new DynamicRgbSpaceFaceStructuredBuffer(device, maxFaceCount);
KinectSensor sensor = KinectSensor.GetDefault();
sensor.Open();
bool doQuit = false;
bool invalidateFace = false;
KinectSensorBodyFrameProvider provider = new KinectSensorBodyFrameProvider(sensor);
BodyTrackingProcessor bodyTracker = new BodyTrackingProcessor();
MultipleHdFaceProcessor multiFace = new MultipleHdFaceProcessor(sensor, bodyTracker, maxFaceCount);
form.KeyDown += (sender, args) => { if (args.KeyCode == Keys.Escape)
{
doQuit = true;
}
};
bool uploadColor = false;
ColorRGBAFrameData currentData = null;
DynamicColorRGBATexture colorTexture = new DynamicColorRGBATexture(device);
KinectSensorColorRGBAFrameProvider colorProvider = new KinectSensorColorRGBAFrameProvider(sensor);
colorProvider.FrameReceived += (sender, args) => { currentData = args.FrameData; uploadColor = true; };
provider.FrameReceived += (sender, args) =>
{
bodyTracker.Next(args.FrameData);
};
multiFace.OnFrameResultsChanged += (sender, args) =>
{
invalidateFace = true;
};
RenderLoop.Run(form, () =>
{
if (doQuit)
{
form.Dispose();
return;
}
if (invalidateFace)
{
int offset = 0;
foreach (var data in multiFace.CurrentResults)
{
var vertices = data.FaceModel.CalculateVerticesForAlignment(data.FaceAlignment).ToArray();
sensor.CoordinateMapper.MapCameraPointsToColorSpace(vertices, vertRgbTempBuffer);
Array.Copy(vertRgbTempBuffer, 0, facePoints, offset, faceVertexCount);
offset += faceVertexCount;
}
faceRgbBuffer.Copy(context, facePoints, multiFace.CurrentResults.Count * faceVertexCount);
invalidateFace = false;
}
if (uploadColor)
{
colorTexture.Copy(context, currentData);
uploadColor = false;
}
context.Context.ClearRenderTargetView(swapChain.RenderView, SharpDX.Color.Black);
context.RenderTargetStack.Push(swapChain);
context.Context.Rasterizer.State = device.RasterizerStates.BackCullSolid;
context.Context.OutputMerger.BlendState = device.BlendStates.Disabled;
device.Primitives.ApplyFullTri(context, colorTexture.ShaderView);
device.Primitives.FullScreenTriangle.Draw(context);
if (multiFace.CurrentResults.Count > 0)
{
context.Context.VertexShader.SetShaderResource(0, faceRgbBuffer.ShaderView);
context.Context.PixelShader.SetSampler(0, device.SamplerStates.LinearClamp);
context.Context.PixelShader.SetShaderResource(0, colorTexture.ShaderView);
if (multiFace.CurrentResults.Count > 1)
{
uint[] buffer = new uint[multiFace.CurrentResults.Count];
for (uint i = 0; i < multiFace.CurrentResults.Count; i++)
{
buffer[i] = (uint)((i + 1) % multiFace.CurrentResults.Count);
}
lookupBuffer.WriteData(context, buffer);
context.Context.VertexShader.Set(vertexShaderIndexed);
context.Context.VertexShader.SetShaderResource(1, lookupBuffer.ShaderView);
}
else
{
context.Context.VertexShader.Set(vertexShader);
}
context.Context.PixelShader.Set(pixelShader);
//Attach index buffer, null topology since we fetch
faceIndexBuffer.AttachWithLayout(context);
faceIndexBuffer.DrawInstanced(context, multiFace.CurrentResults.Count);
}
context.RenderTargetStack.Pop();
swapChain.Present(0, SharpDX.DXGI.PresentFlags.None);
});
swapChain.Dispose();
context.Dispose();
device.Dispose();
colorProvider.Dispose();
colorTexture.Dispose();
faceIndexBuffer.Dispose();
faceRgbBuffer.Dispose();
provider.Dispose();
pixelShader.Dispose();
vertexShader.Dispose();
vertexShaderIndexed.Dispose();
lookupBuffer.Dispose();
sensor.Close();
}
/// <summary>
/// Creates an instance of the shader from the included pixel shader.
/// </summary>
static ZoomBlurEffect()
{
pixelShader = new PixelShader();
pixelShader.UriSource = EffectUriHelper.GetUri(nameof(ZoomBlurEffect));
}
private bool InitializeShader(Device device, IntPtr windowHandler, string vsFileName, string psFileName)
{
try
{
// Setup full pathes
vsFileName = SystemConfiguration.ShadersFilePath + vsFileName;
psFileName = SystemConfiguration.ShadersFilePath + psFileName;
// Compile the vertex shader code.
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "ColorVertexShader", "vs_4_0", ShaderFlags.None, EffectFlags.None);
// Compile the pixel shader code.
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "ColorPixelShader", "ps_4_0", ShaderFlags.None, EffectFlags.None);
// Create the vertex shader from the buffer.
VertexShader = new VertexShader(device, vertexShaderByteCode);
// Create the pixel shader from the buffer.
PixelShader = new PixelShader(device, pixelShaderByteCode);
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType structure in the Model and in the shader.
var inputElements = new InputElement[]
{
new InputElement()
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = Format.R32G32B32A32_Float,
Slot = 0,
AlignedByteOffset = 0,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement()
{
SemanticName = "COLOR",
SemanticIndex = 0,
Format = Format.R32G32B32A32_Float,
Slot = 0,
AlignedByteOffset = ColorShader.Vertex.AppendAlignedElement,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
// Create the vertex input the layout.
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
// Release the vertex and pixel shader buffers, since they are no longer needed.
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var matrixBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <Matrix>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
ConstantMatrixBuffer = new Buffer(device, matrixBufferDesc);
return(true);
}
catch (Exception ex)
{
MessageBox.Show("Error initializing shader. Error is " + ex.Message);
return(false);
};
}
private void CreatePixelShader()
{
InternalPixelShader = new PixelShader(m_device, InternalShaderByteCode);
}
public async Task <bool> Reload(IStorageItem storageItem, RPAssetsManager RPAssetsManager, ProcessingList processingList)
{
Mark(GraphicsObjectStatus.loading);
if (!(storageItem is StorageFile file))
{
Mark(GraphicsObjectStatus.error);
return(false);
}
Windows.Storage.Streams.IBuffer datas;
try
{
datas = await FileIO.ReadBufferAsync(file);
}
catch
{
Mark(GraphicsObjectStatus.error);
return(false);
}
VertexShader vs0 = VS;
GeometryShader gs0 = GS;
VertexShader vs1 = VS1;
GeometryShader gs1 = GS1;
PixelShader ps1 = PS1;
VertexShader vs2 = VSParticle;
GeometryShader gs2 = GSParticle;
PixelShader ps2 = PSParticle;
ComputePO cs1 = CSParticle;
bool haveVS = vs0.CompileInitialize1(datas, "VS", macroEntryVS);
bool haveGS = gs0.CompileInitialize1(datas, "GS", macroEntryGS);
bool haveVS1 = vs1.CompileInitialize1(datas, "VS1", macroEntryVS);
bool haveGS1 = gs1.CompileInitialize1(datas, "GS1", macroEntryGS);
bool havePS1 = ps1.CompileInitialize1(datas, "PS1", macroEntryPS);
bool haveVSParticle = vs2.CompileInitialize1(datas, "VSParticle", macroEntryVS);
bool haveGSParticle = gs2.CompileInitialize1(datas, "GSParticle", macroEntryGS);
bool havePSParticle = ps2.CompileInitialize1(datas, "PSParticle", macroEntryPS);
bool haveCS1 = cs1.CompileInitialize1(datas, "CSParticle", macroEntryCS1);
if (haveVS || haveGS)
{
processingList.UL(new ShaderWarp1()
{
pipelineState = POSkinning, vs = haveVS ? vs0 : RPAssetsManager.VSAssets["VSMMDSkinning2.cso"], gs = haveGS ? gs0 : null, ps = null
});
}
else
{
POSkinning.Status = GraphicsObjectStatus.unload;
}
if (haveVS1 || haveGS1 || havePS1)
{
processingList.UL(new ShaderWarp1()
{
pipelineState = PODraw, vs = haveVS1 ? vs1 : RPAssetsManager.VSMMDTransform, gs = haveGS1 ? gs1 : null, ps = havePS1 ? ps1 : RPAssetsManager.PSMMD
});
}
else
{
PODraw.Status = GraphicsObjectStatus.unload;
}
if (haveVSParticle || haveGSParticle || havePSParticle)
{
processingList.UL(new ShaderWarp1()
{
pipelineState = POParticleDraw, vs = haveVSParticle ? vs2 : RPAssetsManager.VSMMDTransform, gs = haveGSParticle ? gs2 : null, ps = havePSParticle ? ps2 : RPAssetsManager.PSMMD
});
}
else
{
POParticleDraw.Status = GraphicsObjectStatus.unload;
}
if (haveCS1)
{
processingList.UL(CSParticle, 0);
}
else
{
CSParticle.Status = GraphicsObjectStatus.unload;
}
Status = GraphicsObjectStatus.loaded;
return(true);
}
static void Main()
{
var initError = EVRInitError.None;
system = OpenVR.Init(ref initError);
if (initError != EVRInitError.None)
{
return;
}
compositor = OpenVR.Compositor;
compositor.CompositorBringToFront();
compositor.FadeGrid(5.0f, false);
count = OpenVR.k_unMaxTrackedDeviceCount;
currentPoses = new TrackedDevicePose_t[count];
nextPoses = new TrackedDevicePose_t[count];
controllers = new List <uint>();
controllerModels = new RenderModel_t[count];
controllerTextures = new RenderModel_TextureMap_t[count];
controllerTextureViews = new ShaderResourceView[count];
controllerVertexBuffers = new SharpDX.Direct3D11.Buffer[count];
controllerIndexBuffers = new SharpDX.Direct3D11.Buffer[count];
controllerVertexBufferBindings = new VertexBufferBinding[count];
controllerEmitters = new Emitter[count];
controllerVoices = new SourceVoice[count];
for (uint device = 0; device < count; device++)
{
var deviceClass = system.GetTrackedDeviceClass(device);
switch (deviceClass)
{
case ETrackedDeviceClass.HMD:
headset = device;
break;
case ETrackedDeviceClass.Controller:
controllers.Add(device);
break;
}
}
uint width = 0;
uint height = 0;
system.GetRecommendedRenderTargetSize(ref width, ref height);
headsetSize = new Size((int)width, (int)height);
windowSize = new Size(960, 540);
var leftEyeProjection = Convert(system.GetProjectionMatrix(EVREye.Eye_Left, 0.01f, 1000.0f));
var rightEyeProjection = Convert(system.GetProjectionMatrix(EVREye.Eye_Right, 0.01f, 1000.0f));
var leftEyeView = Convert(system.GetEyeToHeadTransform(EVREye.Eye_Left));
var rightEyeView = Convert(system.GetEyeToHeadTransform(EVREye.Eye_Right));
foreach (var controller in controllers)
{
var modelName = new StringBuilder(255, 255);
var propertyError = ETrackedPropertyError.TrackedProp_Success;
var length = system.GetStringTrackedDeviceProperty(controller, ETrackedDeviceProperty.Prop_RenderModelName_String, modelName, 255, ref propertyError);
if (propertyError == ETrackedPropertyError.TrackedProp_Success)
{
var modelName2 = modelName.ToString();
while (true)
{
var pointer = IntPtr.Zero;
var modelError = EVRRenderModelError.None;
modelError = OpenVR.RenderModels.LoadRenderModel_Async(modelName2, ref pointer);
if (modelError == EVRRenderModelError.Loading)
{
continue;
}
if (modelError == EVRRenderModelError.None)
{
var renderModel = System.Runtime.InteropServices.Marshal.PtrToStructure <RenderModel_t>(pointer);
controllerModels[controller] = renderModel;
break;
}
}
while (true)
{
var pointer = IntPtr.Zero;
var textureError = EVRRenderModelError.None;
textureError = OpenVR.RenderModels.LoadTexture_Async(controllerModels[controller].diffuseTextureId, ref pointer);
if (textureError == EVRRenderModelError.Loading)
{
continue;
}
if (textureError == EVRRenderModelError.None)
{
var texture = System.Runtime.InteropServices.Marshal.PtrToStructure <RenderModel_TextureMap_t>(pointer);
controllerTextures[controller] = texture;
break;
}
}
}
}
int adapterIndex = 0;
system.GetDXGIOutputInfo(ref adapterIndex);
using (var form = new Form())
using (var factory = new Factory4())
{
form.ClientSize = windowSize;
var adapter = factory.GetAdapter(adapterIndex);
var swapChainDescription = new SwapChainDescription
{
BufferCount = 1,
Flags = SwapChainFlags.None,
IsWindowed = true,
ModeDescription = new ModeDescription
{
Format = Format.B8G8R8A8_UNorm,
Width = form.ClientSize.Width,
Height = form.ClientSize.Height,
RefreshRate = new Rational(60, 1)
},
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
SharpDX.Direct3D11.Device.CreateWithSwapChain(adapter, DeviceCreationFlags.None, swapChainDescription, out device, out swapChain);
factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.None);
context = device.ImmediateContext;
using (var backBuffer = swapChain.GetBackBuffer <Texture2D>(0))
backBufferView = new RenderTargetView(device, backBuffer);
var depthBufferDescription = new Texture2DDescription
{
Format = Format.D16_UNorm,
ArraySize = 1,
MipLevels = 1,
Width = form.ClientSize.Width,
Height = form.ClientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
using (var depthBuffer = new Texture2D(device, depthBufferDescription))
depthStencilView = new DepthStencilView(device, depthBuffer);
// Create Eye Textures
var eyeTextureDescription = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.B8G8R8A8_UNorm,
Width = headsetSize.Width,
Height = headsetSize.Height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
var leftEyeTexture = new Texture2D(device, eyeTextureDescription);
var rightEyeTexture = new Texture2D(device, eyeTextureDescription);
var leftEyeTextureView = new RenderTargetView(device, leftEyeTexture);
var rightEyeTextureView = new RenderTargetView(device, rightEyeTexture);
// Create Eye Depth Buffer
eyeTextureDescription.BindFlags = BindFlags.DepthStencil;
eyeTextureDescription.Format = Format.D32_Float;
var eyeDepth = new Texture2D(device, eyeTextureDescription);
var eyeDepthView = new DepthStencilView(device, eyeDepth);
Shapes.Cube.Load(device);
Shapes.Sphere.Load(device);
Shaders.Load(device);
// Load Controller Models
foreach (var controller in controllers)
{
var model = controllerModels[controller];
controllerVertexBuffers[controller] = new SharpDX.Direct3D11.Buffer(device, model.rVertexData, new BufferDescription
{
BindFlags = BindFlags.VertexBuffer,
SizeInBytes = (int)model.unVertexCount * 32
});
controllerVertexBufferBindings[controller] = new VertexBufferBinding(controllerVertexBuffers[controller], 32, 0);
controllerIndexBuffers[controller] = new SharpDX.Direct3D11.Buffer(device, model.rIndexData, new BufferDescription
{
BindFlags = BindFlags.IndexBuffer,
SizeInBytes = (int)model.unTriangleCount * 3 * 2
});
var texture = controllerTextures[controller];
using (var texture2d = new Texture2D(device, new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
Format = Format.R8G8B8A8_UNorm,
Width = texture.unWidth,
Height = texture.unHeight,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0)
}, new DataRectangle(texture.rubTextureMapData, texture.unWidth * 4)))
controllerTextureViews[controller] = new ShaderResourceView(device, texture2d);
}
var controllerVertexShaderByteCode = SharpDX.D3DCompiler.ShaderBytecode.Compile(Properties.Resources.NormalTextureShader, "VS", "vs_5_0");
controllerVertexShader = new VertexShader(device, controllerVertexShaderByteCode);
controllerPixelShader = new PixelShader(device, SharpDX.D3DCompiler.ShaderBytecode.Compile(Properties.Resources.NormalTextureShader, "PS", "ps_5_0"));
var controllerLayout = new InputLayout(device, SharpDX.D3DCompiler.ShaderSignature.GetInputSignature(controllerVertexShaderByteCode), new InputElement[]
{
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
});
worldViewProjectionBuffer = new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
var rasterizerStateDescription = RasterizerStateDescription.Default();
//rasterizerStateDescription.FillMode = FillMode.Wireframe;
rasterizerStateDescription.IsFrontCounterClockwise = true;
//rasterizerStateDescription.CullMode = CullMode.None;
rasterizerState = new RasterizerState(device, rasterizerStateDescription);
var blendStateDescription = BlendStateDescription.Default();
blendStateDescription.RenderTarget[0].BlendOperation = BlendOperation.Add;
blendStateDescription.RenderTarget[0].SourceBlend = BlendOption.SourceAlpha;
blendStateDescription.RenderTarget[0].DestinationBlend = BlendOption.InverseSourceAlpha;
blendStateDescription.RenderTarget[0].IsBlendEnabled = false;
blendState = new BlendState(device, blendStateDescription);
var depthStateDescription = DepthStencilStateDescription.Default();
depthStateDescription.DepthComparison = Comparison.LessEqual;
depthStateDescription.IsDepthEnabled = true;
depthStateDescription.IsStencilEnabled = false;
depthStencilState = new DepthStencilState(device, depthStateDescription);
var samplerStateDescription = SamplerStateDescription.Default();
samplerStateDescription.Filter = Filter.MinMagMipLinear;
samplerStateDescription.AddressU = TextureAddressMode.Wrap;
samplerStateDescription.AddressV = TextureAddressMode.Wrap;
samplerState = new SamplerState(device, samplerStateDescription);
startTime = DateTime.Now;
frame = 0;
windowSize = form.ClientSize;
backgroundColor = new RawColor4(0.1f, 0.1f, 0.1f, 1);
var vrEvent = new VREvent_t();
var eventSize = (uint)Utilities.SizeOf <VREvent_t>();
head = Matrix.Identity;
// Initialize Audio
audio = new XAudio2();
var voice = new MasteringVoice(audio);
audio3d = new X3DAudio(Speakers.Stereo);
foreach (var controller in controllers)
{
controllerEmitters[controller] = new Emitter
{
ChannelCount = 1,
CurveDistanceScaler = 0.15f,
OrientFront = Vector3.ForwardLH,
OrientTop = Vector3.Up,
Position = new Vector3(0, 0, 1000),
//Velocity = Vector3.Zero
};
}
listener = new Listener
{
OrientFront = Vector3.ForwardLH,
OrientTop = Vector3.Up,
Position = new Vector3(0, 0, 1000)
};
var audioFormat = new WaveFormat(44100, 32, 1);
//var audioSource = new SourceVoice(audio, audioFormat);
var audioBufferSize = audioFormat.ConvertLatencyToByteSize(1000);
var audioStream = new DataStream(audioBufferSize, true, true);
var audioSamples = audioBufferSize / audioFormat.BlockAlign;
var random = new Random();
for (var sample = 0; sample < audioSamples; sample++)
{
audioStream.Write((float)random.NextFloat(-1, 1));
}
audioStream.Position = 0;
var audioBuffer = new AudioBuffer
{
Stream = audioStream,
AudioBytes = audioBufferSize,
LoopCount = 255
};
var audioSettings = new DspSettings(1, 2);
foreach (var controller in controllers)
{
var audioSource = new SourceVoice(audio, audioFormat);
audioSource.SubmitSourceBuffer(audioBuffer, null);
audio3d.Calculate(listener, controllerEmitters[controller], CalculateFlags.Matrix, audioSettings);
audioSource.SetOutputMatrix(1, 2, audioSettings.MatrixCoefficients);
audioSource.Start();
controllerVoices[controller] = audioSource;
}
RenderLoop.Run(form, () =>
{
while (system.PollNextEvent(ref vrEvent, eventSize))
{
switch ((EVREventType)vrEvent.eventType)
{
case EVREventType.VREvent_TrackedDeviceActivated:
var controller = vrEvent.trackedDeviceIndex;
controllers.Add(controller);
var modelName = new StringBuilder(255, 255);
var propertyError = ETrackedPropertyError.TrackedProp_Success;
var length = system.GetStringTrackedDeviceProperty(controller, ETrackedDeviceProperty.Prop_RenderModelName_String, modelName, 255, ref propertyError);
if (propertyError == ETrackedPropertyError.TrackedProp_Success)
{
var modelName2 = modelName.ToString();
while (true)
{
var pointer = IntPtr.Zero;
var modelError = EVRRenderModelError.None;
modelError = OpenVR.RenderModels.LoadRenderModel_Async(modelName2, ref pointer);
if (modelError == EVRRenderModelError.Loading)
{
continue;
}
if (modelError == EVRRenderModelError.None)
{
var renderModel = System.Runtime.InteropServices.Marshal.PtrToStructure <RenderModel_t>(pointer);
controllerModels[controller] = renderModel;
// Load Controller Model
var model = controllerModels[controller];
controllerVertexBuffers[controller] = new SharpDX.Direct3D11.Buffer(device, model.rVertexData, new BufferDescription
{
BindFlags = BindFlags.VertexBuffer,
SizeInBytes = (int)model.unVertexCount * 32
});
controllerVertexBufferBindings[controller] = new VertexBufferBinding(controllerVertexBuffers[controller], 32, 0);
controllerIndexBuffers[controller] = new SharpDX.Direct3D11.Buffer(device, model.rIndexData, new BufferDescription
{
BindFlags = BindFlags.IndexBuffer,
SizeInBytes = (int)model.unTriangleCount * 3 * 2
});
break;
}
}
while (true)
{
var pointer = IntPtr.Zero;
var textureError = EVRRenderModelError.None;
textureError = OpenVR.RenderModels.LoadTexture_Async(controllerModels[controller].diffuseTextureId, ref pointer);
if (textureError == EVRRenderModelError.Loading)
{
continue;
}
if (textureError == EVRRenderModelError.None)
{
var textureMap = System.Runtime.InteropServices.Marshal.PtrToStructure <RenderModel_TextureMap_t>(pointer);
controllerTextures[controller] = textureMap;
using (var texture2d = new Texture2D(device, new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
Format = Format.R8G8B8A8_UNorm,
Width = textureMap.unWidth,
Height = textureMap.unHeight,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0)
}, new DataRectangle(textureMap.rubTextureMapData, textureMap.unWidth * 4)))
controllerTextureViews[controller] = new ShaderResourceView(device, texture2d);
break;
}
}
controllerEmitters[controller] = new Emitter
{
ChannelCount = 1,
CurveDistanceScaler = 0.15f,
OrientFront = Vector3.ForwardLH,
OrientTop = Vector3.Up,
Position = new Vector3(0, 0, 1000),
//Velocity = Vector3.Zero
};
var audioSource = new SourceVoice(audio, audioFormat);
audioSource.SubmitSourceBuffer(audioBuffer, null);
audio3d.Calculate(listener, controllerEmitters[controller], CalculateFlags.Matrix, audioSettings);
audioSource.SetOutputMatrix(1, 2, audioSettings.MatrixCoefficients);
audioSource.Start();
controllerVoices[controller] = audioSource;
}
break;
case EVREventType.VREvent_TrackedDeviceDeactivated:
controllers.RemoveAll(c => c == vrEvent.trackedDeviceIndex);
break;
default:
System.Diagnostics.Debug.WriteLine((EVREventType)vrEvent.eventType);
break;
}
}
if (form.ClientSize != windowSize)
{
Utilities.Dispose(ref backBufferView);
if (form.ClientSize.Width != 0 && form.ClientSize.Height != 0)
{
swapChain.ResizeBuffers(1, form.ClientSize.Width, form.ClientSize.Height, Format.B8G8R8A8_UNorm, SwapChainFlags.None);
using (var backBuffer = swapChain.GetBackBuffer <Texture2D>(0))
backBufferView = new RenderTargetView(device, backBuffer);
}
windowSize = form.ClientSize;
}
// Update Device Tracking
compositor.WaitGetPoses(currentPoses, nextPoses);
if (currentPoses[headset].bPoseIsValid)
{
Convert(ref currentPoses[headset].mDeviceToAbsoluteTracking, ref head);
// Update Audio Listener
listener.Position = head.TranslationVector * new Vector3(1, 1, -1);
listener.OrientFront = head.Forward * new Vector3(1, 1, -1);
listener.OrientTop = head.Up * new Vector3(1, 1, -1);
}
foreach (var controller in controllers)
{
var controllerMatrix = Matrix.Identity;
Convert(ref currentPoses[controller].mDeviceToAbsoluteTracking, ref controllerMatrix);
var position = controllerMatrix.TranslationVector * new Vector3(1, 1, -1);
controllerEmitters[controller].Position = position;
audio3d.Calculate(listener, controllerEmitters[controller], CalculateFlags.Matrix, audioSettings);
controllerVoices[controller].SetOutputMatrix(1, 2, audioSettings.MatrixCoefficients);
}
// Render Left Eye
context.Rasterizer.SetViewport(0, 0, headsetSize.Width, headsetSize.Height);
context.OutputMerger.SetTargets(eyeDepthView, leftEyeTextureView);
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.ClearRenderTargetView(leftEyeTextureView, backgroundColor);
context.ClearDepthStencilView(eyeDepthView, DepthStencilClearFlags.Depth, 1.0f, 0);
Shaders.Apply(context);
context.Rasterizer.State = rasterizerState;
context.OutputMerger.SetBlendState(blendState);
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.PixelShader.SetSampler(0, samplerState);
var ratio = (float)headsetSize.Width / (float)headsetSize.Height;
var projection = leftEyeProjection;
var view = Matrix.Invert(leftEyeView * head);
var world = Matrix.Scaling(0.5f) * Matrix.Translation(0, 1.0f, 0);
worldViewProjection = world * view * projection;
context.UpdateSubresource(ref worldViewProjection, worldViewProjectionBuffer);
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
//Shapes.Cube.Begin(context);
//Shapes.Cube.Draw(context);
Shapes.Sphere.Begin(context);
Shapes.Sphere.Draw(context);
// Draw Controllers
context.InputAssembler.InputLayout = controllerLayout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.VertexShader.Set(controllerVertexShader);
context.PixelShader.Set(controllerPixelShader);
context.GeometryShader.Set(null);
context.DomainShader.Set(null);
context.HullShader.Set(null);
context.PixelShader.SetSampler(0, samplerState);
foreach (var controller in controllers)
{
context.InputAssembler.SetVertexBuffers(0, controllerVertexBufferBindings[controller]);
context.InputAssembler.SetIndexBuffer(controllerIndexBuffers[controller], Format.R16_UInt, 0);
context.PixelShader.SetShaderResource(0, controllerTextureViews[controller]);
Convert(ref currentPoses[controller].mDeviceToAbsoluteTracking, ref world);
worldViewProjection = world * view * projection;
context.UpdateSubresource(ref worldViewProjection, worldViewProjectionBuffer);
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
context.DrawIndexed((int)controllerModels[controller].unTriangleCount * 3 * 4, 0, 0);
}
var texture = new Texture_t
{
eType = ETextureType.DirectX,
eColorSpace = EColorSpace.Gamma,
handle = leftEyeTextureView.Resource.NativePointer
};
var bounds = new VRTextureBounds_t
{
uMin = 0.0f,
uMax = 1.0f,
vMin = 0.0f,
vMax = 1.0f,
};
var submitError = compositor.Submit(EVREye.Eye_Left, ref texture, ref bounds, EVRSubmitFlags.Submit_Default);
if (submitError != EVRCompositorError.None)
{
System.Diagnostics.Debug.WriteLine(submitError);
}
// Render Right Eye
context.Rasterizer.SetViewport(0, 0, headsetSize.Width, headsetSize.Height);
context.OutputMerger.SetTargets(eyeDepthView, rightEyeTextureView);
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.ClearRenderTargetView(rightEyeTextureView, backgroundColor);
context.ClearDepthStencilView(eyeDepthView, DepthStencilClearFlags.Depth, 1.0f, 0);
Shaders.Apply(context);
context.Rasterizer.State = rasterizerState;
context.OutputMerger.SetBlendState(blendState);
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.PixelShader.SetSampler(0, samplerState);
projection = rightEyeProjection;
view = Matrix.Invert(rightEyeView * head);
world = Matrix.Scaling(0.5f) * Matrix.Translation(0, 1.0f, 0);
worldViewProjection = world * view * projection;
context.UpdateSubresource(ref worldViewProjection, worldViewProjectionBuffer);
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
//Shapes.Cube.Begin(context);
//Shapes.Cube.Draw(context);
Shapes.Sphere.Begin(context);
Shapes.Sphere.Draw(context);
// Draw Controllers
context.InputAssembler.InputLayout = controllerLayout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.VertexShader.Set(controllerVertexShader);
context.PixelShader.Set(controllerPixelShader);
context.GeometryShader.Set(null);
context.DomainShader.Set(null);
context.HullShader.Set(null);
context.PixelShader.SetSampler(0, samplerState);
foreach (var controller in controllers)
{
context.InputAssembler.SetVertexBuffers(0, controllerVertexBufferBindings[controller]);
context.InputAssembler.SetIndexBuffer(controllerIndexBuffers[controller], Format.R16_UInt, 0);
context.PixelShader.SetShaderResource(0, controllerTextureViews[controller]);
Convert(ref currentPoses[controller].mDeviceToAbsoluteTracking, ref world);
worldViewProjection = world * view * projection;
context.UpdateSubresource(ref worldViewProjection, worldViewProjectionBuffer);
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
context.DrawIndexed((int)controllerModels[controller].unTriangleCount * 3 * 4, 0, 0);
}
texture.handle = rightEyeTextureView.Resource.NativePointer;
submitError = compositor.Submit(EVREye.Eye_Right, ref texture, ref bounds, EVRSubmitFlags.Submit_Default);
if (submitError != EVRCompositorError.None)
{
System.Diagnostics.Debug.WriteLine(submitError);
}
// Render Window
context.Rasterizer.SetViewport(0, 0, windowSize.Width, windowSize.Height);
context.OutputMerger.SetTargets(depthStencilView, backBufferView);
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.ClearRenderTargetView(backBufferView, backgroundColor);
context.ClearDepthStencilView(depthStencilView, DepthStencilClearFlags.Depth, 1.0f, 0);
Shaders.Apply(context);
context.Rasterizer.State = rasterizerState;
context.OutputMerger.SetBlendState(blendState);
context.OutputMerger.SetDepthStencilState(depthStencilState);
context.PixelShader.SetSampler(0, samplerState);
ratio = (float)form.ClientSize.Width / (float)form.ClientSize.Height;
projection = Matrix.PerspectiveFovRH(3.14F / 3.0F, ratio, 0.01f, 1000);
view = Matrix.Invert(head);
world = Matrix.Scaling(0.5f) * Matrix.Translation(0, 1.0f, 0);
worldViewProjection = world * view * projection;
context.UpdateSubresource(ref worldViewProjection, worldViewProjectionBuffer);
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
//Shapes.Cube.Begin(context);
//Shapes.Cube.Draw(context);
Shapes.Sphere.Begin(context);
Shapes.Sphere.Draw(context);
// Draw Controllers
context.InputAssembler.InputLayout = controllerLayout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.VertexShader.Set(controllerVertexShader);
context.PixelShader.Set(controllerPixelShader);
context.GeometryShader.Set(null);
context.DomainShader.Set(null);
context.HullShader.Set(null);
context.PixelShader.SetSampler(0, samplerState);
foreach (var controller in controllers)
{
context.InputAssembler.SetVertexBuffers(0, controllerVertexBufferBindings[controller]);
context.InputAssembler.SetIndexBuffer(controllerIndexBuffers[controller], Format.R16_UInt, 0);
Convert(ref currentPoses[controller].mDeviceToAbsoluteTracking, ref world);
worldViewProjection = world * view * projection;
context.UpdateSubresource(ref worldViewProjection, worldViewProjectionBuffer);
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
context.DrawIndexed((int)controllerModels[controller].unTriangleCount * 3 * 4, 0, 0);
}
// Show Backbuffer
swapChain.Present(0, PresentFlags.None);
});
audio.Dispose();
}
}
public PixelShaderEffectBase(PixelShader shader)
{
PixelShader = shader;
UpdateShaderValue(InputProperty);
}
private static unsafe void LoadPixelsShaders()
{
var shaderNormalPath = Settings.ShadersPath + "normal.ps";
var shaderGrayScalePath = Settings.ShadersPath + "grayscale.ps";
var shaderMagicPath = Settings.ShadersPath + "magic.ps";
if (System.IO.File.Exists(shaderNormalPath))
{
using (var gs = ShaderLoader.FromFile(shaderNormalPath, null, ShaderFlags.None))
NormalPixelShader = new PixelShader(Device, gs);
}
if (System.IO.File.Exists(shaderGrayScalePath))
{
using (var gs = ShaderLoader.FromFile(shaderGrayScalePath, null, ShaderFlags.None))
GrayScalePixelShader = new PixelShader(Device, gs);
}
if (System.IO.File.Exists(shaderMagicPath))
{
using (var gs = ShaderLoader.FromFile(shaderMagicPath, null, ShaderFlags.None))
MagicPixelShader = new PixelShader(Device, gs);
}
}
protected override void CreateDeviceDependentResources(DeviceManager deviceManager)
{
base.CreateDeviceDependentResources(deviceManager);
// Release all resources
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref pixelShader);
RemoveAndDispose(ref depthPixelShader);
RemoveAndDispose(ref lambertShader);
RemoveAndDispose(ref blinnPhongShader);
RemoveAndDispose(ref phongShader);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref perObjectBuffer);
RemoveAndDispose(ref perFrameBuffer);
RemoveAndDispose(ref perMaterialBuffer);
RemoveAndDispose(ref depthStencilState);
// Get a reference to the Device1 instance and immediate context
var device = deviceManager.Direct3DDevice;
var context = deviceManager.Direct3DContext;
// Compile and create the vertex shader and input layout
using (var vertexShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\VS.hlsl", "VSMain", "vs_5_0"))
{
vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
// Layout from VertexShader input signature
vertexLayout = ToDispose(new InputLayout(device,
vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
new[]
{
// "SV_Position" = vertex coordinate in object space
new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
// "NORMAL" = the vertex normal
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
// "COLOR"
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 24, 0),
// "UV"
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 28, 0),
}));
}
// Compile and create the pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\SimplePS.hlsl", "PSMain", "ps_5_0"))
pixelShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the depth vertex and pixel shaders
// This shader is for checking what the depth buffer would look like
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DepthPS.hlsl", "PSMain", "ps_5_0"))
depthPixelShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\CubeMapDiffusePS.hlsl", "PSMain", "ps_5_0"))
lambertShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\CubeMapBlinnPhongPS.hlsl", "PSMain", "ps_5_0"))
blinnPhongShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\CubeMapPhongPS.hlsl", "PSMain", "ps_5_0"))
phongShader = ToDispose(new PixelShader(device, bytecode));
// IMPORTANT: A constant buffer's size must be a multiple of 16-bytes
// use LayoutKind.Explicit and an explicit Size= to force this for structures
// or alternatively add private padding properties and use a LayoutKind.Sequential and Pack=1
// Create the constant buffer that will
// store our worldViewProjection matrix
perObjectBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <ConstantBuffers.PerObject>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per frame constant buffer
// lighting / camera position
perFrameBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerFrame>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
perMaterialBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerMaterial>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Configure the depth buffer to discard pixels that are
// further than the current pixel.
depthStencilState = ToDispose(new DepthStencilState(device,
new DepthStencilStateDescription()
{
IsDepthEnabled = true, // enable depth?
DepthComparison = Comparison.Less,
DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All,
IsStencilEnabled = false, // enable stencil?
StencilReadMask = 0xff, // 0xff (no mask)
StencilWriteMask = 0xff, // 0xff (no mask)
// Configure FrontFace depth/stencil operations
FrontFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Increment
},
// Configure BackFace depth/stencil operations
BackFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Decrement
},
}));
// Tell the IA what the vertices will look like
// in this case two 4-component 32bit floats
// (32 bytes in total)
context.InputAssembler.InputLayout = vertexLayout;
// Set our constant buffer (to store worldViewProjection)
context.VertexShader.SetConstantBuffer(0, perObjectBuffer);
context.VertexShader.SetConstantBuffer(1, perFrameBuffer);
context.VertexShader.SetConstantBuffer(2, perMaterialBuffer);
// Set the vertex shader to run
context.VertexShader.Set(vertexShader);
// Set our pixel constant buffers
context.PixelShader.SetConstantBuffer(1, perFrameBuffer);
context.PixelShader.SetConstantBuffer(2, perMaterialBuffer);
// Set the pixel shader to run
context.PixelShader.Set(lambertShader);
// Set our depth stencil state
context.OutputMerger.DepthStencilState = depthStencilState;
context.Rasterizer.State = ToDispose(new RasterizerState(device, new RasterizerStateDescription()
{
FillMode = FillMode.Solid,
CullMode = CullMode.Back,
IsFrontCounterClockwise = false,
}));
}
public ImGuiRender(DX11 dx11, RenderForm form, CoreSettings coreSettings)
{
_form = form;
Dx11 = dx11;
CoreSettings = coreSettings;
FormBounds = form.Bounds;
using (new PerformanceTimer("Init ImGui"))
{
Initialize();
}
sizeOfImDrawVert = Utilities.SizeOf <ImDrawVert>();
sizeOfImDrawIdx = Utilities.SizeOf <ushort>();
VertexBufferSize = 10000;
IndexBufferSize = 30000;
// Compile the vertex shader code.
var vertexShaderByteCode =
ShaderBytecode.CompileFromFile("Shaders\\ImGuiVertexShader.hlsl", "VS", "vs_4_0");
// Compile the pixel shader code.
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("Shaders\\ImGuiPixelShader.hlsl", "PS", "ps_4_0");
VertexShader = new VertexShader(Dx11.D11Device, vertexShaderByteCode);
PixelShader = new PixelShader(Dx11.D11Device, pixelShaderByteCode);
VertexBuffer = new Buffer(Dx11.D11Device,
new BufferDescription
{
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.VertexBuffer,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.Write,
SizeInBytes = VertexBufferSizeBytes
});
IndexBuffer = new Buffer(Dx11.D11Device,
new BufferDescription
{
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.IndexBuffer,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.Write,
SizeInBytes = IndexBufferSizeBytes
});
ConstantBuffer = new Buffer(Dx11.D11Device,
new BufferDescription
{
BindFlags = BindFlags.ConstantBuffer,
Usage = ResourceUsage.Dynamic,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.Write,
SizeInBytes = Utilities.SizeOf <Matrix4x4>()
});
var inputElements = new[]
{
new InputElement
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = Format.R32G32_Float,
Slot = 0,
AlignedByteOffset = 0,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = Format.R32G32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement
{
SemanticName = "COLOR",
SemanticIndex = 0,
Format = Format.R8G8B8A8_UNorm,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
Layout = new InputLayout(Dx11.D11Device, ShaderSignature.GetInputSignature(vertexShaderByteCode),
inputElements);
CreateStates();
UpdateConstantBuffer();
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
}
// Event-handler for DeviceManager.OnInitialize
protected override void CreateDeviceDependentResources(DeviceManager deviceManager)
{
base.CreateDeviceDependentResources(deviceManager);
// Release all resources
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref vertexShaderBytecode);
RemoveAndDispose(ref pixelShader);
RemoveAndDispose(ref pixelShaderBytecode);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref worldViewProjectionBuffer);
RemoveAndDispose(ref depthStencilState);
// Get a reference to the Device1 instance and context
var device = deviceManager.Direct3DDevice;
var context = deviceManager.Direct3DContext;
ShaderFlags shaderFlags = ShaderFlags.None;
#if DEBUG
shaderFlags = ShaderFlags.Debug;
#endif
// compile shader
vertexShaderBytecode = ToDispose(ShaderBytecode.CompileFromFile("Primitive.hlsl", "VSMain", "vs_5_0", shaderFlags));
vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
pixelShaderBytecode = ToDispose(ShaderBytecode.CompileFromFile("Primitive.hlsl", "PSMain", "ps_5_0", shaderFlags));
pixelShader = ToDispose(new PixelShader(device, pixelShaderBytecode));
// vertex input signature
vertexLayout = ToDispose(new InputLayout(device,
vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
new[]
{
new InputElement("SV_Position", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
}));
// mvp matrix
worldViewProjectionBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// depth & stencil
depthStencilState = ToDispose(new DepthStencilState(device,
new DepthStencilStateDescription()
{
IsDepthEnabled = true,
DepthComparison = Comparison.Less,
DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All,
IsStencilEnabled = false,
StencilReadMask = 0xff, // 0xff(no mask)
StencilWriteMask = 0xff, // 0xf(no mask)
FrontFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Increment
},
BackFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Decrement
}
}));
// assign input layout, constant buffer, vertex and pixel shaders and depth stencil state to appropriate graphics pipeline stages
context.InputAssembler.InputLayout = vertexLayout;
context.VertexShader.SetConstantBuffer(0, worldViewProjectionBuffer);
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
context.OutputMerger.DepthStencilState = depthStencilState;
}
/// <summary>
/// 提供PixelShader接口对渲染进一步处理
/// </summary>
/// <param name="shaderbytes">编译出来的ps文件的bytes</param>
public void SetPixelShader(byte[] shaderbytes)
{
this.SafeRelease(this.pixelShader);
this.SafeRelease(this.pixelShaderConstantTable);
this.SafeRelease(this.pixelShaderCode);
this.pixelShaderCode = new ShaderBytecode(shaderbytes);
this.pixelShader = new PixelShader(this.device, this.pixelShaderCode);
this.pixelShaderConstantTable = this.pixelShaderCode.ConstantTable;
}
public virtual void PixelFromString(string input)
{
bcPixel = ShaderBytecode.Compile(input, "PShader", "ps_4_0", ShaderFlags.Debug, EffectFlags.None);
Pixel = new PixelShader(Device, bcPixel);
}
public void CreateShaders(string code)
{
UpdateRenderer = true;
// load and compile the vertex shader
using (var bytecode = ShaderBytecode.Compile(code, "VShader", "vs_5_0", ShaderFlags.None, EffectFlags.None))
{
inputSignature = ShaderSignature.GetInputSignature(bytecode);
vertexShader = new VertexShader(device, bytecode);
}
// load and compile the pixel shader
using (var bytecode = ShaderBytecode.Compile(code, "PShader", "ps_5_0", ShaderFlags.None, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
string compilationError = "";
//ShaderBytecode compiledShader = ShaderBytecode.CompileFromFile("vteffect.fx", "fx_4_0", ShaderFlags.None, EffectFlags.None, null, null, out compilationError);
//fx = new Effect(device, compiledShader);
// create test vertex data, making sure to rewind the stream afterward
vertices = new DataStream(20 * 4, true, true);
vertices.Write(new Vector3(-1f, -1f, 0.5f)); vertices.Write(new Vector2(0f, 1f));
vertices.Write(new Vector3(-1f, 1f, 0.5f)); vertices.Write(new Vector2(0f, 0f));
vertices.Write(new Vector3(1f, -1f, 0.5f)); vertices.Write(new Vector2(1f, 1f));
vertices.Write(new Vector3(1f, 1f, 0.5f)); vertices.Write(new Vector2(1f, 0f));
vertices.Position = 0;
// create the vertex layout and buffer
var elements = new[] {
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0)
};
layout = new InputLayout(device, inputSignature, elements);
vertexBuffer = new SlimDX.Direct3D11.Buffer(device, vertices, 20 * 4, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, 0);
List<int> indices = new List<int>();
indices.Add(0);
indices.Add(1);
indices.Add(2);
indices.Add(2);
indices.Add(1);
indices.Add(3);
var ibd = new BufferDescription(sizeof(int) * indices.Count, ResourceUsage.Immutable, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
indexBuffer = new SlimDX.Direct3D11.Buffer(device, new DataStream(indices.ToArray(), false, false), ibd);
// configure the Input Assembler portion of the pipeline with the vertex data
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, 20, 0));
context.InputAssembler.SetIndexBuffer(indexBuffer, Format.R32_UInt, 0);
// set the shaders
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
SamplerDescription sampleDesc = new SamplerDescription();
sampleDesc.Filter = Filter.MinMagMipPoint;
sampleDesc.AddressU = TextureAddressMode.Clamp;
sampleDesc.AddressV = TextureAddressMode.Clamp;
sampleDesc.AddressW = TextureAddressMode.Clamp;
sampleDesc.MipLodBias = 0.0f;
sampleDesc.ComparisonFunction = Comparison.Always;
sampleDesc.BorderColor = new Color4(0, 0, 0, 0);
sampleDesc.MinimumLod = 0;
sampleDesc.MaximumLod = 1;
sampleState = SamplerState.FromDescription(device, sampleDesc);
SamplerDescription indSampleDesc = new SamplerDescription();
sampleDesc.Filter = Filter.MinMagMipPoint;
sampleDesc.AddressU = TextureAddressMode.Wrap;
sampleDesc.AddressV = TextureAddressMode.Wrap;
sampleDesc.AddressW = TextureAddressMode.Wrap;
sampleDesc.MipLodBias = 0.0f;
sampleDesc.ComparisonFunction = Comparison.Always;
sampleDesc.BorderColor = new Color4(0, 0, 0, 0);
sampleDesc.MinimumLod = 0;
sampleDesc.MaximumLod = 1;
indSampleState = SamplerState.FromDescription(device, sampleDesc);
ImageLoadInformation loadInfo = new ImageLoadInformation() { Width = 2, Height = 2 };
loadInfo.BindFlags = BindFlags.ShaderResource;
loadInfo.CpuAccessFlags = CpuAccessFlags.None;
loadInfo.Depth = 4;
loadInfo.FilterFlags = FilterFlags.Point;
loadInfo.FirstMipLevel = 0;
loadInfo.Format = Format.R8G8B8A8_SInt;
loadInfo.MipLevels = 0;
loadInfo.Usage = ResourceUsage.Default;
texture = new Texture2D(device, new Texture2DDescription
{
BindFlags = BindFlags.ShaderResource,
ArraySize = 1024,
Width = 128,
Height = 128,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
SampleDescription = new SampleDescription(1, 0),
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None
});//Texture2D.FromFile(device,"Tourism_Industrial_d.png");
resourceView = new ShaderResourceView(device, texture);
device.ImmediateContext.PixelShader.SetShaderResource(resourceView, 0);
context.PixelShader.SetShaderResource(resourceView, 0);
context.PixelShader.SetSampler(sampleState, 0);
context.PixelShader.SetSampler(indSampleState, 1);
if (currentEntry != null) SetTexture(currentEntry);
}
private static void Main()
{
var form = new RenderForm("SharpDX - MiniTri Direct3D 11 Sample");
// SwapChain description
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(form.ClientSize.Width, form.ClientSize.Height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
// Create Device and SwapChain
Device device;
SwapChain swapChain;
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, desc, out device, out swapChain);
var context = device.ImmediateContext;
// Ignore all windows events
Factory factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.None);
// New RenderTargetView from the backbuffer
Texture2D backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
var renderView = new RenderTargetView(device, backBuffer);
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.CompileFromFile("MiniTri.fx", "VS", "vs_4_0", ShaderFlags.None,
EffectFlags.None);
var vertexShader = new VertexShader(device, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("MiniTri.fx", "PS", "ps_4_0", ShaderFlags.None,
EffectFlags.None);
var pixelShader = new PixelShader(device, pixelShaderByteCode);
// Layout from VertexShader input signature
var layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), new[] {
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
});
// Write vertex data to a datastream
var stream = new DataStream(32 * 3, true, true);
stream.WriteRange(new[]
{
new Vector4(0.0f, 0.5f, 0.5f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f)
});
stream.Position = 0;
// Instantiate Vertex buiffer from vertex data
var vertices = new Buffer(device, stream, new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = 32 * 3,
Usage = ResourceUsage.Default,
StructureByteStride = 0
});
stream.Release();
// Prepare All the stages
context.InputAssembler.SetInputLayout(layout);
context.InputAssembler.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, 32, 0));
context.VertexShader.Set(vertexShader);
context.Rasterizer.SetViewports(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
context.PixelShader.Set(pixelShader);
context.OutputMerger.SetTargets(renderView);
// Main loop
RenderLoop.Run(form, () =>
{
context.ClearRenderTargetView(renderView, new Color4(1.0f, 0.0f, 0.0f, 0.0f));
context.Draw(3, 0);
swapChain.Present(0, PresentFlags.None);
});
// Release all resources
vertexShaderByteCode.Release();
vertexShader.Release();
pixelShaderByteCode.Release();
pixelShader.Release();
vertices.Release();
layout.Release();
renderView.Release();
backBuffer.Release();
context.ClearState();
context.Flush();
device.Release();
context.Release();
swapChain.Release();
factory.Release();
}
public override void Initialize()
{
base.Initialize();
plStruct = new PointLightStruct[maxLights];
pLightBuffer = new StructuredBuffer<PointLightStruct>(maxLights, false, true);
string path = @"R:\Users\Rox Cox\Documents\Visual Studio 2013\Projects\LightingEngine_v2\LightingEngine_v2\LightingD3D11\HLSL\";
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "gbuffer.hlsl", "GBufferPS", "ps_5_0", ShaderFlags.Debug, EffectFlags.None, null, new IncludeFX(path)))
{
PS_GBuffer = new PixelShader(Renderer.Device, bytecode);
}
InitializeGBuffer();
}
internal MGFXShader (GraphicsDevice device, BinaryReader reader)
{
var isVertexShader = reader.ReadBoolean ();
#if OPENGL
if (isVertexShader)
ShaderType = ShaderType.VertexShader;
else
ShaderType = ShaderType.FragmentShader;
#endif // OPENGL
var shaderLength = (int)reader.ReadUInt16 ();
var shaderBytecode = reader.ReadBytes (shaderLength);
var samplerCount = (int)reader.ReadByte ();
_samplers = new Sampler[samplerCount];
for (var s = 0; s < samplerCount; s++) {
_samplers [s].type = (SamplerType)reader.ReadByte ();
_samplers [s].index = reader.ReadByte ();
#if OPENGL
_samplers [s].name = reader.ReadString ();
#endif
_samplers [s].parameter = (int)reader.ReadByte ();
}
var cbufferCount = (int)reader.ReadByte ();
_cbuffers = new int[cbufferCount];
for (var c = 0; c < cbufferCount; c++)
_cbuffers [c] = (int)reader.ReadByte ();
#if DIRECTX
var d3dDevice = device._d3dDevice;
if (isVertexShader)
{
_vertexShader = new VertexShader(d3dDevice, shaderBytecode, null);
// We need the bytecode later for allocating the
// input layout from the vertex declaration.
Bytecode = shaderBytecode;
HashKey = Effect.ComputeHash(Bytecode);
}
else
_pixelShader = new PixelShader(d3dDevice, shaderBytecode);
#endif // DIRECTX
#if OPENGL
var attributeCount = (int)reader.ReadByte ();
_attributes = new Attribute[attributeCount];
for (var a = 0; a < attributeCount; a++) {
_attributes [a].name = reader.ReadString ();
_attributes [a].usage = (VertexElementUsage)reader.ReadByte ();
_attributes [a].index = reader.ReadByte ();
_attributes [a].format = reader.ReadInt16 ();
}
_glslCode = System.Text.Encoding.ASCII.GetString (shaderBytecode);
Compile ();
#endif // OPENGL
}
internal Shader(GraphicsDevice device, BinaryReader reader)
{
GraphicsDevice = device;
var isVertexShader = reader.ReadBoolean();
Stage = isVertexShader ? ShaderStage.Vertex : ShaderStage.Pixel;
var shaderLength = reader.ReadInt32();
var shaderBytecode = reader.ReadBytes(shaderLength);
var samplerCount = (int)reader.ReadByte();
Samplers = new SamplerInfo[samplerCount];
for (var s = 0; s < samplerCount; s++)
{
Samplers[s].type = (SamplerType)reader.ReadByte();
Samplers[s].textureSlot = reader.ReadByte();
Samplers[s].samplerSlot = reader.ReadByte();
if (reader.ReadBoolean())
{
Samplers[s].state = new SamplerState();
Samplers[s].state.AddressU = (TextureAddressMode)reader.ReadByte();
Samplers[s].state.AddressV = (TextureAddressMode)reader.ReadByte();
Samplers[s].state.AddressW = (TextureAddressMode)reader.ReadByte();
Samplers[s].state.Filter = (TextureFilter)reader.ReadByte();
Samplers[s].state.MaxAnisotropy = reader.ReadInt32();
Samplers[s].state.MaxMipLevel = reader.ReadInt32();
Samplers[s].state.MipMapLevelOfDetailBias = reader.ReadSingle();
}
#if OPENGL
Samplers[s].name = reader.ReadString();
#endif
Samplers[s].parameter = reader.ReadByte();
}
var cbufferCount = (int)reader.ReadByte();
CBuffers = new int[cbufferCount];
for (var c = 0; c < cbufferCount; c++)
CBuffers[c] = reader.ReadByte();
#if DIRECTX
var d3dDevice = device._d3dDevice;
if (isVertexShader)
{
_vertexShader = new VertexShader(d3dDevice, shaderBytecode, null);
// We need the bytecode later for allocating the
// input layout from the vertex declaration.
Bytecode = shaderBytecode;
HashKey = MonoGame.Utilities.Hash.ComputeHash(Bytecode);
}
else
_pixelShader = new PixelShader(d3dDevice, shaderBytecode);
#endif // DIRECTX
#if OPENGL
_glslCode = System.Text.Encoding.ASCII.GetString(shaderBytecode);
HashKey = MonoGame.Utilities.Hash.ComputeHash(shaderBytecode);
var attributeCount = (int)reader.ReadByte();
_attributes = new Attribute[attributeCount];
for (var a = 0; a < attributeCount; a++)
{
_attributes[a].name = reader.ReadString();
_attributes[a].usage = (VertexElementUsage)reader.ReadByte();
_attributes[a].index = reader.ReadByte();
_attributes[a].format = reader.ReadInt16();
}
#endif // OPENGL
}
public PixelShader GetPixelShader( string bytecode )
{
PixelShader shader;
if (!psDictionary.TryGetValue( bytecode, out shader ) ) {
shader = new PixelShader( device, bytecode );
psDictionary.Add( bytecode, shader );
}
return shader;
}
// Example using async
protected async override void CreateDeviceDependentResources(Common.DeviceManager deviceManager)
{
resourcesReady = false;
base.CreateDeviceDependentResources(deviceManager);
RemoveAndDispose(ref fpsRenderer);
RemoveAndDispose(ref cubeRenderer);
RemoveAndDispose(ref textRenderer);
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref pixelShader);
var device = deviceManager.Direct3DDevice;
#region Compile shaders
// Compile Vertex Shader and create vertex InputLayout
using (var bytecode = await HLSLCompiler.CompileFromFileAsync(@"Shaders\VS.hlsl", "VSMain", "vs_5_0"))
{
vertexShader = new VertexShader(device, bytecode);
vertexLayout = ToDispose(new InputLayout(device,
bytecode.GetPart(ShaderBytecodePart.InputSignatureBlob).Data,
new[]
{
// "SV_Position" = vertex coordinate in object space
new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
// "NORMAL" = the vertex normal
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
// "COLOR"
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 24, 0),
// "UV"
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 28, 0),
// "BLENDINDICES"
new InputElement("BLENDINDICES", 0, Format.R32G32B32A32_UInt, 36, 0),
// "BLENDWEIGHT"
new InputElement("BLENDWEIGHT", 0, Format.R32G32B32A32_Float, 52, 0),
}));
}
// Compile pixel shader
using (var bytecode = await HLSLCompiler.CompileFromFileAsync(@"Shaders\SimplePS.hlsl", "PSMain", "ps_5_0"))
pixelShader = ToDispose(new PixelShader(device, bytecode));
#endregion
#region Create constant buffers
// Create constant buffers
// Create the constant buffer that will
// store our worldViewProjection matrix
perObjectBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <ConstantBuffers.PerObject>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per frame constant buffer
// lighting / camera position
perFrameBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerFrame>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per material constant buffer
perMaterialBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerMaterial>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per armature/skeletong constant buffer
perArmatureBuffer = ToDispose(new Buffer(device, ConstantBuffers.PerArmature.Size(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
#endregion
#region Create pipeline state variables
// Configure the depth buffer to discard pixels that are
// further than the current pixel.
depthStencilState = ToDispose(new DepthStencilState(device,
new DepthStencilStateDescription()
{
IsDepthEnabled = true, // enable depth?
DepthComparison = Comparison.Less,
DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All,
IsStencilEnabled = false, // enable stencil?
StencilReadMask = 0xff, // 0xff (no mask)
StencilWriteMask = 0xff, // 0xff (no mask)
}));
rsCullBack = ToDispose(new RasterizerState(device, new RasterizerStateDescription
{
CullMode = CullMode.Back,
IsFrontCounterClockwise = false,
FillMode = FillMode.Solid,
}));
#endregion
#region Create Renderers
cubeRenderer = new CubeRenderer();
cubeRenderer.Initialize(this);
textRenderer = ToDispose(new TextRenderer("Calibri", Color.Black, new Point(20, 100), 48, 800));
textRenderer.Initialize(this);
fpsRenderer = ToDispose(new FpsRenderer());
fpsRenderer.Initialize(this);
#endregion
resourcesReady = true;
clock.Start();
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="shadersFile">Путь к файлу с шейдерами PS и VS</param>
/// <param name="inputElements">Какие входные данные ожидает шейдер</param>
/// <param name="dvContext">Контекст видеокарты</param>
/// <param name="texture">Путь к текстуре</param>
public Drawer(string shadersFile,
InputElement[] inputElements,
DeviceContext dvContext,
bool isTesselation = false,
bool isGeometri = false)
{
_dx11DeviceContext = dvContext;
ShaderFlags shaderFlags = ShaderFlags.None;
#if DEBUG
shaderFlags = ShaderFlags.Debug;
#endif
using (var vertexShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "VS", "vs_5_0", shaderFlags))
{
//Синатура храянящая сведения о том какие входные переменные есть у шейдера
_inputSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
_vertexShader = new VertexShader(_dx11DeviceContext.Device, vertexShaderByteCode);
}
using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "PS", "ps_5_0", shaderFlags))
{
_pixelShader = new PixelShader(_dx11DeviceContext.Device, pixelShaderByteCode);
}
if (isTesselation)
{
using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "HS", "hs_5_0", shaderFlags))
{
_HShader = new HullShader(_dx11DeviceContext.Device, pixelShaderByteCode);
}
using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "DS", "ds_5_0", shaderFlags))
{
_DShader = new DomainShader(_dx11DeviceContext.Device, pixelShaderByteCode);
}
}
if (isGeometri)
{
using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "GS", "gs_5_0", shaderFlags))
{
_GShader = new GeometryShader(_dx11DeviceContext.Device, pixelShaderByteCode);
}
}
//Создаем шаблон ввода данных для шейдера
_inputLayout = new InputLayout(_dx11DeviceContext.Device, _inputSignature, inputElements);
var s = SamplerStateDescription.Default();
s.AddressU = TextureAddressMode.Wrap;
s.AddressV = TextureAddressMode.Wrap;
s.AddressW = TextureAddressMode.Wrap;
s.MaximumAnisotropy = 16;
s.MaximumLod = float.MaxValue;
s.MinimumLod = 0;
s.Filter = Filter.MinMagMipLinear;
Samplerdescription = s;
var d = DepthStencilStateDescription.Default();
d.IsDepthEnabled = true;
d.IsStencilEnabled = false;
DepthStencilDescripshion = d;
var r = RasterizerStateDescription.Default();
r.CullMode = CullMode.None;
r.FillMode = FillMode.Solid;
RasterizerDescription = r;
var b = BlendStateDescription.Default();
b.AlphaToCoverageEnable = new RawBool(true);
BlendDescription = b;
}
public override void Initialize()
{
base.Initialize();
plStruct = new PointLightStruct[maxLights];
pLightBuffer = new StructuredBuffer<PointLightStruct>(maxLights, false, true);
string path = @"R:\Users\Rox Cox\Documents\Visual Studio 2013\Projects\LightingEngine_v2\LightingEngine_v2\LightingD3D11\HLSL\";
ShaderFlags flags = ShaderFlags.Debug | ShaderFlags.EnableStrictness | ShaderFlags.PackMatrixRowMajor;
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "forward.hlsl", "ForwardPS", "ps_5_0", flags, EffectFlags.None, null, new IncludeFX(path)))
{
PS_PointLights = new PixelShader(Renderer.Device, bytecode);
}
DepthStencilStateDescription dssdesc = States.DepthDefault();
dssdesc.DepthComparison = Comparison.GreaterEqual;
dss = DepthStencilState.FromDescription(Renderer.Device, dssdesc);
}
private void OnBindMaterialTextures(RenderContext context, DeviceContextProxy deviceContext, PixelShader shader)
{
if (shader.IsNULL)
{
return;
}
var idx = shader.ShaderStageIndex;
shader.BindTexture(deviceContext, texDiffuseSlot, textureResources[DiffuseIdx]);
shader.BindTexture(deviceContext, texNormalSlot, textureResources[NormalIdx]);
shader.BindTexture(deviceContext, texAlphaSlot, textureResources[AlphaIdx]);
shader.BindTexture(deviceContext, texSpecularSlot, textureResources[SpecularColorIdx]);
shader.BindTexture(deviceContext, texEmissiveSlot, textureResources[EmissiveIdx]);
shader.BindSampler(deviceContext, samplerDiffuseSlot, surfaceSampler);
}
/// <summary>
/// Create any device dependent resources here.
/// This method will be called when the device is first
/// initialized or recreated after being removed or reset.
/// </summary>
protected override void CreateDeviceDependentResources()
{
// Ensure that if already set the device resources
// are correctly disposed of before recreating
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref pixelShader);
RemoveAndDispose(ref pointSamplerState);
//RemoveAndDispose(ref indexBuffer);
// Retrieve our SharpDX.Direct3D11.Device1 instance
// Get a reference to the Device1 instance and immediate context
var device = DeviceManager.Direct3DDevice;
var context = DeviceManager.Direct3DContext;
ShaderFlags shaderFlags = ShaderFlags.None;
#if DEBUG
shaderFlags = ShaderFlags.Debug | ShaderFlags.SkipOptimization;
#endif
// Use our HLSL file include handler to resolve #include directives in the HLSL source
//var includeHandler = new HLSLFileIncludeHandler(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "Shaders"));
// Compile and create the vertex shader
using (var vertexShaderBytecode = Collect(ShaderBytecode.Compile(shaderCode, "VSMain", "vs_4_0", shaderFlags, EffectFlags.None, null, null)))
{
vertexShader = Collect(new VertexShader(device, vertexShaderBytecode));
//// Layout from VertexShader input signature
//vertexLayout = ToDispose(new InputLayout(device,
// ShaderSignature.GetInputSignature(vertexShaderBytecode),
////ShaderSignature.GetInputSignature(vertexShaderBytecode),
//new[]
//{
// // "SV_Position" = vertex coordinate
// new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
//}));
//// Create vertex buffer
//vertexBuffer = ToDispose(Buffer.Create(device, BindFlags.VertexBuffer, new Vector3[] {
// /* Position: float x 3 */
// new Vector3(-1.0f, -1.0f, -1.0f),
// new Vector3(-1.0f, 1.0f, -1.0f),
// new Vector3(1.0f, -1.0f, -1.0f),
// new Vector3(1.0f, 1.0f, -1.0f),
//}));
//vertexBinding = new VertexBufferBinding(vertexBuffer, Utilities.SizeOf<Vector3>(), 0);
// Triangle strip:
// v1 v3
// |\ |
// | \ B|
// | A\ |
// | \|
// v0 v2
}
// Compile and create the pixel shader
using (var bytecode = Collect(ShaderBytecode.Compile(shaderCode, "PSMain", "ps_5_0", shaderFlags, EffectFlags.None, null, null)))
pixelShader = Collect(new PixelShader(device, bytecode));
linearSampleState = Collect(new SamplerState(device, new SamplerStateDescription
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
ComparisonFunction = Comparison.Never,
MinimumLod = 0,
MaximumLod = float.MaxValue
}));
pointSamplerState = Collect(new SamplerState(device, new SamplerStateDescription
{
Filter = Filter.MinMagMipPoint,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
ComparisonFunction = Comparison.Never,
MinimumLod = 0,
MaximumLod = float.MaxValue
}));
context.Rasterizer.State = Collect(new RasterizerState(device, new RasterizerStateDescription()
{
CullMode = CullMode.None,
FillMode = FillMode.Solid,
}));
//// Configure the depth buffer to discard pixels that are
//// further than the current pixel.
//context.OutputMerger.SetDepthStencilState(ToDispose(new DepthStencilState(device,
// new DepthStencilStateDescription()
// {
// IsDepthEnabled = false, // enable depth?
// DepthComparison = Comparison.Less,
// DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All,
// IsStencilEnabled = false,// enable stencil?
// StencilReadMask = 0xff, // 0xff (no mask)
// StencilWriteMask = 0xff,// 0xff (no mask)
// // Configure FrontFace depth/stencil operations
// FrontFace = new DepthStencilOperationDescription()
// {
// Comparison = Comparison.Always,
// PassOperation = StencilOperation.Keep,
// FailOperation = StencilOperation.Keep,
// DepthFailOperation = StencilOperation.Increment
// },
// // Configure BackFace depth/stencil operations
// BackFace = new DepthStencilOperationDescription()
// {
// Comparison = Comparison.Always,
// PassOperation = StencilOperation.Keep,
// FailOperation = StencilOperation.Keep,
// DepthFailOperation = StencilOperation.Decrement
// },
// })));
}
static LightStreak()
{
pixelShader = PixelShaderUtility.LoadPixelShader <LightStreak>();
}
public unsafe StandardEffect(RenderSystem rs)
: base(rs, StandardEffectFactory.Name, false)
{
FileLocation fl = FileSystem.Instance.Locate("tillingmark.tex", GameFileLocs.Texture);
noTexture = TextureManager.Instance.CreateInstance(fl);// fac.CreateTexture(1, 1, 1, TextureUsage.Static, ImagePixelFormat.A8R8G8B8);
this.renderSys = rs;
fl = FileSystem.Instance.Locate("standard.cvs", GameFileLocs.Effect);
vtxShader = LoadVertexShader(renderSys, fl);
fl = FileSystem.Instance.Locate("standard.cps", GameFileLocs.Effect);
pixShader = LoadPixelShader(renderSys, fl);
}
public Shader(CompiledShader vertex, CompiledShader fragment, VertexShader vshader, PixelShader pshader)
{
XnaCompiledVertexShader = vertex;
XnaCompiledPixelShader = fragment;
XnaVertexShader = vshader;
XnaPixelShader = pshader;
}
private bool CompilePixelShader( string code, out PixelShader ps, out ConstantTable consts )
{
string errs;
using( GraphicsStream gs = ShaderLoader.CompileShader( code, "main", new Macro[0],
null, "ps_2_0", ShaderFlags.None, out errs, out consts ) )
{
if( !string.IsNullOrEmpty( errs ) )
throw new Exception( "Shader compilation error: " + errs );
ps = new PixelShader( pn3D.Device, gs );
}
return true;
}
/// <summary>
/// Creates an instance of the shader from the included pixel shader.
/// </summary>
static RippleEffect()
{
pixelShader = new PixelShader();
pixelShader.UriSource = EffectUriHelper.GetUri(nameof(RippleEffect));
}
/// <summary>
/// Init device and required resources
/// </summary>
private void InitDevice()
{
// device creation
device = D3DDevice.CreateDeviceAndSwapChain(host.Handle);
swapChain = device.SwapChain;
deviceContext = device.ImmediateContext;
SetViews();
// vertex shader & layout
// Open precompiled vertex shader
// This file was compiled using: fxc Render.hlsl /T vs_4_0 /EVertShader /FoRender.vs
using (Stream stream = Application.ResourceAssembly.GetManifestResourceStream("Microsoft.WindowsAPICodePack.Samples.Direct3D11.Render.vs"))
{
vertexShader = device.CreateVertexShader(stream);
deviceContext.VS.Shader = vertexShader;
// input layout is for the vert shader
InputElementDescription inputElementDescription = new InputElementDescription();
inputElementDescription.SemanticName = "POSITION";
inputElementDescription.SemanticIndex = 0;
inputElementDescription.Format = Format.R32G32B32Float;
inputElementDescription.InputSlot = 0;
inputElementDescription.AlignedByteOffset = 0;
inputElementDescription.InputSlotClass = InputClassification.PerVertexData;
inputElementDescription.InstanceDataStepRate = 0;
stream.Position = 0;
InputLayout inputLayout = device.CreateInputLayout(
new InputElementDescription[] { inputElementDescription },
stream);
deviceContext.IA.InputLayout = inputLayout;
}
// Open precompiled vertex shader
// This file was compiled using: fxc Render.hlsl /T ps_4_0 /EPixShader /FoRender.ps
using (Stream stream = Application.ResourceAssembly.GetManifestResourceStream("Microsoft.WindowsAPICodePack.Samples.Direct3D11.Render.ps"))
{
pixelShader = device.CreatePixelShader(stream);
}
deviceContext.PS.SetShader(pixelShader, null);
// create some geometry to draw (1 triangle)
SimpleVertexArray vertex = new SimpleVertexArray();
// put the vertices into a vertex buffer
BufferDescription bufferDescription = new BufferDescription();
bufferDescription.Usage = Usage.Default;
bufferDescription.ByteWidth = (uint)Marshal.SizeOf(vertex);
bufferDescription.BindingOptions = BindingOptions.VertexBuffer;
SubresourceData subresourceData = new SubresourceData();
IntPtr vertexData = Marshal.AllocCoTaskMem(Marshal.SizeOf(vertex));
Marshal.StructureToPtr(vertex, vertexData, false);
subresourceData.SystemMemory = vertexData;
vertexBuffer = device.CreateBuffer(bufferDescription, subresourceData);
deviceContext.IA.SetVertexBuffers(0, new D3DBuffer[] { vertexBuffer }, new uint[] { 12 }, new uint[] { 0 });
deviceContext.IA.PrimitiveTopology = PrimitiveTopology.TriangleList;
Marshal.FreeCoTaskMem(vertexData);
}
private bool InitializeShader(Device device, IntPtr windowsHandler, string vsFileName, string psFileName)
{
try
{
// Setup full pathes
vsFileName = DSystemConfiguration.ShaderFilePath + vsFileName;
psFileName = DSystemConfiguration.ShaderFilePath + psFileName;
// Compile the Vertex Shader & Pixel Shader code.
ShaderBytecode vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "TextureVertexShader", DSystemConfiguration.VertexShaderProfile, ShaderFlags.None, EffectFlags.None);
ShaderBytecode pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "TexturePixelShader", DSystemConfiguration.PixelShaderProfile, ShaderFlags.None, EffectFlags.None);
// Create the Vertex & Pixel Shaders from the buffer.
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType structure in the Model and in the shader.
InputElement[] inputElements = new InputElement[]
{
new InputElement()
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = SharpDX.DXGI.Format.R32G32B32_Float,
Slot = 0,
AlignedByteOffset = 0,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement()
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = SharpDX.DXGI.Format.R32G32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
// Create the vertex input the layout. Kin dof like a Vertex Declaration.
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
// Release the vertex and pixel shader buffers, since they are no longer needed.
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
// Setup the description of the dynamic matrix constant Matrix buffer that is in the vertex shader.
BufferDescription matrixBufferDescription = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <DMatrixBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
ConstantMatrixBuffer = new SharpDX.Direct3D11.Buffer(device, matrixBufferDescription);
// Create a texture sampler state description.
SamplerStateDescription samplerDesc = new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
MipLodBias = 0,
MaximumAnisotropy = 1,
ComparisonFunction = Comparison.Always,
BorderColor = new Color4(0, 0, 0, 0), // Black Border.
MinimumLod = 0,
MaximumLod = float.MaxValue
};
// Create the texture sampler state.
SamplerState = new SamplerState(device, samplerDesc);
return(true);
}
catch (Exception ex)
{
MessageBox.Show("Error initializing shader. Error is " + ex.Message);
return(false);
}
}
public unsafe TailEffect(RenderSystem rs)
: base(rs, TailEffectFactory.Name, false)
{
FileLocation fl = FileSystem.Instance.Locate("tillingmark.tex", GameFileLocs.Texture);
noTexture = TextureManager.Instance.CreateInstance(fl);
this.renderSys = rs;
fl = FileSystem.Instance.Locate("tail.cvs", GameFileLocs.Effect);
vtxShader = LoadVertexShader(renderSys, fl);
fl = FileSystem.Instance.Locate("tail.cps", GameFileLocs.Effect);
pixShader = LoadPixelShader(renderSys, fl);
}
bool InitializeShader(Device device, string vsFileName, string psFileName)
{
try {
var compileVertexShaderResult = ShaderBytecode.CompileFromFile(vsFileName, "LightVertexShader", "vs_5_0", ShaderFlags.EnableStrictness);
vertexShader = new VertexShader(device, compileVertexShaderResult.Bytecode);
var compilePixelShaderResult = ShaderBytecode.CompileFromFile(psFileName, "LightPixelShader", "ps_5_0", ShaderFlags.EnableStrictness);
pixelShader = new PixelShader(device, compilePixelShaderResult.Bytecode);
var inputElements = new[] {
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0, InputClassification.PerVertexData, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 20, 0, InputClassification.PerVertexData, 0)
};
inputLayout = new InputLayout(device, compileVertexShaderResult.Bytecode, inputElements);
compileVertexShaderResult.Dispose();
compilePixelShaderResult.Dispose();
var matrixBufferDescription = new BufferDescription {
Usage = ResourceUsage.Default,
SizeInBytes = Utilities.SizeOf <MatrixBufferType>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
matrixBuffer = Buffer.Create(device, new[] { new MatrixBufferType() }, matrixBufferDescription);
var samplerStateDescription = new SamplerStateDescription {
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
MipLodBias = 0.0f,
MaximumAnisotropy = 1,
ComparisonFunction = Comparison.Always,
BorderColor =
{
A = 0,
R = 0,
G = 0,
B = 0
},
MinimumLod = 0,
MaximumLod = float.MaxValue
};
samplerState = new SamplerState(device, samplerStateDescription);
var lightBufferDescription = new BufferDescription {
Usage = ResourceUsage.Default,
SizeInBytes = Utilities.SizeOf <LightBufferType>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
lightBuffer = Buffer.Create(device, new[] { new LightBufferType() }, lightBufferDescription);
} catch { return(false); }
return(true);
}
public void InitializeShaders()
{
Helper.Dispose(VS_FullscreenTriangle, PS_PointLights, PS_PointLights_MS);
string path = @"LightingD3D11\HLSL\";
ShaderMacro[] macros = new[] { new ShaderMacro("MSAA_SAMPLES", Renderer.BufferSampleDescription.Count.ToString()) };
ShaderFlags flags = ShaderFlags.Debug | ShaderFlags.EnableStrictness | ShaderFlags.PackMatrixRowMajor;
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "fullscreenVS.hlsl", "FullScreenTriangleVS", "vs_5_0", flags, EffectFlags.None, null, new IncludeFX(path)))
{
VS_FullscreenTriangle = new VertexShader(Renderer.Device, bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "deferred.hlsl", "DeferredPS", "ps_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
PS_PointLights = new PixelShader(Renderer.Device, bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "deferred.hlsl", "DeferredPerSamplePS", "ps_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
PS_PointLights_MS = new PixelShader(Renderer.Device, bytecode);
}
}
/// <summary>
/// Creates an instance of the shader from the included pixel shader.
/// </summary>
static RippleEffect()
{
pixelShader = new PixelShader();
pixelShader.UriSource = new Uri("/HaoRan.WebCam;component/Shader/Ripple.ps", UriKind.Relative);
}
