mirror of
https://github.com/baldurk/renderdoc.git
synced 2026-09-18 19:55:54 +00:00
baldurk
856c838def
* In a previous update in 2021 many copyright ranges were truncated accidentally, and some files have been copy-pasted with wrong years. These dates have been fixed based on git history and original copyright messages.
701 lines
21 KiB
C++
701 lines
21 KiB
C++
/******************************************************************************
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2025-2026 Baldur Karlsson
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
******************************************************************************/
|
|
|
|
#include "d3d11_test.h"
|
|
|
|
RD_TEST(D3D11_Pixel_History, D3D11GraphicsTest)
|
|
{
|
|
static constexpr const char *Description = "Tests pixel history";
|
|
|
|
const std::string vertex = R"EOSHADER(
|
|
|
|
void main(float3 pos : POSITION, float4 col : COLOR0,
|
|
out float4 outPos : SV_POSITION, out COL_TYPE outCol : COLOR0)
|
|
{
|
|
outPos = float4(pos, 1.0f);
|
|
outCol = ProcessColor(col);
|
|
}
|
|
|
|
)EOSHADER";
|
|
|
|
const std::string pixel = R"EOSHADER(
|
|
|
|
void main(float4 pos : SV_POSITION, COL_TYPE col : COLOR0
|
|
#if COLOR == 1
|
|
, out COL_TYPE outCol : SV_Target0
|
|
#endif
|
|
)
|
|
{
|
|
if (pos.x < DISCARD_X+1 && pos.x > DISCARD_X)
|
|
discard;
|
|
if (col.x > 10000 && col.y > 10000 && col.z > 10000)
|
|
discard;
|
|
#if COLOR == 1
|
|
outCol = col + COL_TYPE(0, 0, 0, ProcessColor((ALPHA_ADD).xxxx).x);
|
|
#endif
|
|
}
|
|
|
|
)EOSHADER";
|
|
|
|
std::string mspixel = R"EOSHADER(
|
|
|
|
void main(float4 pos : SV_POSITION, uint sampleId : SV_SampleIndex
|
|
#if COLOR == 1
|
|
, out COL_TYPE outCol : SV_Target0
|
|
#endif
|
|
)
|
|
{
|
|
#if COLOR == 1
|
|
float4 col = 0.0f.xxxx;
|
|
if (sampleId == 0)
|
|
col = float4(1, 0, 0, 1+ALPHA_ADD);
|
|
else if (sampleId == 1)
|
|
col = float4(0, 0, 1, 1+ALPHA_ADD);
|
|
else if (sampleId == 2)
|
|
col = float4(0, 1, 1, 1+ALPHA_ADD);
|
|
else if (sampleId == 3)
|
|
col = float4(1, 1, 1, 1+ALPHA_ADD);
|
|
outCol = ProcessColor(col);
|
|
#endif
|
|
}
|
|
|
|
)EOSHADER";
|
|
|
|
std::string comp = R"EOSHADER(
|
|
|
|
IMAGE_TYPE<COL_TYPE> Output : register(u0);
|
|
|
|
[numthreads(1, 1, 1)]
|
|
void main()
|
|
{
|
|
float4 data = float4(3, 3, 3, 9);
|
|
|
|
for(int x=0; x < 10; x++)
|
|
for(int y=0; y < 10; y++)
|
|
Output[STORE_TYPE(STORE_X+x, STORE_Y+y STORE_Z)] = ProcessColor(data);
|
|
}
|
|
|
|
)EOSHADER";
|
|
|
|
struct D3D11StateSetup
|
|
{
|
|
struct SetupInfo
|
|
{
|
|
ID3D11VertexShaderPtr VS;
|
|
ID3D11PixelShaderPtr PS;
|
|
D3D11_DEPTH_STENCIL_DESC DepthStencilState;
|
|
D3D11_RASTERIZER_DESC RasterizerState;
|
|
D3D11_BLEND_DESC BlendState;
|
|
};
|
|
|
|
ID3D11VertexShaderPtr VS;
|
|
ID3D11PixelShaderPtr PS;
|
|
ID3D11DepthStencilStatePtr DS;
|
|
ID3D11RasterizerStatePtr RS;
|
|
ID3D11BlendStatePtr BS;
|
|
UINT ref = 0x55;
|
|
UINT SampleMask = ~0U;
|
|
|
|
void init(ID3D11DevicePtr device, const SetupInfo &info)
|
|
{
|
|
VS = info.VS;
|
|
PS = info.PS;
|
|
device->CreateDepthStencilState(&info.DepthStencilState, &DS);
|
|
device->CreateRasterizerState(&info.RasterizerState, &RS);
|
|
device->CreateBlendState(&info.BlendState, &BS);
|
|
}
|
|
|
|
void set(ID3D11DeviceContextPtr context) const
|
|
{
|
|
context->VSSetShader(VS, NULL, 0);
|
|
context->PSSetShader(PS, NULL, 0);
|
|
context->RSSetState(RS);
|
|
context->OMSetDepthStencilState(DS, ref);
|
|
context->OMSetBlendState(BS, NULL, SampleMask);
|
|
}
|
|
};
|
|
|
|
struct D3D11TestBatch
|
|
{
|
|
std::string name;
|
|
|
|
bool uint = false;
|
|
|
|
uint32_t mip = 0;
|
|
|
|
ID3D11Texture2DPtr colImg2D;
|
|
|
|
ID3D11RenderTargetViewPtr RTV;
|
|
ID3D11DepthStencilViewPtr DSV;
|
|
|
|
DXGI_FORMAT depthFormat;
|
|
|
|
ID3D11UnorderedAccessViewPtr compUAV;
|
|
ID3D11ComputeShaderPtr comp;
|
|
|
|
uint32_t width, height;
|
|
|
|
D3D11StateSetup depthWriteState;
|
|
D3D11StateSetup scissorState;
|
|
D3D11StateSetup stencilRefState;
|
|
D3D11StateSetup stencilMaskState;
|
|
D3D11StateSetup depthEqualState;
|
|
D3D11StateSetup depthState;
|
|
D3D11StateSetup stencilWriteState;
|
|
D3D11StateSetup backgroundState;
|
|
D3D11StateSetup noPsState;
|
|
D3D11StateSetup noOutState;
|
|
D3D11StateSetup basicState;
|
|
D3D11StateSetup colorMaskState;
|
|
D3D11StateSetup cullFrontState;
|
|
D3D11StateSetup sampleColourState;
|
|
};
|
|
|
|
std::vector<D3D11TestBatch> batches;
|
|
|
|
void BuildTestBatch(const std::string &name, uint32_t sampleCount, DXGI_FORMAT colourFormat,
|
|
DXGI_FORMAT depthStencilFormat, int targetMip = -1, int targetSlice = -1,
|
|
int targetDepthSlice = -1)
|
|
{
|
|
batches.push_back({});
|
|
|
|
D3D11TestBatch &batch = batches.back();
|
|
batch.name = name;
|
|
|
|
batch.width = screenWidth;
|
|
batch.height = screenHeight;
|
|
|
|
uint32_t arraySize = targetSlice >= 0 ? 5 : 1;
|
|
uint32_t mips = targetMip >= 0 ? 4 : 1;
|
|
uint32_t depth = targetDepthSlice >= 0 ? 14 : 1;
|
|
|
|
uint32_t mip = (uint32_t)std::max(0, targetMip);
|
|
uint32_t slice = (uint32_t)std::max(0, targetSlice);
|
|
if(depth > 1)
|
|
slice = (uint32_t)targetDepthSlice;
|
|
|
|
batch.mip = mip;
|
|
|
|
std::string defines;
|
|
defines +=
|
|
"#define COLOR " + std::string(colourFormat == DXGI_FORMAT_UNKNOWN ? "0" : "1") + "\n";
|
|
|
|
if(colourFormat == DXGI_FORMAT_R8G8B8A8_UINT || colourFormat == DXGI_FORMAT_R16G16B16A16_UINT ||
|
|
colourFormat == DXGI_FORMAT_R32G32B32A32_UINT)
|
|
{
|
|
batch.uint = true;
|
|
defines += R"(
|
|
|
|
#define COL_TYPE uint4
|
|
#define ALPHA_ADD 3
|
|
|
|
uint4 ProcessColor(float4 col)
|
|
{
|
|
uint4 ret = uint4(16*col);
|
|
|
|
if(col.x < 0.0f) ret.x = 0xfffffff0;
|
|
if(col.y < 0.0f) ret.y = 0xfffffff0;
|
|
if(col.z < 0.0f) ret.z = 0xfffffff0;
|
|
|
|
|
|
return ret;
|
|
}
|
|
|
|
)";
|
|
}
|
|
else
|
|
{
|
|
defines += R"(
|
|
|
|
#define COL_TYPE float4
|
|
#define ALPHA_ADD 1.75
|
|
|
|
float4 ProcessColor(float4 col)
|
|
{
|
|
float4 ret = col;
|
|
|
|
// this obviously won't overflow F32 but it will overflow anything 16-bit and under
|
|
if(col.x < 0.0f) ret.x = 100000.0f;
|
|
if(col.y < 0.0f) ret.y = 100000.0f;
|
|
if(col.z < 0.0f) ret.z = 100000.0f;
|
|
|
|
return ret;
|
|
}
|
|
|
|
)";
|
|
}
|
|
|
|
defines += "#define DISCARD_X " + std::to_string(150 >> mip) + "\n";
|
|
defines += "#define IMAGE_TYPE " +
|
|
std::string(depth > 1 ? "RWTexture3D"
|
|
: arraySize > 1 ? "RWTexture2DArray"
|
|
: "RWTexture2D") +
|
|
"\n";
|
|
defines += "#define STORE_X " + std::to_string(220 >> mip) + "\n";
|
|
defines += "#define STORE_Y " + std::to_string(80 >> mip) + "\n";
|
|
if(depth > 1 || arraySize > 1)
|
|
{
|
|
defines += "#define STORE_TYPE uint3\n";
|
|
defines += "#define STORE_Z , " + std::to_string(slice) + "\n";
|
|
}
|
|
else
|
|
{
|
|
defines += "#define STORE_TYPE uint2\n";
|
|
defines += "#define STORE_Z \n";
|
|
}
|
|
defines += "\n\n";
|
|
|
|
ID3DBlobPtr vsBlob = Compile(defines + vertex, "main", "vs_5_0");
|
|
ID3DBlobPtr psBlob = Compile(defines + pixel, "main", "ps_5_0");
|
|
ID3DBlobPtr psMsaaBlob = Compile(defines + mspixel, "main", "ps_5_0");
|
|
|
|
ID3DBlobPtr noOutPSBlob;
|
|
|
|
if(colourFormat != DXGI_FORMAT_UNKNOWN)
|
|
{
|
|
defines += "#undef COLOR\n#define COLOR 0\n";
|
|
noOutPSBlob = Compile(defines + pixel, "main", "ps_5_0");
|
|
|
|
D3D11TextureCreator colCreator =
|
|
MakeTexture(colourFormat, batch.width, batch.height, depth)
|
|
.Mips(mips)
|
|
// this is DepthOrArraySize so need to set it correctly from either
|
|
.Array(arraySize)
|
|
.Multisampled(sampleCount)
|
|
.SRV()
|
|
.RTV();
|
|
|
|
if(sampleCount == 1)
|
|
colCreator.UAV();
|
|
|
|
if(depth > 1)
|
|
{
|
|
ID3D11Texture3DPtr colImg = colCreator;
|
|
SetDebugName(colImg, batch.name + " colImg");
|
|
|
|
batch.RTV = MakeRTV(colImg).FirstMip(mip).NumMips(1).FirstSlice(slice).NumSlices(1);
|
|
|
|
batch.comp = CreateCS(Compile(defines + comp, "main", "cs_5_0"));
|
|
SetDebugName(batch.comp, batch.name + " comp");
|
|
batch.compUAV = MakeUAV(colImg).FirstMip(mip);
|
|
SetDebugName(batch.compUAV, batch.name + " compUAV");
|
|
}
|
|
else
|
|
{
|
|
batch.colImg2D = colCreator;
|
|
SetDebugName(batch.colImg2D, batch.name + " colImg");
|
|
|
|
batch.RTV = MakeRTV(batch.colImg2D).FirstMip(mip).NumMips(1).FirstSlice(slice).NumSlices(1);
|
|
|
|
if(sampleCount == 1)
|
|
{
|
|
batch.comp = CreateCS(Compile(defines + comp, "main", "cs_5_0"));
|
|
SetDebugName(batch.comp, batch.name + " comp");
|
|
batch.compUAV = MakeUAV(batch.colImg2D).FirstMip(mip);
|
|
SetDebugName(batch.compUAV, batch.name + " compUAV");
|
|
}
|
|
}
|
|
}
|
|
|
|
batch.depthFormat = depthStencilFormat;
|
|
|
|
if(depthStencilFormat != DXGI_FORMAT_UNKNOWN)
|
|
{
|
|
// can't create 2D views of 3D with depth images, so we just use a normal 2D array image
|
|
if(depth > 1)
|
|
{
|
|
arraySize = depth;
|
|
depth = 1;
|
|
}
|
|
|
|
ID3D11Texture2DPtr depthImg =
|
|
MakeTexture(depthStencilFormat, batch.width, batch.height, depth)
|
|
.Mips(mips)
|
|
// this is DepthOrArraySize so need to set it correctly from either
|
|
.Array(arraySize)
|
|
.Multisampled(sampleCount)
|
|
.DSV();
|
|
SetDebugName(depthImg, batch.name + " depthImg");
|
|
|
|
batch.DSV = MakeDSV(depthImg).FirstMip(mip).NumMips(1).FirstSlice(slice).NumSlices(1);
|
|
}
|
|
|
|
batch.width >>= mip;
|
|
batch.height >>= mip;
|
|
|
|
D3D11StateSetup::SetupInfo stateInfo = {};
|
|
|
|
ID3D11VertexShaderPtr VS = CreateVS(vsBlob);
|
|
SetDebugName(VS, batch.name + " NormalVS");
|
|
stateInfo.VS = VS;
|
|
|
|
ID3D11PixelShaderPtr PS = CreatePS(psBlob);
|
|
SetDebugName(PS, batch.name + " NormalPS");
|
|
stateInfo.PS = PS;
|
|
|
|
ID3D11PixelShaderPtr noOutPS;
|
|
|
|
if(noOutPSBlob)
|
|
{
|
|
noOutPS = CreatePS(noOutPSBlob);
|
|
SetDebugName(noOutPS, batch.name + " NoOutPS");
|
|
}
|
|
|
|
stateInfo.BlendState.RenderTarget[0].RenderTargetWriteMask = 0xf;
|
|
|
|
stateInfo.RasterizerState.FillMode = D3D11_FILL_SOLID;
|
|
stateInfo.RasterizerState.MultisampleEnable = sampleCount > 1;
|
|
stateInfo.RasterizerState.ScissorEnable = TRUE;
|
|
stateInfo.RasterizerState.DepthClipEnable = TRUE;
|
|
stateInfo.RasterizerState.CullMode = D3D11_CULL_BACK;
|
|
|
|
stateInfo.DepthStencilState.DepthEnable = TRUE;
|
|
stateInfo.DepthStencilState.DepthFunc = D3D11_COMPARISON_ALWAYS;
|
|
stateInfo.DepthStencilState.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
|
|
stateInfo.DepthStencilState.StencilEnable = FALSE;
|
|
stateInfo.DepthStencilState.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
|
|
stateInfo.DepthStencilState.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
|
|
stateInfo.DepthStencilState.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
|
|
stateInfo.DepthStencilState.FrontFace.StencilPassOp = D3D11_STENCIL_OP_REPLACE;
|
|
stateInfo.DepthStencilState.StencilReadMask = 0xff;
|
|
stateInfo.DepthStencilState.StencilWriteMask = 0xff;
|
|
stateInfo.DepthStencilState.BackFace = stateInfo.DepthStencilState.FrontFace;
|
|
|
|
stateInfo.DepthStencilState.DepthFunc = D3D11_COMPARISON_ALWAYS;
|
|
batch.depthWriteState.init(dev, stateInfo);
|
|
|
|
{
|
|
D3D11StateSetup::SetupInfo depthEqualStateInfo = stateInfo;
|
|
depthEqualStateInfo.DepthStencilState.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
|
|
depthEqualStateInfo.DepthStencilState.DepthFunc = D3D11_COMPARISON_EQUAL;
|
|
|
|
batch.depthEqualState.init(dev, depthEqualStateInfo);
|
|
}
|
|
|
|
{
|
|
D3D11StateSetup::SetupInfo scissorStencilStates = stateInfo;
|
|
scissorStencilStates.DepthStencilState.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
|
|
scissorStencilStates.DepthStencilState.DepthEnable = FALSE;
|
|
|
|
batch.scissorState.init(dev, scissorStencilStates);
|
|
|
|
batch.stencilRefState.init(dev, scissorStencilStates);
|
|
batch.stencilRefState.ref = 0x67;
|
|
|
|
scissorStencilStates.DepthStencilState.StencilReadMask = 0;
|
|
scissorStencilStates.DepthStencilState.StencilWriteMask = 0;
|
|
|
|
batch.stencilMaskState.init(dev, scissorStencilStates);
|
|
}
|
|
|
|
stateInfo.DepthStencilState.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
|
|
|
|
batch.depthState.init(dev, stateInfo);
|
|
|
|
stateInfo.DepthStencilState.StencilEnable = TRUE;
|
|
batch.stencilWriteState.init(dev, stateInfo);
|
|
|
|
stateInfo.DepthStencilState.StencilEnable = FALSE;
|
|
batch.backgroundState.init(dev, stateInfo);
|
|
|
|
{
|
|
stateInfo.PS = NULL;
|
|
stateInfo.DepthStencilState.StencilEnable = TRUE;
|
|
batch.noPsState.init(dev, stateInfo);
|
|
batch.noPsState.ref = 0x33;
|
|
stateInfo.PS = PS;
|
|
}
|
|
|
|
if(noOutPS)
|
|
{
|
|
stateInfo.PS = noOutPS;
|
|
stateInfo.DepthStencilState.StencilEnable = FALSE;
|
|
batch.noOutState.init(dev, stateInfo);
|
|
stateInfo.PS = PS;
|
|
}
|
|
|
|
stateInfo.DepthStencilState.StencilEnable = TRUE;
|
|
stateInfo.DepthStencilState.FrontFace.StencilFunc = D3D11_COMPARISON_GREATER;
|
|
batch.basicState.init(dev, stateInfo);
|
|
stateInfo.DepthStencilState.StencilEnable = FALSE;
|
|
|
|
{
|
|
D3D11StateSetup::SetupInfo maskStateInfo = stateInfo;
|
|
maskStateInfo.BlendState.RenderTarget[0].RenderTargetWriteMask = 0x3;
|
|
batch.colorMaskState.init(dev, maskStateInfo);
|
|
}
|
|
|
|
stateInfo.RasterizerState.CullMode = D3D11_CULL_FRONT;
|
|
batch.cullFrontState.init(dev, stateInfo);
|
|
stateInfo.RasterizerState.CullMode = D3D11_CULL_BACK;
|
|
|
|
stateInfo.PS = CreatePS(psMsaaBlob);
|
|
SetDebugName(stateInfo.PS, batch.name + " MSAAPS");
|
|
|
|
stateInfo.DepthStencilState.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
|
|
batch.sampleColourState.init(dev, stateInfo);
|
|
if(sampleCount == 4)
|
|
batch.sampleColourState.SampleMask = 0x7;
|
|
}
|
|
|
|
void RunDraw(const PixelHistory::draw &draw, uint32_t numInstances = 1)
|
|
{
|
|
ctx->DrawInstanced(draw.count, numInstances, draw.first, 0);
|
|
}
|
|
|
|
void RunBatch(const D3D11TestBatch &b)
|
|
{
|
|
float factor = float(b.width) / float(screenWidth);
|
|
|
|
D3D11_VIEWPORT v = {};
|
|
v.Width = (float)b.width - (20.0f * factor);
|
|
v.Height = (float)b.height - (20.0f * factor);
|
|
v.TopLeftX = floorf(10.0f * factor);
|
|
v.TopLeftY = floorf(10.0f * factor);
|
|
v.MaxDepth = 1.0f;
|
|
|
|
D3D11_RECT scissor = {0, 0, (LONG)b.width, (LONG)b.height};
|
|
D3D11_RECT scissorPass = {95 >> b.mip, 245 >> b.mip, 115U >> b.mip, 253U >> b.mip};
|
|
D3D11_RECT scissorFail = {95 >> b.mip, 245 >> b.mip, 103U >> b.mip, 253U >> b.mip};
|
|
|
|
ctx->RSSetViewports(1, &v);
|
|
ctx->RSSetScissorRects(1, &scissor);
|
|
|
|
ctx->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ctx->IASetInputLayout(defaultLayout);
|
|
|
|
// draw the setup triangles
|
|
|
|
pushMarker("Setup");
|
|
{
|
|
setMarker("Depth Write");
|
|
b.depthWriteState.set(ctx);
|
|
RunDraw(PixelHistory::DepthWrite);
|
|
|
|
setMarker("Depth Equal Setup");
|
|
RunDraw(PixelHistory::DepthEqualSetup);
|
|
|
|
setMarker("Unbound Shader");
|
|
b.noPsState.set(ctx);
|
|
RunDraw(PixelHistory::UnboundPS);
|
|
|
|
setMarker("Stencil Write");
|
|
b.stencilWriteState.set(ctx);
|
|
RunDraw(PixelHistory::StencilWrite);
|
|
|
|
setMarker("Background");
|
|
b.backgroundState.set(ctx);
|
|
RunDraw(PixelHistory::Background);
|
|
|
|
setMarker("Cull Front");
|
|
b.cullFrontState.set(ctx);
|
|
RunDraw(PixelHistory::CullFront);
|
|
|
|
// depth bounds would be here but D3D11 does not support it
|
|
}
|
|
popMarker();
|
|
|
|
pushMarker("Stress Test");
|
|
{
|
|
pushMarker("Lots of Drawcalls");
|
|
{
|
|
setMarker("300 Draws");
|
|
b.depthWriteState.set(ctx);
|
|
for(int d = 0; d < 300; ++d)
|
|
RunDraw(PixelHistory::Draws300);
|
|
}
|
|
popMarker();
|
|
|
|
setMarker("300 Instances");
|
|
RunDraw(PixelHistory::Instances300, 300);
|
|
}
|
|
popMarker();
|
|
|
|
setMarker("Simple Test");
|
|
b.basicState.set(ctx);
|
|
RunDraw(PixelHistory::MainTest);
|
|
|
|
b.scissorState.set(ctx);
|
|
|
|
setMarker("Scissor Fail");
|
|
ctx->RSSetScissorRects(1, &scissorFail);
|
|
RunDraw(PixelHistory::ScissorFail);
|
|
|
|
setMarker("Scissor Pass");
|
|
ctx->RSSetScissorRects(1, &scissorPass);
|
|
RunDraw(PixelHistory::ScissorPass);
|
|
|
|
ctx->RSSetScissorRects(1, &scissor);
|
|
|
|
setMarker("Stencil Ref");
|
|
b.stencilRefState.set(ctx);
|
|
RunDraw(PixelHistory::StencilRef);
|
|
|
|
setMarker("Stencil Mask");
|
|
b.stencilMaskState.set(ctx);
|
|
RunDraw(PixelHistory::StencilMask);
|
|
|
|
setMarker("Depth Test");
|
|
b.depthState.set(ctx);
|
|
RunDraw(PixelHistory::DepthTest);
|
|
|
|
setMarker("Sample Colouring");
|
|
b.sampleColourState.set(ctx);
|
|
RunDraw(PixelHistory::SampleColour);
|
|
|
|
setMarker("Depth Equal Fail");
|
|
b.depthEqualState.set(ctx);
|
|
RunDraw(PixelHistory::DepthEqualFail);
|
|
|
|
setMarker("Depth Equal Pass");
|
|
b.depthEqualState.set(ctx);
|
|
if(b.depthFormat == DXGI_FORMAT_D24_UNORM_S8_UINT)
|
|
RunDraw(PixelHistory::DepthEqualPass24);
|
|
else if(b.depthFormat == DXGI_FORMAT_D16_UNORM)
|
|
RunDraw(PixelHistory::DepthEqualPass16);
|
|
else
|
|
RunDraw(PixelHistory::DepthEqualPass32);
|
|
|
|
setMarker("Colour Masked");
|
|
b.colorMaskState.set(ctx);
|
|
RunDraw(PixelHistory::ColourMask);
|
|
|
|
setMarker("Overflowing");
|
|
b.backgroundState.set(ctx);
|
|
RunDraw(PixelHistory::OverflowingDraw);
|
|
|
|
setMarker("Per-Fragment discarding");
|
|
b.backgroundState.set(ctx);
|
|
RunDraw(PixelHistory::PerFragDiscard);
|
|
|
|
if(b.noOutState.VS)
|
|
{
|
|
setMarker("No Output Shader");
|
|
b.noOutState.set(ctx);
|
|
RunDraw(PixelHistory::UnboundPS);
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
// initialise, create window, create device, etc
|
|
if(!Init())
|
|
return 3;
|
|
|
|
PixelHistory::init();
|
|
|
|
ID3D11BufferPtr vb = MakeBuffer()
|
|
.Vertex()
|
|
.Size(UINT(sizeof(DefaultA2V) * PixelHistory::vb.size()))
|
|
.Data(PixelHistory::vb.data());
|
|
|
|
ID3D11Texture2DPtr bbBlitSource;
|
|
|
|
BuildTestBatch("Basic", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
bbBlitSource = batches.back().colImg2D;
|
|
|
|
BuildTestBatch("MSAA", 4, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
BuildTestBatch("Colour Only", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN);
|
|
BuildTestBatch("Depth Only", 1, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
BuildTestBatch("Mip & Slice", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D32_FLOAT_S8X24_UINT,
|
|
2, 3);
|
|
BuildTestBatch("Slice MSAA", 4, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D32_FLOAT_S8X24_UINT,
|
|
-1, 3);
|
|
|
|
// can't test 3D textures with depth as 3D depth is not supported and can't mix 3D with 2D array as in other APIs
|
|
BuildTestBatch("3D texture", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, -1, -1, 8);
|
|
|
|
BuildTestBatch("D24S8", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D24_UNORM_S8_UINT);
|
|
|
|
BuildTestBatch("D16", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D16_UNORM);
|
|
BuildTestBatch("D32", 1, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_D32_FLOAT);
|
|
|
|
BuildTestBatch("F16 UNORM", 1, DXGI_FORMAT_R16G16B16A16_UNORM, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
BuildTestBatch("F16 FLOAT", 1, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
BuildTestBatch("F32 FLOAT", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
|
|
BuildTestBatch("8-bit uint", 1, DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
BuildTestBatch("16-bit uint", 1, DXGI_FORMAT_R16G16B16A16_UINT, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
BuildTestBatch("32-bit uint", 1, DXGI_FORMAT_R32G32B32A32_UINT, DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
|
|
|
|
while(Running())
|
|
{
|
|
for(const D3D11TestBatch &b : batches)
|
|
{
|
|
IASetVertexBuffer(vb, sizeof(DefaultA2V), 0);
|
|
|
|
{
|
|
pushMarker("Batch: " + b.name);
|
|
{
|
|
setMarker("Begin RenderPass");
|
|
|
|
float clearColor[4] = {0.2f, 0.2f, 0.2f, 1.0f};
|
|
if(b.uint)
|
|
{
|
|
clearColor[0] = 80.0f;
|
|
clearColor[1] = 80.0f;
|
|
clearColor[2] = 80.0f;
|
|
clearColor[3] = 16.0f;
|
|
}
|
|
|
|
if(b.RTV)
|
|
ctx->ClearRenderTargetView(b.RTV, clearColor);
|
|
if(b.DSV)
|
|
ctx->ClearDepthStencilView(b.DSV, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
|
|
|
|
ID3D11RenderTargetViewPtr RTV = b.RTV;
|
|
ctx->OMSetRenderTargets(b.RTV ? 1 : 0, &RTV.GetInterfacePtr(), b.DSV);
|
|
|
|
RunBatch(b);
|
|
|
|
if(b.comp)
|
|
{
|
|
setMarker("Compute write");
|
|
|
|
ctx->OMSetRenderTargets(0, NULL, NULL);
|
|
ctx->CSSetShader(b.comp, NULL, 0);
|
|
ID3D11UnorderedAccessViewPtr UAV = b.compUAV;
|
|
ctx->CSSetUnorderedAccessViews(0, 1, &UAV.GetInterfacePtr(), NULL);
|
|
ctx->Dispatch(1, 1, 1);
|
|
}
|
|
}
|
|
popMarker();
|
|
}
|
|
}
|
|
|
|
if(bbBlitSource)
|
|
{
|
|
ctx->OMSetBlendState(NULL, NULL, ~0U);
|
|
blitToSwap(bbBlitSource);
|
|
}
|
|
|
|
Present();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
REGISTER_TEST();
|