openharmony/third_party_vulkan-loader
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_vulkan-loader synced 2025-01-12 18:20:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

tests: Now have two triangle tests using different shaders

Browse Source
This commit is contained in:
Courtney Goeltzenleuchter 2014-10-08 14:26:40 -06:00
parent 39e6b73f91
commit 2918b7a1fd
5 changed files with 93 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
tests/render_tests.cpp
View File

@ -200,7 +200,7 @@ public:
void InitMesh( XGL_UINT32 numVertices, XGL_GPU_SIZE vbStride, const void* vertices ); void InitMesh( XGL_UINT32 numVertices, XGL_GPU_SIZE vbStride, const void* vertices );
void InitTexture(); void InitTexture();
void InitSampler(); void InitSampler();
void DrawTriangleTest(); void DrawTriangleTest(const char *vertShaderText, const char *fragShaderText);
void DrawRotatedTriangleTest(); void DrawRotatedTriangleTest();
void NewGenerateClearAndPrepareBufferCmds(XglImage *renderTarget); void NewGenerateClearAndPrepareBufferCmds(XglImage *renderTarget);
void NewGenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline); void NewGenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline);
@ -239,7 +239,7 @@ protected:
this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO; this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
this->app_info.pNext = NULL; this->app_info.pNext = NULL;
this->app_info.pAppName = (const XGL_CHAR *) "base"; this->app_info.pAppName = (const XGL_CHAR *) "render_tests";
this->app_info.appVersion = 1; this->app_info.appVersion = 1;
this->app_info.pEngineName = (const XGL_CHAR *) "unittest"; this->app_info.pEngineName = (const XGL_CHAR *) "unittest";
this->app_info.engineVersion = 1; this->app_info.engineVersion = 1;
@ -484,67 +484,27 @@ void XglRenderTest::InitSampler()
ASSERT_XGL_SUCCESS(err); ASSERT_XGL_SUCCESS(err);
} }
void XglRenderTest::NewGenerateClearAndPrepareBufferCmds(XglImage *renderTarget)
{
// whatever we want to do, we do it to the whole buffer
XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
srRange.baseMipLevel = 0;
srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
srRange.baseArraySlice = 0;
srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
// prepare the whole back buffer for clear
XGL_IMAGE_STATE_TRANSITION transitionToClear = {};
transitionToClear.image = renderTarget->image();
transitionToClear.oldState = renderTarget->state();
transitionToClear.newState = XGL_IMAGE_STATE_CLEAR;
transitionToClear.subresourceRange = srRange;
xglCmdPrepareImages( m_cmdBuffer, 1, &transitionToClear );
renderTarget->state(( XGL_IMAGE_STATE ) transitionToClear.newState);
// clear the back buffer to dark grey
XGL_UINT clearColor[4] = {64, 64, 64, 0};
xglCmdClearColorImageRaw( m_cmdBuffer, renderTarget->image(), clearColor, 1, &srRange );
// prepare back buffer for rendering
XGL_IMAGE_STATE_TRANSITION transitionToRender = {};
transitionToRender.image = renderTarget->image();
transitionToRender.oldState = renderTarget->state();
transitionToRender.newState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL;
transitionToRender.subresourceRange = srRange;
xglCmdPrepareImages( m_cmdBuffer, 1, &transitionToRender );
renderTarget->state(( XGL_IMAGE_STATE ) transitionToClear.newState);
}
void XglRenderTest::NewGenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline)
{
// set all states
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_RASTER, m_stateRaster );
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_VIEWPORT, m_stateViewport );
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil );
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_MSAA, m_stateMsaa );
// bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, *pipeline );
}
void XglRenderTest::DrawRotatedTriangleTest() void XglRenderTest::DrawRotatedTriangleTest()
{ {
// TODO : This test will pass a matrix into VS to affect triangle orientation. // TODO : This test will pass a matrix into VS to affect triangle orientation.
} }
void XglRenderTest::DrawTriangleTest() void XglRenderTest::DrawTriangleTest(const char *vertShaderText, const char *fragShaderText)
{ {
XGL_PIPELINE pipeline; XGL_PIPELINE pipeline;
XGL_SHADER vs, ps; XGL_SHADER vs, ps;
XGL_RESULT err; XGL_RESULT err;
int width = 256, height = 256;
ASSERT_NO_FATAL_FAILURE(InitState()); ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport(256.0, 256.0)); ASSERT_NO_FATAL_FAILURE(InitViewport());
ASSERT_NO_FATAL_FAILURE(CreateDefaultPipeline(&pipeline, &vs, &ps));
ASSERT_NO_FATAL_FAILURE(CreateShader(XGL_SHADER_STAGE_VERTEX,
vertShaderText, &vs));
ASSERT_NO_FATAL_FAILURE(CreateShader(XGL_SHADER_STAGE_FRAGMENT,
fragShaderText, &ps));
ASSERT_NO_FATAL_FAILURE(CreateDefaultPipeline(&pipeline, vs, ps));
/* /*
* Shaders are now part of the pipeline, don't need these anymore * Shaders are now part of the pipeline, don't need these anymore
@ -552,19 +512,7 @@ void XglRenderTest::DrawTriangleTest()
ASSERT_XGL_SUCCESS(xglDestroyObject(ps)); ASSERT_XGL_SUCCESS(xglDestroyObject(ps));
ASSERT_XGL_SUCCESS(xglDestroyObject(vs)); ASSERT_XGL_SUCCESS(xglDestroyObject(vs));
XGL_QUERY_POOL query; ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XGL_GPU_MEMORY query_mem;
ASSERT_NO_FATAL_FAILURE(CreateQueryPool(XGL_QUERY_PIPELINE_STATISTICS, 1, &query, &query_mem));
XglImage *renderTarget;
XGL_FORMAT fmt = {
XGL_CH_FMT_R8G8B8A8,
XGL_NUM_FMT_UNORM
};
ASSERT_NO_FATAL_FAILURE(m_device->CreateImage(width, height, fmt,
XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
&renderTarget));
const int constantCount = 4; const int constantCount = 4;
const float constants[constantCount] = { 0.5, 0.5, 0.5, 1.0 }; const float constants[constantCount] = { 0.5, 0.5, 0.5, 1.0 };
@ -591,70 +539,16 @@ void XglRenderTest::DrawTriangleTest()
err = xglBeginCommandBuffer(m_cmdBuffer, 0); err = xglBeginCommandBuffer(m_cmdBuffer, 0);
ASSERT_XGL_SUCCESS(err); ASSERT_XGL_SUCCESS(err);
GenerateClearAndPrepareBufferCmds(renderTarget); GenerateClearAndPrepareBufferCmds();
GenerateBindRenderTargetCmd(renderTarget); GenerateBindRenderTargetCmd();
GenerateBindStateAndPipelineCmds(&pipeline); GenerateBindStateAndPipelineCmds(&pipeline);
// xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
}
void XglRenderTest::DrawRotatedTriangleTest()
{
// TODO : This test will pass a matrix into VS to affect triangle orientation.
}
void XglRenderTest::DrawTriangleTest()
{
XGL_PIPELINE pipeline;
XGL_SHADER vs, ps;
XGL_RESULT err;
int width = 256, height = 256;
CreateDefaultPipeline(&pipeline, &vs, &ps, width, height);
//ASSERT_XGL_SUCCESS(err);
err = m_device->AllocAndBindGpuMemory(pipeline, "Pipeline", &m_pipe_mem);
ASSERT_XGL_SUCCESS(err);
/*
* Shaders are now part of the pipeline, don't need these anymore
*/
ASSERT_XGL_SUCCESS(xglDestroyObject(ps));
ASSERT_XGL_SUCCESS(xglDestroyObject(vs));
XGL_QUERY_POOL query;
XGL_GPU_MEMORY query_mem;
ASSERT_NO_FATAL_FAILURE(CreateQueryPool(XGL_QUERY_PIPELINE_STATISTICS, 1, &query, &query_mem));
XglImage *renderTarget;
XGL_FORMAT fmt = {
XGL_CH_FMT_R8G8B8A8,
XGL_NUM_FMT_UNORM
};
ASSERT_NO_FATAL_FAILURE(m_device->CreateImage(width, height, fmt,
XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
&renderTarget));
// Build command buffer
err = xglBeginCommandBuffer(m_cmdBuffer, 0);
ASSERT_XGL_SUCCESS(err);
NewGenerateClearAndPrepareBufferCmds(renderTarget);
GenerateBindRenderTargetCmd(renderTarget);
NewGenerateBindStateAndPipelineCmds(&pipeline);
// xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 ); // xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
// xglCmdBindDynamicMemoryView( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, &m_constantBufferView ); // xglCmdBindDynamicMemoryView( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, &m_constantBufferView );
xglCmdResetQueryPool(m_cmdBuffer, query, 0, 1);
xglCmdBeginQuery(m_cmdBuffer, query, 0, 0);
// render the cube // render the cube
xglCmdDraw( m_cmdBuffer, 0, 3, 0, 1 ); xglCmdDraw( m_cmdBuffer, 0, 3, 0, 1 );
xglCmdEndQuery(m_cmdBuffer, query, 0);
// prepare the back buffer for present // prepare the back buffer for present
// XGL_IMAGE_STATE_TRANSITION transitionToPresent = {}; // XGL_IMAGE_STATE_TRANSITION transitionToPresent = {};
// transitionToPresent.image = m_image; // transitionToPresent.image = m_image;
@ -683,31 +577,59 @@ void XglRenderTest::DrawTriangleTest()
// Wait for work to finish before cleaning up. // Wait for work to finish before cleaning up.
xglDeviceWaitIdle(m_device->device()); xglDeviceWaitIdle(m_device->device());
XGL_PIPELINE_STATISTICS_DATA stats; RecordImage(m_renderTarget);
XGL_SIZE stats_size = sizeof(stats);
err = xglGetQueryPoolResults(query, 0, 1, &stats_size, &stats);
ASSERT_XGL_SUCCESS( err );
ASSERT_EQ(stats_size, sizeof(stats));
ASSERT_EQ(stats.vsInvocations, 3);
ASSERT_EQ(stats.cPrimitives, 1);
ASSERT_EQ(stats.cInvocations, 1);
DestroyQueryPool(query, query_mem);
const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();
// renderTarget->WritePPM(test_info->test_case_name());
// m_screen.Display(renderTarget, m_image_mem);
RecordImage(renderTarget);
free(renderTarget);
} }
TEST_F(XglRenderTest, TestDrawTriangle) { TEST_F(XglRenderTest, TestDrawTriangle1) {
DrawTriangleTest(); static const char *vertShaderText =
"#version 130\n"
"vec2 vertices[3];\n"
"void main() {\n"
" vertices[0] = vec2(-1.0, -1.0);\n"
" vertices[1] = vec2( 1.0, -1.0);\n"
" vertices[2] = vec2( 0.0, 1.0);\n"
" gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
"}\n";
static const char *fragShaderText =
"#version 130\n"
"uniform vec4 foo;\n"
"void main() {\n"
" gl_FragColor = foo;\n"
"}\n";
DrawTriangleTest(vertShaderText, fragShaderText);
}
TEST_F(XglRenderTest, TestDrawTriangle2) {
static const char *vertShaderText =
"#version 330\n"
"out vec4 color;\n"
"out vec4 scale;\n"
"void main() {\n"
" vec2 vertices[3];"
" vertices[0] = vec2(-0.5, -0.5);\n"
" vertices[1] = vec2( 0.5, -0.5);\n"
" vertices[2] = vec2( 0.5, 0.5);\n"
" vec4 colors[3];\n"
" colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n"
" colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n"
" colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n"
" color = colors[int(mod(gl_VertexID, 3))];\n"
" scale = vec4(1.0, 1.0, 1.0, 1.0);\n"
" gl_Position = vec4(vertices[int(mod(gl_VertexID, 3))], 0.0, 1.0);\n"
"}\n";
static const char *fragShaderText =
"#version 430\n"
"in vec4 color;\n"
"in vec4 scale;\n"
"layout(location = 0) uniform vec4 foo;\n"
"void main() {\n"
" gl_FragColor = color * scale + foo;\n"
"}\n";
DrawTriangleTest(vertShaderText, fragShaderText);
} }
TEST_F(XglRenderTest, TestDrawRotatedTriangle) { TEST_F(XglRenderTest, TestDrawRotatedTriangle) {

89
tests/xglrenderframework.cpp
View File

@ -34,7 +34,9 @@ XglRenderFramework::XglRenderFramework() :
m_stateDepthStencil( XGL_NULL_HANDLE ), m_stateDepthStencil( XGL_NULL_HANDLE ),
m_stateRaster( XGL_NULL_HANDLE ), m_stateRaster( XGL_NULL_HANDLE ),
m_cmdBuffer( XGL_NULL_HANDLE ), m_cmdBuffer( XGL_NULL_HANDLE ),
m_stateViewport( XGL_NULL_HANDLE ) m_stateViewport( XGL_NULL_HANDLE ),
m_width( 256.0 ), // default window width
m_height( 256.0 ) // default window height
{ {
m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8;
m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM; m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM;
@ -284,6 +286,11 @@ void XglRenderFramework::InitViewport(float width, float height)
m_height = height; m_height = height;
} }
void XglRenderFramework::InitViewport()
{
InitViewport(m_width, m_height);
}
void XglRenderFramework::InitRenderTarget() void XglRenderFramework::InitRenderTarget()
{ {
m_device->CreateImage(m_width, m_height, m_render_target_fmt, m_device->CreateImage(m_width, m_height, m_render_target_fmt,
@ -292,7 +299,7 @@ void XglRenderFramework::InitRenderTarget()
&m_renderTarget); &m_renderTarget);
} }
void XglRenderFramework::CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADER* vs, XGL_SHADER* ps) void XglRenderFramework::CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADER vs, XGL_SHADER ps)
{ {
XGL_RESULT err; XGL_RESULT err;
XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {}; XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
@ -346,69 +353,20 @@ void XglRenderFramework::CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADE
xglAttachMemoryViewDescriptors( m_rsrcDescSet, 0, 1, &m_constantBufferView ); xglAttachMemoryViewDescriptors( m_rsrcDescSet, 0, 1, &m_constantBufferView );
xglEndDescriptorSetUpdate( m_rsrcDescSet ); xglEndDescriptorSetUpdate( m_rsrcDescSet );
static const char *vertShaderText =
"#version 130\n"
"vec2 vertices[3];\n"
"void main() {\n"
" vertices[0] = vec2(-1.0, -1.0);\n"
" vertices[1] = vec2( 1.0, -1.0);\n"
" vertices[2] = vec2( 0.0, 1.0);\n"
" gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
"}\n";
static const char *vertShader2 =
"#version 330\n"
"out vec4 color;\n"
"out vec4 scale;\n"
"void main() {\n"
" vec2 vertices[3];"
" vertices[0] = vec2(-0.5, -0.5);\n"
" vertices[1] = vec2( 0.5, -0.5);\n"
" vertices[2] = vec2( 0.5, 0.5);\n"
" vec4 colors[3];\n"
" colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n"
" colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n"
" colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n"
" color = colors[int(mod(gl_VertexID, 3))];\n"
" scale = vec4(1.0, 1.0, 1.0, 1.0);\n"
" gl_Position = vec4(vertices[int(mod(gl_VertexID, 3))], 0.0, 1.0);\n"
"}\n";
ASSERT_NO_FATAL_FAILURE(CreateShader(XGL_SHADER_STAGE_VERTEX,
vertShader2, vs));
vs_stage.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; vs_stage.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vs_stage.pNext = XGL_NULL_HANDLE; vs_stage.pNext = XGL_NULL_HANDLE;
vs_stage.shader.stage = XGL_SHADER_STAGE_VERTEX; vs_stage.shader.stage = XGL_SHADER_STAGE_VERTEX;
vs_stage.shader.shader = *vs; vs_stage.shader.shader = vs;
vs_stage.shader.descriptorSetMapping[0].descriptorCount = 0; vs_stage.shader.descriptorSetMapping[0].descriptorCount = 0;
vs_stage.shader.linkConstBufferCount = 0; vs_stage.shader.linkConstBufferCount = 0;
vs_stage.shader.pLinkConstBufferInfo = XGL_NULL_HANDLE; vs_stage.shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
vs_stage.shader.dynamicMemoryViewMapping.slotObjectType = XGL_SLOT_UNUSED; vs_stage.shader.dynamicMemoryViewMapping.slotObjectType = XGL_SLOT_UNUSED;
vs_stage.shader.dynamicMemoryViewMapping.shaderEntityIndex = 0; vs_stage.shader.dynamicMemoryViewMapping.shaderEntityIndex = 0;
static const char *fragShaderText =
"#version 130\n"
"uniform vec4 foo;\n"
"void main() {\n"
" gl_FragColor = foo;\n"
"}\n";
static const char *fragShader2 =
"#version 430\n"
"in vec4 color;\n"
"in vec4 scale;\n"
"layout(location = 0) uniform vec4 foo;\n"
"void main() {\n"
" gl_FragColor = color * scale + foo;\n"
"}\n";
ASSERT_NO_FATAL_FAILURE(CreateShader(XGL_SHADER_STAGE_FRAGMENT,
fragShader2, ps));
ps_stage.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; ps_stage.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
ps_stage.pNext = &vs_stage; ps_stage.pNext = &vs_stage;
ps_stage.shader.stage = XGL_SHADER_STAGE_FRAGMENT; ps_stage.shader.stage = XGL_SHADER_STAGE_FRAGMENT;
ps_stage.shader.shader = *ps; ps_stage.shader.shader = ps;
const int slots = 1; const int slots = 1;
XGL_DESCRIPTOR_SLOT_INFO *slotInfo = (XGL_DESCRIPTOR_SLOT_INFO*) malloc( slots * sizeof(XGL_DESCRIPTOR_SLOT_INFO) ); XGL_DESCRIPTOR_SLOT_INFO *slotInfo = (XGL_DESCRIPTOR_SLOT_INFO*) malloc( slots * sizeof(XGL_DESCRIPTOR_SLOT_INFO) );
@ -473,11 +431,11 @@ void XglRenderFramework::CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADE
ASSERT_XGL_SUCCESS(err); ASSERT_XGL_SUCCESS(err);
} }
void XglRenderFramework::GenerateBindRenderTargetCmd(XglImage *renderTarget) void XglRenderFramework::GenerateBindRenderTargetCmd()
{ {
// bind render target // bind render target
XGL_COLOR_ATTACHMENT_BIND_INFO colorBind = {}; XGL_COLOR_ATTACHMENT_BIND_INFO colorBind = {};
colorBind.view = renderTarget->targetView(); colorBind.view = m_renderTarget->targetView();
colorBind.colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL; colorBind.colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL;
xglCmdBindAttachments(m_cmdBuffer, 1, &colorBind, NULL ); xglCmdBindAttachments(m_cmdBuffer, 1, &colorBind, NULL );
} }
@ -493,9 +451,12 @@ void XglRenderFramework::GenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline
// bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view) // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, *pipeline ); xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, *pipeline );
// bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
} }
void XglRenderFramework::GenerateClearAndPrepareBufferCmds(XglImage *renderTarget) void XglRenderFramework::GenerateClearAndPrepareBufferCmds()
{ {
// whatever we want to do, we do it to the whole buffer // whatever we want to do, we do it to the whole buffer
XGL_IMAGE_SUBRESOURCE_RANGE srRange = {}; XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
@ -526,20 +487,4 @@ void XglRenderFramework::GenerateClearAndPrepareBufferCmds(XglImage *renderTarge
transitionToRender.subresourceRange = srRange; transitionToRender.subresourceRange = srRange;
xglCmdPrepareImages( m_cmdBuffer, 1, &transitionToRender ); xglCmdPrepareImages( m_cmdBuffer, 1, &transitionToRender );
m_renderTarget->state(( XGL_IMAGE_STATE ) transitionToClear.newState); m_renderTarget->state(( XGL_IMAGE_STATE ) transitionToClear.newState);
// bind render target
XGL_COLOR_ATTACHMENT_BIND_INFO colorBind = {};
colorBind.view = m_renderTarget->targetView();
colorBind.colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL;
xglCmdBindAttachments(m_cmdBuffer, 1, &colorBind, NULL );
// set all states
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_RASTER, m_stateRaster );
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_VIEWPORT, m_stateViewport );
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil );
xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_MSAA, m_stateMsaa );
// bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
} }

7
tests/xglrenderframework.h
View File

@ -46,13 +46,14 @@ public:
void InitMesh( XGL_UINT32 numVertices, XGL_GPU_SIZE vbStride, const void* vertices ); void InitMesh( XGL_UINT32 numVertices, XGL_GPU_SIZE vbStride, const void* vertices );
void InitConstantBuffer( int constantCount, int constantSize, const void* data ); void InitConstantBuffer( int constantCount, int constantSize, const void* data );
void InitViewport(float width, float height); void InitViewport(float width, float height);
void InitViewport();
void InitRenderTarget(); void InitRenderTarget();
void InitFramework(); void InitFramework();
void ShutdownFramework(); void ShutdownFramework();
void InitState(); void InitState();
void CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADER* vs, XGL_SHADER* ps); void CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADER vs, XGL_SHADER ps);
void GenerateClearAndPrepareBufferCmds(XglImage *renderTarget); void GenerateClearAndPrepareBufferCmds();
void GenerateBindRenderTargetCmd(XglImage *renderTarget); void GenerateBindRenderTargetCmd();
void GenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline); void GenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline);
protected: protected:

12
tests/xgltestframework.cpp
View File

@ -87,7 +87,6 @@ void TestEnvironment::TearDown()
} }
XglTestFramework::XglTestFramework() : XglTestFramework::XglTestFramework() :
m_glut_initialized( false ),
m_compile_options( 0 ), m_compile_options( 0 ),
m_num_shader_strings( 0 ) m_num_shader_strings( 0 )
{ {
@ -105,6 +104,7 @@ bool XglTestFramework::m_save_images = false;
int XglTestFramework::m_width = 0; int XglTestFramework::m_width = 0;
int XglTestFramework::m_height = 0; int XglTestFramework::m_height = 0;
int XglTestFramework::m_window = 0; int XglTestFramework::m_window = 0;
bool XglTestFramework::m_glut_initialized = false;
std::list<XglTestImageRecord> XglTestFramework::m_images; std::list<XglTestImageRecord> XglTestFramework::m_images;
std::list<XglTestImageRecord>::iterator XglTestFramework::m_display_image; std::list<XglTestImageRecord>::iterator XglTestFramework::m_display_image;
int m_display_image_idx = 0; int m_display_image_idx = 0;
@ -165,7 +165,7 @@ void XglTestFramework::WritePPM( const char *basename, XglImage *image )
{ {
string filename; string filename;
XGL_RESULT err; XGL_RESULT err;
int x, y; int x, y;
filename.append(basename); filename.append(basename);
filename.append(".ppm"); filename.append(".ppm");
@ -267,7 +267,8 @@ void XglTestFramework::Show(const char *comment, XglImage *image)
m_images.push_back(record); m_images.push_back(record);
m_display_image = --m_images.end(); m_display_image = --m_images.end();
Display(); // Display();
glutPostRedisplay();
err = image->UnmapMemory(); err = image->UnmapMemory();
ASSERT_XGL_SUCCESS( err ); ASSERT_XGL_SUCCESS( err );
@ -279,11 +280,11 @@ void XglTestFramework::RecordImage(XglImage *image)
::testing::UnitTest::GetInstance()->current_test_info(); ::testing::UnitTest::GetInstance()->current_test_info();
if (m_save_images) { if (m_save_images) {
WritePPM(test_info->test_case_name(), image); WritePPM(test_info->name(), image);
} }
if (m_show_images) { if (m_show_images) {
Show(test_info->test_case_name(), image); Show(test_info->name(), image);
} }
} }
@ -347,6 +348,7 @@ void XglTestFramework::Finish()
glutKeyboardFunc( Key ); glutKeyboardFunc( Key );
glutSpecialFunc( SpecialKey ); glutSpecialFunc( SpecialKey );
glutDisplayFunc( Display ); glutDisplayFunc( Display );
glutIdleFunc(NULL);
glutMainLoop(); glutMainLoop();
} }

2
tests/xgltestframework.h
View File

@ -95,7 +95,7 @@ private:
static std::list<XglTestImageRecord>::iterator m_display_image; static std::list<XglTestImageRecord>::iterator m_display_image;
static int m_display_image_idx; static int m_display_image_idx;
bool m_glut_initialized; static bool m_glut_initialized;
static int m_window; static int m_window;
static int m_width; // Window width static int m_width; // Window width
static int m_height; // Window height static int m_height; // Window height