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/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index 620b229..bec384e 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -1,5 +1,5 @@
/*
- * XGL Tests
+ * Vulkan Tests
*
* Copyright (C) 2014 LunarG, Inc.
*
@@ -25,18 +25,18 @@
* Courtney Goeltzenleuchter <courtney@lunarg.com>
*/
-#include "xglrenderframework.h"
+#include "vkrenderframework.h"
XglRenderFramework::XglRenderFramework() :
- m_cmdBuffer( XGL_NULL_HANDLE ),
- m_stateRaster( XGL_NULL_HANDLE ),
- m_colorBlend( XGL_NULL_HANDLE ),
- m_stateViewport( XGL_NULL_HANDLE ),
- m_stateDepthStencil( XGL_NULL_HANDLE ),
+ m_cmdBuffer( VK_NULL_HANDLE ),
+ m_stateRaster( VK_NULL_HANDLE ),
+ m_colorBlend( VK_NULL_HANDLE ),
+ m_stateViewport( VK_NULL_HANDLE ),
+ m_stateDepthStencil( VK_NULL_HANDLE ),
m_width( 256.0 ), // default window width
m_height( 256.0 ), // default window height
- m_render_target_fmt( XGL_FMT_R8G8B8A8_UNORM ),
- m_depth_stencil_fmt( XGL_FMT_UNDEFINED ),
+ m_render_target_fmt( VK_FMT_R8G8B8A8_UNORM ),
+ m_depth_stencil_fmt( VK_FMT_UNDEFINED ),
m_depth_clear_color( 1.0 ),
m_stencil_clear_color( 0 )
{
@@ -56,19 +56,19 @@
void XglRenderFramework::InitFramework()
{
- XGL_RESULT err;
- XGL_INSTANCE_CREATE_INFO instInfo = {};
- instInfo.sType = XGL_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+ VK_RESULT err;
+ VK_INSTANCE_CREATE_INFO instInfo = {};
+ instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instInfo.pNext = NULL;
instInfo.pAppInfo = &app_info;
instInfo.pAllocCb = NULL;
instInfo.extensionCount = 0;
instInfo.ppEnabledExtensionNames = NULL;
- err = xglCreateInstance(&instInfo, &this->inst);
- ASSERT_XGL_SUCCESS(err);
- err = xglEnumerateGpus(inst, XGL_MAX_PHYSICAL_GPUS, &this->gpu_count,
+ err = vkCreateInstance(&instInfo, &this->inst);
+ ASSERT_VK_SUCCESS(err);
+ err = vkEnumerateGpus(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";
m_device = new XglDevice(0, objs[0]);
@@ -79,21 +79,21 @@
void XglRenderFramework::ShutdownFramework()
{
- if (m_colorBlend) xglDestroyObject(m_colorBlend);
- if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil);
- if (m_stateRaster) xglDestroyObject(m_stateRaster);
- if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer);
- if (m_framebuffer) xglDestroyObject(m_framebuffer);
- if (m_renderPass) xglDestroyObject(m_renderPass);
+ if (m_colorBlend) vkDestroyObject(m_colorBlend);
+ if (m_stateDepthStencil) vkDestroyObject(m_stateDepthStencil);
+ if (m_stateRaster) vkDestroyObject(m_stateRaster);
+ if (m_cmdBuffer) vkDestroyObject(m_cmdBuffer);
+ if (m_framebuffer) vkDestroyObject(m_framebuffer);
+ if (m_renderPass) vkDestroyObject(m_renderPass);
if (m_stateViewport) {
- xglDestroyObject(m_stateViewport);
+ vkDestroyObject(m_stateViewport);
}
while (!m_renderTargets.empty()) {
- xglDestroyObject(m_renderTargets.back()->targetView());
- xglBindObjectMemory(m_renderTargets.back()->image(), 0, XGL_NULL_HANDLE, 0);
- xglDestroyObject(m_renderTargets.back()->image());
- xglFreeMemory(m_renderTargets.back()->memory());
+ vkDestroyObject(m_renderTargets.back()->targetView());
+ vkBindObjectMemory(m_renderTargets.back()->image(), 0, VK_NULL_HANDLE, 0);
+ vkDestroyObject(m_renderTargets.back()->image());
+ vkFreeMemory(m_renderTargets.back()->memory());
m_renderTargets.pop_back();
}
@@ -101,56 +101,56 @@
// reset the driver
delete m_device;
- xglDestroyInstance(this->inst);
+ vkDestroyInstance(this->inst);
}
void XglRenderFramework::InitState()
{
- XGL_RESULT err;
+ VK_RESULT err;
- m_render_target_fmt = XGL_FMT_B8G8R8A8_UNORM;
+ m_render_target_fmt = VK_FMT_B8G8R8A8_UNORM;
// create a raster state (solid, back-face culling)
- XGL_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
- raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
+ VK_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
+ raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
raster.pointSize = 1.0;
- err = xglCreateDynamicRasterState( device(), &raster, &m_stateRaster );
- ASSERT_XGL_SUCCESS(err);
+ err = vkCreateDynamicRasterState( device(), &raster, &m_stateRaster );
+ ASSERT_VK_SUCCESS(err);
- XGL_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
- blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
- err = xglCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
- ASSERT_XGL_SUCCESS( err );
+ VK_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
+ blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
+ err = vkCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
+ ASSERT_VK_SUCCESS( err );
- XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
- depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+ VK_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
+ depthStencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
depthStencil.minDepth = 0.f;
depthStencil.maxDepth = 1.f;
depthStencil.stencilFrontRef = 0;
depthStencil.stencilBackRef = 0;
- err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
- ASSERT_XGL_SUCCESS( err );
+ err = vkCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
+ ASSERT_VK_SUCCESS( err );
- XGL_CMD_BUFFER_CREATE_INFO cmdInfo = {};
+ VK_CMD_BUFFER_CREATE_INFO cmdInfo = {};
- cmdInfo.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+ cmdInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
cmdInfo.queueNodeIndex = m_device->graphics_queue_node_index_;
- err = xglCreateCommandBuffer(device(), &cmdInfo, &m_cmdBuffer);
- ASSERT_XGL_SUCCESS(err) << "xglCreateCommandBuffer failed";
+ err = vkCreateCommandBuffer(device(), &cmdInfo, &m_cmdBuffer);
+ ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
}
void XglRenderFramework::InitViewport(float width, float height)
{
- XGL_RESULT err;
+ VK_RESULT err;
- XGL_VIEWPORT viewport;
- XGL_RECT scissor;
+ VK_VIEWPORT viewport;
+ VK_RECT scissor;
- XGL_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
- viewportCreate.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+ VK_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
+ viewportCreate.sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
viewportCreate.viewportAndScissorCount = 1;
viewport.originX = 0;
viewport.originY = 0;
@@ -165,8 +165,8 @@
viewportCreate.pViewports = &viewport;
viewportCreate.pScissors = &scissor;
- err = xglCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
- ASSERT_XGL_SUCCESS( err );
+ err = vkCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
+ ASSERT_VK_SUCCESS( err );
m_width = width;
m_height = height;
}
@@ -185,35 +185,35 @@
InitRenderTarget(targets, NULL);
}
-void XglRenderFramework::InitRenderTarget(XGL_DEPTH_STENCIL_BIND_INFO *dsBinding)
+void XglRenderFramework::InitRenderTarget(VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
{
InitRenderTarget(1, dsBinding);
}
-void XglRenderFramework::InitRenderTarget(uint32_t targets, XGL_DEPTH_STENCIL_BIND_INFO *dsBinding)
+void XglRenderFramework::InitRenderTarget(uint32_t targets, VK_DEPTH_STENCIL_BIND_INFO *dsBinding)
{
- std::vector<XGL_ATTACHMENT_LOAD_OP> load_ops;
- std::vector<XGL_ATTACHMENT_STORE_OP> store_ops;
- std::vector<XGL_CLEAR_COLOR> clear_colors;
+ std::vector<VK_ATTACHMENT_LOAD_OP> load_ops;
+ std::vector<VK_ATTACHMENT_STORE_OP> store_ops;
+ std::vector<VK_CLEAR_COLOR> clear_colors;
uint32_t i;
for (i = 0; i < targets; i++) {
XglImage *img = new XglImage(m_device);
img->init(m_width, m_height, m_render_target_fmt,
- XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
- XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+ VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
m_colorBindings[i].view = img->targetView();
- m_colorBindings[i].layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ m_colorBindings[i].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
m_renderTargets.push_back(img);
- load_ops.push_back(XGL_ATTACHMENT_LOAD_OP_LOAD);
- store_ops.push_back(XGL_ATTACHMENT_STORE_OP_STORE);
+ load_ops.push_back(VK_ATTACHMENT_LOAD_OP_LOAD);
+ store_ops.push_back(VK_ATTACHMENT_STORE_OP_STORE);
clear_colors.push_back(m_clear_color);
// m_mem_ref_mgr.AddMemoryRefs(*img);
}
// Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
- XGL_FRAMEBUFFER_CREATE_INFO fb_info = {};
- fb_info.sType = XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+ VK_FRAMEBUFFER_CREATE_INFO fb_info = {};
+ fb_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
fb_info.pNext = NULL;
fb_info.colorAttachmentCount = m_renderTargets.size();
fb_info.pColorAttachments = m_colorBindings;
@@ -223,10 +223,10 @@
fb_info.height = (uint32_t)m_height;
fb_info.layers = 1;
- xglCreateFramebuffer(device(), &fb_info, &m_framebuffer);
+ vkCreateFramebuffer(device(), &fb_info, &m_framebuffer);
- XGL_RENDER_PASS_CREATE_INFO rp_info = {};
- rp_info.sType = XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+ VK_RENDER_PASS_CREATE_INFO rp_info = {};
+ rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
rp_info.renderArea.extent.width = m_width;
rp_info.renderArea.extent.height = m_height;
@@ -240,19 +240,19 @@
if (dsBinding) {
rp_info.depthStencilLayout = dsBinding->layout;
}
- rp_info.depthLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
+ rp_info.depthLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
rp_info.depthLoadClearValue = m_depth_clear_color;
- rp_info.depthStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
- rp_info.stencilLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
+ rp_info.depthStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
+ rp_info.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
rp_info.stencilLoadClearValue = m_stencil_clear_color;
- rp_info.stencilStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
- xglCreateRenderPass(device(), &rp_info, &m_renderPass);
+ rp_info.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
+ vkCreateRenderPass(device(), &rp_info, &m_renderPass);
}
-XglDevice::XglDevice(uint32_t id, XGL_PHYSICAL_GPU obj) :
- xgl_testing::Device(obj), id(id)
+XglDevice::XglDevice(uint32_t id, VK_PHYSICAL_GPU obj) :
+ vk_testing::Device(obj), id(id)
{
init();
@@ -281,22 +281,22 @@
int XglDescriptorSetObj::AppendDummy()
{
/* request a descriptor but do not update it */
- XGL_DESCRIPTOR_TYPE_COUNT tc = {};
- tc.type = XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER;
+ VK_DESCRIPTOR_TYPE_COUNT tc = {};
+ tc.type = VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER;
tc.count = 1;
m_type_counts.push_back(tc);
return m_nextSlot++;
}
-int XglDescriptorSetObj::AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer)
+int XglDescriptorSetObj::AppendBuffer(VK_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer)
{
- XGL_DESCRIPTOR_TYPE_COUNT tc = {};
+ VK_DESCRIPTOR_TYPE_COUNT tc = {};
tc.type = type;
tc.count = 1;
m_type_counts.push_back(tc);
- m_updateBuffers.push_back(xgl_testing::DescriptorSet::update(type,
+ m_updateBuffers.push_back(vk_testing::DescriptorSet::update(type,
m_nextSlot, 0, 1, &constantBuffer.m_bufferViewInfo));
// Track mem references for this descriptor set object
@@ -307,18 +307,18 @@
int XglDescriptorSetObj::AppendSamplerTexture( XglSamplerObj* sampler, XglTextureObj* texture)
{
- XGL_DESCRIPTOR_TYPE_COUNT tc = {};
- tc.type = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
+ VK_DESCRIPTOR_TYPE_COUNT tc = {};
+ tc.type = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
tc.count = 1;
m_type_counts.push_back(tc);
- XGL_SAMPLER_IMAGE_VIEW_INFO tmp = {};
+ VK_SAMPLER_IMAGE_VIEW_INFO tmp = {};
tmp.sampler = sampler->obj();
tmp.pImageView = &texture->m_textureViewInfo;
m_samplerTextureInfo.push_back(tmp);
- m_updateSamplerTextures.push_back(xgl_testing::DescriptorSet::update(m_nextSlot, 0, 1,
- (const XGL_SAMPLER_IMAGE_VIEW_INFO *) NULL));
+ m_updateSamplerTextures.push_back(vk_testing::DescriptorSet::update(m_nextSlot, 0, 1,
+ (const VK_SAMPLER_IMAGE_VIEW_INFO *) NULL));
// Track mem references for the texture referenced here
mem_ref_mgr.AddMemoryRefs(*texture);
@@ -326,49 +326,49 @@
return m_nextSlot++;
}
-XGL_DESCRIPTOR_SET_LAYOUT_CHAIN XglDescriptorSetObj::GetLayoutChain() const
+VK_DESCRIPTOR_SET_LAYOUT_CHAIN XglDescriptorSetObj::GetLayoutChain() const
{
return m_layout_chain.obj();
}
-XGL_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle() const
+VK_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle() const
{
return m_set->obj();
}
-void XglDescriptorSetObj::CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer)
+void XglDescriptorSetObj::CreateVKDescriptorSet(XglCommandBufferObj *cmdBuffer)
{
- // create XGL_DESCRIPTOR_POOL
- XGL_DESCRIPTOR_POOL_CREATE_INFO pool = {};
- pool.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+ // create VK_DESCRIPTOR_POOL
+ VK_DESCRIPTOR_POOL_CREATE_INFO pool = {};
+ pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool.count = m_type_counts.size();
pool.pTypeCount = &m_type_counts[0];
- init(*m_device, XGL_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, pool);
+ init(*m_device, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, pool);
- // create XGL_DESCRIPTOR_SET_LAYOUT
- vector<XGL_DESCRIPTOR_SET_LAYOUT_BINDING> bindings;
+ // create VK_DESCRIPTOR_SET_LAYOUT
+ vector<VK_DESCRIPTOR_SET_LAYOUT_BINDING> bindings;
bindings.resize(m_type_counts.size());
for (int i = 0; i < m_type_counts.size(); i++) {
bindings[i].descriptorType = m_type_counts[i].type;
bindings[i].count = m_type_counts[i].count;
- bindings[i].stageFlags = XGL_SHADER_STAGE_FLAGS_ALL;
+ bindings[i].stageFlags = VK_SHADER_STAGE_FLAGS_ALL;
bindings[i].pImmutableSamplers = NULL;
}
- // create XGL_DESCRIPTOR_SET_LAYOUT
- XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO layout = {};
- layout.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ // create VK_DESCRIPTOR_SET_LAYOUT
+ VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO layout = {};
+ layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layout.count = bindings.size();
layout.pBinding = &bindings[0];
m_layout.init(*m_device, layout);
- vector<const xgl_testing::DescriptorSetLayout *> layouts;
+ vector<const vk_testing::DescriptorSetLayout *> layouts;
layouts.push_back(&m_layout);
m_layout_chain.init(*m_device, layouts);
- // create XGL_DESCRIPTOR_SET
- m_set = alloc_sets(XGL_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
+ // create VK_DESCRIPTOR_SET
+ m_set = alloc_sets(VK_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
// build the update array
vector<const void *> update_array;
@@ -382,7 +382,7 @@
}
// do the updates
- m_device->begin_descriptor_pool_update(XGL_DESCRIPTOR_UPDATE_MODE_FASTEST);
+ m_device->begin_descriptor_pool_update(VK_DESCRIPTOR_UPDATE_MODE_FASTEST);
clear_sets(*m_set);
m_set->update(update_array);
m_device->end_descriptor_pool_update(*cmdBuffer);
@@ -391,95 +391,95 @@
XglImage::XglImage(XglDevice *dev)
{
m_device = dev;
- m_imageInfo.view = XGL_NULL_HANDLE;
- m_imageInfo.layout = XGL_IMAGE_LAYOUT_GENERAL;
+ m_imageInfo.view = VK_NULL_HANDLE;
+ m_imageInfo.layout = VK_IMAGE_LAYOUT_GENERAL;
}
void XglImage::ImageMemoryBarrier(
XglCommandBufferObj *cmd_buf,
- XGL_IMAGE_ASPECT aspect,
- XGL_FLAGS output_mask /*=
- XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
- XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
- XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_COPY_BIT*/,
- XGL_FLAGS input_mask /*=
- XGL_MEMORY_INPUT_CPU_READ_BIT |
- XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
- XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
- XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
- XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
- XGL_MEMORY_INPUT_SHADER_READ_BIT |
- XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_COPY_BIT*/,
- XGL_IMAGE_LAYOUT image_layout)
+ VK_IMAGE_ASPECT aspect,
+ VK_FLAGS output_mask /*=
+ VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_COPY_BIT*/,
+ VK_FLAGS input_mask /*=
+ VK_MEMORY_INPUT_CPU_READ_BIT |
+ VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+ VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+ VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+ VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+ VK_MEMORY_INPUT_SHADER_READ_BIT |
+ VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_COPY_BIT*/,
+ VK_IMAGE_LAYOUT image_layout)
{
- const XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange = subresource_range(aspect, 0, 1, 0, 1);
- XGL_IMAGE_MEMORY_BARRIER barrier;
+ const VK_IMAGE_SUBRESOURCE_RANGE subresourceRange = subresource_range(aspect, 0, 1, 0, 1);
+ VK_IMAGE_MEMORY_BARRIER barrier;
barrier = image_memory_barrier(output_mask, input_mask, layout(), image_layout,
subresourceRange);
- XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &barrier;
+ VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &barrier;
- XGL_PIPE_EVENT pipe_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- XGL_PIPELINE_BARRIER pipeline_barrier = {};
- pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+ VK_PIPE_EVENT pipe_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+ VK_PIPELINE_BARRIER pipeline_barrier = {};
+ pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
pipeline_barrier.pNext = NULL;
pipeline_barrier.eventCount = 1;
pipeline_barrier.pEvents = pipe_events;
- pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+ pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
pipeline_barrier.memBarrierCount = 1;
pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
// write barrier to the command buffer
- xglCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
}
void XglImage::SetLayout(XglCommandBufferObj *cmd_buf,
- XGL_IMAGE_ASPECT aspect,
- XGL_IMAGE_LAYOUT image_layout)
+ VK_IMAGE_ASPECT aspect,
+ VK_IMAGE_LAYOUT image_layout)
{
- XGL_FLAGS output_mask, input_mask;
- const XGL_FLAGS all_cache_outputs =
- XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
- XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
- XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_COPY_BIT;
- const XGL_FLAGS all_cache_inputs =
- XGL_MEMORY_INPUT_CPU_READ_BIT |
- XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
- XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
- XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
- XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
- XGL_MEMORY_INPUT_SHADER_READ_BIT |
- XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_COPY_BIT;
+ VK_FLAGS output_mask, input_mask;
+ const VK_FLAGS all_cache_outputs =
+ VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_COPY_BIT;
+ const VK_FLAGS all_cache_inputs =
+ VK_MEMORY_INPUT_CPU_READ_BIT |
+ VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+ VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+ VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+ VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+ VK_MEMORY_INPUT_SHADER_READ_BIT |
+ VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_COPY_BIT;
if (image_layout == m_imageInfo.layout) {
return;
}
switch (image_layout) {
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
- input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+ case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ output_mask = VK_MEMORY_OUTPUT_COPY_BIT;
+ input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_COPY_BIT;
break;
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
- input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+ case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ output_mask = VK_MEMORY_OUTPUT_COPY_BIT;
+ input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_COPY_BIT;
break;
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case VK_IMAGE_LAYOUT_CLEAR_OPTIMAL:
break;
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- output_mask = XGL_MEMORY_OUTPUT_COPY_BIT;
- input_mask = XGL_MEMORY_INPUT_SHADER_READ_BIT | XGL_MEMORY_INPUT_COPY_BIT;
+ case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ output_mask = VK_MEMORY_OUTPUT_COPY_BIT;
+ input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_COPY_BIT;
break;
default:
@@ -492,10 +492,10 @@
m_imageInfo.layout = image_layout;
}
-void XglImage::SetLayout(XGL_IMAGE_ASPECT aspect,
- XGL_IMAGE_LAYOUT image_layout)
+void XglImage::SetLayout(VK_IMAGE_ASPECT aspect,
+ VK_IMAGE_LAYOUT image_layout)
{
- XGL_RESULT err;
+ VK_RESULT err;
XglCommandBufferObj cmd_buf(m_device);
/* Build command buffer to set image layout in the driver */
@@ -510,27 +510,27 @@
cmd_buf.QueueCommandBuffer();
}
-bool XglImage::IsCompatible(XGL_FLAGS usage, XGL_FLAGS features)
+bool XglImage::IsCompatible(VK_FLAGS usage, VK_FLAGS features)
{
- if ((usage & XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) &&
- !(features & XGL_FORMAT_IMAGE_SHADER_READ_BIT))
+ if ((usage & VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) &&
+ !(features & VK_FORMAT_IMAGE_SHADER_READ_BIT))
return false;
- if ((usage & XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT) &&
- !(features & XGL_FORMAT_IMAGE_SHADER_WRITE_BIT))
+ if ((usage & VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT) &&
+ !(features & VK_FORMAT_IMAGE_SHADER_WRITE_BIT))
return false;
return true;
}
void XglImage::init(uint32_t w, uint32_t h,
- XGL_FORMAT fmt, XGL_FLAGS usage,
- XGL_IMAGE_TILING requested_tiling)
+ VK_FORMAT fmt, VK_FLAGS usage,
+ VK_IMAGE_TILING requested_tiling)
{
uint32_t mipCount;
- XGL_FORMAT_PROPERTIES image_fmt;
- XGL_IMAGE_TILING tiling;
- XGL_RESULT err;
+ VK_FORMAT_PROPERTIES image_fmt;
+ VK_IMAGE_TILING tiling;
+ VK_RESULT err;
size_t size;
mipCount = 0;
@@ -545,29 +545,29 @@
}
size = sizeof(image_fmt);
- err = xglGetFormatInfo(m_device->obj(), fmt,
- XGL_INFO_TYPE_FORMAT_PROPERTIES,
+ err = vkGetFormatInfo(m_device->obj(), fmt,
+ VK_INFO_TYPE_FORMAT_PROPERTIES,
&size, &image_fmt);
- ASSERT_XGL_SUCCESS(err);
+ ASSERT_VK_SUCCESS(err);
- if (requested_tiling == XGL_LINEAR_TILING) {
+ if (requested_tiling == VK_LINEAR_TILING) {
if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
- tiling = XGL_LINEAR_TILING;
+ tiling = VK_LINEAR_TILING;
} else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
- tiling = XGL_OPTIMAL_TILING;
+ tiling = VK_OPTIMAL_TILING;
} else {
ASSERT_TRUE(false) << "Error: Cannot find requested tiling configuration";
}
} else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
- tiling = XGL_OPTIMAL_TILING;
+ tiling = VK_OPTIMAL_TILING;
} else if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
- tiling = XGL_LINEAR_TILING;
+ tiling = VK_LINEAR_TILING;
} else {
ASSERT_TRUE(false) << "Error: Cannot find requested tiling configuration";
}
- XGL_IMAGE_CREATE_INFO imageCreateInfo = xgl_testing::Image::create_info();
- imageCreateInfo.imageType = XGL_IMAGE_2D;
+ VK_IMAGE_CREATE_INFO imageCreateInfo = vk_testing::Image::create_info();
+ imageCreateInfo.imageType = VK_IMAGE_2D;
imageCreateInfo.format = fmt;
imageCreateInfo.extent.width = w;
imageCreateInfo.extent.height = h;
@@ -576,32 +576,32 @@
imageCreateInfo.usage = usage;
- xgl_testing::Image::init(*m_device, imageCreateInfo);
+ vk_testing::Image::init(*m_device, imageCreateInfo);
- if (usage & XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) {
- SetLayout(XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+ if (usage & VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT) {
+ SetLayout(VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
} else {
- SetLayout(XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_GENERAL);
+ SetLayout(VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_GENERAL);
}
}
-XGL_RESULT XglImage::MapMemory(void** ptr)
+VK_RESULT XglImage::MapMemory(void** ptr)
{
*ptr = map();
- return (*ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
+ return (*ptr) ? VK_SUCCESS : VK_ERROR_UNKNOWN;
}
-XGL_RESULT XglImage::UnmapMemory()
+VK_RESULT XglImage::UnmapMemory()
{
unmap();
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-XGL_RESULT XglImage::CopyImage(XglImage &src_image)
+VK_RESULT XglImage::CopyImage(XglImage &src_image)
{
- XGL_RESULT err;
+ VK_RESULT err;
XglCommandBufferObj cmd_buf(m_device);
- XGL_IMAGE_LAYOUT src_image_layout, dest_image_layout;
+ VK_IMAGE_LAYOUT src_image_layout, dest_image_layout;
/* Build command buffer to copy staging texture to usable texture */
err = cmd_buf.BeginCommandBuffer();
@@ -609,19 +609,19 @@
/* TODO: Can we determine image aspect from image object? */
src_image_layout = src_image.layout();
- src_image.SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
+ src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
dest_image_layout = this->layout();
- this->SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
+ this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
- XGL_IMAGE_COPY copy_region = {};
- copy_region.srcSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
+ VK_IMAGE_COPY copy_region = {};
+ copy_region.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR;
copy_region.srcSubresource.arraySlice = 0;
copy_region.srcSubresource.mipLevel = 0;
copy_region.srcOffset.x = 0;
copy_region.srcOffset.y = 0;
copy_region.srcOffset.z = 0;
- copy_region.destSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
+ copy_region.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR;
copy_region.destSubresource.arraySlice = 0;
copy_region.destSubresource.mipLevel = 0;
copy_region.destOffset.x = 0;
@@ -629,56 +629,56 @@
copy_region.destOffset.z = 0;
copy_region.extent = src_image.extent();
- xglCmdCopyImage(cmd_buf.obj(),
+ vkCmdCopyImage(cmd_buf.obj(),
src_image.obj(), src_image.layout(),
obj(), layout(),
1, ©_region);
cmd_buf.mem_ref_mgr.AddMemoryRefs(src_image);
cmd_buf.mem_ref_mgr.AddMemoryRefs(*this);
- src_image.SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, src_image_layout);
+ src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, src_image_layout);
- this->SetLayout(&cmd_buf, XGL_IMAGE_ASPECT_COLOR, dest_image_layout);
+ this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR, dest_image_layout);
err = cmd_buf.EndCommandBuffer();
assert(!err);
cmd_buf.QueueCommandBuffer();
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
XglTextureObj::XglTextureObj(XglDevice *device, uint32_t *colors)
:XglImage(device)
{
m_device = device;
- const XGL_FORMAT tex_format = XGL_FMT_B8G8R8A8_UNORM;
+ 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);
- stagingImage.init(16, 16, tex_format, 0, XGL_LINEAR_TILING);
- XGL_SUBRESOURCE_LAYOUT layout = stagingImage.subresource_layout(subresource(XGL_IMAGE_ASPECT_COLOR, 0, 0));
+ stagingImage.init(16, 16, tex_format, 0, VK_LINEAR_TILING);
+ VK_SUBRESOURCE_LAYOUT layout = stagingImage.subresource_layout(subresource(VK_IMAGE_ASPECT_COLOR, 0, 0));
if (colors == NULL)
colors = tex_colors;
memset(&m_textureViewInfo,0,sizeof(m_textureViewInfo));
- m_textureViewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+ m_textureViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
- XGL_IMAGE_VIEW_CREATE_INFO view = {};
- view.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+ VK_IMAGE_VIEW_CREATE_INFO view = {};
+ view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view.pNext = NULL;
- view.image = XGL_NULL_HANDLE;
- view.viewType = XGL_IMAGE_VIEW_2D;
+ view.image = VK_NULL_HANDLE;
+ view.viewType = VK_IMAGE_VIEW_2D;
view.format = tex_format;
- view.channels.r = XGL_CHANNEL_SWIZZLE_R;
- view.channels.g = XGL_CHANNEL_SWIZZLE_G;
- view.channels.b = XGL_CHANNEL_SWIZZLE_B;
- view.channels.a = XGL_CHANNEL_SWIZZLE_A;
- view.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+ view.channels.r = VK_CHANNEL_SWIZZLE_R;
+ view.channels.g = VK_CHANNEL_SWIZZLE_G;
+ view.channels.b = VK_CHANNEL_SWIZZLE_B;
+ view.channels.a = VK_CHANNEL_SWIZZLE_A;
+ view.subresourceRange.aspect = VK_IMAGE_ASPECT_COLOR;
view.subresourceRange.baseMipLevel = 0;
view.subresourceRange.mipLevels = 1;
view.subresourceRange.baseArraySlice = 0;
@@ -686,7 +686,7 @@
view.minLod = 0.0f;
/* create image */
- init(16, 16, tex_format, XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT, XGL_OPTIMAL_TILING);
+ init(16, 16, tex_format, VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT, VK_OPTIMAL_TILING);
/* create image view */
view.image = obj();
@@ -708,21 +708,21 @@
{
m_device = device;
- XGL_SAMPLER_CREATE_INFO samplerCreateInfo;
+ VK_SAMPLER_CREATE_INFO samplerCreateInfo;
memset(&samplerCreateInfo,0,sizeof(samplerCreateInfo));
- samplerCreateInfo.sType = XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
- samplerCreateInfo.magFilter = XGL_TEX_FILTER_NEAREST;
- samplerCreateInfo.minFilter = XGL_TEX_FILTER_NEAREST;
- samplerCreateInfo.mipMode = XGL_TEX_MIPMAP_BASE;
- samplerCreateInfo.addressU = XGL_TEX_ADDRESS_WRAP;
- samplerCreateInfo.addressV = XGL_TEX_ADDRESS_WRAP;
- samplerCreateInfo.addressW = XGL_TEX_ADDRESS_WRAP;
+ samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+ samplerCreateInfo.magFilter = VK_TEX_FILTER_NEAREST;
+ samplerCreateInfo.minFilter = VK_TEX_FILTER_NEAREST;
+ samplerCreateInfo.mipMode = VK_TEX_MIPMAP_BASE;
+ samplerCreateInfo.addressU = VK_TEX_ADDRESS_WRAP;
+ samplerCreateInfo.addressV = VK_TEX_ADDRESS_WRAP;
+ samplerCreateInfo.addressW = VK_TEX_ADDRESS_WRAP;
samplerCreateInfo.mipLodBias = 0.0;
samplerCreateInfo.maxAnisotropy = 0.0;
- samplerCreateInfo.compareFunc = XGL_COMPARE_NEVER;
+ samplerCreateInfo.compareFunc = VK_COMPARE_NEVER;
samplerCreateInfo.minLod = 0.0;
samplerCreateInfo.maxLod = 0.0;
- samplerCreateInfo.borderColorType = XGL_BORDER_COLOR_OPAQUE_WHITE;
+ samplerCreateInfo.borderColorType = VK_BORDER_COLOR_OPAQUE_WHITE;
init(*m_device, samplerCreateInfo);
}
@@ -763,47 +763,47 @@
unmap();
// set up the buffer view for the constant buffer
- XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
- view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+ VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+ view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.buffer = obj();
- view_info.viewType = XGL_BUFFER_VIEW_RAW;
+ view_info.viewType = VK_BUFFER_VIEW_RAW;
view_info.offset = 0;
view_info.range = allocationSize;
m_bufferView.init(*m_device, view_info);
- this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+ this->m_bufferViewInfo.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
this->m_bufferViewInfo.view = m_bufferView.obj();
}
-void XglConstantBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, uint32_t binding)
+void XglConstantBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset, uint32_t binding)
{
- xglCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
+ vkCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
}
void XglConstantBufferObj::BufferMemoryBarrier(
- XGL_FLAGS outputMask /*=
- XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
- XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
- XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_COPY_BIT*/,
- XGL_FLAGS inputMask /*=
- XGL_MEMORY_INPUT_CPU_READ_BIT |
- XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
- XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
- XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
- XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
- XGL_MEMORY_INPUT_SHADER_READ_BIT |
- XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_COPY_BIT*/)
+ VK_FLAGS outputMask /*=
+ VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_COPY_BIT*/,
+ VK_FLAGS inputMask /*=
+ VK_MEMORY_INPUT_CPU_READ_BIT |
+ VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+ VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+ VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+ VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+ VK_MEMORY_INPUT_SHADER_READ_BIT |
+ VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_COPY_BIT*/)
{
- XGL_RESULT err = XGL_SUCCESS;
+ VK_RESULT err = VK_SUCCESS;
if (!m_commandBuffer)
{
- m_fence.init(*m_device, xgl_testing::Fence::create_info());
+ m_fence.init(*m_device, vk_testing::Fence::create_info());
m_commandBuffer = new XglCommandBufferObj(m_device);
}
@@ -814,24 +814,24 @@
}
// open the command buffer
- XGL_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {};
- cmd_buf_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+ VK_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {};
+ cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
cmd_buf_info.pNext = NULL;
cmd_buf_info.flags = 0;
err = m_commandBuffer->BeginCommandBuffer(&cmd_buf_info);
- ASSERT_XGL_SUCCESS(err);
+ ASSERT_VK_SUCCESS(err);
- XGL_BUFFER_MEMORY_BARRIER memory_barrier =
+ VK_BUFFER_MEMORY_BARRIER memory_barrier =
buffer_memory_barrier(outputMask, inputMask, 0, m_numVertices * m_stride);
- XGL_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+ VK_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
- XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- XGL_PIPELINE_BARRIER pipeline_barrier = {};
- pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+ VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+ VK_PIPELINE_BARRIER pipeline_barrier = {};
+ pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
pipeline_barrier.eventCount = 1;
pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+ pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
pipeline_barrier.memBarrierCount = 1;
pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
@@ -840,7 +840,7 @@
// finish recording the command buffer
err = m_commandBuffer->EndCommandBuffer();
- ASSERT_XGL_SUCCESS(err);
+ ASSERT_VK_SUCCESS(err);
/*
* Tell driver about memory references made in this command buffer
@@ -850,10 +850,10 @@
m_commandBuffer->mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
// submit the command buffer to the universal queue
- XGL_CMD_BUFFER bufferArray[1];
+ VK_CMD_BUFFER bufferArray[1];
bufferArray[0] = m_commandBuffer->GetBufferHandle();
- err = xglQueueSubmit( m_device->m_queue, 1, bufferArray, m_fence.obj() );
- ASSERT_XGL_SUCCESS(err);
+ err = vkQueueSubmit( m_device->m_queue, 1, bufferArray, m_fence.obj() );
+ ASSERT_VK_SUCCESS(err);
}
XglIndexBufferObj::XglIndexBufferObj(XglDevice *device)
@@ -862,24 +862,24 @@
}
-void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE indexType, const void* data)
+void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, VK_INDEX_TYPE indexType, const void* data)
{
- XGL_FORMAT viewFormat;
+ VK_FORMAT viewFormat;
m_numVertices = numIndexes;
m_indexType = indexType;
switch (indexType) {
- case XGL_INDEX_8:
+ case VK_INDEX_8:
m_stride = 1;
- viewFormat = XGL_FMT_R8_UINT;
+ viewFormat = VK_FMT_R8_UINT;
break;
- case XGL_INDEX_16:
+ case VK_INDEX_16:
m_stride = 2;
- viewFormat = XGL_FMT_R16_UINT;
+ viewFormat = VK_FMT_R16_UINT;
break;
- case XGL_INDEX_32:
+ case VK_INDEX_32:
m_stride = 4;
- viewFormat = XGL_FMT_R32_UINT;
+ viewFormat = VK_FMT_R32_UINT;
break;
default:
assert(!"unknown index type");
@@ -894,52 +894,52 @@
unmap();
// set up the buffer view for the constant buffer
- XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
- view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+ VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+ view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.buffer = obj();
- view_info.viewType = XGL_BUFFER_VIEW_TYPED;
+ view_info.viewType = VK_BUFFER_VIEW_TYPED;
view_info.format = viewFormat;
view_info.offset = 0;
view_info.range = allocationSize;
m_bufferView.init(*m_device, view_info);
- this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+ this->m_bufferViewInfo.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
this->m_bufferViewInfo.view = m_bufferView.obj();
}
-void XglIndexBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset)
+void XglIndexBufferObj::Bind(VK_CMD_BUFFER cmdBuffer, VK_GPU_SIZE offset)
{
- xglCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
+ vkCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
}
-XGL_INDEX_TYPE XglIndexBufferObj::GetIndexType()
+VK_INDEX_TYPE XglIndexBufferObj::GetIndexType()
{
return m_indexType;
}
-XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
+VK_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
{
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *stageInfo = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) calloc( 1,sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) );
- stageInfo->sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+ 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;
stageInfo->shader.stage = m_stage;
stageInfo->shader.shader = obj();
stageInfo->shader.linkConstBufferCount = 0;
- stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
+ stageInfo->shader.pLinkConstBufferInfo = VK_NULL_HANDLE;
return stageInfo;
}
-XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
+XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, VK_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
{
- XGL_RESULT err = XGL_SUCCESS;
+ VK_RESULT err = VK_SUCCESS;
std::vector<unsigned int> spv;
- XGL_SHADER_CREATE_INFO createInfo;
+ VK_SHADER_CREATE_INFO createInfo;
size_t shader_len;
m_stage = stage;
m_device = device;
- createInfo.sType = XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO;
+ createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
createInfo.pNext = NULL;
if (!framework->m_use_spv) {
@@ -949,7 +949,7 @@
createInfo.pCode = malloc(createInfo.codeSize);
createInfo.flags = 0;
- /* try version 0 first: XGL_PIPELINE_SHADER_STAGE followed by GLSL */
+ /* try version 0 first: VK_PIPELINE_SHADER_STAGE followed by GLSL */
((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC;
((uint32_t *) createInfo.pCode)[1] = 0;
((uint32_t *) createInfo.pCode)[2] = stage;
@@ -960,7 +960,7 @@
if (framework->m_use_spv || err) {
std::vector<unsigned int> spv;
- err = XGL_SUCCESS;
+ err = VK_SUCCESS;
// Use Reference GLSL to SPV compiler
framework->GLSLtoSPV(stage, shader_code, spv);
@@ -978,55 +978,55 @@
m_vi_state.attributeCount = m_vi_state.bindingCount = 0;
m_vertexBufferCount = 0;
- m_ia_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
- m_ia_state.pNext = XGL_NULL_HANDLE;
- m_ia_state.topology = XGL_TOPOLOGY_TRIANGLE_LIST;
- m_ia_state.disableVertexReuse = XGL_FALSE;
- m_ia_state.primitiveRestartEnable = XGL_FALSE;
+ m_ia_state.sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
+ m_ia_state.pNext = VK_NULL_HANDLE;
+ m_ia_state.topology = VK_TOPOLOGY_TRIANGLE_LIST;
+ m_ia_state.disableVertexReuse = VK_FALSE;
+ m_ia_state.primitiveRestartEnable = VK_FALSE;
m_ia_state.primitiveRestartIndex = 0;
- m_rs_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
+ m_rs_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
m_rs_state.pNext = &m_ia_state;
- m_rs_state.depthClipEnable = XGL_FALSE;
- m_rs_state.rasterizerDiscardEnable = XGL_FALSE;
- m_rs_state.programPointSize = XGL_FALSE;
- m_rs_state.pointOrigin = XGL_COORDINATE_ORIGIN_UPPER_LEFT;
- m_rs_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
- m_rs_state.fillMode = XGL_FILL_SOLID;
- m_rs_state.cullMode = XGL_CULL_NONE;
- m_rs_state.frontFace = XGL_FRONT_FACE_CCW;
+ m_rs_state.depthClipEnable = VK_FALSE;
+ m_rs_state.rasterizerDiscardEnable = VK_FALSE;
+ m_rs_state.programPointSize = VK_FALSE;
+ m_rs_state.pointOrigin = VK_COORDINATE_ORIGIN_UPPER_LEFT;
+ m_rs_state.provokingVertex = VK_PROVOKING_VERTEX_LAST;
+ m_rs_state.fillMode = VK_FILL_SOLID;
+ m_rs_state.cullMode = VK_CULL_NONE;
+ m_rs_state.frontFace = VK_FRONT_FACE_CCW;
memset(&m_cb_state,0,sizeof(m_cb_state));
- m_cb_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
+ m_cb_state.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
m_cb_state.pNext = &m_rs_state;
- m_cb_state.alphaToCoverageEnable = XGL_FALSE;
- m_cb_state.logicOp = XGL_LOGIC_OP_COPY;
+ m_cb_state.alphaToCoverageEnable = VK_FALSE;
+ m_cb_state.logicOp = VK_LOGIC_OP_COPY;
m_ms_state.pNext = &m_cb_state;
- m_ms_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
- m_ms_state.multisampleEnable = XGL_FALSE;
+ m_ms_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
+ m_ms_state.multisampleEnable = VK_FALSE;
m_ms_state.sampleMask = 1; // Do we have to specify MSAA even just to disable it?
m_ms_state.samples = 1;
m_ms_state.minSampleShading = 0;
m_ms_state.sampleShadingEnable = 0;
- m_ds_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
+ m_ds_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
m_ds_state.pNext = &m_ms_state,
- m_ds_state.format = XGL_FMT_D32_SFLOAT;
- m_ds_state.depthTestEnable = XGL_FALSE;
- m_ds_state.depthWriteEnable = XGL_FALSE;
- m_ds_state.depthBoundsEnable = XGL_FALSE;
- m_ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
- m_ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
- m_ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
- m_ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
- m_ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
- m_ds_state.stencilTestEnable = XGL_FALSE;
+ m_ds_state.format = VK_FMT_D32_SFLOAT;
+ m_ds_state.depthTestEnable = VK_FALSE;
+ m_ds_state.depthWriteEnable = VK_FALSE;
+ m_ds_state.depthBoundsEnable = VK_FALSE;
+ m_ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+ m_ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
+ m_ds_state.stencilTestEnable = VK_FALSE;
m_ds_state.front = m_ds_state.back;
- XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
- att.blendEnable = XGL_FALSE;
- att.format = XGL_FMT_B8G8R8A8_UNORM;
+ VK_PIPELINE_CB_ATTACHMENT_STATE att = {};
+ att.blendEnable = VK_FALSE;
+ att.format = VK_FMT_B8G8R8A8_UNORM;
att.channelWriteMask = 0xf;
AddColorAttachment(0, &att);
@@ -1037,13 +1037,13 @@
m_shaderObjs.push_back(shader);
}
-void XglPipelineObj::AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
+void XglPipelineObj::AddVertexInputAttribs(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
{
m_vi_state.pVertexAttributeDescriptions = vi_attrib;
m_vi_state.attributeCount = count;
}
-void XglPipelineObj::AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
+void XglPipelineObj::AddVertexInputBindings(VK_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
{
m_vi_state.pVertexBindingDescriptions = vi_binding;
m_vi_state.bindingCount = count;
@@ -1056,7 +1056,7 @@
m_vertexBufferCount++;
}
-void XglPipelineObj::AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
+void XglPipelineObj::AddColorAttachment(uint32_t binding, const VK_PIPELINE_CB_ATTACHMENT_STATE *att)
{
if (binding+1 > m_colorAttachments.size())
{
@@ -1065,7 +1065,7 @@
m_colorAttachments[binding] = *att;
}
-void XglPipelineObj::SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
+void XglPipelineObj::SetDepthStencil(VK_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
{
m_ds_state.format = ds_state->format;
m_ds_state.depthTestEnable = ds_state->depthTestEnable;
@@ -1077,12 +1077,12 @@
m_ds_state.front = ds_state->front;
}
-void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj &descriptorSet)
+void XglPipelineObj::CreateVKPipeline(XglDescriptorSetObj &descriptorSet)
{
void* head_ptr = &m_ds_state;
- XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
+ VK_GRAPHICS_PIPELINE_CREATE_INFO info = {};
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
+ VK_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
for (int i=0; i<m_shaderObjs.size(); i++)
{
@@ -1093,12 +1093,12 @@
if (m_vi_state.attributeCount && m_vi_state.bindingCount)
{
- m_vi_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
+ m_vi_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
m_vi_state.pNext = head_ptr;
head_ptr = &m_vi_state;
}
- info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+ info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
info.pNext = head_ptr;
info.flags = 0;
info.pSetLayoutChain = descriptorSet.GetLayoutChain();
@@ -1109,9 +1109,9 @@
init(*m_device, info);
}
-vector<XGL_GPU_MEMORY> XglMemoryRefManager::mem_refs() const
+vector<VK_GPU_MEMORY> XglMemoryRefManager::mem_refs() const
{
- std::vector<XGL_GPU_MEMORY> mems;
+ std::vector<VK_GPU_MEMORY> mems;
if (this->mem_refs_.size()) {
mems.reserve(this->mem_refs_.size());
for (uint32_t i = 0; i < this->mem_refs_.size(); i++)
@@ -1121,13 +1121,13 @@
return mems;
}
-void XglMemoryRefManager::AddMemoryRefs(xgl_testing::Object &xglObject)
+void XglMemoryRefManager::AddMemoryRefs(vk_testing::Object &vkObject)
{
- const std::vector<XGL_GPU_MEMORY> mems = xglObject.memories();
+ const std::vector<VK_GPU_MEMORY> mems = vkObject.memories();
AddMemoryRefs(mems);
}
-void XglMemoryRefManager::AddMemoryRefs(vector<XGL_GPU_MEMORY> mem)
+void XglMemoryRefManager::AddMemoryRefs(vector<VK_GPU_MEMORY> mem)
{
for (size_t i = 0; i < mem.size(); i++) {
if (mem[i] != NULL) {
@@ -1136,105 +1136,105 @@
}
}
-void XglMemoryRefManager::EmitAddMemoryRefs(XGL_QUEUE queue)
+void XglMemoryRefManager::EmitAddMemoryRefs(VK_QUEUE queue)
{
for (uint32_t i = 0; i < mem_refs_.size(); i++) {
- xglQueueAddMemReference(queue, mem_refs_[i]);
+ vkQueueAddMemReference(queue, mem_refs_[i]);
}
}
-void XglMemoryRefManager::EmitRemoveMemoryRefs(XGL_QUEUE queue)
+void XglMemoryRefManager::EmitRemoveMemoryRefs(VK_QUEUE queue)
{
for (uint32_t i = 0; i < mem_refs_.size(); i++) {
- xglQueueRemoveMemReference(queue, mem_refs_[i]);
+ vkQueueRemoveMemReference(queue, mem_refs_[i]);
}
}
XglCommandBufferObj::XglCommandBufferObj(XglDevice *device)
- : xgl_testing::CmdBuffer(*device, xgl_testing::CmdBuffer::create_info(device->graphics_queue_node_index_))
+ : vk_testing::CmdBuffer(*device, vk_testing::CmdBuffer::create_info(device->graphics_queue_node_index_))
{
m_device = device;
}
-XGL_CMD_BUFFER XglCommandBufferObj::GetBufferHandle()
+VK_CMD_BUFFER XglCommandBufferObj::GetBufferHandle()
{
return obj();
}
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo)
+VK_RESULT XglCommandBufferObj::BeginCommandBuffer(VK_CMD_BUFFER_BEGIN_INFO *pInfo)
{
begin(pInfo);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj)
+VK_RESULT XglCommandBufferObj::BeginCommandBuffer(VK_RENDER_PASS renderpass_obj, VK_FRAMEBUFFER framebuffer_obj)
{
begin(renderpass_obj, framebuffer_obj);
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer()
+VK_RESULT XglCommandBufferObj::BeginCommandBuffer()
{
begin();
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-XGL_RESULT XglCommandBufferObj::EndCommandBuffer()
+VK_RESULT XglCommandBufferObj::EndCommandBuffer()
{
end();
- return XGL_SUCCESS;
+ return VK_SUCCESS;
}
-void XglCommandBufferObj::PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr)
+void XglCommandBufferObj::PipelineBarrier(VK_PIPELINE_BARRIER *barrierPtr)
{
- xglCmdPipelineBarrier(obj(), barrierPtr);
+ vkCmdPipelineBarrier(obj(), barrierPtr);
}
-void XglCommandBufferObj::ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
+void XglCommandBufferObj::ClearAllBuffers(VK_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color,
XglDepthStencilObj *depthStencilObj)
{
uint32_t i;
- const XGL_FLAGS output_mask =
- XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
- XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
- XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_COPY_BIT;
- const XGL_FLAGS input_mask = 0;
+ const VK_FLAGS output_mask =
+ VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_COPY_BIT;
+ const VK_FLAGS input_mask = 0;
// whatever we want to do, we do it to the whole buffer
- XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
- srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+ VK_IMAGE_SUBRESOURCE_RANGE srRange = {};
+ srRange.aspect = VK_IMAGE_ASPECT_COLOR;
srRange.baseMipLevel = 0;
- srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
+ srRange.mipLevels = VK_LAST_MIP_OR_SLICE;
srRange.baseArraySlice = 0;
- srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
+ srRange.arraySize = VK_LAST_MIP_OR_SLICE;
- XGL_IMAGE_MEMORY_BARRIER memory_barrier = {};
- memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+ VK_IMAGE_MEMORY_BARRIER memory_barrier = {};
+ memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
memory_barrier.outputMask = output_mask;
memory_barrier.inputMask = input_mask;
- memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
+ memory_barrier.newLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
memory_barrier.subresourceRange = srRange;
- XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+ VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
- XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- XGL_PIPELINE_BARRIER pipeline_barrier = {};
- pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+ VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+ VK_PIPELINE_BARRIER pipeline_barrier = {};
+ pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
pipeline_barrier.eventCount = 1;
pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+ pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
pipeline_barrier.memBarrierCount = 1;
pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
for (i = 0; i < m_renderTargets.size(); i++) {
memory_barrier.image = m_renderTargets[i]->image();
memory_barrier.oldLayout = m_renderTargets[i]->layout();
- xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), &pipeline_barrier);
m_renderTargets[i]->layout(memory_barrier.newLayout);
- xglCmdClearColorImage(obj(),
- m_renderTargets[i]->image(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+ vkCmdClearColorImage(obj(),
+ m_renderTargets[i]->image(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
clear_color, 1, &srRange );
mem_ref_mgr.AddMemoryRefs(*m_renderTargets[i]);
@@ -1242,78 +1242,78 @@
if (depthStencilObj)
{
- XGL_IMAGE_SUBRESOURCE_RANGE dsRange = {};
- dsRange.aspect = XGL_IMAGE_ASPECT_DEPTH;
+ VK_IMAGE_SUBRESOURCE_RANGE dsRange = {};
+ dsRange.aspect = VK_IMAGE_ASPECT_DEPTH;
dsRange.baseMipLevel = 0;
- dsRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
+ dsRange.mipLevels = VK_LAST_MIP_OR_SLICE;
dsRange.baseArraySlice = 0;
- dsRange.arraySize = XGL_LAST_MIP_OR_SLICE;
+ dsRange.arraySize = VK_LAST_MIP_OR_SLICE;
// prepare the depth buffer for clear
memory_barrier.oldLayout = depthStencilObj->BindInfo()->layout;
- memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
+ memory_barrier.newLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
memory_barrier.image = depthStencilObj->obj();
memory_barrier.subresourceRange = dsRange;
- xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), &pipeline_barrier);
- xglCmdClearDepthStencil(obj(),
- depthStencilObj->obj(), XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
+ vkCmdClearDepthStencil(obj(),
+ depthStencilObj->obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
depth_clear_color, stencil_clear_color,
1, &dsRange);
mem_ref_mgr.AddMemoryRefs(*depthStencilObj);
// prepare depth buffer for rendering
memory_barrier.image = depthStencilObj->obj();
- memory_barrier.oldLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
+ memory_barrier.oldLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
memory_barrier.newLayout = depthStencilObj->BindInfo()->layout;
memory_barrier.subresourceRange = dsRange;
- xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), &pipeline_barrier);
}
}
void XglCommandBufferObj::PrepareAttachments()
{
uint32_t i;
- const XGL_FLAGS output_mask =
- XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
- XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
- XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_OUTPUT_COPY_BIT;
- const XGL_FLAGS input_mask =
- XGL_MEMORY_INPUT_CPU_READ_BIT |
- XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
- XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
- XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
- XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
- XGL_MEMORY_INPUT_SHADER_READ_BIT |
- XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
- XGL_MEMORY_INPUT_COPY_BIT;
+ const VK_FLAGS output_mask =
+ VK_MEMORY_OUTPUT_CPU_WRITE_BIT |
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT |
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_OUTPUT_COPY_BIT;
+ const VK_FLAGS input_mask =
+ VK_MEMORY_INPUT_CPU_READ_BIT |
+ VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
+ VK_MEMORY_INPUT_INDEX_FETCH_BIT |
+ VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
+ VK_MEMORY_INPUT_UNIFORM_READ_BIT |
+ VK_MEMORY_INPUT_SHADER_READ_BIT |
+ VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_MEMORY_INPUT_COPY_BIT;
- XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
- srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
+ VK_IMAGE_SUBRESOURCE_RANGE srRange = {};
+ srRange.aspect = VK_IMAGE_ASPECT_COLOR;
srRange.baseMipLevel = 0;
- srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
+ srRange.mipLevels = VK_LAST_MIP_OR_SLICE;
srRange.baseArraySlice = 0;
- srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
+ srRange.arraySize = VK_LAST_MIP_OR_SLICE;
- XGL_IMAGE_MEMORY_BARRIER memory_barrier = {};
- memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+ VK_IMAGE_MEMORY_BARRIER memory_barrier = {};
+ memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
memory_barrier.outputMask = output_mask;
memory_barrier.inputMask = input_mask;
- memory_barrier.newLayout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ memory_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
memory_barrier.subresourceRange = srRange;
- XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
+ VK_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
- XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- XGL_PIPELINE_BARRIER pipeline_barrier = {};
- pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
+ VK_PIPE_EVENT set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
+ VK_PIPELINE_BARRIER pipeline_barrier = {};
+ pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
pipeline_barrier.eventCount = 1;
pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
+ pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
pipeline_barrier.memBarrierCount = 1;
pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
@@ -1321,29 +1321,29 @@
{
memory_barrier.image = m_renderTargets[i]->image();
memory_barrier.oldLayout = m_renderTargets[i]->layout();
- xglCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), &pipeline_barrier);
m_renderTargets[i]->layout(memory_barrier.newLayout);
}
}
-void XglCommandBufferObj::BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer)
+void XglCommandBufferObj::BeginRenderPass(VK_RENDER_PASS renderpass, VK_FRAMEBUFFER framebuffer)
{
- XGL_RENDER_PASS_BEGIN rp_begin = {
+ VK_RENDER_PASS_BEGIN rp_begin = {
renderpass,
framebuffer,
};
- xglCmdBeginRenderPass( obj(), &rp_begin);
+ vkCmdBeginRenderPass( obj(), &rp_begin);
}
-void XglCommandBufferObj::EndRenderPass(XGL_RENDER_PASS renderpass)
+void XglCommandBufferObj::EndRenderPass(VK_RENDER_PASS renderpass)
{
- xglCmdEndRenderPass( obj(), renderpass);
+ vkCmdEndRenderPass( obj(), renderpass);
}
-void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject)
+void XglCommandBufferObj::BindStateObject(VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT stateObject)
{
- xglCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
+ vkCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
}
void XglCommandBufferObj::AddRenderTarget(XglImage *renderTarget)
@@ -1353,12 +1353,12 @@
void XglCommandBufferObj::DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
{
- xglCmdDrawIndexed(obj(), firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+ vkCmdDrawIndexed(obj(), firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
}
void XglCommandBufferObj::Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
{
- xglCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
+ vkCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
}
void XglCommandBufferObj::QueueCommandBuffer()
@@ -1366,21 +1366,21 @@
QueueCommandBuffer(NULL);
}
-void XglCommandBufferObj::QueueCommandBuffer(XGL_FENCE fence)
+void XglCommandBufferObj::QueueCommandBuffer(VK_FENCE fence)
{
- XGL_RESULT err = XGL_SUCCESS;
+ VK_RESULT err = VK_SUCCESS;
mem_ref_mgr.EmitAddMemoryRefs(m_device->m_queue);
// submit the command buffer to the universal queue
- err = xglQueueSubmit( m_device->m_queue, 1, &obj(), fence );
- ASSERT_XGL_SUCCESS( err );
+ err = vkQueueSubmit( m_device->m_queue, 1, &obj(), fence );
+ ASSERT_VK_SUCCESS( err );
- err = xglQueueWaitIdle( m_device->m_queue );
- ASSERT_XGL_SUCCESS( err );
+ err = vkQueueWaitIdle( m_device->m_queue );
+ ASSERT_VK_SUCCESS( err );
// Wait for work to finish before cleaning up.
- xglDeviceWaitIdle(m_device->device());
+ vkDeviceWaitIdle(m_device->device());
/*
* Now that processing on this command buffer is complete
@@ -1391,16 +1391,16 @@
void XglCommandBufferObj::BindPipeline(XglPipelineObj &pipeline)
{
- xglCmdBindPipeline( obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, pipeline.obj() );
+ vkCmdBindPipeline( obj(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.obj() );
mem_ref_mgr.AddMemoryRefs(pipeline);
}
void XglCommandBufferObj::BindDescriptorSet(XglDescriptorSetObj &descriptorSet)
{
- XGL_DESCRIPTOR_SET set_obj = descriptorSet.GetDescriptorSetHandle();
+ VK_DESCRIPTOR_SET set_obj = descriptorSet.GetDescriptorSetHandle();
// bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
- xglCmdBindDescriptorSets(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS,
+ vkCmdBindDescriptorSets(obj(), VK_PIPELINE_BIND_POINT_GRAPHICS,
descriptorSet.GetLayoutChain(), 0, 1, &set_obj, NULL );
// Add descriptor set mem refs to command buffer's list
@@ -1410,13 +1410,13 @@
void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset)
{
- xglCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
+ vkCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
mem_ref_mgr.AddMemoryRefs(*indexBuffer);
}
void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
{
- xglCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
+ vkCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
mem_ref_mgr.AddMemoryRefs(*vertexBuffer);
}
@@ -1429,23 +1429,23 @@
return m_initialized;
}
-XGL_DEPTH_STENCIL_BIND_INFO* XglDepthStencilObj::BindInfo()
+VK_DEPTH_STENCIL_BIND_INFO* XglDepthStencilObj::BindInfo()
{
return &m_depthStencilBindInfo;
}
void XglDepthStencilObj::Init(XglDevice *device, int32_t width, int32_t height)
{
- XGL_IMAGE_CREATE_INFO image_info;
- XGL_DEPTH_STENCIL_VIEW_CREATE_INFO view_info;
+ VK_IMAGE_CREATE_INFO image_info;
+ VK_DEPTH_STENCIL_VIEW_CREATE_INFO view_info;
m_device = device;
m_initialized = true;
- m_depth_stencil_fmt = XGL_FMT_D16_UNORM;
+ m_depth_stencil_fmt = VK_FMT_D16_UNORM;
- image_info.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+ image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = NULL;
- image_info.imageType = XGL_IMAGE_2D;
+ image_info.imageType = VK_IMAGE_2D;
image_info.format = m_depth_stencil_fmt;
image_info.extent.width = width;
image_info.extent.height = height;
@@ -1453,14 +1453,14 @@
image_info.mipLevels = 1;
image_info.arraySize = 1;
image_info.samples = 1;
- image_info.tiling = XGL_OPTIMAL_TILING;
- image_info.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT;
+ image_info.tiling = VK_OPTIMAL_TILING;
+ image_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_BIT;
image_info.flags = 0;
init(*m_device, image_info);
- view_info.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO;
+ view_info.sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO;
view_info.pNext = NULL;
- view_info.image = XGL_NULL_HANDLE;
+ view_info.image = VK_NULL_HANDLE;
view_info.mipLevel = 0;
view_info.baseArraySlice = 0;
view_info.arraySize = 1;
@@ -1469,5 +1469,5 @@
m_depthStencilView.init(*m_device, view_info);
m_depthStencilBindInfo.view = m_depthStencilView.obj();
- m_depthStencilBindInfo.layout = XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+ m_depthStencilBindInfo.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
}