private void init(string filename, Stream stream, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
#endif
{
try
{
video = Parent.FindParentOrSelfWithException<Video>();
#if WIN32
shaderVersion = (shaderVersion == ShaderVersions.Max) ? video.Cap.MaxShaderVersion : shaderVersion;
var code = getShaders(stream);
vertex = new VertexShader(this, code[0], shaderVersion);
pixel = new PixelShader(this, code[1], shaderVersion);
#else
await getReflections(filename);
var code = getShaders(stream);
vertex = new VertexShader(this, code[0]);
pixel = new PixelShader(this, code[1]);
#endif
variables = new List<ShaderVariable>();
resources = new List<ShaderResource>();
}
catch (Exception e)
{
FailedToLoad = true;
Loader.AddLoadableException(e);
Dispose();
if (loadedCallback != null) loadedCallback(this, false);
return;
}
Loaded = true;
if (loadedCallback != null) loadedCallback(this, true);
}
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 BasicProgram()
{
vertexShader = shaderBuilder.VertexShader("Common", "Uniforms", "Vertex");
fragmentShader = shaderBuilder.FragmentShader("Common", "Uniforms", "Fragment");
Shaders.AddRange(vertexShader, fragmentShader);
MustLink();
}
public static bool ShouldCullLine(VertexShader.VertexShaderOutput[] vertices)
{
var v0ClipCode = CalculateClipCode(ref vertices[0].Position);
var v1ClipCode = CalculateClipCode(ref vertices[1].Position);
var result = v0ClipCode & v1ClipCode;
return (result != 0);
}
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 unsafe TreeEffect(RenderSystem rs)
: base(rs, TreeEffectFactory.Name, false)
{
this.renderSys = rs;
FileLocation fl = FileSystem.Instance.Locate("tree.cvs", GameFileLocs.Effect);
vtxShader = LoadVertexShader(renderSys, fl);
fl = FileSystem.Instance.Locate("tree.cps", GameFileLocs.Effect);
pixShader = LoadPixelShader(renderSys, fl);
fl = FileSystem.Instance.Locate("tillingmark.tex", GameFileLocs.Texture);
noTexture = TextureManager.Instance.CreateInstance(fl);// fac.CreateTexture(1, 1, 1, TextureUsage.Static, ImagePixelFormat.A8R8G8B8);
}
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);
}
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;
}
}
public override bool ShouldCull(VertexShader.VertexShaderOutput[] vertices)
{
var a = vertices[0].Position;
var b = vertices[1].Position;
var c = vertices[2].Position;
var ab = Number4.Subtract(ref b, ref a);
var ac = Number4.Subtract(ref c, ref a);
var l0 = new Vector3ForCulling(ab.X, ab.Y, ab.Z);
var l1 = new Vector3ForCulling(ac.X, ac.Y, ac.Z);
l0.Normalize();
l1.Normalize();
var normal = Vector3ForCulling.CrossZ(ref l0, ref l1);
return RasterizerState.ShouldCull(normal > 0);
}
public TestTriangle(SlimDX.Direct3D11.Device Device)
{
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(@"R:\Users\Rox Cox\Documents\Visual Studio 2013\Projects\LightingEngine_v2\LightingEngine_v2\test.fx", "fx_5_0"))
{
try
{
SampleEffect = new Effect(Device, bytecode);
}
catch (Exception e)
{
throw e;
}
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(@"R:\Users\Rox Cox\Documents\Visual Studio 2013\Projects\LightingEngine_v2\LightingEngine_v2\test.fx", "VSTri", "vs_5_0", ShaderFlags.None, EffectFlags.None))
{
VS = new VertexShader(Device, bytecode);
}
EffectTechnique technique = SampleEffect.GetTechniqueByIndex(0);
EffectPass pass = technique.GetPassByIndex(0);
SampleLayout = new InputLayout(Device, pass.Description.Signature, new[] {
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
});
SampleStream = new DataStream(4 * 32, true, true);
SampleStream.WriteRange(new[] {
new Vector4(1.0f, 1.0f, 0.5f, 1.0f), new Vector4(0.0f, 0.8f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, 0.5f, 1.0f), new Vector4(0.3f, 1.0f, 0.3f, 1.0f),
new Vector4(-1.0f, -1.0f, 0.5f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 0.5f, 1.0f), new Vector4(0.0f, 0.8f, 1.0f, 1.0f),
});
SampleStream.Position = 0;
SampleVertices = new SlimDX.Direct3D11.Buffer(Device, SampleStream, new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = 3 * 32,
Usage = ResourceUsage.Default
});
}
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);
}
public Shader(GraphicsDevice graphicsDevice, string name, ShaderBytecode vertex, ShaderBytecode pixel)
: base(graphicsDevice, new StackTrace(1))
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Name is empty or whitespace.", "name");
}
if (vertex == null)
{
throw new ArgumentNullException("vertex");
}
if (pixel == null)
{
throw new ArgumentNullException("pixel");
}
this.Name = name;
this.VertexCode = vertex;
this.PixelCode = pixel;
using (ShaderReflection reflection = new ShaderReflection(VertexCode))
{
for (int i = 0; i < reflection.Description.BoundResources; i++)
{
var res = reflection.GetResourceBindingDescription(i);
resourcesVertex[res.Name] = res.BindPoint;
if (res.Type == ShaderInputType.ConstantBuffer)
{
constantBufferSizes[res.Name] = reflection.GetConstantBuffer(res.Name).Description.Size;
}
}
int inputCount = reflection.Description.InputParameters;
var vertexElements = new VertexElement[inputCount];
for (int i = 0; i < inputCount; i++)
{
var input = reflection.GetInputParameterDescription(i);
if (input.ComponentType != RegisterComponentType.Float32)
{
continue;
}
VertexElementType type;
if (input.UsageMask.HasFlag(RegisterComponentMaskFlags.All))
{
type = VertexElementType.Vector4;
}
else if (input.UsageMask.HasFlag(RegisterComponentMaskFlags.ComponentX | RegisterComponentMaskFlags.ComponentY | RegisterComponentMaskFlags.ComponentZ))
{
type = VertexElementType.Vector3;
}
else if (input.UsageMask.HasFlag(RegisterComponentMaskFlags.ComponentX | RegisterComponentMaskFlags.ComponentY))
{
type = VertexElementType.Vector2;
}
else if (input.UsageMask.HasFlag(RegisterComponentMaskFlags.ComponentX))
{
type = VertexElementType.Single;
}
else
{
continue;
}
VertexElementUsage usage = EnumConverter.ConvertToUsage(input.SemanticName);
vertexElements[i] = new VertexElement(usage, input.SemanticIndex, type);
}
VertexDescription = new VertexDescription(vertexElements);
}
using (ShaderReflection reflection = new ShaderReflection(PixelCode))
{
for (int i = 0; i < reflection.Description.BoundResources; i++)
{
var res = reflection.GetResourceBindingDescription(i);
resourcesPixel[res.Name] = res.BindPoint;
if (res.Type == ShaderInputType.ConstantBuffer)
{
constantBufferSizes[res.Name] = reflection.GetConstantBuffer(res.Name).Description.Size;
}
}
}
VertexShaderHandle = new VertexShader(graphicsDevice.Device, VertexCode);
PixelShaderHandle = new PixelShader(graphicsDevice.Device, PixelCode);
using (MemoryStream stream = new MemoryStream())
using (BinaryWriter writer = new BinaryWriter(stream))
{
writer.Write("DIRECTX11");
writer.Write(VertexCode.Data.Length);
writer.Write(VertexCode.Data);
writer.Write(PixelCode.Data.Length);
writer.Write(PixelCode.Data);
binaryCode = stream.GetBuffer();
}
}
// Example using async
protected override void CreateDeviceDependentResources(Common.DeviceManager deviceManager)
{
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 = HLSLCompiler.CompileFromFile(@"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 = HLSLCompiler.CompileFromFile(@"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", SharpDX.Color.Black, new Point(20, 100), 48, 800));
textRenderer.Initialize(this);
fpsRenderer = ToDispose(new FpsRenderer());
fpsRenderer.Initialize(this);
#endregion
clock.Start();
}
public virtual void Initialize(DeviceManager devices)
{
// Remove previous buffer
RemoveAndDispose(ref constantBuffer);
mediaPlayer.BackgroundColor = Color.Gray;
// Initialize the MediaPlayer
mediaPlayer.Initialize(devices);
// Setup local variables
var d3dDevice = devices.DeviceDirect3D;
var d3dContext = devices.ContextDirect3D;
var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
// Loads vertex shader bytecode
var vertexShaderByteCode = NativeFile.ReadAllBytes(path + "\\MiniCubeTexture_VS.fxo");
vertexShader = new VertexShader(d3dDevice, vertexShaderByteCode);
// Loads pixel shader bytecode
pixelShader = new PixelShader(d3dDevice, NativeFile.ReadAllBytes(path + "\\MiniCubeTexture_PS.fxo"));
// Layout from VertexShader input signature
layout = new InputLayout(d3dDevice, vertexShaderByteCode, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 16, 0)
});
// Instantiate Vertex buiffer from vertex data
var vertices = SharpDX.Direct3D11.Buffer.Create(d3dDevice, BindFlags.VertexBuffer, new[]
{
// 3D coordinates UV Texture coordinates
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, // Front
-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, // BACK
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, // Top
-1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 0.0f, // Bottom
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, // Left
-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 0.0f, // Right
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
});
vertexBufferBinding = new VertexBufferBinding(vertices, sizeof(float) * 6, 0);
// Create Constant Buffer
constantBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(d3dDevice, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Load texture and create sampler
var texture2D = new SharpDX.Direct3D11.Texture2D(d3dDevice, new SharpDX.Direct3D11.Texture2DDescription()
{
Width = 512,
Height = 512,
ArraySize = 1,
BindFlags = SharpDX.Direct3D11.BindFlags.ShaderResource | BindFlags.RenderTarget,
Usage = SharpDX.Direct3D11.ResourceUsage.Default,
CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.None,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
MipLevels = 1,
OptionFlags = SharpDX.Direct3D11.ResourceOptionFlags.None,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
});
textureView = new ShaderResourceView(d3dDevice, texture2D);
// Bind the media player with this output texture
mediaPlayer.OutputVideoTexture = texture2D;
sampler = new SamplerState(d3dDevice, new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Never,
MaximumAnisotropy = 16,
MipLodBias = 0,
MinimumLod = -float.MaxValue,
MaximumLod = float.MaxValue
});
clock = new Stopwatch();
clock.Start();
// Plays the video
mediaPlayer.Url = "bidon";
mediaPlayer.SetBytestream(this.VideoStream);
}
private void CreateVertexShader()
{
System.Diagnostics.Debug.Assert(Stage == ShaderStage.Vertex);
_vertexShader = new VertexShader(GraphicsDevice._d3dDevice, _shaderBytecode, null);
}
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\DiffusePS.hlsl", "PSMain", "ps_5_0"))
lambertShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert 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));
// 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(blinnPhongShader);
// Set our depth stencil state
context.OutputMerger.DepthStencilState = depthStencilState;
// Back-face culling
context.Rasterizer.State = ToDispose(new RasterizerState(device, new RasterizerStateDescription()
{
FillMode = FillMode.Solid,
CullMode = CullMode.Back,
IsFrontCounterClockwise = false,
}));
}
private bool InitializeShader(Device device, IntPtr hwnd, string vsFileName, string psFileName)
{
try
{
// Setup full pathes
vsFileName = DSystemConfiguration.ShaderFilePath + vsFileName;
psFileName = DSystemConfiguration.ShaderFilePath + psFileName;
// Compile the Vertex & Pixel Shader code.
ShaderBytecode vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "SkyDomeVertexShader", DSystemConfiguration.VertexShaderProfile, ShaderFlags.None, EffectFlags.None);
ShaderBytecode pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "SkyDomePixelShader", DSystemConfiguration.PixelShaderProfile, ShaderFlags.None, EffectFlags.None);
// Create the Vertex & Pixel Shader from the buffer.
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
// Create the vertex input layout description.
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
}
};
// 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.
BufferDescription matrixBufferDesc = 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, matrixBufferDesc);
// Setup the description of the gradient constant buffer that is in the pixel shader.
BufferDescription gradientBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <DGradientBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
// Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
ConstantGradientBuffer = new SharpDX.Direct3D11.Buffer(device, gradientBufferDesc);
return(true);
}
catch
{
return(false);
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
RenderForm form = new RenderForm("Kinect Simple point cloud view sample");
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, "ColoredPointCloudView.fx", "VS");
PixelShader pixelShader = ShaderCompiler.CompileFromFile <PixelShader>(device, "ColoredPointCloudView.fx", "PS");
DX11NullInstancedDrawer nulldrawer = new DX11NullInstancedDrawer();
nulldrawer.VertexCount = Consts.DepthWidth;
nulldrawer.InstanceCount = Consts.DepthHeight;
DX11NullGeometry nullGeom = new DX11NullGeometry(device, nulldrawer);
nullGeom.Topology = SharpDX.Direct3D.PrimitiveTopology.PointList;
KinectSensor sensor = KinectSensor.GetDefault();
sensor.Open();
cbCamera camera = new cbCamera();
camera.Projection = Matrix.PerspectiveFovLH(1.57f * 0.5f, 1.3f, 0.01f, 100.0f);
camera.View = Matrix.Translation(0.0f, 0.0f, 2.0f);
camera.Projection.Transpose();
camera.View.Transpose();
ConstantBuffer <cbCamera> cameraBuffer = new ConstantBuffer <cbCamera>(device);
cameraBuffer.Update(context, ref camera);
bool doQuit = false;
bool uploadCamera = false;
bool uploadRgb = false;
CameraRGBFrameData cameraFrame = new CameraRGBFrameData();
DynamicCameraRGBTexture cameraTexture = new DynamicCameraRGBTexture(device);
DepthToColorFrameData depthToColorFrame = new DepthToColorFrameData();
DynamicDepthToColorTexture depthToColorTexture = new DynamicDepthToColorTexture(device);
KinectSensorDepthFrameProvider provider = new KinectSensorDepthFrameProvider(sensor);
provider.FrameReceived += (sender, args) => { cameraFrame.Update(sensor.CoordinateMapper, args.DepthData); depthToColorFrame.Update(sensor.CoordinateMapper, args.DepthData); uploadCamera = true; };
//Get coordinate map + rgb
ColorRGBAFrameData colorFrame = new ColorRGBAFrameData();
DynamicColorRGBATexture colorTexture = new DynamicColorRGBATexture(device);
KinectSensorColorRGBAFrameProvider colorProvider = new KinectSensorColorRGBAFrameProvider(sensor);
colorProvider.FrameReceived += (sender, args) => { colorFrame = args.FrameData; uploadRgb = true; };
form.KeyDown += (sender, args) => { if (args.KeyCode == Keys.Escape)
{
doQuit = true;
}
};
RenderLoop.Run(form, () =>
{
if (doQuit)
{
form.Dispose();
return;
}
if (uploadCamera)
{
cameraTexture.Copy(context.Context, cameraFrame);
depthToColorTexture.Copy(context.Context, depthToColorFrame);
uploadCamera = false;
}
if (uploadRgb)
{
colorTexture.Copy(context.Context, colorFrame);
uploadRgb = false;
}
context.RenderTargetStack.Push(swapChain);
context.Context.ClearRenderTargetView(swapChain.RenderView, SharpDX.Color.Black);
context.Context.VertexShader.Set(vertexShader);
context.Context.PixelShader.Set(pixelShader);
context.Context.VertexShader.SetShaderResource(0, cameraTexture.ShaderView);
context.Context.VertexShader.SetShaderResource(1, colorTexture.ShaderView);
context.Context.VertexShader.SetShaderResource(2, depthToColorTexture.ShaderView);
context.Context.VertexShader.SetSampler(0, device.SamplerStates.LinearClamp);
context.Context.VertexShader.SetConstantBuffer(0, cameraBuffer.Buffer);
nullGeom.Bind(context, null);
nullGeom.Draw(context);
context.RenderTargetStack.Pop();
swapChain.Present(0, SharpDX.DXGI.PresentFlags.None);
});
swapChain.Dispose();
context.Dispose();
device.Dispose();
cameraBuffer.Dispose();
cameraTexture.Dispose();
provider.Dispose();
pixelShader.Dispose();
vertexShader.Dispose();
sensor.Close();
colorTexture.Dispose();
colorProvider.Dispose();
depthToColorFrame.Dispose();
depthToColorTexture.Dispose();
}
private bool InitializeShader(Device device, IntPtr windowsHandle, string vsFileName, string psFileName)
{
try
{
vsFileName = DSystemConfiguration.ShaderFilePath + vsFileName;
psFileName = DSystemConfiguration.ShaderFilePath + psFileName;
// Compile the vertex shader code.
ShaderBytecode vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "ColorVertexShader", "vs_4_0", ShaderFlags.None, EffectFlags.None);
// Compile the pixel shader code.
ShaderBytecode 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.
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 = "COLOR",
SemanticIndex = 0,
Format = SharpDX.DXGI.Format.R32G32B32A32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
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.
BufferDescription matrixBufDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <DMatrixBuffer>(), // was 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 SharpDX.Direct3D11.Buffer(device, matrixBufDesc);
return(true);
}
catch (Exception ex)
{
MessageBox.Show("Error initializing shader. Error is " + ex.Message);
return(false);
}
}
internal override void ClearState()
{
base.ClearState();
m_vertexShader = null;
}
public override void CreateDeviceResources()
{
base.CreateDeviceResources();
var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
// Loads vertex shader bytecode
var vertexShaderByteCode = NativeFile.ReadAllBytes(path + "\\MiniCube_VS.fxo");
_vertexShader = new VertexShader(_device, vertexShaderByteCode);
// Loads pixel shader bytecode
_pixelShader = new PixelShader(_device, NativeFile.ReadAllBytes(path + "\\MiniCube_PS.fxo"));
// Layout from VertexShader input signature
_vertexLayout = new InputLayout(_device, vertexShaderByteCode, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
});
// Instantiate Vertex buffer from vertex data
var vertices = SharpDX.Direct3D11.Buffer.Create(_device, BindFlags.VertexBuffer, new[]
{
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f), // Front
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f), // BACK
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f), // Top
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f), // Bottom
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f), // Left
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f), // Right
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
});
_vertexBufferBinding = new VertexBufferBinding(vertices, Utilities.SizeOf <Vector4>() * 2, 0);
// Create Constant Buffer
_constantBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(_device, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
_clock = new Stopwatch();
_clock.Start();
_loadingComplete = true;
}
public static void Initialize(GL_ControlModern control, float scale)
{
if (DefaultShaderProgram != null && DefaultShaderProgram.programs.ContainsKey(control))
{
return;
}
if (DefaultShaderProgram == null)
{
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec4 color;
out vec4 fragColor;
void main(){
fragColor = color;
}");
var solidColorVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
void main(){
gl_Position = mtxCam*mtxMdl*position;
}");
var defaultFrag = new FragmentShader(
@"#version 330
uniform vec4 highlight_color;
uniform sampler2D texture0;
in vec3 viewPosition;
in vec3 normal;
in vec2 f_texcoord0;
out vec4 fragColor;
void main(){
vec4 color = texture(texture0,f_texcoord0);
float hc_a = highlight_color.w;
vec4 colorComb = vec4(color.rgb * (1-hc_a) + highlight_color.rgb * hc_a, color.a);
vec3 displayNormal = (normal.xyz * 0.5) + 0.5;
float halfLambert = max(displayNormal.y,0.5);
vec4 colorOutput = vec4(colorComb.rgb * halfLambert, colorComb.a);
fragColor = colorOutput;
}");
var defaultVert = new VertexShader(
@"#version 330
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 vNormal;
layout(location = 2) in vec2 vTexCoord;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec3 normal;
out vec3 viewPosition;
out vec2 f_texcoord0;
void main(){
normal = vNormal;
viewPosition = position;
f_texcoord0 = vTexCoord;
gl_Position = mtxCam*mtxMdl*vec4(position, 1);
}");
DefaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert, control);
SolidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert, control);
int buffer = GL.GenBuffer();
sphereVao = new VertexArrayObject(buffer);
sphereVao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, 32, 0);
sphereVao.AddAttribute(1, 3, VertexAttribPointerType.Float, false, 32, 12);
sphereVao.AddAttribute(2, 2, VertexAttribPointerType.Float, false, 32, 24);
sphereVao.Initialize(control);
List <float> list = new List <float>();
Vertices = GetVertices(scale);
for (int i = 0; i < Vertices.Length; i++)
{
list.Add(Vertices[i].Position.X);
list.Add(Vertices[i].Position.Y);
list.Add(Vertices[i].Position.Z);
list.Add(Vertices[i].Normal.X);
list.Add(Vertices[i].Normal.Y);
list.Add(Vertices[i].Normal.Z);
list.Add(Vertices[i].TexCoord.X);
list.Add(Vertices[i].TexCoord.Y);
}
float[] data = list.ToArray();
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
}
else
{
sphereVao.Initialize(control);
DefaultShaderProgram.Link(control);
SolidColorShaderProgram.Link(control);
}
}
protected override void CreateDeviceDependentResources()
{
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref vertexShaderInstanced);
RemoveAndDispose(ref geomShader);
RemoveAndDispose(ref pixelShader);
RemoveAndDispose(ref blendState);
RemoveAndDispose(ref linearSampler);
RemoveAndDispose(ref perComputeBuffer);
RemoveAndDispose(ref perFrame);
// Dispose of any loaded particle textures
particleTextureSRVs.ForEach(srv => RemoveAndDispose(ref srv));
particleTextureSRVs.Clear();
// Dispose of any compute shaders
computeShaders.Select(kv => kv.Value).ToList().ForEach(cs => RemoveAndDispose(ref cs));
computeShaders.Clear();
var device = this.DeviceManager.Direct3DDevice;
#region Compile Vertex/Pixel/Geometry shaders
// Compile and create the vertex shader
using (var vsBytecode = HLSLCompiler.CompileFromFile(@"Shaders\ParticleVS.hlsl", "VSMain", "vs_5_0"))
using (var vsInstance = HLSLCompiler.CompileFromFile(@"Shaders\ParticleVS.hlsl", "VSMainInstance", "vs_5_0"))
// Compile and create the pixel shader
using (var psBytecode = HLSLCompiler.CompileFromFile(@"Shaders\ParticlePS.hlsl", "PSMain", "ps_5_0"))
// Compile and create the geometry shader
using (var gsBytecode = HLSLCompiler.CompileFromFile(@"Shaders\ParticleGS.hlsl", "PointToQuadGS", "gs_5_0"))
{
vertexShader = ToDispose(new VertexShader(device, vsBytecode));
vertexShaderInstanced = ToDispose(new VertexShader(device, vsInstance));
pixelShader = ToDispose(new PixelShader(device, psBytecode));
geomShader = ToDispose(new GeometryShader(device, gsBytecode));
}
#endregion
#region Blend States
var blendDesc = new BlendStateDescription()
{
IndependentBlendEnable = false,
AlphaToCoverageEnable = false,
};
// Additive blend state that darkens
blendDesc.RenderTarget[0] = new RenderTargetBlendDescription
{
IsBlendEnabled = true,
BlendOperation = BlendOperation.Add,
AlphaBlendOperation = BlendOperation.Add,
SourceBlend = BlendOption.SourceAlpha,
DestinationBlend = BlendOption.InverseSourceAlpha,
SourceAlphaBlend = BlendOption.One,
DestinationAlphaBlend = BlendOption.Zero,
RenderTargetWriteMask = ColorWriteMaskFlags.All
};
blendState = ToDispose(new BlendState(device, blendDesc));
// Additive blend state that lightens
// (needs a dark background)
blendDesc.RenderTarget[0].DestinationBlend = BlendOption.One;
blendStateLight = ToDispose(new BlendState(device, blendDesc));
#endregion
// depth stencil state to disable Z-buffer
disableDepthWrite = ToDispose(new DepthStencilState(device, new DepthStencilStateDescription {
DepthComparison = Comparison.Less,
DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.Zero,
IsDepthEnabled = true,
IsStencilEnabled = false
}));
// Create a linear sampler
linearSampler = ToDispose(new SamplerState(device, new SamplerStateDescription
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
Filter = Filter.MinMagMipLinear, // Bilinear
MaximumLod = float.MaxValue,
MinimumLod = 0,
}));
// Create the per compute shader constant buffer
perComputeBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ParticleConstants>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the particle frame buffer
perFrame = ToDispose(new Buffer(device, Utilities.SizeOf <ParticleFrame>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
particleTextureSRVs.Add(ToDispose(TextureLoader.ShaderResourceViewFromFile(device, "Particle.png")));
particleTextureSRVs.Add(ToDispose(TextureLoader.ShaderResourceViewFromFile(device, "Snowflake.png")));
particleTextureSRVs.Add(ToDispose(TextureLoader.ShaderResourceViewFromFile(device, "Square.png")));
activeParticleTextureIndex = 0;
// Reinitialize particles if > 0
if (this.Constants.MaxParticles > 0)
{
InitializeParticles(this.Constants.MaxParticles, this.Constants.MaxLifetime);
}
}
public Program(CSGL gl,string VSFileName,string FSFileName)
: base(gl)
{
StreamReader SR;
SR = new StreamReader(VSFileName);
VShader = new CSGL.VertexShader(gl,SR.ReadToEnd());
SR.Close();
SR = new StreamReader(FSFileName);
FShader = new CSGL.FragmentShader(gl,SR.ReadToEnd());
SR.Close();
Initial();
}
public VertexShader GetGLShaderToPixel()
{
return glShaderToPixel ?? (glShaderToPixel = CreateNative(ShaderStage.Pixel));
}
private void FormMain_Shown(object sender, EventArgs e)
{
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(this.Width, this.Height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = this.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
// Create Device and SwapChain
Device11 device11;
SwapChain swMain;
Device11.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, desc, out device11, out swMain);
// Ignore all windows events
var factory = swMain.GetParent <Factory>();
factory.MakeWindowAssociation(this.Handle, WindowAssociationFlags.IgnoreAll);
// New RenderTargetView from the backbuffer
var backBuffer = Texture2D.FromSwapChain <Texture2D>(swMain, 0);
var renderView = new RenderTargetView(device11, backBuffer);
device11.ImmediateContext.Rasterizer.State = new RasterizerState(device11, new RasterizerStateDescription()
{
CullMode = CullMode.None, FillMode = FillMode.Solid
});
device11.ImmediateContext.Rasterizer.SetViewport(new Viewport(0, 0, this.Width, this.Height, 0.0f, 1.0f));
device11.ImmediateContext.OutputMerger.SetTargets(renderView);
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.CompileFromFile("Color.hlsl", "VS", "vs_5_0", ShaderFlags.None, EffectFlags.None);
var vertexShader = new VertexShader(device11, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("Color.hlsl", "PS", "ps_4_0", ShaderFlags.None, EffectFlags.None);
var pixelShader = new PixelShader(device11, pixelShaderByteCode);
// Layout from VertexShader input signature
var layout = new InputLayout(
device11,
ShaderSignature.GetInputSignature(vertexShaderByteCode),
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
});
// Instantiate Vertex buiffer from vertex data
var vertices1 = Buffer11.Create(device11, BindFlags.VertexBuffer, new[]
{
new Vector4(-0.5f, 0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.1f, 0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.5f, 0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.5f, 0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.1f, 0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.1f, 0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.1f, 0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, 0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.1f, 0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.1f, 0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, 0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, 0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
});
var vertices2 = Buffer11.Create(device11, BindFlags.VertexBuffer, new[]
{
new Vector4(-0.5f, -0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.1f, -0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.5f, -0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.5f, -0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.1f, -0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-0.1f, -0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.1f, -0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, -0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.1f, -0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.1f, -0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, -0.1f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, -0.5f, 0f, 1.0f), new Vector4(0.0f, 0.0f, 0.0f, 1.0f),
});
// Prepare All the stages
device11.ImmediateContext.InputAssembler.InputLayout = layout;
device11.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
device11.ImmediateContext.VertexShader.Set(vertexShader);
device11.ImmediateContext.PixelShader.Set(pixelShader);
Buffer11 wvpBuffer = new Buffer11(device11, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
// Main loop
RenderLoop.Run(this, () =>
{
device11.ImmediateContext.ClearRenderTargetView(renderView, Color.Aquamarine);
device11.ImmediateContext.VertexShader.SetConstantBuffer(0, wvpBuffer);
Matrix projection = Matrix.OrthoLH(1f, 1f, 0, 2f);
Matrix view = Matrix.LookAtLH(new Vector3(0, 0, -1f), Vector3.Zero, Vector3.Up);
Matrix world = Matrix.RotationZ(2);
Matrix WVP = world * view * projection;
device11.ImmediateContext.UpdateSubresource <Matrix>(ref WVP, wvpBuffer);
device11.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices1, 32, 0));
device11.ImmediateContext.Draw(12, 0);
device11.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices2, 32, 0));
device11.ImmediateContext.Draw(12, 0);
swMain.Present(0, PresentFlags.None);
});
// Release all resources
vertexShaderByteCode.Dispose();
vertexShader.Dispose();
pixelShaderByteCode.Dispose();
pixelShader.Dispose();
vertices1.Dispose();
vertices2.Dispose();
layout.Dispose();
renderView.Dispose();
backBuffer.Dispose();
device11.ImmediateContext.ClearState();
device11.ImmediateContext.Flush();
device11.Dispose();
device11.ImmediateContext.Dispose();
swMain.Dispose();
factory.Dispose();
}
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);
}
private void CreateMesh()
{
var device = Direct2D1Platform.Direct3D11Device;
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.CompileFromFile("MiniCube.fx", "VS", "vs_4_0");
var vertexShader = new VertexShader(device, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("MiniCube.fx", "PS", "ps_4_0");
var pixelShader = new PixelShader(device, pixelShaderByteCode);
var signature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
var inputElements = new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
};
// Layout from VertexShader input signature
var layout = new InputLayout(
device,
signature,
inputElements);
// Instantiate Vertex buffer from vertex data
var vertices = Buffer.Create(
device,
BindFlags.VertexBuffer,
new[]
{
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f), // Front
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f), // BACK
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f), // Top
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f), // Bottom
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f), // Left
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f), // Right
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
});
// Create Constant Buffer
_contantBuffer = new Buffer(device, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
var context = Direct2D1Platform.Direct3D11Device.ImmediateContext;
// Prepare All the stages
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, Utilities.SizeOf <Vector4>() * 2, 0));
context.VertexShader.SetConstantBuffer(0, _contantBuffer);
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
}
public virtual void VertexFromString(string input)
{
bcVertex = ShaderBytecode.Compile(input, "VShader", "vs_4_0", ShaderFlags.Debug, EffectFlags.None);
Vertex = new VertexShader(Device, bcVertex);
}
/// <summary>
/// Sets the shader.
/// </summary>
/// <param name="shader">The shader.</param>
public void SetShader(VertexShader shader)
{
VertexShader = shader;
}
public static void Initialize()
{
if (!Initialized)
{
var defaultFrag = new FragmentShader(
@"#version 330
uniform sampler2D tex;
uniform vec4 color;
in vec2 uv;
void main(){
gl_FragColor = color * texture(tex,uv);
}");
var defaultVert = new VertexShader(
@"#version 330
layout(location = 0) in vec4 position;
uniform vec2 uvTopLeft;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
out vec2 uv;
vec2 map(vec2 value, vec2 min1, vec2 max1, vec2 min2, vec2 max2) {
return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
}
void main(){
uv = map(position.xy,vec2(-0.5,0.5),vec2(0.5,-0.5), uvTopLeft, uvTopLeft+vec2(0.25,0.25));
gl_Position = mtxCam*mtxMdl*position;
}");
DefaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert);
int buffer;
#region block
buffer = GL.GenBuffer();
planeVao = new VertexArrayObject(buffer);
planeVao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, sizeof(float) * 3, 0);
planeVao.Submit();
float[] data = new float[]
{
-0.5f, -0.5f, 0,
0.5f, -0.5f, 0,
0.5f, 0.5f, 0,
-0.5f, 0.5f, 0,
};
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
#endregion
//texture sheet
TextureSheet = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, TextureSheet);
var bmp = Properties.Resources.Gizmos;
var bmpData = bmp.LockBits(
new Rectangle(0, 0, 128 * 4, 128 * 4),
System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, 128 * 4, 128 * 4, 0, PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
bmp.UnlockBits(bmpData);
Initialized = true;
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
RenderForm form = new RenderForm("Kinect hd face 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, "ProjectedHdFaceView.fx", "VS");
PixelShader pixelShader = ShaderCompiler.CompileFromFile <PixelShader>(device, "ProjectedHdFaceView.fx", "PS");
HdFaceIndexBuffer faceIndexBuffer = new HdFaceIndexBuffer(device, 1);
DynamicRgbSpaceFaceStructuredBuffer faceRgbBuffer = new DynamicRgbSpaceFaceStructuredBuffer(device, 1);
KinectSensor sensor = KinectSensor.GetDefault();
sensor.Open();
bool doQuit = false;
bool doUpload = false;
KinectBody[] bodyFrame = null;
KinectSensorBodyFrameProvider provider = new KinectSensorBodyFrameProvider(sensor);
form.KeyDown += (sender, args) => { if (args.KeyCode == Keys.Escape)
{
doQuit = true;
}
};
FaceModel currentFaceModel = new FaceModel();
FaceAlignment currentFaceAlignment = new FaceAlignment();
SingleHdFaceProcessor hdFaceProcessor = new SingleHdFaceProcessor(sensor);
hdFaceProcessor.HdFrameReceived += (sender, args) => { currentFaceModel = args.FaceModel; currentFaceAlignment = args.FaceAlignment; doUpload = 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) =>
{
bodyFrame = args.FrameData;
var body = bodyFrame.TrackedOnly().ClosestBodies().FirstOrDefault();
if (body != null)
{
hdFaceProcessor.AssignBody(body);
}
else
{
hdFaceProcessor.Suspend();
}
};
RenderLoop.Run(form, () =>
{
if (doQuit)
{
form.Dispose();
return;
}
if (doUpload)
{
var vertices = currentFaceModel.CalculateVerticesForAlignment(currentFaceAlignment).ToArray();
var vertRgb = new ColorSpacePoint[vertices.Length];
sensor.CoordinateMapper.MapCameraPointsToColorSpace(vertices, vertRgb);
faceRgbBuffer.Copy(context, vertRgb);
doUpload = 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 (hdFaceProcessor.IsValid)
{
context.Context.Rasterizer.State = device.RasterizerStates.WireFrame;
context.Context.OutputMerger.BlendState = device.BlendStates.AlphaBlend;
context.Context.VertexShader.SetShaderResource(0, faceRgbBuffer.ShaderView);
//Draw lines
context.Context.PixelShader.Set(pixelShader);
context.Context.VertexShader.Set(vertexShader);
//Attach index buffer, null topology since we fetch
faceIndexBuffer.AttachWithLayout(context);
faceIndexBuffer.Draw(context, 1);
}
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();
sensor.Close();
}
public void SetVertexShader(VertexShader vs)
{
mVertexShader = vs;
}
static void Main()
{
var form = new RenderForm("Triange")
{
ClientSize = new System.Drawing.Size(800, 800)
};
Device device;
SwapChain swapChain;
var swapDesc = 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
};
Device.CreateWithSwapChain(
DriverType.Hardware,
DeviceCreationFlags.None,
swapDesc, out device, out swapChain);
var backBuffer = swapChain.GetBackBuffer <Texture2D>(0);
var renderView = new RenderTargetView(device, backBuffer);
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(@".\MiniTri.fx", "VSMain", "vs_5_0");
var vertexShader = new VertexShader(device, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(@".\MiniTri.fx", "PSMain", "ps_5_0");
var pixelShader = new PixelShader(device, pixelShaderByteCode);
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)
});
var points = 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, 0.0f, 1.0f, 1.0f),
new Vector4(0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f)
};
var bufDesc = new BufferDescription
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default
};
var vb = Buffer.Create(device, points, bufDesc);
DeviceContext context = device.ImmediateContext;
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vb, 32, 0));
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
context.Rasterizer.State = new RasterizerState(device, new RasterizerStateDescription
{
CullMode = CullMode.None,
FillMode = FillMode.Solid
});
context.Rasterizer.SetViewport(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
context.OutputMerger.SetTargets(renderView);
RenderLoop.Run(form, () =>
{
context.ClearRenderTargetView(renderView, Color.Black);
context.Draw(3, 0);
swapChain.Present(0, PresentFlags.None);
});
vertexShaderByteCode.Dispose();
vertexShader.Dispose();
pixelShaderByteCode.Dispose();
pixelShader.Dispose();
vb.Dispose();
layout.Dispose();
renderView.Dispose();
backBuffer.Dispose();
context.ClearState();
context.Flush();
device.Dispose();
context.Dispose();
swapChain.Dispose();
}
public void Initialize(Device1 d3dDevice, DeviceContext1 d3dContext, int capacity = 1024)
{
m_d3dDevice = d3dDevice;
m_d3dContext = d3dContext;
m_capacity = capacity;
var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
var vertexShaderByteCode = NativeFile.ReadAllBytes(path + "\\Assets\\SpriteBatch.vs.cso");
m_vertexShader = new VertexShader(m_d3dDevice, vertexShaderByteCode);
m_pixelShader = new PixelShader(d3dDevice, NativeFile.ReadAllBytes(path + "\\Assets\\SpriteBatch.ps.cso"));
// Layout from VertexShader input signature
m_layout = new InputLayout(d3dDevice, vertexShaderByteCode, new[]
{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32A32_Float, 0, 0),
new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 16, 0),
new InputElement("COLOR", 0, SharpDX.DXGI.Format.R32G32B32A32_Float, 24, 0),
});
SamplerStateDescription samplerDesc = SharpDX.Direct3D11.SamplerStateDescription.Default();
m_sampler = new SamplerState(d3dDevice, samplerDesc);
//BlendStateDescription1 blendDesc = new BlendStateDescription1();
//blendDesc.AlphaToCoverageEnable = true; //set to true to get nice blending betweent sprites
//blendDesc.IndependentBlendEnable = false;
//blendDesc.RenderTarget[0].IsBlendEnabled = true;
//blendDesc.RenderTarget[0].IsLogicOperationEnabled = false;
//blendDesc.RenderTarget[0].SourceBlend = BlendOption.SourceColor;
//blendDesc.RenderTarget[0].DestinationBlend = BlendOption.SourceAlphaSaturate;
//blendDesc.RenderTarget[0].BlendOperation = BlendOperation.Add;
//blendDesc.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
//blendDesc.RenderTarget[0].DestinationAlphaBlend = BlendOption.One
//blendDesc.RenderTarget[0].AlphaBlendOperation = BlendOperation.Maximum; // set to maximum to blend 2 sprites nicely over each other
//blendDesc.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
//m_blendStateAlpha = new BlendState1(d3dDevice, blendDesc);
var description = BlendStateDescription1.Default();
description.RenderTarget[0].IsBlendEnabled = true;
description.RenderTarget[0].SourceBlend = BlendOption.SourceAlpha;
description.RenderTarget[0].DestinationBlend = BlendOption.One;
description.RenderTarget[0].SourceAlphaBlend = BlendOption.SourceAlpha;
description.RenderTarget[0].DestinationAlphaBlend = BlendOption.One;
description.RenderTarget[0].BlendOperation = BlendOperation.Add;
description.RenderTarget[0].IsLogicOperationEnabled = false;
description.RenderTarget[0].AlphaBlendOperation = BlendOperation.Maximum;
description.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
description.AlphaToCoverageEnable = true; //<==RT DOES NOT WORK
description.IndependentBlendEnable = false;
m_blendStateAlpha = new BlendState1(d3dDevice, description);
//[BELOW] Windows RT this does not work
//var description = BlendStateDescription1.Default();
//description.RenderTarget[0].IsBlendEnabled = true;
//description.RenderTarget[0].SourceBlend = BlendOption.SourceColor;
//description.RenderTarget[0].DestinationBlend = BlendOption.SourceAlphaSaturate;
//description.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
//description.RenderTarget[0].DestinationAlphaBlend = BlendOption.One;
//description.RenderTarget[0].BlendOperation = BlendOperation.Add;
//description.RenderTarget[0].IsLogicOperationEnabled = false;
//description.RenderTarget[0].AlphaBlendOperation = BlendOperation.Maximum;
//description.AlphaToCoverageEnable = true;
//description.IndependentBlendEnable = false;
//description.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
//m_blendStateAlpha = new BlendState1(d3dDevice, description);
m_constantBufferVS = ToDispose(new SharpDX.Direct3D11.Buffer(d3dDevice, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
m_constantBufferPS = ToDispose(new SharpDX.Direct3D11.Buffer(d3dDevice, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
//=======================
// Setup the pipeline
//=======================
m_vertices = ToDispose(BuildVerticesBuffer(d3dDevice, 1.0f, new Vector2(0, 1), new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1)));
m_vertexBufferBinding = new VertexBufferBinding(m_vertices, sizeof(float) * 10, 0);
d3dContext.InputAssembler.SetVertexBuffers(0, m_vertexBufferBinding);
d3dContext.InputAssembler.InputLayout = m_layout;
d3dContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
d3dContext.VertexShader.SetConstantBuffer(0, m_constantBufferVS);
d3dContext.VertexShader.Set(m_vertexShader);
d3dContext.PixelShader.SetConstantBuffer(0, m_constantBufferPS);
d3dContext.PixelShader.SetSampler(0, m_sampler);
d3dContext.PixelShader.Set(m_pixelShader);
d3dContext.OutputMerger.BlendState = m_blendStateAlpha; // m_blendStateAlpha, m_blendStateAdditive;
}
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
}
private bool InitialiseShader(Device device, IntPtr windowHandle, string vertexShaderFileName, string pixelShaderFileName)
{
try
{
vertexShaderFileName = SystemConfiguration.ShaderFilePath + vertexShaderFileName;
pixelShaderFileName = SystemConfiguration.ShaderFilePath + pixelShaderFileName;
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(vertexShaderFileName, "FoliageVertexShader", SystemConfiguration.VertexShaderProfile, ShaderFlags.None, EffectFlags.None);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(pixelShaderFileName, "FoliagePixelShader", SystemConfiguration.PixelShaderProfile, ShaderFlags.None, EffectFlags.None);
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
var 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 = "WORLD",
SemanticIndex = 0,
Format = SharpDX.DXGI.Format.R32G32B32A32_Float,
Slot = 1,
AlignedByteOffset = 0,
Classification = InputClassification.PerInstanceData,
InstanceDataStepRate = 1
},
new InputElement()
{
SemanticName = "WORLD",
SemanticIndex = 1,
Format = SharpDX.DXGI.Format.R32G32B32A32_Float,
Slot = 1,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerInstanceData,
InstanceDataStepRate = 1
},
new InputElement()
{
SemanticName = "WORLD",
SemanticIndex = 2,
Format = SharpDX.DXGI.Format.R32G32B32A32_Float,
Slot = 1,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerInstanceData,
InstanceDataStepRate = 1
},
new InputElement()
{
SemanticName = "WORLD",
SemanticIndex = 3,
Format = SharpDX.DXGI.Format.R32G32B32A32_Float,
Slot = 1,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerInstanceData,
InstanceDataStepRate = 1
},
new InputElement()
{
SemanticName = "TEXCOORD",
SemanticIndex = 1,
Format = SharpDX.DXGI.Format.R32G32B32_Float,
Slot = 1,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerInstanceData,
InstanceDataStepRate = 1
}
};
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
var samplerDesc = new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
MipLodBias = 0.0f,
MaximumAnisotropy = 1,
ComparisonFunction = Comparison.Always,
BorderColor = new Color4(0, 0, 0, 0),
MinimumLod = 0,
MaximumLod = float.MaxValue
};
SampleState = new SamplerState(device, samplerDesc);
BufferDescription matrixBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = SharpDX.Utilities.SizeOf <ViewProjectionMatrixBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
ConstantMatrixBuffer = new Buffer(device, matrixBufferDesc);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public void SetVertexShader(VertexShader vertexShader)
{
#if DEBUG_STATE_MANAGER
var s = device.VertexShader;
if (this.vertexShader != s)
throw new Exception("State inconsistent, " + vertexShader + " != " + s);
#endif
if (this.vertexShader != vertexShader)
{
device.VertexShader = vertexShader;
this.vertexShader = vertexShader;
}
}
public static void VertexShader(this Effect effect, VertexShader value)
{
CustomEffect.VertexShaderSet(effect, value);
}
public virtual void Dispose()
{
if (Vertex != null)
{
Vertex.Dispose();
Vertex = null;
bcVertex.Dispose();
bcVertex = null;
}
if (Pixel != null)
{
Pixel.Dispose();
Pixel = null;
bcPixel.Dispose();
bcPixel = null;
}
if (Effect != null)
{
Effect.Dispose();
Effect = null;
bcEffect.Dispose();
bcEffect = null;
}
if (Geo != null)
{
Geo.Dispose();
Geo = null;
bcGeo.Dispose();
bcGeo = null;
}
}
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 tessellateVertexShader);
RemoveAndDispose(ref tessellateTriIntegerShader);
RemoveAndDispose(ref tessellateTriPow2Shader);
RemoveAndDispose(ref tessellateTriFractionalEvenShader);
RemoveAndDispose(ref tessellateTriFractionalOddShader);
RemoveAndDispose(ref tessellateTriDomainShader);
RemoveAndDispose(ref tessellatePhongDomainShader);
RemoveAndDispose(ref debugNormals);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref perObjectBuffer);
RemoveAndDispose(ref perFrameBuffer);
RemoveAndDispose(ref perMaterialBuffer);
RemoveAndDispose(ref perArmatureBuffer);
RemoveAndDispose(ref decalBuffer);
RemoveAndDispose(ref decalDiffuse);
RemoveAndDispose(ref decalDisplacement);
RemoveAndDispose(ref decalNormal);
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"))
using (var vertexTessBytecode = HLSLCompiler.CompileFromFile(@"Shaders\VS.hlsl", "VSPassThruTessellate", "vs_5_0"))
{
vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
tessellateVertexShader = ToDispose(new VertexShader(device, vertexTessBytecode));
// 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),
// "BLENDINDICES"
new InputElement("BLENDINDICES", 0, Format.R32G32B32A32_UInt, 36, 0),
// "BLENDWEIGHT"
new InputElement("BLENDWEIGHT", 0, Format.R32G32B32A32_Float, 52, 0),
// "TANGENT"
new InputElement("TANGENT", 0, Format.R32G32B32A32_Float, 68, 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 Lambert 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));
#region Tessellation Shaders
using (var triIntegerBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesInteger", "hs_5_0", null))
using (var triPow2Bytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesPow2", "hs_5_0", null))
using (var triFractionalEvenBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesFractionalEven", "hs_5_0", null))
using (var triFractionalOddBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesFractionalOdd", "hs_5_0", null))
using (var triDomainShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "DS_Triangles", "ds_5_0", null))
{
tessellateTriIntegerShader = ToDispose(new HullShader(device, triIntegerBytecode));
tessellateTriPow2Shader = ToDispose(new HullShader(device, triPow2Bytecode));
tessellateTriFractionalEvenShader = ToDispose(new HullShader(device, triFractionalEvenBytecode));
tessellateTriFractionalOddShader = ToDispose(new HullShader(device, triFractionalOddBytecode));
tessellateTriDomainShader = ToDispose(new DomainShader(device, triDomainShaderBytecode));
}
using (var phongDomainShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellatePhong.hlsl", "DS_PhongTessellation", "ds_5_0", null))
{
tessellatePhongDomainShader = ToDispose(new DomainShader(device, phongDomainShaderBytecode));
}
using (var pnTriIntegerBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellatePNTri.hlsl", "HS_PNTrianglesInteger", "hs_5_0", null))
using (var pnTriPow2Bytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellatePNTri.hlsl", "HS_PNTrianglesPow2", "hs_5_0", null))
using (var pnTriFractionalEvenBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellatePNTri.hlsl", "HS_PNTrianglesFractionalEven", "hs_5_0", null))
using (var pnTriFractionalOddBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellatePNTri.hlsl", "HS_PNTrianglesFractionalOdd", "hs_5_0", null))
using (var pnTriDomainShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellatePNTri.hlsl", "DS_PNTriangles", "ds_5_0", null))
{
pnTriIntegerShader = ToDispose(new HullShader(device, pnTriIntegerBytecode));
pnTriPow2Shader = ToDispose(new HullShader(device, pnTriPow2Bytecode));
pnTriFractionalEvenShader = ToDispose(new HullShader(device, pnTriFractionalEvenBytecode));
pnTriFractionalOddShader = ToDispose(new HullShader(device, pnTriFractionalOddBytecode));
pnTriDomainShader = ToDispose(new DomainShader(device, pnTriDomainShaderBytecode));
}
using (var geomShaderByteCode = HLSLCompiler.CompileFromFile(@"Shaders\GS_DebugNormals.hlsl", "GSMain", "gs_5_0", null))
{
debugNormals = ToDispose(new GeometryShader(device, geomShaderByteCode));
}
#endregion
// 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));
// Create the decal buffer
decalBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.DecalBuffer>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Load the decal textures
decalDiffuse = ToDispose(ShaderResourceView.FromFile(device, "Crater_Diffuse.png"));
decalDisplacement = ToDispose(ShaderResourceView.FromFile(device, "Crater_Displacement.png"));
decalNormal = ToDispose(ShaderResourceView.FromFile(device, "Crater_Normal.png"));
// 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);
context.VertexShader.SetConstantBuffer(3, perArmatureBuffer);
// Set the vertex shader to run
context.VertexShader.Set(vertexShader);
// Set our hull shader constant buffers
context.HullShader.SetConstantBuffer(0, perObjectBuffer);
context.HullShader.SetConstantBuffer(1, perFrameBuffer);
// Set default Hull Shader
context.HullShader.Set(tessellateTriIntegerShader);
context.DomainShader.SetConstantBuffer(0, perObjectBuffer);
context.DomainShader.SetConstantBuffer(1, perFrameBuffer);
context.DomainShader.SetConstantBuffer(2, perMaterialBuffer);
context.DomainShader.Set(tessellateTriDomainShader);
// Set gemoetry shader buffers
context.GeometryShader.SetConstantBuffer(0, perObjectBuffer);
context.GeometryShader.SetConstantBuffer(1, perFrameBuffer);
// Set our pixel constant buffers
context.PixelShader.SetConstantBuffer(1, perFrameBuffer);
context.PixelShader.SetConstantBuffer(2, perMaterialBuffer);
// Set the pixel shader to run
context.PixelShader.Set(blinnPhongShader);
// Set our depth stencil state
context.OutputMerger.DepthStencilState = depthStencilState;
// Add the decal buffer to the pixel, hull and domain shaders (it uses the 5th slot 0-indexed)
context.HullShader.SetConstantBuffer(4, decalBuffer);
context.DomainShader.SetConstantBuffer(4, decalBuffer);
context.PixelShader.SetConstantBuffer(4, decalBuffer);
// No culling
context.Rasterizer.State = ToDispose(new RasterizerState(device, new RasterizerStateDescription()
{
FillMode = FillMode.Solid,
CullMode = CullMode.None
}));
}
public static bool ShouldCullPoint(VertexShader.VertexShaderOutput[] vertices)
{
var v0ClipCode = CalculateClipCode(ref vertices[0].Position);
return v0ClipCode != 0;
}
public VertexShader GetVertexShader( string bytecode )
{
VertexShader shader;
if (!vsDictionary.TryGetValue( bytecode, out shader ) ) {
shader = new VertexShader( device, bytecode );
vsDictionary.Add( bytecode, shader );
}
return shader;
}
// Initialize hardware-dependent resources.
private void CreateDeviceResources()
{
// Unlike the original C++ sample, we don't have smart pointers so we need to
// dispose Direct3D objects explicitly
Utilities.Dispose(ref d3dDevice);
Utilities.Dispose(ref vertexShader);
Utilities.Dispose(ref inputLayout);
Utilities.Dispose(ref pixelShader);
Utilities.Dispose(ref constantBuffer);
Utilities.Dispose(ref vertexBuffer);
Utilities.Dispose(ref indexBuffer);
// This flag adds support for surfaces with a different color channel ordering
// than the API default. It is required for compatibility with Direct2D.
var creationFlags = DeviceCreationFlags.BgraSupport;
#if DEBUG
// If the project is in a debug build, enable debugging via SDK Layers.
creationFlags |= DeviceCreationFlags.Debug;
#endif
// This array defines the set of DirectX hardware feature levels this app will support.
// Note the ordering should be preserved.
// Don't forget to declare your application's minimum required feature level in its
// description. All applications are assumed to support 9.1 unless otherwise stated.
FeatureLevel[] featureLevels =
{
FeatureLevel.Level_11_1,
FeatureLevel.Level_11_0,
FeatureLevel.Level_10_1,
FeatureLevel.Level_10_0,
FeatureLevel.Level_9_3,
FeatureLevel.Level_9_2,
FeatureLevel.Level_9_1,
};
// Create the Direct3D 11 API device object.
d3dDevice = new Device(DriverType.Hardware, creationFlags, featureLevels);
d3dContext = d3dDevice.ImmediateContext;
// Get the Direct3D 11.1 API device.
using (var dxgiDevice = d3dDevice.QueryInterface <SharpDX.DXGI.Device>())
{
// Query for ISurfaceImageSourceNative interface.
using (var sisNative = ComObject.QueryInterface <ISurfaceImageSourceNative>(this))
{
sisNative.Device = dxgiDevice;
}
}
// Load the vertex shader.
var vsBytecode = ReadData("Scenario2Component\\SimpleVertexShader.cso");
vertexShader = new VertexShader(d3dDevice, vsBytecode);
// Create input layout for vertex shader.
var vertexDesc = new[]
{
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
new InputElement("COLOR", 0, Format.R32G32B32_Float, 12, 0, InputClassification.PerVertexData, 0),
};
inputLayout = new InputLayout(d3dDevice, vsBytecode, vertexDesc);
// Load the pixel shader.
var psBytecode = ReadData("Scenario2Component\\SimplePixelShader.cso");
pixelShader = new PixelShader(d3dDevice, psBytecode);
// Create the constant buffer.
var constantBufferDesc = new BufferDescription()
{
SizeInBytes = Utilities.SizeOf <ModelViewProjectionConstantBuffer>(),
BindFlags = BindFlags.ConstantBuffer
};
constantBuffer = new Buffer(d3dDevice, constantBufferDesc);
// Describe the vertices of the cube.
var cubeVertices = new[]
{
new VertexPositionColor(new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.0f, 0.0f, 0.0f)),
new VertexPositionColor(new Vector3(-0.5f, -0.5f, 0.5f), new Vector3(0.0f, 0.0f, 1.0f)),
new VertexPositionColor(new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(0.0f, 1.0f, 0.0f)),
new VertexPositionColor(new Vector3(-0.5f, 0.5f, 0.5f), new Vector3(0.0f, 1.0f, 1.0f)),
new VertexPositionColor(new Vector3(0.5f, -0.5f, -0.5f), new Vector3(1.0f, 0.0f, 0.0f)),
new VertexPositionColor(new Vector3(0.5f, -0.5f, 0.5f), new Vector3(1.0f, 0.0f, 1.0f)),
new VertexPositionColor(new Vector3(0.5f, 0.5f, -0.5f), new Vector3(1.0f, 1.0f, 0.0f)),
new VertexPositionColor(new Vector3(0.5f, 0.5f, 0.5f), new Vector3(1.0f, 1.0f, 1.0f)),
};
var vertexBufferDesc = new BufferDescription()
{
SizeInBytes = Utilities.SizeOf <VertexPositionColor>() * cubeVertices.Length,
BindFlags = BindFlags.VertexBuffer
};
vertexBuffer = Buffer.Create(d3dDevice, cubeVertices, vertexBufferDesc);
// Describe the cube indices.
var cubeIndices = new ushort[]
{
0, 2, 1, // -x
1, 2, 3,
4, 5, 6, // +x
5, 7, 6,
0, 1, 5, // -y
0, 5, 4,
2, 6, 7, // +y
2, 7, 3,
0, 4, 6, // -z
0, 6, 2,
1, 3, 7, // +z
1, 7, 5,
};
indexCount = cubeIndices.Length;
// Create the index buffer.
var indexBufferDesc = new BufferDescription()
{
SizeInBytes = sizeof(ushort) * cubeIndices.Length,
BindFlags = BindFlags.IndexBuffer
};
indexBuffer = Buffer.Create(d3dDevice, cubeIndices, indexBufferDesc);
// Calculate the aspect ratio and field of view.
float aspectRatio = (float)width / (float)height;
float fovAngleY = 70.0f * MathUtil.Pi / 180.0f;
if (aspectRatio < 1.0f)
{
fovAngleY /= aspectRatio;
}
// Set right-handed perspective projection based on aspect ratio and field of view.
constantBufferData.projection = Matrix.Transpose(
Matrix.PerspectiveFovRH(
fovAngleY,
aspectRatio,
0.01f,
100.0f
)
);
// Start animating at frame 0.
frameCount = 0;
}
private void SetupD3D()
{
SharpDX.Configuration.EnableObjectTracking = true;
if (D3DDevice != null)
{
return;
}
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(Convert.ToInt32(host.ActualWidth), Convert.ToInt32(host.ActualHeight),
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = new WindowInteropHelper(HostWindow).Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
SharpDX.Direct3D11.Device.CreateWithSwapChain(SharpDX.Direct3D.DriverType.Hardware, SharpDX.Direct3D11.DeviceCreationFlags.None, desc, out D3DDevice, out SwapChain);
D3DContext = D3DDevice.ImmediateContext;
//Load Shader from the Internal Resource
string shader = "";
var assembly = this.GetType().Assembly;
using (var stream = assembly.GetManifestResourceStream(assembly.GetName().Name + "." + "ffmege.fx")) {
shader = new StreamReader(stream).ReadToEnd();
}
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.Compile(shader, "VS", "vs_4_0", ShaderFlags.None, EffectFlags.None);
var vertexShader = new VertexShader(D3DDevice, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.Compile(shader, "PS", "ps_4_0", ShaderFlags.None, EffectFlags.None);
var pixelShader = new PixelShader(D3DDevice, pixelShaderByteCode);
var layout = new InputLayout(D3DDevice, ShaderSignature.GetInputSignature(vertexShaderByteCode), new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 16, 0)
});
// Instantiate Vertex buiffer from vertex data
var vertices = SharpDX.Direct3D11.Buffer.Create(D3DDevice, SharpDX.Direct3D11.BindFlags.VertexBuffer, new[]
{
// Position Colour U V
-1.0f, 1.0f, 0.5f, 1.0f, 0.0f, 0.0f, //top left
1.0f, -1.0f, 0.5f, 1.0f, 1.0f, 1.0f, //bottom right
-1.0f, -1.0f, 0.5f, 1.0f, 0.0f, 1.0f, //bottom left
-1.0f, 1.0f, 0.5f, 1.0f, 0.0f, 0.0f, //top left
1.0f, 1.0f, 0.5f, 1.0f, 1.0f, 0.0f, //top right
1.0f, -1.0f, 0.5f, 1.0f, 1.0f, 1.0f, //bottom right
});
var vertexBufferBinding = new VertexBufferBinding(vertices, sizeof(float) * 6, 0);
var sampler = new SamplerState(D3DDevice, new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = SharpDX.Color.Black,
ComparisonFunction = Comparison.Never,
MaximumAnisotropy = 1,
MipLodBias = 0,
MinimumLod = -float.MaxValue,
MaximumLod = float.MaxValue
});
// Prepare All the stages
D3DContext.InputAssembler.SetVertexBuffers(0, vertexBufferBinding);
D3DContext.InputAssembler.InputLayout = layout;
D3DContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
D3DContext.VertexShader.Set(vertexShader);
D3DContext.PixelShader.SetSampler(0, sampler);
D3DContext.PixelShader.Set(pixelShader);
//Clean up temporary resources
vertexShader.Dispose();
pixelShader.Dispose();
layout.Dispose();
vertexBufferBinding.Buffer.Dispose();
vertices.Dispose();
sampler.Dispose();
}
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
}
// [STAThread]
private static void Main()
{
var form = new RenderForm("SharpDX - MiniCube Direct3D11 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
};
// Used for debugging dispose object references
// Configuration.EnableObjectTracking = true;
// Disable throws on shader compilation errors
//Configuration.ThrowOnShaderCompileError = false;
// Create Device and SwapChain
Device device;
SwapChain swapChain;
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, desc, out device, out swapChain);
var context = device.ImmediateContext;
// Ignore all windows events
var factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.CompileFromFile("MiniCube.fx", "VS", "vs_4_0");
var vertexShader = new VertexShader(device, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("MiniCube.fx", "PS", "ps_4_0");
var pixelShader = new PixelShader(device, pixelShaderByteCode);
var signature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
// Layout from VertexShader input signature
var layout = new InputLayout(device, signature, new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
});
// Instantiate Vertex buiffer from vertex data
var vertices = Buffer.Create(device, BindFlags.VertexBuffer, new[]
{
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f), // Front
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f), // BACK
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f), // Top
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f), // Bottom
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f), // Left
new Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f), // Right
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, -1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, -1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f, 1.0f, 1.0f, 1.0f),
});
// Create Constant Buffer
var contantBuffer = new Buffer(device, Utilities.SizeOf <Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
// Prepare All the stages
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, Utilities.SizeOf <Vector4>() * 2, 0));
context.VertexShader.SetConstantBuffer(0, contantBuffer);
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
// Prepare matrices
var view = Matrix.LookAtLH(new Vector3(0, 0, -5), new Vector3(0, 0, 0), Vector3.UnitY);
Matrix proj = Matrix.Identity;
// Use clock
var clock = new Stopwatch();
clock.Start();
// Declare texture for rendering
bool userResized = true;
Texture2D backBuffer = null;
RenderTargetView renderView = null;
Texture2D depthBuffer = null;
DepthStencilView depthView = null;
// Setup handler on resize form
form.UserResized += (sender, args) => userResized = true;
// Setup full screen mode change F5 (Full) F4 (Window)
form.KeyUp += (sender, args) =>
{
if (args.KeyCode == Keys.F5)
{
swapChain.SetFullscreenState(true, null);
}
else if (args.KeyCode == Keys.F4)
{
swapChain.SetFullscreenState(false, null);
}
else if (args.KeyCode == Keys.Escape)
{
form.Close();
}
};
// Main loop
RenderLoop.Run(form, () =>
{
// If Form resized
if (userResized)
{
// Dispose all previous allocated resources
Utilities.Dispose(ref backBuffer);
Utilities.Dispose(ref renderView);
Utilities.Dispose(ref depthBuffer);
Utilities.Dispose(ref depthView);
// Resize the backbuffer
swapChain.ResizeBuffers(desc.BufferCount, form.ClientSize.Width, form.ClientSize.Height, Format.Unknown, SwapChainFlags.None);
// Get the backbuffer from the swapchain
backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
// Renderview on the backbuffer
renderView = new RenderTargetView(device, backBuffer);
// Create the depth buffer
depthBuffer = new Texture2D(device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
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
});
// Create the depth buffer view
depthView = new DepthStencilView(device, depthBuffer);
// Setup targets and viewport for rendering
context.Rasterizer.SetViewport(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
context.OutputMerger.SetTargets(depthView, renderView);
// Setup new projection matrix with correct aspect ratio
proj = Matrix.PerspectiveFovLH((float)Math.PI / 4.0f, form.ClientSize.Width / (float)form.ClientSize.Height, 0.1f, 100.0f);
// We are done resizing
userResized = false;
}
var time = clock.ElapsedMilliseconds / 1000.0f;
var viewProj = Matrix.Multiply(view, proj);
// Clear views
context.ClearDepthStencilView(depthView, DepthStencilClearFlags.Depth, 1.0f, 0);
context.ClearRenderTargetView(renderView, Color.Black);
// Update WorldViewProj Matrix
var worldViewProj = Matrix.RotationX(time) * Matrix.RotationY(time * 2) * Matrix.RotationZ(time * .7f) * viewProj;
worldViewProj.Transpose();
context.UpdateSubresource(ref worldViewProj, contantBuffer);
// Draw the cube
context.Draw(36, 0);
// Present!
swapChain.Present(0, PresentFlags.None);
});
// Release all resources
signature.Dispose();
vertexShaderByteCode.Dispose();
vertexShader.Dispose();
pixelShaderByteCode.Dispose();
pixelShader.Dispose();
vertices.Dispose();
layout.Dispose();
contantBuffer.Dispose();
depthBuffer.Dispose();
depthView.Dispose();
renderView.Dispose();
backBuffer.Dispose();
context.ClearState();
context.Flush();
device.Dispose();
context.Dispose();
swapChain.Dispose();
factory.Dispose();
}
private bool CompileVertexShader( string code, out VertexShader vs, out ConstantTable consts )
{
string errs;
using( GraphicsStream gs = ShaderLoader.CompileShader( code, "main", new Macro[0],
null, "vs_2_0", ShaderFlags.None, out errs, out consts ) )
{
if( !string.IsNullOrEmpty( errs ) )
throw new Exception( "Shader compilation error: " + errs );
vs = new VertexShader( pn3D.Device, gs );
}
return true;
}
private bool InitializeShader(Device device, IntPtr windowHandler, string vsFileName, string psFileName)
{
try
{
// Setup full pathes
vsFileName = SystemConfiguration.ShadersFilePath + vsFileName;
psFileName = SystemConfiguration.ShadersFilePath + psFileName;
#region Initilize Shaders
// Compile the vertex shader code.
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "ClipPlaneVertexShader", SystemConfiguration.VertexShaderProfile, ShaderFlags.None, EffectFlags.None);
// Compile the pixel shader code.
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "ClipPlanePixelShader", SystemConfiguration.PixelShaderProfile, 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);
#endregion
#region Initialize Input Layouts
// 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.R32G32B32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
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
}
};
// Create the vertex input the layout.
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
#endregion
// Release the vertex and pixel shader buffers, since they are no longer needed.
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
#region Initialize Matrix Buffer
// 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 <MatrixBuffer>(),
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);
#endregion
#region Initialize Sampler
// Create a texture sampler state description.
var 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 = 0
};
// Create the texture sampler state.
SampleState = new SamplerState(device, samplerDesc);
#endregion
#region Initialize Clip Plane Buffer
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var clipPlaneBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <ClipPlaneBuffer>(),
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.
ConstantClipPlaneBuffer = new Buffer(device, clipPlaneBufferDesc);
#endregion
return(true);
}
catch (Exception ex)
{
MessageBox.Show("Error initializing shader. Error is " + ex.Message);
return(false);
};
}
public Program(CSGL gl,VertexShader VS,FragmentShader FS)
: base(gl)
{
VShader = VS;
FShader = FS;
Initial();
}
private void InitializeVertexShader(ShaderBytecode sbc)
{
vertexshader_ = new VertexShader(ApplicationDX11.Instance.Device, sbc);
GetSignatureAndReflection(sbc, ref vertexsignature_, ref vertexreflection_);
}
/// <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);
}
public ShadowShader(Device device)
{
byte[] vsbytes = File.ReadAllBytes("Shaders\\ShadowVS.cso");
byte[] vssbytes = File.ReadAllBytes("Shaders\\ShadowVS_Skin.cso");
byte[] psbytes = File.ReadAllBytes("Shaders\\ShadowPS.cso");
shadowvs = new VertexShader(device, vsbytes);
shadowvs_skin = new VertexShader(device, vssbytes);
shadowps = new PixelShader(device, psbytes);
VSSceneVars = new GpuVarsBuffer <ShadowShaderVSSceneVars>(device);
VSEntityVars = new GpuVarsBuffer <ShadowShaderVSEntityVars>(device);
VSModelVars = new GpuVarsBuffer <ShadowShaderVSModelVars>(device);
GeomVars = new GpuVarsBuffer <ShadowShaderGeomVars>(device);
BoneMatrices = new GpuABuffer <Matrix3_s>(device, 255);
ClothVertices = new GpuABuffer <Vector4>(device, 254);
//supported layouts - requires Position, Normal, Colour, Texcoord
layouts.Add(VertexType.Default, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.Default)));
layouts.Add(VertexType.DefaultEx, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.DefaultEx)));
layouts.Add(VertexType.PNCCT, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCT)));
layouts.Add(VertexType.PNCCTTTT, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCTTTT)));
layouts.Add(VertexType.PNCTTTX, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTTTX)));
layouts.Add(VertexType.PNCTTTX_2, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTTTX_2)));
layouts.Add(VertexType.PNCTTTX_3, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTTTX_3)));
layouts.Add(VertexType.PNCTTTTX, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTTTTX)));
layouts.Add(VertexType.PNCTTX, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTTX)));
layouts.Add(VertexType.PNCCTTX, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCTTX)));
layouts.Add(VertexType.PNCCTTX_2, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCTTX_2)));
layouts.Add(VertexType.PNCCTTTX, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCTTTX)));
layouts.Add(VertexType.PNCCTT, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCTT)));
layouts.Add(VertexType.PNCCTX, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCCTX)));
layouts.Add(VertexType.PNCH2, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCH2, VertexDeclarationTypes.Types3)));
layouts.Add(VertexType.PCCH2H4, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PCCH2H4, VertexDeclarationTypes.Types2)));
layouts.Add(VertexType.PNCTT, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTT)));
layouts.Add(VertexType.PNCTTT, new InputLayout(device, vsbytes, VertexTypeGTAV.GetLayout(VertexType.PNCTTT)));
layouts.Add(VertexType.PBBNCT, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCT)));
layouts.Add(VertexType.PBBNCTX, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCTX)));
layouts.Add(VertexType.PBBNCTT, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCTT)));
layouts.Add(VertexType.PBBNCTTT, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCTTT)));
layouts.Add(VertexType.PBBNCCT, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCCT)));
layouts.Add(VertexType.PBBNCCTT, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCCTT)));//TODO
layouts.Add(VertexType.PBBNCCTX, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCCTX)));
layouts.Add(VertexType.PBBNCTTX, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCTTX)));
layouts.Add(VertexType.PBBNCTTTX, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCTTTX))); //TODO
layouts.Add(VertexType.PBBNCCTTX, new InputLayout(device, vssbytes, VertexTypeGTAV.GetLayout(VertexType.PBBNCCTTX))); //TODO
//PBBCCT todo
//PBBNC todo
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,
});
texsamplerc = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Always,
Filter = Filter.MinMagMipPoint,
MaximumAnisotropy = 1,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0,
});
defaultBoneMatrices = new Matrix3_s[255];
for (int i = 0; i < 255; i++)
{
defaultBoneMatrices[i].Row1 = Vector4.UnitX;
defaultBoneMatrices[i].Row2 = Vector4.UnitY;
defaultBoneMatrices[i].Row3 = Vector4.UnitZ;
}
}
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);
}
public TextureShader(Device device)
{
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(VertexShaderFileName, "TextureVertexShader", "vs_4_0", ShaderFlags.None, EffectFlags.None);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(PixelShaderFileName, "TexturePixelShader", "ps_4_0", ShaderFlags.None, EffectFlags.None);
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
var inputElements = new InputElement[]
{
new InputElement
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = Format.R32G32B32_Float,
Slot = 0,
AlignedByteOffset = 0,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = Format.R32G32_Float,
Slot = 0,
AlignedByteOffset = TextureShader.Vertex.AppendAlignedElement,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
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, // Updated each frame
SizeInBytes = Utilities.SizeOf <TextureShader.MatrixBuffer>(), // Contains three matrices
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
ConstantMatrixBuffer = new SharpDX.Direct3D11.Buffer(device, matrixBufferDesc);
// Create a texture sampler state description.
var 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 = 0
};
// Create the texture sampler state.
SamplerState = new SamplerState(device, samplerDesc);
}
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);
}
}
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 depthVertexShader);
RemoveAndDispose(ref depthVertexShaderBytecode);
RemoveAndDispose(ref depthPixelShader);
RemoveAndDispose(ref depthPixelShaderBytecode);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref worldViewProjectionBuffer);
RemoveAndDispose(ref depthStencilState);
// 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;
#endif
// Compile and create the vertex shader
vertexShaderBytecode = ToDispose(ShaderBytecode.CompileFromFile("Simple.hlsl", "VSMain", "vs_5_0", shaderFlags));
vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
// Compile and create the pixel shader
pixelShaderBytecode = ToDispose(ShaderBytecode.CompileFromFile("Simple.hlsl", "PSMain", "ps_5_0", shaderFlags));
pixelShader = ToDispose(new PixelShader(device, pixelShaderBytecode));
// Compile and create the depth vertex and pixel shaders
// These shaders are for checking what the depth buffer should look like
depthVertexShaderBytecode = ToDispose(ShaderBytecode.CompileFromFile("Depth.hlsl", "VSMain", "vs_5_0", shaderFlags));
depthVertexShader = ToDispose(new VertexShader(device, depthVertexShaderBytecode));
depthPixelShaderBytecode = ToDispose(ShaderBytecode.CompileFromFile("Depth.hlsl", "PSMain", "ps_5_0", shaderFlags));
depthPixelShader = ToDispose(new PixelShader(device, depthPixelShaderBytecode));
// Layout from VertexShader input signature
vertexLayout = ToDispose(new InputLayout(device,
vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
//ShaderSignature.GetInputSignature(vertexShaderBytecode),
new[]
{
// input semantic SV_Position = vertex coordinate in object space
new InputElement("SV_Position", 0, Format.R32G32B32A32_Float, 0, 0),
// input semantic COLOR = vertex color
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
}));
// Create the constant buffer that will
// store our worldViewProjection matrix
worldViewProjectionBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <Matrix>(), 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, worldViewProjectionBuffer);
// Set the vertex shader to run
context.VertexShader.Set(vertexShader);
// Set the pixel shader to run
context.PixelShader.Set(pixelShader);
// Set our depth stencil state
context.OutputMerger.DepthStencilState = depthStencilState;
}
