public DX11SliceRenderTarget(DX11RenderContext context, DX11Texture2D texture, int sliceindex)
{
this.isowner = false;
this.context = context;
this.parent = texture;
this.desc = texture.Description;
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
ArraySize = 1,
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = texture.Format,
MipSlice = 0,
FirstArraySlice = sliceindex,
};
this.RTV = new RenderTargetView(context.Device, this.parent.Resource, rtd);
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription()
{
ArraySize = 1,
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = texture.Format,
FirstArraySlice = sliceindex,
MipLevels = texture.Resource.Description.MipLevels,
MostDetailedMip = 0
};
this.SRV = new ShaderResourceView(context.Device, this.parent.Resource, srvd);
}
/// <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 DX11MipSliceRenderTarget(DX11RenderContext context, DX11Texture3D texture, int mipindex,int w, int h,int d)
{
this.context = context;
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture3D,
Format = texture.Format,
MipSlice = mipindex,
DepthSliceCount = d
};
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription();
srvd.Dimension = ShaderResourceViewDimension.Texture3D;
srvd.MipLevels = 1;
srvd.MostDetailedMip = mipindex;
srvd.Format = texture.Format;
this.RTV = new RenderTargetView(context.Device, texture.Resource, rtd);
this.SRV = new ShaderResourceView(context.Device, texture.Resource, srvd);
this.Width = w;
this.Height = h;
this.Depth = d;
}
public DX11MipSliceRenderTarget2D(DX11RenderContext context, DX11Texture2D texture, int mipindex, int w, int h)
{
this.context = context;
this.Resource = texture.Resource;
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture2D,
Format = texture.Format,
MipSlice = mipindex
};
UnorderedAccessViewDescription uavd = new UnorderedAccessViewDescription()
{
Dimension = UnorderedAccessViewDimension.Texture2D,
Format = texture.Format,
MipSlice = mipindex,
};
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription();
srvd.Dimension = ShaderResourceViewDimension.Texture2D;
srvd.MipLevels = 1;
srvd.MostDetailedMip = mipindex;
srvd.Format = texture.Format;
this.SRV = new ShaderResourceView(context.Device, texture.Resource, srvd);
}
public DX11RenderTexture3D(DX11RenderContext context, int w, int h, int d, Format format)
: base(context)
{
Texture3DDescription desc = new Texture3DDescription()
{
BindFlags = BindFlags.UnorderedAccess | BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
Depth = d,
Format = format,
Height = h,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
Width = w
};
RenderTargetViewDescription rtvd = new RenderTargetViewDescription();
rtvd.Dimension = RenderTargetViewDimension.Texture3D;
rtvd.MipSlice = 0;
rtvd.FirstDepthSlice = 0;
rtvd.DepthSliceCount = d;
this.Resource = new Texture3D(context.Device, desc);
this.SRV = new ShaderResourceView(context.Device, this.Resource);
this.UAV = new UnorderedAccessView(context.Device, this.Resource);
this.RTV = new RenderTargetView(context.Device, this.Resource, rtvd);
this.Width = desc.Width;
this.Height = desc.Height;
this.Format = desc.Format;
this.Depth = desc.Depth;
}
public DX11RenderTextureArray(DX11RenderContext context, int w, int h, int elemcnt, Format format)
{
this.context = context;
var texBufferDesc = new Texture2DDescription
{
ArraySize = elemcnt,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = h,
Width = w,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1,0),
Usage = ResourceUsage.Default,
};
this.Resource = new Texture2D(context.Device, texBufferDesc);
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
ArraySize = elemcnt,
FirstArraySlice = 0,
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = format
};
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription()
{
ArraySize = elemcnt,
FirstArraySlice = 0,
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = format,
MipLevels = 1,
MostDetailedMip = 0
};
this.SRV = new ShaderResourceView(context.Device, this.Resource, srvd);
this.RTV = new RenderTargetView(context.Device, this.Resource, rtd);
this.SRVArray = new ShaderResourceView[elemcnt];
ShaderResourceViewDescription srvad = new ShaderResourceViewDescription()
{
ArraySize = 1,
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = format,
MipLevels = 1,
MostDetailedMip = 0
};
for (int i = 0; i < elemcnt; i++)
{
srvad.FirstArraySlice = i;
this.SRVArray[i] = new ShaderResourceView(context.Device, this.Resource, srvad);
}
this.desc = texBufferDesc;
}
private void CreateRenderTargetView()
{
var renderTargetViewDesc = new RenderTargetViewDescription();
renderTargetViewDesc.ArraySize = layerCount;
renderTargetViewDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
renderTargetViewDesc.FirstArraySlice = 0;
renderTargetViewDesc.Format = format;
renderTargetViewDesc.MipSlice = 0;
renderTargetViewAsArray = new RenderTargetView(device, texture, renderTargetViewDesc);
}
public DX11RenderTextureArray(DX11RenderContext context, int w, int h, int elemcnt, Format format, bool buildslices = true, int miplevels = 0)
{
this.context = context;
var texBufferDesc = new Texture2DDescription
{
ArraySize = elemcnt,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = h,
Width = w,
OptionFlags = miplevels == 0 ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1,0),
Usage = ResourceUsage.Default,
MipLevels= miplevels
};
this.Resource = new Texture2D(context.Device, texBufferDesc);
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
ArraySize = elemcnt,
FirstArraySlice = 0,
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = format
};
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription()
{
ArraySize = elemcnt,
FirstArraySlice = 0,
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = format,
MipLevels = this.Resource.Description.MipLevels,
MostDetailedMip = 0
};
this.SRV = new ShaderResourceView(context.Device, this.Resource, srvd);
this.RTV = new RenderTargetView(context.Device, this.Resource, rtd);
this.desc = texBufferDesc;
this.SliceRTV = new DX11SliceRenderTarget[this.ElemCnt];
if (buildslices)
{
for (int i = 0; i < this.ElemCnt; i++)
{
this.SliceRTV[i] = new DX11SliceRenderTarget(this.context, this, i);
}
}
}
public bool Initialize(Device device, SystemConfiguration configuration)
{
try
{
// Initialize and set up the render target description.
var textureDesc = new Texture2DDescription()
{
Width = configuration.Width,
Height = configuration.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.R32G32B32A32_Float,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
// Create the render target texture.
RenderTargetTexture = new Texture2D(device, textureDesc);
// Initialize and setup the render target view
var renderTargetViewDesc = new RenderTargetViewDescription()
{
Format = textureDesc.Format,
Dimension = RenderTargetViewDimension.Texture2D,
};
renderTargetViewDesc.Texture2D.MipSlice = 0;
// Create the render target view.
RenderTargetView = new RenderTargetView(device, RenderTargetTexture, renderTargetViewDesc);
// Initialize and setup the shader resource view
var shaderResourceViewDesc = new ShaderResourceViewDescription()
{
Format = textureDesc.Format,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceViewDesc.Texture2D.MipLevels = 1;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
// Create the render target view.
ShaderResourceView = new ShaderResourceView(device, RenderTargetTexture, shaderResourceViewDesc);
return true;
}
catch
{
return false;
}
}
private void CreateRenderTargetViews()
{
var renderTargetViewDesc = new RenderTargetViewDescription();
renderTargetViewDesc.Format = texture.Description.Format;
renderTargetViewDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
renderTargetViewDesc.ArraySize = 1;
renderTargetViewDesc.MipSlice = 0;
for (int i = 0; i < deferredShadingConfiguration.LayerCount; ++i)
{
renderTargetViewDesc.FirstArraySlice = i;
var renderTargetView = new RenderTargetView(device, texture, renderTargetViewDesc);
renderTargetViews.Add(renderTargetView);
}
}
public void OnDeviceInit()
{
{
ShaderResourceViewDescription desc = new ShaderResourceViewDescription();
desc.Format = m_format;
desc.Dimension = ShaderResourceViewDimension.Texture2D;
desc.Texture2D.MipLevels = 1;
desc.Texture2D.MostDetailedMip = 0;
m_srv = new ShaderResourceView(MyRender11.Device, m_owner.Resource, desc);
m_srv.DebugName = m_owner.Name;
}
{
RenderTargetViewDescription desc = new RenderTargetViewDescription();
desc.Format = m_format;
desc.Dimension = RenderTargetViewDimension.Texture2D;
desc.Texture2D.MipSlice = 0;
m_rtv = new RenderTargetView(MyRender11.Device, m_owner.Resource, desc);
m_rtv.DebugName = m_owner.Name;
}
}
public DX11MipSliceRenderTarget3D(DX11RenderContext context, DX11Texture3D texture, int mipindex, int w, int h, int d)
: base(context)
{
this.Resource = texture.Resource;
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture3D,
Format = texture.Format,
MipSlice = mipindex,
DepthSliceCount = d
};
UnorderedAccessViewDescription uavd = new UnorderedAccessViewDescription()
{
Dimension = UnorderedAccessViewDimension.Texture3D,
Format = texture.Format,
MipSlice = mipindex,
FirstDepthSlice = 0,
DepthSliceCount = d
};
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription();
srvd.Dimension = ShaderResourceViewDimension.Texture3D;
srvd.MipLevels = 1;
srvd.MostDetailedMip = mipindex;
srvd.Format = texture.Format;
srvd.ArraySize = d;
srvd.FirstArraySlice = 0;
this.RTV = new RenderTargetView(context.Device, texture.Resource, rtd);
this.SRV = new ShaderResourceView(context.Device, texture.Resource, srvd);
this.UAV = new UnorderedAccessView(context.Device, texture.Resource, uavd);
this.Width = w;
this.Height = h;
this.Depth = d;
}
public RenderTexture(Game game, int width, int height, int mrtCount = 1, string debugName = null)
{
this.game = game;
if (mrtCount < 1) mrtCount = 1;
this.debugName = debugName ?? "RenderTexture " + Debug.NextObjectId;
var format = Format.R32G32B32A32_Float;
{
var desc = new Texture2DDescription();
desc.Format = format;
desc.Width = width;
desc.Height = height;
desc.BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource;
desc.Usage = ResourceUsage.Default;
desc.ArraySize = 1;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.MipLevels = 1;
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
desc.OptionFlags = ResourceOptionFlags.None;
textures = new Texture2D[mrtCount];
for (int i = 0; i < mrtCount; ++i)
{
textures[i] = new Texture2D(game.Device, desc);
textures[i].DebugName = DebugName + "[" + i + "]";
}
}
{
var desc = new RenderTargetViewDescription();
desc.Format = format;
desc.Dimension = RenderTargetViewDimension.Texture2D;
desc.Texture2D.MipSlice = 0;
renderTargetViews = new RenderTargetView[mrtCount];
for (int i = 0; i < mrtCount; ++i)
{
renderTargetViews[i] = new RenderTargetView(game.Device, textures[i], desc);
renderTargetViews[i].DebugName = DebugName + "[" + i + "]";
}
}
{
shaderResourceViews = new ShaderResourceView[mrtCount];
for (int i = 0; i < mrtCount; ++i)
{
shaderResourceViews[i] = new ShaderResourceView(game.Device, textures[i]);
shaderResourceViews[i].DebugName = DebugName + "[" + i + "]";
}
}
{
clearColors = new Color4[mrtCount];
for (int i = 0; i < mrtCount; ++i)
{
clearColors[i] = Color4.Black;
}
}
{
var desc = new Texture2DDescription();
desc.Format = Format.D24_UNorm_S8_UInt;
desc.ArraySize = 1;
desc.MipLevels = 1;
desc.Width = width;
desc.Height = height;
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
desc.Usage = ResourceUsage.Default;
desc.BindFlags = BindFlags.DepthStencil;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.OptionFlags = ResourceOptionFlags.None;
depthStencilTexture = new Texture2D(game.Device, desc);
depthStencilTexture.DebugName = DebugName + "(DS)";
}
{
depthStencilView = new DepthStencilView(game.Device, depthStencilTexture);
depthStencilView.DebugName = DebugName;
}
vp = new SharpDX.Viewport(0, 0, width, height);
game.AddObject(this);
}
/// <summary>
/// Creates render target
/// </summary>
/// <param name="rs"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="format"></param>
public FeedbackBuffer(GraphicsDevice device, int width, int height) : base(device)
{
Log.Debug("FeedbackBuffer: w:{0} h:{1}", width, height);
feedbackData = new VTAddress[width * height];
feedbackDataRaw = new int[width * height];
linearSize = width * height;
Width = width;
Height = height;
Depth = 1;
//
// Create Texture2D :
//
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 = DXGI.Format.R10G10B10A2_UNorm;
texDesc.MipLevels = 1;
texDesc.OptionFlags = ResourceOptionFlags.None;
texDesc.SampleDescription = new DXGI.SampleDescription(1, 0);
texDesc.Usage = ResourceUsage.Default;
tex2D = new D3D.Texture2D(device.Device, texDesc);
//
// Create staging Texture2D :
//
var texDescStaging = new Texture2DDescription();
texDescStaging.Width = width;
texDescStaging.Height = height;
texDescStaging.ArraySize = 1;
texDescStaging.BindFlags = BindFlags.None;
texDescStaging.CpuAccessFlags = CpuAccessFlags.Read;
texDescStaging.Format = DXGI.Format.R10G10B10A2_UNorm;
texDescStaging.MipLevels = 1;
texDescStaging.OptionFlags = ResourceOptionFlags.None;
texDescStaging.SampleDescription = new DXGI.SampleDescription(1, 0);
texDescStaging.Usage = ResourceUsage.Staging;
tex2Dstaging = new D3D.Texture2D(device.Device, texDescStaging);
tex2Dstaging1 = new D3D.Texture2D(device.Device, texDescStaging);
tex2Dstaging2 = new D3D.Texture2D(device.Device, texDescStaging);
//
// Create SRV :
//
var srvDesc = new ShaderResourceViewDescription();
srvDesc.Texture2D.MipLevels = 1;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Dimension = ShaderResourceViewDimension.Texture2D;
srvDesc.Format = DXGI.Format.R10G10B10A2_UNorm;
SRV = new ShaderResourceView(device.Device, tex2D, srvDesc);
//
// Create RTV :
//
width = Width;
height = Height;
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Texture2D.MipSlice = 0;
rtvDesc.Dimension = RenderTargetViewDimension.Texture2D;
rtvDesc.Format = DXGI.Format.R10G10B10A2_UNorm;
var rtv = new RenderTargetView(device.Device, tex2D, rtvDesc);
surface = new RenderTargetSurface(rtv, null, tex2D, 0, ColorFormat.Unknown, width, height, 1);
}
private void CreateRenderTargets()
{
Texture2D backBuffer = Texture2D.FromSwapChain<Texture2D>(SwapChain, 0);
sceneView = new RenderTargetView(Device, backBuffer);
Texture2DDescription depthBufferDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R32_Typeless,
Width = WindowWidth,
Height = WindowHeight,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
Texture2D depthBuffer = new Texture2D(Device, depthBufferDesc);
DepthStencilViewDescription depthStencilDesc = new DepthStencilViewDescription
{
ArraySize = 0,
Format = Format.D32_Float,
Dimension = DepthStencilViewDimension.Texture2D,
MipSlice = 0,
Flags = 0,
FirstArraySlice = 0
};
depthView = new DepthStencilView(Device, depthBuffer, depthStencilDesc);
ShaderResourceViewDescription depthResViewDesc = new ShaderResourceViewDescription
{
ArraySize = 0,
Format = Format.R32_Float,
Dimension = ShaderResourceViewDimension.Texture2D,
MipLevels = 1,
Flags = 0,
FirstArraySlice = 0
};
depthResView = new ShaderResourceView(Device, depthBuffer, depthResViewDesc);
Texture2DDescription densityBufferDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
Width = WindowWidth,
Height = WindowHeight,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
Texture2D densityBuffer = new Texture2D(Device, densityBufferDesc);
RenderTargetViewDescription densityViewDesc = new RenderTargetViewDescription
{
ArraySize = 0,
Format = Format.R8G8B8A8_UNorm,
Dimension = RenderTargetViewDimension.Texture2D,
MipSlice = 0,
FirstArraySlice = 0
};
densityView = new RenderTargetView(Device, densityBuffer, densityViewDesc);
ShaderResourceViewDescription densityResViewDesc = new ShaderResourceViewDescription
{
ArraySize = 0,
Format = Format.R8G8B8A8_UNorm,
Dimension = ShaderResourceViewDimension.Texture2D,
MipLevels = 1,
Flags = 0,
FirstArraySlice = 0
};
densityResView = new ShaderResourceView(Device, densityBuffer, densityResViewDesc);
}
/// <summary>
/// テクスチャーを作成する
/// </summary>
/// <param name="app"></param>
/// <param name="name"></param>
/// <param name="desc"></param>
/// <returns></returns>
public static MCBaseTexture CreateTexture2D(Application app, string name, Texture2DDescription desc)
{
int hr = -1;
bool isCreateDepth = false;
MCTexture tx = new MCTexture(app, name);
var d = new Texture123DDesc();
if (tx == null)
{
throw new CreatedException();
}
if ((desc.BindFlags & BindFlags.DepthStencil) != 0)
{
desc.BindFlags &= ~BindFlags.DepthStencil;
isCreateDepth = true;
}
d.D2 = desc;
if (tx.CreateTexture2D(0, d) != 0)
{
return(null);
}
// 1．レンダーターゲット
if ((desc.BindFlags & BindFlags.RenderTarget) != 0)
{
RenderTargetViewDescription renderD = new RenderTargetViewDescription();
renderD.Format = desc.Format;
renderD.Dimension = RenderTargetViewDimension.Texture2D;
renderD.Texture2D.MipSlice = 0;
hr = tx.CreateRenderTargetView(0, renderD);
if (hr == -1)
{
return(null);
}
}
// 2．シェーダーターゲット
if ((desc.BindFlags & BindFlags.ShaderResource) != 0)
{
ShaderResourceViewDescription shaderD = new ShaderResourceViewDescription();
shaderD.Format = desc.Format;
shaderD.Dimension = ShaderResourceViewDimension.Texture2D;
shaderD.Texture2D.MostDetailedMip = 0;
shaderD.Texture2D.MipLevels = 1;
hr = tx.CreateShaderResourceView(0, shaderD);
if (hr == -1)
{
return(null);
}
}
if (isCreateDepth)
{
hr = tx.CreateDepthTexture();
if (hr == -1)
{
return(null);
}
}
if (!app.ImageMgr.RegisterTexture(name, tx))
{
return(null);
}
return(tx);
}
protected override void CreateDeviceDependentResources()
{
RemoveAndDispose(ref EnvMap);
RemoveAndDispose(ref EnvMapSRV);
RemoveAndDispose(ref EnvMapRTV);
RemoveAndDispose(ref EnvMapDSV);
RemoveAndDispose(ref PerEnvMapBuffer);
EnvMapRTVs.ToList().ForEach((rtv) => RemoveAndDispose(ref rtv));
EnvMapDSVs.ToList().ForEach((dsv) => RemoveAndDispose(ref dsv));
contextList.ToList().ForEach((ctx) => RemoveAndDispose(ref ctx));
var device = this.DeviceManager.Direct3DDevice;
// Create the cube map TextureCube (array of 6 textures)
var textureDesc = new Texture2DDescription()
{
Format = Format.R8G8B8A8_UNorm,
Height = Size,
Width = Size,
ArraySize = 6, // 6-sides of the cube
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube,
SampleDescription = new SampleDescription(1, 0),
MipLevels = 0,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None,
};
EnvMap = ToDispose(new Texture2D(device, textureDesc));
// Create the SRV for the texture cube
var descSRV = new ShaderResourceViewDescription();
descSRV.Format = textureDesc.Format;
descSRV.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube;
descSRV.TextureCube.MostDetailedMip = 0;
descSRV.TextureCube.MipLevels = -1;
EnvMapSRV = ToDispose(new ShaderResourceView(device, EnvMap, descSRV));
// Create the RTVs
var descRTV = new RenderTargetViewDescription();
descRTV.Format = textureDesc.Format;
descRTV.Dimension = RenderTargetViewDimension.Texture2DArray;
descRTV.Texture2DArray.MipSlice = 0;
// 1. Single RTV for single pass rendering
descRTV.Texture2DArray.FirstArraySlice = 0;
descRTV.Texture2DArray.ArraySize = 6;
EnvMapRTV = ToDispose(new RenderTargetView(device, EnvMap, descRTV));
// 2. RTV for each of the 6 sides of the texture cube
descRTV.Texture2DArray.ArraySize = 1;
for (int i = 0; i < 6; i++)
{
descRTV.Texture2DArray.FirstArraySlice = i;
EnvMapRTVs[i] = ToDispose(new RenderTargetView(device, EnvMap, descRTV));
}
// Create DSVs
using (var depth = new Texture2D(device, new Texture2DDescription
{
Format = Format.D32_Float,
BindFlags = BindFlags.DepthStencil,
Height = Size,
Width = Size,
Usage = ResourceUsage.Default,
SampleDescription = new SampleDescription(1, 0),
CpuAccessFlags = CpuAccessFlags.None,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.TextureCube,
ArraySize = 6 // 6-sides of the cube
}))
{
var descDSV = new DepthStencilViewDescription();
descDSV.Format = depth.Description.Format;
descDSV.Dimension = DepthStencilViewDimension.Texture2DArray;
descDSV.Flags = DepthStencilViewFlags.None;
descDSV.Texture2DArray.MipSlice = 0;
// 1. Single DSV for single pass rendering
descDSV.Texture2DArray.FirstArraySlice = 0;
descDSV.Texture2DArray.ArraySize = 6;
EnvMapDSV = ToDispose(new DepthStencilView(device, depth, descDSV));
// 2. Create DSV for each face
descDSV.Texture2DArray.ArraySize = 1;
for (var i = 0; i < 6; i++)
{
descDSV.Texture2DArray.FirstArraySlice = i;
EnvMapDSVs[i] = ToDispose(new DepthStencilView(device, depth, descDSV));
}
}
// Create the viewport
Viewport = new Viewport(0, 0, Size, Size);
// Initialize context List for threaded rendering
// See UpdateCubeThreaded
if (Threads == 1)
{
contextList = null;
}
else
{
contextList = new DeviceContext[Threads];
for (var i = 0; i < Threads; i++)
{
contextList[i] = ToDispose(new DeviceContext(device));
}
}
// Create the per environment map buffer (to store the 6 ViewProjection matrices)
PerEnvMapBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <Matrix>() * 6, ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
PerEnvMapBuffer.DebugName = "PerEnvMapBuffer";
EnvMap.Dispose();
}
internal MyRtvView(MyBindableResource from, Format fmt)
{
m_owner = from;
var desc = new RenderTargetViewDescription
{
Format = fmt,
Dimension = RenderTargetViewDimension.Texture2D,
Texture2D = new RenderTargetViewDescription.Texture2DResource { MipSlice = 0 }
};
m_rtv = new RenderTargetView(MyRender11.Device, m_owner.m_resource, desc);
}
/// <summary>
/// Creates the view.
/// </summary>
/// <param name="desc">The desc.</param>
public void CreateView(RenderTargetViewDescription desc)
{
RemoveAndDispose(ref renderTargetView);
renderTargetView = Collect(new RenderTargetView(device, resource, desc));
}
public DX11CubeRenderTarget(DxDevice device, int size, SampleDescription sd, Format format, bool genMipMaps, int mmLevels)
{
this.device = device;
var texBufferDesc = new Texture2DDescription
{
ArraySize = 6,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = size,
Width = size,
OptionFlags = ResourceOptionFlags.TextureCube,
SampleDescription = sd,
Usage = ResourceUsage.Default,
};
if (genMipMaps && sd.Count == 1)
{
texBufferDesc.OptionFlags |= ResourceOptionFlags.GenerateMipMaps;
texBufferDesc.MipLevels = mmLevels;
}
else
{
//Make sure we enforce 1 here, as we dont generate
texBufferDesc.MipLevels = 1;
}
this.Texture = new Texture2D(device.Device, texBufferDesc);
this.resourceDesc = this.Texture.Description;
//Create faces SRV/RTV
this.Slices = new DX11SliceRenderTarget[6];
ShaderResourceViewDescription svd = new ShaderResourceViewDescription()
{
Format = format,
Dimension = ShaderResourceViewDimension.TextureCube,
TextureCube = new ShaderResourceViewDescription.TextureCubeResource()
{
MipLevels = 1,
MostDetailedMip = 0,
}
};
RenderTargetViewDescription rtvd = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = format,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
ArraySize = 6,
FirstArraySlice = 0,
MipSlice = 0
}
};
this.RenderView = new RenderTargetView(device.Device, this.Texture, rtvd);
this.ShaderView = new ShaderResourceView(device.Device, this.Texture, svd);
for (int i = 0; i < 6; i++)
{
this.Slices[i] = new DX11SliceRenderTarget(device, this, i);
}
}
public FramebufferD3D11(DeviceD3D11 device, FramebufferAttachment[] colorAttachments, FramebufferAttachment?depthStencilAttachment)
: base(device, colorAttachments, depthStencilAttachment)
{
if (colorAttachments.Length > 0)
{
RenderTargetViews = new ID3D11RenderTargetView[colorAttachments.Length];
for (var i = 0; i < colorAttachments.Length; i++)
{
var attachment = colorAttachments[i];
var texture = attachment.Texture;
var arraySize = texture.ArrayLayers - attachment.Slice;
bool isTextureMs = (int)texture.Samples > 1;
var d3dTexture = (TextureD3D11)texture;
var viewDesc = new RenderTargetViewDescription
{
Format = d3dTexture.DXGIFormat
};
switch (texture.TextureType)
{
case TextureType.Texture1D:
if (arraySize > 1)
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture1DArray;
viewDesc.Texture1DArray.MipSlice = attachment.MipLevel;
viewDesc.Texture1DArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture1DArray.ArraySize = arraySize;
}
else
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture1D;
viewDesc.Texture1D.MipSlice = attachment.MipLevel;
}
break;
case TextureType.Texture2D:
if (arraySize > 1)
{
if (isTextureMs)
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DMultisampledArray;
viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture2DMSArray.ArraySize = arraySize;
}
else
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DArray;
viewDesc.Texture2DArray.MipSlice = attachment.MipLevel;
viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture2DArray.ArraySize = arraySize;
}
}
else
{
if (isTextureMs)
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DMultisampled;
}
else
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture2D;
viewDesc.Texture2D.MipSlice = attachment.MipLevel;
}
}
break;
case TextureType.Texture3D:
// TODO: Add RenderPassAttachment.DepthPlane
viewDesc.ViewDimension = RenderTargetViewDimension.Texture3D;
viewDesc.Texture3D.MipSlice = attachment.MipLevel;
viewDesc.Texture3D.FirstWSlice = attachment.Slice;
viewDesc.Texture3D.WSize = texture.Depth;
break;
case TextureType.TextureCube:
if (isTextureMs)
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DMultisampledArray;
viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice * 6;
viewDesc.Texture2DMSArray.ArraySize = arraySize * 6;
}
else
{
viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DArray;
viewDesc.Texture2DArray.MipSlice = attachment.MipLevel;
viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice * 6;
viewDesc.Texture2DArray.ArraySize = arraySize * 6;
}
break;
}
RenderTargetViews[i] = device.Device.CreateRenderTargetView(d3dTexture.Resource, viewDesc);
}
}
else
{
RenderTargetViews = new ID3D11RenderTargetView[0];
}
if (depthStencilAttachment != null)
{
var attachment = depthStencilAttachment.Value;
var texture = attachment.Texture;
var d3dTexture = (TextureD3D11)texture;
var arraySize = texture.ArrayLayers - attachment.Slice;
bool isTextureMs = (int)texture.Samples > 1;
var viewDesc = new DepthStencilViewDescription
{
Format = d3dTexture.DXGIFormat,
Flags = DepthStencilViewFlags.None
};
switch (texture.TextureType)
{
case TextureType.Texture1D:
if (arraySize > 1)
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture1DArray;
viewDesc.Texture1DArray.MipSlice = attachment.MipLevel;
viewDesc.Texture1DArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture1DArray.ArraySize = arraySize;
}
else
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture1D;
viewDesc.Texture1D.MipSlice = attachment.MipLevel;
}
break;
case TextureType.Texture2D:
if (arraySize > 1)
{
if (isTextureMs)
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DMultisampledArray;
viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture2DMSArray.ArraySize = arraySize;
}
else
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DArray;
viewDesc.Texture2DArray.MipSlice = attachment.MipLevel;
viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture2DArray.ArraySize = arraySize;
}
}
else
{
if (isTextureMs)
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DMultisampled;
}
else
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2D;
viewDesc.Texture2D.MipSlice = attachment.MipLevel;
}
}
break;
case TextureType.TextureCube:
if (isTextureMs)
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DMultisampledArray;
viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice * 6;
viewDesc.Texture2DMSArray.ArraySize = arraySize * 6;
}
else
{
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DArray;
viewDesc.Texture2DArray.MipSlice = attachment.MipLevel * 6;
viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice * 6;
viewDesc.Texture2DArray.ArraySize = arraySize * 6;
}
break;
case TextureType.Texture3D:
viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DArray;
viewDesc.Texture2DArray.MipSlice = attachment.MipLevel;
viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice;
viewDesc.Texture2DArray.ArraySize = texture.Depth;
break;
default:
viewDesc.ViewDimension = DepthStencilViewDimension.Unknown;
Log.Error("Invalid texture type");
break;
}
DepthStencilView = device.Device.CreateDepthStencilView(d3dTexture.Resource, viewDesc);
}
}
// Puvlix Methods
public bool Initialize(SharpDX.Direct3D11.Device device, DSystemConfiguration configuration)
{
try
{
// Initialize and set up the render target description.
Texture2DDescription textureDesc = new Texture2DDescription()
{
// Shadow Map Texture size as a 1024x1024 Square
Width = 1024,
Height = 1024,
MipLevels = 1,
ArraySize = 1,
Format = Format.R32G32B32A32_Float,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
// Create the render target texture.
RenderTargetTexture = new Texture2D(device, textureDesc);
// Setup the description of the render target view.
RenderTargetViewDescription renderTargetViewDesc = new RenderTargetViewDescription()
{
Format = textureDesc.Format,
Dimension = RenderTargetViewDimension.Texture2D,
};
renderTargetViewDesc.Texture2D.MipSlice = 0;
// Create the render target view.
RenderTargetView = new RenderTargetView(device, RenderTargetTexture, renderTargetViewDesc);
// Setup the description of the shader resource view.
ShaderResourceViewDescription shaderResourceViewDesc = new ShaderResourceViewDescription()
{
Format = textureDesc.Format,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceViewDesc.Texture2D.MipLevels = 1;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
// Create the render target view.
ShaderResourceView = new ShaderResourceView(device, RenderTargetTexture, shaderResourceViewDesc);
// Initialize and Set up the description of the depth buffer.
Texture2DDescription depthStencilDesc = new Texture2DDescription()
{
Width = 1024,
Height = 1024,
MipLevels = 1,
ArraySize = 1,
Format = Format.D24_UNorm_S8_UInt,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
// Create the texture for the depth buffer using the filled out description.
DepthStencilBuffer = new Texture2D(device, depthStencilDesc);
// Initailze the depth stencil view description.
DepthStencilViewDescription deothStencilViewDesc = new DepthStencilViewDescription()
{
Format = Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2D
};
deothStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
DepthStencilView = new DepthStencilView(device, DepthStencilBuffer, deothStencilViewDesc);
// Setup the viewport for rendering.
ViewPort = new ViewportF()
{
Width = 1024.0f,
Height = 1024.0f,
MinDepth = 0.0f,
MaxDepth = 1.0f,
X = 0.0f,
Y = 0.0f
};
return(true);
}
catch
{
return(false);
}
}
private void BuildDynamicCubeMapViews()
{
// create the render target cube map texture
var texDesc = new Texture2DDescription()
{
Width = CubeMapSize,
Height = CubeMapSize,
MipLevels = 0,
ArraySize = 6,
SampleDescription = new SampleDescription(1, 0),
Format = Format.R8G8B8A8_UNorm,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube
};
var cubeTex = new Texture2D(Device, texDesc);
cubeTex.DebugName = "dynamic cubemap texture";
// create the render target view array
var rtvDesc = new RenderTargetViewDescription()
{
Format = texDesc.Format,
Dimension = RenderTargetViewDimension.Texture2DArray,
ArraySize = 1,
MipSlice = 0
};
for (int i = 0; i < 6; i++)
{
rtvDesc.FirstArraySlice = i;
_dynamicCubeMapRTV[i] = new RenderTargetView(Device, cubeTex, rtvDesc);
}
// Create the shader resource view that we will bind to our effect for the cubemap
var srvDesc = new ShaderResourceViewDescription()
{
Format = texDesc.Format,
Dimension = ShaderResourceViewDimension.TextureCube,
MostDetailedMip = 0,
MipLevels = -1
};
_dynamicCubeMapSRV = new ShaderResourceView(Device, cubeTex, srvDesc);
// release the texture, now that it is saved to the views
Util.ReleaseCom(ref cubeTex);
// create the depth/stencil texture
var depthTexDesc = new Texture2DDescription()
{
Width = CubeMapSize,
Height = CubeMapSize,
MipLevels = 1,
ArraySize = 1,
SampleDescription = new SampleDescription(1, 0),
Format = Format.D32_Float,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
var depthTex = new Texture2D(Device, depthTexDesc);
depthTex.DebugName = "dynamic cubemap depthmap";
var dsvDesc = new DepthStencilViewDescription()
{
Format = depthTexDesc.Format,
Flags = DepthStencilViewFlags.None,
Dimension = DepthStencilViewDimension.Texture2D,
MipSlice = 0,
};
_dynamicCubeMapDSV = new DepthStencilView(Device, depthTex, dsvDesc);
Util.ReleaseCom(ref depthTex);
// create the viewport for rendering the cubemap faces
_cubeMapViewPort = new Viewport(0, 0, CubeMapSize, CubeMapSize, 0, 1.0f);
}
private void GenerateIfRequired()
{
if (_renderTargetViews != null)
{
return;
}
// Create a view interface on the rendertarget to use on bind.
if (ArraySize > 1)
{
_renderTargetViews = new RenderTargetView[ArraySize];
for (var i = 0; i < ArraySize; i++)
{
var renderTargetViewDescription = new RenderTargetViewDescription();
if (GetTextureSampleDescription().Count > 1)
{
renderTargetViewDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampledArray;
renderTargetViewDescription.Texture2DMSArray.ArraySize = 1;
renderTargetViewDescription.Texture2DMSArray.FirstArraySlice = i;
}
else
{
renderTargetViewDescription.Dimension = RenderTargetViewDimension.Texture2DArray;
renderTargetViewDescription.Texture2DArray.ArraySize = 1;
renderTargetViewDescription.Texture2DArray.FirstArraySlice = i;
renderTargetViewDescription.Texture2DArray.MipSlice = 0;
}
_renderTargetViews[i] = new RenderTargetView(
GraphicsDevice._d3dDevice, GetTexture(),
renderTargetViewDescription);
}
}
else
{
_renderTargetViews = new[] { new RenderTargetView(GraphicsDevice._d3dDevice, GetTexture()) };
}
// If we don't need a depth buffer then we're done.
if (DepthStencilFormat == DepthFormat.None)
{
return;
}
// The depth stencil view's multisampling configuration must strictly
// match the texture's multisampling configuration. Ignore whatever parameters
// were provided and use the texture's configuration so that things are
// guarenteed to work.
var multisampleDesc = GetTextureSampleDescription();
// Create a descriptor for the depth/stencil buffer.
// Allocate a 2-D surface as the depth/stencil buffer.
// Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(DepthStencilFormat),
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = multisampleDesc,
BindFlags = BindFlags.DepthStencil,
}))
{
// Create the view for binding to the device.
_depthStencilView = new DepthStencilView(GraphicsDevice._d3dDevice, depthBuffer,
new DepthStencilViewDescription()
{
Format = SharpDXHelper.ToFormat(DepthStencilFormat),
Dimension = GetTextureSampleDescription().Count > 1 ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D
});
}
}
protected override void CreateDeviceDependentResources()
{
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref lightBuffer);
RemoveAndDispose(ref RTV);
RemoveAndDispose(ref SRV);
RemoveAndDispose(ref rsCullBack);
RemoveAndDispose(ref rsCullFront);
RemoveAndDispose(ref rsWireframe);
RemoveAndDispose(ref blendStateAdd);
RemoveAndDispose(ref depthLessThan);
RemoveAndDispose(ref depthGreaterThan);
RemoveAndDispose(ref depthDisabled);
RemoveAndDispose(ref perLightBuffer);
RemoveAndDispose(ref psAmbientLight);
RemoveAndDispose(ref psDirectionalLight);
RemoveAndDispose(ref psPointLight);
RemoveAndDispose(ref psSpotLight);
RemoveAndDispose(ref psDebugLight);
RemoveAndDispose(ref perLightBuffer);
// Retrieve our SharpDX.Direct3D11.Device1 instance
var device = this.DeviceManager.Direct3DDevice;
int width, height;
SampleDescription sampleDesc;
// Retrieve DSV from GBuffer and extract width/height
// then create a new read-only DSV
using (var depthTexture = gbuffer.DSV.ResourceAs <Texture2D>())
{
width = depthTexture.Description.Width;
height = depthTexture.Description.Height;
sampleDesc = depthTexture.Description.SampleDescription;
// Initialize read-only DSV
var dsvDesc = gbuffer.DSV.Description;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth | DepthStencilViewFlags.ReadOnlyStencil;
DSVReadonly = ToDispose(new DepthStencilView(device, depthTexture, dsvDesc));
}
// Check if GBuffer is multi-sampled
bool isMSAA = sampleDesc.Count > 1;
// Initialize the light render target
var texDesc = new Texture2DDescription();
texDesc.BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget;
texDesc.ArraySize = 1;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = width;
texDesc.Height = height;
texDesc.MipLevels = 1; // No mip levels
texDesc.SampleDescription = sampleDesc;
texDesc.Format = Format.R8G8B8A8_UNorm;
lightBuffer = ToDispose(new Texture2D(device, texDesc));
// Render Target View description
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Format = Format.R8G8B8A8_UNorm;
rtvDesc.Dimension = isMSAA ? RenderTargetViewDimension.Texture2DMultisampled : RenderTargetViewDimension.Texture2D;
rtvDesc.Texture2D.MipSlice = 0;
RTV = ToDispose(new RenderTargetView(device, lightBuffer, rtvDesc));
// SRV description for render targets
var srvDesc = new ShaderResourceViewDescription();
srvDesc.Format = Format.R8G8B8A8_UNorm;
srvDesc.Dimension = isMSAA ? SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampled : SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
SRV = ToDispose(new ShaderResourceView(device, lightBuffer, srvDesc));
// Initialize additive blend state (assuming single render target)
BlendStateDescription bsDesc = new BlendStateDescription();
bsDesc.RenderTarget[0].IsBlendEnabled = true;
bsDesc.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
bsDesc.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
bsDesc.RenderTarget[0].DestinationAlphaBlend = BlendOption.One;
bsDesc.RenderTarget[0].BlendOperation = BlendOperation.Add;
bsDesc.RenderTarget[0].SourceBlend = BlendOption.One;
bsDesc.RenderTarget[0].DestinationBlend = BlendOption.One;
bsDesc.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
blendStateAdd = ToDispose(new BlendState(device, bsDesc));
// Initialize rasterizer states
RasterizerStateDescription rsDesc = new RasterizerStateDescription();
rsDesc.FillMode = FillMode.Solid;
rsDesc.CullMode = CullMode.Back;
rsCullBack = ToDispose(new RasterizerState(device, rsDesc));
rsDesc.CullMode = CullMode.Front;
rsCullFront = ToDispose(new RasterizerState(device, rsDesc));
rsDesc.CullMode = CullMode.Front;
rsDesc.FillMode = FillMode.Wireframe;
rsWireframe = ToDispose(new RasterizerState(device, rsDesc));
// Initialize depth state
var dsDesc = new DepthStencilStateDescription();
dsDesc.IsStencilEnabled = false;
dsDesc.IsDepthEnabled = true;
// Less-than depth comparison
dsDesc.DepthComparison = Comparison.Less;
depthLessThan = ToDispose(new DepthStencilState(device, dsDesc));
// Greater-than depth comparison
dsDesc.DepthComparison = Comparison.Greater;
depthGreaterThan = ToDispose(new DepthStencilState(device, dsDesc));
// Depth/stencil testing disabled
dsDesc.IsDepthEnabled = false;
depthDisabled = ToDispose(new DepthStencilState(device, dsDesc));
// Buffer to light parameters
perLightBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <PerLight>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
if (isMSAA)
{
// Compile and create the vertex shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\LightsMS.hlsl", "VSLight", "vs_5_0"))
vertexShader = ToDispose(new VertexShader(device, bytecode));
// Compile pixel shaders
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\LightsMS.hlsl", "PSAmbientLight", "ps_5_0"))
psAmbientLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\LightsMS.hlsl", "PSDirectionalLight", "ps_5_0"))
psDirectionalLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\LightsMS.hlsl", "PSPointLight", "ps_5_0"))
psPointLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\LightsMS.hlsl", "PSSpotLight", "ps_5_0"))
psSpotLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\LightsMS.hlsl", "PSDebugLight", "ps_5_0"))
psDebugLight = ToDispose(new PixelShader(device, bytecode));
}
else
{
// Compile and create the vertex shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\Lights.hlsl", "VSLight", "vs_5_0"))
vertexShader = ToDispose(new VertexShader(device, bytecode));
// Compile pixel shaders
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\Lights.hlsl", "PSAmbientLight", "ps_5_0"))
psAmbientLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\Lights.hlsl", "PSDirectionalLight", "ps_5_0"))
psDirectionalLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\Lights.hlsl", "PSPointLight", "ps_5_0"))
psPointLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\Lights.hlsl", "PSSpotLight", "ps_5_0"))
psSpotLight = ToDispose(new PixelShader(device, bytecode));
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\Lights.hlsl", "PSDebugLight", "ps_5_0"))
psDebugLight = ToDispose(new PixelShader(device, bytecode));
}
}
/// <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);
//
// 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);
}
}
}
void CrateCubeMapResourses()
{
var textureDesc = new Texture2DDescription()
{
Format = Format.R8G8B8A8_UNorm,
Height = this.Size,
Width = this.Size,
ArraySize = 6,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube,
SampleDescription = new SampleDescription(1, 0),
MipLevels = 0,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None,
};
EnvMap = new Texture2D(_dx11Device, textureDesc);
EnvMap1 = new Texture2D(_dx11Device, textureDesc);
var descSRV = new ShaderResourceViewDescription();
descSRV.Format = textureDesc.Format;
descSRV.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube;
descSRV.TextureCube.MostDetailedMip = 0;
descSRV.TextureCube.MipLevels = -1;
EnvMapSRV = new ShaderResourceView(_dx11Device, EnvMap, descSRV);
EnvMapSRV1 = new ShaderResourceView(_dx11Device, EnvMap1, descSRV);
var descRTV = new RenderTargetViewDescription();
descRTV.Format = textureDesc.Format;
descRTV.Dimension = RenderTargetViewDimension.Texture2DArray;
descRTV.Texture2DArray.MipSlice = 0;
descRTV.Texture2DArray.FirstArraySlice = 0;
descRTV.Texture2DArray.ArraySize = 6;
EnvMapRTV = new RenderTargetView(_dx11Device, EnvMap, descRTV);
EnvMapRTV1 = new RenderTargetView(_dx11Device, EnvMap1, descRTV);
using (var depth = new Texture2D(_dx11Device, new Texture2DDescription
{
Format = Format.D32_Float,
BindFlags = BindFlags.DepthStencil,
Height = Size,
Width = Size,
Usage = ResourceUsage.Default,
SampleDescription = new SampleDescription(1, 0),
CpuAccessFlags = CpuAccessFlags.None,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.TextureCube,
ArraySize = 6
}))
{
var descDSV = new DepthStencilViewDescription();
descDSV.Format = depth.Description.Format;
descDSV.Dimension = DepthStencilViewDimension.Texture2DArray;
descDSV.Flags = DepthStencilViewFlags.None;
descDSV.Texture2DArray.MipSlice = 0;
descDSV.Texture2DArray.FirstArraySlice = 0;
descDSV.Texture2DArray.ArraySize = 6;
EnvMapDSV = new DepthStencilView(_dx11Device, depth, descDSV);
}
Viewport = new Viewport(0, 0, Size, Size);
}
public void CreateRenderTargetView(DescriptorHeap target, uint descriptorHeapSlot, Resource resource, ref RenderTargetViewDescription description)
{
Assert.Debug(target.Desc.Type == DescriptorHeap.Descriptor.ResourceDescriptorType.RenderTarget, "Can create render target views only on render target descriptor heaps.");
Assert.Debug(target.Desc.NumResourceDescriptors >= descriptorHeapSlot, "Descriptor heap does not have enought slots.");
target.SetAssociatedResource(descriptorHeapSlot, resource);
CreateRenderTargetViewImpl(target, descriptorHeapSlot, resource, ref description);
}
void CreateDeviceResources()
{
uint width = (uint) host.ActualWidth;
uint height = (uint) host.ActualHeight;
// If we don't have a device, need to create one now and all
// accompanying D3D resources.
CreateDevice();
DXGIFactory dxgiFactory = DXGIFactory.CreateFactory();
SwapChainDescription swapDesc = new SwapChainDescription();
swapDesc.BufferDescription.Width = width;
swapDesc.BufferDescription.Height = height;
swapDesc.BufferDescription.Format = Format.R8G8B8A8_UNORM;
swapDesc.BufferDescription.RefreshRate.Numerator = 60;
swapDesc.BufferDescription.RefreshRate.Denominator = 1;
swapDesc.SampleDescription.Count = 1;
swapDesc.SampleDescription.Quality = 0;
swapDesc.BufferUsage = UsageOption.RenderTargetOutput;
swapDesc.BufferCount = 1;
swapDesc.OutputWindowHandle = host.Handle;
swapDesc.Windowed = true;
swapChain = dxgiFactory.CreateSwapChain(
device, swapDesc);
// Create rasterizer state object
RasterizerDescription rsDesc = new RasterizerDescription();
rsDesc.AntialiasedLineEnable = false;
rsDesc.CullMode = CullMode.None;
rsDesc.DepthBias = 0;
rsDesc.DepthBiasClamp = 0;
rsDesc.DepthClipEnable = true;
rsDesc.FillMode = D3D10.FillMode.Solid;
rsDesc.FrontCounterClockwise = false; // Must be FALSE for 10on9
rsDesc.MultisampleEnable = false;
rsDesc.ScissorEnable = false;
rsDesc.SlopeScaledDepthBias = 0;
rasterizerState = device.CreateRasterizerState(
rsDesc);
device.RS.SetState(
rasterizerState
);
// If we don't have a D2D render target, need to create all of the resources
// required to render to one here.
// Ensure that nobody is holding onto one of the old resources
device.OM.SetRenderTargets(new RenderTargetView[] {null});
InitializeDepthStencil(width, height);
// Create views on the RT buffers and set them on the device
RenderTargetViewDescription renderDesc = new RenderTargetViewDescription();
renderDesc.Format = Format.R8G8B8A8_UNORM;
renderDesc.ViewDimension = RenderTargetViewDimension.Texture2D;
renderDesc.Texture2D.MipSlice = 0;
using (D3DResource spBackBufferResource = swapChain.GetBuffer<D3DResource>(0))
{
renderTargetView = device.CreateRenderTargetView(
spBackBufferResource,
renderDesc);
}
device.OM.SetRenderTargets(new RenderTargetView[] {renderTargetView}, depthStencilView);
SetViewport(width, height);
// Create a D2D render target which can draw into the surface in the swap chain
RenderTargetProperties props =
new RenderTargetProperties(
RenderTargetType.Default, new PixelFormat(Format.Unknown, AlphaMode.Premultiplied),
96, 96, RenderTargetUsage.None, FeatureLevel.Default);
// Allocate a offscreen D3D surface for D2D to render our 2D content into
Texture2DDescription tex2DDescription;
tex2DDescription.ArraySize = 1;
tex2DDescription.BindFlags = BindFlag.RenderTarget | BindFlag.ShaderResource;
tex2DDescription.CpuAccessFlags = CpuAccessFlag.Unspecified;
tex2DDescription.Format = Format.R8G8B8A8_UNORM;
tex2DDescription.Height = 4096;
tex2DDescription.Width = 512;
tex2DDescription.MipLevels = 1;
tex2DDescription.MiscFlags = 0;
tex2DDescription.SampleDescription.Count = 1;
tex2DDescription.SampleDescription.Quality = 0;
tex2DDescription.Usage = Usage.Default;
offscreenTexture = device.CreateTexture2D(tex2DDescription);
using (Surface dxgiSurface = offscreenTexture.GetDXGISurface())
{
// Create a D2D render target which can draw into our offscreen D3D surface
renderTarget = d2DFactory.CreateDxgiSurfaceRenderTarget(
dxgiSurface,
props);
}
PixelFormat alphaOnlyFormat = new PixelFormat(Format.A8_UNORM, AlphaMode.Premultiplied);
opacityRenderTarget = renderTarget.CreateCompatibleRenderTarget(CompatibleRenderTargetOptions.None,
alphaOnlyFormat);
// Load pixel shader
// Open precompiled vertex shader
// This file was compiled using DirectX's SDK Shader compilation tool:
// fxc.exe /T fx_4_0 /Fo SciFiText.fxo SciFiText.fx
shader = LoadResourceShader(device, "SciFiTextDemo.SciFiText.fxo");
// Obtain the technique
technique = shader.GetTechniqueByName("Render");
// Obtain the variables
worldMatrixVariable = shader.GetVariableByName("World").AsMatrix();
viewMatrixVariable = shader.GetVariableByName("View").AsMatrix();
projectionMarixVariable = shader.GetVariableByName("Projection").AsMatrix();
diffuseVariable = shader.GetVariableByName("txDiffuse").AsShaderResource();
// Create the input layout
PassDescription passDesc = new PassDescription();
passDesc = technique.GetPassByIndex(0).Description;
vertexLayout = device.CreateInputLayout(
inputLayoutDescriptions,
passDesc.InputAssemblerInputSignature,
passDesc.InputAssemblerInputSignatureSize
);
// Set the input layout
device.IA.SetInputLayout(
vertexLayout
);
IntPtr verticesDataPtr = Marshal.AllocHGlobal(Marshal.SizeOf(VertexArray.VerticesInstance));
Marshal.StructureToPtr(VertexArray.VerticesInstance, verticesDataPtr, true);
BufferDescription bd = new BufferDescription();
bd.Usage = Usage.Default;
bd.ByteWidth = (uint) Marshal.SizeOf(VertexArray.VerticesInstance);
bd.BindFlags = BindFlag.VertexBuffer;
bd.CpuAccessFlags = CpuAccessFlag.Unspecified;
bd.MiscFlags = ResourceMiscFlag.Undefined;
SubresourceData InitData = new SubresourceData()
{
SysMem = verticesDataPtr
};
vertexBuffer = device.CreateBuffer(
bd,
InitData
);
Marshal.FreeHGlobal(verticesDataPtr);
// Set vertex buffer
uint stride = (uint) Marshal.SizeOf(typeof (SimpleVertex));
uint offset = 0;
device.IA.SetVertexBuffers(
0,
new D3DBuffer[] {vertexBuffer},
new uint[] {stride},
new uint[] {offset}
);
IntPtr indicesDataPtr = Marshal.AllocHGlobal(Marshal.SizeOf(VertexArray.IndicesInstance));
Marshal.StructureToPtr(VertexArray.IndicesInstance, indicesDataPtr, true);
bd.Usage = Usage.Default;
bd.ByteWidth = (uint) Marshal.SizeOf(VertexArray.IndicesInstance);
bd.BindFlags = BindFlag.IndexBuffer;
bd.CpuAccessFlags = 0;
bd.MiscFlags = 0;
InitData.SysMem = indicesDataPtr;
facesIndexBuffer = device.CreateBuffer(
bd,
InitData
);
Marshal.FreeHGlobal(indicesDataPtr);
// Set primitive topology
device.IA.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
// Convert the D2D texture into a Shader Resource View
textureResourceView = device.CreateShaderResourceView(
offscreenTexture);
// Initialize the world matrices
worldMatrix = Matrix4x4F.Identity;
// Initialize the view matrix
Vector3F Eye = new Vector3F(0.0f, 0.0f, 13.0f);
Vector3F At = new Vector3F(0.0f, -3.5f, 45.0f);
Vector3F Up = new Vector3F(0.0f, 1.0f, 0.0f);
viewMatrix = Camera.MatrixLookAtLH(Eye, At, Up);
// Initialize the projection matrix
projectionMatrix = Camera.MatrixPerspectiveFovLH(
(float) Math.PI*0.1f,
width/(float) height,
0.1f,
100.0f);
// Update Variables that never change
viewMatrixVariable.Matrix = viewMatrix;
projectionMarixVariable.Matrix = projectionMatrix;
GradientStop[] gradientStops =
{
new GradientStop(0.0f, new ColorF(Colors.Yellow)),
new GradientStop(1.0f, new ColorF(Colors.Black))
};
GradientStopCollection spGradientStopCollection = renderTarget.CreateGradientStopCollection(
gradientStops,
Gamma.Gamma_22,
ExtendMode.Clamp);
// Create a linear gradient brush for text
textBrush = renderTarget.CreateLinearGradientBrush(
new LinearGradientBrushProperties(new Point2F(0, 0), new Point2F(0, -2048)),
spGradientStopCollection
);
}
protected abstract void CreateRenderTargetViewImpl(DescriptorHeap target, uint descriptorHeapSlot, Resource resource, ref RenderTargetViewDescription description);
private void CreateSliceViews(Device device, Format format)
{
RenderTargetViewDescription rtd = new RenderTargetViewDescription()
{
ArraySize = 1,
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = format
};
ShaderResourceViewDescription srvd = new ShaderResourceViewDescription()
{
ArraySize = 1,
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = format,
MipLevels = 1,
MostDetailedMip = 0
};
for (int i = 0; i < 6; i++)
{
rtd.FirstArraySlice = i;
srvd.FirstArraySlice = i;
this.FaceRTVs[i] = new RenderTargetView(device, this.Resource, rtd);
this.FaceSRVs[i] = new ShaderResourceView(device, this.Resource, srvd);
}
}
public void CreateDeviceDependentResources()
{
var device = Resources.D3DDevice;
MeshColor = ToDispose(new Texture2D(device, new Texture2DDescription()
{
Width = Resolution,
Height = Resolution,
ArraySize = 1,
CpuAccessFlags = CpuAccessFlags.Read,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None,
MipLevels = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0)
}));
MeshQualityAndTime = ToDispose(new Texture2D(device, new Texture2DDescription()
{
Width = Resolution,
Height = Resolution,
ArraySize = 1,
CpuAccessFlags = CpuAccessFlags.None,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = SharpDX.DXGI.Format.R16G16_Float,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None,
MipLevels = 1,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0)
}));
var colorRenderTargetViewDescription = new RenderTargetViewDescription()
{
Format = MeshColor.Description.Format,
Dimension = RenderTargetViewDimension.Texture2D
};
colorRenderTargetViewDescription.Texture2D.MipSlice = 0;
RenderColorView = ToDispose(new RenderTargetView(device, MeshColor, colorRenderTargetViewDescription));
var qualityAndTimeRenderTargetViewDescription = new RenderTargetViewDescription()
{
Format = MeshQualityAndTime.Description.Format,
Dimension = RenderTargetViewDimension.Texture2D
};
qualityAndTimeRenderTargetViewDescription.Texture2D.MipSlice = 0;
RenderQualityAndTimeView = ToDispose(new RenderTargetView(device, MeshQualityAndTime, qualityAndTimeRenderTargetViewDescription));
var colorShaderResourceViewDescription = new ShaderResourceViewDescription()
{
Format = MeshColor.Description.Format,
Dimension = ShaderResourceViewDimension.Texture2D
};
colorShaderResourceViewDescription.Texture2D.MipLevels = -1;
colorShaderResourceViewDescription.Texture2D.MostDetailedMip = 0;
ColorResourceView = ToDispose(new ShaderResourceView(device, MeshColor, colorShaderResourceViewDescription));
var qualityAndTimeShaderResourceViewDescription = new ShaderResourceViewDescription()
{
Format = MeshQualityAndTime.Description.Format,
Dimension = ShaderResourceViewDimension.Texture2D
};
qualityAndTimeShaderResourceViewDescription.Texture2D.MipLevels = -1;
qualityAndTimeShaderResourceViewDescription.Texture2D.MostDetailedMip = 0;
QualityAndTimeResourceView = ToDispose(new ShaderResourceView(device, MeshQualityAndTime, qualityAndTimeShaderResourceViewDescription));
}
protected override void CreateDeviceDependentResources()
{
RemoveAndDispose(ref DSSRV);
RemoveAndDispose(ref DSV);
RemoveAndDispose(ref DS0);
RTs.ForEach(rt => RemoveAndDispose(ref rt));
SRVs.ForEach(srv => RemoveAndDispose(ref srv));
RTVs.ForEach(rtv => RemoveAndDispose(ref rtv));
RTs.Clear();
SRVs.Clear();
RTVs.Clear();
var device = DeviceManager.Direct3DDevice;
bool isMSAA = sampleDescription.Count > 1;
// Render Target texture description
var texDesc = new Texture2DDescription();
texDesc.BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget;
texDesc.ArraySize = 1;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = width;
texDesc.Height = height;
texDesc.MipLevels = 1; // No mip levels
texDesc.SampleDescription = sampleDescription;
// Render Target View description
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Dimension = isMSAA ? RenderTargetViewDimension.Texture2DMultisampled : RenderTargetViewDimension.Texture2D;
rtvDesc.Texture2D.MipSlice = 0;
// SRV description for render targets
var srvDesc = new ShaderResourceViewDescription();
srvDesc.Dimension = isMSAA ? SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampled : SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
// Create Render Targets (with SRV and RTV)
foreach (var format in RTFormats)
{
texDesc.Format = format;
srvDesc.Format = format;
rtvDesc.Format = format;
RTs.Add(ToDispose(new Texture2D(device, texDesc)));
SRVs.Add(ToDispose(new ShaderResourceView(device, RTs.Last(), srvDesc)));
RTVs.Add(ToDispose(new RenderTargetView(device, RTs.Last(), rtvDesc)));
RTs.Last().DebugName = String.Format("RT{0}_{1}", RTs.Count, format);
SRVs.Last().DebugName = String.Format("SRV{0}_{1}", RTs.Count, format);
RTVs.Last().DebugName = String.Format("RTV{0}_{1}", RTs.Count, format);
}
// Create Depth/Stencil
texDesc.BindFlags = BindFlags.ShaderResource | BindFlags.DepthStencil;
texDesc.Format = SharpDX.DXGI.Format.R32G8X24_Typeless; // typeless so we can use as shader resource
DS0 = ToDispose(new Texture2D(device, texDesc));
DS0.DebugName = "DS0";
srvDesc.Format = SharpDX.DXGI.Format.R32_Float_X8X24_Typeless;
DSSRV = ToDispose(new ShaderResourceView(device, DS0, srvDesc));
DSSRV.DebugName = "DSSRV-DepthStencil";
// Depth Stencil View
var dsvDesc = new DepthStencilViewDescription();
dsvDesc.Flags = DepthStencilViewFlags.None;
dsvDesc.Dimension = isMSAA ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D;
dsvDesc.Format = SharpDX.DXGI.Format.D32_Float_S8X24_UInt;
dsvDesc.Texture2D.MipSlice = 0;
DSV = ToDispose(new DepthStencilView(device, DS0, dsvDesc));
DSV.DebugName = "DSV0";
}
/// <summary>Gets the render target view.</summary>
/// <param name="viewType">Type of the view.</param>
/// <param name="arrayOrDepthSlice">The array original depth slice.</param>
/// <param name="mipIndex">Index of the mip.</param>
/// <returns>TextureView.</returns>
/// <exception cref="System.NotSupportedException">ViewSlice.MipBand is not supported for render targets</exception>
internal override TextureView GetRenderTargetView(ViewType viewType, int arrayOrDepthSlice, int mipIndex)
{
if ((this.Description.BindFlags & BindFlags.RenderTarget) == 0)
{
return(null);
}
if (viewType == ViewType.MipBand)
{
throw new NotSupportedException("ViewSlice.MipBand is not supported for render targets");
}
int arrayCount;
int mipCount;
GetViewSliceBounds(viewType, ref arrayOrDepthSlice, ref mipIndex, out arrayCount, out mipCount);
var rtvIndex = GetViewIndex(viewType, arrayOrDepthSlice, mipIndex);
lock (this.renderTargetViews)
{
var rtv = this.renderTargetViews[rtvIndex];
// Creates the shader resource view
if (rtv == null)
{
// Create the render target view
var rtvDescription = new RenderTargetViewDescription()
{
Format = this.Description.Format
};
if (this.Description.ArraySize > 1)
{
rtvDescription.Dimension = this.Description.SampleDescription.Count > 1 ? RenderTargetViewDimension.Texture2DMultisampledArray : RenderTargetViewDimension.Texture2DArray;
if (this.Description.SampleDescription.Count > 1)
{
rtvDescription.Texture2DMSArray.ArraySize = arrayCount;
rtvDescription.Texture2DMSArray.FirstArraySlice = arrayOrDepthSlice;
}
else
{
rtvDescription.Texture2DArray.ArraySize = arrayCount;
rtvDescription.Texture2DArray.FirstArraySlice = arrayOrDepthSlice;
rtvDescription.Texture2DArray.MipSlice = mipIndex;
}
}
else
{
rtvDescription.Dimension = this.Description.SampleDescription.Count > 1 ? RenderTargetViewDimension.Texture2DMultisampled : RenderTargetViewDimension.Texture2D;
if (this.Description.SampleDescription.Count <= 1)
{
rtvDescription.Texture2D.MipSlice = mipIndex;
}
}
rtv = new TextureView(this, new RenderTargetView(GraphicsDevice, Resource, rtvDescription));
this.renderTargetViews[rtvIndex] = ToDispose(rtv);
}
return(rtv);
}
}
private void LoadArraySlices(bool rtvFlag, bool srvFlag, bool dsvFlag)
{
var arraySize = NativeTexture.Description.ArraySize;
var cubemap = NativeTexture.Description.OptionFlags.HasFlag(ResourceOptionFlags.TextureCube);
if (cubemap)
{
if (rtvFlag)
{
RtvArraySlices.Add(new RenderTargetView(Renderer.Device, _nativeTexture));
}
if (srvFlag)
{
SrvArraySlices.Add(new ShaderResourceView(Renderer.Device, _nativeTexture));
}
if (dsvFlag)
{
throw new ArgumentException();
}
return;
}
if (rtvFlag)
{
var format = NativeTexture.Description.Format;
switch (format)
{
case Format.R32_Typeless:
format = Format.R32_Float;
break;
case Format.R24G8_Typeless:
case Format.R24_UNorm_X8_Typeless:
format = Format.R24_UNorm_X8_Typeless;
break;
}
for (int i = 0; i < arraySize; i++)
{
var rtvDesc = new RenderTargetViewDescription {
Format = format
};
if (arraySize == 1)
{
rtvDesc.Dimension = RenderTargetViewDimension.Texture2D;
rtvDesc.Texture2D.MipSlice = 0;
}
else
{
rtvDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
rtvDesc.Texture2DArray.ArraySize = 1;
rtvDesc.Texture2DArray.FirstArraySlice = i;
rtvDesc.Texture2DArray.MipSlice = 0;
}
var rtv = new RenderTargetView(Renderer.Device, NativeTexture, rtvDesc)
{
Tag = this, DebugName = Name
};
RtvArraySlices.Add(rtv);
}
}
if (srvFlag)
{
var format = NativeTexture.Description.Format;
switch (format)
{
case Format.R32_Typeless:
format = Format.R32_Float;
break;
case Format.R24_UNorm_X8_Typeless:
case Format.R24G8_Typeless:
format = Format.R24_UNorm_X8_Typeless;
break;
}
for (int i = 0; i < arraySize; i++)
{
var srvDesc = new ShaderResourceViewDescription {
Format = format
};
if (arraySize == 1)
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
}
else
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2DArray;
srvDesc.Texture2DArray.ArraySize = 1;
srvDesc.Texture2DArray.FirstArraySlice = i;
srvDesc.Texture2DArray.MipLevels = -1;
srvDesc.Texture2DArray.MostDetailedMip = 0;
}
var srv = new ShaderResourceView(Renderer.Device, NativeTexture, srvDesc)
{
Tag = this, DebugName = Name
};
SrvArraySlices.Add(srv);
}
}
if (dsvFlag)
{
for (int i = 0; i < arraySize; i++)
{
var format = NativeTexture.Description.Format;
switch (format)
{
case Format.R32_Typeless:
format = Format.D32_Float;
break;
case Format.R24G8_Typeless:
case Format.R24_UNorm_X8_Typeless:
format = Format.D24_UNorm_S8_UInt;
break;
}
var dsvDesc = new DepthStencilViewDescription {
Format = format
};
if (arraySize == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DArray;
dsvDesc.Texture2DArray.ArraySize = 1;
dsvDesc.Texture2DArray.FirstArraySlice = i;
dsvDesc.Texture2DArray.MipSlice = 0;
}
var dsv = new DepthStencilView(Renderer.Device, NativeTexture, dsvDesc)
{
Tag = this, DebugName = Name
};
DsvArraySlices.Add(dsv);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderTargetCube"/> class.
/// </summary>
/// <param name="graphicsDevice">The graphics device.</param>
/// <param name="size">The width and height of a texture cube face in pixels.</param>
/// <param name="mipMap"><see langword="true"/> to generate a full mipmap chain; otherwise <see langword="false"/>.</param>
/// <param name="preferredFormat">The preferred format of the surface.</param>
/// <param name="preferredDepthFormat">The preferred format of the depth-stencil buffer.</param>
/// <param name="preferredMultiSampleCount">The preferred number of multisample locations.</param>
/// <param name="usage">The usage mode of the render target.</param>
public RenderTargetCube(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
: base(graphicsDevice, size, mipMap, preferredFormat, true)
{
DepthStencilFormat = preferredDepthFormat;
MultiSampleCount = preferredMultiSampleCount;
RenderTargetUsage = usage;
#if DIRECTX
// Create one render target view per cube map face.
_renderTargetViews = new RenderTargetView[6];
for (int i = 0; i < _renderTargetViews.Length; i++)
{
var renderTargetViewDescription = new RenderTargetViewDescription
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = SharpDXHelper.ToFormat(preferredFormat),
Texture2DArray =
{
ArraySize = 1,
FirstArraySlice = i,
MipSlice = 0
}
};
_renderTargetViews[i] = new RenderTargetView(graphicsDevice._d3dDevice, GetTexture(), renderTargetViewDescription);
}
// If we don't need a depth buffer then we're done.
if (preferredDepthFormat == DepthFormat.None)
{
return;
}
var sampleDescription = new SampleDescription(1, 0);
if (preferredMultiSampleCount > 1)
{
sampleDescription.Count = preferredMultiSampleCount;
sampleDescription.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
var depthStencilDescription = new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
ArraySize = 1,
MipLevels = 1,
Width = size,
Height = size,
SampleDescription = sampleDescription,
BindFlags = BindFlags.DepthStencil,
};
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, depthStencilDescription))
{
var depthStencilViewDescription = new DepthStencilViewDescription
{
Dimension = DepthStencilViewDimension.Texture2D,
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
};
_depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, depthStencilViewDescription);
}
#else
throw new NotImplementedException();
#endif
}
private void EnsureOutputBuffers()
{
if (SharedTexture == null ||
SharedTexture.Description.Width != ClientWidth ||
SharedTexture.Description.Height != ClientHeight)
{
if (SharedTexture != null)
{
SharedTexture.Dispose();
SharedTexture = null;
}
var colordesc = new Texture2DDescription
{
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.B8G8R8A8_UNorm,
Width = ClientWidth,
Height = ClientHeight,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.Shared, // needed for D3DImage
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
};
if (_dxRenderView != null)
{
_dxRenderView.Dispose();
_dxRenderView = null;
}
SharedTexture = new Texture2D(_dxDevice, colordesc);
var descRtv = new RenderTargetViewDescription();
if (colordesc.SampleDescription.Count > 1)
descRtv.Dimension = RenderTargetViewDimension.Texture2DMultisampled;
else
descRtv.Dimension = RenderTargetViewDimension.Texture2D;
_dxRenderView = new RenderTargetView(_dxDevice, SharedTexture, descRtv);
}
if (DepthTexture == null ||
DepthTexture.Description.Width != ClientWidth ||
DepthTexture.Description.Height != ClientHeight)
{
if (DepthTexture != null)
{
DepthTexture.Dispose();
DepthTexture = null;
}
var depthDesc = new Texture2DDescription
{
BindFlags = BindFlags.DepthStencil,
Format = Format.D32_Float_S8X24_UInt,
Width = ClientWidth,
Height = ClientHeight,
MipLevels = 1,
SampleDescription = new SampleDescription(1, 0), // not using multisampling
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
};
// create depth texture
DepthTexture = new Texture2D(_dxDevice, depthDesc);
if (_dxDepthStencilView != null)
{
_dxDepthStencilView.Dispose();
_dxDepthStencilView = null;
}
var descDsv = new DepthStencilViewDescription();
descDsv.Format = depthDesc.Format;
if (depthDesc.SampleDescription.Count > 1)
{
descDsv.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
}
else
{
descDsv.Dimension = DepthStencilViewDimension.Texture2D;
}
descDsv.MipSlice = 0;
// create depth/stencil view
_dxDepthStencilView = new DepthStencilView(_dxDevice, DepthTexture, descDsv);
}
}
public D3D11Framebuffer(Device device, ref FramebufferDescription description)
: base(description.DepthTarget, description.ColorTargets)
{
if (description.DepthTarget != null)
{
D3D11Texture d3dDepthTarget = Util.AssertSubtype <Texture, D3D11Texture>(description.DepthTarget.Value.Target);
DepthStencilViewDescription dsvDesc = new DepthStencilViewDescription()
{
Format = D3D11Formats.GetDepthFormat(d3dDepthTarget.Format),
};
if (d3dDepthTarget.ArrayLayers == 1)
{
if (d3dDepthTarget.SampleCount == TextureSampleCount.Count1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
}
}
else
{
if (d3dDepthTarget.SampleCount == TextureSampleCount.Count1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DArray;
dsvDesc.Texture2DArray.FirstArraySlice = (int)description.DepthTarget.Value.ArrayLayer;
dsvDesc.Texture2DArray.ArraySize = 1;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampledArray;
dsvDesc.Texture2DMSArray.FirstArraySlice = (int)description.DepthTarget.Value.ArrayLayer;
dsvDesc.Texture2DMSArray.ArraySize = 1;
}
}
DepthStencilView = new DepthStencilView(device, d3dDepthTarget.DeviceTexture, dsvDesc);
}
if (description.ColorTargets != null && description.ColorTargets.Length > 0)
{
RenderTargetViews = new RenderTargetView[description.ColorTargets.Length];
for (int i = 0; i < RenderTargetViews.Length; i++)
{
D3D11Texture d3dColorTarget = Util.AssertSubtype <Texture, D3D11Texture>(description.ColorTargets[i].Target);
RenderTargetViewDescription rtvDesc = new RenderTargetViewDescription
{
Format = D3D11Formats.ToDxgiFormat(d3dColorTarget.Format, false),
};
if (d3dColorTarget.ArrayLayers == 1)
{
if (d3dColorTarget.SampleCount == TextureSampleCount.Count1)
{
rtvDesc.Dimension = RenderTargetViewDimension.Texture2D;
}
else
{
rtvDesc.Dimension = RenderTargetViewDimension.Texture2DMultisampled;
}
}
else
{
if (d3dColorTarget.SampleCount == TextureSampleCount.Count1)
{
rtvDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
rtvDesc.Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource
{
ArraySize = 1,
FirstArraySlice = (int)description.ColorTargets[i].ArrayLayer
};
}
else
{
rtvDesc.Dimension = RenderTargetViewDimension.Texture2DMultisampledArray;
rtvDesc.Texture2DMSArray = new RenderTargetViewDescription.Texture2DMultisampledArrayResource
{
ArraySize = 1,
FirstArraySlice = (int)description.ColorTargets[i].ArrayLayer
};
}
}
RenderTargetViews[i] = new RenderTargetView(device, d3dColorTarget.DeviceTexture, rtvDesc);
}
}
else
{
RenderTargetViews = Array.Empty <RenderTargetView>();
}
}
public bool Initialize(Device device, int _width, int _height)
{
try
{
// Initialize and set up the render target description.
var textureDesc = new Texture2DDescription()
{
Width = _width,
Height = _height,
MipLevels = 1,
ArraySize = 1,
Format = Format.R32G32B32A32_Float,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
/*
var exttextureDesc = new Texture2DDescription()
{
Width = _width,
Height = _height,
MipLevels = 1,
ArraySize = 1,
Format = Format.R8G8B8A8_UNorm,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Staging,
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Write | CpuAccessFlags.Read,
OptionFlags = ResourceOptionFlags.Shared,
};
* */
// Create the render target texture.
texRenderTargetTexture = new Texture2D(device, textureDesc);
//extRenderTargetTexture = new Texture2D(device, exttextureDesc);
// Initialize and setup the render target view
var renderTargetViewDesc = new RenderTargetViewDescription()
{
Format = textureDesc.Format,
Dimension = RenderTargetViewDimension.Texture2D,
};
renderTargetViewDesc.Texture2D.MipSlice = 0;
// Create the render target view.
texRenderTargetView = new RenderTargetView(device, texRenderTargetTexture, renderTargetViewDesc);
texRenderTargetView.DebugName = "text";
// Initialize and setup the shader resource view
var shaderResourceViewDesc = new ShaderResourceViewDescription()
{
Format = textureDesc.Format,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceViewDesc.Texture2D.MipLevels = 1;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
// Create the shader resource view.
ShaderResourceView = new ShaderResourceView(device, texRenderTargetTexture, shaderResourceViewDesc);
return true;
}
catch(Exception ex)
{
return false;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderTargetCube"/> class.
/// </summary>
/// <param name="graphicsDevice">The graphics device.</param>
/// <param name="size">The width and height of a texture cube face in pixels.</param>
/// <param name="mipMap"><see langword="true"/> to generate a full mipmap chain; otherwise <see langword="false"/>.</param>
/// <param name="preferredFormat">The preferred format of the surface.</param>
/// <param name="preferredDepthFormat">The preferred format of the depth-stencil buffer.</param>
/// <param name="preferredMultiSampleCount">The preferred number of multisample locations.</param>
/// <param name="usage">The usage mode of the render target.</param>
public RenderTargetCube(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
: base(graphicsDevice, size, mipMap, preferredFormat, true)
{
DepthStencilFormat = preferredDepthFormat;
MultiSampleCount = preferredMultiSampleCount;
RenderTargetUsage = usage;
#if DIRECTX
// Create one render target view per cube map face.
_renderTargetViews = new RenderTargetView[6];
for (int i = 0; i < _renderTargetViews.Length; i++)
{
var renderTargetViewDescription = new RenderTargetViewDescription
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = SharpDXHelper.ToFormat(preferredFormat),
Texture2DArray =
{
ArraySize = 1,
FirstArraySlice = i,
MipSlice = 0
}
};
_renderTargetViews[i] = new RenderTargetView(graphicsDevice._d3dDevice, _texture, renderTargetViewDescription);
}
// If we don't need a depth buffer then we're done.
if (preferredDepthFormat == DepthFormat.None)
return;
var sampleDescription = new SampleDescription(1, 0);
if (preferredMultiSampleCount > 1)
{
sampleDescription.Count = preferredMultiSampleCount;
sampleDescription.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
var depthStencilDescription = new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
ArraySize = 1,
MipLevels = 1,
Width = size,
Height = size,
SampleDescription = sampleDescription,
BindFlags = BindFlags.DepthStencil,
};
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, depthStencilDescription))
{
var depthStencilViewDescription = new DepthStencilViewDescription
{
Dimension = DepthStencilViewDimension.Texture2D,
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
};
_depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, depthStencilViewDescription);
}
#else
throw new NotImplementedException();
#endif
}
protected override void CreateDeviceDependentResources()
{
RemoveAndDispose(ref DSSRV);
RemoveAndDispose(ref DSV);
RemoveAndDispose(ref DS0);
RTs.ForEach(rt => RemoveAndDispose(ref rt));
SRVs.ForEach(srv => RemoveAndDispose(ref srv));
RTVs.ForEach(rtv => RemoveAndDispose(ref rtv));
RTs.Clear();
SRVs.Clear();
RTVs.Clear();
var device = DeviceManager.Direct3DDevice;
bool isMSAA = sampleDescription.Count > 1;
// Render Target texture description
var texDesc = new Texture2DDescription();
texDesc.BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget;
texDesc.ArraySize = 1;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Usage = ResourceUsage.Default;
texDesc.Width = width;
texDesc.Height = height;
texDesc.MipLevels = 1; // No mip levels
texDesc.SampleDescription = sampleDescription;
// Render Target View description
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Dimension = isMSAA ? RenderTargetViewDimension.Texture2DMultisampled : RenderTargetViewDimension.Texture2D;
rtvDesc.Texture2D.MipSlice = 0;
// SRV description for render targets
var srvDesc = new ShaderResourceViewDescription();
srvDesc.Dimension = isMSAA ? SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampled : SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
// Create Render Targets (with SRV and RTV)
foreach (var format in RTFormats)
{
texDesc.Format = format;
srvDesc.Format = format;
rtvDesc.Format = format;
RTs.Add(ToDispose(new Texture2D(device, texDesc)));
SRVs.Add(ToDispose(new ShaderResourceView(device, RTs.Last(), srvDesc)));
RTVs.Add(ToDispose(new RenderTargetView(device, RTs.Last(), rtvDesc)));
RTs.Last().DebugName = String.Format("RT{0}_{1}", RTs.Count, format);
SRVs.Last().DebugName = String.Format("SRV{0}_{1}", RTs.Count, format);
RTVs.Last().DebugName = String.Format("RTV{0}_{1}", RTs.Count, format);
}
// Create Depth/Stencil
texDesc.BindFlags = BindFlags.ShaderResource | BindFlags.DepthStencil;
texDesc.Format = SharpDX.DXGI.Format.R32G8X24_Typeless; // typeless so we can use as shader resource
DS0 = ToDispose(new Texture2D(device, texDesc));
DS0.DebugName = "DS0";
srvDesc.Format = SharpDX.DXGI.Format.R32_Float_X8X24_Typeless;
DSSRV = ToDispose(new ShaderResourceView(device, DS0, srvDesc));
DSSRV.DebugName = "DSSRV-DepthStencil";
// Depth Stencil View
var dsvDesc = new DepthStencilViewDescription();
dsvDesc.Flags = DepthStencilViewFlags.None;
dsvDesc.Dimension = isMSAA ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D;
dsvDesc.Format = SharpDX.DXGI.Format.D32_Float_S8X24_UInt;
dsvDesc.Texture2D.MipSlice = 0;
DSV = ToDispose(new DepthStencilView(device, DS0, dsvDesc));
DSV.DebugName = "DSV0";
}
public void Initialize()
{
LoadSky(0);
Texture2DDescription descTex = new Texture2DDescription();
descTex.ArraySize = 6;
descTex.Width = Size;
descTex.Height = Size;
descTex.Usage = ResourceUsage.Default;
descTex.CpuAccessFlags = CpuAccessFlags.None;
descTex.Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm;
descTex.SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0);
descTex.MipLevels = MipLevel;
descTex.BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget;
descTex.OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube;
//Create the texture and shader view
CubeTexture = new Texture2D(ModelViewer.Program.device, descTex);
CubeSRV = new ShaderResourceView(ModelViewer.Program.device, CubeTexture);
RenderTargetViewDescription RTVD = new RenderTargetViewDescription();
RTVD.Format = descTex.Format;
RTVD.Dimension = RenderTargetViewDimension.Texture2DArray;
RTVD.Texture2DArray.FirstArraySlice = 0;
RTVD.Texture2DArray.ArraySize = 1;
RTVD.Texture2DArray.MipSlice = 0;
CubeRenderTarget = new RenderTargetView[6];
for (int i = 0; i < 6; i++)
{
RTVD.Texture2DArray.FirstArraySlice = i;
CubeRenderTarget[i] = new RenderTargetView(ModelViewer.Program.device, CubeTexture, RTVD);
}
SamplerStateDescription a = new SamplerStateDescription();
a.AddressU = TextureAddressMode.Clamp;
a.AddressV = TextureAddressMode.Clamp;
a.AddressW = TextureAddressMode.Clamp;
a.Filter = Filter.MinMagMipLinear;
SSWrapMipLinear = new SamplerState(ModelViewer.Program.device, a);
MContains = new MeshContainer();
MContains.BytesPerVertex = 20;
MContains.FaceCount = 12;
MContains.VertexsCount = 24;
Vector3 vExtents = new Vector3(500, 500, 500);
var vertices = new DataStream(MContains.BytesPerVertex * MContains.VertexsCount, true, true);
//Back
vertices.Write(new Vector3(-vExtents.X, -vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(1, 1));
vertices.Write(new Vector3(-vExtents.X, vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(1, 0));
vertices.Write(new Vector3(vExtents.X, vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(0, 0));
vertices.Write(new Vector3(vExtents.X, -vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(0, 1));
//Front
vertices.Write(new Vector3(vExtents.X, -vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(1, 1));
vertices.Write(new Vector3(vExtents.X, vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(1, 0));
vertices.Write(new Vector3(-vExtents.X, vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(0, 0));
vertices.Write(new Vector3(-vExtents.X, -vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(0, 1));
//Bottom
vertices.Write(new Vector3(-vExtents.X, -vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(0, 0));
vertices.Write(new Vector3(-vExtents.X, -vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(0, 1));
vertices.Write(new Vector3(vExtents.X, -vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(1, 1));
vertices.Write(new Vector3(vExtents.X, -vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(1, 0));
//Top
vertices.Write(new Vector3(vExtents.X, vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(1, 1));
vertices.Write(new Vector3(vExtents.X, vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(1, 0));
vertices.Write(new Vector3(-vExtents.X, vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(0, 0));
vertices.Write(new Vector3(-vExtents.X, vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(0, 1));
//Left
vertices.Write(new Vector3(-vExtents.X, vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(1, 0));
vertices.Write(new Vector3(-vExtents.X, vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(0, 0));
vertices.Write(new Vector3(-vExtents.X, -vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(0, 1));
vertices.Write(new Vector3(-vExtents.X, -vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(1, 1));
//Right
vertices.Write(new Vector3(vExtents.X, -vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(0, 1));
vertices.Write(new Vector3(vExtents.X, -vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(1, 1));
vertices.Write(new Vector3(vExtents.X, vExtents.Y, vExtents.Z));
vertices.Write(new Vector2(1, 0));
vertices.Write(new Vector3(vExtents.X, vExtents.Y, -vExtents.Z));
vertices.Write(new Vector2(0, 0));
vertices.Position = 0;
InputElement[] elements11 = new[] {
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0) ,
new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 12, 0)};
MContains.Vertexs = new Buffer(ModelViewer.Program.device, vertices, MContains.BytesPerVertex * MContains.VertexsCount, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
var indices = new DataStream(4 * MContains.FaceCount * 3, true, true);
for (int x = 0; x < 6; x++)
{
indices.Write((int)(x * 4 + 0));
indices.Write((int)(x * 4 + 1));
indices.Write((int)(x * 4 + 2));
indices.Write((int)(x * 4 + 2));
indices.Write((int)(x * 4 + 3));
indices.Write((int)(x * 4 + 0));
}
indices.Position = 0;
MContains.Indices = new Buffer(ModelViewer.Program.device, indices, 4 * MContains.FaceCount * 3, ResourceUsage.Default, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
MContains.binding = new VertexBufferBinding(MContains.Vertexs, MContains.BytesPerVertex, 0);
EEEM = ContentManager.LoadEffect("Content/Shaders/SkyBox", elements11);
// Подготовка константного буффера
BufferDescription bd = new BufferDescription();
bd.SizeInBytes = Marshal.SizeOf(typeof(SkyShaderConstants));
bd.Usage = ResourceUsage.Dynamic;
bd.BindFlags = BindFlags.ConstantBuffer;
bd.CpuAccessFlags = CpuAccessFlags.Write;
bd.OptionFlags = ResourceOptionFlags.None;
bd.StructureByteStride = 0;
SkyConstantsBuffer = new Buffer(ModelViewer.Program.device, bd);
SSC = new SkyShaderConstants();
}
// has 6 rtv subresources and mipLevels * 6 srv/uav subresources
internal static RwTexId CreateCubemap(int resolution, Format resourceFormat, string debugName = null)
{
int mipLevels = 1;
while ((resolution >> mipLevels) > 0)
{
++mipLevels;
}
var desc = new Texture2DDescription
{
ArraySize = 6,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget | BindFlags.UnorderedAccess,
CpuAccessFlags = CpuAccessFlags.None,
Format = resourceFormat,
MipLevels = mipLevels,
Usage = ResourceUsage.Default,
Width = resolution,
Height = resolution,
OptionFlags = ResourceOptionFlags.TextureCube,
SampleDescription = new SampleDescription(1, 0)
};
var handle = new RwTexId { Index = Textures.Allocate() };
Textures.Data[handle.Index] = new MyRwTextureInfo { Description2D = desc };
Textures.Data[handle.Index].Resource = new Texture2D(MyRender11.Device, desc);
var res = Textures.Data[handle.Index].Resource;
Srvs[handle] = new MySrvInfo { Description = null, View = new ShaderResourceView(MyRender11.Device, Textures.Data[handle.Index].Resource) };
Index.Add(handle);
var srvDesc = new ShaderResourceViewDescription();
srvDesc.Dimension = ShaderResourceViewDimension.Texture2DArray;
srvDesc.Format = resourceFormat;
srvDesc.Texture2DArray.MipLevels = 1;
srvDesc.Texture2DArray.ArraySize = 1;
var uavDesc = new UnorderedAccessViewDescription();
uavDesc.Dimension = UnorderedAccessViewDimension.Texture2DArray;
uavDesc.Format = resourceFormat;
uavDesc.Texture2DArray.ArraySize = 1;
for (int m = 0; m < mipLevels; ++m)
{
for (int i = 0; i < 6; i++)
{
var subresource = i * mipLevels + m;
srvDesc.Texture2DArray.FirstArraySlice = i;
srvDesc.Texture2DArray.MostDetailedMip = m;
SubresourceSrvs[new MySubresourceId { Id = handle, Subresource = subresource }] = new MySrvInfo
{
Description = srvDesc,
View = new ShaderResourceView(MyRender11.Device, res, srvDesc)
};
uavDesc.Texture2DArray.FirstArraySlice = i;
uavDesc.Texture2DArray.MipSlice = m;
SubresourceUavs[new MySubresourceId { Id = handle, Subresource = subresource }] = new MyUavInfo
{
Description = uavDesc,
View = new UnorderedAccessView(MyRender11.Device, res, uavDesc)
};
}
}
var rtvDesc = new RenderTargetViewDescription();
rtvDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
rtvDesc.Format = resourceFormat;
for (int i = 0; i < 6; i++)
{
rtvDesc.Texture2DArray.MipSlice = 0;
rtvDesc.Texture2DArray.FirstArraySlice = i;
rtvDesc.Texture2DArray.ArraySize = 1;
SubresourceRtvs[new MySubresourceId { Id = handle, Subresource = i }] = new MyRtvInfo
{
Description = rtvDesc,
View = new RenderTargetView(MyRender11.Device, res, rtvDesc)
};
}
return handle;
}
protected virtual void CreateSizeDependentResources(object sender, RenderEventArgs renderBase)
{
var d3dDevice = deviceManager.DeviceDirect3D;
var d3dContext = deviceManager.ContextDirect3D;
var d2dContext = deviceManager.ContextDirect2D;
d2dContext.Target = null;
RemoveAndDispose(ref renderTargetView);
RemoveAndDispose(ref depthStencilView);
RemoveAndDispose(ref bitmapTarget);
RemoveAndDispose(ref backBuffer);
// If the swap chain already exists, resize it.
if (swapChain != null)
{
swapChain.ResizeBuffers(2, Width, Height, SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.DXGI.SwapChainFlags.None);
}
// Otherwise, create a new one.
else
{
// SwapChain description
var desc = CreateSwapChainDescription();
// Once the desired swap chain description is configured, it must be created on the
// same adapter as our D3D Device
// First, retrieve the underlying DXGI Device from the D3D Device. Creates the swap
// chain
using (var dxgiDevice2 = d3dDevice.QueryInterface <SharpDX.DXGI.Device2>())
using (var dxgiAdapter = dxgiDevice2.Adapter)
using (var dxgiFactory2 = dxgiAdapter.GetParent <SharpDX.DXGI.Factory2>())
{
swapChain = ToDispose(CreateSwapChain(dxgiFactory2, d3dDevice, desc));
swapChain.ResizeBuffers(2, deviceManager.Settings.ScreenWidth,
deviceManager.Settings.ScreenHeight, desc.Format, desc.Flags);
// Ensure that DXGI does not queue more than one frame at a time. This both
// reduces latency and ensures that the application will only render after each
// VSync, minimizing power consumption.
dxgiDevice2.MaximumFrameLatency = 1;
}
}
// Obtain the backbuffer for this window which will be the final 3D rendertarget.
backBuffer = ToDispose(SharpDX.Direct3D11.Texture2D.FromSwapChain <SharpDX.Direct3D11.Texture2D>(swapChain, 0));
{
RenderTargetViewDescription rtvDescription = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
MipSlice = 0, FirstArraySlice = 0, ArraySize = 1
}
};
// Create a view interface on the rendertarget to use on bind.
renderTargetView = ToDispose(new SharpDX.Direct3D11.RenderTargetView(d3dDevice, BackBuffer, rtvDescription));
if (IsStereoEnabled)
{
RenderTargetViewDescription rtvDescriptionRight = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
MipSlice = 0, FirstArraySlice = 1, ArraySize = 1
}
};
renderTargetViewRight = ToDispose(new SharpDX.Direct3D11.RenderTargetView(d3dDevice, BackBuffer, rtvDescriptionRight));
}
// Cache the rendertarget dimensions in our helper class for convenient use.
var backBufferDesc = BackBuffer.Description;
RenderTargetBounds = new Rectangle(0, 0, backBufferDesc.Width, backBufferDesc.Height);
}
// Create a descriptor for the depth/stencil buffer. Allocate a 2-D surface as the
// depth/stencil buffer. Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(d3dDevice, new SharpDX.Direct3D11.Texture2DDescription()
{
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
ArraySize = 1,
MipLevels = 1,
Width = (int)RenderTargetSize.Width,
Height = (int)RenderTargetSize.Height,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil,
}))
depthStencilView = ToDispose(new SharpDX.Direct3D11.DepthStencilView(d3dDevice, depthBuffer,
new SharpDX.Direct3D11.DepthStencilViewDescription()
{
Dimension = SharpDX.Direct3D11.DepthStencilViewDimension.Texture2D
}));
// Create a viewport descriptor of the full window size.
var viewport = new SharpDX.ViewportF((float)RenderTargetBounds.X, (float)RenderTargetBounds.Y, (float)RenderTargetBounds.Width, (float)RenderTargetBounds.Height, 0.0f, 1.0f);
// Set the current viewport using the descriptor.
d3dContext.Rasterizer.SetViewport(viewport);
// Now we set up the Direct2D render target bitmap linked to the swapchain. Whenever we
// render to this bitmap, it will be directly rendered to the swapchain associated with
// the window.
var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties1(
new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied),
deviceManager.Dpi,
deviceManager.Dpi,
SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw);
// Direct2D needs the dxgi version of the backbuffer surface pointer. Get a D2D surface
// from the DXGI back buffer to use as the D2D render target.
if (IsStereoEnabled)
{
using (var dxgiBackBuffer = swapChain.GetBackBuffer <SharpDX.DXGI.Resource1>(0))
{
using (var dxgiSurface = new Surface2(dxgiBackBuffer, 0))
bitmapTarget = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiSurface, bitmapProperties));
using (var dxgiSurface = new Surface2(dxgiBackBuffer, 1))
bitmapTargetRight = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiSurface, bitmapProperties));
}
}
else
{
using (var dxgiBackBuffer = swapChain.GetBackBuffer <SharpDX.DXGI.Surface2>(0))
bitmapTarget = ToDispose(new SharpDX.Direct2D1.Bitmap1(d2dContext, dxgiBackBuffer, bitmapProperties));
}
// So now we can set the Direct2D render target.
d2dContext.Target = BitmapTarget;
// Set D2D text anti-alias mode to Grayscale to ensure proper rendering of text on
// intermediate surfaces.
d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Grayscale;
}
public DynamicCubemap(int cubemapsize)
{
CubeMapSize = cubemapsize;
// On commence par initialiser la description de la texture qui sera mise
// à jour par cette classe
TextureDescription = new Texture2DDescription()
{
Width = CubeMapSize,
Height = CubeMapSize,
MipLevels = 0,
ArraySize = 6, // Comme on cherche à créer une cubemap, ArraySize est à 6
Format = Format.R32G32B32A32_Float,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.GenerateMipMaps | ResourceOptionFlags.TextureCube,
SampleDescription = new SampleDescription
{
Count = 1,
Quality = 0
}
};
//Création de la texture
Texture = new Texture2D
(
ApplicationDX11.Instance.Device,
TextureDescription
);
// Création d'un renderTargetDescription qui sera utilisé
// par tout les autres RenderTargetView
RenderTargetViewDescription rtvDesc = new RenderTargetViewDescription()
{
Format = TextureDescription.Format,
Dimension = RenderTargetViewDimension.Texture2DArray,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
MipSlice = 0,
ArraySize = 1,
}
};
// Initialisation des 6 renderTargetView
for (int i = 0; i < 6; i++)
{
// On utilise FirstArraySlice pour préciser sur quel "Slice", ou Texture,
// on se trouve
rtvDesc.Texture2DArray.FirstArraySlice = i;
RenderTargetViews.Add(new RenderTargetView(ApplicationDX11.Instance.Device, Texture, rtvDesc));
}
// Initialisation du ShaderResourceView
ShaderResourceViewDescription SRVDescription = new ShaderResourceViewDescription()
{
Format = TextureDescription.Format,
Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube,
Texture2D = new ShaderResourceViewDescription.Texture2DResource()
{
MipLevels = 1,
MostDetailedMip = 0
}
};
SRV = new ShaderResourceView(ApplicationDX11.Instance.Device, Texture, SRVDescription);
// Création des renderTarget
foreach (RenderTargetView view in RenderTargetViews)
{
RenderTargets.Add(new RenderTarget(view, CubeMapSize, CubeMapSize));
}
// Création de la transformation
Transform = new Transform();
// Création des caméras
for (int i = 0; i < 6; i++)
{
Entity entity = new Entity();
Camera cam = entity.AddComponent <Camera>();
cam.Initialize(new FrustumProjection(3.141592f / 2.0f, 1.0f, 0.1f, 1000.0f));
cam.SetViewport(0, 0, CubeMapSize, cubemapsize);
Cameras.Add(cam);
}
// Right Camera
Cameras[0].m_transform.LookAt(new Vector3(1.0f, 0.0f, 0.0F), Transform.position_);
// Left Camera
Cameras[1].m_transform.LookAt(new Vector3(-1.0f, 0.0f, 0.0F), Transform.position_);
// Up Camera
Cameras[2].m_transform.LookAt(Vector3.Up + new Vector3(0.0f, 0.0f, 0.00001f), Transform.position_);
// Down Camera
Cameras[3].m_transform.LookAt(Vector3.Down + new Vector3(0.0f, 0.0f, 0.00001f), Transform.position_);
// Forward Camera
Cameras[4].m_transform.LookAt(Vector3.ForwardLH, Transform.position_);
// Backward Camera
Cameras[5].m_transform.LookAt(Vector3.BackwardLH, Transform.position_);
ApplicationDX11.Instance.Cubemaps.Add(this);
}
/// <summary>
/// Creates a <see cref = "T:SharpDX.Direct3D11.RenderTargetView" /> for accessing resource data.
/// </summary>
/// <param name = "device">The device to use when creating this <see cref = "T:SharpDX.Direct3D11.RenderTargetView" />.</param>
/// <param name = "resource">The resource that represents the render-target surface. This surface must have been created with the <see cref = "T:SharpDX.Direct3D11.BindFlags">RenderTarget</see> flag.</param>
/// <param name = "description">A structure describing the <see cref = "T:SharpDX.Direct3D11.RenderTargetView" /> to be created.</param>
/// <unmanaged>ID3D11Device::CreateRenderTargetView</unmanaged>
public RenderTargetView(Device device, Resource resource, RenderTargetViewDescription description)
: base(IntPtr.Zero)
{
device.CreateRenderTargetView(resource, description, this);
}
private void UpdateEyeProperties()
{
var cameraResources = this.deviceResources.cameraResourcesDictionary.Values.FirstOrDefault();
if (cameraResources != null)
{
int newWidth = (int)cameraResources.RenderTargetSize.Width;
int newHeight = (int)cameraResources.RenderTargetSize.Height;
var adapter = this.Adapter as Adapter.Adapter;
if (newWidth != adapter.Width || newHeight != adapter.Height)
{
adapter.SetSize(newWidth, newHeight);
RenderTargetManager renderTargetManager = this.Adapter.Graphics.RenderTargetManager as RenderTargetManager;
DepthTexture depthTexture = renderTargetManager.CreateDepthTexture(newWidth, newHeight);
this.eyeTextures = new VREyeTexture[cameraResources.IsRenderingStereoscopic ? 2 : 1];
for (int i = 0; i < this.eyeTextures.Length; i++)
{
RenderTargetViewDescription rtViewDescription = new RenderTargetViewDescription()
{
Format = cameraResources.BackBufferTexture2D.Description.Format,
Dimension = RenderTargetViewDimension.Texture2DArray,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
FirstArraySlice = i,
ArraySize = 1,
MipSlice = 0
}
};
var renderTarget = renderTargetManager.CreateRenderTarget(cameraResources.BackBufferTexture2D, rtViewDescription);
renderTarget.DepthTexture = depthTexture;
VREyeTexture eyeTexture = new VREyeTexture()
{
Viewport = new Viewport(0, 0, 1, 1),
NearPlane = 0.01f,
FarPlane = 1000,
RenderTarget = renderTarget
};
this.eyeTextures[i] = eyeTexture;
}
var dxRT = renderTargetManager.TargetFromHandle<DXRenderTarget>(this.EyeTextures[0].RenderTarget.TextureHandle);
adapter.GraphicsDevice.BackBuffer = dxRT.TargetView;
}
}
}
// ReSharper disable once FunctionComplexityOverflow
public void Resize(int width, int height, bool bgra)
{
if (Texture != null)
Texture.Dispose();
if (Native != null)
Native.Dispose();
var texDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
Format = bgra ? SharpDX.DXGI.Format.B8G8R8A8_UNorm : SharpDX.DXGI.Format.R8G8B8A8_UNorm,
Height = height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = mContext.Multisampling,
Usage = ResourceUsage.Default,
Width = width
};
Texture = new Texture2D(mContext.Device, texDesc);
var rtvd = new RenderTargetViewDescription
{
Dimension = RenderTargetViewDimension.Texture2DMultisampled,
Format = texDesc.Format,
Texture2DMS = new RenderTargetViewDescription.Texture2DMultisampledResource()
};
Native = new RenderTargetView(mContext.Device, Texture, rtvd);
if (mDepthTexture != null)
mDepthTexture.Dispose();
if (mDepthView != null)
mDepthView.Dispose();
texDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
Height = height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = mContext.Multisampling,
Usage = ResourceUsage.Default,
Width = width
};
mDepthTexture = new Texture2D(mContext.Device, texDesc);
var dsvd = new DepthStencilViewDescription
{
Dimension = DepthStencilViewDimension.Texture2DMultisampled,
Flags = DepthStencilViewFlags.None,
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
Texture2DMS = new DepthStencilViewDescription.Texture2DMultisampledResource()
};
mDepthView = new DepthStencilView(mContext.Device, mDepthTexture, dsvd);
}
private void Update(EvaluationContext context)
{
var updateLive = UpdateLive.GetValue(context);
if (_updatedOnce && !updateLive)
{
FilteredCubeMap.Value = _prefilteredCubeMap;
return;
}
//ConstantBuffers.GetValues(ref _constantBuffers, context);
ShaderResources.GetValues(ref _shaderResourceViews, context);
SamplerStates.GetValues(ref _samplerStates, context);
var vs = VertexShader.GetValue(context);
var gs = GeometryShader.GetValue(context);
if (CubeMap.IsConnected && CubeMap.DirtyFlag.IsDirty)
{
//Log.Debug("Dirty");
}
var cubeMapSrc = CubeMap.GetValue(context); // Needs to be checked for null!
if (cubeMapSrc == null)
{
FilteredCubeMap.Value = null;
return;
}
var device = ResourceManager.Instance().Device;
var deviceContext = device.ImmediateContext;
// Vertex shader stage
var vsStage = deviceContext.VertexShader;
_prevVsConstantBuffers = vsStage.GetConstantBuffers(0, 1);
_prevVsShaderResourceViews = vsStage.GetShaderResources(0, _shaderResourceViews.Length);
_prevVertexShader = vsStage.Get();
if (vs == null)
{
Log.Warning($"{nameof(_SpecularPrefilter)} requires valid vertex shader", SymbolChildId);
return;
}
vsStage.Set(vs);
vsStage.SetShaderResources(0, _shaderResourceViews.Length, _shaderResourceViews);
// Geometry shader stage
var gsStage = deviceContext.GeometryShader;
_prevGsConstantBuffers = gsStage.GetConstantBuffers(0, 1);
_prevGsShaderResourceViews = gsStage.GetShaderResources(0, _shaderResourceViews.Length);
_prevGeometryShader = gsStage.Get();
if (gs == null)
{
Log.Warning($"{nameof(_SpecularPrefilter)} requires valid geometry shader", SymbolChildId);
return;
}
gsStage.Set(gs);
gsStage.SetShaderResources(0, _shaderResourceViews.Length, _shaderResourceViews);
// Pixel shader stage
var psStage = deviceContext.PixelShader;
_prevPixelShader = psStage.Get();
_prevPsConstantBuffers = psStage.GetConstantBuffers(0, 1);
_prevPsShaderResourceViews = psStage.GetShaderResources(0, _shaderResourceViews.Length);
_prevPsSamplerStates = psStage.GetSamplers(0, _samplerStates.Length);
var ps = PixelShader.GetValue(context);
if (ps == null)
{
Log.Warning($"{nameof(_SpecularPrefilter)} requires valid pixel shader", SymbolChildId);
return;
}
psStage.Set(ps);
psStage.SetShaderResources(0, _shaderResourceViews.Length, _shaderResourceViews);
psStage.SetSamplers(0, _samplerStates);
// if (_prefilteredCubeMap != null && !Changed)
// {
// context.Image = _prefilteredCubeMap;
// return context;
// }
Vector2 cubeMapSize = new Vector2(cubeMapSrc.Description.Width, cubeMapSrc.Description.Height);
// Log.Debug($"source size: {cubeMapSrc.Description.Width} num mips in src: {cubeMapSrc.Description.MipLevels}");
// if ( _prefilteredCubeMap == null )
// {
var cubeMapDesc = new Texture2DDescription
{
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
Format = cubeMapSrc.Description.Format,
Width = (int)cubeMapSize.X,
Height = (int)cubeMapSize.Y,
MipLevels = cubeMapSrc.Description.MipLevels,
SampleDescription = cubeMapSrc.Description.SampleDescription,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.TextureCube | ResourceOptionFlags.GenerateMipMaps,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 6
};
Utilities.Dispose(ref _prefilteredCubeMap);
try
{
_prefilteredCubeMap = new Texture2D(device, cubeMapDesc);
}
catch (SharpDXException e)
{
Log.Debug($"can't create CubeMap target {e.Message}");
return;
}
var rastDesc = new RasterizerStateDescription
{
FillMode = FillMode.Solid,
CullMode = CullMode.None,
IsDepthClipEnabled = false
};
_rasterizerState = new RasterizerState(device, rastDesc);
// Input Assembler
var previousTopology = device.ImmediateContext.InputAssembler.PrimitiveTopology;
device.ImmediateContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
_prevBlendState = device.ImmediateContext.OutputMerger.GetBlendState(out _prevBlendFactor, out _prevSampleMask);
device.ImmediateContext.OutputMerger.BlendState = DefaultRenderingStates.DisabledBlendState;
device.ImmediateContext.OutputMerger.DepthStencilState = DefaultRenderingStates.DisabledDepthStencilState;
_prevRenderTargetViews = device.ImmediateContext.OutputMerger.GetRenderTargets(1);
device.ImmediateContext.OutputMerger.GetRenderTargets(out _prevDepthStencilView);
var rtvDesc = new RenderTargetViewDescription()
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = cubeMapSrc.Description.Format,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
{
ArraySize = 6,
FirstArraySlice = 0,
MipSlice = 0
}
};
int size = _prefilteredCubeMap.Description.Width;
_prevViewports = device.ImmediateContext.Rasterizer.GetViewports <RawViewportF>();
device.ImmediateContext.Rasterizer.State = _rasterizerState;
int numMipLevels = _prefilteredCubeMap.Description.MipLevels;
int mipSlice = 0;
while (mipSlice < numMipLevels)
{
// Log.Debug($"Update mipmap level {mipSlice} size: {size}");
var viewport = new RawViewportF {
X = 0, Y = 0, Width = size, Height = size, MinDepth = 0, MaxDepth = 1
};
device.ImmediateContext.Rasterizer.SetViewports(new[] { viewport });
Utilities.Dispose(ref _cubeMapRtv);
rtvDesc.Texture2DArray.MipSlice = mipSlice;
_cubeMapRtv = new RenderTargetView(device, _prefilteredCubeMap, rtvDesc);
device.ImmediateContext.OutputMerger.SetTargets(_cubeMapRtv, null);
var roughness = (float)mipSlice / (_prefilteredCubeMap.Description.MipLevels - 1);
// Is this required?
if (_settingsBuffer != null)
{
Utilities.Dispose(ref _settingsBuffer);
}
for (int i = 0; i < _samplingParameters.Length; ++i)
{
int indexToUse = -1;
if (Math.Abs(roughness - _samplingParameters[i].roughness) < 0.001f)
{
indexToUse = i;
}
if (indexToUse == -1 && roughness < _samplingParameters[i].roughness)
{
indexToUse = i - 1;
}
if (indexToUse != -1)
{
var param = _samplingParameters[indexToUse];
param.roughness = roughness;
ResourceManager.Instance().SetupConstBuffer(param, ref _settingsBuffer);
break;
}
}
var constantBuffers = new[] { _settingsBuffer };
psStage.SetConstantBuffers(0, 1, constantBuffers);
vsStage.SetConstantBuffers(0, 1, constantBuffers);
gsStage.SetConstantBuffers(0, 1, constantBuffers);
device.ImmediateContext.Draw(3, 0);
size /= 2;
++mipSlice;
}
FilteredCubeMap.Value = _prefilteredCubeMap;
Utilities.Dispose(ref _cubeMapRtv);
//device.ImmediateContext.InputAssembler.PrimitiveTopology = previousTopology;
Restore(context);
_updatedOnce = true;
}
public override void Init(D3D11RenderBackend backend)
{
base.Init(backend);
// Create shaders and layouts.
AssetsLoader.GetShader <VertexShader>("ScreenQuadVS", out ShaderSignature vsSignature);
QuadLayoyt = new InputLayout(RenderBackend.Device, vsSignature, new InputElement[] {
new InputElement("SV_VertexID", 0, Format.R32G32B32_Float, 0, 0),
});
AssetsLoader.GetShader <VertexShader>("ForwardPlusPosOnlyVS", out vsSignature);
DepthPassLayout = new InputLayout(RenderBackend.Device, vsSignature, new InputElement[] {
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TEXCOORD", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TEXCOORD", 1, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("NORMAL", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
new InputElement("TANGENT", 0, Format.R32G32B32A32_Float, InputElement.AppendAligned, 0),
});
//Create constant buffer
PerObjConstantBuffer = new Buffer(
RenderBackend.Device,
Utilities.SizeOf <CommonStructs.ConstBufferPerObjectStruct>(),
ResourceUsage.Default,
BindFlags.ConstantBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None, 0
);
PerFrameConstantBuffer = new Buffer(
RenderBackend.Device,
Utilities.SizeOf <CommonStructs.ConstBufferPerFrameStruct>(),
ResourceUsage.Default,
BindFlags.ConstantBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None, 0
);
m_LightBuffer = new LightBufferStruct[] { new LightBufferStruct(), new LightBufferStruct(), new LightBufferStruct() };
LightBuffer = new Buffer(
RenderBackend.Device,
Utilities.SizeOf <LightBufferStruct>() * m_LightBuffer.Length,
ResourceUsage.Default,
BindFlags.ConstantBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None, 0
);
ScreenParameters = new Buffer(
RenderBackend.Device,
Utilities.SizeOf <ScreenParametersStruct>(),
ResourceUsage.Default,
BindFlags.ConstantBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None, 0
);
GetContext.VertexShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.VertexShader.SetConstantBuffer(1, PerFrameConstantBuffer);
GetContext.VertexShader.SetConstantBuffer(2, LightBuffer);
GetContext.PixelShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.PixelShader.SetConstantBuffer(1, PerFrameConstantBuffer);
GetContext.PixelShader.SetConstantBuffer(2, LightBuffer);
Texture2DDescription textureDescription = new Texture2DDescription()
{
Width = RenderBackend.DisplayRef.Width,
Height = RenderBackend.DisplayRef.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.R16G16_Float,
SampleDescription = new SampleDescription()
{
Count = 1,
},
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
};
RenderTargetViewDescription renderTargetDescription = new RenderTargetViewDescription()
{
Format = Format.R16G16_Float,
Dimension = RenderTargetViewDimension.Texture2D,
};
ShaderResourceViewDescription shaderResourceDescription = new ShaderResourceViewDescription()
{
Format = Format.R16G16_Float,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceDescription.Texture2D.MostDetailedMip = 0;
shaderResourceDescription.Texture2D.MipLevels = 1;
textureTarget = new Texture2D(RenderBackend.Device, textureDescription);
velocityRenderTargetView = new RenderTargetView(RenderBackend.Device, textureTarget, renderTargetDescription);
velocitySRV = new ShaderResourceView(RenderBackend.Device, textureTarget, shaderResourceDescription);
textureDescription.Format = m_HDRformar;
renderTargetDescription.Format = m_HDRformar;
shaderResourceDescription = new ShaderResourceViewDescription()
{
Format = m_HDRformar,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceDescription.Texture2D.MostDetailedMip = 0;
shaderResourceDescription.Texture2D.MipLevels = 1;
hdrTextureTarget = new Texture2D(RenderBackend.Device, textureDescription);
hdrSRV = new ShaderResourceView(RenderBackend.Device, hdrTextureTarget, shaderResourceDescription);
hdrRenderTargetView = new RenderTargetView(RenderBackend.Device, hdrTextureTarget, renderTargetDescription);
textureDescription.Width = textureDescription.Width / 4;
textureDescription.Height = textureDescription.Height / 4;
downSamplingTarget = new Texture2D(RenderBackend.Device, textureDescription);
downSamplingSRV = new ShaderResourceView(RenderBackend.Device, downSamplingTarget, shaderResourceDescription);
downSamplingTargetView = new RenderTargetView(RenderBackend.Device, downSamplingTarget, renderTargetDescription);
}
/// <summary>
/// Gets a specific <see cref="RenderTargetView" /> from this texture.
/// </summary>
/// <param name="viewType">Type of the view slice.</param>
/// <param name="arrayOrDepthSlice">The texture array slice index.</param>
/// <param name="mipIndex">Index of the mip.</param>
/// <returns>An <see cref="RenderTargetView" /></returns>
/// <exception cref="System.NotSupportedException">ViewSlice.MipBand is not supported for render targets</exception>
private RenderTargetView GetRenderTargetView(ViewType viewType, int arrayOrDepthSlice, int mipIndex)
{
if (!IsRenderTarget)
return null;
if (viewType == ViewType.MipBand)
throw new NotSupportedException("ViewSlice.MipBand is not supported for render targets");
int arrayCount;
int mipCount;
GetViewSliceBounds(viewType, ref arrayOrDepthSlice, ref mipIndex, out arrayCount, out mipCount);
// Create the render target view
var rtvDescription = new RenderTargetViewDescription() { Format = (SharpDX.DXGI.Format)ViewFormat };
if (this.ArraySize > 1)
{
if (this.MultiSampleLevel > MSAALevel.None)
{
if (Dimension != TextureDimension.Texture2D)
{
throw new NotSupportedException("Multisample is only supported for 2D Textures");
}
rtvDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampledArray;
rtvDescription.Texture2DMSArray.ArraySize = arrayCount;
rtvDescription.Texture2DMSArray.FirstArraySlice = arrayOrDepthSlice;
}
else
{
if (Dimension == TextureDimension.Texture3D)
{
throw new NotSupportedException("Texture Array is not supported for Texture3D");
}
rtvDescription.Dimension = Dimension == TextureDimension.Texture2D || Dimension == TextureDimension.TextureCube ? RenderTargetViewDimension.Texture2DArray : RenderTargetViewDimension.Texture1DArray;
// Use rtvDescription.Texture1DArray as it matches also Texture memory layout
rtvDescription.Texture1DArray.ArraySize = arrayCount;
rtvDescription.Texture1DArray.FirstArraySlice = arrayOrDepthSlice;
rtvDescription.Texture1DArray.MipSlice = mipIndex;
}
}
else
{
if (IsMultiSample)
{
if (Dimension != TextureDimension.Texture2D)
{
throw new NotSupportedException("Multisample is only supported for 2D RenderTarget Textures");
}
rtvDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampled;
}
else
{
switch (Dimension)
{
case TextureDimension.Texture1D:
rtvDescription.Dimension = RenderTargetViewDimension.Texture1D;
rtvDescription.Texture1D.MipSlice = mipIndex;
break;
case TextureDimension.Texture2D:
rtvDescription.Dimension = RenderTargetViewDimension.Texture2D;
rtvDescription.Texture2D.MipSlice = mipIndex;
break;
case TextureDimension.Texture3D:
rtvDescription.Dimension = RenderTargetViewDimension.Texture3D;
rtvDescription.Texture3D.DepthSliceCount = arrayCount;
rtvDescription.Texture3D.FirstDepthSlice = arrayOrDepthSlice;
rtvDescription.Texture3D.MipSlice = mipIndex;
break;
case TextureDimension.TextureCube:
throw new NotSupportedException("TextureCube dimension is expecting an arraysize > 1");
}
}
}
return new RenderTargetView(GraphicsDevice.NativeDevice, NativeResource, rtvDescription);
}
/// <summary>
/// Gets a specific <see cref="RenderTargetView" /> from this texture.
/// </summary>
/// <param name="viewType">Type of the view slice.</param>
/// <param name="arrayOrDepthSlice">The texture array slice index.</param>
/// <param name="mipIndex">Index of the mip.</param>
/// <returns>An <see cref="RenderTargetView" /></returns>
/// <exception cref="System.NotSupportedException">ViewSlice.MipBand is not supported for render targets</exception>
private CpuDescriptorHandle GetRenderTargetView(ViewType viewType, int arrayOrDepthSlice, int mipIndex)
{
if (!IsRenderTarget)
{
return(new CpuDescriptorHandle());
}
if (viewType == ViewType.MipBand)
{
throw new NotSupportedException("ViewSlice.MipBand is not supported for render targets");
}
int arrayCount;
int mipCount;
GetViewSliceBounds(viewType, ref arrayOrDepthSlice, ref mipIndex, out arrayCount, out mipCount);
// Create the render target view
var rtvDescription = new RenderTargetViewDescription()
{
Format = (SharpDX.DXGI.Format)ViewFormat
};
if (this.ArraySize > 1)
{
if (this.MultisampleCount > MultisampleCount.None)
{
if (Dimension != TextureDimension.Texture2D)
{
throw new NotSupportedException("Multisample is only supported for 2D Textures");
}
rtvDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampledArray;
rtvDescription.Texture2DMSArray.ArraySize = arrayCount;
rtvDescription.Texture2DMSArray.FirstArraySlice = arrayOrDepthSlice;
}
else
{
if (Dimension == TextureDimension.Texture3D)
{
throw new NotSupportedException("Texture Array is not supported for Texture3D");
}
rtvDescription.Dimension = Dimension == TextureDimension.Texture2D || Dimension == TextureDimension.TextureCube ? RenderTargetViewDimension.Texture2DArray : RenderTargetViewDimension.Texture1DArray;
// Use rtvDescription.Texture1DArray as it matches also Texture memory layout
rtvDescription.Texture1DArray.ArraySize = arrayCount;
rtvDescription.Texture1DArray.FirstArraySlice = arrayOrDepthSlice;
rtvDescription.Texture1DArray.MipSlice = mipIndex;
}
}
else
{
if (IsMultisample)
{
if (Dimension != TextureDimension.Texture2D)
{
throw new NotSupportedException("Multisample is only supported for 2D RenderTarget Textures");
}
rtvDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampled;
}
else
{
switch (Dimension)
{
case TextureDimension.Texture1D:
rtvDescription.Dimension = RenderTargetViewDimension.Texture1D;
rtvDescription.Texture1D.MipSlice = mipIndex;
break;
case TextureDimension.Texture2D:
rtvDescription.Dimension = RenderTargetViewDimension.Texture2D;
rtvDescription.Texture2D.MipSlice = mipIndex;
break;
case TextureDimension.Texture3D:
rtvDescription.Dimension = RenderTargetViewDimension.Texture3D;
rtvDescription.Texture3D.DepthSliceCount = arrayCount;
rtvDescription.Texture3D.FirstDepthSlice = arrayOrDepthSlice;
rtvDescription.Texture3D.MipSlice = mipIndex;
break;
case TextureDimension.TextureCube:
throw new NotSupportedException("TextureCube dimension is expecting an arraysize > 1");
}
}
}
var descriptorHandle = GraphicsDevice.RenderTargetViewAllocator.Allocate(1);
NativeDevice.CreateRenderTargetView(NativeResource, rtvDescription, descriptorHandle);
return(descriptorHandle);
}
// Static functions
static public TextureObject CreateCubeTexture(Device device, int width, int height, int mips, Format format, bool isDepthStencil, bool needsGpuWrite)
{
if (isDepthStencil && format != Format.R32_Typeless && format != Format.R24G8_Typeless)
{
throw new Exception("Unsupported depth format");
}
TextureObject newTexture = new TextureObject();
// Variables
newTexture.m_Width = width;
newTexture.m_Height = height;
newTexture.m_TexFormat = format;
newTexture.m_Mips = mips;
newTexture.m_IsCube = true;
newTexture.m_ArraySize = 6;
BindFlags bindFlags = BindFlags.ShaderResource;
if (isDepthStencil)
{
bindFlags |= BindFlags.DepthStencil;
}
if (needsGpuWrite && !isDepthStencil)
{
bindFlags |= BindFlags.RenderTarget;
}
if (needsGpuWrite && !isDepthStencil)
{
bindFlags |= BindFlags.UnorderedAccess;
}
Texture2DDescription textureDescription = new Texture2DDescription
{
ArraySize = 6,
BindFlags = bindFlags,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = height,
Width = width,
MipLevels = mips,
OptionFlags = ResourceOptionFlags.TextureCube | ((mips > 1 && needsGpuWrite) ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None),
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
newTexture.m_TextureObject2D = new Texture2D(device, textureDescription);
Format srvFormat = format;
// Special case for depth
if (isDepthStencil)
{
srvFormat = (format == Format.R32_Typeless) ? Format.R32_Float : Format.R24_UNorm_X8_Typeless;
}
ShaderResourceViewDescription srvViewDesc = new ShaderResourceViewDescription
{
Format = srvFormat,
Dimension = ShaderResourceViewDimension.TextureCube,
Flags = 0,
FirstArraySlice = 0,
MostDetailedMip = 0,
MipLevels = mips,
ArraySize = 6,
};
newTexture.m_ShaderResourceView = new ShaderResourceView(device, newTexture.m_TextureObject2D, srvViewDesc);
newTexture.m_ArrayShaderResourceViews = new ShaderResourceView[6];
for (int i = 0; i < 6; ++i)
{
srvViewDesc.ArraySize = 1;
srvViewDesc.FirstArraySlice = i;
newTexture.m_ArrayShaderResourceViews[i] = new ShaderResourceView(device, newTexture.m_TextureObject2D, srvViewDesc);
}
if (isDepthStencil)
{
DepthStencilViewDescription dsViewDesc = new DepthStencilViewDescription
{
ArraySize = 6,
Format = (format == Format.R32_Typeless) ? Format.D32_Float : Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2DArray,
MipSlice = 0,
Flags = 0,
FirstArraySlice = 0
};
newTexture.m_DepthStencilView = new DepthStencilView(device, newTexture.m_TextureObject2D, dsViewDesc);
newTexture.m_ArrayDepthStencilViews = new DepthStencilView[6];
for (int i = 0; i < 6; ++i)
{
dsViewDesc.ArraySize = 1;
dsViewDesc.FirstArraySlice = i;
newTexture.m_ArrayDepthStencilViews[i] = new DepthStencilView(device, newTexture.m_TextureObject2D, dsViewDesc);
}
}
// No RTV for depth stencil, sorry
if (needsGpuWrite && !isDepthStencil)
{
newTexture.m_RenderTargetView = new RenderTargetView(device, newTexture.m_TextureObject2D);
RenderTargetViewDescription rtvDesc = new RenderTargetViewDescription
{
ArraySize = 6,
Dimension = RenderTargetViewDimension.Texture2DArray,
FirstArraySlice = 0,
Format = format,
};
newTexture.m_ArrayRenderTargetViews = new RenderTargetView[6 * mips];
for (int m = 0; m < mips; ++m)
{
for (int i = 0; i < 6; ++i)
{
rtvDesc.MipSlice = m;
rtvDesc.ArraySize = 1;
rtvDesc.FirstArraySlice = i;
newTexture.m_ArrayRenderTargetViews[6 * m + i] = new RenderTargetView(device, newTexture.m_TextureObject2D, rtvDesc);
}
}
UnorderedAccessViewDescription uavDesc = new UnorderedAccessViewDescription
{
ArraySize = 6,
Dimension = UnorderedAccessViewDimension.Texture2DArray,
FirstArraySlice = 0,
Format = format,
};
newTexture.m_UnorderedAccessView = new UnorderedAccessView(device, newTexture.m_TextureObject2D, uavDesc);
newTexture.m_ArrayUnorderedAccessViews = new UnorderedAccessView[6 * mips];
for (int m = 0; m < mips; ++m)
{
for (int i = 0; i < 6; ++i)
{
uavDesc.ArraySize = 1;
uavDesc.FirstArraySlice = i;
uavDesc.MipSlice = m;
newTexture.m_ArrayUnorderedAccessViews[6 * m + i] = new UnorderedAccessView(device, newTexture.m_TextureObject2D, uavDesc);
}
}
}
return(newTexture);
}
public override void Init(D3D11RenderBackend renderBackend)
{
base.Init(renderBackend);
// Create constant buffers
BufferDescription bufferDescription = new BufferDescription()
{
SizeInBytes = Utilities.SizeOf <CommonStructs.ConstBufferPerObjectStruct>(),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0,
};
PerObjConstantBuffer = new Buffer(GetDevice, bufferDescription);
bufferDescription.SizeInBytes = Utilities.SizeOf <CommonStructs.ConstBufferPerFrameStruct>();
PerFrameConstantBuffer = new Buffer(GetDevice, bufferDescription);
// Bind constant buffers
GetContext.VertexShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.VertexShader.SetConstantBuffer(1, PerFrameConstantBuffer);
GetContext.PixelShader.SetConstantBuffer(0, PerObjConstantBuffer);
GetContext.PixelShader.SetConstantBuffer(1, PerFrameConstantBuffer);
InitLightsBuffers();
Texture2DDescription textureDescription = new Texture2DDescription()
{
Width = GetDisplay.Width,
Height = GetDisplay.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.R16G16_Float,
SampleDescription = new SampleDescription()
{
Count = 1,
},
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
};
RenderTargetViewDescription renderTargetDescription = new RenderTargetViewDescription()
{
Format = Format.R16G16_Float,
Dimension = RenderTargetViewDimension.Texture2D,
};
ShaderResourceViewDescription shaderResourceDescription = new ShaderResourceViewDescription()
{
Format = Format.R16G16_Float,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceDescription.Texture2D.MostDetailedMip = 0;
shaderResourceDescription.Texture2D.MipLevels = 1;
textureDescription.Format = m_HDRformar;
renderTargetDescription.Format = m_HDRformar;
shaderResourceDescription = new ShaderResourceViewDescription()
{
Format = m_HDRformar,
Dimension = ShaderResourceViewDimension.Texture2D,
};
shaderResourceDescription.Texture2D.MostDetailedMip = 0;
shaderResourceDescription.Texture2D.MipLevels = 1;
hdrTextureTarget = new Texture2D(GetDevice, textureDescription);
hdrSRV = new ShaderResourceView(GetDevice, hdrTextureTarget, shaderResourceDescription);
hdrRenderTargetView = new RenderTargetView(GetDevice, hdrTextureTarget, renderTargetDescription);
}
private void GenerateIfRequired()
{
if (_renderTargetViews != null)
return;
// Create a view interface on the rendertarget to use on bind.
if (ArraySize > 1)
{
_renderTargetViews = new RenderTargetView[ArraySize];
for (var i = 0; i < ArraySize; i++)
{
var renderTargetViewDescription = new RenderTargetViewDescription();
if (MultiSampleCount > 1)
{
renderTargetViewDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampledArray;
renderTargetViewDescription.Texture2DMSArray.ArraySize = 1;
renderTargetViewDescription.Texture2DMSArray.FirstArraySlice = i;
}
else
{
renderTargetViewDescription.Dimension = RenderTargetViewDimension.Texture2DArray;
renderTargetViewDescription.Texture2DArray.ArraySize = 1;
renderTargetViewDescription.Texture2DArray.FirstArraySlice = i;
renderTargetViewDescription.Texture2DArray.MipSlice = 0;
}
_renderTargetViews[i] = new RenderTargetView(
GraphicsDevice._d3dDevice, GetTexture(),
renderTargetViewDescription);
}
}
else
{
_renderTargetViews = new[] { new RenderTargetView(GraphicsDevice._d3dDevice, GetTexture()) };
}
// If we don't need a depth buffer then we're done.
if (DepthStencilFormat == DepthFormat.None)
return;
// Setup the multisampling description.
var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
if (MultiSampleCount > 1)
{
multisampleDesc.Count = MultiSampleCount;
multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
// Create a descriptor for the depth/stencil buffer.
// Allocate a 2-D surface as the depth/stencil buffer.
// Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(DepthStencilFormat),
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = multisampleDesc,
BindFlags = BindFlags.DepthStencil,
}))
{
// Create the view for binding to the device.
_depthStencilView = new DepthStencilView(GraphicsDevice._d3dDevice, depthBuffer,
new DepthStencilViewDescription()
{
Format = SharpDXHelper.ToFormat(DepthStencilFormat),
Dimension = DepthStencilViewDimension.Texture2D
});
}
}
private void CreateTextureViews(bool createUav)
{
Debug.Assert(handle != null);
// default View
var defaultDesc = new ShaderResourceViewDescription
{
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = Format,
Texture2DArray = new ShaderResourceViewDescription.Texture2DArrayResource
{
ArraySize = LayerMipmap.Layers,
FirstArraySlice = 0,
MipLevels = LayerMipmap.Mipmaps,
MostDetailedMip = 0
}
};
View = new ShaderResourceView(Device.Get().Handle, handle, defaultDesc);
if (HasCubemap)
{
cubeViews = new ShaderResourceView[LayerMipmap.Mipmaps];
for (int curMipmap = 0; curMipmap < LayerMipmap.Mipmaps; ++curMipmap)
{
var cubeDesc = new ShaderResourceViewDescription
{
Dimension = ShaderResourceViewDimension.TextureCube,
Format = Format,
TextureCube = new ShaderResourceViewDescription.TextureCubeResource
{
MipLevels = 1,
MostDetailedMip = curMipmap
}
};
cubeViews[curMipmap] = new ShaderResourceView(Device.Get().Handle, handle, cubeDesc);
}
}
// single slice views
views = new ShaderResourceView[LayerMipmap.Layers * LayerMipmap.Mipmaps];
rtViews = new RenderTargetView[LayerMipmap.Layers * LayerMipmap.Mipmaps];
foreach (var lm in LayerMipmap.Range)
{
var desc = new ShaderResourceViewDescription
{
Dimension = ShaderResourceViewDimension.Texture2DArray,
Format = Format,
Texture2DArray = new ShaderResourceViewDescription.Texture2DArrayResource
{
MipLevels = 1,
MostDetailedMip = lm.Mipmap,
ArraySize = 1,
FirstArraySlice = lm.Layer
}
};
views[GetSubresourceIndex(lm)] = new ShaderResourceView(Device.Get().Handle, handle, desc);
var rtDesc = new RenderTargetViewDescription
{
Dimension = RenderTargetViewDimension.Texture2DArray,
Format = Format,
Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource
{
ArraySize = 1,
FirstArraySlice = lm.Layer,
MipSlice = lm.Mipmap
}
};
rtViews[GetSubresourceIndex(lm)] = new RenderTargetView(Device.Get().Handle, handle, rtDesc);
}
if (createUav)
{
uaViews = new UnorderedAccessView[LayerMipmap.Mipmaps];
for (int curMipmap = 0; curMipmap < LayerMipmap.Mipmaps; ++curMipmap)
{
var desc = new UnorderedAccessViewDescription
{
Dimension = UnorderedAccessViewDimension.Texture2DArray,
Format = Format,
Texture2DArray = new UnorderedAccessViewDescription.Texture2DArrayResource
{
ArraySize = LayerMipmap.Layers,
FirstArraySlice = 0,
MipSlice = curMipmap
}
};
uaViews[curMipmap] = new UnorderedAccessView(Device.Get().Handle, handle, desc);
}
}
}
internal override RenderTargetView GetRenderTargetView(ViewType viewType, int arrayOrDepthSlice, int mipIndex)
{
if ((this.Description.BindFlags & BindFlags.RenderTarget) == 0)
return null;
if (viewType == ViewType.MipBand)
throw new NotSupportedException("ViewSlice.MipBand is not supported for render targets");
int arrayCount;
int mipCount;
GetViewSliceBounds(viewType, ref arrayOrDepthSlice, ref mipIndex, out arrayCount, out mipCount);
var rtvIndex = GetViewIndex(viewType, arrayOrDepthSlice, mipIndex);
lock (this.renderTargetViews)
{
var rtv = this.renderTargetViews[rtvIndex];
// Creates the shader resource view
if (rtv == null)
{
// Create the render target view
var rtvDescription = new RenderTargetViewDescription {
Format = this.Description.Format,
Dimension = RenderTargetViewDimension.Texture2DArray,
Texture2DArray = {
ArraySize = arrayCount,
FirstArraySlice = arrayOrDepthSlice,
MipSlice = mipIndex
}
};
rtv = new RenderTargetView(GraphicsDevice, Resource, rtvDescription);
this.renderTargetViews[rtvIndex] = ToDispose(rtv);
}
// Associate this instance
rtv.Tag = this;
return rtv;
}
}
public void AfterEngineInit()
{
// Basics.
{
var deviceDesc = new Device.Descriptor {
DebugDevice = true
};
renderDevice = new ClearSight.RendererDX12.Device(ref deviceDesc,
ClearSight.RendererDX12.Device.FeatureLevel.Level_11_0);
var descCQ = new CommandQueue.Descriptor()
{
Type = CommandListType.Graphics
};
commandQueue = renderDevice.Create(ref descCQ);
var wih = new WindowInteropHelper(window);
var swapChainDesc = new SwapChain.Descriptor()
{
AssociatedGraphicsQueue = commandQueue,
MaxFramesInFlight = 3,
BufferCount = 3,
Width = (uint)window.Width,
Height = (uint)window.Height,
Format = Format.R8G8B8A8_UNorm,
SampleCount = 1,
SampleQuality = 0,
WindowHandle = wih.Handle,
Fullscreen = false
};
swapChain = renderDevice.Create(ref swapChainDesc);
var commandListDesc = new CommandList.Descriptor()
{
Type = CommandListType.Graphics,
AllocationPolicy = new CommandListInFlightFrameAllocationPolicy(CommandListType.Graphics, swapChain)
};
commandList = renderDevice.Create(ref commandListDesc);
}
// Render targets.
{
var descHeapDesc = new DescriptorHeap.Descriptor()
{
Type = DescriptorHeap.Descriptor.ResourceDescriptorType.RenderTarget,
NumResourceDescriptors = swapChain.Desc.BufferCount
};
descHeapRenderTargets = renderDevice.Create(ref descHeapDesc);
var rtvViewDesc = new RenderTargetViewDescription()
{
Format = swapChain.Desc.Format,
Dimension = Dimension.Texture2D,
Texture = new TextureSubresourceDesc(mipSlice: 0)
};
for (uint i = 0; i < swapChain.Desc.BufferCount; ++i)
{
renderDevice.CreateRenderTargetView(descHeapRenderTargets, i, swapChain.BackbufferResources[i], ref rtvViewDesc);
}
}
}
// Static functions
static public TextureObject CreateCubeTexture(Device device, int width, int height, int mips, Format format, bool isDepthStencil, bool needsGpuWrite)
{
if (isDepthStencil && format != Format.R32_Typeless && format != Format.R24G8_Typeless)
{
throw new Exception("Unsupported depth format");
}
TextureObject newTexture = new TextureObject();
// Variables
newTexture.m_Width = width;
newTexture.m_Height = height;
newTexture.m_TexFormat = format;
newTexture.m_Mips = mips;
newTexture.m_IsCube = true;
newTexture.m_ArraySize = 6;
BindFlags bindFlags = BindFlags.ShaderResource;
if (isDepthStencil) bindFlags |= BindFlags.DepthStencil;
if (needsGpuWrite && !isDepthStencil) bindFlags |= BindFlags.RenderTarget;
if (needsGpuWrite && !isDepthStencil) bindFlags |= BindFlags.UnorderedAccess;
Texture2DDescription textureDescription = new Texture2DDescription
{
ArraySize = 6,
BindFlags = bindFlags,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = height,
Width = width,
MipLevels = mips,
OptionFlags = ResourceOptionFlags.TextureCube | ((mips > 1 && needsGpuWrite) ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None),
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
};
newTexture.m_TextureObject2D = new Texture2D(device, textureDescription);
Format srvFormat = format;
// Special case for depth
if (isDepthStencil)
{
srvFormat = (format == Format.R32_Typeless) ? Format.R32_Float : Format.R24_UNorm_X8_Typeless;
}
ShaderResourceViewDescription srvViewDesc = new ShaderResourceViewDescription
{
ArraySize = 6,
Format = srvFormat,
Dimension = ShaderResourceViewDimension.Texture2DArray,
Flags = 0,
FirstArraySlice = 0,
MostDetailedMip = 0,
MipLevels = mips
};
newTexture.m_ShaderResourceView = new ShaderResourceView(device, newTexture.m_TextureObject2D, srvViewDesc);
newTexture.m_ArrayShaderResourceViews = new ShaderResourceView[6];
for (int i = 0; i < 6; ++ i )
{
srvViewDesc.ArraySize = 1;
srvViewDesc.FirstArraySlice = i;
newTexture.m_ArrayShaderResourceViews[i] = new ShaderResourceView(device, newTexture.m_TextureObject2D, srvViewDesc);
}
if (isDepthStencil)
{
DepthStencilViewDescription dsViewDesc = new DepthStencilViewDescription
{
ArraySize = 6,
Format = (format == Format.R32_Typeless) ? Format.D32_Float : Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2DArray,
MipSlice = 0,
Flags = 0,
FirstArraySlice = 0
};
newTexture.m_DepthStencilView = new DepthStencilView(device, newTexture.m_TextureObject2D, dsViewDesc);
newTexture.m_ArrayDepthStencilViews = new DepthStencilView[6];
for (int i = 0; i < 6; ++i)
{
dsViewDesc.ArraySize = 1;
dsViewDesc.FirstArraySlice = i;
newTexture.m_ArrayDepthStencilViews[i] = new DepthStencilView(device, newTexture.m_TextureObject2D, dsViewDesc);
}
}
// No RTV for depth stencil, sorry
if (needsGpuWrite && !isDepthStencil)
{
newTexture.m_RenderTargetView = new RenderTargetView(device, newTexture.m_TextureObject2D);
RenderTargetViewDescription rtvDesc = new RenderTargetViewDescription
{
ArraySize = 6,
Dimension = RenderTargetViewDimension.Texture2DArray,
FirstArraySlice = 0,
Format = format,
};
newTexture.m_ArrayRenderTargetViews = new RenderTargetView[6];
for (int i = 0; i < 6; ++i)
{
rtvDesc.ArraySize = 1;
rtvDesc.FirstArraySlice = i;
newTexture.m_ArrayRenderTargetViews[i] = new RenderTargetView(device, newTexture.m_TextureObject2D, rtvDesc);
}
UnorderedAccessViewDescription uavDesc = new UnorderedAccessViewDescription
{
ArraySize = 6,
Dimension = UnorderedAccessViewDimension.Texture2DArray,
FirstArraySlice = 0,
Format = format,
};
newTexture.m_UnorderedAccessView = new UnorderedAccessView(device, newTexture.m_TextureObject2D, uavDesc);
newTexture.m_ArrayUnorderedAccessViews = new UnorderedAccessView[6];
for (int i = 0; i < 6; ++i)
{
uavDesc.ArraySize = 1;
uavDesc.FirstArraySlice = i;
newTexture.m_ArrayUnorderedAccessViews[i] = new UnorderedAccessView(device, newTexture.m_TextureObject2D, uavDesc);
}
}
return newTexture;
}
void CreateDeviceResources()
{
uint width = (uint)host.ActualWidth;
uint height = (uint)host.ActualHeight;
// If we don't have a device, need to create one now and all
// accompanying D3D resources.
CreateDevice();
Factory dxgiFactory = Factory.Create();
SwapChainDescription swapDesc = new SwapChainDescription
{
BufferDescription = new ModeDescription
{
Width = width, Height = height,
Format = Format.R8G8B8A8UNorm,
RefreshRate = new Rational {
Numerator = 60, Denominator = 1
}
},
SampleDescription = new SampleDescription {
Count = 1, Quality = 0
},
BufferUsage = UsageOptions.RenderTargetOutput,
BufferCount = 1,
OutputWindowHandle = host.Handle,
Windowed = true
};
swapChain = dxgiFactory.CreateSwapChain(
device, swapDesc);
// Create rasterizer state object
RasterizerDescription rsDesc = new RasterizerDescription();
rsDesc.AntiAliasedLineEnable = false;
rsDesc.CullMode = CullMode.None;
rsDesc.DepthBias = 0;
rsDesc.DepthBiasClamp = 0;
rsDesc.DepthClipEnable = true;
rsDesc.FillMode = D3D10.FillMode.Solid;
rsDesc.FrontCounterclockwise = false; // Must be FALSE for 10on9
rsDesc.MultisampleEnable = false;
rsDesc.ScissorEnable = false;
rsDesc.SlopeScaledDepthBias = 0;
rasterizerState = device.CreateRasterizerState(
rsDesc);
device.RS.State = rasterizerState;
// If we don't have a D2D render target, need to create all of the resources
// required to render to one here.
// Ensure that nobody is holding onto one of the old resources
device.OM.RenderTargets = new OutputMergerRenderTargets(new RenderTargetView[] { null });
InitializeDepthStencil(width, height);
// Create views on the RT buffers and set them on the device
RenderTargetViewDescription renderDesc = new RenderTargetViewDescription();
renderDesc.Format = Format.R8G8B8A8UNorm;
renderDesc.ViewDimension = RenderTargetViewDimension.Texture2D;
Texture2DRenderTargetView renderView = renderDesc.Texture2D;
renderView.MipSlice = 0;
renderDesc.Texture2D = renderView;
using (D3DResource spBackBufferResource = swapChain.GetBuffer <D3DResource>(0))
{
renderTargetView = device.CreateRenderTargetView(
spBackBufferResource,
renderDesc);
}
device.OM.RenderTargets = new OutputMergerRenderTargets(new RenderTargetView[] { renderTargetView }, depthStencilView);
SetViewport(width, height);
// Create a D2D render target which can draw into the surface in the swap chain
RenderTargetProperties props =
new RenderTargetProperties(
RenderTargetType.Default, new PixelFormat(Format.Unknown, AlphaMode.Premultiplied),
96, 96, RenderTargetUsages.None, FeatureLevel.Default);
// Allocate a offscreen D3D surface for D2D to render our 2D content into
Texture2DDescription tex2DDescription = new Texture2DDescription
{
ArraySize = 1,
BindingOptions = BindingOptions.RenderTarget | BindingOptions.ShaderResource,
CpuAccessOptions = CpuAccessOptions.None,
Format = Format.R8G8B8A8UNorm,
Height = 4096,
Width = 512,
MipLevels = 1,
MiscellaneousResourceOptions = MiscellaneousResourceOptions.None,
SampleDescription = new SampleDescription {
Count = 1, Quality = 0
},
Usage = Usage.Default
};
offscreenTexture = device.CreateTexture2D(tex2DDescription);
using (Surface dxgiSurface = offscreenTexture.GraphicsSurface)
{
// Create a D2D render target which can draw into our offscreen D3D surface
renderTarget = d2DFactory.CreateGraphicsSurfaceRenderTarget(
dxgiSurface,
props);
}
PixelFormat alphaOnlyFormat = new PixelFormat(Format.A8UNorm, AlphaMode.Premultiplied);
opacityRenderTarget = renderTarget.CreateCompatibleRenderTarget(CompatibleRenderTargetOptions.None,
alphaOnlyFormat);
// Load pixel shader
// Open precompiled vertex shader
// This file was compiled using DirectX's SDK Shader compilation tool:
// fxc.exe /T fx_4_0 /Fo SciFiText.fxo SciFiText.fx
shader = LoadResourceShader(device, "SciFiTextDemo.SciFiText.fxo");
// Obtain the technique
technique = shader.GetTechniqueByName("Render");
// Obtain the variables
worldMatrixVariable = shader.GetVariableByName("World").AsMatrix;
viewMatrixVariable = shader.GetVariableByName("View").AsMatrix;
projectionMarixVariable = shader.GetVariableByName("Projection").AsMatrix;
diffuseVariable = shader.GetVariableByName("txDiffuse").AsShaderResource;
// Create the input layout
PassDescription passDesc = new PassDescription();
passDesc = technique.GetPassByIndex(0).Description;
vertexLayout = device.CreateInputLayout(
inputLayoutDescriptions,
passDesc.InputAssemblerInputSignature,
passDesc.InputAssemblerInputSignatureSize
);
// Set the input layout
device.IA.InputLayout = vertexLayout;
IntPtr verticesDataPtr = Marshal.AllocHGlobal(Marshal.SizeOf(VertexArray.VerticesInstance));
Marshal.StructureToPtr(VertexArray.VerticesInstance, verticesDataPtr, true);
BufferDescription bd = new BufferDescription();
bd.Usage = Usage.Default;
bd.ByteWidth = (uint)Marshal.SizeOf(VertexArray.VerticesInstance);
bd.BindingOptions = BindingOptions.VertexBuffer;
bd.CpuAccessOptions = CpuAccessOptions.None;
bd.MiscellaneousResourceOptions = MiscellaneousResourceOptions.None;
SubresourceData InitData = new SubresourceData {
SystemMemory = verticesDataPtr
};
vertexBuffer = device.CreateBuffer(bd, InitData);
Marshal.FreeHGlobal(verticesDataPtr);
// Set vertex buffer
uint stride = (uint)Marshal.SizeOf(typeof(SimpleVertex));
uint offset = 0;
device.IA.SetVertexBuffers(
0,
new D3DBuffer[] { vertexBuffer },
new uint[] { stride },
new uint[] { offset }
);
IntPtr indicesDataPtr = Marshal.AllocHGlobal(Marshal.SizeOf(VertexArray.IndicesInstance));
Marshal.StructureToPtr(VertexArray.IndicesInstance, indicesDataPtr, true);
bd.Usage = Usage.Default;
bd.ByteWidth = (uint)Marshal.SizeOf(VertexArray.IndicesInstance);
bd.BindingOptions = BindingOptions.IndexBuffer;
bd.CpuAccessOptions = CpuAccessOptions.None;
bd.MiscellaneousResourceOptions = MiscellaneousResourceOptions.None;
InitData.SystemMemory = indicesDataPtr;
facesIndexBuffer = device.CreateBuffer(
bd,
InitData
);
Marshal.FreeHGlobal(indicesDataPtr);
// Set primitive topology
device.IA.PrimitiveTopology = PrimitiveTopology.TriangleList;
// Convert the D2D texture into a Shader Resource View
textureResourceView = device.CreateShaderResourceView(
offscreenTexture);
// Initialize the world matrices
worldMatrix = Matrix4x4F.Identity;
// Initialize the view matrix
Vector3F Eye = new Vector3F(0.0f, 0.0f, 13.0f);
Vector3F At = new Vector3F(0.0f, -3.5f, 45.0f);
Vector3F Up = new Vector3F(0.0f, 1.0f, 0.0f);
viewMatrix = Camera.MatrixLookAtLH(Eye, At, Up);
// Initialize the projection matrix
projectionMatrix = Camera.MatrixPerspectiveFovLH(
(float)Math.PI * 0.1f,
width / (float)height,
0.1f,
100.0f);
// Update Variables that never change
viewMatrixVariable.Matrix = viewMatrix;
projectionMarixVariable.Matrix = projectionMatrix;
GradientStop[] gradientStops =
{
new GradientStop(0.0f, new ColorF(GetColorValues(System.Windows.Media.Colors.Yellow))),
new GradientStop(1.0f, new ColorF(GetColorValues(System.Windows.Media.Colors.Black)))
};
GradientStopCollection spGradientStopCollection = renderTarget.CreateGradientStopCollection(
gradientStops, Gamma.StandardRgb, ExtendMode.Clamp);
// Create a linear gradient brush for text
textBrush = renderTarget.CreateLinearGradientBrush(
new LinearGradientBrushProperties(new Point2F(0, 0), new Point2F(0, -2048)),
spGradientStopCollection
);
}
