/// <summary>
/// Binds a single viewport to the rasterizer stage.
/// </summary>
/// <param name="viewport">The viewport.</param>
/// <remarks>
/// <p></p><p>All viewports must be set atomically as one operation. Any viewports not defined by the call are disabled.</p><p>Which viewport to use is determined by the SV_ViewportArrayIndex semantic output by a geometry shader; if a geometry shader does not specify the semantic, Direct3D will use the first viewport in the array.</p>
/// </remarks>
/// <msdn-id>ff476480</msdn-id>
/// <unmanaged>void ID3D11DeviceContext::RSSetViewports([In] unsigned int NumViewports,[In, Buffer, Optional] const void* pViewports)</unmanaged>
/// <unmanaged-short>ID3D11DeviceContext::RSSetViewports</unmanaged-short>
public void SetViewport(RawViewportF viewport)
{
unsafe
{
SetViewports(1, new IntPtr(Interop.Fixed(ref viewport)));
}
}
/// <summary>
/// Initializes all the DirectX boilerplate required to render models.
/// </summary>
/// <param name="windowName">The name of the application window.</param>
/// <param name="windowWidth">Window width in pixels.</param>
/// <param name="windowHeight">Window height in pixels.</param>
/// <param name="fps">Target frames per second.</param>
public Renderer(string windowName, int windowWidth, int windowHeight, int fps)
{
form = new RenderForm(windowName);
form.Width = windowWidth;
form.Height = windowHeight;
swapChainDescription = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(form.Width, form.Height,
new Rational(fps, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, swapChainDescription, out device, out swapChain);
context = device.ImmediateContext;
// Ignore all windows events
factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);
// Create render view and depth buffer
backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
renderView = new RenderTargetView(device, backBuffer);
var depthBuffer = new Texture2D(device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = form.Width,
Height = form.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
depthView = new DepthStencilView(device, depthBuffer);
var viewport = new RawViewportF();
viewport.Width = form.Width;
viewport.Height = form.Height;
viewport.X = 0;
viewport.Y = 0;
viewport.MinDepth = 0f;
viewport.MaxDepth = 1f;
context.Rasterizer.SetViewport(viewport);
context.OutputMerger.SetTargets(depthView, renderView);
}
/// <summary>
/// Binds a single viewport to the rasterizer stage.
/// </summary>
/// <param name="x">The x coordinate of the viewport.</param>
/// <param name="y">The y coordinate of the viewport.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="minZ">The min Z.</param>
/// <param name="maxZ">The max Z.</param>
/// <remarks>
/// <p></p><p>All viewports must be set atomically as one operation. Any viewports not defined by the call are disabled.</p><p>Which viewport to use is determined by the SV_ViewportArrayIndex semantic output by a geometry shader; if a geometry shader does not specify the semantic, Direct3D will use the first viewport in the array.</p>
/// </remarks>
/// <msdn-id>ff476480</msdn-id>
/// <unmanaged>void ID3D11DeviceContext::RSSetViewports([In] unsigned int NumViewports,[In, Buffer, Optional] const void* pViewports)</unmanaged>
/// <unmanaged-short>ID3D11DeviceContext::RSSetViewports</unmanaged-short>
public void SetViewport(float x, float y, float width, float height, float minZ = 0.0f, float maxZ = 1.0f)
{
var viewport = new RawViewportF()
{
X = x, Y = y, Width = width, Height = height, MinDepth = minZ, MaxDepth = maxZ
};
unsafe
{
SetViewports(1, new IntPtr(&viewport));
}
}
public override void SetViewport(uint index, ref Viewport viewport)
{
_viewportsChanged = true;
Util.EnsureArrayMinimumSize(ref _viewports, index + 1);
_viewports[index] = new RawViewportF
{
X = viewport.X,
Y = viewport.Y,
Width = viewport.Width,
Height = viewport.Height,
MinDepth = viewport.MinDepth,
MaxDepth = viewport.MaxDepth
};
}
internal void SetViewport(float x, float y, float width, float height, float minZ = 0f, float maxZ = 1f)
{
RawViewportF viewport = new RawViewportF
{
X = x,
Y = y,
Width = width,
Height = height,
MinDepth = minZ,
MaxDepth = maxZ
};
SetViewport(viewport);
CheckErrors();
}
internal void SetViewport(RawViewportF viewport)
{
if (viewport.X != m_viewport.X ||
viewport.Y != m_viewport.Y ||
viewport.Width != m_viewport.Width ||
viewport.Height != m_viewport.Height ||
viewport.MinDepth != m_viewport.MinDepth ||
viewport.MaxDepth != m_viewport.MaxDepth)
{
m_viewport = viewport;
m_deviceContext.Rasterizer.SetViewport(viewport);
m_statistics.SetViewports++;
}
}
internal void Clear()
{
if (m_deviceContext != null)
{
m_deviceContext.ClearState();
}
m_inputLayout = null;
m_primitiveTopology = PrimitiveTopology.Undefined;
m_indexBufferRef = null;
m_indexBufferFormat = 0;
m_indexBufferOffset = 0;
for (int i = 0; i < m_vertexBuffers.Length; i++)
{
m_vertexBuffers[i] = null;
}
for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
{
m_vertexBuffersStrides[i] = 0;
}
for (int i = 0; i < m_vertexBuffersByteOffset.Length; i++)
{
m_vertexBuffersByteOffset[i] = 0;
}
m_blendState = null;
m_stencilRef = 0;
m_depthStencilState = null;
m_rtvsCount = 0;
for (int i = 0; i < m_rtvs.Length; i++)
{
m_rtvs[i] = null;
}
m_dsv = null;
m_rasterizerState = null;
m_scissorLeftTop = new Vector2I(-1, -1);
m_scissorRightBottom = new Vector2I(-1, -1);
m_viewport = default(RawViewportF);
m_targetBuffer = null;
m_targetOffsets = 0;
if (m_statistics != null)
{
m_statistics.ClearStates++;
}
}
public static void Resize(PictureBox f)
{
if (renderTargetView != null)
{
renderTargetView.Dispose();
}
backBuffer.Dispose();
swapChain.ResizeBuffers(1, f.ClientSize.Width, f.ClientSize.Height, SharpDX.DXGI.Format.Unknown, SwapChainFlags.AllowModeSwitch);
backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
renderTargetView = new RenderTargetView(device, backBuffer);
viewport = new RawViewportF();
viewport.X = 0;
viewport.Y = 0;
viewport.Width = f.ClientSize.Width;
viewport.Height = f.ClientSize.Height;
context.Rasterizer.SetViewport(viewport);
proj = Matrix.PerspectiveFovLH((float)Math.PI / 3f, f.ClientSize.Width / (float)f.ClientSize.Height, 0.5f, 100f);
}
public void Resize(PictureBox f)
{
if (renderTargetView != null)
{
renderTargetView.Dispose();
}
if (depthStencilView != null)
{
depthStencilView.Dispose();
}
if (backBuffer != null)
{
backBuffer.Dispose();
}
swapChain.ResizeBuffers(1, f.ClientSize.Width, f.ClientSize.Height, Format.Unknown, SwapChainFlags.AllowModeSwitch);
viewport = new RawViewportF();
viewport.X = 0;
viewport.Y = 0;
viewport.Width = f.ClientSize.Width;
viewport.Height = f.ClientSize.Height;
viewport.MinDepth = 0;
viewport.MaxDepth = 1;
backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
renderTargetView = new RenderTargetView(device, backBuffer);
Texture2D depthBuffer = new Texture2D(device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = f.ClientSize.Width,
Height = f.ClientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
depthStencilView = new DepthStencilView(device, depthBuffer);
context.Rasterizer.SetViewport(viewport);
context.OutputMerger.SetTargets(depthStencilView, renderTargetView);
context.OutputMerger.SetRenderTargets(depthStencilView, renderTargetView);
proj = Matrix.PerspectiveFovLH((float)Math.PI / 3f, f.ClientSize.Width / (float)f.ClientSize.Height, 0.5f, 100000f);
}
public static void Initialize(Window window)
{
var wpd = window.GetPlatformData();
if (wpd.Backend != WindowingBackend.Win32)
{
throw new PlatformNotSupportedException($"The DirectX sample only runs on Win32, but the current backend is {wpd.Backend}.");
}
var wd = (Win32WindowData)wpd;
ModeDescription backBufferDesc = new ModeDescription(600, 600, new Rational(60, 1), Format.R8G8B8A8_UNorm);
SwapChainDescription swapChainDesc = new SwapChainDescription()
{
ModeDescription = backBufferDesc,
SampleDescription = new SampleDescription(1, 0),
Usage = Usage.RenderTargetOutput,
BufferCount = 1,
OutputHandle = wd.Hwnd,
IsWindowed = true
};
D3D11.Device.CreateWithSwapChain(DriverType.Hardware, D3D11.DeviceCreationFlags.None, swapChainDesc,
out _d3dDevice, out _swapChain);
_d3dDeviceContext = _d3dDevice.ImmediateContext;
using (D3D11.Texture2D backBuffer = _swapChain.GetBackBuffer <D3D11.Texture2D>(0))
{
_renderTargetView = new D3D11.RenderTargetView(_d3dDevice, backBuffer);
}
_viewport = new RawViewportF
{
X = 0,
Y = 0,
Width = 600,
Height = 600
};
_d3dDeviceContext.Rasterizer.SetViewport(_viewport);
}
private void InitializeDeviceResources()
{
//format is rgba with 32 but unsigned ints
var backBufferDescription = new ModeDescription(Width, Height, new Rational(60, 1), Format.R8G8B8A8_UNorm);
var swapChainDesc = new SwapChainDescription
{
ModeDescription = backBufferDescription,
SampleDescription = new SampleDescription(1, 0),
Usage = Usage.RenderTargetOutput,
BufferCount = 1,
OutputHandle = _renderForm.Handle,
IsWindowed = true
};
D3D11.Device.CreateWithSwapChain(
DriverType.Hardware,
D3D11.DeviceCreationFlags.None,
swapChainDesc,
out _d3DDevice,
out _swapChain);
_d3DDeviceContext = _d3DDevice.ImmediateContext;
using (D3D11.Texture2D backBuffer = _swapChain.GetBackBuffer <D3D11.Texture2D>(0))
{
_renderTargetView = new D3D11.RenderTargetView(_d3DDevice, backBuffer);
}
// Set viewport
_viewPort = new RawViewportF
{
Height = Height,
Width = Width,
MaxDepth = 1.0f,
MinDepth = 0.0f,
X = 0,
Y = 0
};
_d3DDeviceContext.Rasterizer.SetViewport(_viewPort);
}
public void Submit()
{
foreach (var command in _commandList)
{
switch (command.Type)
{
case CommandType.Begin:
break;
case CommandType.End:
break;
case CommandType.Draw:
_graphicsDevice.NativeDeviceContext.Draw(command.VertexCount, command.VertexOffset);
break;
case CommandType.DrawIndexed:
_graphicsDevice.NativeDeviceContext.DrawIndexed(command.IndexCount, command.IndexOffset, command.VertexOffset);
break;
case CommandType.SetViewport:
var viewport = new RawViewportF();
viewport.X = command.Viewport.X;
viewport.Y = command.Viewport.Y;
viewport.Width = command.Viewport.Width;
viewport.Height = command.Viewport.Height;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
_graphicsDevice.NativeDeviceContext.Rasterizer.SetViewport(viewport);
break;
case CommandType.SetScissor:
_graphicsDevice.NativeDeviceContext.Rasterizer.SetScissorRectangle(command.ScissorRectangle.Left, command.ScissorRectangle.Top, command.ScissorRectangle.Right, command.ScissorRectangle.Bottom);
break;
case CommandType.SetPrimitiveTopology:
_graphicsDevice.NativeDeviceContext.InputAssembler.PrimitiveTopology = command.PrimitiveTopology.ToSharpDX();
break;
case CommandType.SetInputLayout:
_graphicsDevice.NativeDeviceContext.InputAssembler.InputLayout = command.InputLayout;
break;
case CommandType.SetDepthStencilState:
_graphicsDevice.NativeDeviceContext.OutputMerger.DepthStencilState = command.DepthStencilState;
break;
case CommandType.SetRasterizerState:
_graphicsDevice.NativeDeviceContext.Rasterizer.State = command.RasterizerState;
break;
case CommandType.SetBlendState:
_graphicsDevice.NativeDeviceContext.OutputMerger.BlendFactor = new RawColor4(0, 0, 0, 0);
_graphicsDevice.NativeDeviceContext.OutputMerger.BlendState = command.BlendState;
break;
case CommandType.SetVertexBuffer:
_graphicsDevice.NativeDeviceContext.InputAssembler.SetVertexBuffers(0, command.VertexBufferBinding);
break;
case CommandType.SetIndexBuffer:
_graphicsDevice.NativeDeviceContext.InputAssembler.SetIndexBuffer(command.IndexBuffer, command.IndexBufferFormat.ToSharpDX(), command.IndexOffset);
break;
case CommandType.SetVertexShader:
_graphicsDevice.NativeDeviceContext.VertexShader.Set(command.VertexShader);
break;
case CommandType.SetPixelShader:
_graphicsDevice.NativeDeviceContext.PixelShader.Set(command.PixelShader);
break;
case CommandType.SetComputeShader:
_graphicsDevice.NativeDeviceContext.ComputeShader.Set(command.ComputeShader);
break;
case CommandType.SetConstantBuffers:
switch (command.ConstantBufferScope)
{
case BufferScope.VertexShader:
_graphicsDevice.NativeDeviceContext.VertexShader.SetConstantBuffer(command.ConstantBuffersStartSlot, command.ConstantBuffer);
break;
case BufferScope.PixelShader:
_graphicsDevice.NativeDeviceContext.PixelShader.SetConstantBuffer(command.ConstantBuffersStartSlot, command.ConstantBuffer);
break;
case BufferScope.Global:
_graphicsDevice.NativeDeviceContext.VertexShader.SetConstantBuffer(command.ConstantBuffersStartSlot, command.ConstantBuffer);
_graphicsDevice.NativeDeviceContext.PixelShader.SetConstantBuffer(command.ConstantBuffersStartSlot, command.ConstantBuffer);
break;
case BufferScope.NotAssigned:
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case CommandType.SetSamplers:
_graphicsDevice.NativeDeviceContext.PixelShader.SetSamplers(command.SamplersStartSlot, command.SamplerCount, command.Samplers);
break;
case CommandType.SetTextures:
_graphicsDevice.NativeDeviceContext.PixelShader.SetShaderResources(command.TexturesStartSlot, command.TextureCount, command.Textures);
break;
case CommandType.SetRenderTarget:
_graphicsDevice.NativeDeviceContext.OutputMerger.SetRenderTargets(command.RenderTargetDepthStencil, command.RenderTarget);
break;
case CommandType.SetRenderTargets:
_graphicsDevice.NativeDeviceContext.OutputMerger.SetRenderTargets(command.RenderTargetDepthStencil, command.RenderTargets);
break;
case CommandType.ClearRenderTarget:
_graphicsDevice.NativeDeviceContext.ClearRenderTargetView(command.RenderTarget, command.RenderTargetClearColor);
break;
case CommandType.ClearDepthStencil:
var depthStencilClearFlags = DepthStencilClearFlags.Depth;
_graphicsDevice.NativeDeviceContext.ClearDepthStencilView(command.RenderTargetDepthStencil, depthStencilClearFlags, command.DepthClear, command.DepthClearStencil);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
private void Update(EvaluationContext context)
{
var updateLive = UpdateLive.GetValue(context);
if (_updatedOnce && !updateLive)
{
FilteredCubeMap.Value = _prefilteredCubeMap;
return;
}
var exposure = Exposure.GetValue(context);
//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 parameterData = _samplingParameters[indexToUse];
parameterData.roughness = roughness;
parameterData.exposure = exposure;
ResourceManager.Instance().SetupConstBuffer(parameterData, 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;
}
/// <summary>
/// スワップチェーンが変更された時に呼び出される
/// </summary>
/// <param name="device"></param>
/// <param name="swapChain"></param>
/// <param name="desc">変更後のスワップチェーン情報</param>
public override void OnSwapChainResized(SharpDX.Direct3D11.Device device, SwapChain swapChain, SwapChainDescription desc)
{
if (!m_isCreated)
{
return;
}
int mx = (int)(System.Math.Max(desc.ModeDescription.Width, desc.ModeDescription.Height));
int r = 2;
while ((r *= 2) < mx)
{
;
}
if (r != m_mainTxLenght)
{
m_mainTxLenght = r;
//=====================================
// テクスチャー作成
if (m_hMainRT == null)
{
App.ImageMgr.GetTexture("2D_main_screen", out m_hMainRT);
}
if (m_hTx == null)
{
m_hTx = GetCreateRenderTargetTexture2D("2D_Technique", m_mainTxLenght, m_mainTxLenght);
}
else
{
m_hTx.ReSize2D(m_mainTxLenght, m_mainTxLenght);
}
if (m_hPrintSTx == null)
{
App.ImageMgr.GetTexture("PrintScreen", out m_hPrintSTx);
}
//=====================================
// 通常スプライト作成
if (m_drawSprite == null)
{
MCRect rc = new MCRect();
rc.SetXYWH(0, 0, m_mainTxLenght, m_mainTxLenght);
m_sprite = (MCSprite)m_spriteRegister.CreateSpriteFromTextureName("2D_Technique", rc.X, rc.Y, rc.Width, rc.Heith);
m_drawSprite = m_spriteRegister.CreateDrawSprite(m_sprite);
//=====================================
// マップチップ用のスプライト作成
m_drawSprite.D2RenderType = (int)SPRITE_TYPE.DEFAULT;
m_drawSprite.Position = new MCVector3(
(float)System.Math.Ceiling(m_mainTxLenght * 0.5f),
(float)System.Math.Ceiling(m_mainTxLenght * 0.5f), 0
);
}
else
{
MCRect rc = new MCRect();
rc.SetXYWH(0, 0, m_mainTxLenght, m_mainTxLenght);
m_sprite.ResetRect(rc);
m_drawSprite.Position = new MCVector3(
(float)System.Math.Ceiling(m_mainTxLenght * 0.5f),
(float)System.Math.Ceiling(m_mainTxLenght * 0.5f), 0
);
}
//=====================================
// カメラの作成
if (m_isConstCoordinate)
{
if (m_hTxCamera == null)
{
CreateViewTextureCamera("FixedCameraSpriteD2Screen");
}
}
else
{
if (m_hTxCamera == null)
{
CreateViewTextureCamera("MCTexture");
}
}
if (m_hTxCamera != null)
{
MCTextureCamera hTmp = (MCTextureCamera)m_hTxCamera;
hTmp.SetTextureSize(m_mainTxLenght, m_mainTxLenght);
}
// ビューポートの設定
m_aVP = new RawViewportF[] { new RawViewportF()
{
X = 0,
Y = 0,
Width = m_mainTxLenght,
Height = m_mainTxLenght,
MinDepth = 0,
MaxDepth = 1.0f,
} };
}
}
public void SetViewport(RawViewportF viewport)
{
_dx11Device?.ImmediateContext.Rasterizer.SetViewport(viewport);
}
public virtual void Bind(Renderer renderer)
{
if (renderer.ActiveRenderTarget != _lastRenderTarget.Get(renderer))
{
_lastRenderTarget.Set(renderer, renderer.ActiveRenderTarget);
}
renderer.ActiveRenderTarget = this;
RenderTargetView[] rtViews = _renderTargetViews.Get(renderer);
if (rtViews == null || rtViews.Length != ColorBuffer.Count)
{
rtViews = new RenderTargetView[ColorBuffer.Count];
_renderTargetViews.Set(renderer, rtViews);
}
RawViewportF[] viewports = _viewports.Get(renderer);
if (viewports == null || viewports.Length != ColorBuffer.Count)
{
viewports = new RawViewportF[ColorBuffer.Count];
_viewports.Set(renderer, viewports);
}
for (int i = 0; i < rtViews.Length; i++)
{
rtViews[i] = ColorBuffer[i].GetRenderTargetView(renderer);
viewports[i] = new RawViewportF {
X = 0, Y = 0, Width = ColorBuffer[i].Width, Height = ColorBuffer[i].Height, MinDepth = 0, MaxDepth = 1
};
if (ColorBuffer[i] is TextureColorBuffer)
{
(ColorBuffer[i] as TextureColorBuffer).InvalidateMipMaps(renderer);
}
}
if (DepthStencilBuffer == null)
{
renderer.DeviceContext.OutputMerger.SetTargets(rtViews.Length > 0 ? rtViews : null);
}
else
{
renderer.DeviceContext.OutputMerger.SetTargets(DepthStencilBuffer.GetDepthStencilView(renderer), rtViews.Length > 0 ? rtViews : null);
}
renderer.DeviceContext.Rasterizer.SetViewports(viewports, viewports.Length);
if (this.RasterizerState != null)
{
this.RasterizerState.Bind(renderer);
}
if (this.DepthStencilState != null)
{
this.DepthStencilState.Bind(renderer);
}
if (this.BlendState != null)
{
this.BlendState.Bind(renderer);
}
}
