/// <summary>
/// Loads bytecode into a shader object.
/// </summary>
public void Load()
{
if (_vertexBytecode.Length > 0)
{
_vertexShader?.Dispose();
_vertexShader = new VertexShader(Renderer.Device, _vertexBytecode);
}
if (_pixelBytecode.Length > 0)
{
_pixelShader?.Dispose();
_pixelShader = new PixelShader(Renderer.Device, _pixelBytecode);
}
if (_geometryBytecode.Length > 0)
{
_geometryShader?.Dispose();
_geometryShader = new GeometryShader(Renderer.Device, _geometryBytecode);
}
if (_computeBytecode.Length > 0)
{
_computeShader?.Dispose();
_computeShader = new ComputeShader(Renderer.Device, _computeBytecode);
}
// bytecode no longer needed, so unload it
_vertexBytecode = new byte[0];
_pixelBytecode = new byte[0];
_geometryBytecode = new byte[0];
_computeBytecode = new byte[0];
}
public void setGSShader(string GS)
{
var geoShaderBC = ShaderBytecode.CompileFromFile(GS, "GS", "gs_4_0");
var geoShader = new GeometryShader(device, geoShaderBC);
ctx.GeometryShader.Set(geoShader);
}
public void ModifyObject()
{
IntPtr vertexShaderHandle = IntPtr.Zero;
IntPtr geometryShaderHandle = IntPtr.Zero;
IntPtr pixelShaderHandle = IntPtr.Zero;
Program program = m_program.Program;
VertexShader vertexShader = program.VertexShader;
GeometryShader geometryShader = program.GeometryShader;
PixelShader pixelShader = program.PixelShader;
if (vertexShader != null)
{
vertexShaderHandle = ((NativeVertexShader)vertexShader.InternalObject).Handle;
}
if (geometryShader != null)
{
geometryShaderHandle = ((NativeGeometryShader)geometryShader.InternalObject).Handle;
}
if (pixelShader != null)
{
pixelShaderHandle = ((NativePixelShader)pixelShader.InternalObject).Handle;
}
IntPtr vertexLayout = Marshal.UnsafeAddrOfPinnedArrayElement(m_vertexLayout, 0);
m_program.Handle = Program_new(vertexShaderHandle, geometryShaderHandle, pixelShaderHandle, vertexLayout, m_vertexLayout.Length, m_vertexSize, m_pipeline.Handle);
}
public void ImportFile(string srcFile, string targetName, string targetDir)
{
string ext = Path.GetExtension(srcFile).ToLower();
string[] output = this.GetOutputFiles(srcFile, targetName, targetDir);
if (ext == ".vert")
{
VertexShader res = new VertexShader();
res.LoadSource(srcFile);
res.Compile();
res.Save(output[0]);
}
else if (ext == ".frag")
{
FragmentShader res = new FragmentShader();
res.LoadSource(srcFile);
res.Compile();
res.Save(output[0]);
}
else
{
GeometryShader res = new GeometryShader();
res.LoadSource(srcFile);
res.Compile();
res.Save(output[0]);
}
}
public EGeometryShader(GraphicsDevice graphicsDevice, EffectCreateInfo createInfo, string debugName = "")
{
base.graphicsDevice = graphicsDevice;
shaderType = ShaderType.GeometryShader;
if (string.IsNullOrEmpty(createInfo.GeometryShaderBlob))
{
shaderByteCode = GetShaderByteCode(createInfo.GeometryShaderPath, createInfo.GeometryShaderEntryPoint, "gs_5_0");
}
else
{
shaderByteCode = GetShaderByteCodeFromResource(createInfo.GeometryShaderBlob, createInfo.GeometryShaderEntryPoint, "gs_5_0");
}
shaderReflection = ReflectShaderByteCode();
#if DEBUG
base.debugName = debugName;
#endif
constantBuffers = ReflectConstantBuffers();
GeometryShader = new GeometryShader(graphicsDevice.NatiDevice1.D3D11Device, shaderByteCode);
}
public void Dispose()
{
VertexShader?.Dispose();
GeometryShader?.Dispose();
PixelShader?.Dispose();
Layout?.Dispose();
}
private void Update(EvaluationContext context)
{
var resourceManager = ResourceManager.Instance();
var device = resourceManager.Device;
var deviceContext = device.ImmediateContext;
var gsStage = deviceContext.GeometryShader;
ConstantBuffers.GetValues(ref _constantBuffers, context);
ShaderResources.GetValues(ref _shaderResourceViews, context);
SamplerStates.GetValue(context);
_prevConstantBuffers = gsStage.GetConstantBuffers(0, _constantBuffers.Length);
_prevShaderResourceViews = gsStage.GetShaderResources(0, _shaderResourceViews.Length);
_prevGeometryShader = gsStage.Get();
var vs = GeometryShader.GetValue(context);
if (vs == null)
{
return;
}
gsStage.Set(vs);
gsStage.SetConstantBuffers(0, _constantBuffers.Length, _constantBuffers);
gsStage.SetShaderResources(0, _shaderResourceViews.Length, _shaderResourceViews);
}
/// <summary>
/// Release Elements
/// </summary>
public void Dispose()
{
if (VertexShader != null)
{
VertexShader.Dispose();
}
if (PixelShader != null)
{
PixelShader.Dispose();
}
if (GeometryShader != null)
{
GeometryShader.Dispose();
}
if (DomainShader != null)
{
DomainShader.Dispose();
}
if (HullShader != null)
{
HullShader.Dispose();
}
if (Layout != null)
{
Layout.Dispose();
}
}
private void Init(string name, InputElement[] inplElems, FillMode fillMode, bool geometryShader)
{
geom = geometryShader;
//Shaders
using (var b = ShaderBytecode.CompileFromFile("Shaders\\" + name + "Shader.fx", "vs", "vs_4_0", ShaderFlags.None, EffectFlags.None))
{
Sig = ShaderSignature.GetInputSignature(b);
VS = new VertexShader(Renderer.viewport.Device, b);
}
using (var b = ShaderBytecode.CompileFromFile("Shaders\\" + name + "Shader.fx", "ps", "ps_4_0", ShaderFlags.None, EffectFlags.None))
{
PS = new PixelShader(Renderer.viewport.Device, b);
}
if (geometryShader)
{
using (var b = ShaderBytecode.CompileFromFile("Shaders\\" + name + "Shader.fx", "gs", "gs_4_0", ShaderFlags.None, EffectFlags.None))
{
GS_Tri = new GeometryShader(Renderer.viewport.Device, b);
}
}
//InputLayout
Inpl = new InputLayout(Renderer.viewport.Device, Sig, inplElems);
//Rasterizer state
var wireFrameDesc = new RasterizerStateDescription
{
FillMode = fillMode,
CullMode = CullMode.None,
IsFrontCounterclockwise = false,
IsDepthClipEnabled = true
};
RS = RasterizerState.FromDescription(Renderer.viewport.Device, wireFrameDesc);
}
public override T Import <T>(System.IO.Stream source, string source_name, ResourceManager man)
{
System.IO.StreamReader rd = new System.IO.StreamReader(source);
GeometryShader ret = new GeometryShader(rd.ReadToEnd());
return(ret as T);
}
protected async Task RegGSAssets(string name)
{
GeometryShader geometryShader = new GeometryShader();
geometryShader.Initialize(await ReadFile(assetsUri + name));
GSAssets.Add(name, geometryShader);
}
public D3D11Shader(Device device, ShaderDescription description)
{
switch (description.Stage)
{
case ShaderStages.Vertex:
DeviceShader = new VertexShader(device, description.ShaderBytes);
break;
case ShaderStages.Geometry:
DeviceShader = new GeometryShader(device, description.ShaderBytes);
break;
case ShaderStages.TessellationControl:
DeviceShader = new HullShader(device, description.ShaderBytes);
break;
case ShaderStages.TessellationEvaluation:
DeviceShader = new DomainShader(device, description.ShaderBytes);
break;
case ShaderStages.Fragment:
DeviceShader = new PixelShader(device, description.ShaderBytes);
break;
default:
throw Illegal.Value <ShaderStages>();
}
Bytecode = description.ShaderBytes;
}
public PathShader(Device device)
{
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(FileName, "VS", "vs_4_0", ShaderFlags);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(FileName, "PS", "ps_4_0", ShaderFlags);
var geometryShaderByteCode = ShaderBytecode.CompileFromFile(FileName, "GS", "gs_4_0", ShaderFlags);
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
GeometryShader = new GeometryShader(device, geometryShaderByteCode);
Layout = VertexDefinition.Path.GetInputLayout(device, vertexShaderByteCode);
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
geometryShaderByteCode.Dispose();
ConstantMatrixBuffer = new Buffer(device, MatrixBufferDesription);
ConstantPathDataBuffer = new Buffer(device,
new BufferDescription
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <PathData>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
});
SamplerState = new SamplerState(device, WrapSamplerStateDescription);
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <param name="position"></param>
/// <param name="normal"></param>
/// <param name="size"></param>
/// <returns></returns>
public static NormalNode Create(IBufferSource model, string position, string normal, vec3 size)
{
var builders = new RenderMethodBuilder[2];
{
// render model
var vs = new VertexShader(vertexShader, vPosition, vNormal);
var fs = new FragmentShader(fragmentShader);
var provider = new ShaderArray(vs, fs);
var map = new AttributeMap();
map.Add(vPosition, position);
map.Add(vNormal, normal);
builders[0] = new RenderMethodBuilder(provider, map);
}
{
// render normal
var vs = new VertexShader(normalVertex, vPosition, vNormal);
var gs = new GeometryShader(normalGeometry);
var fs = new FragmentShader(normalFragment);
var provider = new ShaderArray(vs, gs, fs);
var map = new AttributeMap();
map.Add(vPosition, position);
map.Add(vNormal, normal);
builders[1] = new RenderMethodBuilder(provider, map);
}
var node = new NormalNode(model, position, builders);
node.ModelSize = size;
node.Initialize();
return(node);
}
/// <summary>
/// Function to reset the shader states.
/// </summary>
internal void Reset()
{
VertexShader.Reset();
PixelShader.Reset();
if (GeometryShader != null)
{
GeometryShader.Reset();
}
if (ComputeShader != null)
{
ComputeShader.Reset();
}
if (HullShader != null)
{
HullShader.Reset();
}
if (DomainShader != null)
{
DomainShader.Reset();
}
}
public void ModifyObject()
{
m_handle = GL.CreateProgram();
PixelShader pixelShader = m_program.PixelShader;
GeometryShader geometryShader = m_program.GeometryShader;
VertexShader vertexShader = m_program.VertexShader;
if (pixelShader != null)
{
GL.AttachShader(m_handle, ((OpenTKPixelShader)pixelShader.InternalObject).Handle);
}
if (geometryShader != null)
{
GL.AttachShader(m_handle, ((OpenTKGeometryShader)geometryShader.InternalObject).Handle);
}
if (vertexShader != null)
{
GL.AttachShader(m_handle, ((OpenTKVertexShader)vertexShader.InternalObject).Handle);
}
GL.LinkProgram(m_handle);
#if DEBUG_INFO
string info;
GL.GetProgramInfoLog(m_handle, out info);
if (!string.IsNullOrEmpty(info))
{
InternalConsole.AddMessage(info, InternalConsole.e_Alert.Warning);
}
#endif
}
public void Dispose()
{
InputLayout.Dispose();
VertexShader.Dispose();
GeometryShader?.Dispose();
FragmentShader.Dispose();
}
/// <summary>
/// Sets the shader.
/// </summary>
/// <param name="shader">The shader.</param>
public void SetShader(ShaderBase shader)
{
switch (shader.ShaderType)
{
case ShaderStage.Vertex:
RemoveAndDispose(ref vertexShader);
vertexShader = shader as VertexShader ?? VertexShader.NullVertexShader;
break;
case ShaderStage.Pixel:
RemoveAndDispose(ref pixelShader);
pixelShader = shader as PixelShader ?? PixelShader.NullPixelShader;
break;
case ShaderStage.Compute:
RemoveAndDispose(ref computeShader);
computeShader = shader as ComputeShader ?? ComputeShader.NullComputeShader;
break;
case ShaderStage.Hull:
RemoveAndDispose(ref hullShader);
hullShader = shader as HullShader ?? HullShader.NullHullShader;
break;
case ShaderStage.Domain:
RemoveAndDispose(ref domainShader);
domainShader = shader as DomainShader ?? DomainShader.NullDomainShader;
break;
case ShaderStage.Geometry:
RemoveAndDispose(ref geometryShader);
geometryShader = shader as GeometryShader ?? GeometryShader.NullGeometryShader;
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="passDescription"></param>
/// <param name="manager"></param>
public ShaderPass(ShaderPassDescription passDescription, IEffectsManager manager)
{
Name = passDescription.Name;
effectsManager = manager;
if (passDescription.ShaderList != null)
{
foreach (var shader in passDescription.ShaderList)
{
var s = manager.ShaderManager.RegisterShader(shader);
switch (shader.ShaderType)
{
case ShaderStage.Vertex:
vertexShader = s as VertexShader;
break;
case ShaderStage.Domain:
domainShader = s as DomainShader;
break;
case ShaderStage.Hull:
hullShader = s as HullShader;
break;
case ShaderStage.Geometry:
geometryShader = s as GeometryShader;
break;
case ShaderStage.Pixel:
pixelShader = s as PixelShader;
break;
case ShaderStage.Compute:
computeShader = s as ComputeShader;
break;
}
}
}
blendState = passDescription.BlendStateDescription != null?
manager.StateManager.Register((BlendStateDescription)passDescription.BlendStateDescription) : BlendStateProxy.Empty;
depthStencilState = passDescription.DepthStencilStateDescription != null?
manager.StateManager.Register((DepthStencilStateDescription)passDescription.DepthStencilStateDescription) : DepthStencilStateProxy.Empty;
rasterState = passDescription.RasterStateDescription != null?
manager.StateManager.Register((RasterizerStateDescription)passDescription.RasterStateDescription) : RasterizerStateProxy.Empty;
BlendFactor = passDescription.BlendFactor;
StencilRef = passDescription.StencilRef;
SampleMask = passDescription.SampleMask;
Topology = passDescription.Topology;
if (passDescription.InputLayoutDescription != null)
{
layout = manager.ShaderManager.RegisterInputLayout(passDescription.InputLayoutDescription);
}
}
public void Dispose()
{
InputLayout.Dispose();
VertexShader.Dispose();
GeometryShader?.Dispose();
FragmentShader.Dispose();
GL.DeleteProgram(ProgramID);
}
/// <summary>Get a geometry shader that has been loaded and compiled on the GPU.</summary>
/// <param name="shaderId">The name associated with the shader when you loaded it.</param>
/// <returns>The shader if it exists.</returns>
public static GeometryShader GetGeometryShader(string shaderId)
{
//GeometryShader shader = _geometryShaderDatabase[shaderId];
GeometryShader shader = _geometryShaderDatabase.Get <string>(shaderId, GeometryShader.CompareTo);
shader.ExistingReferences++;
return(shader);
}
public void Dispose()
{
VertexShader?.Dispose();
PixelShader?.Dispose();
GeometryShader?.Dispose();
Signature?.Dispose();
InputLayout?.Dispose();
}
public ShaderManager(Device device, ShaderBytecode vertexShaderByteCode, ShaderBytecode pixelShaderByteCode, ShaderBytecode geometryShaderByteCode)
{
this.vertexShaderByteCode = vertexShaderByteCode;
this.pixelShaderByteCode = pixelShaderByteCode;
this.geometryShaderByteCode = geometryShaderByteCode;
vertexShader = new VertexShader(device, vertexShaderByteCode);
pixelShader = new PixelShader(device, pixelShaderByteCode);
geometryShader = new GeometryShader(device, geometryShaderByteCode);
}
internal void SetGS(GeometryShader gs)
{
if (State.m_gs != gs)
{
State.m_gs = gs;
Context.GeometryShader.Set(gs);
Stats.SetGS++;
}
}
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 ShaderManager(Device device, ShaderBytecode vertexShaderByteCode, ShaderBytecode pixelShaderByteCode, ShaderBytecode geometryShaderByteCode)
{
this.vertexShaderByteCode = dispose.Add(vertexShaderByteCode);
this.pixelShaderByteCode = dispose.Add(pixelShaderByteCode);
this.geometryShaderByteCode = dispose.Add(geometryShaderByteCode);
vertexShader = dispose.Add(new VertexShader(device, vertexShaderByteCode));
pixelShader = dispose.Add(new PixelShader(device, pixelShaderByteCode));
geometryShader = dispose.Add(new GeometryShader(device, geometryShaderByteCode));
}
public IGeometryShader LoadGeometryShaderFromFile(string relativePath, string entryPoint = null)
{
var bytecode = CompileShaderBytecodeFromFileOrThrow($"{BasePath}\\{relativePath}.hlsl", entryPoint ?? "GS", "gs_5_0");
var shader = new GeometryShader(_device, bytecode);
return(new GeometryShaderBox {
Shader = shader
});
}
public void Dispose()
{
InputLayout.Dispose();
VertexShader.Dispose();
TessellationControlShader?.Dispose();
TessellationEvaluationShader?.Dispose();
GeometryShader?.Dispose();
FragmentShader.Dispose();
}
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();
}
internal void Set(GeometryShader shader)
{
if (shader == m_geometryShader)
{
return;
}
m_geometryShader = shader;
m_deviceContext.GeometryShader.Set(shader);
m_statistics.SetGeometryShaders++;
}
internal void SetGS(GeometryShader gs)
{
if (State.m_gs != gs)
{
State.m_gs = gs;
DeviceContext.GeometryShader.Set(gs);
Stats.SetGS++;
MyRender11.ProcessDebugOutput();
}
}
private float[] FindVertices( GeometryShader shader )
{
List<float> verts = new List<float>();
FindSolidFacesDelegate<UInt16> solidCheck = ( x =>
{
var comp = BlockManager.Get( x ).GetComponant<VisibilityBComponant>();
if ( comp != null )
return comp.SolidFaces;
return Face.None;
} );
foreach ( Octree<UInt16> octree in Chunk.Octrees )
{
var iter = (OctreeEnumerator<UInt16>) octree.GetEnumerator();
while( iter.MoveNext() )
{
OctreeLeaf<UInt16> leaf = iter.Current;
BlockType type = BlockManager.Get( leaf.Value );
var vis = type.GetComponant<VisibilityBComponant>();
if ( vis == null || !vis.IsVisible )
continue;
var mdl = type.GetComponant<ModelBComponant>();
if ( mdl == null )
continue;
int size = iter.Size;
Vector3 offset = new Vector3( iter.X, iter.Y, iter.Z );
verts.AddRange( mdl.Model.GenerateVertexData( offset, size,
leaf.FindExposedFaces( solidCheck ) ) );
}
}
return verts.ToArray();
}
public virtual void GeometryFromString(string input)
{
bcGeo = ShaderBytecode.Compile(input, "GShader", "gs_4_0", ShaderFlags.Debug, EffectFlags.None);
Geo = new GeometryShader(Device, bcGeo);
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var form = new Form1();
Device device;
SwapChain swapChain;
ShaderSignature inputSignature;
VertexShader vertexShader;
GeometryShader geometryShader;
PixelShader pixelShader;
var description = new SwapChainDescription()
{
BufferCount = 2,
Usage = Usage.RenderTargetOutput,
OutputHandle = form.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(1, 0),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard
};
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, description, out device, out swapChain);
// create a view of our render target, which is the backbuffer of the swap chain we just created
RenderTargetView renderTarget;
using (var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0))
renderTarget = new RenderTargetView(device, resource);
// setting a viewport is required if you want to actually see anything
var context = device.ImmediateContext;
var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
context.OutputMerger.SetTargets(renderTarget);
context.Rasterizer.SetViewports(viewport);
// load and compile the vertex shader
using (var bytecode = ShaderBytecode.CompileFromFile("Voxel.fx", "VS", "vs_4_0", ShaderFlags.None, EffectFlags.None))
{
inputSignature = ShaderSignature.GetInputSignature(bytecode);
vertexShader = new VertexShader(device, bytecode);
}
using (var bytecode = ShaderBytecode.CompileFromFile("Voxel.fx", "GS", "gs_4_0", ShaderFlags.None, EffectFlags.None))
{
geometryShader = new GeometryShader(device, bytecode);
}
// load and compile the pixel shader
using (var bytecode = ShaderBytecode.CompileFromFile("Voxel.fx", "PS", "ps_4_0", ShaderFlags.None, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
// create test vertex data, making sure to rewind the stream afterward
var vertices = new DataStream(12 * 3, true, true);
vertices.Write(new Vector3(0.0f, 0.5f, 0.5f));
vertices.Write(new Vector3(0.5f, -0.5f, 0.5f));
vertices.Write(new Vector3(-0.5f, -0.5f, 0.5f));
vertices.Position = 0;
// create the vertex layout and buffer
var elements = new[] { new InputElement("POSITION", 0, Format.R32G32B32_Float, 0) };
var layout = new InputLayout(device, inputSignature, elements);
var vertexBuffer = new Buffer(device, vertices, 12 * 3, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
// configure the Input Assembler portion of the pipeline with the vertex data
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, 12, 0));
// set the shaders
context.VertexShader.Set(vertexShader);
// context.GeometryShader.Set(geometryShader);
context.PixelShader.Set(pixelShader);
// prevent DXGI handling of alt+enter, which doesn't work properly with Winforms
using (var factory = swapChain.GetParent<Factory>())
factory.SetWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAltEnter);
// handle alt+enter ourselves
form.KeyDown += (o, e) =>
{
if (e.Alt && e.KeyCode == Keys.Enter)
swapChain.IsFullScreen = !swapChain.IsFullScreen;
};
// handle form size changes
form.Resize += (o, e) =>
{
renderTarget.Dispose();
swapChain.ResizeBuffers(2, 0, 0, Format.R8G8B8A8_UNorm, SwapChainFlags.AllowModeSwitch);
using (var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0))
renderTarget = new RenderTargetView(device, resource);
context.OutputMerger.SetTargets(renderTarget);
};
MessagePump.Run(form, () =>
{
// clear the render target to a soothing blue
context.ClearRenderTargetView(renderTarget, new Color4(0.5f, 0.5f, 1.0f));
// draw the triangle
context.Draw(3, 0);
swapChain.Present(0, PresentFlags.None);
});
// clean up all resources
// anything we missed will show up in the debug output
vertices.Close();
vertexBuffer.Dispose();
layout.Dispose();
inputSignature.Dispose();
vertexShader.Dispose();
geometryShader.Dispose();
pixelShader.Dispose();
renderTarget.Dispose();
swapChain.Dispose();
device.Dispose();
}
public void UpdateVertices( GeometryShader shader )
{
Monitor.Enter( this );
myVertices = FindVertices( shader );
Monitor.Exit( this );
}
public GeometryShader GetGLShaderToPixel()
{
return glShaderToPixel ?? (glShaderToPixel = CreateNative());
}
public GeometryShader GetGeometryShader( string bytecode )
{
GeometryShader shader;
if (!gsDictionary.TryGetValue( bytecode, out shader ) ) {
shader = new GeometryShader( device, bytecode );
gsDictionary.Add( bytecode, shader );
}
return shader;
}
public void InitializeShaders()
{
Helper.Dispose(VS_FullscreenTriangle, simplePS, mGPUQuadGS, mGPUQuadPerSamplePS, mGPUQuadPS, mGPUQuadVS);
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 + "deferredQuad.hlsl", "GPUQuadPS", "ps_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
mGPUQuadPS = new PixelShader(Renderer.Device, bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "deferredQuad.hlsl", "GPUQuadPerSamplePS", "ps_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
mGPUQuadPerSamplePS = new PixelShader(Renderer.Device, bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "deferredQuad.hlsl", "GPUQuadVS", "vs_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
mGPUQuadVS = new VertexShader(Renderer.Device, bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "deferredQuad.hlsl", "GPUQuadGS", "gs_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
mGPUQuadGS = new GeometryShader(Renderer.Device, bytecode);
}
using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile(path + "simple.hlsl", "SkyboxPS", "ps_5_0", flags, EffectFlags.None, macros, new IncludeFX(path)))
{
simplePS = new PixelShader(Renderer.Device, bytecode);
}
}
