libretro/RetroArch
1
0 Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2026-11-07 08:36:02 -10:00
Code Issues Packages Projects Releases 1 Wiki Activity

openxr: explicit initialization of fixed-ABI structs in place of memset

Browse Source 
The runtime, session, swapchain, frame, tracking and host structs, the graphics bindings and requirements, the swapchain image arrays and the Vulkan staging and submit infos of the cursor upload are set member by member; the event poll writes only the header of its 4000-byte buffer. CODING-GUIDELINES now has a query struct set only its chain when its outputs are read after the call's success is checked, and keeps the memset for structs with bit-fields or reserved members.
This commit is contained in:
LibretroAdmin authored and libretroadmin committed 2026-10-15 02:05:36 +02:00
1 parent 3f5382ed43
commit e363abc7fa
12 files changed
+200 -128
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

CODING-GUIDELINES
+10 -6
View File
@@ -240,15 +240,19 @@ program built against them.
- Write every member the struct has, zero or not, so nothing is left
undefined.
- A struct the API fills in (a query, a properties or a state struct)
needs only its chain (sType/type and pNext/next, or the size member)
and each member the code reads back.
needs only its chain (sType/type and pNext/next, or the size member).
The API defines its outputs once the call succeeds; a member read
without that check, or after a call that returns nothing, is set
too.
- Of a union, write the member that is in use in full; a view
description sets the member its dimension selects.
- Keep the memset for the tree's own structs, which can still grow,
and for structs whose member names differ between the SDKs or C
- Keep the memset for the tree's own structs, which can still grow;
for structs whose member names differ between the SDKs or C
libraries we build with (OVERLAPPED, struct input_event,
struct sigaction): a member store that compiles against one header
breaks the build against another.
struct sigaction), where a member store that compiles against one
header breaks the build against another; and for structs with
bit-fields or reserved members (the Vulkan Video Std* parameter
sets), which member stores cannot clear whole.
- Several statements replace one: give a single-statement if/else body
its braces when its memset becomes member stores.
gfx/common/openxr_binding_gl.c
+6 -3
View File
@@ -40,8 +40,8 @@ bool openxr_binding_gl_requirements(const openxr_runtime_t *rt,
RARCH_ERR("[OpenXR] The runtime lacks functions headset output needs.\n");
return false;
}
memset(&reqs, 0, sizeof(reqs));
reqs.type = XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR;
reqs.next = NULL;
if (XR_FAILED(res = get_reqs(rt->instance, rt->system, &reqs)))
{
RARCH_ERR("[OpenXR] xrGetOpenGLGraphicsRequirementsKHR failed (%d).\n",
@@ -87,9 +87,11 @@ XrResult openxr_binding_gl_images(void *user, XrSwapchain swapchain,
XrResult res;
XrSwapchainImageOpenGLKHR imgs[OPENXR_MAX_IMAGES];
openxr_gl_images_t *li = (openxr_gl_images_t*)user;
memset(imgs, 0, sizeof(imgs));
for (i = 0; i < OPENXR_MAX_IMAGES; i++)
{
imgs[i].type = XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR;
imgs[i].next = NULL;
}
res = li->sc->EnumerateSwapchainImages(swapchain, *count, count,
(XrSwapchainImageBaseHeader*)imgs);
for (i = 0; XR_SUCCEEDED(res) && i < *count; i++)
@@ -101,12 +103,12 @@ XrResult openxr_binding_gl_images(void *user, XrSwapchain swapchain,
const void *openxr_binding_gl_chain(openxr_gl_binding_t *binding,
const struct gfx_ctx_shared_context *ctx)
{
memset(binding, 0, sizeof(*binding));
switch (ctx->kind)
{
#ifdef HAVE_EGL
case GFX_CTX_SHARED_EGL:
binding->egl.type = XR_TYPE_GRAPHICS_BINDING_EGL_MNDX;
binding->egl.next = NULL;
binding->egl.getProcAddress =
(PFN_xrEglGetProcAddressMNDX)ctx->get_proc_address;
binding->egl.display = (EGLDisplay)ctx->display;
@@ -117,6 +119,7 @@ const void *openxr_binding_gl_chain(openxr_gl_binding_t *binding,
#ifdef HAVE_X11
case GFX_CTX_SHARED_GLX:
binding->glx.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR;
binding->glx.next = NULL;
binding->glx.xDisplay = (Display*)ctx->display;
binding->glx.visualid = (uint32_t)ctx->visual_id;
binding->glx.glxFBConfig = (GLXFBConfig)ctx->config;
gfx/common/openxr_binding_gles.c
+4 -2
View File
@@ -41,8 +41,8 @@ bool openxr_binding_gles_requirements(const openxr_runtime_t *rt)
RARCH_ERR("[OpenXR] The runtime lacks functions headset output needs.\n");
return false;
}
memset(&reqs, 0, sizeof(reqs));
reqs.type = XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR;
reqs.next = NULL;
if (XR_FAILED(res = get_reqs(rt->instance, rt->system, &reqs)))
{
RARCH_ERR("[OpenXR] xrGetOpenGLESGraphicsRequirementsKHR failed (%d).\n",
@@ -78,9 +78,11 @@ XrResult openxr_binding_gles_images(void *user, XrSwapchain swapchain,
XrResult res;
XrSwapchainImageOpenGLESKHR imgs[OPENXR_MAX_IMAGES];
openxr_gles_images_t *li = (openxr_gles_images_t*)user;
memset(imgs, 0, sizeof(imgs));
for (i = 0; i < OPENXR_MAX_IMAGES; i++)
{
imgs[i].type = XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR;
imgs[i].next = NULL;
}
res = li->sc->EnumerateSwapchainImages(swapchain, *count, count,
(XrSwapchainImageBaseHeader*)imgs);
for (i = 0; XR_SUCCEEDED(res) && i < *count; i++)
gfx/common/openxr_frame.c
+27 -18
View File
@@ -106,16 +106,17 @@ static void openxr_frame_measure(openxr_frame_t *f, XrTime time)
XrViewState vs;
XrView views[2];
memset(&li, 0, sizeof(li));
li.type = XR_TYPE_VIEW_LOCATE_INFO;
li.next = NULL;
li.viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
li.displayTime = time;
li.space = f->session->local_space;
memset(&vs, 0, sizeof(vs));
vs.type = XR_TYPE_VIEW_STATE;
memset(views, 0, sizeof(views));
vs.type = XR_TYPE_VIEW_STATE;
vs.next = NULL;
views[0].type = XR_TYPE_VIEW;
views[0].next = NULL;
views[1].type = XR_TYPE_VIEW;
views[1].next = NULL;
if ( XR_FAILED(f->session->LocateViews(f->session->session, &li,
&vs, 2, &n, views))
|| !n)
@@ -163,8 +164,11 @@ static unsigned openxr_frame_layers(openxr_frame_t *f,
|| !retro_atomic_load_acquire_int(&slot->content))
continue;
video_xr_compose(&f->screens.pose, &q->pose, &pose);
memset(l, 0, sizeof(*l));
l->type = XR_TYPE_COMPOSITION_LAYER_QUAD;
l->type = XR_TYPE_COMPOSITION_LAYER_QUAD;
l->next = NULL;
l->subImage.imageRect.offset.x = 0;
l->subImage.imageRect.offset.y = 0;
l->subImage.imageArrayIndex = 0;
/* The UI is drawn over transparent black: premultiplied. */
l->layerFlags = (q->kind == VIDEO_XR_QUAD_MENU)
? XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT : 0;
@@ -214,20 +218,24 @@ static bool openxr_frame_projection(openxr_frame_t *f,
return false;
for (eye = 0; eye < 2; eye++)
{
memset(&views[eye], 0, sizeof(views[eye]));
views[eye].type =
XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW;
views[eye].next = NULL;
views[eye].subImage.imageRect.offset.x = 0;
views[eye].subImage.imageRect.offset.y = 0;
views[eye].subImage.imageArrayIndex = 0;
views[eye].pose = p.pose[eye];
views[eye].fov = p.fov[eye];
views[eye].subImage.swapchain = slot->swapchains[eye];
views[eye].subImage.imageRect.extent.width = (int32_t)w;
views[eye].subImage.imageRect.extent.height = (int32_t)h;
}
memset(layer, 0, sizeof(*layer));
layer->type = XR_TYPE_COMPOSITION_LAYER_PROJECTION;
layer->space = f->session->track_space;
layer->viewCount = 2;
layer->views = views;
layer->type = XR_TYPE_COMPOSITION_LAYER_PROJECTION;
layer->next = NULL;
layer->layerFlags = 0;
layer->space = f->session->track_space;
layer->viewCount = 2;
layer->views = views;
return true;
}
@@ -239,8 +247,8 @@ static bool openxr_frame_head(openxr_frame_t *f, XrTime time,
XrSpaceLocationFlags valid = XR_SPACE_LOCATION_ORIENTATION_VALID_BIT
| XR_SPACE_LOCATION_POSITION_VALID_BIT;
memset(&loc, 0, sizeof(loc));
loc.type = XR_TYPE_SPACE_LOCATION;
loc.next = NULL;
if ( XR_FAILED(f->session->LocateSpace(f->session->view_space,
f->session->local_space, time, &loc))
|| (loc.locationFlags & valid) != valid)
@@ -395,10 +403,10 @@ static bool openxr_frame_wait_begin(openxr_frame_t *f,
XrFrameBeginInfo begin_info;
memset(b, 0, sizeof(*b));
memset(&wait_info, 0, sizeof(wait_info));
wait_info.type = XR_TYPE_FRAME_WAIT_INFO;
memset(&state, 0, sizeof(state));
state.type = XR_TYPE_FRAME_STATE;
wait_info.next = NULL;
state.type = XR_TYPE_FRAME_STATE;
state.next = NULL;
if (XR_FAILED(res = f->WaitFrame(f->session->session, &wait_info, &state)))
{
openxr_frame_error(f, "xrWaitFrame", res);
@@ -439,8 +447,8 @@ static bool openxr_frame_wait_begin(openxr_frame_t *f,
if (!f->inline_host)
openxr_frame_tick(f);
memset(&begin_info, 0, sizeof(begin_info));
begin_info.type = XR_TYPE_FRAME_BEGIN_INFO;
begin_info.next = NULL;
openxr_session_lock(f->session);
if (XR_FAILED(res = f->BeginFrame(f->session->session, &begin_info)))
{
@@ -492,8 +500,9 @@ static void openxr_frame_submit(openxr_frame_t *f,
const XrCompositionLayerBaseHeader *ptrs[1 + VIDEO_XR_MAX_QUADS
+ OPENXR_MAX_EXTRA_LAYERS];
memset(&end_info, 0, sizeof(end_info));
end_info.type = XR_TYPE_FRAME_END_INFO;
end_info.next = NULL;
end_info.layerCount = 0;
end_info.displayTime = b->display_time;
end_info.environmentBlendMode = f->rt->blend_mode;
if (!locked)
gfx/common/openxr_host.c
+10 -4
View File
@@ -306,15 +306,21 @@ static int openxr_host_track_in_stage(const openxr_host_t *h,
return -1;
if (time <= 0 || !h->session->track_space)
return 0;
memset(&rci, 0, sizeof(rci));
rci.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
rci.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE;
rci.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
rci.next = NULL;
rci.poseInReferenceSpace.orientation.x = 0.0f;
rci.poseInReferenceSpace.orientation.y = 0.0f;
rci.poseInReferenceSpace.orientation.z = 0.0f;
rci.poseInReferenceSpace.position.x = 0.0f;
rci.poseInReferenceSpace.position.y = 0.0f;
rci.poseInReferenceSpace.position.z = 0.0f;
rci.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE;
rci.poseInReferenceSpace.orientation.w = 1.0f;
if (XR_FAILED(h->session->CreateReferenceSpace(h->session->session,
&rci, &stage)))
return -1;
memset(&loc, 0, sizeof(loc));
loc.type = XR_TYPE_SPACE_LOCATION;
loc.next = NULL;
ok = XR_SUCCEEDED(h->session->LocateSpace(h->session->track_space,
stage, time, &loc))
&& (loc.locationFlags & valid) == valid;
gfx/common/openxr_runtime.c
+12 -7
View File
@@ -148,9 +148,13 @@ enum openxr_runtime_result openxr_runtime_create_instance(
rt->platform.instance_ext))
exts[num_exts++] = rt->platform.instance_ext;
memset(&ici, 0, sizeof(ici));
ici.type = XR_TYPE_INSTANCE_CREATE_INFO;
ici.next = rt->platform.instance_next;
ici.type = XR_TYPE_INSTANCE_CREATE_INFO;
ici.createFlags = 0;
ici.applicationInfo.applicationVersion = 0;
ici.applicationInfo.engineVersion = 0;
ici.enabledApiLayerCount = 0;
ici.enabledApiLayerNames = NULL;
ici.next = rt->platform.instance_next;
strlcpy(ici.applicationInfo.applicationName, "RetroArch",
sizeof(ici.applicationInfo.applicationName));
strlcpy(ici.applicationInfo.engineName, "RetroArch",
@@ -204,8 +208,8 @@ enum openxr_runtime_result openxr_runtime_find_system(openxr_runtime_t *rt)
return OPENXR_RUNTIME_FAILED;
}
memset(&sgi, 0, sizeof(sgi));
sgi.type = XR_TYPE_SYSTEM_GET_INFO;
sgi.next = NULL;
sgi.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
if (XR_FAILED(res = get_system(rt->instance, &sgi, &rt->system)))
{
@@ -215,8 +219,8 @@ enum openxr_runtime_result openxr_runtime_find_system(openxr_runtime_t *rt)
rt->max_dim = 4096;
rt->max_layers = XR_MIN_COMPOSITION_LAYERS_SUPPORTED;
memset(&props, 0, sizeof(props));
props.type = XR_TYPE_SYSTEM_PROPERTIES;
props.type = XR_TYPE_SYSTEM_PROPERTIES;
props.next = NULL;
if (XR_SUCCEEDED(get_system_properties(rt->instance, rt->system, &props)))
{
uint32_t mw = props.graphicsProperties.maxSwapchainImageWidth;
@@ -230,9 +234,10 @@ enum openxr_runtime_result openxr_runtime_find_system(openxr_runtime_t *rt)
RARCH_LOG("[OpenXR] Headset: %s.\n", props.systemName);
}
memset(views, 0, sizeof(views));
views[0].type = XR_TYPE_VIEW_CONFIGURATION_VIEW;
views[0].next = NULL;
views[1].type = XR_TYPE_VIEW_CONFIGURATION_VIEW;
views[1].next = NULL;
count = 0;
if ( XR_FAILED(enum_views(rt->instance, rt->system,
XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, 2, &count, views))
gfx/common/openxr_session.c
+21 -9
View File
@@ -84,8 +84,8 @@ static void openxr_session_state(openxr_session_t *s, XrSessionState state)
case XR_SESSION_STATE_READY:
{
XrSessionBeginInfo bi;
memset(&bi, 0, sizeof(bi));
bi.type = XR_TYPE_SESSION_BEGIN_INFO;
bi.next = NULL;
bi.primaryViewConfigurationType =
XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
openxr_session_lock(s);
@@ -122,8 +122,8 @@ void openxr_session_poll(openxr_session_t *s)
XrEventDataBuffer ev;
for (;;)
{
memset(&ev, 0, sizeof(ev));
ev.type = XR_TYPE_EVENT_DATA_BUFFER;
ev.next = NULL;
res = s->PollEvent(s->rt->instance, &ev);
if (res == XR_ERROR_INSTANCE_LOST)
openxr_session_end(s, true);
@@ -183,10 +183,10 @@ bool openxr_session_create(openxr_session_t *s, const void *graphics_binding)
XrSessionCreateInfo sci;
XrReferenceSpaceCreateInfo rci;
memset(&sci, 0, sizeof(sci));
sci.type = XR_TYPE_SESSION_CREATE_INFO;
sci.next = graphics_binding;
sci.systemId = s->rt->system;
sci.type = XR_TYPE_SESSION_CREATE_INFO;
sci.next = graphics_binding;
sci.createFlags = 0;
sci.systemId = s->rt->system;
if (XR_FAILED(res = s->CreateSession(s->rt->instance, &sci, &s->session)))
{
RARCH_ERR("[OpenXR] xrCreateSession failed (%d).\n", (int)res);
@@ -194,8 +194,14 @@ bool openxr_session_create(openxr_session_t *s, const void *graphics_binding)
return false;
}
memset(&rci, 0, sizeof(rci));
rci.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
rci.next = NULL;
rci.poseInReferenceSpace.orientation.x = 0.0f;
rci.poseInReferenceSpace.orientation.y = 0.0f;
rci.poseInReferenceSpace.orientation.z = 0.0f;
rci.poseInReferenceSpace.position.x = 0.0f;
rci.poseInReferenceSpace.position.y = 0.0f;
rci.poseInReferenceSpace.position.z = 0.0f;
rci.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
rci.poseInReferenceSpace.orientation.w = 1.0f;
if (XR_FAILED(res = s->CreateReferenceSpace(s->session, &rci,
@@ -254,8 +260,14 @@ bool openxr_session_swap_track_space(openxr_session_t *s,
if (!s->session)
return false;
memset(&rci, 0, sizeof(rci));
rci.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
rci.type = XR_TYPE_REFERENCE_SPACE_CREATE_INFO;
rci.next = NULL;
rci.poseInReferenceSpace.orientation.x = 0.0f;
rci.poseInReferenceSpace.orientation.y = 0.0f;
rci.poseInReferenceSpace.orientation.z = 0.0f;
rci.poseInReferenceSpace.position.x = 0.0f;
rci.poseInReferenceSpace.position.y = 0.0f;
rci.poseInReferenceSpace.position.z = 0.0f;
if (*space == RETRO_VR_REFERENCE_SPACE_STAGE)
{
rci.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE;
gfx/common/openxr_swapchain.c
+14 -12
View File
@@ -86,7 +86,6 @@ XrSwapchain openxr_swapchains_create_filled(openxr_swapchains_t *sc,
*step = NULL;
*code = 0;
memset(&ci, 0, sizeof(ci));
for (i = 0; i < num_formats && !found; i++)
if ((found = openxr_swapchains_supports(sc, formats[i])))
ci.format = formats[i];
@@ -96,6 +95,8 @@ XrSwapchain openxr_swapchains_create_filled(openxr_swapchains_t *sc,
return XR_NULL_HANDLE;
}
ci.type = XR_TYPE_SWAPCHAIN_CREATE_INFO;
ci.next = NULL;
ci.createFlags = 0;
ci.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT
| XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT;
ci.sampleCount = 1;
@@ -104,11 +105,11 @@ XrSwapchain openxr_swapchains_create_filled(openxr_swapchains_t *sc,
ci.faceCount = 1;
ci.arraySize = 1;
ci.mipCount = 1;
memset(&ai, 0, sizeof(ai));
ai.type = XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO;
memset(&wi, 0, sizeof(wi));
wi.type = XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO;
wi.timeout = 100000000; /* 100 ms: a fresh swapchain is free */
ai.type = XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO;
ai.next = NULL;
wi.type = XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO;
wi.next = NULL;
wi.timeout = 100000000; /* 100 ms: a fresh swapchain is free */
openxr_session_lock(sc->session);
res = sc->CreateSwapchain(sc->session->session, &ci, &chain);
@@ -134,8 +135,8 @@ XrSwapchain openxr_swapchains_create_filled(openxr_swapchains_t *sc,
}
if (!fill(fill_user, index, step, code))
goto fail;
memset(&ri, 0, sizeof(ri));
ri.type = XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO;
ri.next = NULL;
openxr_session_lock(sc->session);
res = sc->ReleaseSwapchainImage(chain, &ri);
openxr_session_unlock(sc->session);
@@ -190,8 +191,9 @@ bool openxr_slot_create(openxr_swapchains_t *sc, unsigned slot,
openxr_slot_t *s = &sc->slots[slot];
openxr_slot_destroy(sc, slot);
memset(&ci, 0, sizeof(ci));
ci.type = XR_TYPE_SWAPCHAIN_CREATE_INFO;
ci.next = NULL;
ci.createFlags = 0;
ci.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT
| XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT;
/* The chains' final passes write through a view in the window's
@@ -263,8 +265,8 @@ bool openxr_slot_acquire(openxr_swapchains_t *sc, unsigned slot,
if (!s->acquired[l])
{
XrSwapchainImageAcquireInfo ai;
memset(&ai, 0, sizeof(ai));
ai.type = XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO;
ai.next = NULL;
if (XR_FAILED(sc->AcquireSwapchainImage(s->swapchains[l], &ai,
&s->index[l])))
return false;
@@ -274,8 +276,8 @@ bool openxr_slot_acquire(openxr_swapchains_t *sc, unsigned slot,
if (!s->waited[l])
{
XrSwapchainImageWaitInfo wi;
memset(&wi, 0, sizeof(wi));
wi.type = XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO;
wi.type = XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO;
wi.next = NULL;
/* Never stall the core, nor the XR thread behind the queue lock:
* an image the compositor still reads is tried again next frame. */
wi.timeout = 0;
@@ -299,8 +301,8 @@ void openxr_slot_release(openxr_swapchains_t *sc, unsigned slot)
for (l = 0; l < s->layers; l++)
if (!s->acquired[l] || !s->waited[l])
return;
memset(&ri, 0, sizeof(ri));
ri.type = XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO;
ri.next = NULL;
for (l = 0; l < s->layers; l++)
{
if (XR_FAILED(sc->ReleaseSwapchainImage(s->swapchains[l], &ri)))
gfx/common/openxr_tracking.c
+6 -6
View File
@@ -48,24 +48,24 @@ bool openxr_tracking_sample(openxr_tracking_t *t, const openxr_session_t *s,
if (!s->session || !s->view_space || !base || time <= 0)
return false;
memset(&li, 0, sizeof(li));
li.type = XR_TYPE_VIEW_LOCATE_INFO;
li.next = NULL;
li.viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
li.displayTime = time;
li.space = base;
memset(&vs, 0, sizeof(vs));
vs.type = XR_TYPE_VIEW_STATE;
memset(t->views, 0, sizeof(t->views));
vs.type = XR_TYPE_VIEW_STATE;
vs.next = NULL;
t->views[0].type = XR_TYPE_VIEW;
t->views[0].next = NULL;
t->views[1].type = XR_TYPE_VIEW;
t->views[1].next = NULL;
if ( s->LocateViews(s->session, &li, &vs, 2, &n, t->views) != XR_SUCCESS
|| n != 2
|| !(vs.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT))
return false;
memset(&vel, 0, sizeof(vel));
vel.type = XR_TYPE_SPACE_VELOCITY;
memset(&loc, 0, sizeof(loc));
vel.next = NULL;
loc.type = XR_TYPE_SPACE_LOCATION;
loc.next = &vel;
if ( s->LocateSpace(s->view_space, base, time, &loc) != XR_SUCCESS
gfx/common/vulkan_openxr.c
+71 -45
View File
@@ -292,8 +292,8 @@ vulkan_openxr_t *vulkan_openxr_new(bool enable1, uint32_t api_version)
goto end;
/* The runtime must be asked before any Vulkan object is made. */
memset(&reqs, 0, sizeof(reqs));
reqs.type = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR;
reqs.next = NULL;
res = enable1
? xr->GetVulkanGraphicsRequirementsKHR(xr->rt.instance, xr->rt.system, &reqs)
: xr->GetVulkanGraphicsRequirements2KHR(xr->rt.instance, xr->rt.system, &reqs);
@@ -414,8 +414,10 @@ VkResult vulkan_openxr_create_instance(vulkan_openxr_t *xr,
XrVulkanInstanceCreateInfoKHR ci;
VkResult vk_res = VK_ERROR_INITIALIZATION_FAILED;
memset(&ci, 0, sizeof(ci));
ci.type = XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR;
ci.next = NULL;
ci.createFlags = 0;
ci.vulkanAllocator = NULL;
ci.systemId = xr->rt.system;
ci.pfnGetInstanceProcAddr = gipa;
ci.vulkanCreateInfo = info;
@@ -438,8 +440,10 @@ VkResult vulkan_openxr_create_device(vulkan_openxr_t *xr,
XrVulkanDeviceCreateInfoKHR ci;
VkResult vk_res = VK_ERROR_INITIALIZATION_FAILED;
memset(&ci, 0, sizeof(ci));
ci.type = XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR;
ci.next = NULL;
ci.createFlags = 0;
ci.vulkanAllocator = NULL;
ci.systemId = xr->rt.system;
ci.pfnGetInstanceProcAddr = gipa;
ci.vulkanPhysicalDevice = gpu;
@@ -463,8 +467,8 @@ VkPhysicalDevice vulkan_openxr_gpu(vulkan_openxr_t *xr, VkInstance instance)
if (xr->enable2)
{
XrVulkanGraphicsDeviceGetInfoKHR gi;
memset(&gi, 0, sizeof(gi));
gi.type = XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR;
gi.next = NULL;
gi.systemId = xr->rt.system;
gi.vulkanInstance = instance;
res = xr->GetVulkanGraphicsDevice2KHR(xr->rt.instance, &gi, &gpu);
@@ -494,8 +498,8 @@ static bool vulkan_openxr_create_session(vulkan_openxr_t *xr,
return false;
}
memset(&binding, 0, sizeof(binding));
binding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR;
binding.next = NULL;
binding.instance = instance;
binding.physicalDevice = gpu;
binding.device = device;
@@ -526,9 +530,11 @@ static XrResult vulkan_openxr_list_images(void *user, XrSwapchain swapchain,
XrResult res;
XrSwapchainImageVulkanKHR imgs[OPENXR_MAX_IMAGES];
struct vulkan_openxr_images *li = (struct vulkan_openxr_images*)user;
memset(imgs, 0, sizeof(imgs));
for (i = 0; i < OPENXR_MAX_IMAGES; i++)
{
imgs[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR;
imgs[i].next = NULL;
}
res = li->xr->sc.EnumerateSwapchainImages(swapchain, *count, count,
(XrSwapchainImageBaseHeader*)imgs);
for (i = 0; XR_SUCCEEDED(res) && i < *count; i++)
@@ -578,11 +584,14 @@ static bool vulkan_openxr_cursor_fill(void *user, uint32_t index,
VkSubmitInfo si;
vkGetDeviceQueue(device, dot->queue_family, 0, &queue);
memset(&bi, 0, sizeof(bi));
bi.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bi.size = size;
bi.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
bi.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
bi.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bi.pNext = NULL;
bi.flags = 0;
bi.queueFamilyIndexCount = 0;
bi.pQueueFamilyIndices = NULL;
bi.size = size;
bi.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
bi.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
if (vkCreateBuffer(device, &bi, NULL, &buffer) != VK_SUCCESS)
{
failed = "vkCreateBuffer";
@@ -594,8 +603,8 @@ static bool vulkan_openxr_cursor_fill(void *user, uint32_t index,
if ( (req.memoryTypeBits & (1u << i))
&& (props.memoryTypes[i].propertyFlags & host) == host)
break;
memset(&mi, 0, sizeof(mi));
mi.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mi.pNext = NULL;
mi.allocationSize = req.size;
mi.memoryTypeIndex = i;
if ( i == props.memoryTypeCount
@@ -609,15 +618,17 @@ static bool vulkan_openxr_cursor_fill(void *user, uint32_t index,
video_xr_cursor_pixels((uint8_t*)map);
vkUnmapMemory(device, memory);
memset(&pi, 0, sizeof(pi));
pi.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
pi.queueFamilyIndex = dot->queue_family;
memset(&cai, 0, sizeof(cai));
cai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
pi.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
pi.pNext = NULL;
pi.flags = 0;
pi.queueFamilyIndex = dot->queue_family;
cai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cai.pNext = NULL;
cai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cai.commandBufferCount = 1;
memset(&fi, 0, sizeof(fi));
fi.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fi.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fi.pNext = NULL;
fi.flags = 0;
if (vkCreateCommandPool(device, &pi, NULL, &pool) != VK_SUCCESS)
{
failed = "command pool";
@@ -631,30 +642,40 @@ static bool vulkan_openxr_cursor_fill(void *user, uint32_t index,
goto end;
}
memset(&cbi, 0, sizeof(cbi));
cbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
cbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cbi.pNext = NULL;
cbi.pInheritanceInfo = NULL;
cbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(cmd, &cbi);
memset(&b, 0, sizeof(b));
b.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
b.srcAccessMask = 0;
b.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
b.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.image = dot->images[index][0];
b.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
b.subresourceRange.levelCount = 1;
b.subresourceRange.layerCount = 1;
b.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
b.pNext = NULL;
b.subresourceRange.baseMipLevel = 0;
b.subresourceRange.baseArrayLayer = 0;
b.srcAccessMask = 0;
b.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
b.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.image = dot->images[index][0];
b.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
b.subresourceRange.levelCount = 1;
b.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &b);
memset(&region, 0, sizeof(region));
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.layerCount = 1;
region.imageExtent.width = VIDEO_XR_CURSOR_DIM;
region.imageExtent.height = VIDEO_XR_CURSOR_DIM;
region.imageExtent.depth = 1;
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageOffset.x = 0;
region.imageOffset.y = 0;
region.imageOffset.z = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.layerCount = 1;
region.imageExtent.width = VIDEO_XR_CURSOR_DIM;
region.imageExtent.height = VIDEO_XR_CURSOR_DIM;
region.imageExtent.depth = 1;
vkCmdCopyBufferToImage(cmd, buffer, dot->images[index][0],
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
/* The layout the runtime takes it back in. */
@@ -667,10 +688,15 @@ static bool vulkan_openxr_cursor_fill(void *user, uint32_t index,
1, &b);
vkEndCommandBuffer(cmd);
memset(&si, 0, sizeof(si));
si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
si.commandBufferCount = 1;
si.pCommandBuffers = &cmd;
si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
si.pNext = NULL;
si.waitSemaphoreCount = 0;
si.pWaitSemaphores = NULL;
si.pWaitDstStageMask = NULL;
si.signalSemaphoreCount = 0;
si.pSignalSemaphores = NULL;
si.commandBufferCount = 1;
si.pCommandBuffers = &cmd;
slock_lock(dot->xr->queue_lock);
vk_res = vkQueueSubmit(queue, 1, &si, fence);
slock_unlock(dot->xr->queue_lock);
gfx/drivers_context/android_vk_openxr_ctx.c
+18 -15
View File
@@ -129,28 +129,31 @@ static bool android_vk_openxr_window_create(android_vk_openxr_t *xr)
VkImageCreateInfo ici;
VkMemoryRequirements req;
VkMemoryAllocateInfo mai;
memset(&ici, 0, sizeof(ici));
ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
ici.imageType = VK_IMAGE_TYPE_2D;
ici.format = format;
ici.extent.width = w;
ici.extent.height = h;
ici.extent.depth = 1;
ici.mipLevels = 1;
ici.arrayLayers = 1;
ici.samples = VK_SAMPLE_COUNT_1_BIT;
ici.tiling = VK_IMAGE_TILING_OPTIMAL;
ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
ici.pNext = NULL;
ici.flags = 0;
ici.queueFamilyIndexCount = 0;
ici.pQueueFamilyIndices = NULL;
ici.imageType = VK_IMAGE_TYPE_2D;
ici.format = format;
ici.extent.width = w;
ici.extent.height = h;
ici.extent.depth = 1;
ici.mipLevels = 1;
ici.arrayLayers = 1;
ici.samples = VK_SAMPLE_COUNT_1_BIT;
ici.tiling = VK_IMAGE_TILING_OPTIMAL;
ici.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
| VK_IMAGE_USAGE_TRANSFER_SRC_BIT
| VK_IMAGE_USAGE_TRANSFER_DST_BIT;
ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
if (vkCreateImage(ctx->device, &ici, NULL, &xr->images[i])
!= VK_SUCCESS)
return false;
vkGetImageMemoryRequirements(ctx->device, xr->images[i], &req);
memset(&mai, 0, sizeof(mai));
mai.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mai.pNext = NULL;
mai.allocationSize = req.size;
mai.memoryTypeIndex = vulkan_find_memory_type_fallback(
&ctx->memory_properties, req.memoryTypeBits,
gfx/drivers_context/gl_android_openxr_ctx.c
+1 -1
View File
@@ -421,8 +421,8 @@ static bool gl_xr_start(gl_android_openxr_t *xr)
}
openxr_host_init(&xr->host, &xr->rt, &xr->session, &xr->frame);
memset(&binding, 0, sizeof(binding));
binding.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR;
binding.next = NULL;
binding.display = xr->egl_display;
binding.config = xr->egl_config;
binding.context = xr->egl_context;