/// <summary>
/// Creates texture
/// </summary>
/// <param name="device"></param>
public TextureCube(GraphicsDevice device, int size, ColorFormat format, bool mips, bool srgb = false) : base(device)
{
this.Width = size;
this.Depth = 1;
this.Height = size;
this.format = format;
this.mipCount = mips ? ShaderResource.CalculateMipLevels(Width, Height) : 1;
//Log.Warning("CHECK ARRAY SIZE!");
var texDesc = new Texture2DDescription();
texDesc.ArraySize = 6;
texDesc.BindFlags = BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = MakeTypeless(Converter.Convert(format));
texDesc.Height = Height;
texDesc.MipLevels = mipCount;
texDesc.OptionFlags = ResourceOptionFlags.TextureCube;
texDesc.SampleDescription.Count = 1;
texDesc.SampleDescription.Quality = 0;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = Width;
texCube = new D3D.Texture2D(device.Device, texDesc);
SRV = new ShaderResourceView(device.Device, texCube);
}
/// <summary>
/// Creates texture
/// </summary>
/// <param name="device"></param>
public VolumeRWTexture(GraphicsDevice device, int width, int height, int depth, ColorFormat format, bool mips) : base(device)
{
this.Width = width;
this.Height = height;
this.Depth = depth;
this.format = format;
this.mipCount = mips ? ShaderResource.CalculateMipLevels(Width, Height, Depth) : 1;
var texDesc = new Texture3DDescription();
texDesc.BindFlags = BindFlags.ShaderResource | BindFlags.UnorderedAccess;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = Converter.Convert(format);
texDesc.Height = Height;
texDesc.MipLevels = mipCount;
texDesc.OptionFlags = ResourceOptionFlags.None;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = Width;
texDesc.Depth = Depth;
var uavDesc = new UnorderedAccessViewDescription();
uavDesc.Format = Converter.Convert(format);
uavDesc.Dimension = UnorderedAccessViewDimension.Texture3D;
uavDesc.Texture3D.FirstWSlice = 0;
uavDesc.Texture3D.MipSlice = 0;
uavDesc.Texture3D.WSize = depth;
tex3D = new D3D.Texture3D(device.Device, texDesc);
SRV = new D3D.ShaderResourceView(device.Device, tex3D);
uav = new UnorderedAccessView(device.Device, tex3D, uavDesc);
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
/// <param name="size"></param>
/// <param name="count"></param>
/// <param name="format"></param>
/// <param name="mips"></param>
public TextureCubeArray(GraphicsDevice device, int size, int count, ColorFormat format, bool mips) : base(device)
{
if (count > 2048 / 6)
{
throw new GraphicsException("Too much elements in texture array");
}
this.Width = size;
this.Depth = 1;
this.Height = size;
this.MipCount = mips ? ShaderResource.CalculateMipLevels(Width, Height) : 1;
var texDesc = new Texture2DDescription();
texDesc.ArraySize = 6 * count;
texDesc.BindFlags = BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = MakeTypeless(Converter.Convert(format));
texDesc.Height = Height;
texDesc.MipLevels = 0;
texDesc.OptionFlags = ResourceOptionFlags.TextureCube;
texDesc.SampleDescription.Count = 1;
texDesc.SampleDescription.Quality = 0;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = Width;
texCubeArray = new D3D.Texture2D(device.Device, texDesc);
SRV = new ShaderResourceView(device.Device, texCubeArray);
}
/// <summary>
/// Creates texture
/// </summary>
/// <param name="device"></param>
public Texture2D(GraphicsDevice device, int width, int height, ColorFormat format, bool mips, bool srgb = false) : base(device)
{
this.Width = width;
this.Height = height;
this.Depth = 1;
this.format = format;
this.mipCount = mips ? ShaderResource.CalculateMipLevels(Width, Height) : 1;
var texDesc = new Texture2DDescription();
texDesc.ArraySize = 1;
texDesc.BindFlags = BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = srgb ? MakeSRgb(Converter.Convert(format)) : Converter.Convert(format);
texDesc.Height = Height;
texDesc.MipLevels = mipCount;
texDesc.OptionFlags = ResourceOptionFlags.None;
texDesc.SampleDescription.Count = 1;
texDesc.SampleDescription.Quality = 0;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = Width;
lock (device.DeviceContext) {
tex2D = new D3D.Texture2D(device.Device, texDesc);
SRV = new ShaderResourceView(device.Device, tex2D);
}
}
/// <summary>
/// Creates texture
/// </summary>
/// <param name="device"></param>
public Texture3D(GraphicsDevice device, int width, int height, int depth, ColorFormat format, bool mips, bool srgb = false) : base(device)
{
this.Width = width;
this.Height = height;
this.Depth = depth;
this.format = format;
this.mipCount = mips ? ShaderResource.CalculateMipLevels(Width, Height, Depth) : 1;
var texDesc = new Texture3DDescription();
texDesc.BindFlags = BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = Converter.Convert(format);
texDesc.Height = Height;
texDesc.MipLevels = mipCount;
texDesc.OptionFlags = ResourceOptionFlags.None;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = Width;
texDesc.Depth = Depth;
tex3D = new D3D.Texture3D(device.Device, texDesc);
SRV = new D3D.ShaderResourceView(device.Device, tex3D);
}
/// <summary>
///
/// </summary>
/// <param name="dst">target to copy to</param>
/// <param name="src">target to copy from</param>
public void Copy( RenderTargetSurface dst, ShaderResource src )
{
SetDefaultRenderStates();
using( new PixEvent("Copy") ) {
if(dst == null) {
rs.RestoreBackbuffer();
} else {
SetViewport(dst);
rs.SetTargets( null, dst );
}
rs.PipelineState = factory[ (int)ShaderFlags.COPY ];
rs.PixelShaderResources[0] = src;
rs.Draw( 3, 0 );
}
rs.ResetStates();
}
public void LinearizeDepth( RenderTargetSurface dst, ShaderResource src )
{
throw new NotImplementedException();
#if false
Debug.Assert( Game.IsServiceExist<Camera>() );
var camera = Game.GetService<Camera>();
bufLinearizeDepth.Data.linearizeDepthA = 1.0f / camera.FrustumZFar - 1.0f / camera.FrustumZNear;
bufLinearizeDepth.Data.linearizeDepthB = 1.0f / camera.FrustumZNear;
bufLinearizeDepth.UpdateCBuffer();
var isDepthMSAA = ( src.SampleCount > 1 );
var depthShader = (int)( isDepthMSAA ? ShaderFlags.RESOLVE_AND_LINEARIZE_DEPTH_MSAA : ShaderFlags.LINEARIZE_DEPTH );
string signature;
SetDefaultRenderStates();
using( new PixEvent() ) {
bufLinearizeDepth.SetCBufferPS( 0 );
shaders.SetPixelShader( depthShader );
shaders.SetVertexShader( depthShader );
dst.SetViewport();
rs.SetRenderTargets( dst );
src.SetPS( 0 );
rs.Draw( Primitive.TriangleList, 3, 0 );
}
rs.ResetStates();
#endif
}
/*-----------------------------------------------------------------------------------------------
*
* Base filters
*
-----------------------------------------------------------------------------------------------*/
/// <summary>
/// Performs good-old StretchRect to destination buffer with blending.
/// </summary>
/// <param name="dst"></param>
/// <param name="src"></param>
/// <param name="filter"></param>
/// <param name="rect"></param>
public void StretchRect( RenderTargetSurface dst, ShaderResource src, SamplerState filter = null, bool flipToCubeFace = false )
{
SetDefaultRenderStates();
using( new PixEvent("StretchRect") ) {
SetViewport(dst);
rs.SetTargets( null, dst );
if (flipToCubeFace) {
rs.PipelineState = factory[ (int)(ShaderFlags.STRETCH_RECT|ShaderFlags.TO_CUBE_FACE) ];
} else {
rs.PipelineState = factory[ (int)ShaderFlags.STRETCH_RECT ];
}
rs.VertexShaderResources[0] = src;
rs.PixelShaderResources[0] = src;
rs.PixelShaderSamplers[0] = filter ?? SamplerState.LinearPointClamp;
rs.VertexShaderConstants[0] = sourceRectCB;
rs.Draw( 3, 0 );
}
rs.ResetStates();
}
/// <summary>
/// Creates render target
/// </summary>
/// <param name="?"></param>
/// <param name="format"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="samples"></param>
/// <param name="mips"></param>
/// <param name="debugName"></param>
void Create(ColorFormat format, int size, int samples, bool mips, string debugName)
{
bool msaa = samples > 1;
CheckSamplesCount(samples);
if (mips && samples > 1)
{
throw new ArgumentException("Render target should be multisampler either mipmapped");
}
SampleCount = samples;
Format = format;
SampleCount = samples;
Width = size;
Height = size;
Depth = 1;
MipCount = mips ? ShaderResource.CalculateMipLevels(Width, Height) : 1;
var texDesc = new Texture2DDescription();
texDesc.Width = Width;
texDesc.Height = Height;
texDesc.ArraySize = 6;
texDesc.BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = Converter.Convert(format);
texDesc.MipLevels = mips ? MipCount : 1;
texDesc.OptionFlags = ResourceOptionFlags.TextureCube | (mips ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None);
texDesc.SampleDescription = new DXGI.SampleDescription(samples, 0);
texDesc.Usage = ResourceUsage.Default;
texCube = new D3D.Texture2D(device.Device, texDesc);
SRV = new ShaderResourceView(device.Device, texCube);
texDesc.BindFlags = BindFlags.None;
texDesc.CpuAccessFlags = CpuAccessFlags.Write | CpuAccessFlags.Read;
texDesc.Usage = ResourceUsage.Staging;
texDesc.OptionFlags = ResourceOptionFlags.TextureCube;
staging = new D3D.Texture2D(device.Device, texDesc);
//
// Top mipmap level :
//
cubeMipShaderResources = new ShaderResource[MipCount];
for (int mip = 0; mip < MipCount; mip++)
{
var srvDesc = new ShaderResourceViewDescription();
srvDesc.TextureCube.MipLevels = 1;
srvDesc.TextureCube.MostDetailedMip = mip;
srvDesc.Format = Converter.Convert(format);
srvDesc.Dimension = ShaderResourceViewDimension.TextureCube;
cubeMipShaderResources[mip] = new ShaderResource(device, new ShaderResourceView(device.Device, texCube, srvDesc), size >> mip, size >> mip, 1);
}
//
// Create surfaces :
//
surfaces = new RenderTargetSurface[MipCount, 6];
for (int mip = 0; mip < MipCount; mip++)
{
int width = GetMipSize(Width, mip);
int height = GetMipSize(Height, mip);
for (int face = 0; face < 6; face++)
{
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Texture2DArray.MipSlice = mip;
rtvDesc.Texture2DArray.FirstArraySlice = face;
rtvDesc.Texture2DArray.ArraySize = 1;
rtvDesc.Dimension = msaa ? RenderTargetViewDimension.Texture2DMultisampledArray : RenderTargetViewDimension.Texture2DArray;
rtvDesc.Format = Converter.Convert(format);
var rtv = new RenderTargetView(device.Device, texCube, rtvDesc);
int subResId = Resource.CalculateSubResourceIndex(mip, face, MipCount);
surfaces[mip, face] = new RenderTargetSurface(rtv, null, texCube, subResId, format, Width, Height, samples);
GraphicsDevice.Clear(surfaces[mip, face], Color4.Zero);
}
}
}
/// <summary>
/// Performs luminance measurement, tonemapping, applies bloom.
/// </summary>
/// <param name="target">LDR target.</param>
/// <param name="hdrImage">HDR source image.</param>
public void Render ( GameTime gameTime, RenderTargetSurface target, ShaderResource hdrImage, RenderWorld viewLayer )
{
var device = Game.GraphicsDevice;
var filter = Game.RenderSystem.Filter;
var settings = viewLayer.HdrSettings;
//
// Rough downsampling of source HDR-image :
//
filter.StretchRect( averageLum.Surface, hdrImage, SamplerState.PointClamp );
averageLum.BuildMipmaps();
//
// Make bloom :
//
filter.StretchRect( viewLayer.Bloom0.Surface, hdrImage, SamplerState.LinearClamp );
viewLayer.Bloom0.BuildMipmaps();
filter.GaussBlur( viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 0 );
filter.GaussBlur( viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 1 );
filter.GaussBlur( viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 2 );
filter.GaussBlur( viewLayer.Bloom0, viewLayer.Bloom1, settings.GaussBlurSigma, 3 );
//
// Setup parameters :
//
var paramsData = new Params();
paramsData.AdaptationRate = 1 - (float)Math.Pow( 0.5f, gameTime.ElapsedSec / settings.AdaptationHalfLife );
paramsData.LuminanceLowBound = settings.LuminanceLowBound;
paramsData.LuminanceHighBound = settings.LuminanceHighBound;
paramsData.KeyValue = settings.KeyValue;
paramsData.BloomAmount = settings.BloomAmount;
paramsData.DirtMaskLerpFactor = settings.DirtMaskLerpFactor;
paramsData.DirtAmount = settings.DirtAmount;
paramsCB.SetData( paramsData );
device.PixelShaderConstants[0] = paramsCB;
//
// Measure and adapt :
//
device.SetTargets( null, viewLayer.MeasuredNew );
device.PixelShaderResources[0] = averageLum;
device.PixelShaderResources[1] = viewLayer.MeasuredOld;
device.PipelineState = factory[ (int)(Flags.MEASURE_ADAPT) ];
device.Draw( 3, 0 );
//
// Tonemap and compose :
//
device.SetTargets( null, target );
device.PixelShaderResources[0] = hdrImage;// averageLum;
device.PixelShaderResources[1] = viewLayer.MeasuredNew;// averageLum;
device.PixelShaderResources[2] = viewLayer.Bloom0;// averageLum;
device.PixelShaderResources[3] = settings.DirtMask1==null ? whiteTex.Srv : settings.DirtMask1.Srv;
device.PixelShaderResources[4] = settings.DirtMask2==null ? whiteTex.Srv : settings.DirtMask2.Srv;
device.PixelShaderSamplers[0] = SamplerState.LinearClamp;
Flags op = Flags.LINEAR;
if (settings.TonemappingOperator==TonemappingOperator.Filmic) { op = Flags.FILMIC; }
if (settings.TonemappingOperator==TonemappingOperator.Linear) { op = Flags.LINEAR; }
if (settings.TonemappingOperator==TonemappingOperator.Reinhard) { op = Flags.REINHARD; }
device.PipelineState = factory[ (int)(Flags.TONEMAPPING|op) ];
device.Draw( 3, 0 );
device.ResetStates();
// swap luminanice buffers :
Misc.Swap( ref viewLayer.MeasuredNew, ref viewLayer.MeasuredOld );
}
/// <summary>
///
/// </summary>
/// <param name="srcDst"></param>
/// <param name="temporary"></param>
/// <param name="?"></param>
/// <param name="depthData"></param>
/// <param name="normalData"></param>
/// <param name="sigma"></param>
/// <param name="mipLevel"></param>
public void GaussBlurBilateral ( RenderTarget2D srcDst, RenderTarget2D temporary, ShaderResource depthData, ShaderResource normalData, float sigma, float sharpness, int mipLevel )
{
GaussBlurInternal( srcDst, temporary, sigma, sharpness, mipLevel, depthData, normalData );
}
/// <summary>
/// Creates render target
/// </summary>
/// <param name="?"></param>
/// <param name="format"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="samples"></param>
/// <param name="mips"></param>
/// <param name="debugName"></param>
void Create(ColorFormat format, int width, int height, int samples, int mips, bool enableRWBuffer)
{
//Log.Debug("RenderTarget2D: f:{0} w:{1} h:{2} s:{3}{4}{5}", format, width, height, samples, mips?" mips":"", enableRWBuffer?" uav":"" );
bool msaa = samples > 1;
CheckSamplesCount(samples);
if (mips != 1 && samples > 1)
{
throw new ArgumentException("Render target should be multisampler either mipmapped");
}
SampleCount = samples;
Format = format;
SampleCount = samples;
Width = width;
Height = height;
Depth = 1;
MipCount = mips == 0 ? ShaderResource.CalculateMipLevels(width, height) : mips;
var texDesc = new Texture2DDescription();
texDesc.Width = width;
texDesc.Height = height;
texDesc.ArraySize = 1;
texDesc.BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = Converter.Convert(format);
texDesc.MipLevels = MipCount;
texDesc.OptionFlags = (mips != 1) ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None;
texDesc.SampleDescription = new DXGI.SampleDescription(samples, 0);
texDesc.Usage = ResourceUsage.Default;
if (enableRWBuffer)
{
texDesc.BindFlags |= BindFlags.UnorderedAccess;
}
tex2D = new D3D.Texture2D(device.Device, texDesc);
SRV = new ShaderResourceView(device.Device, tex2D);
//
// Create surfaces :
//
surfaces = new RenderTargetSurface[MipCount];
for (int i = 0; i < MipCount; i++)
{
width = GetMipSize(Width, i);
height = GetMipSize(Height, i);
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Texture2D.MipSlice = i;
rtvDesc.Dimension = msaa ? RenderTargetViewDimension.Texture2DMultisampled : RenderTargetViewDimension.Texture2D;
rtvDesc.Format = Converter.Convert(format);
var rtv = new RenderTargetView(device.Device, tex2D, rtvDesc);
UnorderedAccessView uav = null;
if (enableRWBuffer)
{
var uavDesc = new UnorderedAccessViewDescription();
uavDesc.Buffer.ElementCount = width * height;
uavDesc.Buffer.FirstElement = 0;
uavDesc.Buffer.Flags = UnorderedAccessViewBufferFlags.None;
uavDesc.Dimension = UnorderedAccessViewDimension.Texture2D;
uavDesc.Format = Converter.Convert(format);
uavDesc.Texture2D.MipSlice = i;
uav = new UnorderedAccessView(device.Device, tex2D, uavDesc);
}
surfaces[i] = new RenderTargetSurface(rtv, uav, tex2D, i, format, width, height, samples);
}
}
/// <summary>
///
/// </summary>
void RenderGeneric ( string passName, GameTime gameTime, Camera camera, Viewport viewport, Matrix view, Matrix projection, RenderTargetSurface colorTarget, DepthStencilSurface depthTarget, ShaderResource depthValues, Flags flags )
{
var device = Game.GraphicsDevice;
if (rs.SkipParticles) {
return;
}
using ( new PixEvent(passName) ) {
device.ResetStates();
//
// Setup images :
//
if (Images!=null && !Images.IsDisposed) {
imagesCB.SetData( Images.GetNormalizedRectangles( MaxImages ) );
}
SetupGPUParameters( 0, renderWorld, view, projection, flags );
device.ComputeShaderConstants[0] = paramsCB ;
//
// Render
//
using (new PixEvent("Drawing")) {
device.ResetStates();
// target and viewport :
device.SetTargets( depthTarget, colorTarget );
device.SetViewport( viewport );
// params CB :
device.ComputeShaderConstants[0] = paramsCB ;
device.VertexShaderConstants[0] = paramsCB ;
device.GeometryShaderConstants[0] = paramsCB ;
device.PixelShaderConstants[0] = paramsCB ;
// atlas CB :
device.VertexShaderConstants[1] = imagesCB ;
device.GeometryShaderConstants[1] = imagesCB ;
device.PixelShaderConstants[1] = imagesCB ;
// sampler & textures :
device.PixelShaderSamplers[0] = SamplerState.LinearClamp4Mips ;
device.PixelShaderResources[0] = Images==null? rs.WhiteTexture.Srv : Images.Texture.Srv;
device.PixelShaderResources[5] = depthValues;
device.GeometryShaderResources[1] = simulationBuffer ;
device.GeometryShaderResources[2] = simulationBuffer ;
device.GeometryShaderResources[3] = sortParticlesBuffer;
device.GeometryShaderResources[4] = particleLighting;
// setup PS :
device.PipelineState = factory[ (int)flags ];
// GPU time : 0.81 ms -> 0.91 ms
device.Draw( MaxSimulatedParticles, 0 );
}
}
}
/// <summary>
/// Applies DOF effect
/// </summary>
public void Render ( GameTime gameTime, RenderTarget2D temp, RenderTarget2D hdrImage, ShaderResource depthBuffer, RenderWorld renderWorld )
{
if (!renderWorld.DofSettings.Enabled) {
return;
}
var device = Game.GraphicsDevice;
var filter = Game.RenderSystem.Filter;
device.ResetStates();
//
// Setup parameters :
//
var paramsData = new Params();
paramsData.LinearDepthBias = renderWorld.Camera.LinearizeDepthBias;
paramsData.LinearDepthScale = renderWorld.Camera.LinearizeDepthScale;
paramsData.CocBias = renderWorld.DofSettings.CocBias;
paramsData.CocScale = renderWorld.DofSettings.CocScale;
paramsCB.SetData( paramsData );
device.PixelShaderConstants[0] = paramsCB;
//
// Compute COC and write it in alpha channel :
//
device.SetTargets( (DepthStencilSurface)null, hdrImage.Surface );
device.PixelShaderResources[0] = depthBuffer;
device.PipelineState = factory[ (int)(Flags.COC_TO_ALPHA) ];
device.Draw( 3, 0 );
//
// Perform DOF :
//
device.SetTargets( null, temp );
device.PixelShaderResources[0] = hdrImage;
device.PixelShaderSamplers[0] = SamplerState.LinearClamp;
device.VertexShaderResources[0] = hdrImage;
device.VertexShaderSamplers[0] = SamplerState.LinearClamp;
device.PipelineState = factory[ (int)(Flags.DEPTH_OF_FIELD) ];
device.Draw( 3, 0 );
device.ResetStates();
//
// Copy DOFed image back to source :
//
filter.Copy( hdrImage.Surface, temp );
}
/// <summary>
/// Creates render target
/// </summary>
/// <param name="?"></param>
/// <param name="format"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="samples"></param>
/// <param name="mips"></param>
/// <param name="debugName"></param>
void Create ( ColorFormat format, int size, int samples, bool mips, string debugName )
{
bool msaa = samples > 1;
CheckSamplesCount( samples );
if (mips && samples>1) {
throw new ArgumentException("Render target should be multisampler either mipmapped");
}
SampleCount = samples;
Format = format;
SampleCount = samples;
Width = size;
Height = size;
Depth = 1;
MipCount = mips ? ShaderResource.CalculateMipLevels( Width, Height ) : 1;
var texDesc = new Texture2DDescription();
texDesc.Width = Width;
texDesc.Height = Height;
texDesc.ArraySize = 6;
texDesc.BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = Converter.Convert( format );
texDesc.MipLevels = mips ? MipCount : 1;
texDesc.OptionFlags = ResourceOptionFlags.TextureCube | (mips ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None);
texDesc.SampleDescription = new DXGI.SampleDescription(samples, 0);
texDesc.Usage = ResourceUsage.Default;
texCube = new D3D.Texture2D( device.Device, texDesc );
SRV = new ShaderResourceView( device.Device, texCube );
//
// Top mipmap level :
//
cubeMipShaderResources = new ShaderResource[MipCount];
for (int mip=0; mip<MipCount; mip++) {
var srvDesc = new ShaderResourceViewDescription();
srvDesc.TextureCube.MipLevels = 1;
srvDesc.TextureCube.MostDetailedMip = mip;
srvDesc.Format = Converter.Convert( format );
srvDesc.Dimension = ShaderResourceViewDimension.TextureCube;
cubeMipShaderResources[mip] = new ShaderResource( device, new ShaderResourceView(device.Device, texCube, srvDesc), size>>mip, size>>mip, 1 );
}
//
// Create surfaces :
//
surfaces = new RenderTargetSurface[ MipCount, 6 ];
for ( int mip=0; mip<MipCount; mip++ ) {
int width = GetMipSize( Width, mip );
int height = GetMipSize( Height, mip );
for ( int face=0; face<6; face++) {
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Texture2DArray.MipSlice = mip;
rtvDesc.Texture2DArray.FirstArraySlice = face;
rtvDesc.Texture2DArray.ArraySize = 1;
rtvDesc.Dimension = msaa ? RenderTargetViewDimension.Texture2DMultisampledArray : RenderTargetViewDimension.Texture2DArray;
rtvDesc.Format = Converter.Convert( format );
var rtv = new RenderTargetView( device.Device, texCube, rtvDesc );
int subResId = Resource.CalculateSubResourceIndex( mip, face, MipCount );
surfaces[mip,face] = new RenderTargetSurface( rtv, null, texCube, subResId, format, Width, Height, samples );
GraphicsDevice.Clear( surfaces[mip,face], Color4.Zero );
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dst">target to copy to</param>
/// <param name="src">target to copy from</param>
public void OverlayAdditive( RenderTargetSurface dst, ShaderResource src )
{
SetDefaultRenderStates();
using( new PixEvent("OverlayAdditive") ) {
if(dst == null) {
rs.RestoreBackbuffer();
} else {
rs.SetTargets( null, dst );
}
rs.PipelineState = factory[ (int)ShaderFlags.OVERLAY_ADDITIVE ];
rs.PixelShaderResources[0] = src;
rs.Draw( 3, 0 );
}
rs.ResetStates();
}
/// <summary>
/// Performs FXAA antialiasing.
/// </summary>
/// <param name="dst">Target buffer to render FXAA to</param>
/// <param name="src">Source image with luminance in alpha</param>
public void Fxaa( RenderTargetSurface dst, ShaderResource src )
{
SetDefaultRenderStates();
using( new PixEvent("Fxaa") ) {
if(dst == null) {
rs.RestoreBackbuffer();
} else {
SetViewport( dst );
rs.SetTargets( null, dst );
}
rs.PipelineState = factory[ (int)ShaderFlags.FXAA ];
rs.VertexShaderResources[0] = src;
rs.PixelShaderResources[0] = src;
rs.PixelShaderSamplers[0] = SamplerState.LinearPointClamp;
rs.Draw( 3, 0 );
}
rs.ResetStates();
}
public void RenderBlank(Matrix view, Matrix projection, ShaderResource depthBuffer, ShaderResource wsNormals)
{
var device = Game.GraphicsDevice;
var filter = Game.RenderSystem.Filter;
filter.StretchRect(downsampledDepth.Surface, depthBuffer);
filter.StretchRect(downsampledNormals.Surface, wsNormals);
//
// Setup parameters :
//
var paramsData = new Params();
paramsData.ProjMatrix = projection;
paramsData.View = view;
paramsData.ViewProj = view * projection;
paramsData.InvViewProj = Matrix.Invert(view * projection);
paramsData.InvProj = Matrix.Invert( projection );
//paramsData.TraceStep = Config.TraceStep;
//paramsData.DecayRate = Config.DecayRate;
paramsData.MaxSampleRadius = MaxSamplingRadius;
paramsData.MaxDepthJump = MaxDepthJump;
paramsCB.SetData(paramsData);
sampleDirectionsCB.SetData(sampleDirectionData);
device.PixelShaderConstants[0] = paramsCB;
device.PixelShaderConstants[1] = sampleDirectionsCB;
//
// Measure and adapt :
//
device.SetTargets(null, occlusionMap0);
device.PixelShaderResources[0] = downsampledDepth;
device.PixelShaderResources[1] = downsampledNormals;
device.PixelShaderResources[2] = randomDir;
device.PixelShaderSamplers[0] = SamplerState.LinearClamp;
device.PipelineState = factory[(int)Flags.BLANK];
device.Draw(3, 0);
device.ResetStates();
}
/// <summary>
///
/// </summary>
/// <param name="srcDst"></param>
/// <param name="temporary"></param>
/// <param name="sigma"></param>
/// <param name="kernelSize"></param>
void GaussBlurInternal ( RenderTarget2D srcDst, RenderTarget2D temporary, float sigma, float sharpness, int mipLevel, ShaderResource depthData, ShaderResource normalData )
{
var taps = GetGaussWeightsBuffer( sigma, mipLevel );
SetDefaultRenderStates();
gaussWeightsCB.SetData( taps );
int combination = (int)ShaderFlags.GAUSS_BLUR;
if (depthData!=null && normalData!=null) {
combination |= (int)ShaderFlags.BILATERAL;
}
using( new PixEvent("GaussBlur") ) {
SetViewport(temporary.GetSurface(mipLevel));
rs.SetTargets( null, temporary.GetSurface(mipLevel) );
rs.PipelineState = factory[ combination|(int)ShaderFlags.PASS1 ];
rs.VertexShaderResources[0] = srcDst;
rs.PixelShaderResources[0] = srcDst;
rs.PixelShaderResources[1] = depthData;
rs.PixelShaderResources[2] = normalData;
rs.PixelShaderConstants[0] = gaussWeightsCB;
rs.PixelShaderSamplers[0] = SamplerState.LinearPointClamp;
rs.PixelShaderSamplers[1] = SamplerState.PointClamp;
rs.Draw( 3, 0 );
rs.VertexShaderResources[0] = null;
rs.PixelShaderResources[0] = null;
SetViewport(srcDst.GetSurface(mipLevel));
rs.SetTargets( null, srcDst.GetSurface(mipLevel) );
rs.PipelineState = factory[ combination|(int)ShaderFlags.PASS2 ];
rs.VertexShaderResources[0] = temporary;
rs.PixelShaderResources[0] = temporary;
rs.PixelShaderResources[1] = depthData;
rs.PixelShaderResources[2] = normalData;
rs.PixelShaderConstants[0] = gaussWeightsCB;
rs.PixelShaderSamplers[0] = SamplerState.LinearPointClamp;
rs.PixelShaderSamplers[1] = SamplerState.PointClamp;
rs.Draw( 3, 0 );
}
rs.ResetStates();
}
/// <summary>
/// Performs luminance measurement, tonemapping, applies bloom.
/// </summary>
/// <param name="target">LDR target.</param>
/// <param name="hdrImage">HDR source image.</param>
public void Render ( StereoEye stereoEye, Camera camera, ShaderResource depthBuffer, ShaderResource wsNormals )
{
var view = camera.GetViewMatrix( stereoEye );
var projection = camera.GetProjectionMatrix( stereoEye );
var device = Game.GraphicsDevice;
var filter = Game.RenderSystem.Filter;
if (!Enabled) {
device.Clear( occlusionMap0.Surface, Color4.White );
return;
}
using (new PixEvent("SSAO Render")) {
filter.StretchRect( downsampledDepth.Surface, depthBuffer );
filter.StretchRect( downsampledNormals.Surface, wsNormals );
using (new PixEvent("SSAO Pass")) {
//
// Setup parameters :
//
var paramsData = new Params();
paramsData.ProjMatrix = projection;
paramsData.View = view;
paramsData.ViewProj = view * projection;
paramsData.InvViewProj = Matrix.Invert( view * projection );
paramsData.InvProj = Matrix.Invert(projection);
//paramsData.TraceStep = Config.TraceStep;
//paramsData.DecayRate = Config.DecayRate;
paramsData.MaxSampleRadius = MaxSamplingRadius;
paramsData.MaxDepthJump = MaxDepthJump;
paramsCB.SetData( paramsData );
sampleDirectionsCB.SetData(sampleDirectionData);
device.PixelShaderConstants[0] = paramsCB;
device.PixelShaderConstants[1] = sampleDirectionsCB;
//
// Measure and adapt :
//
device.SetTargets( null, occlusionMap0 );
device.PixelShaderResources[0] = downsampledDepth;
device.PixelShaderResources[1] = downsampledNormals;
device.PixelShaderResources[2] = randomDir;
device.PixelShaderSamplers[0] = SamplerState.LinearClamp;
Flags sampleNumFlag = getSampleNumFlag();
device.PipelineState = factory[getFlags()];
device.Draw( 3, 0 );
device.ResetStates();
}
using (new PixEvent("Bilateral Filter")) {
if (BlurSigma!=0) {
filter.GaussBlurBilateral( occlusionMap0, occlusionMap1, downsampledDepth, downsampledNormals, BlurSigma, Sharpness, 0 );
}
}
}
}