/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
//Dispose of managed resources
if (disposing)
{
if (_shaderResourceView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_shaderResourceView.ComPointer);
}
_shaderResourceView.Dispose();
_shaderResourceView = null;
}
if (_renderTargetView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_renderTargetView.ComPointer);
}
_renderTargetView.Dispose();
_renderTargetView = null;
}
if (_depthStencilView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_depthStencilView.ComPointer);
}
_depthStencilView.Dispose();
_depthStencilView = null;
}
if (_texture2D != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_texture2D.ComPointer);
}
_texture2D.Dispose();
_texture2D = null;
}
if (_staging != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_staging.ComPointer);
}
_staging.Dispose();
_staging = null;
}
}
base.Dispose(disposing);
}
}
public override D3D.RenderTargetView[] GetRenderTargets()
{
D3D.RenderTargetView[] views = new D3D.RenderTargetView[Targets.Length];
for (int i = 0; i < views.Length; i++)
views[i] = Targets[i].RenderView;
return views;
}
private void CreateViews()
{
_backBuffer = D3D.Resource.FromSwapChain <D3D.Texture2D>(_swapChain, 0);
_renderTargetView = new D3D.RenderTargetView(_graphicsDevice, _backBuffer);
//Add resources to tracker
_renderer.Resources.AddTrackedObject(_backBuffer.ComPointer, this);
_renderer.Resources.AddTrackedObject(_renderTargetView.ComPointer, this);
if (_presentParams.DepthStencilFormat != DepthFormat.None)
{
D3D.Texture2DDescription depthBufferDesc = new D3D.Texture2DDescription {
ArraySize = 1,
BindFlags = D3D.BindFlags.DepthStencil,
CpuAccessFlags = D3D.CpuAccessFlags.None,
Format = D3D10Helper.ToD3DDepthFormat(_presentParams.DepthStencilFormat),
Height = _presentParams.BackBufferHeight,
Width = _presentParams.BackBufferWidth,
MipLevels = 1,
OptionFlags = D3D.ResourceOptionFlags.None,
SampleDescription = _backBuffer.Description.SampleDescription,
Usage = D3D.ResourceUsage.Default
};
using (var depthBuffer = new D3D.Texture2D(_graphicsDevice, depthBufferDesc)) {
_depthStencilView = new D3D.DepthStencilView(_graphicsDevice, depthBuffer);
//Add resource to tracker
_renderer.Resources.AddTrackedObject(_depthStencilView.ComPointer, this);
}
}
}
public RenderTarget(D3D.Device device, D3D.Texture2DDescription rdesc)
: base(device)
{
rdesc.BindFlags |= D3D.BindFlags.ShaderResource;
D3D.Texture2D te = new D3D.Texture2D(device, rdesc);
Resource = te;
RenderView = new D3D.RenderTargetView(device, te);
View = new D3D.ShaderResourceView(device, Resource);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
//Dispose of managed resources
if (disposing)
{
if (_shaderResourceView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_shaderResourceView.ComPointer);
}
_shaderResourceView.Dispose();
_shaderResourceView = null;
}
if (_renderTargetView != null)
{
for (int i = 0; i < 6; i++)
{
D3D.RenderTargetView rt = _renderTargetView[i];
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(rt.ComPointer);
}
rt.Dispose();
_renderTargetView[i] = null;
}
}
if (_depthStencilView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_depthStencilView.ComPointer);
}
_depthStencilView.Dispose();
_depthStencilView = null;
}
if (_texture2D != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_texture2D.ComPointer);
}
_texture2D.Dispose();
_texture2D = null;
}
}
base.Dispose(disposing);
}
}
protected override void SetOutputTargets()
{
RenderTargets = new D3D.RenderTargetView[1 + NumAdditionalTargets];
RenderTextures = new D3D.Texture2D[1 + NumAdditionalTargets];
Targets = new Texturing.RenderTarget[1 + NumAdditionalTargets];
RenderTargets[0] = RenderTarget.RenderView;
RenderTextures[0] = RenderTarget.Texture;
Targets[0] = RenderTarget;
for (int i = 0; i < NumAdditionalTargets; i++)
{
RenderTextures[i + 1] = new D3D.Texture2D(Device, RenderTarget.Texture.Description);
RenderTargets[i + 1] = new D3D.RenderTargetView(Device, RenderTextures[i + 1]);
//Targets[i + 1] = new Texturing.RenderTarget(Device, RenderTargetView.Texture.Description.Width, RenderTargetView.Texture.Description.Height);
Targets[i + 1] = new Texturing.RenderTarget(Device, RenderTarget.Texture.Description);
}
Device.OutputMerger.SetTargets(DepthBufferView, GetRenderTargets());
//Device.OutputMerger.SetTargets(DepthBufferView, RenderTargets);
}
private void DestroyViews()
{
if (_renderTargetView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_renderTargetView.ComPointer);
}
_renderTargetView.Dispose();
_renderTargetView = null;
}
if (_backBuffer != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_backBuffer.ComPointer);
}
_backBuffer.Dispose();
_backBuffer = null;
}
if (_staging != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_staging.ComPointer);
}
_staging.Dispose();
_staging = null;
}
if (_depthStencilView != null)
{
if (_renderer != null)
{
_renderer.Resources.RemoveTrackedObject(_depthStencilView.ComPointer);
}
_depthStencilView.Dispose();
_depthStencilView = null;
}
}
public RenderTarget(D3D.Device device, int width, int height)
: base(device)
{
D3D.Texture2DDescription rdesc = new D3D.Texture2DDescription()
{
Width = width,
Height = height,
MipLevels = 1,
ArraySize = 1,
Format = SlimDX.DXGI.Format.R8G8B8A8_UNorm,
SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0),
Usage = D3D.ResourceUsage.Default,
BindFlags = D3D.BindFlags.RenderTarget | D3D.BindFlags.ShaderResource,
CpuAccessFlags = D3D.CpuAccessFlags.None,
OptionFlags = D3D.ResourceOptionFlags.None
};
Resource = new D3D.Texture2D(device, rdesc);
RenderView = new D3D.RenderTargetView(device, Texture);
View = new D3D.ShaderResourceView(device, Resource);
}
private void SetBackBufferTargets()
{
if (_activeBackBuffer != null)
{
D3D10Helper.CheckDisposed(_activeBackBuffer);
D3D.RenderTargetView rtv = _activeBackBuffer.D3D10RenderTargetView;
D3D.DepthStencilView dsv = _activeBackBuffer.D3D10DepthStencilView;
if (rtv != null)
{
if (dsv != null)
{
_graphicsDevice.OutputMerger.SetTargets(dsv, rtv);
}
else
{
_graphicsDevice.OutputMerger.SetTargets(rtv);
}
}
}
}
public RenderTarget( D3D10.Device device, int width, int height, DXGI.Format format )
{
this.device = device;
D3D10.Texture2DDescription desc = new D3D10.Texture2DDescription();
desc.Width = width;
desc.Height = height;
desc.ArraySize = 1;
desc.BindFlags = D3D10.BindFlags.RenderTarget | D3D10.BindFlags.ShaderResource;
desc.CpuAccessFlags = D3D10.CpuAccessFlags.None;
desc.Format = format;
desc.MipLevels = 1;
desc.OptionFlags = D3D10.ResourceOptionFlags.None;
desc.SampleDescription = new SlimDX.DXGI.SampleDescription( 1, 0 );
desc.Usage = D3D10.ResourceUsage.Default;
Resource = new D3D10.Texture2D( device, desc );
RenderTargetView = new D3D10.RenderTargetView( device, Resource );
ShaderResourceView = new D3D10.ShaderResourceView( device, Resource );
}
/// <summary>
/// Creates a new instance of <see cref="D3D10Texture2DImplementation"/>, for RenderTarget2D.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="width">The texture width in pixels.</param>
/// <param name="height">The texture height in pixels.</param>
/// <param name="genMipMaps">True if a mipmap chain should be generated or not.</param>
/// <param name="format">The surface format.</param>
/// <param name="depthFormat">The depth-stencil format.</param>
/// <param name="multiSampleCount">The multisample count.</param>
/// <param name="usage">The target usage.</param>
/// <exception cref="System.ArgumentException">Thrown if the formats are invalid to be used in a render target.</exception>
internal D3D10Texture2DImplementation(D3D10Renderer renderer, int width, int height, bool genMipMaps, SurfaceFormat format, DepthFormat depthFormat, int multiSampleCount, RenderTargetUsage usage)
: base(width, height, format, depthFormat, multiSampleCount, usage)
{
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
if (!renderer.Adapter.QueryRenderTargetFormat(format, depthFormat, multiSampleCount))
{
throw new ArgumentException("Format combination not supported.");
}
D3D.Texture2DDescription desc2D = new D3D.Texture2DDescription();
desc2D.ArraySize = 1;
desc2D.BindFlags = D3D.BindFlags.ShaderResource | D3D.BindFlags.RenderTarget;
desc2D.CpuAccessFlags = D3D.CpuAccessFlags.None;
desc2D.Format = D3D10Helper.ToD3DSurfaceFormat(format);
desc2D.Height = height;
desc2D.Width = width;
desc2D.Usage = _usage = D3D.ResourceUsage.Default;
if (genMipMaps)
{
desc2D.OptionFlags = D3D.ResourceOptionFlags.GenerateMipMaps;
}
else
{
desc2D.OptionFlags = D3D.ResourceOptionFlags.None;
}
desc2D.MipLevels = (genMipMaps) ? 0 : 1;
if (multiSampleCount > 1)
{
desc2D.SampleDescription = new SlimDX.DXGI.SampleDescription(multiSampleCount, 0);
}
else
{
desc2D.SampleDescription = new DXGI.SampleDescription(1, 0);
}
_texture2D = new D3D.Texture2D(_graphicsDevice, desc2D);
_shaderResourceView = new D3D.ShaderResourceView(_graphicsDevice, _texture2D);
_renderTargetView = new D3D.RenderTargetView(_graphicsDevice, _texture2D);
_graphicsDevice.ClearRenderTargetView(_renderTargetView, new SDX.Color4(1.0f, 0, 0, 0));
//Add to tracker
_renderer.Resources.AddTrackedObject(_texture2D.ComPointer, this);
_renderer.Resources.AddTrackedObject(_shaderResourceView.ComPointer, this);
_renderer.Resources.AddTrackedObject(_renderTargetView.ComPointer, this);
_mipCount = _texture2D.Description.MipLevels;
if (depthFormat != DepthFormat.None)
{
D3D.Texture2DDescription dbdesc = new D3D.Texture2DDescription();
dbdesc.ArraySize = 1;
dbdesc.BindFlags = D3D.BindFlags.DepthStencil;
dbdesc.CpuAccessFlags = D3D.CpuAccessFlags.None;
dbdesc.Format = D3D10Helper.ToD3DDepthFormat(depthFormat);
dbdesc.Height = height;
dbdesc.Width = width;
dbdesc.Usage = D3D.ResourceUsage.Default;
dbdesc.OptionFlags = D3D.ResourceOptionFlags.None;
dbdesc.MipLevels = 1;
if (multiSampleCount > 1)
{
dbdesc.SampleDescription = new SlimDX.DXGI.SampleDescription(multiSampleCount, 0);
}
else
{
dbdesc.SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0);
}
using (D3D.Texture2D depthBuffer = new D3D.Texture2D(_graphicsDevice, dbdesc)) {
_depthStencilView = new D3D.DepthStencilView(_graphicsDevice, depthBuffer);
if (depthFormat == Tesla.Graphics.DepthFormat.Depth24Stencil8)
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Depth | D3D.DepthStencilClearFlags.Stencil, 1.0f, 0);
}
else
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Depth, 1.0f, 0);
}
//Add to tracker
_renderer.Resources.AddTrackedObject(_depthStencilView.ComPointer, this);
}
}
}
public Sky(Vector3 lightDir, StreamReader file)
{
///
// outerRadius = innerRadius * 1.0157313f;
// atmScale = 1f / (outerRadius - innerRadius);
dome.CreateDome((int)size.X, (int)size.Y);
// waveLength4 = new Vector3((float)Math.Pow(waveLength.X, 4), (float)Math.Pow(waveLength.Y, 4), (float)Math.Pow(waveLength.Z, 4));
// double pow = -0.84;
// waveLength084 = new Vector3((float)Math.Pow(waveLength.X, pow), (float)Math.Pow(waveLength.Y, pow), (float)Math.Pow(waveLength.Z, pow));
effect = ResourceManager.mainManager.LoadEffect("Resources\\Effects\\Sky.fx", ResourceManager.mainManager.GetDefaultEffectPool());
pass = effect.GetTechniqueByName("Render").GetPassByIndex(0);
updatePass = effect.GetTechniqueByName("Update").GetPassByIndex(0);
D3D10.InputElement[] elements = new SlimDX.Direct3D10.InputElement[2];
elements[0] = new SlimDX.Direct3D10.InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32_Float, 0, 0);
elements[1] = new D3D10.InputElement("TEXCOORD", 0, SlimDX.DXGI.Format.R32G32_Float, 12, 0);
layout = new SlimDX.Direct3D10.InputLayout(Game.gameClass.GetDevice(), elements, pass.Description.Signature);
layoutUpdate = Quad.GetLayout(updatePass);
translation = effect.GetVariableByName("translation").AsVector();
sunPosition = effect.GetVariableByName("sunPos").AsVector();
// Vector4 mieTemps = new Vector4((3 * (1 - g * g)) / (2 * (2 + g * g)), 1 + g * g, g, 1);
mieTemps = effect.GetVariableByName("mieTemps").AsVector();
K = effect.GetVariableByName("K").AsVector();
waveLengthRay = effect.GetVariableByName("waveLengthRay").AsVector();
waveLengthMie = effect.GetVariableByName("waveLengthMie").AsVector();
scaleDepth = effect.GetVariableByName("scaleDepth").AsVector();
sunIntensity = effect.GetVariableByName("sunIntensity").AsScalar();
//textures
D3D10.Texture2DDescription desc = new SlimDX.Direct3D10.Texture2DDescription();
desc.ArraySize = 1;
desc.BindFlags = D3D10.BindFlags.ShaderResource | SlimDX.Direct3D10.BindFlags.RenderTarget;
desc.CpuAccessFlags = D3D10.CpuAccessFlags.None;
desc.Format = SlimDX.DXGI.Format.R16G16B16A16_Float;
desc.Height = (int)size.Y;
desc.MipLevels = 1;
desc.OptionFlags = D3D10.ResourceOptionFlags.None;
desc.Usage = D3D10.ResourceUsage.Default;
desc.Width = (int)size.X;
SlimDX.DXGI.SampleDescription sampleDescription = new SlimDX.DXGI.SampleDescription();
sampleDescription.Count = 1;
sampleDescription.Quality = 0;
desc.SampleDescription = sampleDescription;
rayLookupTexture = new D3D10.Texture2D(Game.gameClass.GetDevice(), desc);
mieLookupTexture = new D3D10.Texture2D(Game.gameClass.GetDevice(), desc);
/* desc.BindFlags = D3D10.BindFlags.None;
desc.CpuAccessFlags = D3D10.CpuAccessFlags.Write;
desc.Usage = D3D10.ResourceUsage.Staging;
mieUpdateTexture = new D3D10.Texture2D(Game.gameClass.GetDevice(), desc);
rayUpdateTexture = new D3D10.Texture2D(Game.gameClass.GetDevice(), desc);
mieUpdateTextureMap = mieUpdateTexture.Map(0, D3D10.MapMode.Write, D3D10.MapFlags.DoNotWait);
mieUpdateTexture.Unmap(0);
rayUpdateTextureMap = rayUpdateTexture.Map(0, D3D10.MapMode.Write, D3D10.MapFlags.DoNotWait);
rayUpdateTexture.Unmap(0);*/
using (D3D10.ShaderResourceView view = new SlimDX.Direct3D10.ShaderResourceView(Game.gameClass.GetDevice(), rayLookupTexture))
effect.GetVariableByName("rayLookupTex").AsResource().SetResource(view);
using (D3D10.ShaderResourceView view = new SlimDX.Direct3D10.ShaderResourceView(Game.gameClass.GetDevice(), mieLookupTexture))
effect.GetVariableByName("mieLookupTex").AsResource().SetResource(view);
viewPort = new Viewport();
viewPort.Height = (int)size.Y;
viewPort.Width = (int)size.X;
viewPort.MaxZ = 1.0f;
viewPort.MinZ = 0.0f;
viewPort.X = 0;
viewPort.Y = 0;
renderTargets[0] = new SlimDX.Direct3D10.RenderTargetView(Game.gameClass.GetDevice(), rayLookupTexture);
renderTargets[1] = new SlimDX.Direct3D10.RenderTargetView(Game.gameClass.GetDevice(), mieLookupTexture);
Load(file);
CalculateLookupOnGPU(-lightDir);
}
/// <summary>
/// Creates a new instance of <see cref="D3D10TextureCubeImplementation"/>.
/// </summary>
/// <param name="renderer">The D3D10 renderer.</param>
/// <param name="size">The size (width/height) of each cube face.</param>
/// <param name="genMipMaps">True if a mipmap chain should be generated or not.</param>
/// <param name="format">The surface format.</param>
/// <param name="depthFormat">The depth-stencil format.</param>
/// <param name="multiSampleCount">The number of sample locations for multisampling</param>
/// <param name="usage">Sets the render target's behavior.</param>
internal D3D10TextureCubeImplementation(D3D10Renderer renderer, int size, bool genMipMaps, SurfaceFormat format, DepthFormat depthFormat, int multiSampleCount, RenderTargetUsage usage)
: base(size, format, depthFormat, multiSampleCount, usage)
{
_renderer = renderer;
_graphicsDevice = _renderer.GraphicsDevice;
if (!renderer.Adapter.QueryRenderTargetFormat(format, depthFormat, multiSampleCount))
{
throw new ArgumentException("Format combination not supported.");
}
D3D.Texture2DDescription desc2D = new D3D.Texture2DDescription();
desc2D.ArraySize = 6;
desc2D.BindFlags = D3D.BindFlags.ShaderResource | D3D.BindFlags.RenderTarget;
desc2D.CpuAccessFlags = D3D.CpuAccessFlags.None;
desc2D.Format = D3D10Helper.ToD3DSurfaceFormat(format);
desc2D.Height = size;
desc2D.Width = size;
desc2D.Usage = D3D.ResourceUsage.Default;
if (genMipMaps)
{
desc2D.OptionFlags = D3D.ResourceOptionFlags.GenerateMipMaps | D3D.ResourceOptionFlags.TextureCube;
}
else
{
desc2D.OptionFlags = D3D.ResourceOptionFlags.TextureCube;
}
desc2D.MipLevels = (genMipMaps) ? 0 : 1;
if (multiSampleCount > 1)
{
desc2D.SampleDescription = new SlimDX.DXGI.SampleDescription(multiSampleCount, 0);
}
else
{
desc2D.SampleDescription = new DXGI.SampleDescription(1, 0);
}
//Create the resources
_texture2D = new D3D.Texture2D(_graphicsDevice, desc2D);
_shaderResourceView = new D3D.ShaderResourceView(_graphicsDevice, _texture2D);
_renderTargetView = new D3D.RenderTargetView[6];
//Add to tracker
_renderer.Resources.AddTrackedObject(_texture2D.ComPointer, this);
_renderer.Resources.AddTrackedObject(_shaderResourceView.ComPointer, this);
//Setup each render target view for each face
for (int i = 0; i < 6; i++)
{
D3D.RenderTargetViewDescription rtDesc = new D3D.RenderTargetViewDescription();
rtDesc.ArraySize = 1;
rtDesc.FirstArraySlice = i;
if (multiSampleCount > 1)
{
rtDesc.Dimension = D3D.RenderTargetViewDimension.Texture2DMultisampledArray;
}
else
{
rtDesc.Dimension = D3D.RenderTargetViewDimension.Texture2DArray;
}
rtDesc.Format = desc2D.Format;
_renderTargetView[i] = new D3D.RenderTargetView(_graphicsDevice, _texture2D, rtDesc);
_graphicsDevice.ClearRenderTargetView(_renderTargetView[i], new SDX.Color4(1.0f, 0, 0, 0));
_renderer.Resources.AddTrackedObject(_renderTargetView[i].ComPointer, this);
}
_mipCount = _texture2D.Description.MipLevels;
if (depthFormat != DepthFormat.None)
{
D3D.Texture2DDescription dbdesc = new D3D.Texture2DDescription();
dbdesc.ArraySize = 6;
dbdesc.BindFlags = D3D.BindFlags.DepthStencil;
dbdesc.CpuAccessFlags = D3D.CpuAccessFlags.None;
dbdesc.Format = D3D10Helper.ToD3DDepthFormat(depthFormat);
dbdesc.Height = size;
dbdesc.Width = size;
dbdesc.Usage = D3D.ResourceUsage.Default;
dbdesc.OptionFlags = D3D.ResourceOptionFlags.None;
dbdesc.MipLevels = 1;
if (multiSampleCount > 1)
{
dbdesc.SampleDescription = new SlimDX.DXGI.SampleDescription(multiSampleCount, 0);
}
else
{
dbdesc.SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0);
}
using (D3D.Texture2D depthBuffer = new D3D.Texture2D(_graphicsDevice, dbdesc)) {
_depthStencilView = new D3D.DepthStencilView(_graphicsDevice, depthBuffer);
if (depthFormat == Tesla.Graphics.DepthFormat.Depth24Stencil8)
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Depth | D3D.DepthStencilClearFlags.Stencil, 1.0f, 0);
}
else
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Depth, 1.0f, 0);
}
//Add to tracker
_renderer.Resources.AddTrackedObject(_depthStencilView.ComPointer, this);
}
}
}
public RenderTarget(D3DDevice device, int width, int height)
: base(device.Device)
{
Resource = D3D.Texture2D.FromSwapChain<D3D.Texture2D>(device.SwapChain, 0);
RenderView = new D3D.RenderTargetView(device.Device, Resource);
}
/// <summary>
/// Basic DX10 initialization. It contains: creating a window, device, swap chain, render targets, viewPort
/// </summary>
private void InitializeDX()
{
//Initializing window
window = new Form();
window.ClientSize = new Size(width, height);
window.Text = "Quinta Essentia Engine ver. 0.03";
//Creating device and swap chain (first filling the description structures)
modeDesc = new SlimDX.DXGI.ModeDescription();
modeDesc.Format = DXGI.Format.R8G8B8A8_UNorm;
modeDesc.RefreshRate = new Rational(60, 1);
modeDesc.Scaling = DXGI.DisplayModeScaling.Unspecified;
modeDesc.ScanlineOrdering = DXGI.DisplayModeScanlineOrdering.Unspecified;
modeDesc.Width = width;
modeDesc.Height = height;
DXGI.SampleDescription sampleDesc = new SlimDX.DXGI.SampleDescription();
sampleDesc.Count = 1;
sampleDesc.Quality = 0;
DXGI.SwapChainDescription swapDesc = new SlimDX.DXGI.SwapChainDescription();
swapDesc.BufferCount = 1;
swapDesc.IsWindowed = windowed;
swapDesc.Flags = DXGI.SwapChainFlags.AllowModeSwitch;
swapDesc.ModeDescription = modeDesc;
swapDesc.OutputHandle = window.Handle;
swapDesc.SampleDescription = sampleDesc;
swapDesc.SwapEffect = DXGI.SwapEffect.Discard;
swapDesc.Usage = DXGI.Usage.RenderTargetOutput;
//DEBUG FLAG ON!!! REMEMBER THIS!
D3D10.Device.CreateWithSwapChain(null, SlimDX.Direct3D10.DriverType.Hardware,
SlimDX.Direct3D10.DeviceCreationFlags.Debug, swapDesc, out device, out swapChain);
//making and setting the new viewport
viewPort = new Viewport();
viewPort.Height = height;
viewPort.Width = width;
viewPort.MaxZ = 1.0f;
viewPort.MinZ = 0.0f;
viewPort.X = 0;
viewPort.Y = 0;
device.Rasterizer.SetViewports(viewPort);
//making main render target (it is bind with back buffer of swap chain)
using (D3D10.Texture2D temp = swapChain.GetBuffer<D3D10.Texture2D>(0))
{
renderTarget = new SlimDX.Direct3D10.RenderTargetView(device, temp);
}
CreateDepthStencil();
device.OutputMerger.SetTargets(depthStencilView, renderTarget);
}
//other functions
/// <summary>
/// Allows you to change window size during runtime
/// </summary>
/// <param name="width">New width of the window</param>
/// <param name="height">New height of the window</param>
void ChangeWindowSize(int w, int h)
{
if (width > 0 && height > 0)
{
width = w;
height = h;
window.Width = w;
window.Height = h;
viewPort.Height = height;
viewPort.Width = width;
device.Rasterizer.SetViewports(viewPort);
modeDesc.Width = width;
modeDesc.Height = height;
swapChain.ResizeTarget(modeDesc);
renderTarget.Dispose();
depthStencilView.Dispose();
swapChain.ResizeBuffers(1, width, height, modeDesc.Format, DXGI.SwapChainFlags.AllowModeSwitch);
using (D3D10.Texture2D temp = swapChain.GetBuffer<D3D10.Texture2D>(0))
{
renderTarget = new SlimDX.Direct3D10.RenderTargetView(device, temp);
}
CreateDepthStencil();
device.OutputMerger.SetTargets(depthStencilView, renderTarget);
sceneManager.WindowResized();
}
}
/// <summary>
/// Clears the active targets, or back buffer if there are none.
/// </summary>
/// <param name="options"></param>
/// <param name="color"></param>
/// <param name="depth"></param>
/// <param name="stencil"></param>
public void ClearTargets(ClearOptions options, Color color, float depth, int stencil)
{
D3D10Helper.CheckDisposed(_graphicsDevice);
SlimDX.Color4 sc;
D3D10Helper.Convert(ref color, out sc);
if (_currentRenderTargetCount == 0 && _activeBackBuffer != null)
{
D3D10Helper.CheckDisposed(_activeBackBuffer);
if (_activeBackBuffer.D3D10DepthStencilView != null)
{
if (((options & ClearOptions.Depth) == ClearOptions.Depth) && ((options & ClearOptions.Stencil) == ClearOptions.Stencil))
{
_graphicsDevice.ClearDepthStencilView(_activeBackBuffer.D3D10DepthStencilView, D3D.DepthStencilClearFlags.Depth | D3D.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
}
else if ((options & ClearOptions.Depth) == ClearOptions.Depth)
{
_graphicsDevice.ClearDepthStencilView(_activeBackBuffer.D3D10DepthStencilView, D3D.DepthStencilClearFlags.Depth, depth, (byte)stencil);
}
else if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
{
_graphicsDevice.ClearDepthStencilView(_activeBackBuffer.D3D10DepthStencilView, D3D.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
}
}
if ((_activeBackBuffer.D3D10RenderTargetView != null) && ((options & ClearOptions.Target) == ClearOptions.Target))
{
_graphicsDevice.ClearRenderTargetView(_activeBackBuffer.D3D10RenderTargetView, sc);
}
}
else
{
for (int i = 0; i < _currentRenderTargetCount; i++)
{
RenderTargetBinding binding = _currentRenderTargets[i];
D3D.DepthStencilView dsv = null;
D3D.RenderTargetView rtv = null;
if (!binding.IsRenderTargetCube)
{
D3D10Texture2DImplementation impl2D = binding.RenderTarget2D.Implementation as D3D10Texture2DImplementation;
D3D10Helper.CheckDisposed(impl2D);
dsv = impl2D.D3D10DepthStencilView;
rtv = impl2D.D3D10RenderTargetVew;
}
else
{
D3D10TextureCubeImplementation implcube = binding.RenderTargetCube.Implementation as D3D10TextureCubeImplementation;
D3D10Helper.CheckDisposed(implcube);
dsv = implcube.D3D10DepthStencilView;
rtv = implcube.GetRenderTargetView(binding.CubeMapFace);
}
if (dsv != null)
{
if (((options & ClearOptions.Depth) == ClearOptions.Depth) && ((options & ClearOptions.Stencil) == ClearOptions.Stencil))
{
_graphicsDevice.ClearDepthStencilView(dsv, D3D.DepthStencilClearFlags.Depth | D3D.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
}
else if ((options & ClearOptions.Depth) == ClearOptions.Depth)
{
_graphicsDevice.ClearDepthStencilView(dsv, D3D.DepthStencilClearFlags.Depth, depth, (byte)stencil);
}
else if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
{
_graphicsDevice.ClearDepthStencilView(dsv, D3D.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
}
}
if ((rtv != null) && ((options & ClearOptions.Target) == ClearOptions.Target))
{
_graphicsDevice.ClearRenderTargetView(rtv, sc);
}
}
}
}
