Stage 1 of rename
TODO: re-enable glave build, advance API for glave
v2: get rid of outdated code in tri introduced by rebase
rename wsi_null.c (olv)
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index c4cc58e..a843a4a 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -28,7 +28,7 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// XGL tests
+// VK tests
//
// Copyright (C) 2014 LunarG, Inc.
//
@@ -51,16 +51,16 @@
// DEALINGS IN THE SOFTWARE.
-// Verify XGL driver initialization
+// Verify VK driver initialization
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
-#include <xgl.h>
+#include <vulkan.h>
#include "gtest-1.7.0/include/gtest/gtest.h"
-#include "xgltestbinding.h"
+#include "vktestbinding.h"
#include "test_common.h"
class XglImageTest : public ::testing::Test {
@@ -68,62 +68,62 @@
void CreateImage(uint32_t w, uint32_t h);
void DestroyImage();
- void CreateImageView(XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
- XGL_IMAGE_VIEW* pView);
- void DestroyImageView(XGL_IMAGE_VIEW imageView);
- XGL_DEVICE device() {return m_device->obj();}
+ void CreateImageView(VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ VK_IMAGE_VIEW* pView);
+ void DestroyImageView(VK_IMAGE_VIEW imageView);
+ VK_DEVICE device() {return m_device->obj();}
protected:
- xgl_testing::Device *m_device;
- XGL_APPLICATION_INFO app_info;
- XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
+ vk_testing::Device *m_device;
+ VK_APPLICATION_INFO app_info;
+ VK_PHYSICAL_GPU objs[VK_MAX_PHYSICAL_GPUS];
uint32_t gpu_count;
- XGL_INSTANCE inst;
- XGL_IMAGE m_image;
- XGL_GPU_MEMORY *m_image_mem;
+ VK_INSTANCE inst;
+ VK_IMAGE m_image;
+ VK_GPU_MEMORY *m_image_mem;
uint32_t m_num_mem;
virtual void SetUp() {
- XGL_RESULT err;
+ VK_RESULT err;
- this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
+ this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
this->app_info.pNext = NULL;
this->app_info.pAppName = "base";
this->app_info.appVersion = 1;
this->app_info.pEngineName = "unittest";
this->app_info.engineVersion = 1;
- this->app_info.apiVersion = XGL_API_VERSION;
- XGL_INSTANCE_CREATE_INFO inst_info = {};
- inst_info.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+ this->app_info.apiVersion = VK_API_VERSION;
+ VK_INSTANCE_CREATE_INFO inst_info = {};
+ inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_info;
inst_info.pAllocCb = NULL;
inst_info.extensionCount = 0;
inst_info.ppEnabledExtensionNames = NULL;
- err = xglCreateInstance(&inst_info, &this->inst);
- ASSERT_XGL_SUCCESS(err);
- err = xglEnumerateGpus(this->inst, XGL_MAX_PHYSICAL_GPUS,
+ err = vkCreateInstance(&inst_info, &this->inst);
+ ASSERT_VK_SUCCESS(err);
+ err = vkEnumerateGpus(this->inst, VK_MAX_PHYSICAL_GPUS,
&this->gpu_count, objs);
- ASSERT_XGL_SUCCESS(err);
+ ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, 1) << "No GPU available";
- this->m_device = new xgl_testing::Device(objs[0]);
+ this->m_device = new vk_testing::Device(objs[0]);
this->m_device->init();
}
virtual void TearDown() {
- xglDestroyInstance(this->inst);
+ vkDestroyInstance(this->inst);
}
};
void XglImageTest::CreateImage(uint32_t w, uint32_t h)
{
- XGL_RESULT err;
+ VK_RESULT err;
uint32_t mipCount;
size_t size;
- XGL_FORMAT fmt;
- XGL_FORMAT_PROPERTIES image_fmt;
+ VK_FORMAT fmt;
+ VK_FORMAT_PROPERTIES image_fmt;
mipCount = 0;
@@ -136,41 +136,41 @@
mipCount++;
}
- fmt = XGL_FMT_R8G8B8A8_UINT;
+ fmt = VK_FMT_R8G8B8A8_UINT;
// TODO: Pick known good format rather than just expect common format
/*
* XXX: What should happen if given NULL HANDLE for the pData argument?
- * We're not requesting XGL_INFO_TYPE_MEMORY_REQUIREMENTS so there is
+ * We're not requesting VK_INFO_TYPE_MEMORY_REQUIREMENTS so there is
* an expectation that pData is a valid pointer.
* However, why include a returned size value? That implies that the
* amount of data may vary and that doesn't work well for using a
* fixed structure.
*/
size = sizeof(image_fmt);
- err = xglGetFormatInfo(this->device(), fmt,
- XGL_INFO_TYPE_FORMAT_PROPERTIES,
+ err = vkGetFormatInfo(this->device(), fmt,
+ VK_INFO_TYPE_FORMAT_PROPERTIES,
&size, &image_fmt);
- ASSERT_XGL_SUCCESS(err);
+ ASSERT_VK_SUCCESS(err);
- // typedef struct _XGL_IMAGE_CREATE_INFO
+ // typedef struct _VK_IMAGE_CREATE_INFO
// {
- // XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+ // VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
// const void* pNext; // Pointer to next structure.
- // XGL_IMAGE_TYPE imageType;
- // XGL_FORMAT format;
- // XGL_EXTENT3D extent;
+ // VK_IMAGE_TYPE imageType;
+ // VK_FORMAT format;
+ // VK_EXTENT3D extent;
// uint32_t mipLevels;
// uint32_t arraySize;
// uint32_t samples;
- // XGL_IMAGE_TILING tiling;
- // XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
- // XGL_FLAGS flags; // XGL_IMAGE_CREATE_FLAGS
- // } XGL_IMAGE_CREATE_INFO;
+ // VK_IMAGE_TILING tiling;
+ // VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS
+ // VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS
+ // } VK_IMAGE_CREATE_INFO;
- XGL_IMAGE_CREATE_INFO imageCreateInfo = {};
- imageCreateInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
- imageCreateInfo.imageType = XGL_IMAGE_2D;
+ VK_IMAGE_CREATE_INFO imageCreateInfo = {};
+ imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+ imageCreateInfo.imageType = VK_IMAGE_2D;
imageCreateInfo.format = fmt;
imageCreateInfo.arraySize = 1;
imageCreateInfo.extent.width = w;
@@ -178,151 +178,151 @@
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = mipCount;
imageCreateInfo.samples = 1;
- if (image_fmt.linearTilingFeatures & XGL_FORMAT_IMAGE_SHADER_READ_BIT) {
- imageCreateInfo.tiling = XGL_LINEAR_TILING;
+ if (image_fmt.linearTilingFeatures & VK_FORMAT_IMAGE_SHADER_READ_BIT) {
+ imageCreateInfo.tiling = VK_LINEAR_TILING;
}
- else if (image_fmt.optimalTilingFeatures & XGL_FORMAT_IMAGE_SHADER_READ_BIT) {
- imageCreateInfo.tiling = XGL_OPTIMAL_TILING;
+ else if (image_fmt.optimalTilingFeatures & VK_FORMAT_IMAGE_SHADER_READ_BIT) {
+ imageCreateInfo.tiling = VK_OPTIMAL_TILING;
}
else {
ASSERT_TRUE(false) << "Cannot find supported tiling format - Exiting";
}
// Image usage flags
- // typedef enum _XGL_IMAGE_USAGE_FLAGS
+ // typedef enum _VK_IMAGE_USAGE_FLAGS
// {
- // XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001,
- // XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002,
- // XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000004,
- // XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000008,
- // } XGL_IMAGE_USAGE_FLAGS;
- imageCreateInfo.usage = XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ // VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001,
+ // VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002,
+ // VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000004,
+ // VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000008,
+ // } VK_IMAGE_USAGE_FLAGS;
+ imageCreateInfo.usage = VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
- // XGL_RESULT XGLAPI xglCreateImage(
- // XGL_DEVICE device,
- // const XGL_IMAGE_CREATE_INFO* pCreateInfo,
- // XGL_IMAGE* pImage);
- err = xglCreateImage(device(), &imageCreateInfo, &m_image);
- ASSERT_XGL_SUCCESS(err);
+ // VK_RESULT VKAPI vkCreateImage(
+ // VK_DEVICE device,
+ // const VK_IMAGE_CREATE_INFO* pCreateInfo,
+ // VK_IMAGE* pImage);
+ err = vkCreateImage(device(), &imageCreateInfo, &m_image);
+ ASSERT_VK_SUCCESS(err);
- XGL_MEMORY_REQUIREMENTS *mem_req;
- size_t mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
- XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
- size_t img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ VK_MEMORY_REQUIREMENTS *mem_req;
+ size_t mem_reqs_size = sizeof(VK_MEMORY_REQUIREMENTS);
+ VK_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+ size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
uint32_t num_allocations = 0;
size_t num_alloc_size = sizeof(num_allocations);
- XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {};
- img_alloc.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
+ VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {};
+ img_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
img_alloc.pNext = NULL;
- XGL_MEMORY_ALLOC_INFO mem_info = {};
- mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
+ VK_MEMORY_ALLOC_INFO mem_info = {};
+ mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.pNext = &img_alloc;
- err = xglGetObjectInfo(m_image, XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+ err = vkGetObjectInfo(m_image, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
&num_alloc_size, &num_allocations);
- ASSERT_XGL_SUCCESS(err);
+ ASSERT_VK_SUCCESS(err);
ASSERT_EQ(num_alloc_size,sizeof(num_allocations));
- mem_req = (XGL_MEMORY_REQUIREMENTS *) malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
- m_image_mem = (XGL_GPU_MEMORY *) malloc(num_allocations * sizeof(XGL_GPU_MEMORY));
+ mem_req = (VK_MEMORY_REQUIREMENTS *) malloc(num_allocations * sizeof(VK_MEMORY_REQUIREMENTS));
+ m_image_mem = (VK_GPU_MEMORY *) malloc(num_allocations * sizeof(VK_GPU_MEMORY));
m_num_mem = num_allocations;
- err = xglGetObjectInfo(m_image,
- XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
+ err = vkGetObjectInfo(m_image,
+ VK_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size, mem_req);
- ASSERT_XGL_SUCCESS(err);
- ASSERT_EQ(mem_reqs_size, num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
- err = xglGetObjectInfo(m_image,
- XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+ ASSERT_VK_SUCCESS(err);
+ ASSERT_EQ(mem_reqs_size, num_allocations * sizeof(VK_MEMORY_REQUIREMENTS));
+ err = vkGetObjectInfo(m_image,
+ VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
&img_reqs_size, &img_reqs);
- ASSERT_XGL_SUCCESS(err);
- ASSERT_EQ(img_reqs_size, sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+ ASSERT_VK_SUCCESS(err);
+ ASSERT_EQ(img_reqs_size, sizeof(VK_IMAGE_MEMORY_REQUIREMENTS));
img_alloc.usage = img_reqs.usage;
img_alloc.formatClass = img_reqs.formatClass;
img_alloc.samples = img_reqs.samples;
for (uint32_t i = 0; i < num_allocations; i ++) {
- ASSERT_NE(0, mem_req[i].size) << "xglGetObjectInfo (Image): Failed - expect images to require memory";
+ ASSERT_NE(0, mem_req[i].size) << "vkGetObjectInfo (Image): Failed - expect images to require memory";
mem_info.allocationSize = mem_req[i].size;
- mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
- mem_info.memType = XGL_MEMORY_TYPE_IMAGE;
- mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
+ mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+ mem_info.memType = VK_MEMORY_TYPE_IMAGE;
+ mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
/* allocate memory */
- err = xglAllocMemory(device(), &mem_info, &m_image_mem[i]);
- ASSERT_XGL_SUCCESS(err);
+ err = vkAllocMemory(device(), &mem_info, &m_image_mem[i]);
+ ASSERT_VK_SUCCESS(err);
/* bind memory */
- err = xglBindObjectMemory(m_image, i, m_image_mem[i], 0);
- ASSERT_XGL_SUCCESS(err);
+ err = vkBindObjectMemory(m_image, i, m_image_mem[i], 0);
+ ASSERT_VK_SUCCESS(err);
}
}
void XglImageTest::DestroyImage()
{
- XGL_RESULT err;
+ VK_RESULT err;
// All done with image memory, clean up
- ASSERT_XGL_SUCCESS(xglBindObjectMemory(m_image, 0, XGL_NULL_HANDLE, 0));
+ ASSERT_VK_SUCCESS(vkBindObjectMemory(m_image, 0, VK_NULL_HANDLE, 0));
for (uint32_t i = 0 ; i < m_num_mem; i++) {
- err = xglFreeMemory(m_image_mem[i]);
- ASSERT_XGL_SUCCESS(err);
+ err = vkFreeMemory(m_image_mem[i]);
+ ASSERT_VK_SUCCESS(err);
}
- ASSERT_XGL_SUCCESS(xglDestroyObject(m_image));
+ ASSERT_VK_SUCCESS(vkDestroyObject(m_image));
}
-void XglImageTest::CreateImageView(XGL_IMAGE_VIEW_CREATE_INFO *pCreateInfo,
- XGL_IMAGE_VIEW *pView)
+void XglImageTest::CreateImageView(VK_IMAGE_VIEW_CREATE_INFO *pCreateInfo,
+ VK_IMAGE_VIEW *pView)
{
pCreateInfo->image = this->m_image;
- ASSERT_XGL_SUCCESS(xglCreateImageView(device(), pCreateInfo, pView));
+ ASSERT_VK_SUCCESS(vkCreateImageView(device(), pCreateInfo, pView));
}
-void XglImageTest::DestroyImageView(XGL_IMAGE_VIEW imageView)
+void XglImageTest::DestroyImageView(VK_IMAGE_VIEW imageView)
{
- ASSERT_XGL_SUCCESS(xglDestroyObject(imageView));
+ ASSERT_VK_SUCCESS(vkDestroyObject(imageView));
}
TEST_F(XglImageTest, CreateImageViewTest) {
- XGL_FORMAT fmt;
- XGL_IMAGE_VIEW imageView;
+ VK_FORMAT fmt;
+ VK_IMAGE_VIEW imageView;
- fmt = XGL_FMT_R8G8B8A8_UINT;
+ fmt = VK_FMT_R8G8B8A8_UINT;
CreateImage(512, 256);
- // typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
+ // typedef struct _VK_IMAGE_VIEW_CREATE_INFO
// {
- // XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+ // VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
// const void* pNext; // Pointer to next structure
- // XGL_IMAGE image;
- // XGL_IMAGE_VIEW_TYPE viewType;
- // XGL_FORMAT format;
- // XGL_CHANNEL_MAPPING channels;
- // XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
+ // VK_IMAGE image;
+ // VK_IMAGE_VIEW_TYPE viewType;
+ // VK_FORMAT format;
+ // VK_CHANNEL_MAPPING channels;
+ // VK_IMAGE_SUBRESOURCE_RANGE subresourceRange;
// float minLod;
- // } XGL_IMAGE_VIEW_CREATE_INFO;
- XGL_IMAGE_VIEW_CREATE_INFO viewInfo = {};
- viewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
- viewInfo.viewType = XGL_IMAGE_VIEW_2D;
+ // } VK_IMAGE_VIEW_CREATE_INFO;
+ VK_IMAGE_VIEW_CREATE_INFO viewInfo = {};
+ viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+ viewInfo.viewType = VK_IMAGE_VIEW_2D;
viewInfo.format = fmt;
- viewInfo.channels.r = XGL_CHANNEL_SWIZZLE_R;
- viewInfo.channels.g = XGL_CHANNEL_SWIZZLE_G;
- viewInfo.channels.b = XGL_CHANNEL_SWIZZLE_B;
- viewInfo.channels.a = XGL_CHANNEL_SWIZZLE_A;
+ viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
+ viewInfo.channels.g = VK_CHANNEL_SWIZZLE_G;
+ viewInfo.channels.b = VK_CHANNEL_SWIZZLE_B;
+ viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
viewInfo.subresourceRange.baseArraySlice = 0;
viewInfo.subresourceRange.arraySize = 1;
viewInfo.subresourceRange.baseMipLevel = 0;
viewInfo.subresourceRange.mipLevels = 1;
- viewInfo.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+ viewInfo.subresourceRange.aspect = VK_IMAGE_ASPECT_COLOR;
- // XGL_RESULT XGLAPI xglCreateImageView(
- // XGL_DEVICE device,
- // const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
- // XGL_IMAGE_VIEW* pView);
+ // VK_RESULT VKAPI vkCreateImageView(
+ // VK_DEVICE device,
+ // const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ // VK_IMAGE_VIEW* pView);
CreateImageView(&viewInfo, &imageView);
@@ -331,6 +331,6 @@
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
- xgl_testing::set_error_callback(test_error_callback);
+ vk_testing::set_error_callback(test_error_callback);
return RUN_ALL_TESTS();
}