private static void CreateBitmapTexture(D3D11Device device, string fileName, out D3D11ShaderResourceView textureView)
{
int width;
int height;
byte[] bytes;
using (var file = new Bitmap(fileName))
{
var rect = new Rectangle(0, 0, file.Width, file.Height);
int length = file.Width * file.Height;
width = file.Width;
height = file.Height;
bytes = new byte[length * 4];
using (var bitmap = file.Clone(rect, PixelFormat.Format32bppArgb))
{
BitmapData data = bitmap.LockBits(rect, ImageLockMode.ReadOnly, bitmap.PixelFormat);
try
{
Marshal.Copy(data.Scan0, bytes, 0, length * 4);
}
finally
{
bitmap.UnlockBits(data);
}
}
}
D3D11SubResourceData[] textureSubResData = new[]
{
new D3D11SubResourceData(bytes, (uint)width * 4)
};
var textureDesc = new D3D11Texture2DDesc(DxgiFormat.B8G8R8A8UNorm, (uint)width, (uint)height, 1, 1);
using (var texture = device.CreateTexture2D(textureDesc, textureSubResData))
{
var textureViewDesc = new D3D11ShaderResourceViewDesc
{
Format = textureDesc.Format,
ViewDimension = D3D11SrvDimension.Texture2D,
Texture2D = new D3D11Texture2DSrv
{
MipLevels = textureDesc.MipLevels,
MostDetailedMip = 0
}
};
textureView = device.CreateShaderResourceView(texture, textureViewDesc);
}
}
protected override D3D11Texture2D OnCreateBackBuffer()
{
D3D11Texture2DDesc backBufferDesc = new D3D11Texture2DDesc(
DxgiFormat.B8G8R8A8UNorm,
this.width,
this.height,
1,
1,
D3D11BindOptions.RenderTarget,
D3D11Usage.Default,
D3D11CpuAccessOptions.None,
1,
0,
D3D11ResourceMiscOptions.None);
return(this.D3DDevice.CreateTexture2D(backBufferDesc));
}
private void CreateTexture(byte[] data, uint width, uint height, out D3D11Texture2D texture, out D3D11ShaderResourceView textureView)
{
D3D11Texture2DDesc textureDesc = new D3D11Texture2DDesc(DxgiFormat.R8G8B8A8UNorm, width, height, 1, 1);
D3D11SubResourceData[] textureSubResData = new[]
{
new D3D11SubResourceData(data, width * 4)
};
D3D11Texture2D texture2D = this.d3dDevice.CreateTexture2D(textureDesc, textureSubResData);
D3D11ShaderResourceView shaderResourceView;
try
{
D3D11ShaderResourceViewDesc textureViewDesc = new D3D11ShaderResourceViewDesc
{
Format = textureDesc.Format,
ViewDimension = D3D11SrvDimension.Texture2D,
Texture2D = new D3D11Texture2DSrv
{
MipLevels = textureDesc.MipLevels,
MostDetailedMip = 0
}
};
shaderResourceView = this.d3dDevice.CreateShaderResourceView(texture2D, textureViewDesc);
}
catch
{
D3D11Utils.DisposeAndNull(ref texture2D);
throw;
}
texture = texture2D;
textureView = shaderResourceView;
}
private static void CreateD3DResources(
D3D11Device device,
D3D11ResourceDimension resDim,
int width,
int height,
int depth,
int mipCount,
int arraySize,
DxgiFormat format,
D3D11Usage usage,
D3D11BindOptions bindFlags,
D3D11CpuAccessOptions cpuAccessFlags,
D3D11ResourceMiscOptions miscFlags,
bool forceSRGB,
bool isCubeMap,
D3D11SubResourceData[] initData,
out D3D11Resource texture,
out D3D11ShaderResourceView textureView)
{
texture = null;
textureView = null;
if (forceSRGB)
{
format = (DxgiFormat)DdsHelpers.MakeSrgb((DdsFormat)format);
}
switch (resDim)
{
case D3D11ResourceDimension.Texture1D:
{
var desc = new D3D11Texture1DDesc(
format,
(uint)width,
(uint)arraySize,
(uint)mipCount,
bindFlags,
usage,
cpuAccessFlags,
miscFlags & ~D3D11ResourceMiscOptions.TextureCube);
texture = device.CreateTexture1D(desc, initData);
try
{
var SRVDesc = new D3D11ShaderResourceViewDesc
{
Format = format
};
if (arraySize > 1)
{
SRVDesc.ViewDimension = D3D11SrvDimension.Texture1DArray;
SRVDesc.Texture1DArray = new D3D11Texture1DArraySrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels,
ArraySize = (uint)arraySize
};
}
else
{
SRVDesc.ViewDimension = D3D11SrvDimension.Texture1D;
SRVDesc.Texture1D = new D3D11Texture1DSrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels
};
}
textureView = device.CreateShaderResourceView(texture, SRVDesc);
}
catch
{
D3D11Utils.DisposeAndNull(ref texture);
throw;
}
break;
}
case D3D11ResourceDimension.Texture2D:
{
var desc = new D3D11Texture2DDesc(
format,
(uint)width,
(uint)height,
(uint)arraySize,
(uint)mipCount,
bindFlags,
usage,
cpuAccessFlags,
1,
0);
if (isCubeMap)
{
desc.MiscOptions = miscFlags | D3D11ResourceMiscOptions.TextureCube;
}
else
{
desc.MiscOptions = miscFlags & ~D3D11ResourceMiscOptions.TextureCube;
}
if (format == DxgiFormat.BC1UNorm || format == DxgiFormat.BC2UNorm || format == DxgiFormat.BC3UNorm)
{
if ((width & 3) != 0 || (height & 3) != 0)
{
desc.Width = (uint)(width + 3) & ~3U;
desc.Height = (uint)(height + 3) & ~3U;
}
}
texture = device.CreateTexture2D(desc, initData);
try
{
var SRVDesc = new D3D11ShaderResourceViewDesc
{
Format = format
};
if (isCubeMap)
{
if (arraySize > 6)
{
SRVDesc.ViewDimension = D3D11SrvDimension.TextureCubeArray;
SRVDesc.TextureCubeArray = new D3D11TextureCubeArraySrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels,
// Earlier we set arraySize to (NumCubes * 6)
NumCubes = (uint)arraySize / 6
};
}
else
{
SRVDesc.ViewDimension = D3D11SrvDimension.TextureCube;
SRVDesc.TextureCube = new D3D11TextureCubeSrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels,
};
}
}
else if (arraySize > 1)
{
SRVDesc.ViewDimension = D3D11SrvDimension.Texture2DArray;
SRVDesc.Texture2DArray = new D3D11Texture2DArraySrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels,
ArraySize = (uint)arraySize
};
}
else
{
SRVDesc.ViewDimension = D3D11SrvDimension.Texture2D;
SRVDesc.Texture2D = new D3D11Texture2DSrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels,
};
}
textureView = device.CreateShaderResourceView(texture, SRVDesc);
}
catch
{
D3D11Utils.DisposeAndNull(ref texture);
throw;
}
break;
}
case D3D11ResourceDimension.Texture3D:
{
var desc = new D3D11Texture3DDesc(
format,
(uint)width,
(uint)height,
(uint)depth,
(uint)mipCount,
bindFlags,
usage,
cpuAccessFlags,
miscFlags & ~D3D11ResourceMiscOptions.TextureCube);
texture = device.CreateTexture3D(desc, initData);
try
{
var SRVDesc = new D3D11ShaderResourceViewDesc
{
Format = format,
ViewDimension = D3D11SrvDimension.Texture3D,
Texture3D = new D3D11Texture3DSrv
{
MipLevels = (mipCount == 0) ? uint.MaxValue : desc.MipLevels,
}
};
textureView = device.CreateShaderResourceView(texture, SRVDesc);
}
catch
{
D3D11Utils.DisposeAndNull(ref texture);
throw;
}
break;
}
}
}
protected override void CreateDeviceDependentResources()
{
base.CreateDeviceDependentResources();
byte[] vertexShaderBytecode = File.ReadAllBytes(Lesson4Game.ShadersDirectory + "Textures.VertexShader.cso");
this.vertexShader = this.DeviceResources.D3DDevice.CreateVertexShader(vertexShaderBytecode, null);
D3D11InputElementDesc[] basicVertexLayoutDesc = new D3D11InputElementDesc[]
{
new D3D11InputElementDesc
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 0,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "NORMAL",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 12,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = DxgiFormat.R32G32Float,
InputSlot = 0,
AlignedByteOffset = 24,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
this.inputLayout = this.DeviceResources.D3DDevice.CreateInputLayout(basicVertexLayoutDesc, vertexShaderBytecode);
byte[] pixelShaderBytecode = File.ReadAllBytes(Lesson4Game.ShadersDirectory + "Textures.PixelShader.cso");
this.pixelShader = this.DeviceResources.D3DDevice.CreatePixelShader(pixelShaderBytecode, null);
var vertexBufferDesc = D3D11BufferDesc.From(cubeVertices, D3D11BindOptions.VertexBuffer);
this.vertexBuffer = this.DeviceResources.D3DDevice.CreateBuffer(vertexBufferDesc, cubeVertices, 0, 0);
var indexBufferDesc = D3D11BufferDesc.From(cubeIndices, D3D11BindOptions.IndexBuffer);
this.indexBuffer = this.DeviceResources.D3DDevice.CreateBuffer(indexBufferDesc, cubeIndices, 0, 0);
var constantBufferDesc = new D3D11BufferDesc(ConstantBufferData.Size, D3D11BindOptions.ConstantBuffer);
this.constantBuffer = this.DeviceResources.D3DDevice.CreateBuffer(constantBufferDesc);
this.constantBufferData.View = new Float4X4(
-1.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
0.00000000f, 0.89442718f, 0.44721359f, 0.00000000f,
0.00000000f, 0.44721359f, -0.89442718f, -2.23606800f,
0.00000000f, 0.00000000f, 0.00000000f, 1.00000000f
);
byte[] textureData = File.ReadAllBytes("../../texturedata.bin");
D3D11Texture2DDesc textureDesc = new D3D11Texture2DDesc(DxgiFormat.R8G8B8A8UNorm, 256, 256, 1, 1);
D3D11SubResourceData[] textureSubResData = new[]
{
new D3D11SubResourceData(textureData, 1024)
};
using (var texture = this.DeviceResources.D3DDevice.CreateTexture2D(textureDesc, textureSubResData))
{
D3D11ShaderResourceViewDesc textureViewDesc = new D3D11ShaderResourceViewDesc
{
Format = textureDesc.Format,
ViewDimension = D3D11SrvDimension.Texture2D,
Texture2D = new D3D11Texture2DSrv
{
MipLevels = textureDesc.MipLevels,
MostDetailedMip = 0
}
};
this.textureView = this.DeviceResources.D3DDevice.CreateShaderResourceView(texture, textureViewDesc);
}
D3D11SamplerDesc samplerDesc = new D3D11SamplerDesc(
D3D11Filter.Anisotropic,
D3D11TextureAddressMode.Wrap,
D3D11TextureAddressMode.Wrap,
D3D11TextureAddressMode.Wrap,
0.0f,
this.DeviceResources.D3DFeatureLevel > D3D11FeatureLevel.FeatureLevel91 ? D3D11Constants.DefaultMaxAnisotropy : D3D11Constants.FeatureLevel91DefaultMaxAnisotropy,
D3D11ComparisonFunction.Never,
new float[] { 0.0f, 0.0f, 0.0f, 0.0f },
0.0f,
float.MaxValue);
this.sampler = this.DeviceResources.D3DDevice.CreateSamplerState(samplerDesc);
}
private void CreateTextures(OptFile opt)
{
foreach (var textureKey in opt.Textures)
{
var optTextureName = textureKey.Key;
var optTexture = textureKey.Value;
int mipLevels = optTexture.MipmapsCount;
if (mipLevels == 0)
{
continue;
}
D3D11SubResourceData[] textureSubResData = new D3D11SubResourceData[mipLevels];
int bpp = optTexture.BitsPerPixel;
if (bpp == 8)
{
List <XMUInt3> palette = Enumerable.Range(0, 256)
.Select(i =>
{
ushort c = BitConverter.ToUInt16(optTexture.Palette, 8 * 512 + i * 2);
byte r = (byte)((c & 0xF800) >> 11);
byte g = (byte)((c & 0x7E0) >> 5);
byte b = (byte)(c & 0x1F);
r = (byte)((r * (0xffU * 2) + 0x1fU) / (0x1fU * 2));
g = (byte)((g * (0xffU * 2) + 0x3fU) / (0x3fU * 2));
b = (byte)((b * (0xffU * 2) + 0x1fU) / (0x1fU * 2));
return(new XMUInt3(r, g, b));
})
.ToList();
for (int level = 0; level < mipLevels; level++)
{
byte[] imageData = optTexture.GetMipmapImageData(level, out int width, out int height);
byte[] alphaData = optTexture.GetMipmapAlphaData(level, out int w, out int h);
int size = width * height;
byte[] textureData = new byte[size * 4];
for (int i = 0; i < size; i++)
{
int colorIndex = imageData[i];
XMUInt3 color = palette[colorIndex];
textureData[i * 4 + 0] = (byte)color.Z;
textureData[i * 4 + 1] = (byte)color.Y;
textureData[i * 4 + 2] = (byte)color.X;
textureData[i * 4 + 3] = alphaData != null ? alphaData[i] : (byte)255;
}
textureSubResData[level] = new D3D11SubResourceData(textureData, (uint)width * 4);
}
}
else if (bpp == 32)
{
for (int level = 0; level < mipLevels; level++)
{
byte[] imageData = optTexture.GetMipmapImageData(level, out int width, out int height);
textureSubResData[level] = new D3D11SubResourceData(imageData, (uint)width * 4);
}
}
else
{
continue;
}
D3D11Texture2DDesc textureDesc = new D3D11Texture2DDesc(DxgiFormat.B8G8R8A8UNorm, (uint)optTexture.Width, (uint)optTexture.Height, 1, (uint)textureSubResData.Length);
using (var texture = this.deviceResources.D3DDevice.CreateTexture2D(textureDesc, textureSubResData))
{
D3D11ShaderResourceViewDesc textureViewDesc = new D3D11ShaderResourceViewDesc
{
Format = textureDesc.Format,
ViewDimension = D3D11SrvDimension.Texture2D,
Texture2D = new D3D11Texture2DSrv
{
MipLevels = textureDesc.MipLevels,
MostDetailedMip = 0
}
};
this.textureViews.Add(optTextureName, this.deviceResources.D3DDevice.CreateShaderResourceView(texture, textureViewDesc));
}
}
}
private void CreateWindowSizeDependentResources()
{
this.d3dContext.OutputMergerSetRenderTargets(new D3D11RenderTargetView[] { null }, null);
D3D11Utils.DisposeAndNull(ref this.backBuffer);
D3D11Utils.DisposeAndNull(ref this.offscreenBuffer);
D3D11Utils.DisposeAndNull(ref this.d3dRenderTargetView);
D3D11Utils.DisposeAndNull(ref this.d3dDepthStencilView);
D2D1Utils.DisposeAndNull(ref this.d2dRenderTarget);
this.d3dContext.Flush();
var createdBackBuffer = this.OnCreateBackBuffer();
if (createdBackBuffer == null)
{
return;
}
this.backBuffer = createdBackBuffer;
var backBufferDesc = this.backBuffer.Description;
this.backBufferWidth = backBufferDesc.Width;
this.backBufferHeight = backBufferDesc.Height;
if (this.d3dSampleDesc.Count > 1)
{
D3D11Texture2DDesc desc = new D3D11Texture2DDesc(
DxgiFormat.B8G8R8A8UNorm,
this.backBufferWidth,
this.backBufferHeight,
1,
1,
D3D11BindOptions.RenderTarget,
D3D11Usage.Default,
D3D11CpuAccessOptions.None,
this.d3dSampleDesc.Count,
this.d3dSampleDesc.Quality,
D3D11ResourceMiscOptions.None);
this.offscreenBuffer = this.D3DDevice.CreateTexture2D(desc);
}
if (this.d3dSampleDesc.Count > 1)
{
D3D11RenderTargetViewDesc renderTargetViewDesc = new D3D11RenderTargetViewDesc(D3D11RtvDimension.Texture2DMs);
this.d3dRenderTargetView = this.d3dDevice.CreateRenderTargetView(this.offscreenBuffer, renderTargetViewDesc);
}
else
{
D3D11RenderTargetViewDesc renderTargetViewDesc = new D3D11RenderTargetViewDesc(D3D11RtvDimension.Texture2D);
this.d3dRenderTargetView = this.d3dDevice.CreateRenderTargetView(this.backBuffer, renderTargetViewDesc);
}
D3D11Texture2DDesc depthStencilDesc = new D3D11Texture2DDesc
{
Width = this.backBufferWidth,
Height = this.backBufferHeight,
MipLevels = 1,
ArraySize = 1,
Format = DxgiFormat.D24UNormS8UInt,
SampleDesc = this.d3dSampleDesc,
Usage = D3D11Usage.Default,
BindOptions = D3D11BindOptions.DepthStencil,
CpuAccessOptions = D3D11CpuAccessOptions.None,
MiscOptions = D3D11ResourceMiscOptions.None
};
using (var depthStencil = this.d3dDevice.CreateTexture2D(depthStencilDesc))
{
D3D11DepthStencilViewDesc depthStencilViewDesc = new D3D11DepthStencilViewDesc(this.d3dSampleDesc.Count > 1 ? D3D11DsvDimension.Texture2DMs : D3D11DsvDimension.Texture2D);
this.d3dDepthStencilView = this.d3dDevice.CreateDepthStencilView(depthStencil, depthStencilViewDesc);
}
this.screenViewport = new D3D11Viewport
{
TopLeftX = 0,
TopLeftY = 0,
Width = this.backBufferWidth,
Height = this.backBufferHeight,
MinDepth = 0.0f,
MaxDepth = 1.0f
};
this.d3dContext.RasterizerStageSetViewports(new[] { this.screenViewport });
using (var surface = new DxgiSurface2(this.d3dSampleDesc.Count > 1 ? this.offscreenBuffer.Handle : this.backBuffer.Handle))
{
float dpiX;
float dpiY;
this.d2dFactory.GetDesktopDpi(out dpiX, out dpiY);
var properties = new D2D1RenderTargetProperties(
D2D1RenderTargetType.Default,
new D2D1PixelFormat(DxgiFormat.B8G8R8A8UNorm, D2D1AlphaMode.Premultiplied),
dpiX,
dpiY,
D2D1RenderTargetUsages.None,
D2D1FeatureLevel.Default);
this.d2dRenderTarget = this.d2dFactory.CreateDxgiSurfaceRenderTarget(surface, properties);
}
this.d2dRenderTarget.AntialiasMode = D2D1AntialiasMode.PerPrimitive;
this.d2dRenderTarget.TextAntialiasMode = D2D1TextAntialiasMode.Grayscale;
D3D11RasterizerDesc rasterizerStateDesc = new D3D11RasterizerDesc(D3D11FillMode.Solid, D3D11CullMode.Back, false, 0, 0.0f, 0.0f, true, false, true, false);
using (var rasterizerState = this.d3dDevice.CreateRasterizerState(rasterizerStateDesc))
{
this.d3dContext.RasterizerStageSetState(rasterizerState);
}
}
public IDisplay Create(string title, int width, int height, IAdapter adapter)
{
const uint defaultRefreshRate = 144;
const bool debug = true;
var window = _windowCreator.CreateWindow(new CreateWindowArguments(title, width, height));
// Create device
var d3D11Device = _d3D11DeviceFactory.Create(new CreateDeviceArguments(window, defaultRefreshRate, adapter?.Handle ?? IntPtr.Zero, debug));
// Created the backbuffer and the RenderTargetView
using var backBuffer = d3D11Device.SwapChain.GetBuffer(0, D3D11Resources.D3D11Resource);
var renderTarget = d3D11Device.CreateRenderTargetView(backBuffer);
D3D11Texture2DDesc sTarget = default;
sTarget.Height = (uint)window.Height;
sTarget.Width = (uint)window.Width;
sTarget.MipLevels = 1u;
sTarget.ArraySize = 1u;
sTarget.Format = DxgiFormat.R8G8B8A8Unorm;
sTarget.SampleDesc.Count = 1;
sTarget.SampleDesc.Quality = 0;
sTarget.Usage = D3D11Usage.Default;
sTarget.BindFlags = D3D11BindFlag.RenderTarget;
//var d3D11Texture2D = d3D11Device.CreateTexture2D(sTarget); // TODO: this is getting leaked
//var secondRenderTarget = d3D11Device.CreateRenderTargetView(d3D11Texture2D); // TODO: this is getting leaked
// Create the DepthStencilView (z-buffering)
D3D11DepthStencilDesc depthDesc = default;
depthDesc.DepthEnable = true;
//depthDesc.DepthWriteMask = D3D11DepthWriteMask.Zero;
//depthDesc.DepthFunc = D3D11ComparisonFunc.LessEqual; // this is needed to add alpha-blending to sprites, not sure why.
depthDesc.DepthWriteMask = D3D11DepthWriteMask.All;
depthDesc.DepthFunc = D3D11ComparisonFunc.LessEqual; // this is needed to add alpha-blending to sprites, not sure why.
using var depthStencilState = d3D11Device.CreateDepthStencilState(depthDesc);
d3D11Device.Context.OMSetDepthStencilState(depthStencilState, 1u);
D3D11Texture2DDesc texture2DDesc = default;
texture2DDesc.Height = (uint)window.Height;
texture2DDesc.Width = (uint)window.Width;
texture2DDesc.MipLevels = 1u;
texture2DDesc.ArraySize = 1u;
texture2DDesc.Format = DxgiFormat.D32Float;
//texture2DDesc.SampleDesc.Count = 4u; // AA
texture2DDesc.SampleDesc.Count = 1;
texture2DDesc.SampleDesc.Quality = 0;
texture2DDesc.Usage = D3D11Usage.Default;
texture2DDesc.BindFlags = D3D11BindFlag.DepthStencil;
using var depthStencil = d3D11Device.CreateTexture2D(texture2DDesc);
D3D11DepthStencilViewDesc viewDesc = default;
viewDesc.Format = DxgiFormat.D32Float;
viewDesc.ViewDimension = D3D11DsvDimension.Texture2D;
//viewDesc.ViewDimension = D3D11DsvDimension.Texture2Dms; // AA
viewDesc.Texture2D.MipSlice = 0u;
var depthStencilView = d3D11Device.CreateDepthStencilView(depthStencil, viewDesc);
// Set the render target view and depthStencil
unsafe
{
var renderTargets = stackalloc IntPtr[1];
renderTargets[0] = renderTarget.Handle;
d3D11Device.Context.OMSetRenderTargets(renderTargets, 1, depthStencilView.Handle);
}
// Set the default viewport
D3D11Viewport viewport = default;
viewport.Width = window.Width;
viewport.Height = window.Height;
viewport.MinDepth = 0;
viewport.MaxDepth = 1;
d3D11Device.Context.SetViewport(viewport);
// Create the device abstraction
var device = new Device(d3D11Device, renderTarget, depthStencilView, _compiler);
return(new Display(device, window));
}
public void CreateDeviceDependentResources(DeviceResources resources)
{
this.deviceResources = resources;
byte[] renderSceneVertexShaderBytecode = File.ReadAllBytes("RenderSceneVertexShader.cso");
this.g_pSceneVS = this.deviceResources.D3DDevice.CreateVertexShader(renderSceneVertexShaderBytecode, null);
D3D11InputElementDesc[] layoutDesc = new D3D11InputElementDesc[]
{
new D3D11InputElementDesc
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 0,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "NORMAL",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 12,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "TEXTURE",
SemanticIndex = 0,
Format = DxgiFormat.R32G32Float,
InputSlot = 0,
AlignedByteOffset = 24,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
this.g_pSceneVertexLayout = this.deviceResources.D3DDevice.CreateInputLayout(layoutDesc, renderSceneVertexShaderBytecode);
byte[] renderScenePixelShaderBytecode = File.ReadAllBytes("RenderScenePixelShader.cso");
this.g_pScenePS = this.deviceResources.D3DDevice.CreatePixelShader(renderScenePixelShaderBytecode, null);
byte[] renderSceneShadowMapVertexShaderBytecode = File.ReadAllBytes("RenderSceneShadowMapVertexShader.cso");
this.g_pShadowMapVS = this.deviceResources.D3DDevice.CreateVertexShader(renderSceneShadowMapVertexShaderBytecode, null);
this.g_SceneMesh = SdkMeshFile.FromFile(this.deviceResources.D3DDevice, this.deviceResources.D3DContext, @"ColumnScene\scene.sdkmesh");
this.g_Poles = SdkMeshFile.FromFile(this.deviceResources.D3DDevice, this.deviceResources.D3DContext, @"ColumnScene\poles.sdkmesh");
this.g_pcbConstants = this.deviceResources.D3DDevice.CreateBuffer(
new D3D11BufferDesc(ConstantBufferConstants.Size, D3D11BindOptions.ConstantBuffer));
D3D11SamplerDesc samplerDesc = new D3D11SamplerDesc(
D3D11Filter.ComparisonMinMagMipPoint,
D3D11TextureAddressMode.Border,
D3D11TextureAddressMode.Border,
D3D11TextureAddressMode.Border,
0.0f,
1,
D3D11ComparisonFunction.LessEqual,
new float[] { 1.0f, 1.0f, 1.0f, 1.0f },
0.0f,
float.MaxValue);
// PointCmp
this.g_pSamplePointCmp = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
// Point
samplerDesc.Filter = D3D11Filter.MinMagMipPoint;
samplerDesc.ComparisonFunction = D3D11ComparisonFunction.Always;
this.g_pSamplePoint = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
// Linear
samplerDesc.Filter = D3D11Filter.MinMagMipLinear;
samplerDesc.AddressU = D3D11TextureAddressMode.Wrap;
samplerDesc.AddressV = D3D11TextureAddressMode.Wrap;
samplerDesc.AddressW = D3D11TextureAddressMode.Wrap;
this.g_pSampleLinear = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
// Create a blend state to disable alpha blending
D3D11BlendDesc blendDesc = D3D11BlendDesc.Default;
blendDesc.IsIndependentBlendEnabled = false;
D3D11RenderTargetBlendDesc[] blendDescRenderTargets = blendDesc.GetRenderTargets();
blendDescRenderTargets[0].IsBlendEnabled = false;
blendDescRenderTargets[0].RenderTargetWriteMask = D3D11ColorWriteEnables.All;
blendDesc.SetRenderTargets(blendDescRenderTargets);
this.g_pBlendStateNoBlend = this.deviceResources.D3DDevice.CreateBlendState(blendDesc);
blendDescRenderTargets[0].RenderTargetWriteMask = D3D11ColorWriteEnables.None;
blendDesc.SetRenderTargets(blendDescRenderTargets);
this.g_pBlendStateColorWritesOff = this.deviceResources.D3DDevice.CreateBlendState(blendDesc);
// textures / rts
D3D11Texture2DDesc TDesc = new D3D11Texture2DDesc(
DxgiFormat.R16Typeless,
(uint)g_fShadowMapWidth,
(uint)g_fShadowMapHeight,
1,
1,
D3D11BindOptions.DepthStencil | D3D11BindOptions.ShaderResource);
this.g_pShadowMapDepthStencilTexture = this.deviceResources.D3DDevice.CreateTexture2D(TDesc);
D3D11ShaderResourceViewDesc SRVDesc = new D3D11ShaderResourceViewDesc
{
Format = DxgiFormat.R16UNorm,
ViewDimension = D3D11SrvDimension.Texture2D,
Texture2D = new D3D11Texture2DSrv
{
MipLevels = 1,
MostDetailedMip = 0
}
};
this.g_pDepthTextureSRV = this.deviceResources.D3DDevice.CreateShaderResourceView(this.g_pShadowMapDepthStencilTexture, SRVDesc);
D3D11DepthStencilViewDesc DSVDesc = new D3D11DepthStencilViewDesc
{
Format = DxgiFormat.D16UNorm,
ViewDimension = D3D11DsvDimension.Texture2D,
Options = D3D11DepthStencilViewOptions.None,
Texture2D = new D3D11Texture2DDsv
{
MipSlice = 0
}
};
this.g_pDepthStencilTextureDSV = this.deviceResources.D3DDevice.CreateDepthStencilView(this.g_pShadowMapDepthStencilTexture, DSVDesc);
XMFloat3 vecEye = new XMFloat3(0.95f, 5.83f, -14.48f);
XMFloat3 vecAt = new XMFloat3(0.90f, 5.44f, -13.56f);
XMFloat3 vecUp = new XMFloat3(0.0f, 1.0f, 0.0f);
this.ViewMatrix = XMMatrix.LookAtLH(vecEye, vecAt, vecUp);
this.WorldMatrix = XMMatrix.Identity;
XMFloat3 vecEyeL = new XMFloat3(0, 0, 0);
XMFloat3 vecAtL = new XMFloat3(0, -0.5f, 1);
XMFloat3 vecUUpL = new XMFloat3(0.0f, 1.0f, 0.0f);
this.LightViewMatrix = XMMatrix.LookAtLH(vecEyeL, vecAtL, vecUUpL);
this.LightWorldMatrix = XMMatrix.Identity;
}
