public DX11DynamicStructuredBuffer(Device dev, Buffer buffer, int cnt) //Dynamic default buffer
{
this.Size = cnt;
this.Buffer = buffer;
this.Stride = buffer.Description.StructureByteStride;
this.SRV = new ShaderResourceView(dev, this.Buffer);
}
/// <summary>
/// Resizes the buffer to the nearest power of two >= nElements
/// and sets Count to nElements
/// </summary>
/// <param name="nElements"></param>
public void Resize( int nElements )
{
if( nElements > Capacity || // if we need more than we currently have allocated
nElements < Capacity / 2 ) // or if the current one is more than twice as big
{
Capacity = nElements.RoundUpToNearestPowerOfTwo();
if( Buffer != null )
{
View.Dispose();
Buffer.Dispose();
}
Buffer = BufferFactory.CreateDynamicDataBuffer( Capacity, ElementSizeBytes );
var srv = new ShaderResourceViewDescription()
{
ArraySize = 1,
Format = SlimDX.DXGI.Format.R32G32B32A32_Float,
Dimension = ShaderResourceViewDimension.Buffer,
ElementOffset = 0,
ElementWidth = ElementSizeBytes
};
View = new ShaderResourceView( D3D10Wrapper.Instance.Device, Buffer, srv );
}
Count = nElements;
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
if (this.FInvalidate)
{
if (this.FTextureOutput[0].Contains(context))
{
this.FTextureOutput[0].Dispose(context);
}
try
{
Texture2D tex = context.Device.OpenSharedResource<Texture2D>((IntPtr)this.FPointer[0]);
ShaderResourceView srv = new ShaderResourceView(context.Device, tex);
DX11Texture2D resource = DX11Texture2D.FromTextureAndSRV(context, tex, srv);
this.FTextureOutput[0][context] = resource;
this.FValid[0] = true;
}
catch (Exception ex)
{
this.FValid[0] = false;
}
this.FInvalidate = false;
}
}
public override void Resize(DeviceContextHolder holder, int width, int height) {
if (width == Width && height == Height) return;
base.Resize(holder, width, height);
TargetView = new RenderTargetView(holder.Device, Texture);
View = new ShaderResourceView(holder.Device, Texture);
}
public SimpleObject(string name, IServiceProvider services, PositionTexCoordNormalVertex[] vertices, short[] indices,
string effectAsset, string diffuseMapAsset)
: base(name)
{
if (services == null)
throw new ArgumentNullException("services");
if (vertices == null)
throw new ArgumentNullException("vertices");
if (indices == null)
throw new ArgumentNullException("indices");
batchesRO = new BatchReadOnlyCollection(batches);
// Services
var resourceManager = (ResourceManager)services.GetService(typeof(ResourceManager));
var renderer = (Renderer)services.GetService(typeof(Renderer));
// Load effect & textures
effect = resourceManager.Load<Effect>(effectAsset, false);
diffuseMapView = new ShaderResourceView(renderer.Device, resourceManager.Load<Texture2D>(diffuseMapAsset));
effect.SetVariableByName("DiffuseMap", diffuseMapView, true);
// Create batch
CreateBatch(vertices, indices, renderer);
// Calculate boundary
CalculateBoundary(vertices);
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
if (this.FInvalidate)
{
if (srv != null) { srv.Dispose(); }
if (tex != null) { tex.Dispose(); }
try
{
int p = unchecked((int) this.FPointer[0]);
tex = context.Device.OpenSharedResource<Texture2D>(new IntPtr(p));
srv = new ShaderResourceView(context.Device, tex);
DX11Texture2D resource = DX11Texture2D.FromTextureAndSRV(context, tex, srv);
this.FTextureOutput[0][context] = resource;
this.FValid[0] = true;
}
catch (Exception ex)
{
this.FValid[0] = false;
}
this.FInvalidate = false;
}
}
/// <summary>
/// Plane to display scalar/vector field data on. Condition: Fields domain is 2D.
/// </summary>
/// <param name="origin"></param>
/// <param name="xAxis"></param>
/// <param name="yAxis"></param>
/// <param name="scale">Scaling the field extent.</param>
/// <param name="field"></param>
public FieldPlane(Plane plane, VectorField fields, RenderEffect effect = RenderEffect.DEFAULT, Colormap map = Colormap.Parula)
{
#if DEBUG
// Assert that the fields are 2 dimensional.
foreach(Field field in fields.Scalars)
System.Diagnostics.Debug.Assert(field.Size.Length >= 2);
#endif
this._effect = _planeEffect;
this._vertexSizeBytes = 32;
this._numVertices = 6;
this.UsedMap = map;
this._width = fields[0].Size[0];
this._height = fields[0].Size[1];
this._invalid = fields.InvalidValue ?? float.MaxValue;
this._field = fields;
// Setting up the vertex buffer.
GenerateGeometry(plane, fields[0].Size.ToInt2(), fields.TimeSlice??0);
// Generating Textures from the fields.
_fieldTextures = new ShaderResourceView[fields.Scalars.Length];
for(int f = 0; f < _field.NumVectorDimensions; ++f)
{
Texture2D tex = ColorMapping.GenerateTextureFromField(_device, fields[f]);
_fieldTextures[f] = new ShaderResourceView(_device, tex);
}
this.SetRenderEffect(effect);
this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("TEXTURE", 0, Format.R32G32B32A32_Float, 16, 0)
});
}
public void SetProceduralOverride(byte[] textureBytes, Device device) {
try {
ProceduralOverride = ShaderResourceView.FromMemory(device, textureBytes);
} catch (Exception) {
ProceduralOverride = null;
}
}
public void Draw(DeviceContextHolder holder, ShaderResourceView view, RenderTargetView target,
TargetResourceTexture temporaryEdges, TargetResourceTexture temporaryBlending) {
holder.PrepareQuad(_effect.LayoutPT);
holder.DeviceContext.OutputMerger.BlendState = null;
// edges
holder.DeviceContext.OutputMerger.SetTargets(temporaryEdges.TargetView);
holder.DeviceContext.ClearRenderTargetView(temporaryEdges.TargetView, new Color4(0f, 0f, 0f, 0f));
_effect.FxScreenSizeSpec.Set(new Vector4(1f / holder.Width, 1f / holder.Height, holder.Width, holder.Height));
_effect.FxInputMap.SetResource(view);
_effect.TechSmaa.DrawAllPasses(holder.DeviceContext, 6);
// blending
holder.DeviceContext.OutputMerger.SetTargets(temporaryBlending.TargetView);
holder.DeviceContext.ClearRenderTargetView(temporaryBlending.TargetView, new Color4(0f, 0f, 0f, 0f));
_effect.FxEdgesMap.SetResource(temporaryEdges.View);
_effect.FxAreaTexMap.SetResource(_areasTexMap);
_effect.FxSearchTexMap.SetResource(_searchTexMap);
_effect.TechSmaaB.DrawAllPasses(holder.DeviceContext, 6);
// final part
holder.DeviceContext.OutputMerger.SetTargets(target);
_effect.FxBlendMap.SetResource(temporaryBlending.View);
_effect.TechSmaaN.DrawAllPasses(holder.DeviceContext, 6);
}
public void LoadResources()
{
if (m_Disposed == true)
{
if (m_Filename != null)
{
m_ImposterTexture = Texture2D.FromFile(GameEnvironment.Device, Helper.ResolvePath(m_Filename));
TextureView = new ShaderResourceView(GameEnvironment.Device, m_ImposterTexture);
}
m_Vertices = new SlimDX.Direct3D11.Buffer(GameEnvironment.Device, new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = 4 * Marshal.SizeOf(typeof(Vertex2D)),
Usage = ResourceUsage.Dynamic
});
m_VerticesBindings = new VertexBufferBinding(m_Vertices, Marshal.SizeOf(typeof(Vertex2D)), 0);
WriteRectangle();
m_Disposed = false;
}
}
public void Initialize(Device device, int resolutionX, int resolutionY)
{
m_BokehSpriteTexture = Texture2D.FromFile(device, "textures\\bokeh.dds");
m_BokehSpriteTextureSRV = new ShaderResourceView(device, m_BokehSpriteTexture);
m_HalfResDescriptor = new RenderTargetSet.RenderTargetDescriptor()
{
m_Format = Format.R16G16B16A16_Float,
m_HasDepth = false,
m_NumSurfaces = 1,
m_Height = resolutionY / 2,
m_Width = resolutionX / 2
};
m_HalfHeightDescriptor = new RenderTargetSet.RenderTargetDescriptor()
{
m_Format = Format.R16G16B16A16_Float,
m_HasDepth = false,
m_NumSurfaces = 1,
m_Height = resolutionY / 2,
m_Width = resolutionX
};
m_NumQuads = resolutionX * resolutionY / 4;
}
public void LoadResources()
{
if (m_Disposed == true)
{
Buffer = new Texture2D(GameEnvironment.Device, new Texture2DDescription()
{
Format = m_Format,
Width = m_Width,
Height = m_Height,
OptionFlags = ResourceOptionFlags.None,
MipLevels = 1,
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
});
View = new RenderTargetView(GameEnvironment.Device, Buffer);
ResourceView = new ShaderResourceView(GameEnvironment.Device, Buffer);
Viewport = new Viewport(0, 0, Buffer.Description.Width, Buffer.Description.Height);
m_Disposed = false;
}
}
public Sky(Device device, string filename, float skySphereRadius) {
CubeMapSRV = ShaderResourceView.FromFile(device, filename);
using (var r = CubeMapSRV.Resource) {
r.DebugName = "sky cubemap";
}
var sphere = GeometryGenerator.CreateSphere(skySphereRadius, 30, 30);
var vertices = sphere.Vertices.Select(v => v.Position).ToArray();
var vbd = new BufferDescription(
Marshal.SizeOf(typeof(Vector3)) * vertices.Length,
ResourceUsage.Immutable,
BindFlags.VertexBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None,
0
);
_vb = new Buffer(device, new DataStream(vertices, false, false), vbd);
_indexCount = sphere.Indices.Count;
var ibd = new BufferDescription(
_indexCount * sizeof(int),
ResourceUsage.Immutable,
BindFlags.IndexBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None,
0
);
_ib = new Buffer(device, new DataStream(sphere.Indices.ToArray(), false, false), ibd);
}
public CircleEffect(GameContext context)
: base(context)
{
_context = context;
effect = CGHelper.CreateEffectFx5("Resources\\Shader\\circleShader.fx",
context.RenderContext.DeviceManager.Device);
beffect = CGHelper.CreateEffectFx5("Resources\\Shader\\convergenceBeam.fx",
context.RenderContext.DeviceManager.Device);
noiseView = context.LoadTexture("Resources\\Effect\\noise.png");
beamView = context.LoadTexture("Resources\\Effect\\lazer.png");
ShaderResourceView view = context.LoadTexture("Resources\\Effect\\circle.png");
frontCircle = new DividedPlaneBoard(context.RenderContext, view,100,
new Vector2(100, 100),
new PlaneBoard.PlaneBoardDescription(BlendStateManager.BlendStates.Add, effect, false, RenderFront));
frontCircle.Initialize();
for (int i = 0; i < 3; i++)
{
subCircle[i] = new PlaneBoard(context.RenderContext, view, new Vector2(30, 30),
new PlaneBoard.PlaneBoardDescription(BlendStateManager.BlendStates.Add, effect, false, RenderFront));
subCircle[i].Initialize();
}
for (int i = 0; i < 5; i++)
{
beamEffects[i]=new DividedPlaneBoard(context.RenderContext, view, 100,
new Vector2(100, 100),
new PlaneBoard.PlaneBoardDescription(BlendStateManager.BlendStates.Add, beffect, false, Renderbeam));
beamEffects[i].Initialize();
}
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
if (this.FInvalidate)
{
for (int i = 0; i < FTextureOutput.SliceCount; i++)
{
if (this.FTextureOutput[i].Contains(context))
{
this.FTextureOutput[i].Dispose(context);
}
try
{
int p = unchecked((int) this.FPointer[i]);
IntPtr share = new IntPtr(p);
Texture2D tex = context.Device.OpenSharedResource<Texture2D>(share);
ShaderResourceView srv = new ShaderResourceView(context.Device, tex);
DX11Texture2D resource = DX11Texture2D.FromTextureAndSRV(context, tex, srv);
this.FTextureOutput[i][context] = resource;
this.FValid[i] = true;
}
catch (Exception)
{
this.FValid[i] = false;
}
}
this.FInvalidate = false;
}
}
public void Resize( int length )
{
if( Length == length || length == 0 )
{
return;
}
Length = length;
if( Texture != null )
{
View.Dispose();
Texture.Dispose();
}
var desc = new Texture1DDescription
{
Width = length,
MipLevels = 1,
ArraySize = 1,
Format = Format.R32G32B32A32_Float,
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None
};
Texture = new Texture1D( D3D10Wrapper.Instance.Device, desc );
View = new ShaderResourceView( D3D10Wrapper.Instance.Device, Texture );
}
/// <summary>
/// Constructor
/// Creates the texture we will render to based on the supplied width and height
/// </summary>
/// <param name="device">The device we will create the texture with</param>
/// <param name="texWidth"></param>
/// <param name="texHeight"></param>
public RenderTexture(Device device, int texWidth, int texHeight)
{
Texture2DDescription textureDescription = new Texture2DDescription()
{
Width = texWidth,
Height = texHeight,
MipLevels = 1,
ArraySize = 1,
Format = SlimDX.DXGI.Format.R32G32B32A32_Float,
SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
};
Texture = new Texture2D(device, textureDescription);
RenderTargetViewDescription renderTargetViewDescription = new RenderTargetViewDescription()
{
Format = textureDescription.Format,
Dimension = RenderTargetViewDimension.Texture2D,
MipSlice = 0,
};
renderTargetView = new RenderTargetView(device, Texture, renderTargetViewDescription);
ShaderResourceViewDescription shaderResourceViewDescription = new ShaderResourceViewDescription()
{
Format = textureDescription.Format,
Dimension = ShaderResourceViewDimension.Texture2D,
MostDetailedMip = 0,
MipLevels = 1
};
shaderResourceView = new ShaderResourceView(device, Texture, shaderResourceViewDescription);
}
public void Init(Device device, ParticleEffect fx, ShaderResourceView texArraySRV, ShaderResourceView randomTexSRV, int maxParticles) {
_maxParticles = maxParticles;
_fx = fx;
_texArraySRV = texArraySRV;
_randomTexSRV = randomTexSRV;
BuildVB(device);
}
public void Draw(DeviceContextHolder holder, ShaderResourceView view, RenderTargetView target) {
holder.DeviceContext.OutputMerger.SetTargets(target);
holder.QuadBuffers.Prepare(holder.DeviceContext, _effect.LayoutPT);
_effect.FxScreenSize.Set(new Vector4(holder.Width, holder.Height, 1f / holder.Width, 1f / holder.Height));
_effect.FxInputMap.SetResource(view);
_effect.TechFxaa.DrawAllPasses(holder.DeviceContext, 6);
}
public DX11RenderTexture3D(DX11RenderContext context, Texture3D tex, ShaderResourceView srv, UnorderedAccessView uav)
: base(context)
{
this.Resource = tex;
this.SRV = srv;
this.UAV = uav;
}
public void Blit(ShaderResourceView textureView, params RenderTargetView[] targets)
{
view.Device10.OutputMerger.SetTargets((RenderTargetView)null);
var effect = view.Content.Acquire<Effect>(blitTextureEffect);
effect.GetVariableByName("Texture").AsResource().SetResource(textureView);
Blit(view.Content.Acquire<Effect>(blitTextureEffect), targets);
effect.GetVariableByName("Texture").AsResource().SetResource(null);
effect.GetTechniqueByIndex(0).GetPassByIndex(0).Apply();
}
/// <summary>
/// Renders texture onto screen and scales it.
/// </summary>
/// <param name="texture">Texture to render onto screen.</param>
/// <param name="scale">Scaling value.</param>
public void Render(ShaderResourceView texture, float scale)
{
effect.GetVariableByName("xScale").AsScalar().Set(scale);
effect.GetVariableByName("xTexture").AsResource().SetResource(texture);
graphicsDevice.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
effect.GetTechniqueByIndex(0).GetPassByIndex(0).Apply(graphicsDevice.ImmediateContext);
graphicsDevice.ImmediateContext.Draw(4, 0);
}
void ISpriteObject.CreateResource()
{
Contract.Requires<ArgumentNullException>(Texture != null);
srvTexture = new ShaderResourceView(Game.Context.Device, Texture);
Texture2DDescription tDesc = ((Texture2D)srvTexture.Resource).Description;
if (Size == Size.Empty)
Size = new Size(tDesc.Width, tDesc.Height);
}
public BulletEffect(GameContext context)
: base(context)
{
game = context;
effect=CGHelper.CreateEffectFx5("Resources\\Shader\\bulletShader.fx",context.RenderContext.DeviceManager.Device);
bulletTexture = context.LoadTexture("Resources\\Effect\\thunder.png");
board=new DividedPlaneBoard(context.RenderContext,bulletTexture,100,new Vector2(10,10),new PlaneBoard.PlaneBoardDescription(BlendStateManager.BlendStates.Add, effect,false,SubscribeLazerEffectVariable));
board.Initialize();
}
// Functions
public GPUBufferObject()
{
m_Size = -1;
m_BufferObject = null;
m_ShaderResourceView = null;
m_UnorderedAccessView = null;
m_StagingBufferObject = null;
m_StagingCountBufferObject = null;
}
public void LoadResources()
{
if (m_Disposed == true)
{
m_ParticleTexture = Texture2D.FromFile(GameEnvironment.Device, m_ParticleTexturePath);
m_ParticleTextureView = new ShaderResourceView(GameEnvironment.Device, m_ParticleTexture);
#region Billboard
using (DataStream stream = new DataStream(4 * Marshal.SizeOf(typeof(TexturedVertex)), true, true))
{
stream.WriteRange(new TexturedVertex[] {
new TexturedVertex() { Position = new Vector4(1f, -1f, 0.0f, 1f), TextureCoords = new Vector2(1.0f, 0.0f) },
new TexturedVertex() { Position = new Vector4(-1f, -1f, 0.0f, 1f), TextureCoords = new Vector2(0.0f, 0.0f) },
new TexturedVertex() { Position = new Vector4(1f, 1f, 0.0f, 1f), TextureCoords = new Vector2(1.0f, 1.0f) },
new TexturedVertex() { Position = new Vector4(-1f, 1f, 0.0f, 1f), TextureCoords = new Vector2(0.0f, 1.0f) }
});
stream.Position = 0;
m_BillboardVertices = new SlimDX.Direct3D11.Buffer(GameEnvironment.Device, stream, new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = 4 * Marshal.SizeOf(typeof(TexturedVertex)),
Usage = ResourceUsage.Default
});
}
#endregion
#region Instances
m_Instances = new SlimDX.Direct3D11.Buffer(GameEnvironment.Device, new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = m_MaxCount * Marshal.SizeOf(typeof(StarInstanceVertex)),
Usage = ResourceUsage.Dynamic
});
#endregion
#region Bindings
m_DataBindings = new VertexBufferBinding[2];
m_DataBindings[0] = new VertexBufferBinding(m_BillboardVertices, Marshal.SizeOf(typeof(TexturedVertex)), 0);
m_DataBindings[1] = new VertexBufferBinding(m_Instances, Marshal.SizeOf(typeof(StarInstanceVertex)), 0);
#endregion
m_Disposed = false;
}
}
public override void PrepareToDraw(RenderingContext context)
{
if (!textureSent && Target.Texture != null)
DiffuseTexture = Target.Texture;
CameraMatrix = context.camMatrix;
Effect.GetTechniqueByIndex(0).GetPassByIndex(0).Apply(Mat3DView.GraphicsDevice.ImmediateContext);
Mat3DView.GraphicsDevice.ImmediateContext.InputAssembler.InputLayout = VertexLayout;
}
public void Initialize(DeviceContextHolder holder) {
const Format format = Format.R16G16B16A16_Float;
using (var cubeTex = new Texture2D(holder.Device, new Texture2DDescription {
Width = _cubeMapSize,
Height = _cubeMapSize,
MipLevels = 2,
ArraySize = 6,
SampleDescription = new SampleDescription(1, 0),
Format = format,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube
})) {
_targetView = Enumerable.Range(0, 6).Select(x => new RenderTargetView(holder.Device, cubeTex,
new RenderTargetViewDescription {
Format = format,
Dimension =
RenderTargetViewDimension
.Texture2DArray,
ArraySize = 1,
FirstArraySlice = x,
MipSlice = 0
})).ToArray();
_view = new ShaderResourceView(holder.Device, cubeTex, new ShaderResourceViewDescription {
Format = format,
Dimension = ShaderResourceViewDimension.TextureCube,
MostDetailedMip = 0,
MipLevels = -1
});
}
const Format depthFormat = Format.D32_Float;
using (var depthTex = new Texture2D(holder.Device, new Texture2DDescription {
Width = _cubeMapSize,
Height = _cubeMapSize,
MipLevels = 1,
ArraySize = 1,
SampleDescription = new SampleDescription(1, 0),
Format = depthFormat,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
})) {
_depthTargetView = new DepthStencilView(holder.Device, depthTex, new DepthStencilViewDescription {
Format = depthFormat,
Flags = DepthStencilViewFlags.None,
Dimension = DepthStencilViewDimension.Texture2D,
MipSlice = 0,
});
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
protected virtual void Dispose(bool disposable)
{
if (disposable)
{
if (TextureView != null)
{
TextureView.Dispose();
TextureView = null;
}
}
}
internal void Blend(ShaderResourceView renderTargetsToBlend)
{
if (renderTargetsToBlend == null)
throw new ArgumentNullException("renderTargetsToBlend");
effect.SetVariableBySemantic(StandartSemantics.ColorLayersToBlend, renderTargetsToBlend, true);
effect.SetVariableBySemantic(StandartSemantics.LayerCount, renderTargetsToBlend.Description.ArraySize, true);
PrepareForBlend();
renderer.DrawProceduralEffect(effectTechnique);
}
private bool SetShaderParameters(DeviceContext deviceContext, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, ShaderResourceView texture, float fadeAmount)
{
try
{
#region Set Matrix Shader Resources
// Transpose the matrices to prepare them for shader.
worldMatrix.Transpose();
viewMatrix.Transpose();
projectionMatrix.Transpose();
// Lock the constant buffer so it can be written to.
DataStream mappedResource;
deviceContext.MapSubresource(ConstantMatrixBuffer, MapMode.WriteDiscard, MapFlags.None, out mappedResource);
// Copy the passed in matrices into the constant buffer.
DMatrixBuffer matrixBuffer = new DMatrixBuffer()
{
world = worldMatrix,
view = viewMatrix,
projection = projectionMatrix
};
mappedResource.Write(matrixBuffer);
// Unlock the constant buffer.
deviceContext.UnmapSubresource(ConstantMatrixBuffer, 0);
// Set the position of the constant buffer in the vertex shader.
int bufferPositionNumber = 0;
// Finally set the constant buffer in the vertex shader with the updated values.
deviceContext.VertexShader.SetConstantBuffer(bufferPositionNumber, ConstantMatrixBuffer);
// Set shader resource in the pixel shader.
deviceContext.PixelShader.SetShaderResource(0, texture);
#endregion
#region Set Fade Shader Resources
// Lock the fade constant buffer so it can be written to.
deviceContext.MapSubresource(ConstantFadeBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource);
// Copy the matrices into the constant buffer.
DFadeBuffer fadeBuffer = new DFadeBuffer()
{
fadeAmount = fadeAmount,
padding = Vector3.Zero
};
mappedResource.Write(fadeBuffer);
// Unlock the constant buffer.
deviceContext.UnmapSubresource(ConstantFadeBuffer, 0);
// Set the position of the constant buffer in the vertex shader.
bufferPositionNumber = 0;
// Now set the fade constant buffer in the pixel shader with the updated values.
deviceContext.PixelShader.SetConstantBuffer(bufferPositionNumber, ConstantFadeBuffer);
#endregion
return(true);
}
catch (Exception)
{
return(false);
}
}
public void TestAutoAdjustTonemap()
{
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var hdrImage1 = Texture2D.FromFile(device, HdrImageDDS);
var hdrImage1RV = new ShaderResourceView(device, hdrImage1);
var desc = new Texture2DDescription
{
BindFlags =
BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.R16G16B16A16_Float,
Width = 300,
Height = 300,
ArraySize = 1,
SampleDescription = new SampleDescription(1, 0),
MipLevels = 1,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
var hdrImage = new Texture2D(device, desc);
var hdrImageRTV = new RenderTargetView(device, hdrImage);
var hdrImageRV = new ShaderResourceView(device, hdrImage);
var calculater = new AverageLuminanceCalculater(game, hdrImageRV);
var toneMap = new ToneMapRenderer(game);
game.GameLoopEvent += delegate
{
context.Rasterizer.SetViewports(new Viewport(0, 0, 300, 300));
context.OutputMerger.SetTargets(hdrImageRTV);
if (game.Keyboard.IsKeyPressed(Key.D1))
{
game.TextureRenderer.Draw(hdrImage1RV, new Vector2(), new Vector2(300, 300));
}
if (game.Keyboard.IsKeyPressed(Key.D2))
{
context.ClearRenderTargetView(hdrImageRTV, new Color4(1, 1, 1, 1));
}
calculater.DrawUpdatedLogLuminance();
calculater.DrawUpdatedAdaptedLogLuminance();
context.ClearState();
game.SetBackbuffer();
//game.TextureRenderer.Draw(calculater.AverageLuminanceRV, new Vector2(10, 10),
// new Vector2(300, 300));
game.TextureRenderer.Draw(hdrImageRV, new Vector2(320, 10),
new Vector2(300, 300));
game.TextureRenderer.Draw(calculater.CurrAverageLumRV, new Vector2(10, 320),
new Vector2(270, 270));
context.Rasterizer.SetViewports(new Viewport(10, 10, 300, 300));
toneMap.DrawTonemapped(hdrImageRV, calculater.CurrAverageLumRV);
};
game.Run();
}
public void DrawCombined(ShaderResourceView ambientOcclusionSRV)
{
combineFinal.DrawCombined(ambientOcclusionSRV);
}
protected override void CreateDeviceDependentResources()
{
RemoveAndDispose(ref vertexBuffer);
RemoveAndDispose(ref indexBuffer);
RemoveAndDispose(ref textureView);
RemoveAndDispose(ref samplerState);
// Retrieve our SharpDX.Direct3D11.Device1 instance
var device = this.DeviceManager.Direct3DDevice;
// Load texture (a DDS cube map)
textureView = TextureLoader.ShaderResourceViewFromFile(device, "CubeMap.dds");
// Create our sampler state
samplerState = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
BorderColor = new Color4(0, 0, 0, 0),
ComparisonFunction = Comparison.Never,
Filter = Filter.MinMagMipLinear,
MaximumLod = 9, // Our cube map has 10 mip map levels (0-9)
MinimumLod = 0,
MipLodBias = 0.0f
});
// Create vertex buffer for cube
vertexBuffer = ToDispose(Buffer.Create(device, BindFlags.VertexBuffer, new Vertex[] {
/* Vertex Position Normal, Color */
new Vertex(-0.5f, 0.5f, -0.5f, -1f, 1f, -1f, Color.Gray), // 0-Top-left
new Vertex(0.5f, 0.5f, -0.5f, 1f, 1f, -1f, Color.Gray), // 1-Top-right
new Vertex(0.5f, -0.5f, -0.5f, 1f, -1f, -1f, Color.Gray), // 2-Base-right
new Vertex(-0.5f, -0.5f, -0.5f, -1f, -1f, -1f, Color.Gray), // 3-Base-left
new Vertex(-0.5f, 0.5f, 0.5f, -1f, 1f, 1f, Color.Gray), // 4-Top-left
new Vertex(0.5f, 0.5f, 0.5f, 1f, 1f, 1f, Color.Gray), // 5-Top-right
new Vertex(0.5f, -0.5f, 0.5f, 1f, -1f, 1f, Color.Gray), // 6-Base-right
new Vertex(-0.5f, -0.5f, 0.5f, -1f, -1f, 1f, Color.Gray), // 7-Base-left
}));
vertexBinding = new VertexBufferBinding(vertexBuffer, Utilities.SizeOf <Vertex>(), 0);
// Front Right Top Back Left Bottom
// v0 v1 v1 v5 v1 v0 v5 v4 v4 v0 v3 v2
// |-----| |-----| |-----| |-----| |-----| |-----|
// | \ A | | \ A | | \ A | | \ A | | \ A | | \ A |
// | B \ | | B \ | | B \ | | B \ | | B \ | | B \ |
// |-----| |-----| |-----| |-----| |-----| |-----|
// v3 v2 v2 v6 v5 v4 v6 v7 v7 v3 v7 v6
indexBuffer = ToDispose(Buffer.Create(device, BindFlags.IndexBuffer, new ushort[] {
0, 1, 2, // Front A
0, 2, 3, // Front B
1, 5, 6, // Right A
1, 6, 2, // Right B
1, 0, 4, // Top A
1, 4, 5, // Top B
5, 4, 7, // Back A
5, 7, 6, // Back B
4, 0, 3, // Left A
4, 3, 7, // Left B
3, 2, 6, // Bottom A
3, 6, 7, // Bottom B
}));
}
public bool RenderTerrainShader(DeviceContext deviceContext, int indexCount, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, ShaderResourceView texture, ShaderResourceView normal, Vector3 lightDirection, Vector4 diffuse)
{
if (!TerrainShader.Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, normal, lightDirection, diffuse))
{
return(false);
}
return(true);
}
private RayTableTexture(Texture2D texture, ShaderResourceView view)
{
this.texture = texture;
this.rawView = view;
}
public bool Render(DeviceContext deviceContext, int indexCount, Matrix world, Matrix view, Matrix projection, ShaderResourceView texture)
{
if (!SetShaderParameters(deviceContext, world, view, projection, texture))
{
return(false);
}
RenderShader(deviceContext, indexCount);
return(true);
}
void EnsureResources(SharpDX.Direct3D11.Device device, Texture2DDescription description, Rectangle captureRegion, ScreenshotRequest request)
{
if (_device != null && request.Resize != null && (_resizedRT == null || (_resizedRT.Device.NativePointer != _device.NativePointer || _resizedRT.Description.Width != request.Resize.Value.Width || _resizedRT.Description.Height != request.Resize.Value.Height)))
{
// Create/Recreate resources for resizing
RemoveAndDispose(ref _resizedRT);
RemoveAndDispose(ref _resizedRTV);
RemoveAndDispose(ref _saQuad);
_resizedRT = ToDispose(new Texture2D(_device, new Texture2DDescription()
{
Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm, // Supports BMP/PNG/etc
Height = request.Resize.Value.Height,
Width = request.Resize.Value.Width,
ArraySize = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.RenderTarget,
MipLevels = 1,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None
}));
_resizedRTV = ToDispose(new RenderTargetView(_device, _resizedRT));
_saQuad = ToDispose(new DX11.ScreenAlignedQuadRenderer());
_saQuad.Initialize(new DX11.DeviceManager(_device));
}
// Check if _resolvedRT or _finalRT require creation
if (_finalRT != null && _finalRT.Device.NativePointer == _device.NativePointer &&
_finalRT.Description.Height == captureRegion.Height && _finalRT.Description.Width == captureRegion.Width &&
_resolvedRT != null && _resolvedRT.Description.Height == description.Height && _resolvedRT.Description.Width == description.Width &&
_resolvedRT.Device.NativePointer == device.NativePointer && _resolvedRT.Description.Format == description.Format
)
{
return;
}
RemoveAndDispose(ref _query);
RemoveAndDispose(ref _resolvedRT);
RemoveAndDispose(ref _resolvedSharedSRV);
RemoveAndDispose(ref _finalRT);
RemoveAndDispose(ref _resolvedRTShared);
_query = new Query(_device, new QueryDescription()
{
Flags = QueryFlags.None,
Type = QueryType.Event
});
_queryIssued = false;
_resolvedRT = ToDispose(new Texture2D(device, new Texture2DDescription()
{
CpuAccessFlags = CpuAccessFlags.None,
Format = description.Format, // for multisampled backbuffer, this must be same format
Height = description.Height,
Usage = ResourceUsage.Default,
Width = description.Width,
ArraySize = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0), // Ensure single sample
BindFlags = BindFlags.ShaderResource,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.SharedKeyedmutex
}));
// Retrieve reference to the keyed mutex
_resolvedRTKeyedMutex = ToDispose(_resolvedRT.QueryInterfaceOrNull <SharpDX.DXGI.KeyedMutex>());
using (var resource = _resolvedRT.QueryInterface <SharpDX.DXGI.Resource>())
{
_resolvedRTShared = ToDispose(_device.OpenSharedResource <Texture2D>(resource.SharedHandle));
_resolvedRTKeyedMutex_Dev2 = ToDispose(_resolvedRTShared.QueryInterfaceOrNull <SharpDX.DXGI.KeyedMutex>());
}
// SRV for use if resizing
_resolvedSharedSRV = ToDispose(new ShaderResourceView(_device, _resolvedRTShared));
_finalRT = ToDispose(new Texture2D(_device, new Texture2DDescription()
{
CpuAccessFlags = CpuAccessFlags.Read,
Format = description.Format,
Height = captureRegion.Height,
Usage = ResourceUsage.Staging,
Width = captureRegion.Width,
ArraySize = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.None,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None
}));
_finalRTMapped = false;
}
protected override void CreateDeviceDependentResources()
{
// Dispose of each vertex and index buffer
vertexBuffers.ForEach(vb => RemoveAndDispose(ref vb));
vertexBuffers.Clear();
indexBuffers.ForEach(ib => RemoveAndDispose(ref ib));
indexBuffers.Clear();
textureViews.ForEach(tv => RemoveAndDispose(ref tv));
textureViews.Clear();
RemoveAndDispose(ref samplerState);
// Retrieve our SharpDX.Direct3D11.Device1 instance
var device = this.DeviceManager.Direct3DDevice;
// Initialize vertex buffers
for (int indx = 0; indx < mesh.VertexBuffers.Count; indx++)
{
var vb = mesh.VertexBuffers[indx];
Vertex[] vertices = new Vertex[vb.Length];
for (var i = 0; i < vb.Length; i++)
{
// Retrieve skinning information for vertex
Common.Mesh.SkinningVertex skin = new Common.Mesh.SkinningVertex();
if (mesh.SkinningVertexBuffers.Count > 0)
{
skin = mesh.SkinningVertexBuffers[indx][i];
}
// Create vertex
vertices[i] = new Vertex(vb[i].Position, vb[i].Normal, vb[i].Color, vb[i].UV, skin);
}
vertexBuffers.Add(ToDispose(Buffer.Create(device, BindFlags.VertexBuffer, vertices.ToArray())));
vertexBuffers[vertexBuffers.Count - 1].DebugName = "VertexBuffer_" + indx.ToString();
}
// Initialize index buffers
foreach (var ib in mesh.IndexBuffers)
{
indexBuffers.Add(ToDispose(Buffer.Create(device, BindFlags.IndexBuffer, ib)));
indexBuffers[indexBuffers.Count - 1].DebugName = "IndexBuffer_" + (indexBuffers.Count - 1).ToString();
}
// Load textures if a material has any.
foreach (var m in mesh.Materials)
{
for (var i = 0; i < m.Textures.Length; i++)
{
if (System.IO.File.Exists(m.Textures[i]))
{
textureViews.Add(ToDispose(ShaderResourceView.FromFile(device, m.Textures[i])));
}
else
{
textureViews.Add(null);
}
}
}
// Create our sampler state
samplerState = ToDispose(new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = new Color4(0, 0, 0, 0),
ComparisonFunction = Comparison.Never,
Filter = Filter.Anisotropic,
MaximumAnisotropy = 16,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0.0f
}));
}
public Texture(GxContext context)
{
mContext = context;
NativeView = gDefaultView;
mTexture = gDefaultTexture;
}
static void Main()
{
if (!SharpDevice.IsDirectX11Supported())
{
System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
return;
}
RenderForm form = new RenderForm();
form.Text = "Tutorial 19: Adaptive Tesselation";
SharpFPS fpsCounter = new SharpFPS();
using (SharpDevice device = new SharpDevice(form))
{
SharpBatch font = new SharpBatch(device, "textfont.dds");
InputElement[] description = new InputElement[]
{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0),
new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 12, 0),
};
SharpShader shader = new SharpShader(device, "../../Shader.hlsl",
new SharpShaderDescription()
{
VertexShaderFunction = "VSMain",
PixelShaderFunction = "PSMain",
DomainShaderFunction = "DSMain",
HullShaderFunction = "HSMain"
}, description);
int seqX = 64;
int seqY = 64;
float size = 100;
float sizeW = seqX * size;
float sizeH = seqY * size;
TessellationVertex[] vertices = new TessellationVertex[4356];
int[] indices = new int[63504];
int k = 0;
for (int y = -1; y < seqY + 1; y++)
{
for (int x = -1; x < seqX + 1; x++)
{
float vX = x * size - (seqX / 2.0F) * size;
float vY = y * size - (seqY / 2.0F) * size;
float vZ = 0;
TessellationVertex v = new TessellationVertex(vX, vY, vZ, x / 4.0F, y / 4.0F);
vertices[k] = v;
k++;
}
}
//indici
k = 0;
for (int y = 0; y < seqY - 1; y++)
{
for (int x = 0; x < seqX - 1; x++)
{
int startX = x + 1;
int startY = y + 1;
for (int j = -1; j < 3; j++)
{
for (int i = -1; i < 3; i++)
{
indices[k] = (i + startX + (seqX + 2) * (j + startY));
k++;
}
}
}
}
SharpMesh mesh = SharpMesh.Create <TessellationVertex>(device, vertices, indices);
string path = @"../../../Models/adaptive_tess/";
ShaderResourceView diffuseMap = ShaderResourceView.FromFile(device.Device, path + "D.dds");
ShaderResourceView normalMap = ShaderResourceView.FromFile(device.Device, path + "N.dds");
ShaderResourceView heightMap = ShaderResourceView.FromFile(device.Device, path + "H.dds");
Buffer11 buffer = shader.CreateBuffer <SceneData>();
fpsCounter.Reset();
float angle = 3.14F;
float distance = 1200;
float heightPos = 500;
form.KeyDown += (sender, e) =>
{
switch (e.KeyCode)
{
case Keys.A:
distance -= 5;
if (distance < 100)
{
distance = 100;
}
break;
case Keys.Z:
distance += 5;
if (distance > 2000)
{
distance = 2000;
}
break;
case Keys.Up:
heightPos--;
if (heightPos < 50)
{
heightPos = 50;
}
break;
case Keys.Down:
heightPos++;
if (heightPos > 800)
{
heightPos = 800;
}
break;
case Keys.Left:
angle -= 0.01F;
break;
case Keys.Right:
angle += 0.01F;
break;
case Keys.W:
device.SetWireframeRasterState();
break;
case Keys.S:
device.SetDefaultRasterState();
break;
}
};
//main loop
RenderLoop.Run(form, () =>
{
//Resizing
if (device.MustResize)
{
device.Resize();
font.Resize();
}
//apply states
device.UpdateAllStates();
//clear color
device.Clear(Color.CornflowerBlue);
//Set matrices
float ratio = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
Vector3 vAt = new Vector3((float)Math.Cos(angle) * distance, (float)Math.Sin(angle) * distance, heightPos);
Vector3 vTo = new Vector3(0, 0, 0);
Vector3 vUp = new Vector3(0, 0, 1);
Matrix view = Matrix.LookAtLH(vAt, vTo, vUp);
Matrix proj = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1.0F, 50000);
Vector3 lightDir = new Vector3(1, 0, -2);
lightDir.Normalize();
Matrix WVP = view * proj;
WVP.Transpose();
//update constant buffer
SceneData data = new SceneData()
{
Transform = WVP,
LightDirection = new Vector4(lightDir, 0),
ViewAt = new Vector4(vAt, 0)
};
device.UpdateData <SceneData>(buffer, data);
//pass constant buffer to shader
device.DeviceContext.VertexShader.SetConstantBuffer(0, buffer);
device.DeviceContext.PixelShader.SetConstantBuffer(0, buffer);
device.DeviceContext.HullShader.SetConstantBuffer(0, buffer);
device.DeviceContext.DomainShader.SetConstantBuffer(0, buffer);
//set map to shader
device.DeviceContext.DomainShader.SetShaderResource(0, heightMap);
device.DeviceContext.PixelShader.SetShaderResource(0, diffuseMap);
device.DeviceContext.PixelShader.SetShaderResource(1, normalMap);
//apply shader
shader.Apply();
//draw mesh
mesh.DrawPatch(SharpDX.Direct3D.PrimitiveTopology.PatchListWith16ControlPoints);
//begin drawing text
font.Begin();
//draw string
fpsCounter.Update();
font.DrawString("FPS: " + fpsCounter.FPS, 0, 0, Color.White);
font.DrawString("Presso Up,Down,Left,Right,A,Z to move camera", 0, 20, Color.White);
font.DrawString("Presso W and S to Switch to Wireframe", 0, 40, Color.White);
//flush text to view
font.End();
//present
device.Present();
});
}
}
public void LoadFromLoadInfo(IO.Files.Texture.TextureLoadInfo loadInfo)
{
var texDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = loadInfo.Format,
Height = loadInfo.Height,
Width = loadInfo.Width,
MipLevels = loadInfo.Layers.Count,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
if (mTexture != gDefaultTexture)
{
if (mTexture != null)
{
mTexture.Dispose();
}
if (NativeView != null)
{
NativeView.Dispose();
}
}
var boxes = new DataBox[texDesc.MipLevels];
var streams = new DataStream[texDesc.MipLevels];
try
{
for (var i = 0; i < texDesc.MipLevels; ++i)
{
streams[i] = new DataStream(loadInfo.Layers[i].Length, true, true);
streams[i].WriteRange(loadInfo.Layers[i]);
streams[i].Position = 0;
boxes[i] = new DataBox(streams[i].DataPointer, loadInfo.RowPitchs[i], 0);
}
mTexture = new Texture2D(mContext.Device, texDesc, boxes);
var srvd = new ShaderResourceViewDescription
{
Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D,
Format = loadInfo.Format,
Texture2D = new ShaderResourceViewDescription.Texture2DResource {
MipLevels = boxes.Length, MostDetailedMip = 0
}
};
NativeView = new ShaderResourceView(mContext.Device, mTexture, srvd);
}
finally
{
foreach (var stream in streams)
{
if (stream != null)
{
stream.Dispose();
}
}
}
}
private bool RetrieveFrame()
{
var desktopWidth = _outputDescription.DesktopBounds.GetWidth();
var desktopHeight = _outputDescription.DesktopBounds.GetHeight();
if (_stagingTexture == null)
{
_stagingTexture = new Texture2D(_device, new Texture2DDescription()
{
CpuAccessFlags = CpuAccessFlags.Read,
BindFlags = BindFlags.None,
Format = Format.B8G8R8A8_UNorm,
Width = desktopWidth / scalingFactor,
Height = desktopHeight / scalingFactor,
OptionFlags = ResourceOptionFlags.None,
MipLevels = 1,
ArraySize = 1,
SampleDescription = { Count = 1, Quality = 0 },
Usage = ResourceUsage.Staging // << can be read by CPU
});
}
SharpDX.DXGI.Resource desktopResource;
try
{
if (_outputDuplication == null)
{
throw new Exception("_outputDuplication is null");
}
_outputDuplication.AcquireNextFrame(500, out var frameInformation, out desktopResource);
}
catch (SharpDXException ex)
{
if (ex.ResultCode.Code == SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code)
{
return(false);
}
throw new DesktopDuplicationException("Failed to acquire next frame.", ex);
}
if (desktopResource == null)
{
throw new Exception("desktopResource is null");
}
if (_smallerTexture == null)
{
_smallerTexture = new Texture2D(_device, new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.B8G8R8A8_UNorm,
Width = desktopWidth,
Height = desktopHeight,
OptionFlags = ResourceOptionFlags.GenerateMipMaps,
MipLevels = mipMapLevel + 1,
ArraySize = 1,
SampleDescription = { Count = 1, Quality = 0 },
Usage = ResourceUsage.Default
});
_smallerTextureView = new ShaderResourceView(_device, _smallerTexture);
}
using (var tempTexture = desktopResource.QueryInterface <Texture2D>())
{
if (_device == null)
{
throw new Exception("_device is null");
}
if (_device.ImmediateContext == null)
{
throw new Exception("_device.ImmediateContext is null");
}
_device.ImmediateContext.CopySubresourceRegion(tempTexture, 0, null, _smallerTexture, 0);
}
_outputDuplication.ReleaseFrame();
// Generates the mipmap of the screen
_device.ImmediateContext.GenerateMips(_smallerTextureView);
// Copy the mipmap 1 of smallerTexture (size/2) to the staging texture
_device.ImmediateContext.CopySubresourceRegion(_smallerTexture, mipMapLevel, null, _stagingTexture, 0);
desktopResource.Dispose(); //perf?
return(true);
}
void OnResize()
{
Helpers.Dispose(ref depthBuffer);
Helpers.Dispose(ref dsv);
Helpers.Dispose(ref colorBuffer);
Helpers.Dispose(ref rtv);
var resolution = Surface.Resolution;
TextBatcher.Resolution = resolution;
UILineBatcher.Resolution = resolution;
var sampleDescription = new SampleDescription(4, 0);
depthBuffer = new Texture2D(Surface.Device, new Texture2DDescription
{
Format = Format.R32_Typeless,
ArraySize = 1,
MipLevels = 1,
Width = resolution.X,
Height = resolution.Y,
SampleDescription = sampleDescription,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
depthBuffer.DebugName = "Depth Buffer";
var depthStencilViewDescription = new DepthStencilViewDescription
{
Flags = DepthStencilViewFlags.None,
Dimension = DepthStencilViewDimension.Texture2DMultisampled,
Format = Format.D32_Float,
Texture2D = { MipSlice = 0 }
};
dsv = new DepthStencilView(Surface.Device, depthBuffer, depthStencilViewDescription);
dsv.DebugName = "Depth DSV";
//Using a 64 bit texture in the demos for lighting is pretty silly. But we gon do it.
var description = new Texture2DDescription
{
Format = Format.R16G16B16A16_Float,
ArraySize = 1,
MipLevels = 1,
Width = resolution.X,
Height = resolution.Y,
SampleDescription = sampleDescription,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
colorBuffer = new Texture2D(Surface.Device, description);
colorBuffer.DebugName = "Color Buffer";
rtv = new RenderTargetView(Surface.Device, colorBuffer);
rtv.DebugName = "Color RTV";
description.SampleDescription = new SampleDescription(1, 0);
resolvedColorBuffer = new Texture2D(Surface.Device, description);
resolvedColorBuffer.DebugName = "Resolved Color Buffer";
resolvedSRV = new ShaderResourceView(Surface.Device, resolvedColorBuffer);
resolvedSRV.DebugName = "Resolved Color SRV";
resolvedRTV = new RenderTargetView(Surface.Device, resolvedColorBuffer);
resolvedRTV.DebugName = "Resolved Color RTV";
}
public TextureAndSRV(Texture2D texture, ShaderResourceView srv)
{
Texture = texture;
SRV = srv;
}
public void ShutDown()
{
TextureResource?.Dispose();
TextureResource = null;
}
void CreateBuffers()
{
DisposeBuffers();
// New RenderTargetView from the backbuffer
using (var bb = Texture2D.FromSwapChain <Texture2D>(_swapChain, 0))
{
renderView = new RenderTargetView(Device, bb);
}
var gBufferDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
Width = _width,
Height = _height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
gBufferLight = new Texture2D(Device, gBufferDesc);
gBufferLightView = new RenderTargetView(Device, gBufferLight);
gBufferNormal = new Texture2D(Device, gBufferDesc);
gBufferNormalView = new RenderTargetView(Device, gBufferNormal);
gBufferDiffuse = new Texture2D(Device, gBufferDesc);
gBufferDiffuseView = new RenderTargetView(Device, gBufferDiffuse);
gBufferPostProcess = new Texture2D(Device, gBufferDesc);
gBufferPostProcessView = new RenderTargetView(Device, gBufferPostProcess);
if (depthOfFieldEnabled)
{
gBufferPostProcessBlur1 = new Texture2D(Device, gBufferDesc);
gBufferPostProcessViewBlur1 = new RenderTargetView(Device, gBufferPostProcessBlur1);
gBufferPostProcessBlur2 = new Texture2D(Device, gBufferDesc);
gBufferPostProcessViewBlur2 = new RenderTargetView(Device, gBufferPostProcessBlur2);
}
gBufferViews = new[] { gBufferNormalView, gBufferDiffuseView };
var gBufferResourceDesc = new ShaderResourceViewDescription
{
Format = Format.R8G8B8A8_UNorm,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource()
{
MipLevels = 1,
MostDetailedMip = 0
}
};
lightBufferRes = new ShaderResourceView(Device, gBufferLight, gBufferResourceDesc);
normalBufferRes = new ShaderResourceView(Device, gBufferNormal, gBufferResourceDesc);
diffuseBufferRes = new ShaderResourceView(Device, gBufferDiffuse, gBufferResourceDesc);
postProcessBufferRes = new ShaderResourceView(Device, gBufferPostProcess, gBufferResourceDesc);
if (depthOfFieldEnabled)
{
postProcessBufferBlur1Res = new ShaderResourceView(Device, gBufferPostProcessBlur1, gBufferResourceDesc);
postProcessBufferBlur2Res = new ShaderResourceView(Device, gBufferPostProcessBlur2, gBufferResourceDesc);
}
var depthDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R32_Typeless,
Height = _height,
Width = _width,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
var depthViewDesc = new DepthStencilViewDescription
{
Dimension = DepthStencilViewDimension.Texture2D,
Format = Format.D32_Float,
};
var resourceDesc = new ShaderResourceViewDescription
{
Format = Format.R32_Float,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource()
{
MipLevels = 1,
MostDetailedMip = 0
}
};
depthTexture = new Texture2D(Device, depthDesc);
depthView = new DepthStencilView(Device, depthTexture, depthViewDesc);
depthBufferRes = new ShaderResourceView(Device, depthTexture, resourceDesc);
lightDepthTexture = new Texture2D(Device, depthDesc);
lightDepthView = new DepthStencilView(Device, lightDepthTexture, depthViewDesc);
lightDepthRes = new ShaderResourceView(Device, lightDepthTexture, resourceDesc);
_immediateContext.Rasterizer.SetViewport(0, 0, _width, _height);
}
// Simple DDS loader ported from http://msdn.microsoft.com/en-us/library/windows/apps/jj651550.aspx
static void CreateD3DResources(
SharpDX.Direct3D11.Device d3dDevice,
TextureDimension resDim,
int width,
int height,
int depth,
int mipCount,
int arraySize,
Format format,
bool isCubeMap,
DataBox[] initData,
//_In_reads_(mipCount*arraySize) D3D11_SUBRESOURCE_DATA* initData,
out SharpDX.Direct3D11.Resource texture,
out SharpDX.Direct3D11.ShaderResourceView textureView
//_Out_opt_ ID3D11Resource** texture,
//_Out_opt_ ID3D11ShaderResourceView** textureView
)
{
texture = null;
textureView = null;
if (d3dDevice == null || initData == null)
{
return;
}
switch (resDim)
{
case TextureDimension.Texture1D: // D3D11_RESOURCE_DIMENSION_TEXTURE1D:
{
Texture1DDescription desc = new Texture1DDescription();
//D3D11_TEXTURE1D_DESC desc;
desc.Width = width;
desc.MipLevels = mipCount;
desc.ArraySize = arraySize;
desc.Format = format;
desc.Usage = ResourceUsage.Default;
desc.BindFlags = BindFlags.ShaderResource; // D3D11_BIND_SHADER_RESOURCE;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.OptionFlags = ResourceOptionFlags.None;
Texture1D tex = null;
//ID3D11Texture1D* tex = nullptr;
tex = new Texture1D(d3dDevice, desc, initData);
//hr = d3dDevice->CreateTexture1D(&desc, initData, &tex);
if (tex != null)
{
ShaderResourceViewDescription SRVDesc = new ShaderResourceViewDescription();
//D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
//memset(&SRVDesc, 0, sizeof(SRVDesc));
SRVDesc.Format = format;
if (arraySize > 1)
{
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture1DArray; // D3D_SRV_DIMENSION_TEXTURE1DARRAY;
SRVDesc.Texture1DArray.MipLevels = desc.MipLevels;
SRVDesc.Texture1DArray.ArraySize = arraySize;
}
else
{
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture1D;// D3D_SRV_DIMENSION_TEXTURE1D;
SRVDesc.Texture1D.MipLevels = desc.MipLevels;
}
textureView = new ShaderResourceView(d3dDevice, tex, SRVDesc);
//hr = d3dDevice->CreateShaderResourceView(tex, &SRVDesc, textureView);
if (textureView == null)
{
tex.Dispose();
return;
}
texture = tex;
}
}
break;
case TextureDimension.TextureCube:
case TextureDimension.Texture2D: // D3D11_RESOURCE_DIMENSION_TEXTURE2D:
{
Texture2DDescription desc = new Texture2DDescription();
desc.Width = width;
desc.Height = height;
desc.MipLevels = mipCount;
desc.ArraySize = arraySize;
desc.Format = format;
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
desc.Usage = ResourceUsage.Default;
desc.BindFlags = BindFlags.ShaderResource;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.OptionFlags = (isCubeMap) ? ResourceOptionFlags.TextureCube : ResourceOptionFlags.None;
Texture2D tex = null;
tex = new Texture2D(d3dDevice, desc, initData);
tex.DebugName = "Test";
//hr = d3dDevice->CreateTexture2D(&desc, initData, &tex);
if (tex != null)
{
ShaderResourceViewDescription SRVDesc = new ShaderResourceViewDescription();
SRVDesc.Format = format;
if (isCubeMap)
{
if (arraySize > 6)
{
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.TextureCubeArray;
SRVDesc.TextureCubeArray.MipLevels = desc.MipLevels;
// Earlier we set arraySize to (NumCubes * 6)
SRVDesc.TextureCubeArray.CubeCount = arraySize / 6;
}
else
{
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube;
SRVDesc.TextureCube.MipLevels = desc.MipLevels;
}
}
else if (arraySize > 1)
{
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DArray;
SRVDesc.Texture2DArray.MipLevels = desc.MipLevels;
SRVDesc.Texture2DArray.ArraySize = arraySize;
}
else
{
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
SRVDesc.Texture2D.MipLevels = desc.MipLevels;
}
textureView = new ShaderResourceView(d3dDevice, tex, SRVDesc);
//hr = d3dDevice->CreateShaderResourceView(tex, &SRVDesc, textureView);
texture = tex;
}
}
break;
case TextureDimension.Texture3D: {
Texture3DDescription desc = new Texture3DDescription();
desc.Width = width;
desc.Height = height;
desc.Depth = depth;
desc.MipLevels = mipCount;
desc.Format = format;
desc.Usage = ResourceUsage.Default;
desc.BindFlags = BindFlags.ShaderResource;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.OptionFlags = ResourceOptionFlags.None;
Texture3D tex = null;
tex = new Texture3D(d3dDevice, desc, initData);
//hr = d3dDevice->CreateTexture3D(&desc, initData, &tex);
if (tex != null)
{
ShaderResourceViewDescription SRVDesc = new ShaderResourceViewDescription();
SRVDesc.Format = format;
SRVDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture3D;
SRVDesc.Texture3D.MipLevels = desc.MipLevels;
textureView = new ShaderResourceView(d3dDevice, tex, SRVDesc);
texture = tex;
}
}
break;
}
}
private unsafe static Resource LoadDDSFromBuffer(Device device, byte[] buffer, out ShaderResourceView srv)
{
Resource result = null;
srv = null;
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
int size = buffer.Length;
// If buffer is allocated on Larget Object Heap, then we are going to pin it instead of making a copy.
if (size > (85 * 1024))
{
var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
DDSHelper.CreateDDSTextureFromMemory(device, handle.AddrOfPinnedObject(), size, out result, out srv);
}
fixed(void *pbuffer = buffer)
{
DDSHelper.CreateDDSTextureFromMemory(device, (IntPtr)pbuffer, size, out result, out srv);
}
return(result);
}
private bool SetShaderParameters(DeviceContext deviceContext, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, ShaderResourceView texture, Vector4 pixelColor)
{
try
{
DataStream mappedResource;
#region Matrix Constant Buffer
// Transpose the matrices to prepare them for shader.
worldMatrix.Transpose();
viewMatrix.Transpose();
projectionMatrix.Transpose();
// Lock the constant buffer so it can be written to.
deviceContext.MapSubresource(ConstantMatrixBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource);
// Copy the matrices into the constant buffer.
var matrixBuffer = new DMatrixBuffer()
{
world = worldMatrix,
view = viewMatrix,
projection = projectionMatrix
};
mappedResource.Write(matrixBuffer);
// Unlock the constant buffer.
deviceContext.UnmapSubresource(ConstantMatrixBuffer, 0);
// Set the position of the constant buffer in the vertex shader.
var bufferNumber = 0;
// Now set the constant buffer in the vertex shader with the updated values.
deviceContext.VertexShader.SetConstantBuffer(bufferNumber, ConstantMatrixBuffer);
// Set shader resource in the pixel shader.
deviceContext.PixelShader.SetShaderResource(0, texture);
#endregion
#region Pixel Constant Shader
// Lock the pixel constant buffer so it can be written to.
deviceContext.MapSubresource(ConstantPixelBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource);
// Copy the matrices into the constant buffer.
var pixelBuffer = new DPixelBuffer()
{
pixelColor = pixelColor
};
mappedResource.Write(pixelBuffer);
// Unlock the constant buffer.
deviceContext.UnmapSubresource(ConstantPixelBuffer, 0);
// Set the position of the constant buffer in the vertex shader.
bufferNumber = 0;
// Finally set the constant buffer in the vertex shader with the updated values.
deviceContext.PixelShader.SetConstantBuffer(bufferNumber, ConstantPixelBuffer);
#endregion
return(true);
}
catch (Exception)
{
return(false);
}
}
bool SetShaderParameters(DeviceContext deviceContext, Matrix world, Matrix view, Matrix projection, ShaderResourceView texture)
{
try {
var matrixBufferType = new MatrixBufferType {
World = Matrix.Transpose(world),
View = Matrix.Transpose(view),
Projection = Matrix.Transpose(projection)
};
deviceContext.UpdateSubresource(ref matrixBufferType, matrixBuffer);
deviceContext.VertexShader.SetConstantBuffer(0, matrixBuffer);
deviceContext.PixelShader.SetShaderResource(0, texture);
} catch { return(false); }
return(true);
}
public void Dilate(MultiUvTextureMask mask, Size2 size, bool isLinear, DataBox imageData)
{
//set every alpha value to 0
for (int i = 0; i < imageData.SlicePitch; i += 4)
{
var rgba = Utilities.Read <uint>(imageData.DataPointer + i);
rgba &= 0xffffff;
Utilities.Write <uint>(imageData.DataPointer + i, ref rgba);
}
var sourceTextureDesc = new Texture2DDescription {
Width = size.Width,
Height = size.Height,
MipLevels = 0,
ArraySize = 1,
Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget | BindFlags.UnorderedAccess,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
var sourceTexture = new Texture2D(device, sourceTextureDesc);
var sourceTextureInView = new ShaderResourceView(device, sourceTexture);
var sourceTextureOutView = new UnorderedAccessView(device, sourceTexture);
var destTextureDesc = new Texture2DDescription {
Width = size.Width,
Height = size.Height,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.UnorderedAccess
};
var destTexture = new Texture2D(device, destTextureDesc);
var destTextureOutView = new UnorderedAccessView(device, destTexture);
var stagingTextureDesc = new Texture2DDescription {
Width = size.Width,
Height = size.Height,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Staging,
CpuAccessFlags = CpuAccessFlags.Read
};
var stagingTexture = new Texture2D(device, stagingTextureDesc);
var context = device.ImmediateContext;
context.UpdateSubresource(imageData, sourceTexture, 0);
foreach (var perUvMask in mask.PerUvMasks)
{
maskRenderer.RenderMaskToAlpha(perUvMask, size, sourceTexture);
}
context.ClearState();
context.ComputeShader.Set(alphaPremultiplerShader);
context.ComputeShader.SetUnorderedAccessView(0, sourceTextureOutView);
context.Dispatch(
IntegerUtils.RoundUp(size.Width, ShaderNumThreadsPerDim),
IntegerUtils.RoundUp(size.Height, ShaderNumThreadsPerDim),
1);
context.ClearState();
context.GenerateMips(sourceTextureInView);
context.ClearState();
context.ComputeShader.Set(dilatorShader);
context.ComputeShader.SetShaderResources(0, sourceTextureInView);
context.ComputeShader.SetUnorderedAccessView(0, destTextureOutView);
context.Dispatch(
IntegerUtils.RoundUp(size.Width, ShaderNumThreadsPerDim),
IntegerUtils.RoundUp(size.Height, ShaderNumThreadsPerDim),
1);
context.ClearState();
context.CopyResource(destTexture, stagingTexture);
var resultImageData = context.MapSubresource(stagingTexture, 0, MapMode.Read, MapFlags.None);
CopyDataBox(resultImageData, imageData);
context.UnmapSubresource(stagingTexture, 0);
stagingTexture.Dispose();
destTexture.Dispose();
destTextureOutView.Dispose();
sourceTexture.Dispose();
sourceTextureInView.Dispose();
sourceTextureOutView.Dispose();
}
public bool RenderFontShader(DeviceContext deviceContext, int indexCount, Matrix worldMatrix, Matrix viewMatrix, Matrix orthoMatrix, ShaderResourceView texture, Vector4 fontColour)
{
// Render the FontShader.
if (!FontShader.Render(deviceContext, indexCount, worldMatrix, viewMatrix, orthoMatrix, texture, fontColour))
{
return(false);
}
return(true);
}
public ShaderResourceView CreateTexArray(string arrayName, params string[] filenames)
{
if (_textures.ContainsKey(arrayName))
{
return(_textures[arrayName]);
}
//
// Load the texture elements individually from file. These textures
// won't be used by the GPU (0 bind flags), they are just used to
// load the image data from file. We use the STAGING usage so the
// CPU can read the resource.
//
int arraySize = filenames.Length;
var srcTex = new Texture2D[arraySize];
for (int i = 0; i < arraySize; ++i)
{
var loadInfo = new ImageLoadInformation
{
Usage = ResourceUsage.Staging,
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Read | CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
Format = Format.R8G8B8A8_UNorm,
FilterFlags = FilterFlags.None,
MipFilterFlags = FilterFlags.None
};
srcTex[i] = Texture2D.FromFile(_dxDevice, filenames[i], loadInfo);
}
//
// Create the texture array. Each element in the texture
// array has the same format/dimensions.
//
var texElementDesc = srcTex[0].Description;
var texArrayDesc = new Texture2DDescription
{
Width = texElementDesc.Width,
Height = texElementDesc.Height,
MipLevels = texElementDesc.MipLevels,
ArraySize = arraySize,
Format = Format.R8G8B8A8_UNorm,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
var texArray = new Texture2D(_dxDevice, texArrayDesc);
//
// Copy individual texture elements into texture array.
//
// for each texture element...
for (int i = 0; i < arraySize; ++i)
{
// for each mipmap level...
for (int j = 0; j < texElementDesc.MipLevels; ++j)
{
var mappedTex2D = srcTex[i].Map(j, MapMode.Read, MapFlags.None);
_dxDevice.UpdateSubresource(
new DataBox(mappedTex2D.Pitch, 0, mappedTex2D.Data), texArray,
Resource.CalculateSubresourceIndex(j, i, texElementDesc.MipLevels));
srcTex[i].Unmap(j);
}
}
//
// Create a resource view to the texture array.
//
var viewDesc = new ShaderResourceViewDescription();
viewDesc.Format = texArrayDesc.Format;
viewDesc.Dimension = ShaderResourceViewDimension.Texture2DArray;
viewDesc.MostDetailedMip = 0;
viewDesc.MipLevels = texArrayDesc.MipLevels;
viewDesc.FirstArraySlice = 0;
viewDesc.ArraySize = arraySize;
var texArrayRV = new ShaderResourceView(_dxDevice, texArray, viewDesc);
//
// Cleanup--we only need the resource view.
//
texArray.Dispose();
for (int i = 0; i < arraySize; ++i)
{
srcTex[i].Dispose();
}
_textures.Add(arrayName, texArrayRV);
return(texArrayRV);
}
public void TestFog()
{
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var desc = new Texture2DDescription
{
BindFlags =
BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.R16G16B16A16_Float,
Width = 800,
Height = 600,
ArraySize = 1,
SampleDescription = new SampleDescription(1, 0),
MipLevels = 1,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
var hdrImage = new Texture2D(device, desc);
var hdrImageRTV = new RenderTargetView(device, hdrImage);
var hdrImageRV = new ShaderResourceView(device, hdrImage);
var desc2 = new Texture2DDescription
{
BindFlags =
BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.R8G8B8A8_UNorm,
Width = 800,
Height = 600,
ArraySize = 1,
SampleDescription = new SampleDescription(1, 0),
MipLevels = 1,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
var toneMappedImage = new Texture2D(device, desc2);
var toneMappedImageRTV = new RenderTargetView(device, toneMappedImage);
var toneMappedImageRV = new ShaderResourceView(device, toneMappedImage);
var foggedImage = new Texture2D(device, desc2);
var foggedImageRTV = new RenderTargetView(device, foggedImage);
var foggedImageRV = new ShaderResourceView(device, foggedImage);
var calculater = new AverageLuminanceCalculater(game, hdrImageRV);
var toneMap = new ToneMapRenderer(game);
var combineFinal = new TestCombineFinalClass(game);
var fogRenderer = new FogEffect(game);
game.GameLoopEvent += delegate
{
combineFinal.DrawUpdatedDeferredRendering();
if (game.Keyboard.IsKeyDown(Key.I))
{
return;
}
context.Rasterizer.SetViewports(new Viewport(0, 0, 800, 600));
context.OutputMerger.SetTargets(hdrImageRTV);
combineFinal.DrawCombined();
calculater.DrawUpdatedLogLuminance();
calculater.DrawUpdatedAdaptedLogLuminance();
context.ClearState();
game.SetBackbuffer();
context.OutputMerger.SetTargets(toneMappedImageRTV);
if (game.Keyboard.IsKeyDown(Key.K))
{
game.TextureRenderer.Draw(calculater.AverageLuminanceRV, new Vector2(10, 10),
new Vector2(300, 300));
game.TextureRenderer.Draw(hdrImageRV, new Vector2(320, 10),
new Vector2(300, 300));
game.TextureRenderer.Draw(calculater.CurrAverageLumRV, new Vector2(10, 320),
new Vector2(270, 270));
}
else
{
toneMap.DrawTonemapped(hdrImageRV, calculater.CurrAverageLumRV);
}
context.ClearState();
game.SetBackbuffer();
fogRenderer.PostProcessFog(toneMappedImageRV, combineFinal.FilledGBuffer.GBuffer, foggedImageRTV);
context.ClearState();
game.SetBackbuffer();
//context.ClearRenderTargetView(foggedImageRTV, new Color4(1, 1, 0));
game.TextureRenderer.Draw(foggedImageRV, new Vector2(0, 0), new Vector2(800, 600));
};
game.Run();
}
public void DrawSqrt(DeviceContextHolder holder, ShaderResourceView view, RenderTargetView target) {
holder.DeviceContext.OutputMerger.SetTargets(target);
holder.PrepareQuad(_effect.LayoutPT);
_effect.FxInputMap.SetResource(view);
_effect.TechCopySqrt.DrawAllPasses(holder.DeviceContext, 6);
}
public override void 数を更新する(EffectVariable 数, 数更新時引数 引数)
{
// 深度ステンシルビューを取得する。
RenderContext.Instance.DeviceManager.D3DDeviceContext.OutputMerger.GetRenderTargets(out var depthStencilView);
using (depthStencilView)
using (var depthStencilBuffer = depthStencilView.ResourceAs <Texture2D>())
{
#region " 未作成または深度ステンシルバッファといろいろ異なっている場合、Texture2D と ShaderResourceView を作成する。"
//----------------
if (null == _Texture2D ||
null == _ShaderResourceView ||
depthStencilBuffer.Description.Width != _Texture2D.Description.Width ||
depthStencilBuffer.Description.Height != _Texture2D.Description.Height ||
depthStencilBuffer.Description.Format != _Texture2D.Description.Format)
{
数.AsShaderResource().SetResource(null);
_ShaderResourceView?.Dispose();
_Texture2D?.Dispose();
// 深度ステンシルバッファと同じサイズ・同じフォーマットのテクスチャを作成する。
_Texture2D = new Texture2D(
RenderContext.Instance.DeviceManager.D3DDevice,
new Texture2DDescription {
ArraySize = 1,
BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None, // CPUからアクセス不要
Format = SharpDX.DXGI.Format.R32_Typeless,
Width = depthStencilBuffer.Description.Width,
Height = depthStencilBuffer.Description.Height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Default,
});
// テクスチャのシェーダーリソースビューを作成する。
_ShaderResourceView = new ShaderResourceView(
RenderContext.Instance.DeviceManager.D3DDevice,
_Texture2D,
new ShaderResourceViewDescription {
Format = SharpDX.DXGI.Format.R32_Float,
Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource {
MipLevels = 1,
MostDetailedMip = 0,
},
});
// シェーダーリソースビューを変数に設定する。
数.AsShaderResource().SetResource(_ShaderResourceView);
}
//----------------
#endregion
// 深度ステンシルバッファの内容を Texture2D に複写する。
RenderContext.Instance.DeviceManager.D3DDeviceContext.CopyResource(depthStencilBuffer, _Texture2D);
}
}
private bool SetShaderParameters(DeviceContext deviceContext, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, ShaderResourceView texture, Vector3 lightDirection, Vector4 diffuseColor)
{
try
{
// Transpose the matrices to prepare them for shader.
worldMatrix.Transpose();
viewMatrix.Transpose();
projectionMatrix.Transpose();
// Lock the matrix constant buffer so it can be written to.
DataStream mappedResource;
deviceContext.MapSubresource(ConstantMatrixBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource);
// Copy the matrices into the constant buffer.
var matrixBuffer = new MatrixBuffer()
{
world = worldMatrix,
view = viewMatrix,
projection = projectionMatrix
};
mappedResource.Write(matrixBuffer);
// Unlock the constant buffer.
deviceContext.UnmapSubresource(ConstantMatrixBuffer, 0);
// Set the position of the constant buffer in the vertex shader.
var bufferNumber = 0;
// Finally set the constant buffer in the vertex shader with the updated values.
deviceContext.VertexShader.SetConstantBuffer(bufferNumber, ConstantMatrixBuffer);
// Set shader resource in the pixel shader.
deviceContext.PixelShader.SetShaderResource(0, texture);
// Lock the light constant buffer so it can be written to.
deviceContext.MapSubresource(ConstantLightBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource);
// Copy the lighting variables into the constant buffer.
var lightBuffer = new LightBuffer()
{
diffuseColor = diffuseColor,
lightDirection = lightDirection,
padding = 0
};
mappedResource.Write(lightBuffer);
// Unlock the constant buffer.
deviceContext.UnmapSubresource(ConstantLightBuffer, 0);
// Set the position of the light constant buffer in the pixel shader.
bufferNumber = 0;
// Finally set the light constant buffer in the pixel shader with the updated values.
deviceContext.PixelShader.SetConstantBuffer(bufferNumber, ConstantLightBuffer);
return(true);
}
catch (Exception)
{
return(false);
}
}
public bool Render(DeviceContext deviceContext, int indexCount, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, ShaderResourceView texture, Vector3 lightDirection, Vector4 diffuseColor)
{
// Set the shader parameters that it will use for rendering.
if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, diffuseColor))
{
return(false);
}
// Now render the prepared buffers with the shader.
RenderShader(deviceContext, indexCount);
return(true);
}
// encapsulates d3d resources for a camera
public CameraDeviceResource(SharpDX.Direct3D11.Device device, ProjectorCameraEnsemble.Camera camera, Object renderLock, string directory)
{
this.device = device;
this.camera = camera;
this.renderLock = renderLock;
// Kinect depth image
var depthImageTextureDesc = new Texture2DDescription()
{
Width = Kinect2Calibration.depthImageWidth,
Height = Kinect2Calibration.depthImageHeight,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.R16_UInt,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.Write,
};
depthImageTexture = new Texture2D(device, depthImageTextureDesc);
depthImageTextureRV = new ShaderResourceView(device, depthImageTexture);
var floatDepthImageTextureDesc = new Texture2DDescription()
{
Width = Kinect2Calibration.depthImageWidth,
Height = Kinect2Calibration.depthImageHeight,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.R32_Float,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
};
floatDepthImageTexture = new Texture2D(device, floatDepthImageTextureDesc);
floatDepthImageRV = new ShaderResourceView(device, floatDepthImageTexture);
floatDepthImageRenderTargetView = new RenderTargetView(device, floatDepthImageTexture);
floatDepthImageTexture2 = new Texture2D(device, floatDepthImageTextureDesc);
floatDepthImageRV2 = new ShaderResourceView(device, floatDepthImageTexture2);
floatDepthImageRenderTargetView2 = new RenderTargetView(device, floatDepthImageTexture2);
// Kinect color image
var colorImageStagingTextureDesc = new Texture2DDescription()
{
Width = Kinect2Calibration.colorImageWidth,
Height = Kinect2Calibration.colorImageHeight,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.Write
};
colorImageStagingTexture = new Texture2D(device, colorImageStagingTextureDesc);
var colorImageTextureDesc = new Texture2DDescription()
{
Width = Kinect2Calibration.colorImageWidth,
Height = Kinect2Calibration.colorImageHeight,
MipLevels = 0,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
colorImageTexture = new Texture2D(device, colorImageTextureDesc);
colorImageTextureRV = new ShaderResourceView(device, colorImageTexture);
// vertex buffer
var table = camera.calibration.ComputeDepthFrameToCameraSpaceTable();
int numVertices = 6 * (Kinect2Calibration.depthImageWidth - 1) * (Kinect2Calibration.depthImageHeight - 1);
var vertices = new VertexPosition[numVertices];
Int3[] quadOffsets = new Int3[]
{
new Int3(0, 0, 0),
new Int3(1, 0, 0),
new Int3(0, 1, 0),
new Int3(1, 0, 0),
new Int3(1, 1, 0),
new Int3(0, 1, 0),
};
int vertexIndex = 0;
for (int y = 0; y < Kinect2Calibration.depthImageHeight - 1; y++)
{
for (int x = 0; x < Kinect2Calibration.depthImageWidth - 1; x++)
{
for (int i = 0; i < 6; i++)
{
int vertexX = x + quadOffsets[i].X;
int vertexY = y + quadOffsets[i].Y;
var point = table[Kinect2Calibration.depthImageWidth * vertexY + vertexX];
var vertex = new VertexPosition();
vertex.position = new SharpDX.Vector4(point.X, point.Y, vertexX, vertexY);
vertices[vertexIndex++] = vertex;
}
}
}
var stream = new DataStream(numVertices * VertexPosition.SizeInBytes, true, true);
stream.WriteRange(vertices);
stream.Position = 0;
var vertexBufferDesc = new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
Usage = ResourceUsage.Default,
SizeInBytes = numVertices * VertexPosition.SizeInBytes,
};
vertexBuffer = new SharpDX.Direct3D11.Buffer(device, stream, vertexBufferDesc);
vertexBufferBinding = new VertexBufferBinding(vertexBuffer, VertexPosition.SizeInBytes, 0);
stream.Dispose();
var colorImage = new RoomAliveToolkit.ARGBImage(Kinect2Calibration.colorImageWidth, Kinect2Calibration.colorImageHeight);
ProjectorCameraEnsemble.LoadFromTiff(imagingFactory, colorImage, directory + "/camera" + camera.name + "/color.tiff");
var depthImage = new RoomAliveToolkit.ShortImage(Kinect2Calibration.depthImageWidth, Kinect2Calibration.depthImageHeight);
ProjectorCameraEnsemble.LoadFromTiff(imagingFactory, depthImage, directory + "/camera" + camera.name + "/mean.tiff");
lock (renderLock) // necessary?
{
UpdateColorImage(device.ImmediateContext, colorImage.DataIntPtr);
UpdateDepthImage(device.ImmediateContext, depthImage.DataIntPtr);
}
colorImage.Dispose();
depthImage.Dispose();
}
