Skip to content

Replace OpenXRHandle with std::unique_ptr #21

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
nvddr merged 3 commits into from
Dec 18, 2025
Merged

Replace OpenXRHandle with std::unique_ptr #21

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
54b415e
Replace OpenXRHandle with std::unique_ptr
aristarkhovNV Dec 18, 2025
6dc0413
Bump to C++20 to allow using designated initializers
aristarkhovNV Dec 18, 2025
ff5c9f3
Avoid exceeding CI usage limits
aristarkhovNV Dec 18, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
128 changes: 15 additions & 113 deletions src/core/oxr_utils/cpp/inc/oxr_utils/oxr_funcs.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -97,145 +97,53 @@ struct OpenXRCoreFunctions
}
};

// Custom deleter for OpenXR handles
template <typename HandleType>
struct OpenXRHandleDeleter
{
std::function<void(HandleType)> destroy_func;

void operator()(HandleType handle) const
{
if (handle != XR_NULL_HANDLE && destroy_func)
{
destroy_func(handle);
}
}
};

// Helper to wrap OpenXR handles in unique_ptr-like semantics
template <typename HandleType>
class OpenXRHandle
{
public:
// Default constructor creates an empty/moved-from state
OpenXRHandle() : handle_(XR_NULL_HANDLE), deleter_(nullptr)
{
}

OpenXRHandle(HandleType handle, std::function<void(HandleType)> deleter)
: handle_(handle), deleter_(std::move(deleter))
{
}

~OpenXRHandle()
{
reset();
}

// Move semantics only
OpenXRHandle(OpenXRHandle&& other) noexcept : handle_(other.handle_), deleter_(std::move(other.deleter_))
{
other.handle_ = XR_NULL_HANDLE;
}

OpenXRHandle& operator=(OpenXRHandle&& other) noexcept
{
if (this != &other)
{
reset();
handle_ = other.handle_;
deleter_ = std::move(other.deleter_);
other.handle_ = XR_NULL_HANDLE;
}
return *this;
}

// Disable copy
OpenXRHandle(const OpenXRHandle&) = delete;
OpenXRHandle& operator=(const OpenXRHandle&) = delete;

// Convenience functions to get the handle.
HandleType get() const
{
return handle_;
}
HandleType operator*() const
{
return handle_;
}
explicit operator bool() const
{
return handle_ != XR_NULL_HANDLE;
}

void reset()
{
if (handle_ != XR_NULL_HANDLE)
{
assert(deleter_);
deleter_(handle_);
handle_ = XR_NULL_HANDLE;
}
}

private:
HandleType handle_;
std::function<void(HandleType)> deleter_;
};

// Smart pointer type aliases for OpenXR resources
using XrActionSetPtr = OpenXRHandle<XrActionSet>;
using XrSpacePtr = OpenXRHandle<XrSpace>;
using XrActionSetPtr = std::unique_ptr<std::remove_pointer_t<XrActionSet>, PFN_xrDestroyActionSet>;
using XrSpacePtr = std::unique_ptr<std::remove_pointer_t<XrSpace>, PFN_xrDestroySpace>;

// Create an action set with automatic cleanup - throws on failure
inline XrActionSetPtr createActionSet(const OpenXRCoreFunctions& funcs,
XrInstance instance,
const XrActionSetCreateInfo* createInfo)
const XrActionSetCreateInfo& createInfo)
{
assert(funcs.xrDestroyActionSet);

XrActionSet actionSet = XR_NULL_HANDLE;
XrResult result = funcs.xrCreateActionSet(instance, createInfo, &actionSet);
XrResult result = funcs.xrCreateActionSet(instance, &createInfo, &actionSet);

if (XR_FAILED(result))
{
throw std::runtime_error("Failed to create action set: " + std::to_string(result));
}

auto deleter = [destroyFunc = funcs.xrDestroyActionSet](XrActionSet handle)
{
assert(destroyFunc);
destroyFunc(handle);
};

return XrActionSetPtr(actionSet, deleter);
return XrActionSetPtr(actionSet, funcs.xrDestroyActionSet);
}

// Create a reference space with automatic cleanup - throws on failure
inline XrSpacePtr createReferenceSpace(const OpenXRCoreFunctions& funcs,
XrSession session,
const XrReferenceSpaceCreateInfo* createInfo)
const XrReferenceSpaceCreateInfo& createInfo)
{
assert(funcs.xrDestroySpace);

XrSpace space = XR_NULL_HANDLE;
XrResult result = funcs.xrCreateReferenceSpace(session, createInfo, &space);
XrResult result = funcs.xrCreateReferenceSpace(session, &createInfo, &space);

if (XR_FAILED(result))
{
throw std::runtime_error("Failed to create reference space: " + std::to_string(result));
}

auto deleter = [destroyFunc = funcs.xrDestroySpace](XrSpace handle)
{
assert(destroyFunc);
destroyFunc(handle);
};

return XrSpacePtr(space, deleter);
return XrSpacePtr(space, funcs.xrDestroySpace);
}

// Create an action space with automatic cleanup - throws on failure
inline XrSpacePtr createActionSpace(const OpenXRCoreFunctions& funcs,
XrSession session,
const XrActionSpaceCreateInfo* createInfo)
{
assert(funcs.xrDestroySpace);

XrSpace space = XR_NULL_HANDLE;
XrResult result = funcs.xrCreateActionSpace(session, createInfo, &space);

Expand All @@ -244,13 +152,7 @@ inline XrSpacePtr createActionSpace(const OpenXRCoreFunctions& funcs,
throw std::runtime_error("Failed to create action space: " + std::to_string(result));
}

auto deleter = [destroyFunc = funcs.xrDestroySpace](XrSpace handle)
{
assert(destroyFunc);
destroyFunc(handle);
};

return XrSpacePtr(space, deleter);
return XrSpacePtr(space, funcs.xrDestroySpace);
}

} // namespace core
Loading
Loading