tests: Rename Xgl->Vk all test objects
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 6de1ddd..848fc83 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -501,9 +501,9 @@
static vk_testing::Environment *environment;
-class XglCmdBlitTest : public ::testing::Test {
+class VkCmdBlitTest : public ::testing::Test {
protected:
- XglCmdBlitTest() :
+ VkCmdBlitTest() :
dev_(environment->default_device()),
queue_(*dev_.graphics_queues()[0]),
cmd_(dev_, vk_testing::CmdBuffer::create_info(dev_.graphics_queue_node_index_))
@@ -543,9 +543,9 @@
std::vector<VK_GPU_MEMORY> mem_refs_;
};
-typedef XglCmdBlitTest XglCmdFillBufferTest;
+typedef VkCmdBlitTest VkCmdFillBufferTest;
-TEST_F(XglCmdFillBufferTest, Basic)
+TEST_F(VkCmdFillBufferTest, Basic)
{
vk_testing::Buffer buf;
@@ -568,7 +568,7 @@
buf.unmap();
}
-TEST_F(XglCmdFillBufferTest, Large)
+TEST_F(VkCmdFillBufferTest, Large)
{
const VK_GPU_SIZE size = 32 * 1024 * 1024;
vk_testing::Buffer buf;
@@ -592,7 +592,7 @@
buf.unmap();
}
-TEST_F(XglCmdFillBufferTest, Overlap)
+TEST_F(VkCmdFillBufferTest, Overlap)
{
vk_testing::Buffer buf;
@@ -615,7 +615,7 @@
buf.unmap();
}
-TEST_F(XglCmdFillBufferTest, MultiAlignments)
+TEST_F(VkCmdFillBufferTest, MultiAlignments)
{
vk_testing::Buffer bufs[9];
VK_GPU_SIZE size = 4;
@@ -644,9 +644,9 @@
}
}
-typedef XglCmdBlitTest XglCmdCopyBufferTest;
+typedef VkCmdBlitTest VkCmdCopyBufferTest;
-TEST_F(XglCmdCopyBufferTest, Basic)
+TEST_F(VkCmdCopyBufferTest, Basic)
{
vk_testing::Buffer src, dst;
@@ -672,7 +672,7 @@
dst.unmap();
}
-TEST_F(XglCmdCopyBufferTest, Large)
+TEST_F(VkCmdCopyBufferTest, Large)
{
const VK_GPU_SIZE size = 32 * 1024 * 1024;
vk_testing::Buffer src, dst;
@@ -702,7 +702,7 @@
dst.unmap();
}
-TEST_F(XglCmdCopyBufferTest, MultiAlignments)
+TEST_F(VkCmdCopyBufferTest, MultiAlignments)
{
const VK_BUFFER_COPY regions[] = {
/* well aligned */
@@ -751,7 +751,7 @@
dst.unmap();
}
-TEST_F(XglCmdCopyBufferTest, RAWHazard)
+TEST_F(VkCmdCopyBufferTest, RAWHazard)
{
vk_testing::Buffer bufs[3];
VK_EVENT_CREATE_INFO event_info;
@@ -882,7 +882,7 @@
ASSERT_VK_SUCCESS(err);
}
-class XglCmdBlitImageTest : public XglCmdBlitTest {
+class VkCmdBlitImageTest : public VkCmdBlitTest {
protected:
void init_test_formats(VK_FLAGS features)
{
@@ -968,11 +968,11 @@
VK_FORMAT first_optimal_format_;
};
-class XglCmdCopyBufferToImageTest : public XglCmdBlitImageTest {
+class VkCmdCopyBufferToImageTest : public VkCmdBlitImageTest {
protected:
virtual void SetUp()
{
- XglCmdBlitTest::SetUp();
+ VkCmdBlitTest::SetUp();
init_test_formats(VK_FORMAT_IMAGE_COPY_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1014,7 +1014,7 @@
}
};
-TEST_F(XglCmdCopyBufferToImageTest, Basic)
+TEST_F(VkCmdCopyBufferToImageTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -1036,11 +1036,11 @@
}
}
-class XglCmdCopyImageToBufferTest : public XglCmdBlitImageTest {
+class VkCmdCopyImageToBufferTest : public VkCmdBlitImageTest {
protected:
virtual void SetUp()
{
- XglCmdBlitTest::SetUp();
+ VkCmdBlitTest::SetUp();
init_test_formats(VK_FORMAT_IMAGE_COPY_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1082,7 +1082,7 @@
}
};
-TEST_F(XglCmdCopyImageToBufferTest, Basic)
+TEST_F(VkCmdCopyImageToBufferTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -1104,11 +1104,11 @@
}
}
-class XglCmdCopyImageTest : public XglCmdBlitImageTest {
+class VkCmdCopyImageTest : public VkCmdBlitImageTest {
protected:
virtual void SetUp()
{
- XglCmdBlitTest::SetUp();
+ VkCmdBlitTest::SetUp();
init_test_formats(VK_FORMAT_IMAGE_COPY_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1164,7 +1164,7 @@
}
};
-TEST_F(XglCmdCopyImageTest, Basic)
+TEST_F(VkCmdCopyImageTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -1191,11 +1191,11 @@
}
}
-class XglCmdCloneImageDataTest : public XglCmdBlitImageTest {
+class VkCmdCloneImageDataTest : public VkCmdBlitImageTest {
protected:
virtual void SetUp()
{
- XglCmdBlitTest::SetUp();
+ VkCmdBlitTest::SetUp();
init_test_formats();
ASSERT_NE(true, test_formats_.empty());
}
@@ -1229,7 +1229,7 @@
}
};
-TEST_F(XglCmdCloneImageDataTest, Basic)
+TEST_F(VkCmdCloneImageDataTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -1263,14 +1263,14 @@
}
}
-class XglCmdClearColorImageTest : public XglCmdBlitImageTest {
+class VkCmdClearColorImageTest : public VkCmdBlitImageTest {
protected:
- XglCmdClearColorImageTest() : test_raw_(false) {}
- XglCmdClearColorImageTest(bool test_raw) : test_raw_(test_raw) {}
+ VkCmdClearColorImageTest() : test_raw_(false) {}
+ VkCmdClearColorImageTest(bool test_raw) : test_raw_(test_raw) {}
virtual void SetUp()
{
- XglCmdBlitTest::SetUp();
+ VkCmdBlitTest::SetUp();
if (test_raw_)
init_test_formats();
@@ -1439,7 +1439,7 @@
}
};
-TEST_F(XglCmdClearColorImageTest, Basic)
+TEST_F(VkCmdClearColorImageTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -1460,9 +1460,9 @@
}
}
-class XglCmdClearColorImageRawTest : public XglCmdClearColorImageTest {
+class VkCmdClearColorImageRawTest : public VkCmdClearColorImageTest {
protected:
- XglCmdClearColorImageRawTest() : XglCmdClearColorImageTest(true) {}
+ VkCmdClearColorImageRawTest() : VkCmdClearColorImageTest(true) {}
void test_clear_color_image_raw(const VK_IMAGE_CREATE_INFO &img_info,
const uint32_t color[4],
@@ -1475,7 +1475,7 @@
}
};
-TEST_F(XglCmdClearColorImageRawTest, Basic)
+TEST_F(VkCmdClearColorImageRawTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
@@ -1512,11 +1512,11 @@
}
}
-class XglCmdClearDepthStencilTest : public XglCmdBlitImageTest {
+class VkCmdClearDepthStencilTest : public VkCmdBlitImageTest {
protected:
virtual void SetUp()
{
- XglCmdBlitTest::SetUp();
+ VkCmdBlitTest::SetUp();
init_test_formats(VK_FORMAT_DEPTH_ATTACHMENT_BIT |
VK_FORMAT_STENCIL_ATTACHMENT_BIT);
ASSERT_NE(true, test_formats_.empty());
@@ -1658,7 +1658,7 @@
}
};
-TEST_F(XglCmdClearDepthStencilTest, Basic)
+TEST_F(VkCmdClearDepthStencilTest, Basic)
{
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index a843a4a..8898ae7 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -63,7 +63,7 @@
#include "vktestbinding.h"
#include "test_common.h"
-class XglImageTest : public ::testing::Test {
+class VkImageTest : public ::testing::Test {
public:
void CreateImage(uint32_t w, uint32_t h);
void DestroyImage();
@@ -117,7 +117,7 @@
};
-void XglImageTest::CreateImage(uint32_t w, uint32_t h)
+void VkImageTest::CreateImage(uint32_t w, uint32_t h)
{
VK_RESULT err;
uint32_t mipCount;
@@ -257,7 +257,7 @@
}
}
-void XglImageTest::DestroyImage()
+void VkImageTest::DestroyImage()
{
VK_RESULT err;
// All done with image memory, clean up
@@ -272,19 +272,19 @@
ASSERT_VK_SUCCESS(vkDestroyObject(m_image));
}
-void XglImageTest::CreateImageView(VK_IMAGE_VIEW_CREATE_INFO *pCreateInfo,
+void VkImageTest::CreateImageView(VK_IMAGE_VIEW_CREATE_INFO *pCreateInfo,
VK_IMAGE_VIEW *pView)
{
pCreateInfo->image = this->m_image;
ASSERT_VK_SUCCESS(vkCreateImageView(device(), pCreateInfo, pView));
}
-void XglImageTest::DestroyImageView(VK_IMAGE_VIEW imageView)
+void VkImageTest::DestroyImageView(VK_IMAGE_VIEW imageView)
{
ASSERT_VK_SUCCESS(vkDestroyObject(imageView));
}
-TEST_F(XglImageTest, CreateImageViewTest) {
+TEST_F(VkImageTest, CreateImageViewTest) {
VK_FORMAT fmt;
VK_IMAGE_VIEW imageView;
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index f79b435..172805b 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -55,15 +55,15 @@
errMonitor->SetState(msgType, pMsg);
}
}
-class VkLayerTest : public XglRenderFramework
+class VkLayerTest : public VkRenderFramework
{
public:
- VK_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
- VK_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
+ VK_RESULT BeginCommandBuffer(VkCommandBufferObj &cmdBuffer);
+ VK_RESULT EndCommandBuffer(VkCommandBufferObj &cmdBuffer);
protected:
- XglMemoryRefManager m_memoryRefManager;
- ErrorMonitor *m_errorMonitor;
+ VkMemoryRefManager m_memoryRefManager;
+ ErrorMonitor *m_errorMonitor;
virtual void SetUp() {
@@ -85,7 +85,7 @@
delete m_errorMonitor;
}
};
-VK_RESULT VkLayerTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT VkLayerTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer)
{
VK_RESULT result;
@@ -102,7 +102,7 @@
return result;
}
-VK_RESULT VkLayerTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT VkLayerTest::EndCommandBuffer(VkCommandBufferObj &cmdBuffer)
{
VK_RESULT result;
@@ -129,7 +129,7 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
BeginCommandBuffer(cmdBuffer);
@@ -142,7 +142,7 @@
msgType = m_errorMonitor->GetState(&msgString);
ASSERT_EQ(msgType, VK_DBG_MSG_ERROR) << "Did not receive an err from using a fence in SIGNALED state in call to vkQueueSubmit";
if (!strstr(msgString.c_str(),"submitted in SIGNALED state. Fences must be reset before being submitted")) {
- ASSERT_TRUE(false) << "Error received was not vkQueueSubmit with fence in SIGNALED_STATE";
+ ASSERT_TRUE(false) << "Error received was not VkQueueSubmit with fence in SIGNALED_STATE";
}
}
@@ -165,8 +165,8 @@
vkResetFences(m_device->device(), 1, fences);
msgType = m_errorMonitor->GetState(&msgString);
ASSERT_EQ(msgType, VK_DBG_MSG_ERROR) << "Did not receive an error from submitting fence with UNSIGNALED state to vkResetFences";
- if (!strstr(msgString.c_str(),"submitted to vkResetFences in UNSIGNALED STATE")) {
- ASSERT_TRUE(false) << "Error received was not vkResetFences with fence in UNSIGNALED_STATE";
+ if (!strstr(msgString.c_str(),"submitted to VkResetFences in UNSIGNALED STATE")) {
+ ASSERT_TRUE(false) << "Error received was not VkResetFences with fence in UNSIGNALED_STATE";
}
}
@@ -175,12 +175,12 @@
int result;
::testing::InitGoogleTest(&argc, argv);
- XglTestFramework::InitArgs(&argc, argv);
+ VkTestFramework::InitArgs(&argc, argv);
::testing::AddGlobalTestEnvironment(new TestEnvironment);
result = RUN_ALL_TESTS();
- XglTestFramework::Finish();
+ VkTestFramework::Finish();
return result;
}
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 882f14f..3a8ca6a 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -209,18 +209,18 @@
{ XYZ1( -1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) },
};
-class XglRenderTest : public XglRenderFramework
+class VkRenderTest : public VkRenderFramework
{
public:
void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
- XglConstantBufferObj *constantBuffer, XglCommandBufferObj *cmdBuffer);
- void GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj &pipelineobj, XglDescriptorSetObj &descriptorSet);
+ VkConstantBufferObj *constantBuffer, VkCommandBufferObj *cmdBuffer);
+ void GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet);
void InitDepthStencil();
void VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
- VK_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
- VK_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
+ VK_RESULT BeginCommandBuffer(VkCommandBufferObj &cmdBuffer);
+ VK_RESULT EndCommandBuffer(VkCommandBufferObj &cmdBuffer);
protected:
VK_IMAGE m_texture;
@@ -253,7 +253,7 @@
}
};
-VK_RESULT XglRenderTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer)
{
VK_RESULT result;
@@ -270,7 +270,7 @@
return result;
}
-VK_RESULT XglRenderTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
+VK_RESULT VkRenderTest::EndCommandBuffer(VkCommandBufferObj &cmdBuffer)
{
VK_RESULT result;
@@ -282,7 +282,7 @@
}
-void XglRenderTest::GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj &pipelineobj, XglDescriptorSetObj &descriptorSet)
+void VkRenderTest::GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet)
{
if (m_depthStencil->Initialized()) {
cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
@@ -301,8 +301,8 @@
cmdBuffer->BindDescriptorSet(descriptorSet);
}
-void XglRenderTest::RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
- XglConstantBufferObj *constantBuffer, XglCommandBufferObj *cmdBuffer)
+void VkRenderTest::RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
+ VkConstantBufferObj *constantBuffer, VkCommandBufferObj *cmdBuffer)
{
int i;
glm::mat4 MVP;
@@ -359,7 +359,7 @@
float color[3][4];
};
-void XglRenderTest::VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate)
+void VkRenderTest::VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate)
{
#ifdef DEBUG_CALLBACK
vkDbgRegisterMsgCallback(inst, myDbgFunc, NULL);
@@ -397,20 +397,20 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj constantBuffer(m_device, bufSize*2, sizeof(float), (const void*) &data);
+ VkConstantBufferObj constantBuffer(m_device, bufSize*2, sizeof(float), (const void*) &data);
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, constantBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -451,7 +451,7 @@
}
-TEST_F(XglRenderTest, VKTriangle_FragColor)
+TEST_F(VkRenderTest, VKTriangle_FragColor)
{
static const char *vertShaderText =
"#version 140\n"
@@ -488,7 +488,7 @@
VKTriangleTest(vertShaderText, fragShaderText, true);
}
-TEST_F(XglRenderTest, VKTriangle_OutputLocation)
+TEST_F(VkRenderTest, VKTriangle_OutputLocation)
{
static const char *vertShaderText =
"#version 140\n"
@@ -527,9 +527,9 @@
VKTriangleTest(vertShaderText, fragShaderText, true);
}
#ifndef _WIN32 // Implicit (for now at least) in WIN32 is that we are using the Nvidia driver and it won't consume SPIRV yet
-TEST_F(XglRenderTest, SPV_VKTriangle)
+TEST_F(VkRenderTest, SPV_VKTriangle)
{
- bool saved_use_spv = XglTestFramework::m_use_spv;
+ bool saved_use_spv = VkTestFramework::m_use_spv;
static const char *vertShaderText =
"#version 140\n"
@@ -564,14 +564,14 @@
TEST_DESCRIPTION("VK-style shaders, but force test framework to compile shader to SPV and pass SPV to driver.");
- XglTestFramework::m_use_spv = true;
+ VkTestFramework::m_use_spv = true;
VKTriangleTest(vertShaderText, fragShaderText, true);
- XglTestFramework::m_use_spv = saved_use_spv;
+ VkTestFramework::m_use_spv = saved_use_spv;
}
#endif
-TEST_F(XglRenderTest, GreenTriangle)
+TEST_F(VkRenderTest, GreenTriangle)
{
static const char *vertShaderText =
"#version 130\n"
@@ -594,9 +594,9 @@
VKTriangleTest(vertShaderText, fragShaderText, false);
}
#ifndef _WIN32 // Implicit (for now at least) in WIN32 is that we are using the Nvidia driver and it won't consume SPIRV yet
-TEST_F(XglRenderTest, SPV_GreenTriangle)
+TEST_F(VkRenderTest, SPV_GreenTriangle)
{
- bool saved_use_spv = XglTestFramework::m_use_spv;
+ bool saved_use_spv = VkTestFramework::m_use_spv;
static const char *vertShaderText =
"#version 130\n"
@@ -616,12 +616,12 @@
TEST_DESCRIPTION("Same shader as GreenTriangle, but compiles shader to SPV and gives SPV to driver.");
- XglTestFramework::m_use_spv = true;
+ VkTestFramework::m_use_spv = true;
VKTriangleTest(vertShaderText, fragShaderText, false);
- XglTestFramework::m_use_spv = saved_use_spv;
+ VkTestFramework::m_use_spv = saved_use_spv;
}
#endif
-TEST_F(XglRenderTest, YellowTriangle)
+TEST_F(VkRenderTest, YellowTriangle)
{
static const char *vertShaderText =
"#version 130\n"
@@ -646,7 +646,7 @@
VKTriangleTest(vertShaderText, fragShaderText, false);
}
-TEST_F(XglRenderTest, QuadWithVertexFetch)
+TEST_F(VkRenderTest, QuadWithVertexFetch)
{
static const char *vertShaderText =
"#version 140\n"
@@ -678,17 +678,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BIND_ID 0
@@ -713,7 +713,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BIND_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -733,7 +733,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleMRT)
+TEST_F(VkRenderTest, TriangleMRT)
{
static const char *vertShaderText =
"#version 140\n"
@@ -759,13 +759,13 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data);
+ VkConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
@@ -786,7 +786,7 @@
pipelineobj.AddVertexInputBindings(&vi_binding,1);
pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget(2));
@@ -797,7 +797,7 @@
att.channelWriteMask = 0xf;
pipelineobj.AddColorAttachment(1, &att);
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
cmdBuffer.AddRenderTarget(m_renderTargets[1]);
@@ -822,7 +822,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, QuadWithIndexedVertexFetch)
+TEST_F(VkRenderTest, QuadWithIndexedVertexFetch)
{
static const char *vertShaderText =
"#version 140\n"
@@ -867,21 +867,21 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglIndexBufferObj indexBuffer(m_device);
+ VkIndexBufferObj indexBuffer(m_device);
indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), VK_INDEX_16, g_idxData);
indexBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, indexBuffer);
@@ -907,7 +907,7 @@
pipelineobj.AddVertexInputBindings(&vi_binding,1);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -931,7 +931,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, GreyandRedCirclesonBlue)
+TEST_F(VkRenderTest, GreyandRedCirclesonBlue)
{
// This tests gl_FragCoord
@@ -967,17 +967,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BIND_ID 0
@@ -998,7 +998,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1021,7 +1021,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, RedCirclesonBlue)
+TEST_F(VkRenderTest, RedCirclesonBlue)
{
// This tests that we correctly handle unread fragment inputs
@@ -1057,17 +1057,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BIND_ID 0
@@ -1088,7 +1088,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1110,7 +1110,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, GreyCirclesonBlueFade)
+TEST_F(VkRenderTest, GreyCirclesonBlueFade)
{
// This tests reading gl_ClipDistance from FS
@@ -1157,17 +1157,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BIND_ID 0
@@ -1188,7 +1188,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1211,7 +1211,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, GreyCirclesonBlueDiscard)
+TEST_F(VkRenderTest, GreyCirclesonBlueDiscard)
{
static const char *vertShaderText =
"#version 140\n"
@@ -1248,17 +1248,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BIND_ID 0
@@ -1279,7 +1279,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer,MESH_BIND_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1303,7 +1303,7 @@
}
-TEST_F(XglRenderTest, TriangleVSUniform)
+TEST_F(VkRenderTest, TriangleVSUniform)
{
static const char *vertShaderText =
"#version 140\n"
@@ -1337,20 +1337,20 @@
glm::mat4 MVP = Projection * View * Model;
const int matrixSize = sizeof(MVP) / sizeof(MVP[0]);
- XglConstantBufferObj MVPBuffer(m_device, matrixSize, sizeof(MVP[0]), (const void*) &MVP[0][0]);
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkConstantBufferObj MVPBuffer(m_device, matrixSize, sizeof(MVP[0]), (const void*) &MVP[0][0]);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
// Create descriptor set and attach the constant buffer to it
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1375,7 +1375,7 @@
RotateTriangleVSUniform(Projection, View, Model, &MVPBuffer, &cmdBuffer);
}
-TEST_F(XglRenderTest, MixTriangle)
+TEST_F(VkRenderTest, MixTriangle)
{
// This tests location applied to varyings. Notice that we have switched foo
// and bar in the FS. The triangle should be blended with red, green and blue
@@ -1416,18 +1416,18 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendDummy();
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1449,7 +1449,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, QuadVertFetchAndVertID)
+TEST_F(VkRenderTest, QuadVertFetchAndVertID)
{
// This tests that attributes work in the presence of gl_VertexID
@@ -1482,17 +1482,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BUF_ID 0
@@ -1517,7 +1517,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1540,7 +1540,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, QuadSparseVertFetch)
+TEST_F(VkRenderTest, QuadSparseVertFetch)
{
// This tests that attributes work in the presence of gl_VertexID
@@ -1587,17 +1587,17 @@
{ XYZ1(0, 0, 0), XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
};
- XglConstantBufferObj meshBuffer(m_device,sizeof(vData)/sizeof(vData[0]),sizeof(vData[0]), vData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(vData)/sizeof(vData[0]),sizeof(vData[0]), vData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BUF_ID 0
@@ -1622,7 +1622,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1645,7 +1645,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriVertFetchDeadAttr)
+TEST_F(VkRenderTest, TriVertFetchDeadAttr)
{
// This tests that attributes work in the presence of gl_VertexID
// and a dead attribute in position 0. Draws a triangle with yellow,
@@ -1682,17 +1682,17 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
meshBuffer.BufferMemoryBarrier();
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, meshBuffer);
#define MESH_BUF_ID 0
@@ -1717,7 +1717,7 @@
pipelineobj.AddVertexDataBuffer(&meshBuffer, MESH_BUF_ID);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1740,7 +1740,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, CubeWithVertexFetchAndMVP)
+TEST_F(VkRenderTest, CubeWithVertexFetchAndMVP)
{
static const char *vertShaderText =
"#version 140\n"
@@ -1779,16 +1779,16 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
m_depthStencil->Init(m_device, m_width, m_height);
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data);
const int buf_size = sizeof(MVP) / sizeof(float);
- XglConstantBufferObj MVPBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkConstantBufferObj MVPBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
@@ -1806,7 +1806,7 @@
ds_state.front = ds_state.back;
pipelineobj.SetDepthStencil(&ds_state);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
#define MESH_BUF_ID 0
@@ -1832,7 +1832,7 @@
ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1855,7 +1855,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, VSTexture)
+TEST_F(VkRenderTest, VSTexture)
{
// The expected result from this test is a green and red triangle;
// one red vertex on the left, two green vertices on the right.
@@ -1887,20 +1887,20 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglSamplerObj sampler(m_device);
- XglTextureObj texture(m_device);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkSamplerObj sampler(m_device);
+ VkTextureObj texture(m_device);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler, &texture);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1921,7 +1921,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TexturedTriangle)
+TEST_F(VkRenderTest, TexturedTriangle)
{
// The expected result from this test is a red and green checkered triangle
static const char *vertShaderText =
@@ -1957,20 +1957,20 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglSamplerObj sampler(m_device);
- XglTextureObj texture(m_device);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkSamplerObj sampler(m_device);
+ VkTextureObj texture(m_device);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler, &texture);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -1990,7 +1990,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TexturedTriangleClip)
+TEST_F(VkRenderTest, TexturedTriangleClip)
{
// The expected result from this test is a red and green checkered triangle
static const char *vertShaderText =
@@ -2037,20 +2037,20 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglSamplerObj sampler(m_device);
- XglTextureObj texture(m_device);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkSamplerObj sampler(m_device);
+ VkTextureObj texture(m_device);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler, &texture);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2070,7 +2070,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, FSTriangle)
+TEST_F(VkRenderTest, FSTriangle)
{
// The expected result from this test is a red and green checkered triangle
static const char *vertShaderText =
@@ -2106,20 +2106,20 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglSamplerObj sampler(m_device);
- XglTextureObj texture(m_device);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkSamplerObj sampler(m_device);
+ VkTextureObj texture(m_device);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler, &texture);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2139,7 +2139,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, SamplerBindingsTriangle)
+TEST_F(VkRenderTest, SamplerBindingsTriangle)
{
// This test sets bindings on the samplers
// For now we are asserting that sampler and texture pairs
@@ -2181,25 +2181,25 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglSamplerObj sampler1(m_device);
- XglSamplerObj sampler2(m_device);
- XglSamplerObj sampler3(m_device);
+ VkSamplerObj sampler1(m_device);
+ VkSamplerObj sampler2(m_device);
+ VkSamplerObj sampler3(m_device);
uint32_t tex_colors[2] = { 0xffff0000, 0xffff0000 };
- XglTextureObj texture1(m_device, tex_colors); // Red
+ VkTextureObj texture1(m_device, tex_colors); // Red
tex_colors[0] = 0xff00ff00; tex_colors[1] = 0xff00ff00;
- XglTextureObj texture2(m_device, tex_colors); // Green
+ VkTextureObj texture2(m_device, tex_colors); // Green
tex_colors[0] = 0xff0000ff; tex_colors[1] = 0xff0000ff;
- XglTextureObj texture3(m_device, tex_colors); // Blue
+ VkTextureObj texture3(m_device, tex_colors); // Blue
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler1, &texture1);
descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
for (int i = 0; i < 10; i++)
@@ -2207,7 +2207,7 @@
descriptorSet.AppendSamplerTexture(&sampler3, &texture3);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2228,7 +2228,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleVSUniformBlock)
+TEST_F(VkRenderTest, TriangleVSUniformBlock)
{
// The expected result from this test is a blue triangle
@@ -2264,8 +2264,8 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
// Let's populate our buffer with the following:
// vec4 red;
@@ -2278,17 +2278,17 @@
0.0, 0.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0 };
- XglConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals);
+ VkConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, colorBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2309,7 +2309,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleFSUniformBlockBinding)
+TEST_F(VkRenderTest, TriangleFSUniformBlockBinding)
{
// This test allows the shader to select which buffer it is
// pulling from using layout binding qualifier.
@@ -2347,8 +2347,8 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
// We're going to create a number of uniform buffers, and then allow
// the shader to select which it wants to read from with a binding
@@ -2369,26 +2369,26 @@
const int blueCount = sizeof(blueVals) / sizeof(float);
const int whiteCount = sizeof(whiteVals) / sizeof(float);
- XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
+ VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
+ VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
+ VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
+ VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2409,7 +2409,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleFSAnonymousUniformBlockBinding)
+TEST_F(VkRenderTest, TriangleFSAnonymousUniformBlockBinding)
{
// This test is the same as TriangleFSUniformBlockBinding, but
// it does not provide an instance name.
@@ -2443,8 +2443,8 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
// We're going to create a number of uniform buffers, and then allow
// the shader to select which it wants to read from with a binding
@@ -2465,26 +2465,26 @@
const int blueCount = sizeof(blueVals) / sizeof(float);
const int whiteCount = sizeof(whiteVals) / sizeof(float);
- XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
+ VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
+ VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
+ VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
+ VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2505,7 +2505,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, CubeWithVertexFetchAndMVPAndTexture)
+TEST_F(VkRenderTest, CubeWithVertexFetchAndMVPAndTexture)
{
static const char *vertShaderText =
"#version 140\n"
@@ -2552,23 +2552,23 @@
ASSERT_NO_FATAL_FAILURE(InitViewport());
m_depthStencil->Init(m_device, m_width, m_height);
- XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
+ VkConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data);
meshBuffer.BufferMemoryBarrier();
const int buf_size = sizeof(MVP) / sizeof(float);
- XglConstantBufferObj mvpBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglSamplerObj sampler(m_device);
- XglTextureObj texture(m_device);
+ VkConstantBufferObj mvpBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkSamplerObj sampler(m_device);
+ VkTextureObj texture(m_device);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mvpBuffer);
descriptorSet.AppendSamplerTexture(&sampler, &texture);
@@ -2608,7 +2608,7 @@
pipelineobj.SetDepthStencil(&ds_state);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2630,7 +2630,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleMixedSamplerUniformBlockBinding)
+TEST_F(VkRenderTest, TriangleMixedSamplerUniformBlockBinding)
{
// This test mixes binding slots of textures and buffers, ensuring
// that sparse and overlapping assignments work.
@@ -2673,8 +2673,8 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
@@ -2686,32 +2686,32 @@
const int blueCount = sizeof(blueVals) / sizeof(float);
const int whiteCount = sizeof(whiteVals) / sizeof(float);
- XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
+ VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
+ VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
+ VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
+ VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
uint32_t tex_colors[2] = { 0xff800000, 0xff800000 };
- XglSamplerObj sampler0(m_device);
- XglTextureObj texture0(m_device, tex_colors); // Light Red
+ VkSamplerObj sampler0(m_device);
+ VkTextureObj texture0(m_device, tex_colors); // Light Red
tex_colors[0] = 0xff000080; tex_colors[1] = 0xff000080;
- XglSamplerObj sampler2(m_device);
- XglTextureObj texture2(m_device, tex_colors); // Light Blue
+ VkSamplerObj sampler2(m_device);
+ VkTextureObj texture2(m_device, tex_colors); // Light Blue
tex_colors[0] = 0xff008000; tex_colors[1] = 0xff008000;
- XglSamplerObj sampler4(m_device);
- XglTextureObj texture4(m_device, tex_colors); // Light Green
+ VkSamplerObj sampler4(m_device);
+ VkTextureObj texture4(m_device, tex_colors); // Light Green
// NOTE: Bindings 1,3,5,7,8,9,11,12,14,16 work for this sampler, but 6 does not!!!
// TODO: Get back here ASAP and understand why.
tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff;
- XglSamplerObj sampler7(m_device);
- XglTextureObj texture7(m_device, tex_colors); // Red and Blue
+ VkSamplerObj sampler7(m_device);
+ VkTextureObj texture7(m_device, tex_colors); // Red and Blue
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
@@ -2723,7 +2723,7 @@
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2744,7 +2744,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleMatchingSamplerUniformBlockBinding)
+TEST_F(VkRenderTest, TriangleMatchingSamplerUniformBlockBinding)
{
// This test matches binding slots of textures and buffers, requiring
// the driver to give them distinct number spaces.
@@ -2785,8 +2785,8 @@
ASSERT_NO_FATAL_FAILURE(InitState());
ASSERT_NO_FATAL_FAILURE(InitViewport());
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
@@ -2798,29 +2798,29 @@
const int blueCount = sizeof(blueVals) / sizeof(float);
const int whiteCount = sizeof(whiteVals) / sizeof(float);
- XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
+ VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
+ VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
+ VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
+ VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
uint32_t tex_colors[2] = { 0xff800000, 0xff800000 };
- XglSamplerObj sampler0(m_device);
- XglTextureObj texture0(m_device, tex_colors); // Light Red
+ VkSamplerObj sampler0(m_device);
+ VkTextureObj texture0(m_device, tex_colors); // Light Red
tex_colors[0] = 0xff000080; tex_colors[1] = 0xff000080;
- XglSamplerObj sampler2(m_device);
- XglTextureObj texture2(m_device, tex_colors); // Light Blue
+ VkSamplerObj sampler2(m_device);
+ VkTextureObj texture2(m_device, tex_colors); // Light Blue
tex_colors[0] = 0xff008000; tex_colors[1] = 0xff008000;
- XglSamplerObj sampler4(m_device);
- XglTextureObj texture4(m_device, tex_colors); // Light Green
+ VkSamplerObj sampler4(m_device);
+ VkTextureObj texture4(m_device, tex_colors); // Light Green
tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff;
- XglSamplerObj sampler7(m_device);
- XglTextureObj texture7(m_device, tex_colors); // Red and Blue
+ VkSamplerObj sampler7(m_device);
+ VkTextureObj texture7(m_device, tex_colors); // Red and Blue
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
@@ -2831,7 +2831,7 @@
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -2852,7 +2852,7 @@
RecordImages(m_renderTargets);
}
-TEST_F(XglRenderTest, TriangleUniformBufferLayout)
+TEST_F(VkRenderTest, TriangleUniformBufferLayout)
{
// This test populates a buffer with a variety of different data
// types, then reads them out with a shader.
@@ -3068,20 +3068,20 @@
const int constCount = sizeof(mixedVals) / sizeof(float);
- XglShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
- XglShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
+ VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
+ VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT, this);
- XglConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
+ VkConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
- XglPipelineObj pipelineobj(m_device);
+ VkPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
- XglDescriptorSetObj descriptorSet(m_device);
+ VkDescriptorSetObj descriptorSet(m_device);
descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mixedBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
- XglCommandBufferObj cmdBuffer(m_device);
+ VkCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
ASSERT_VK_SUCCESS(BeginCommandBuffer(cmdBuffer));
@@ -3106,12 +3106,12 @@
int result;
::testing::InitGoogleTest(&argc, argv);
- XglTestFramework::InitArgs(&argc, argv);
+ VkTestFramework::InitArgs(&argc, argv);
::testing::AddGlobalTestEnvironment(new TestEnvironment);
result = RUN_ALL_TESTS();
- XglTestFramework::Finish();
+ VkTestFramework::Finish();
return result;
}
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 6943ddf..9d38aa2 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -27,7 +27,7 @@
#include "vkrenderframework.h"
-XglRenderFramework::XglRenderFramework() :
+VkRenderFramework::VkRenderFramework() :
m_cmdBuffer( VK_NULL_HANDLE ),
m_renderPass(VK_NULL_HANDLE),
m_framebuffer(VK_NULL_HANDLE),
@@ -51,12 +51,12 @@
m_clear_color.useRawValue = true;
}
-XglRenderFramework::~XglRenderFramework()
+VkRenderFramework::~VkRenderFramework()
{
}
-void XglRenderFramework::InitFramework()
+void VkRenderFramework::InitFramework()
{
VK_RESULT err;
VK_INSTANCE_CREATE_INFO instInfo = {};
@@ -73,13 +73,13 @@
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, 1) << "No GPU available";
- m_device = new XglDevice(0, objs[0]);
+ m_device = new VkDeviceObj(0, objs[0]);
m_device->get_device_queue();
- m_depthStencil = new XglDepthStencilObj();
+ m_depthStencil = new VkDepthStencilObj();
}
-void XglRenderFramework::ShutdownFramework()
+void VkRenderFramework::ShutdownFramework()
{
if (m_colorBlend) vkDestroyObject(m_colorBlend);
if (m_stateDepthStencil) vkDestroyObject(m_stateDepthStencil);
@@ -106,7 +106,7 @@
vkDestroyInstance(this->inst);
}
-void XglRenderFramework::InitState()
+void VkRenderFramework::InitState()
{
VK_RESULT err;
@@ -144,7 +144,7 @@
ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
}
-void XglRenderFramework::InitViewport(float width, float height)
+void VkRenderFramework::InitViewport(float width, float height)
{
VK_RESULT err;
@@ -173,26 +173,26 @@
m_height = height;
}
-void XglRenderFramework::InitViewport()
+void VkRenderFramework::InitViewport()
{
InitViewport(m_width, m_height);
}
-void XglRenderFramework::InitRenderTarget()
+void VkRenderFramework::InitRenderTarget()
{
InitRenderTarget(1);
}
-void XglRenderFramework::InitRenderTarget(uint32_t targets)
+void VkRenderFramework::InitRenderTarget(uint32_t targets)
{
InitRenderTarget(targets, NULL);
}
-void XglRenderFramework::InitRenderTarget(VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
+void VkRenderFramework::InitRenderTarget(VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
{
InitRenderTarget(1, dsBinding);
}
-void XglRenderFramework::InitRenderTarget(uint32_t targets, VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
+void VkRenderFramework::InitRenderTarget(uint32_t targets, VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
{
std::vector<VK_ATTACHMENT_LOAD_OP> load_ops;
std::vector<VK_ATTACHMENT_STORE_OP> store_ops;
@@ -201,7 +201,7 @@
uint32_t i;
for (i = 0; i < targets; i++) {
- XglImage *img = new XglImage(m_device);
+ VkImageObj *img = new VkImageObj(m_device);
img->init(m_width, m_height, m_render_target_fmt,
VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
@@ -253,7 +253,7 @@
-XglDevice::XglDevice(uint32_t id, VK_PHYSICAL_GPU obj) :
+VkDeviceObj::VkDeviceObj(uint32_t id, VK_PHYSICAL_GPU obj) :
vk_testing::Device(obj), id(id)
{
init();
@@ -262,25 +262,25 @@
queue_props = &gpu().queue_properties()[0];
}
-void XglDevice::get_device_queue()
+void VkDeviceObj::get_device_queue()
{
ASSERT_NE(true, graphics_queues().empty());
m_queue = graphics_queues()[0]->obj();
}
-XglDescriptorSetObj::XglDescriptorSetObj(XglDevice *device)
+VkDescriptorSetObj::VkDescriptorSetObj(VkDeviceObj *device)
{
m_device = device;
m_nextSlot = 0;
}
-XglDescriptorSetObj::~XglDescriptorSetObj()
+VkDescriptorSetObj::~VkDescriptorSetObj()
{
delete m_set;
}
-int XglDescriptorSetObj::AppendDummy()
+int VkDescriptorSetObj::AppendDummy()
{
/* request a descriptor but do not update it */
VK_DESCRIPTOR_TYPE_COUNT tc = {};
@@ -291,7 +291,7 @@
return m_nextSlot++;
}
-int XglDescriptorSetObj::AppendBuffer(VK_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer)
+int VkDescriptorSetObj::AppendBuffer(VK_DESCRIPTOR_TYPE type, VkConstantBufferObj &constantBuffer)
{
VK_DESCRIPTOR_TYPE_COUNT tc = {};
tc.type = type;
@@ -307,7 +307,7 @@
return m_nextSlot++;
}
-int XglDescriptorSetObj::AppendSamplerTexture( XglSamplerObj* sampler, XglTextureObj* texture)
+int VkDescriptorSetObj::AppendSamplerTexture( VkSamplerObj* sampler, VkTextureObj* texture)
{
VK_DESCRIPTOR_TYPE_COUNT tc = {};
tc.type = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
@@ -328,17 +328,17 @@
return m_nextSlot++;
}
-VK_DESCRIPTOR_SET_LAYOUT_CHAIN XglDescriptorSetObj::GetLayoutChain() const
+VK_DESCRIPTOR_SET_LAYOUT_CHAIN VkDescriptorSetObj::GetLayoutChain() const
{
return m_layout_chain.obj();
}
-VK_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle() const
+VK_DESCRIPTOR_SET VkDescriptorSetObj::GetDescriptorSetHandle() const
{
return m_set->obj();
}
-void XglDescriptorSetObj::CreateVKDescriptorSet(XglCommandBufferObj *cmdBuffer)
+void VkDescriptorSetObj::CreateVKDescriptorSet(VkCommandBufferObj *cmdBuffer)
{
// create VK_DESCRIPTOR_POOL
VK_DESCRIPTOR_POOL_CREATE_INFO pool = {};
@@ -390,15 +390,15 @@
m_device->end_descriptor_pool_update(*cmdBuffer);
}
-XglImage::XglImage(XglDevice *dev)
+VkImageObj::VkImageObj(VkDeviceObj *dev)
{
m_device = dev;
m_imageInfo.view = VK_NULL_HANDLE;
m_imageInfo.layout = VK_IMAGE_LAYOUT_GENERAL;
}
-void XglImage::ImageMemoryBarrier(
- XglCommandBufferObj *cmd_buf,
+void VkImageObj::ImageMemoryBarrier(
+ VkCommandBufferObj *cmd_buf,
VK_IMAGE_ASPECT aspect,
VK_FLAGS output_mask /*=
VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
@@ -439,7 +439,7 @@
vkCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
}
-void XglImage::SetLayout(XglCommandBufferObj *cmd_buf,
+void VkImageObj::SetLayout(VkCommandBufferObj *cmd_buf,
VK_IMAGE_ASPECT aspect,
VK_IMAGE_LAYOUT image_layout)
{
@@ -494,11 +494,11 @@
m_imageInfo.layout = image_layout;
}
-void XglImage::SetLayout(VK_IMAGE_ASPECT aspect,
+void VkImageObj::SetLayout(VK_IMAGE_ASPECT aspect,
VK_IMAGE_LAYOUT image_layout)
{
VK_RESULT err;
- XglCommandBufferObj cmd_buf(m_device);
+ VkCommandBufferObj cmd_buf(m_device);
/* Build command buffer to set image layout in the driver */
err = cmd_buf.BeginCommandBuffer();
@@ -512,7 +512,7 @@
cmd_buf.QueueCommandBuffer();
}
-bool XglImage::IsCompatible(VK_FLAGS usage, VK_FLAGS features)
+bool VkImageObj::IsCompatible(VK_FLAGS usage, VK_FLAGS features)
{
if ((usage & VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) &&
!(features & VK_FORMAT_IMAGE_SHADER_READ_BIT))
@@ -525,7 +525,7 @@
return true;
}
-void XglImage::init(uint32_t w, uint32_t h,
+void VkImageObj::init(uint32_t w, uint32_t h,
VK_FORMAT fmt, VK_FLAGS usage,
VK_IMAGE_TILING requested_tiling)
{
@@ -587,22 +587,22 @@
}
}
-VK_RESULT XglImage::MapMemory(void** ptr)
+VK_RESULT VkImageObj::MapMemory(void** ptr)
{
*ptr = map();
return (*ptr) ? VK_SUCCESS : VK_ERROR_UNKNOWN;
}
-VK_RESULT XglImage::UnmapMemory()
+VK_RESULT VkImageObj::UnmapMemory()
{
unmap();
return VK_SUCCESS;
}
-VK_RESULT XglImage::CopyImage(XglImage &src_image)
+VK_RESULT VkImageObj::CopyImage(VkImageObj &src_image)
{
VK_RESULT err;
- XglCommandBufferObj cmd_buf(m_device);
+ VkCommandBufferObj cmd_buf(m_device);
VK_IMAGE_LAYOUT src_image_layout, dest_image_layout;
/* Build command buffer to copy staging texture to usable texture */
@@ -650,15 +650,15 @@
return VK_SUCCESS;
}
-XglTextureObj::XglTextureObj(XglDevice *device, uint32_t *colors)
- :XglImage(device)
+VkTextureObj::VkTextureObj(VkDeviceObj *device, uint32_t *colors)
+ :VkImageObj(device)
{
m_device = device;
const VK_FORMAT tex_format = VK_FMT_B8G8R8A8_UNORM;
uint32_t tex_colors[2] = { 0xffff0000, 0xff00ff00 };
void *data;
int32_t x, y;
- XglImage stagingImage(device);
+ VkImageObj stagingImage(device);
stagingImage.init(16, 16, tex_format, 0, VK_LINEAR_TILING);
VK_SUBRESOURCE_LAYOUT layout = stagingImage.subresource_layout(subresource(VK_IMAGE_ASPECT_COLOR, 0, 0));
@@ -703,10 +703,10 @@
row[x] = colors[(x & 1) ^ (y & 1)];
}
stagingImage.unmap();
- XglImage::CopyImage(stagingImage);
+ VkImageObj::CopyImage(stagingImage);
}
-XglSamplerObj::XglSamplerObj(XglDevice *device)
+VkSamplerObj::VkSamplerObj(VkDeviceObj *device)
{
m_device = device;
@@ -732,7 +732,7 @@
/*
* Basic ConstantBuffer constructor. Then use create methods to fill in the details.
*/
-XglConstantBufferObj::XglConstantBufferObj(XglDevice *device)
+VkConstantBufferObj::VkConstantBufferObj(VkDeviceObj *device)
{
m_device = device;
m_commandBuffer = 0;
@@ -740,7 +740,7 @@
memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
}
-XglConstantBufferObj::~XglConstantBufferObj()
+VkConstantBufferObj::~VkConstantBufferObj()
{
// TODO: Should we call QueueRemoveMemReference for the constant buffer memory here?
if (m_commandBuffer) {
@@ -748,7 +748,7 @@
}
}
-XglConstantBufferObj::XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data)
+VkConstantBufferObj::VkConstantBufferObj(VkDeviceObj *device, int constantCount, int constantSize, const void* data)
{
m_device = device;
m_commandBuffer = 0;
@@ -777,13 +777,13 @@
this->m_bufferViewInfo.view = m_bufferView.obj();
}
-void XglConstantBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset, uint32_t binding)
+void VkConstantBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset, uint32_t binding)
{
vkCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
}
-void XglConstantBufferObj::BufferMemoryBarrier(
+void VkConstantBufferObj::BufferMemoryBarrier(
VK_FLAGS outputMask /*=
VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
@@ -807,7 +807,7 @@
{
m_fence.init(*m_device, vk_testing::Fence::create_info());
- m_commandBuffer = new XglCommandBufferObj(m_device);
+ m_commandBuffer = new VkCommandBufferObj(m_device);
}
else
{
@@ -858,13 +858,13 @@
ASSERT_VK_SUCCESS(err);
}
-XglIndexBufferObj::XglIndexBufferObj(XglDevice *device)
- : XglConstantBufferObj(device)
+VkIndexBufferObj::VkIndexBufferObj(VkDeviceObj *device)
+ : VkConstantBufferObj(device)
{
}
-void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, VK_INDEX_TYPE indexType, const void* data)
+void VkIndexBufferObj::CreateAndInitBuffer(int numIndexes, VK_INDEX_TYPE indexType, const void* data)
{
VK_FORMAT viewFormat;
@@ -909,17 +909,17 @@
this->m_bufferViewInfo.view = m_bufferView.obj();
}
-void XglIndexBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset)
+void VkIndexBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset)
{
vkCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
}
-VK_INDEX_TYPE XglIndexBufferObj::GetIndexType()
+VK_INDEX_TYPE VkIndexBufferObj::GetIndexType()
{
return m_indexType;
}
-VK_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
+VK_PIPELINE_SHADER_STAGE_CREATE_INFO* VkShaderObj::GetStageCreateInfo()
{
VK_PIPELINE_SHADER_STAGE_CREATE_INFO *stageInfo = (VK_PIPELINE_SHADER_STAGE_CREATE_INFO*) calloc( 1,sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO) );
stageInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
@@ -931,7 +931,7 @@
return stageInfo;
}
-XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, VK_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
+VkShaderObj::VkShaderObj(VkDeviceObj *device, const char * shader_code, VK_PIPELINE_SHADER_STAGE stage, VkRenderFramework *framework)
{
VK_RESULT err = VK_SUCCESS;
std::vector<unsigned int> spv;
@@ -974,7 +974,7 @@
}
}
-XglPipelineObj::XglPipelineObj(XglDevice *device)
+VkPipelineObj::VkPipelineObj(VkDeviceObj *device)
{
m_device = device;
m_vi_state.attributeCount = m_vi_state.bindingCount = 0;
@@ -1034,31 +1034,31 @@
};
-void XglPipelineObj::AddShader(XglShaderObj* shader)
+void VkPipelineObj::AddShader(VkShaderObj* shader)
{
m_shaderObjs.push_back(shader);
}
-void XglPipelineObj::AddVertexInputAttribs(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
+void VkPipelineObj::AddVertexInputAttribs(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
{
m_vi_state.pVertexAttributeDescriptions = vi_attrib;
m_vi_state.attributeCount = count;
}
-void XglPipelineObj::AddVertexInputBindings(VK_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
+void VkPipelineObj::AddVertexInputBindings(VK_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
{
m_vi_state.pVertexBindingDescriptions = vi_binding;
m_vi_state.bindingCount = count;
}
-void XglPipelineObj::AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding)
+void VkPipelineObj::AddVertexDataBuffer(VkConstantBufferObj* vertexDataBuffer, int binding)
{
m_vertexBufferObjs.push_back(vertexDataBuffer);
m_vertexBufferBindings.push_back(binding);
m_vertexBufferCount++;
}
-void XglPipelineObj::AddColorAttachment(uint32_t binding, const VK_PIPELINE_CB_ATTACHMENT_STATE *att)
+void VkPipelineObj::AddColorAttachment(uint32_t binding, const VK_PIPELINE_CB_ATTACHMENT_STATE *att)
{
if (binding+1 > m_colorAttachments.size())
{
@@ -1067,7 +1067,7 @@
m_colorAttachments[binding] = *att;
}
-void XglPipelineObj::SetDepthStencil(VK_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
+void VkPipelineObj::SetDepthStencil(VK_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
{
m_ds_state.format = ds_state->format;
m_ds_state.depthTestEnable = ds_state->depthTestEnable;
@@ -1079,7 +1079,7 @@
m_ds_state.front = ds_state->front;
}
-void XglPipelineObj::CreateVKPipeline(XglDescriptorSetObj &descriptorSet)
+void VkPipelineObj::CreateVKPipeline(VkDescriptorSetObj &descriptorSet)
{
void* head_ptr = &m_ds_state;
VK_GRAPHICS_PIPELINE_CREATE_INFO info = {};
@@ -1111,7 +1111,7 @@
init(*m_device, info);
}
-vector<VK_GPU_MEMORY> XglMemoryRefManager::mem_refs() const
+vector<VK_GPU_MEMORY> VkMemoryRefManager::mem_refs() const
{
std::vector<VK_GPU_MEMORY> mems;
if (this->mem_refs_.size()) {
@@ -1123,13 +1123,13 @@
return mems;
}
-void XglMemoryRefManager::AddMemoryRefs(vk_testing::Object &vkObject)
+void VkMemoryRefManager::AddMemoryRefs(vk_testing::Object &vkObject)
{
const std::vector<VK_GPU_MEMORY> mems = vkObject.memories();
AddMemoryRefs(mems);
}
-void XglMemoryRefManager::AddMemoryRefs(vector<VK_GPU_MEMORY> mem)
+void VkMemoryRefManager::AddMemoryRefs(vector<VK_GPU_MEMORY> mem)
{
for (size_t i = 0; i < mem.size(); i++) {
if (mem[i] != NULL) {
@@ -1138,62 +1138,62 @@
}
}
-void XglMemoryRefManager::EmitAddMemoryRefs(VK_QUEUE queue)
+void VkMemoryRefManager::EmitAddMemoryRefs(VK_QUEUE queue)
{
for (uint32_t i = 0; i < mem_refs_.size(); i++) {
vkQueueAddMemReference(queue, mem_refs_[i]);
}
}
-void XglMemoryRefManager::EmitRemoveMemoryRefs(VK_QUEUE queue)
+void VkMemoryRefManager::EmitRemoveMemoryRefs(VK_QUEUE queue)
{
for (uint32_t i = 0; i < mem_refs_.size(); i++) {
vkQueueRemoveMemReference(queue, mem_refs_[i]);
}
}
-XglCommandBufferObj::XglCommandBufferObj(XglDevice *device)
+VkCommandBufferObj::VkCommandBufferObj(VkDeviceObj *device)
: vk_testing::CmdBuffer(*device, vk_testing::CmdBuffer::create_info(device->graphics_queue_node_index_))
{
m_device = device;
}
-VK_CMD_BUFFER XglCommandBufferObj::GetBufferHandle()
+VK_CMD_BUFFER VkCommandBufferObj::GetBufferHandle()
{
return obj();
}
-VK_RESULT XglCommandBufferObj::BeginCommandBuffer(VK_CMD_BUFFER_BEGIN_INFO *pInfo)
+VK_RESULT VkCommandBufferObj::BeginCommandBuffer(VK_CMD_BUFFER_BEGIN_INFO *pInfo)
{
begin(pInfo);
return VK_SUCCESS;
}
-VK_RESULT XglCommandBufferObj::BeginCommandBuffer(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj)
+VK_RESULT VkCommandBufferObj::BeginCommandBuffer(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj)
{
begin(renderpass_obj, framebuffer_obj);
return VK_SUCCESS;
}
-VK_RESULT XglCommandBufferObj::BeginCommandBuffer()
+VK_RESULT VkCommandBufferObj::BeginCommandBuffer()
{
begin();
return VK_SUCCESS;
}
-VK_RESULT XglCommandBufferObj::EndCommandBuffer()
+VK_RESULT VkCommandBufferObj::EndCommandBuffer()
{
end();
return VK_SUCCESS;
}
-void XglCommandBufferObj::PipelineBarrier(VK_PIPELINE_BARRIER *barrierPtr)
+void VkCommandBufferObj::PipelineBarrier(VK_PIPELINE_BARRIER *barrierPtr)
{
vkCmdPipelineBarrier(obj(), barrierPtr);
}
-void XglCommandBufferObj::ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
- XglDepthStencilObj *depthStencilObj)
+void VkCommandBufferObj::ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
+ VkDepthStencilObj *depthStencilObj)
{
uint32_t i;
const VK_FLAGS output_mask =
@@ -1275,7 +1275,7 @@
}
}
-void XglCommandBufferObj::PrepareAttachments()
+void VkCommandBufferObj::PrepareAttachments()
{
uint32_t i;
const VK_FLAGS output_mask =
@@ -1328,7 +1328,7 @@
}
}
-void XglCommandBufferObj::BeginRenderPass(VK_RENDER_PASS renderpass, VK_FRAMEBUFFER framebuffer)
+void VkCommandBufferObj::BeginRenderPass(VK_RENDER_PASS renderpass, VK_FRAMEBUFFER framebuffer)
{
VK_RENDER_PASS_BEGIN rp_begin = {
renderpass,
@@ -1338,37 +1338,37 @@
vkCmdBeginRenderPass( obj(), &rp_begin);
}
-void XglCommandBufferObj::EndRenderPass(VK_RENDER_PASS renderpass)
+void VkCommandBufferObj::EndRenderPass(VK_RENDER_PASS renderpass)
{
vkCmdEndRenderPass( obj(), renderpass);
}
-void XglCommandBufferObj::BindStateObject(VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT stateObject)
+void VkCommandBufferObj::BindStateObject(VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT stateObject)
{
vkCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
}
-void XglCommandBufferObj::AddRenderTarget(XglImage *renderTarget)
+void VkCommandBufferObj::AddRenderTarget(VkImageObj *renderTarget)
{
m_renderTargets.push_back(renderTarget);
}
-void XglCommandBufferObj::DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+void VkCommandBufferObj::DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
{
vkCmdDrawIndexed(obj(), firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
-void XglCommandBufferObj::Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+void VkCommandBufferObj::Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
{
vkCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
}
-void XglCommandBufferObj::QueueCommandBuffer()
+void VkCommandBufferObj::QueueCommandBuffer()
{
QueueCommandBuffer(NULL);
}
-void XglCommandBufferObj::QueueCommandBuffer(VK_FENCE fence)
+void VkCommandBufferObj::QueueCommandBuffer(VK_FENCE fence)
{
VK_RESULT err = VK_SUCCESS;
@@ -1391,13 +1391,13 @@
mem_ref_mgr.EmitRemoveMemoryRefs(m_device->m_queue);
}
-void XglCommandBufferObj::BindPipeline(XglPipelineObj &pipeline)
+void VkCommandBufferObj::BindPipeline(VkPipelineObj &pipeline)
{
vkCmdBindPipeline( obj(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.obj() );
mem_ref_mgr.AddMemoryRefs(pipeline);
}
-void XglCommandBufferObj::BindDescriptorSet(XglDescriptorSetObj &descriptorSet)
+void VkCommandBufferObj::BindDescriptorSet(VkDescriptorSetObj &descriptorSet)
{
VK_DESCRIPTOR_SET set_obj = descriptorSet.GetDescriptorSetHandle();
@@ -1410,33 +1410,33 @@
mem_ref_mgr.AddMemoryRefs(descriptorSet.mem_ref_mgr.mem_refs());
}
-void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset)
+void VkCommandBufferObj::BindIndexBuffer(VkIndexBufferObj *indexBuffer, uint32_t offset)
{
vkCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
mem_ref_mgr.AddMemoryRefs(*indexBuffer);
}
-void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
+void VkCommandBufferObj::BindVertexBuffer(VkConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
{
vkCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
mem_ref_mgr.AddMemoryRefs(*vertexBuffer);
}
-XglDepthStencilObj::XglDepthStencilObj()
+VkDepthStencilObj::VkDepthStencilObj()
{
m_initialized = false;
}
-bool XglDepthStencilObj::Initialized()
+bool VkDepthStencilObj::Initialized()
{
return m_initialized;
}
-VK_DEPTH_STENCIL_BIND_INFO* XglDepthStencilObj::BindInfo()
+VK_DEPTH_STENCIL_BIND_INFO* VkDepthStencilObj::BindInfo()
{
return &m_depthStencilBindInfo;
}
-void XglDepthStencilObj::Init(XglDevice *device, int32_t width, int32_t height)
+void VkDepthStencilObj::Init(VkDeviceObj *device, int32_t width, int32_t height)
{
VK_IMAGE_CREATE_INFO image_info;
VK_DEPTH_STENCIL_VIEW_CREATE_INFO view_info;
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 4c7ba01..d23e4b4 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -31,10 +31,10 @@
#include "vktestframework.h"
-class XglDevice : public vk_testing::Device
+class VkDeviceObj : public vk_testing::Device
{
public:
- XglDevice(uint32_t id, VK_PHYSICAL_GPU obj);
+ VkDeviceObj(uint32_t id, VK_PHYSICAL_GPU obj);
VK_DEVICE device() { return obj(); }
void get_device_queue();
@@ -46,7 +46,7 @@
VK_QUEUE m_queue;
};
-class XglMemoryRefManager
+class VkMemoryRefManager
{
public:
void AddMemoryRefs(vk_testing::Object &vkObject);
@@ -60,27 +60,27 @@
};
-class XglDepthStencilObj : public vk_testing::Image
+class VkDepthStencilObj : public vk_testing::Image
{
public:
- XglDepthStencilObj();
- void Init(XglDevice *device, int32_t width, int32_t height);
+ VkDepthStencilObj();
+ void Init(VkDeviceObj *device, int32_t width, int32_t height);
bool Initialized();
VK_DEPTH_STENCIL_BIND_INFO* BindInfo();
protected:
- XglDevice *m_device;
+ VkDeviceObj *m_device;
bool m_initialized;
vk_testing::DepthStencilView m_depthStencilView;
VK_FORMAT m_depth_stencil_fmt;
VK_DEPTH_STENCIL_BIND_INFO m_depthStencilBindInfo;
};
-class XglRenderFramework : public XglTestFramework
+class VkRenderFramework : public VkTestFramework
{
public:
- XglRenderFramework();
- ~XglRenderFramework();
+ VkRenderFramework();
+ ~VkRenderFramework();
VK_DEVICE device() {return m_device->device();}
VK_PHYSICAL_GPU gpu() {return objs[0];}
@@ -102,7 +102,7 @@
VK_INSTANCE inst;
VK_PHYSICAL_GPU objs[VK_MAX_PHYSICAL_GPUS];
uint32_t gpu_count;
- XglDevice *m_device;
+ VkDeviceObj *m_device;
VK_CMD_BUFFER m_cmdBuffer;
VK_RENDER_PASS m_renderPass;
VK_FRAMEBUFFER m_framebuffer;
@@ -110,7 +110,7 @@
VK_DYNAMIC_CB_STATE_OBJECT m_colorBlend;
VK_DYNAMIC_VP_STATE_OBJECT m_stateViewport;
VK_DYNAMIC_DS_STATE_OBJECT m_stateDepthStencil;
- vector<XglImage*> m_renderTargets;
+ vector<VkImageObj*> m_renderTargets;
float m_width, m_height;
VK_FORMAT m_render_target_fmt;
VK_FORMAT m_depth_stencil_fmt;
@@ -118,8 +118,8 @@
VK_CLEAR_COLOR m_clear_color;
float m_depth_clear_color;
uint32_t m_stencil_clear_color;
- XglDepthStencilObj *m_depthStencil;
- XglMemoryRefManager m_mem_ref_mgr;
+ VkDepthStencilObj *m_depthStencil;
+ VkMemoryRefManager m_mem_ref_mgr;
/*
* SetUp and TearDown are called by the Google Test framework
@@ -142,33 +142,33 @@
}
};
-class XglDescriptorSetObj;
-class XglIndexBufferObj;
-class XglConstantBufferObj;
-class XglPipelineObj;
-class XglDescriptorSetObj;
+class VkDescriptorSetObj;
+class VkIndexBufferObj;
+class VkConstantBufferObj;
+class VkPipelineObj;
+class VkDescriptorSetObj;
-class XglCommandBufferObj : public vk_testing::CmdBuffer
+class VkCommandBufferObj : public vk_testing::CmdBuffer
{
public:
- XglCommandBufferObj(XglDevice *device);
+ VkCommandBufferObj(VkDeviceObj *device);
VK_CMD_BUFFER GetBufferHandle();
VK_RESULT BeginCommandBuffer();
VK_RESULT BeginCommandBuffer(VK_CMD_BUFFER_BEGIN_INFO *pInfo);
VK_RESULT BeginCommandBuffer(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj);
VK_RESULT EndCommandBuffer();
void PipelineBarrier(VK_PIPELINE_BARRIER *barrierPtr);
- void AddRenderTarget(XglImage *renderTarget);
+ void AddRenderTarget(VkImageObj *renderTarget);
void AddDepthStencil();
- void ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XglDepthStencilObj *depthStencilObj);
+ void ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, VkDepthStencilObj *depthStencilObj);
void PrepareAttachments();
void AddMemoryRefs(vk_testing::Object &vkObject);
void AddMemoryRefs(uint32_t ref_count, const VK_GPU_MEMORY *mem);
void AddMemoryRefs(vector<vk_testing::Object *> images);
- void BindPipeline(XglPipelineObj &pipeline);
- void BindDescriptorSet(XglDescriptorSetObj &descriptorSet);
- void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
- void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset);
+ void BindPipeline(VkPipelineObj &pipeline);
+ void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
+ void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
+ void BindIndexBuffer(VkIndexBufferObj *indexBuffer, uint32_t offset);
void BindStateObject(VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT stateObject);
void BeginRenderPass(VK_RENDER_PASS renderpass, VK_FRAMEBUFFER framebuffer);
void EndRenderPass(VK_RENDER_PASS renderpass);
@@ -177,19 +177,19 @@
void QueueCommandBuffer();
void QueueCommandBuffer(VK_FENCE fence);
- XglMemoryRefManager mem_ref_mgr;
+ VkMemoryRefManager mem_ref_mgr;
protected:
- XglDevice *m_device;
- vector<XglImage*> m_renderTargets;
+ VkDeviceObj *m_device;
+ vector<VkImageObj*> m_renderTargets;
};
-class XglConstantBufferObj : public vk_testing::Buffer
+class VkConstantBufferObj : public vk_testing::Buffer
{
public:
- XglConstantBufferObj(XglDevice *device);
- XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
- ~XglConstantBufferObj();
+ VkConstantBufferObj(VkDeviceObj *device);
+ VkConstantBufferObj(VkDeviceObj *device, int constantCount, int constantSize, const void* data);
+ ~VkConstantBufferObj();
void BufferMemoryBarrier(
VK_FLAGS outputMask =
VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
@@ -213,18 +213,18 @@
VK_BUFFER_VIEW_ATTACH_INFO m_bufferViewInfo;
protected:
- XglDevice *m_device;
+ VkDeviceObj *m_device;
vk_testing::BufferView m_bufferView;
int m_numVertices;
int m_stride;
- XglCommandBufferObj *m_commandBuffer;
+ VkCommandBufferObj *m_commandBuffer;
vk_testing::Fence m_fence;
};
-class XglIndexBufferObj : public XglConstantBufferObj
+class VkIndexBufferObj : public VkConstantBufferObj
{
public:
- XglIndexBufferObj(XglDevice *device);
+ VkIndexBufferObj(VkDeviceObj *device);
void CreateAndInitBuffer(int numIndexes, VK_INDEX_TYPE dataFormat, const void* data);
void Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset);
VK_INDEX_TYPE GetIndexType();
@@ -233,10 +233,10 @@
VK_INDEX_TYPE m_indexType;
};
-class XglImage : public vk_testing::Image
+class VkImageObj : public vk_testing::Image
{
public:
- XglImage(XglDevice *dev);
+ VkImageObj(VkDeviceObj *dev);
bool IsCompatible(VK_FLAGS usage, VK_FLAGS features);
public:
@@ -257,13 +257,13 @@
return mems.empty() ? VK_NULL_HANDLE : mems[0];
}
- void ImageMemoryBarrier(XglCommandBufferObj *cmd,
+ void ImageMemoryBarrier(VkCommandBufferObj *cmd,
VK_IMAGE_ASPECT aspect,
VK_FLAGS output_mask,
VK_FLAGS input_mask,
VK_IMAGE_LAYOUT image_layout);
- VK_RESULT CopyImage(XglImage &src_image);
+ VK_RESULT CopyImage(VkImageObj &src_image);
VK_IMAGE image() const
{
@@ -288,7 +288,7 @@
return m_targetView.obj();
}
- void SetLayout(XglCommandBufferObj *cmd_buf, VK_IMAGE_ASPECT aspect, VK_IMAGE_LAYOUT image_layout);
+ void SetLayout(VkCommandBufferObj *cmd_buf, VK_IMAGE_ASPECT aspect, VK_IMAGE_LAYOUT image_layout);
void SetLayout(VK_IMAGE_ASPECT aspect, VK_IMAGE_LAYOUT image_layout);
VK_IMAGE_LAYOUT layout() const
@@ -303,7 +303,7 @@
{
return extent().height;
}
- XglDevice* device() const
+ VkDeviceObj* device() const
{
return m_device;
}
@@ -312,53 +312,53 @@
VK_RESULT UnmapMemory();
protected:
- XglDevice *m_device;
+ VkDeviceObj *m_device;
vk_testing::ColorAttachmentView m_targetView;
VK_IMAGE_VIEW_ATTACH_INFO m_imageInfo;
};
-class XglTextureObj : public XglImage
+class VkTextureObj : public VkImageObj
{
public:
- XglTextureObj(XglDevice *device, uint32_t *colors = NULL);
+ VkTextureObj(VkDeviceObj *device, uint32_t *colors = NULL);
VK_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
protected:
- XglDevice *m_device;
+ VkDeviceObj *m_device;
vk_testing::ImageView m_textureView;
VK_GPU_SIZE m_rowPitch;
};
-class XglSamplerObj : public vk_testing::Sampler
+class VkSamplerObj : public vk_testing::Sampler
{
public:
- XglSamplerObj(XglDevice *device);
+ VkSamplerObj(VkDeviceObj *device);
protected:
- XglDevice *m_device;
+ VkDeviceObj *m_device;
};
-class XglDescriptorSetObj : public vk_testing::DescriptorPool
+class VkDescriptorSetObj : public vk_testing::DescriptorPool
{
public:
- XglDescriptorSetObj(XglDevice *device);
- ~XglDescriptorSetObj();
+ VkDescriptorSetObj(VkDeviceObj *device);
+ ~VkDescriptorSetObj();
int AppendDummy();
- int AppendBuffer(VK_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer);
- int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture);
- void CreateVKDescriptorSet(XglCommandBufferObj *cmdBuffer);
+ int AppendBuffer(VK_DESCRIPTOR_TYPE type, VkConstantBufferObj &constantBuffer);
+ int AppendSamplerTexture(VkSamplerObj* sampler, VkTextureObj* texture);
+ void CreateVKDescriptorSet(VkCommandBufferObj *cmdBuffer);
VK_DESCRIPTOR_SET GetDescriptorSetHandle() const;
VK_DESCRIPTOR_SET_LAYOUT_CHAIN GetLayoutChain() const;
- XglMemoryRefManager mem_ref_mgr;
+ VkMemoryRefManager mem_ref_mgr;
protected:
- XglDevice *m_device;
+ VkDeviceObj *m_device;
vector<VK_DESCRIPTOR_TYPE_COUNT> m_type_counts;
int m_nextSlot;
@@ -373,30 +373,30 @@
};
-class XglShaderObj : public vk_testing::Shader
+class VkShaderObj : public vk_testing::Shader
{
public:
- XglShaderObj(XglDevice *device, const char * shaderText, VK_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework);
+ VkShaderObj(VkDeviceObj *device, const char * shaderText, VK_PIPELINE_SHADER_STAGE stage, VkRenderFramework *framework);
VK_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo();
protected:
VK_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
VK_PIPELINE_SHADER_STAGE m_stage;
- XglDevice *m_device;
+ VkDeviceObj *m_device;
};
-class XglPipelineObj : public vk_testing::Pipeline
+class VkPipelineObj : public vk_testing::Pipeline
{
public:
- XglPipelineObj(XglDevice *device);
- void AddShader(XglShaderObj* shaderObj);
+ VkPipelineObj(VkDeviceObj *device);
+ void AddShader(VkShaderObj* shaderObj);
void AddVertexInputAttribs(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
void AddVertexInputBindings(VK_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
- void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
+ void AddVertexDataBuffer(VkConstantBufferObj* vertexDataBuffer, int binding);
void AddColorAttachment(uint32_t binding, const VK_PIPELINE_CB_ATTACHMENT_STATE *att);
void SetDepthStencil(VK_PIPELINE_DS_STATE_CREATE_INFO *);
- void CreateVKPipeline(XglDescriptorSetObj &descriptorSet);
+ void CreateVKPipeline(VkDescriptorSetObj &descriptorSet);
protected:
VK_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
@@ -405,9 +405,9 @@
VK_PIPELINE_CB_STATE_CREATE_INFO m_cb_state;
VK_PIPELINE_DS_STATE_CREATE_INFO m_ds_state;
VK_PIPELINE_MS_STATE_CREATE_INFO m_ms_state;
- XglDevice *m_device;
- vector<XglShaderObj*> m_shaderObjs;
- vector<XglConstantBufferObj*> m_vertexBufferObjs;
+ VkDeviceObj *m_device;
+ vector<VkShaderObj*> m_shaderObjs;
+ vector<VkConstantBufferObj*> m_vertexBufferObjs;
vector<int> m_vertexBufferBindings;
vector<VK_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments;
int m_vertexBufferCount;
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 9f13c8a..6e8f92e 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -91,34 +91,34 @@
glslang::FinalizeProcess();
}
-XglTestFramework::XglTestFramework() :
+VkTestFramework::VkTestFramework() :
m_compile_options( 0 ),
m_num_shader_strings( 0 )
{
}
-XglTestFramework::~XglTestFramework()
+VkTestFramework::~VkTestFramework()
{
}
// Define all the static elements
-bool XglTestFramework::m_show_images = false;
-bool XglTestFramework::m_save_images = false;
-bool XglTestFramework::m_compare_images = false;
+bool VkTestFramework::m_show_images = false;
+bool VkTestFramework::m_save_images = false;
+bool VkTestFramework::m_compare_images = false;
#ifdef _WIN32
-bool XglTestFramework::m_use_spv = false;
+bool VkTestFramework::m_use_spv = false;
#else
-bool XglTestFramework::m_use_spv = true;
+bool VkTestFramework::m_use_spv = true;
#endif
-int XglTestFramework::m_width = 0;
-int XglTestFramework::m_height = 0;
-std::list<XglTestImageRecord> XglTestFramework::m_images;
-std::list<XglTestImageRecord>::iterator XglTestFramework::m_display_image;
+int VkTestFramework::m_width = 0;
+int VkTestFramework::m_height = 0;
+std::list<VkTestImageRecord> VkTestFramework::m_images;
+std::list<VkTestImageRecord>::iterator VkTestFramework::m_display_image;
int m_display_image_idx = 0;
-void XglTestFramework::InitArgs(int *argc, char *argv[])
+void VkTestFramework::InitArgs(int *argc, char *argv[])
{
int i, n;
@@ -177,12 +177,12 @@
}
}
-void XglTestFramework::WritePPM( const char *basename, XglImage *image )
+void VkTestFramework::WritePPM( const char *basename, VkImageObj *image )
{
string filename;
VK_RESULT err;
int x, y;
- XglImage displayImage(image->device());
+ VkImageObj displayImage(image->device());
displayImage.init(image->extent().width, image->extent().height, image->format(), 0, VK_LINEAR_TILING);
displayImage.CopyImage(*image);
@@ -245,7 +245,7 @@
displayImage.unmap();
}
-void XglTestFramework::Compare(const char *basename, XglImage *image )
+void VkTestFramework::Compare(const char *basename, VkImageObj *image )
{
MagickWand *magick_wand_1;
@@ -298,7 +298,7 @@
}
}
-void XglTestFramework::Show(const char *comment, XglImage *image)
+void VkTestFramework::Show(const char *comment, VkImageObj *image)
{
VK_RESULT err;
@@ -307,7 +307,7 @@
};
VK_SUBRESOURCE_LAYOUT sr_layout;
size_t data_size = sizeof(sr_layout);
- XglTestImageRecord record;
+ VkTestImageRecord record;
if (!m_show_images) return;
@@ -338,14 +338,14 @@
}
-void XglTestFramework::RecordImages(vector<XglImage *> images)
+void VkTestFramework::RecordImages(vector<VkImageObj *> images)
{
for (int32_t i = 0; i < images.size(); i++) {
RecordImage(images[i]);
}
}
-void XglTestFramework::RecordImage(XglImage * image)
+void VkTestFramework::RecordImage(VkImageObj * image)
{
const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();
@@ -382,7 +382,7 @@
static vk_testing::Environment *environment;
-TestFrameworkXglPresent::TestFrameworkXglPresent() :
+TestFrameworkVkPresent::TestFrameworkVkPresent() :
m_device(environment->default_device()),
m_queue(*m_device.graphics_queues()[0]),
m_cmdbuf(m_device, vk_testing::CmdBuffer::create_info(m_device.graphics_queue_node_index_))
@@ -393,7 +393,7 @@
m_height = 0;
}
-void TestFrameworkXglPresent::Display()
+void TestFrameworkVkPresent::Display()
{
VK_RESULT err;
@@ -417,7 +417,7 @@
}
-void TestFrameworkXglPresent::HandleEvent(xcb_generic_event_t *event)
+void TestFrameworkVkPresent::HandleEvent(xcb_generic_event_t *event)
{
uint8_t event_code = event->response_type & 0x7f;
switch (event_code) {
@@ -464,7 +464,7 @@
}
}
-void TestFrameworkXglPresent::Run()
+void TestFrameworkVkPresent::Run()
{
xcb_flush(environment->m_connection);
@@ -483,7 +483,7 @@
}
}
-void TestFrameworkXglPresent::CreatePresentableImages()
+void TestFrameworkVkPresent::CreatePresentableImages()
{
VK_RESULT err;
@@ -549,12 +549,12 @@
m_display_image = m_images.begin();
}
-void TestFrameworkXglPresent::InitPresentFramework(std::list<XglTestImageRecord> &imagesIn)
+void TestFrameworkVkPresent::InitPresentFramework(std::list<VkTestImageRecord> &imagesIn)
{
m_images = imagesIn;
}
-void TestFrameworkXglPresent::CreateMyWindow()
+void TestFrameworkVkPresent::CreateMyWindow()
{
uint32_t value_mask, value_list[32];
@@ -590,16 +590,16 @@
xcb_map_window(environment->m_connection, m_window);
}
-void TestFrameworkXglPresent::TearDown()
+void TestFrameworkVkPresent::TearDown()
{
- std::list<XglTestImageRecord>::const_iterator iterator;
+ std::list<VkTestImageRecord>::const_iterator iterator;
for (iterator = m_images.begin(); iterator != m_images.end(); ++iterator) {
vkDestroyObject(iterator->m_presentableImage);
}
xcb_destroy_window(environment->m_connection, m_window);
}
-void XglTestFramework::Finish()
+void VkTestFramework::Finish()
{
if (m_images.size() == 0) return;
@@ -608,7 +608,7 @@
environment->X11SetUp();
{
- TestFrameworkXglPresent vkPresent;
+ TestFrameworkVkPresent vkPresent;
vkPresent.InitPresentFramework(m_images);
vkPresent.CreatePresentableImages();
@@ -723,7 +723,7 @@
//
// *.conf => this is a config file that can set limits/resources
//
-bool XglTestFramework::SetConfigFile(const std::string& name)
+bool VkTestFramework::SetConfigFile(const std::string& name)
{
if (name.size() < 5)
return false;
@@ -739,7 +739,7 @@
//
// Parse either a .conf file provided by the user or the default string above.
//
-void XglTestFramework::ProcessConfigFile()
+void VkTestFramework::ProcessConfigFile()
{
char** configStrings = 0;
char* config = 0;
@@ -961,7 +961,7 @@
FreeFileData(configStrings);
}
-void XglTestFramework::SetMessageOptions(EShMessages& messages)
+void VkTestFramework::SetMessageOptions(EShMessages& messages)
{
if (m_compile_options & EOptionRelaxedErrors)
messages = (EShMessages)(messages | EShMsgRelaxedErrors);
@@ -974,7 +974,7 @@
//
// Malloc a string of sufficient size and read a string into it.
//
-char** XglTestFramework::ReadFileData(const char* fileName)
+char** VkTestFramework::ReadFileData(const char* fileName)
{
FILE *in;
#if defined(_WIN32) && defined(__GNUC__)
@@ -1037,7 +1037,7 @@
return return_data;
}
-void XglTestFramework::FreeFileData(char** data)
+void VkTestFramework::FreeFileData(char** data)
{
for(int i=0;i<m_num_shader_strings;i++)
free(data[i]);
@@ -1054,7 +1054,7 @@
// .frag = fragment
// .comp = compute
//
-EShLanguage XglTestFramework::FindLanguage(const std::string& name)
+EShLanguage VkTestFramework::FindLanguage(const std::string& name)
{
size_t ext = name.rfind('.');
if (ext == std::string::npos) {
@@ -1081,7 +1081,7 @@
//
// Convert VK shader type to compiler's
//
-EShLanguage XglTestFramework::FindLanguage(const VK_PIPELINE_SHADER_STAGE shader_type)
+EShLanguage VkTestFramework::FindLanguage(const VK_PIPELINE_SHADER_STAGE shader_type)
{
switch (shader_type) {
case VK_SHADER_STAGE_VERTEX:
@@ -1112,7 +1112,7 @@
// Compile a given string containing GLSL into SPV for use by VK
// Return value of false means an error was encountered.
//
-bool XglTestFramework::GLSLtoSPV(const VK_PIPELINE_SHADER_STAGE shader_type,
+bool VkTestFramework::GLSLtoSPV(const VK_PIPELINE_SHADER_STAGE shader_type,
const char *pshader,
std::vector<unsigned int> &spv)
{
@@ -1173,7 +1173,7 @@
-XglTestImageRecord::XglTestImageRecord() : // Constructor
+VkTestImageRecord::VkTestImageRecord() : // Constructor
m_width( 0 ),
m_height( 0 ),
m_data( NULL ),
@@ -1183,12 +1183,12 @@
{
}
-XglTestImageRecord::~XglTestImageRecord()
+VkTestImageRecord::~VkTestImageRecord()
{
}
-XglTestImageRecord::XglTestImageRecord(const XglTestImageRecord ©in) // Copy constructor to handle pass by value.
+VkTestImageRecord::VkTestImageRecord(const VkTestImageRecord ©in) // Copy constructor to handle pass by value.
{
m_title = copyin.m_title;
m_width = copyin.m_width;
@@ -1199,14 +1199,14 @@
m_presentableMemory = copyin.m_presentableMemory;
}
-ostream &operator<<(ostream &output, const XglTestImageRecord &XglTestImageRecord)
+ostream &operator<<(ostream &output, const VkTestImageRecord &VkTestImageRecord)
{
- output << XglTestImageRecord.m_title << " (" << XglTestImageRecord.m_width <<
- "," << XglTestImageRecord.m_height << ")" << endl;
+ output << VkTestImageRecord.m_title << " (" << VkTestImageRecord.m_width <<
+ "," << VkTestImageRecord.m_height << ")" << endl;
return output;
}
-XglTestImageRecord& XglTestImageRecord::operator=(const XglTestImageRecord &rhs)
+VkTestImageRecord& VkTestImageRecord::operator=(const VkTestImageRecord &rhs)
{
m_title = rhs.m_title;
m_width = rhs.m_width;
@@ -1218,14 +1218,14 @@
return *this;
}
-int XglTestImageRecord::operator==(const XglTestImageRecord &rhs) const
+int VkTestImageRecord::operator==(const VkTestImageRecord &rhs) const
{
if( this->m_data != rhs.m_data) return 0;
return 1;
}
// This function is required for built-in STL list functions like sort
-int XglTestImageRecord::operator<(const XglTestImageRecord &rhs) const
+int VkTestImageRecord::operator<(const VkTestImageRecord &rhs) const
{
if( this->m_data_size < rhs.m_data_size ) return 1;
return 0;
diff --git a/tests/vktestframework.h b/tests/vktestframework.h
index 9648009..4944abb 100644
--- a/tests/vktestframework.h
+++ b/tests/vktestframework.h
@@ -45,18 +45,18 @@
using namespace std;
-class XglImage;
+class VkImageObj;
-class XglTestImageRecord
+class VkTestImageRecord
{
public:
- XglTestImageRecord();
- XglTestImageRecord(const XglTestImageRecord &);
- ~XglTestImageRecord();
- XglTestImageRecord &operator=(const XglTestImageRecord &rhs);
- int operator==(const XglTestImageRecord &rhs) const;
- int operator<(const XglTestImageRecord &rhs) const;
+ VkTestImageRecord();
+ VkTestImageRecord(const VkTestImageRecord &);
+ ~VkTestImageRecord();
+ VkTestImageRecord &operator=(const VkTestImageRecord &rhs);
+ int operator==(const VkTestImageRecord &rhs) const;
+ int operator<(const VkTestImageRecord &rhs) const;
string m_title;
int m_width;
@@ -67,20 +67,20 @@
unsigned m_data_size;
};
-class XglTestFramework : public ::testing::Test
+class VkTestFramework : public ::testing::Test
{
public:
- XglTestFramework();
- ~XglTestFramework();
+ VkTestFramework();
+ ~VkTestFramework();
static void InitArgs(int *argc, char *argv[]);
static void Finish();
- void WritePPM( const char *basename, XglImage *image );
- void Show(const char *comment, XglImage *image);
- void Compare(const char *comment, XglImage *image);
- void RecordImage(XglImage * image);
- void RecordImages(vector<XglImage *> image);
+ void WritePPM( const char *basename, VkImageObj *image );
+ void Show(const char *comment, VkImageObj *image);
+ void Compare(const char *comment, VkImageObj *image);
+ void RecordImage(VkImageObj * image);
+ void RecordImages(vector<VkImageObj *> image);
bool GLSLtoSPV(const VK_PIPELINE_SHADER_STAGE shader_type,
const char *pshader,
std::vector<unsigned int> &spv);
@@ -104,8 +104,8 @@
static bool m_save_images;
static bool m_compare_images;
- static std::list<XglTestImageRecord> m_images;
- static std::list<XglTestImageRecord>::iterator m_display_image;
+ static std::list<VkTestImageRecord> m_images;
+ static std::list<VkTestImageRecord>::iterator m_display_image;
static int m_display_image_idx;
static int m_width; // Window width
@@ -117,13 +117,13 @@
};
-class TestFrameworkXglPresent
+class TestFrameworkVkPresent
{
public:
- TestFrameworkXglPresent();
+ TestFrameworkVkPresent();
void Run();
- void InitPresentFramework(std::list<XglTestImageRecord> &imagesIn);
+ void InitPresentFramework(std::list<VkTestImageRecord> &imagesIn);
void CreateMyWindow();
void CreatePresentableImages();
void TearDown();
@@ -136,7 +136,7 @@
private:
xcb_window_t m_window;
xcb_intern_atom_reply_t *m_atom_wm_delete_window;
- std::list<XglTestImageRecord> m_images;
+ std::list<VkTestImageRecord> m_images;
bool m_quit;
bool m_pause;
@@ -144,7 +144,7 @@
uint32_t m_width;
uint32_t m_height;
- std::list<XglTestImageRecord>::iterator m_display_image;
+ std::list<VkTestImageRecord>::iterator m_display_image;
void Display();
void HandleEvent(xcb_generic_event_t *event);