virtualx-engine/thirdparty/openxr/src/loader/xr_generated_loader.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

701 lines
31 KiB
C++
Raw Normal View History

2023-07-11 09:13:16 +02:00
// Copyright (c) 2017-2023, The Khronos Group Inc.
// Copyright (c) 2017-2019 Valve Corporation
// Copyright (c) 2017-2019 LunarG, Inc.
// SPDX-License-Identifier: Apache-2.0 OR MIT
// *********** THIS FILE IS GENERATED - DO NOT EDIT ***********
// See loader_source_generator.py for modifications
// ************************************************************
2023-07-11 09:13:16 +02:00
// Copyright (c) 2017-2023, The Khronos Group Inc.
// Copyright (c) 2017-2019 Valve Corporation
// Copyright (c) 2017-2019 LunarG, Inc.
//
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Mark Young <marky@lunarg.com>
//
#include "xr_generated_loader.hpp"
#include "api_layer_interface.hpp"
#include "exception_handling.hpp"
#include "hex_and_handles.h"
#include "loader_instance.hpp"
#include "loader_logger.hpp"
#include "loader_platform.hpp"
#include "runtime_interface.hpp"
2023-09-30 13:01:45 +02:00
#include "xr_generated_dispatch_table_core.h"
#include "xr_dependencies.h"
#include <openxr/openxr.h>
#include <openxr/openxr_platform.h>
#include <cstring>
#include <memory>
#include <new>
#include <string>
#include <unordered_map>
// Automatically generated instance trampolines and terminators
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProperties(
XrInstance instance,
XrInstanceProperties* instanceProperties) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetInstanceProperties");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetInstanceProperties(instance, instanceProperties);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrPollEvent(
XrInstance instance,
XrEventDataBuffer* eventData) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrPollEvent");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->PollEvent(instance, eventData);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrResultToString(
XrInstance instance,
XrResult value,
char buffer[XR_MAX_RESULT_STRING_SIZE]) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrResultToString");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->ResultToString(instance, value, buffer);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString(
XrInstance instance,
XrStructureType value,
char buffer[XR_MAX_STRUCTURE_NAME_SIZE]) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrStructureTypeToString");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->StructureTypeToString(instance, value, buffer);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetSystem(
XrInstance instance,
const XrSystemGetInfo* getInfo,
XrSystemId* systemId) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetSystem");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetSystem(instance, getInfo, systemId);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetSystemProperties(
XrInstance instance,
XrSystemId systemId,
XrSystemProperties* properties) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetSystemProperties");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetSystemProperties(instance, systemId, properties);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentBlendModes(
XrInstance instance,
XrSystemId systemId,
XrViewConfigurationType viewConfigurationType,
uint32_t environmentBlendModeCapacityInput,
uint32_t* environmentBlendModeCountOutput,
XrEnvironmentBlendMode* environmentBlendModes) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateEnvironmentBlendModes");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateEnvironmentBlendModes(instance, systemId, viewConfigurationType, environmentBlendModeCapacityInput, environmentBlendModeCountOutput, environmentBlendModes);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateSession(
XrInstance instance,
const XrSessionCreateInfo* createInfo,
XrSession* session) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrCreateSession");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->CreateSession(instance, createInfo, session);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrDestroySession(
XrSession session) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrDestroySession");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->DestroySession(session);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateReferenceSpaces(
XrSession session,
uint32_t spaceCapacityInput,
uint32_t* spaceCountOutput,
XrReferenceSpaceType* spaces) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateReferenceSpaces");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateReferenceSpaces(session, spaceCapacityInput, spaceCountOutput, spaces);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateReferenceSpace(
XrSession session,
const XrReferenceSpaceCreateInfo* createInfo,
XrSpace* space) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrCreateReferenceSpace");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->CreateReferenceSpace(session, createInfo, space);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetReferenceSpaceBoundsRect(
XrSession session,
XrReferenceSpaceType referenceSpaceType,
XrExtent2Df* bounds) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetReferenceSpaceBoundsRect");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetReferenceSpaceBoundsRect(session, referenceSpaceType, bounds);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateActionSpace(
XrSession session,
const XrActionSpaceCreateInfo* createInfo,
XrSpace* space) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrCreateActionSpace");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->CreateActionSpace(session, createInfo, space);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpace(
XrSpace space,
XrSpace baseSpace,
XrTime time,
XrSpaceLocation* location) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrLocateSpace");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->LocateSpace(space, baseSpace, time, location);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpace(
XrSpace space) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrDestroySpace");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->DestroySpace(space);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViewConfigurations(
XrInstance instance,
XrSystemId systemId,
uint32_t viewConfigurationTypeCapacityInput,
uint32_t* viewConfigurationTypeCountOutput,
XrViewConfigurationType* viewConfigurationTypes) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateViewConfigurations");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateViewConfigurations(instance, systemId, viewConfigurationTypeCapacityInput, viewConfigurationTypeCountOutput, viewConfigurationTypes);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetViewConfigurationProperties(
XrInstance instance,
XrSystemId systemId,
XrViewConfigurationType viewConfigurationType,
XrViewConfigurationProperties* configurationProperties) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetViewConfigurationProperties");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetViewConfigurationProperties(instance, systemId, viewConfigurationType, configurationProperties);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateViewConfigurationViews(
XrInstance instance,
XrSystemId systemId,
XrViewConfigurationType viewConfigurationType,
uint32_t viewCapacityInput,
uint32_t* viewCountOutput,
XrViewConfigurationView* views) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateViewConfigurationViews");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateViewConfigurationViews(instance, systemId, viewConfigurationType, viewCapacityInput, viewCountOutput, views);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSwapchainFormats(
XrSession session,
uint32_t formatCapacityInput,
uint32_t* formatCountOutput,
int64_t* formats) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateSwapchainFormats");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateSwapchainFormats(session, formatCapacityInput, formatCountOutput, formats);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateSwapchain(
XrSession session,
const XrSwapchainCreateInfo* createInfo,
XrSwapchain* swapchain) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrCreateSwapchain");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->CreateSwapchain(session, createInfo, swapchain);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrDestroySwapchain(
XrSwapchain swapchain) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrDestroySwapchain");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->DestroySwapchain(swapchain);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSwapchainImages(
XrSwapchain swapchain,
uint32_t imageCapacityInput,
uint32_t* imageCountOutput,
XrSwapchainImageBaseHeader* images) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateSwapchainImages");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateSwapchainImages(swapchain, imageCapacityInput, imageCountOutput, images);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrAcquireSwapchainImage(
XrSwapchain swapchain,
const XrSwapchainImageAcquireInfo* acquireInfo,
uint32_t* index) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrAcquireSwapchainImage");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->AcquireSwapchainImage(swapchain, acquireInfo, index);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrWaitSwapchainImage(
XrSwapchain swapchain,
const XrSwapchainImageWaitInfo* waitInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrWaitSwapchainImage");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->WaitSwapchainImage(swapchain, waitInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrReleaseSwapchainImage(
XrSwapchain swapchain,
const XrSwapchainImageReleaseInfo* releaseInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrReleaseSwapchainImage");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->ReleaseSwapchainImage(swapchain, releaseInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrBeginSession(
XrSession session,
const XrSessionBeginInfo* beginInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrBeginSession");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->BeginSession(session, beginInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEndSession(
XrSession session) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEndSession");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EndSession(session);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrRequestExitSession(
XrSession session) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrRequestExitSession");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->RequestExitSession(session);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrWaitFrame(
XrSession session,
const XrFrameWaitInfo* frameWaitInfo,
XrFrameState* frameState) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrWaitFrame");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->WaitFrame(session, frameWaitInfo, frameState);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrBeginFrame(
XrSession session,
const XrFrameBeginInfo* frameBeginInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrBeginFrame");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->BeginFrame(session, frameBeginInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEndFrame(
XrSession session,
const XrFrameEndInfo* frameEndInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEndFrame");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EndFrame(session, frameEndInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrLocateViews(
XrSession session,
const XrViewLocateInfo* viewLocateInfo,
XrViewState* viewState,
uint32_t viewCapacityInput,
uint32_t* viewCountOutput,
XrView* views) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrLocateViews");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->LocateViews(session, viewLocateInfo, viewState, viewCapacityInput, viewCountOutput, views);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrStringToPath(
XrInstance instance,
const char* pathString,
XrPath* path) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrStringToPath");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->StringToPath(instance, pathString, path);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrPathToString(
XrInstance instance,
XrPath path,
uint32_t bufferCapacityInput,
uint32_t* bufferCountOutput,
char* buffer) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrPathToString");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->PathToString(instance, path, bufferCapacityInput, bufferCountOutput, buffer);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateActionSet(
XrInstance instance,
const XrActionSetCreateInfo* createInfo,
XrActionSet* actionSet) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrCreateActionSet");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->CreateActionSet(instance, createInfo, actionSet);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrDestroyActionSet(
XrActionSet actionSet) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrDestroyActionSet");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->DestroyActionSet(actionSet);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrCreateAction(
XrActionSet actionSet,
const XrActionCreateInfo* createInfo,
XrAction* action) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrCreateAction");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->CreateAction(actionSet, createInfo, action);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrDestroyAction(
XrAction action) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrDestroyAction");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->DestroyAction(action);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrSuggestInteractionProfileBindings(
XrInstance instance,
const XrInteractionProfileSuggestedBinding* suggestedBindings) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrSuggestInteractionProfileBindings");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->SuggestInteractionProfileBindings(instance, suggestedBindings);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrAttachSessionActionSets(
XrSession session,
const XrSessionActionSetsAttachInfo* attachInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrAttachSessionActionSets");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->AttachSessionActionSets(session, attachInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetCurrentInteractionProfile(
XrSession session,
XrPath topLevelUserPath,
XrInteractionProfileState* interactionProfile) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetCurrentInteractionProfile");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetCurrentInteractionProfile(session, topLevelUserPath, interactionProfile);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateBoolean(
XrSession session,
const XrActionStateGetInfo* getInfo,
XrActionStateBoolean* state) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetActionStateBoolean");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetActionStateBoolean(session, getInfo, state);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateFloat(
XrSession session,
const XrActionStateGetInfo* getInfo,
XrActionStateFloat* state) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetActionStateFloat");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetActionStateFloat(session, getInfo, state);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStateVector2f(
XrSession session,
const XrActionStateGetInfo* getInfo,
XrActionStateVector2f* state) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetActionStateVector2f");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetActionStateVector2f(session, getInfo, state);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetActionStatePose(
XrSession session,
const XrActionStateGetInfo* getInfo,
XrActionStatePose* state) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetActionStatePose");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetActionStatePose(session, getInfo, state);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrSyncActions(
XrSession session,
const XrActionsSyncInfo* syncInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrSyncActions");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->SyncActions(session, syncInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateBoundSourcesForAction(
XrSession session,
const XrBoundSourcesForActionEnumerateInfo* enumerateInfo,
uint32_t sourceCapacityInput,
uint32_t* sourceCountOutput,
XrPath* sources) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrEnumerateBoundSourcesForAction");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->EnumerateBoundSourcesForAction(session, enumerateInfo, sourceCapacityInput, sourceCountOutput, sources);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetInputSourceLocalizedName(
XrSession session,
const XrInputSourceLocalizedNameGetInfo* getInfo,
uint32_t bufferCapacityInput,
uint32_t* bufferCountOutput,
char* buffer) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrGetInputSourceLocalizedName");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->GetInputSourceLocalizedName(session, getInfo, bufferCapacityInput, bufferCountOutput, buffer);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrApplyHapticFeedback(
XrSession session,
const XrHapticActionInfo* hapticActionInfo,
const XrHapticBaseHeader* hapticFeedback) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrApplyHapticFeedback");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->ApplyHapticFeedback(session, hapticActionInfo, hapticFeedback);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK
extern "C" LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrStopHapticFeedback(
XrSession session,
const XrHapticActionInfo* hapticActionInfo) XRLOADER_ABI_TRY {
LoaderInstance* loader_instance;
XrResult result = ActiveLoaderInstance::Get(&loader_instance, "xrStopHapticFeedback");
if (XR_SUCCEEDED(result)) {
result = loader_instance->DispatchTable()->StopHapticFeedback(session, hapticActionInfo);
}
return result;
}
XRLOADER_ABI_CATCH_FALLBACK