cmbruns / pyopenxr Goto Github PK

.make_array() is called on too many inappropriate objects.

It's not working, but it's getting close.

like for xr.ApplicationInfo(), so it can accept unicode strings

...to make room for a class called "Instance", for example. The low level opaque handle type should be "InstanceHandle"

I want to record the hmd and the controllers positions and rotations into a csv file while playing a steam-vr game , would it be possible at the current state of the library ? where should i start looking how to do that ?

GitHub notified me of the update to the README of pyopenvr. Since you're switching to OpenXR and I just happen to know that Blender (a Python-based free and open source 3D creation suite) has been working on integrating it as well. You might be able to reuse some code from that project:
https://wiki.blender.org/wiki/Source/Interface/XR

I don't know the current state of that project, but thought to just leave this pointer here ^-^

• to/from string
• equality with string/bytes
• correctness of type field

this was an ill considered hack.
A particular Type might have these three api names:
C: "uint32_t"
ctypes: "c_uint32"
python: "int"

• That should instead be a ctypes name, not the original C name
• Errors like this should ideally have caused an exception during code generation

This is the last major missing piece before we can begin trying to actually code things using pyopenxr

for example enumerate_intance_extension_properties(layer_name=None)

instead of CTypesPrimitiveType...

Keep simple uses as simple as possible via exceptions and reasonable defaults

with xr.System() as system:
  pass

• Update and install latest OpenXR-SDK from github
  • On Windows, be sure to set the DYNAMIC_LOADER option in CMake, because we need a shared DLL library.
• Update latest OpenXR-Registry from github
• Build and install libclang
• Pull latest pyopenxr sources from github
• Generate: Run CMake and configure src/generate/CMakeLists.txt with build folder outside of src.
• Commit to local repository
• Run tests
• python -m build --sdist --wheel
• twine upload --repository pypi dist/*
• Create tag like 1.0.1901 at current HEAD
• Push to github INCLUDING TAGS
• Write release notes and publish release on github

Attributes:

• has a parent System
• has a SessionHandle
• has a GraphicsBinding
• has a GraphicsBinding type e.g. xr.GraphicsBindingOpenGLWin32KHR
• has a swapchain image type e.g. xr.SwapchainImageOpenGLKHR
• has SessionCreateFlags

Methods:

• create()
• destroy()
• enumerate_reference_spaces()
• [create_reference_space(...)]
• [get_reference_space_bounds_rect(...)]
• [create_action_space(...)]
• enumerate_swapchain_formats()
• [create_swapchain(...)]
• begin(...)
• end()
• request_exit()
• wait_frame()
• begin_frame()
• end_frame()
• locate_views()
• attach_action_sets(...)
• get_current_interaction_profile(...)
• get_action_state_boolean(...)
• get_action_state_float(...)
• get_action_state_vector2f(...)
• get_action_state_pose(...)
• sync_actions()
• enumerate_bound_sources_for_action()
• get_input_source_localized_name(...)
• apply_haptic_feedback(...)
• stop_haptic_feedback(...)

so we can say "foo" in props

like XR_USE_GRAPHICS_API_OPENGL
and XR_USE_PLATFORM_WIN32
etc.

OpenXR has some logging functions. We should hook those up to the python logging system.

Such as XrSpaceVelocityFlags

See unit tests at https://github.com/KhronosGroup/OpenXR-Hpp/blob/master/tests/flags.cpp

... and maybe structs at the same time. This is a prerequisite to wrapping the raw C functions.

• wrap release version
• wrap enums
• wrap constants
• wrap typedefs
• wrap structures
• wrap C functions
• wrap exceptions

For eventual use in planned track_hmd.py

• On Linux:
  • Update and install latest OpenXR-SDK from github
  • Update latest OpenXR-Registry from github
  • Build and install libclang
  • Pull latest pyopenxr sources from github
  • Generate: Run CMake and configure src/generate/CMakeLists.txt with build folder outside of src.
  • Run tests
  • Commit to local repository
  • Push to github
• On Windows:
  • Update and install latest OpenXR-SDK from github
    • On Windows, be sure to set the DYNAMIC_LOADER option in CMake, because we need a shared DLL library.
  • Update latest OpenXR-Registry from github
  • Build and install libclang
  • Pull latest pyopenxr sources from github
  • Generate: Run CMake and configure src/generate/CMakeLists.txt with build folder outside of src.
  • Run tests
  • Commit to local repository
  • python -m build --sdist --wheel
  • twine upload --repository pypi dist/*
  • Create tag like 1.0.1901 at current HEAD
  • Push to github INCLUDING TAGS
  • Write release notes and publish release on github

Like "HDC"
https://stackoverflow.com/questions/48440040/what-ctypes-types-to-use-with-word-and-dword-definitions

Hi,

I am trying to get a headless session (without the compositor) with the XR_MND_headless extension.
I modified the example script a bit:

import time
import xr

available = xr.enumerate_instance_extension_properties()
required = [xr.MND_HEADLESS_EXTENSION_NAME]
for prop in required:
    assert prop in available

with xr.Instance(application_name="track_headless", requested_extensions = required) as instance:
    with xr.System(instance) as system:
        with xr.Session(system) as session:
            for _ in range(50):
                print ("entered loop")
                session.poll_xr_events()

But it fails at system creation:

Info: All enumerated devices attached.
Info: Loaded drivers: HTCVive
Info: Adding tracked object T20 from HTC
Info: Device T20 has watchman FW version 1562916277 and FPGA version 538/10/2; named '                       watchman'. Hardware id 0x110e0009
Info: Detected LH gen 2 system.
LOG in xrCreateInstance: Info: Adding lighthouse ch 1 (idx: 0, cnt: 1)
Instance created
	createInfo->applicationInfo.applicationName: track_headless
	createInfo->applicationInfo.applicationVersion: 0
	createInfo->applicationInfo.engineName: pyopenvr
	createInfo->applicationInfo.engineVersion: 1902
	appinfo.detected.engine.name: (null)
	appinfo.detected.engine.version: 0.0.0
	quirks.disable_vulkan_format_depth_stencil: false
Info: OOTX not set for LH in channel 1; attaching ootx decoder using device T20
Info: LightcapMode (T20) 1 -> 2
Info: MPFIT stats for T20:
Info: 	seed runs         0 / 0
Info: 	error failures    0
Traceback (most recent call last):
  File "/home/adi/xrwork/pyopenxr/examples/track_nohmd.py", line 10, in <module>
    with xr.System(instance) as system:
  File "/home/adi/.local/lib/python3.9/site-packages/xr/classes.py", line 115, in __init__
    get_instance_proc_addr(
  File "/home/adi/.local/lib/python3.9/site-packages/xr/functions.py", line 33, in get_instance_proc_addr
    raise result
xr.exception.FunctionUnsupportedError: The requested function was not found or is otherwise unsupported.

And this is the part of the System class being the culprit:

        self.pxrGetOpenGLGraphicsRequirementsKHR = ctypes.cast(
            get_instance_proc_addr(
                self.instance.handle,
                "xrGetOpenGLGraphicsRequirementsKHR",
            ),
            PFN_xrGetOpenGLGraphicsRequirementsKHR
        )

... and message strings for XrResult based exceptions.

This is not a full solution to #21 because there are no docstrings for the commands/functions in xr.xml. Where does that text come from?!

This might require some sort of custom file writing.

Once this project is minimally working, we should give the opportunity for relevant collaborators to join. For example:
@jherico
@risa2000
@lgbeno
@tomgoddard
@JoeLudwig
@jeremyselan
@gregpinero
@Ralith
@rpavlik
@artob

The standard header has no docstring comments. But it should be possible to pull documentation from the OpenXR-Registry project

...to formalize the de facto development process.
Contains code we would like the generator to eventually generate.

Remember do not combine whitespace changes with other changes tho

as described at #19 (comment)

Each xr module file should have correct arrangement of docstring, import, etc.