int vr_type::run(const draw_callback_type &draw_callback,
const event_callback_type &event_callback) {
vcc::command_pool::command_pool_type command_pool(
vcc::command_pool::create(vcc::internal::get_parent(*queue),
0, vcc::queue::get_family_index(*queue)));
vcc::command_buffer::command_buffer_type pre_draw_command_buffer(std::move(
vcc::command_buffer::allocate(vcc::internal::get_parent(*queue),
std::ref(command_pool), VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1)
.front())),
post_draw_command_buffer(std::move(vcc::command_buffer::allocate(
vcc::internal::get_parent(*queue), std::ref(command_pool),
VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1).front()));
vcc::command::compile(
vcc::command::build(std::ref(pre_draw_command_buffer), 0, VK_FALSE, 0, 0),
vcc::command::pipeline_barrier(
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, {},
{}, {
vcc::command::image_memory_barrier{ 0, 0,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_QUEUE_FAMILY_IGNORED,
vcc::queue::get_family_index(*queue),
std::ref(image),
{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }
}
}));
vcc::command::compile(
vcc::command::build(std::ref(post_draw_command_buffer), 0, VK_FALSE, 0, 0),
vcc::command::pipeline_barrier(
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, {},
{
vcc::command::image_memory_barrier{ 0, 0,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_QUEUE_FAMILY_IGNORED,
VK_QUEUE_FAMILY_IGNORED,
std::ref(image),
{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }
}
}));
std::array<vr::TrackedDevicePose_t, vr::k_unMaxTrackedDeviceCount>
trackedDevicePose;
std::array<glm::mat4x3, vr::k_unMaxTrackedDeviceCount> mat4DevicePose;
std::array<bool, vr::k_unMaxTrackedDeviceCount> bPoseIsValid;
for (;;) {
vr::VREvent_t event;
while (hmd.hmd->PollNextEvent(&event, sizeof(event))) {
event_callback(event);
}
for (vr::TrackedDeviceIndex_t unDevice = 0;
unDevice < vr::k_unMaxTrackedDeviceCount; unDevice++) {
vr::VRControllerState_t state;
if (hmd.hmd->GetControllerState(unDevice, &state, sizeof(vr::VRControllerState_t))) {
//m_rbShowTrackedDevice[unDevice] = state.ulButtonPressed == 0;
}
}
vr::IVRCompositor *compositor(vr::VRCompositor());
compositor->WaitGetPoses(trackedDevicePose.data(),
vr::k_unMaxTrackedDeviceCount, NULL, 0);
for (int nDevice = 0; nDevice < vr::k_unMaxTrackedDeviceCount; ++nDevice) {
bPoseIsValid[nDevice] = trackedDevicePose[nDevice].bPoseIsValid;
if (bPoseIsValid[nDevice]) {
mat4DevicePose[nDevice] = convert(
trackedDevicePose[nDevice].mDeviceToAbsoluteTracking);
}
}
type::supplier<const vcc::device::device_type> device(
vcc::internal::get_parent(*queue));
vcc::queue::submit(*queue, { }, { pre_draw_command_buffer }, {});
draw_callback(mat4DevicePose);
vcc::queue::submit(*queue, {}, { post_draw_command_buffer }, { });
vr::VRVulkanTextureData_t texture_data{
uint64_t(VkImage(vcc::internal::get_instance(image))),
vcc::internal::get_instance(*device),
vcc::device::get_physical_device(*device),
vcc::internal::get_instance(*instance),
vcc::internal::get_instance(*queue),
vcc::queue::get_family_index(*queue),
extent.width, extent.height, VK_FORMAT_R8G8B8A8_UNORM, 1
};
const vr::Texture_t texdesc = { (void*)&texture_data,
vr::TextureType_Vulkan, vr::ColorSpace_Gamma };
{
const vr::VRTextureBounds_t bounds = { 0.f, 0.f, .5f, 1.f };
vr::EVRCompositorError error(compositor->Submit(vr::Eye_Left, &texdesc, &bounds));
assert(error == vr::VRCompositorError_None);
}
{
const vr::VRTextureBounds_t bounds = { .5f, 0.f, 1.f, 1.f };
vr::EVRCompositorError error(compositor->Submit(vr::Eye_Right, &texdesc, &bounds));
assert(error == vr::VRCompositorError_None);
}
}
}
bool WrappedVulkan::ReleaseResource(WrappedVkRes *res)
{
if(res == NULL) return true;
// MULTIDEVICE need to get the actual device that created this object
VkDevice dev = GetDev();
const VkLayerDispatchTable *vt = ObjDisp(dev);
WrappedVkNonDispRes *nondisp = (WrappedVkNonDispRes *)res;
WrappedVkDispRes *disp = (WrappedVkDispRes *)res;
uint64_t handle = (uint64_t)nondisp;
switch(IdentifyTypeByPtr(res))
{
case eResSurface:
case eResSwapchain:
if(m_State >= WRITING)
RDCERR("Swapchain/swapchain object is leaking");
else
RDCERR("Should be no swapchain/surface objects created on replay");
break;
case eResUnknown:
RDCERR("Unknown resource type!");
break;
case eResCommandBuffer:
// special case here, on replay we don't have the tracking
// to remove these with the parent object so do it here.
// This ensures we clean up after ourselves with a well-
// behaved application.
if(m_State < WRITING)
GetResourceManager()->ReleaseWrappedResource((VkCommandBuffer)res);
break;
case eResDescriptorSet:
if(m_State < WRITING)
GetResourceManager()->ReleaseWrappedResource(VkDescriptorSet(handle));
break;
case eResPhysicalDevice:
if(m_State < WRITING)
GetResourceManager()->ReleaseWrappedResource((VkPhysicalDevice)disp);
break;
case eResQueue:
if(m_State < WRITING)
GetResourceManager()->ReleaseWrappedResource((VkQueue)disp);
break;
case eResDevice:
// these are explicitly released elsewhere, do not need to destroy
// any API objects.
// On replay though we do need to tidy up book-keeping for these.
if(m_State < WRITING)
{
GetResourceManager()->ReleaseCurrentResource(disp->id);
GetResourceManager()->RemoveWrapper(ToTypedHandle(disp->real.As<VkDevice>()));
}
break;
case eResInstance:
if(m_State < WRITING)
{
GetResourceManager()->ReleaseCurrentResource(disp->id);
GetResourceManager()->RemoveWrapper(ToTypedHandle(disp->real.As<VkInstance>()));
}
break;
case eResDeviceMemory:
{
VkDeviceMemory real = nondisp->real.As<VkDeviceMemory>();
GetResourceManager()->ReleaseWrappedResource(VkDeviceMemory(handle));
vt->FreeMemory(Unwrap(dev), real, NULL);
break;
}
case eResBuffer:
{
VkBuffer real = nondisp->real.As<VkBuffer>();
GetResourceManager()->ReleaseWrappedResource(VkBuffer(handle));
vt->DestroyBuffer(Unwrap(dev), real, NULL);
break;
}
case eResBufferView:
{
VkBufferView real = nondisp->real.As<VkBufferView>();
GetResourceManager()->ReleaseWrappedResource(VkBufferView(handle));
vt->DestroyBufferView(Unwrap(dev), real, NULL);
break;
}
case eResImage:
{
VkImage real = nondisp->real.As<VkImage>();
GetResourceManager()->ReleaseWrappedResource(VkImage(handle));
vt->DestroyImage(Unwrap(dev), real, NULL);
break;
}
case eResImageView:
{
VkImageView real = nondisp->real.As<VkImageView>();
GetResourceManager()->ReleaseWrappedResource(VkImageView(handle));
vt->DestroyImageView(Unwrap(dev), real, NULL);
break;
}
case eResFramebuffer:
{
VkFramebuffer real = nondisp->real.As<VkFramebuffer>();
GetResourceManager()->ReleaseWrappedResource(VkFramebuffer(handle));
vt->DestroyFramebuffer(Unwrap(dev), real, NULL);
break;
}
case eResRenderPass:
{
VkRenderPass real = nondisp->real.As<VkRenderPass>();
GetResourceManager()->ReleaseWrappedResource(VkRenderPass(handle));
vt->DestroyRenderPass(Unwrap(dev), real, NULL);
break;
}
case eResShaderModule:
{
VkShaderModule real = nondisp->real.As<VkShaderModule>();
GetResourceManager()->ReleaseWrappedResource(VkShaderModule(handle));
vt->DestroyShaderModule(Unwrap(dev), real, NULL);
break;
}
case eResPipelineCache:
{
VkPipelineCache real = nondisp->real.As<VkPipelineCache>();
GetResourceManager()->ReleaseWrappedResource(VkPipelineCache(handle));
vt->DestroyPipelineCache(Unwrap(dev), real, NULL);
break;
}
case eResPipelineLayout:
{
VkPipelineLayout real = nondisp->real.As<VkPipelineLayout>();
GetResourceManager()->ReleaseWrappedResource(VkPipelineLayout(handle));
vt->DestroyPipelineLayout(Unwrap(dev), real, NULL);
break;
}
case eResPipeline:
{
VkPipeline real = nondisp->real.As<VkPipeline>();
GetResourceManager()->ReleaseWrappedResource(VkPipeline(handle));
vt->DestroyPipeline(Unwrap(dev), real, NULL);
break;
}
case eResSampler:
{
VkSampler real = nondisp->real.As<VkSampler>();
GetResourceManager()->ReleaseWrappedResource(VkSampler(handle));
vt->DestroySampler(Unwrap(dev), real, NULL);
break;
}
case eResDescriptorPool:
{
VkDescriptorPool real = nondisp->real.As<VkDescriptorPool>();
GetResourceManager()->ReleaseWrappedResource(VkDescriptorPool(handle));
vt->DestroyDescriptorPool(Unwrap(dev), real, NULL);
break;
}
case eResDescriptorSetLayout:
{
VkDescriptorSetLayout real = nondisp->real.As<VkDescriptorSetLayout>();
GetResourceManager()->ReleaseWrappedResource(VkDescriptorSetLayout(handle));
vt->DestroyDescriptorSetLayout(Unwrap(dev), real, NULL);
break;
}
case eResCommandPool:
{
VkCommandPool real = nondisp->real.As<VkCommandPool>();
GetResourceManager()->ReleaseWrappedResource(VkCommandPool(handle));
vt->DestroyCommandPool(Unwrap(dev), real, NULL);
break;
}
case eResFence:
{
VkFence real = nondisp->real.As<VkFence>();
GetResourceManager()->ReleaseWrappedResource(VkFence(handle));
vt->DestroyFence(Unwrap(dev), real, NULL);
break;
}
case eResEvent:
{
VkEvent real = nondisp->real.As<VkEvent>();
GetResourceManager()->ReleaseWrappedResource(VkEvent(handle));
vt->DestroyEvent(Unwrap(dev), real, NULL);
break;
}
case eResQueryPool:
{
VkQueryPool real = nondisp->real.As<VkQueryPool>();
GetResourceManager()->ReleaseWrappedResource(VkQueryPool(handle));
vt->DestroyQueryPool(Unwrap(dev), real, NULL);
break;
}
case eResSemaphore:
{
VkSemaphore real = nondisp->real.As<VkSemaphore>();
GetResourceManager()->ReleaseWrappedResource(VkSemaphore(handle));
vt->DestroySemaphore(Unwrap(dev), real, NULL);
break;
}
}
return true;
}
