• Home
• org.lwjgl
• lwjgl-openxr
• 3.3.5
• source code
• METAVirtualKeyboard.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.lwjgl.openxr.METAVirtualKeyboard Maven / Gradle / Ivy

/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.openxr;

import org.jspecify.annotations.*;

import java.nio.*;

import org.lwjgl.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * The XR_META_virtual_keyboard extension.
 * 
 * 
The virtual keyboard extension provides a system-driven localized keyboard that the application has full control over in terms of positioning and rendering.
 * 
 * 
This is achieved by giving the application the data required to drive rendering and animation of the keyboard in response to interaction data passed from the application to the runtime.
 * 
 * 
This approach is an alternative to a potential system keyboard overlay solution and provides a keyboard that can seamlessly blend into the application environment, since it is rendered by the same system, and avoids input focus issues that might come with a system overlay.
 * 
 * 
The API is also designed to work with custom hand and/or controller models in various games and applications.
 */
public class METAVirtualKeyboard {

    /** The extension specification version. */
    public static final int XR_META_virtual_keyboard_SPEC_VERSION = 1;

    /** The extension name. */
    public static final String XR_META_VIRTUAL_KEYBOARD_EXTENSION_NAME = "XR_META_virtual_keyboard";

    /** XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META */
    public static final int XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META = 3992;

    /** Extends {@code XrObjectType}. */
    public static final int XR_OBJECT_TYPE_VIRTUAL_KEYBOARD_META = 1000219000;

    /**
     * Extends {@code XrStructureType}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META}
     * 
{@link #XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META}
     * 
{@link #XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META}
     * 
{@link #XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META}
     * 
{@link #XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META}
     * 
{@link #XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META}
     * 
{@link #XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META}
     * 
     */
    public static final int
        XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META         = 1000219001,
        XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META               = 1000219002,
        XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META         = 1000219003,
        XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META             = 1000219004,
        XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META = 1000219005,
        XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META           = 1000219006,
        XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META    = 1000219007,
        XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META              = 1000219009,
        XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META                = 1000219010,
        XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META  = 1000219011,
        XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META    = 1000219014,
        XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META      = 1000219015,
        XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META          = 1000219016,
        XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META          = 1000219017,
        XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META         = 1000219018;

    /**
     * XrVirtualKeyboardLocationTypeMETA - Enum describing keyboard placement types
     * 
     * 
Enumerant Descriptions
     * 
     * 

     * 
{@link #XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META} Indicates that the application will provide the position and scale of the keyboard.
     * 
{@link #XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META} Indicates that the runtime will set the position and scale for far field keyboard.
     * 
{@link #XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META} Indicates that the runtime will set the position and scale for direct interaction keyboard.
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardLocationInfoMETA}, {@link XrVirtualKeyboardSpaceCreateInfoMETA}
     */
    public static final int
        XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META = 0,
        XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META    = 1,
        XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META = 2;

    /**
     * XrVirtualKeyboardInputSourceMETA - Enum describing keyboard input source types
     * 
     * 
Description
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Enum
Description
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META}
Left controller ray.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META}
Right controller ray.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META}
Left hand ray.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META}
Right hand ray.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META}
Left controller direct touch.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META}
Right controller direct touch.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META}
Left hand direct touch.
{@link #XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META}
Right hand direct touch.
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardInputInfoMETA}
     */
    public static final int
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META         = 1,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META        = 2,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META               = 3,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META              = 4,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META      = 5,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META     = 6,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META  = 7,
        XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META = 8;

    /**
     * XrVirtualKeyboardInputStateFlagBitsMETA - XrVirtualKeyboardInputStateFlagBitsMETA
     * 
     * 
Flag Descriptions
     * 
     * 

     * 
{@link #XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META} — If the input source is considered 'pressed' at all. Pinch for hands, Primary button for controllers.
     * 
     */
    public static final int XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META = 0x1;

    protected METAVirtualKeyboard() {
        throw new UnsupportedOperationException();
    }

    // --- [ xrCreateVirtualKeyboardMETA ] ---

    /** Unsafe version of: {@link #xrCreateVirtualKeyboardMETA CreateVirtualKeyboardMETA} */
    public static int nxrCreateVirtualKeyboardMETA(XrSession session, long createInfo, long keyboard) {
        long __functionAddress = session.getCapabilities().xrCreateVirtualKeyboardMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(session.address(), createInfo, keyboard, __functionAddress);
    }

    /**
     * Create a virtual keyboard.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrCreateVirtualKeyboardMETA CreateVirtualKeyboardMETA} function is defined as:
     * 
     * 

     * XrResult xrCreateVirtualKeyboardMETA(
     *     XrSession                                   session,
     *     const XrVirtualKeyboardCreateInfoMETA*      createInfo,
     *     XrVirtualKeyboardMETA*                      keyboard);
     * 
     * 
Description
     * 
     * 
{@link #xrCreateVirtualKeyboardMETA CreateVirtualKeyboardMETA} creates an {@code XrVirtualKeyboardMETA} handle and establishes a keyboard within the runtime {@code XrSession}. The returned virtual keyboard handle may be subsequently used in API calls.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrCreateVirtualKeyboardMETA CreateVirtualKeyboardMETA}
     * 
{@code session} must be a valid {@code XrSession} handle
     * 
{@code createInfo} must be a pointer to a valid {@link XrVirtualKeyboardCreateInfoMETA} structure
     * 
{@code keyboard} must be a pointer to an {@code XrVirtualKeyboardMETA} handle
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_OUT_OF_MEMORY ERROR_OUT_OF_MEMORY}
     * 
{@link XR10#XR_ERROR_LIMIT_REACHED ERROR_LIMIT_REACHED}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardCreateInfoMETA}
     *
     * @param session    the {@code XrSession}.
     * @param createInfo the {@link XrVirtualKeyboardCreateInfoMETA}.
     * @param keyboard   the returned {@code XrVirtualKeyboardMETA}.
     */
    @NativeType("XrResult")
    public static int xrCreateVirtualKeyboardMETA(XrSession session, @NativeType("XrVirtualKeyboardCreateInfoMETA const *") XrVirtualKeyboardCreateInfoMETA createInfo, @NativeType("XrVirtualKeyboardMETA *") PointerBuffer keyboard) {
        if (CHECKS) {
            check(keyboard, 1);
        }
        return nxrCreateVirtualKeyboardMETA(session, createInfo.address(), memAddress(keyboard));
    }

    // --- [ xrDestroyVirtualKeyboardMETA ] ---

    /**
     * Destroy a virtual keyboard.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrDestroyVirtualKeyboardMETA DestroyVirtualKeyboardMETA} function is defined as:
     * 
     * 

     * XrResult xrDestroyVirtualKeyboardMETA(
     *     XrVirtualKeyboardMETA                       keyboard);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrDestroyVirtualKeyboardMETA DestroyVirtualKeyboardMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
     * 
     * 
Thread Safety
     * 
     * 

     * 
Access to {@code keyboard}, and any child handles, must be externally synchronized
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     *
     * @param keyboard the {@code XrVirtualKeyboardMETA} handle to the keyboard to destroy.
     */
    @NativeType("XrResult")
    public static int xrDestroyVirtualKeyboardMETA(XrVirtualKeyboardMETA keyboard) {
        long __functionAddress = keyboard.getCapabilities().xrDestroyVirtualKeyboardMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPI(keyboard.address(), __functionAddress);
    }

    // --- [ xrCreateVirtualKeyboardSpaceMETA ] ---

    /** Unsafe version of: {@link #xrCreateVirtualKeyboardSpaceMETA CreateVirtualKeyboardSpaceMETA} */
    public static int nxrCreateVirtualKeyboardSpaceMETA(XrSession session, XrVirtualKeyboardMETA keyboard, long createInfo, long keyboardSpace) {
        long __functionAddress = session.getCapabilities().xrCreateVirtualKeyboardSpaceMETA;
        if (CHECKS) {
            check(__functionAddress);
            XrVirtualKeyboardSpaceCreateInfoMETA.validate(createInfo);
        }
        return callPPPPI(session.address(), keyboard.address(), createInfo, keyboardSpace, __functionAddress);
    }

    /**
     * Create a virtual keyboard space.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrCreateVirtualKeyboardSpaceMETA CreateVirtualKeyboardSpaceMETA} function is defined as:
     * 
     * 

     * XrResult xrCreateVirtualKeyboardSpaceMETA(
     *     XrSession                                   session,
     *     XrVirtualKeyboardMETA                       keyboard,
     *     const XrVirtualKeyboardSpaceCreateInfoMETA* createInfo,
     *     XrSpace*                                    keyboardSpace);
     * 
     * 
Description
     * 
     * 
Creates an {@code XrSpace} handle and places the keyboard in this space. The returned space handle may be subsequently used in API calls.
     * 
     * 
Once placed, the application should query the keyboard’s location each frame using {@link XR10#xrLocateSpace LocateSpace}. It is important to do this every frame as the runtime is in control of the keyboard’s movement.
     * 
     * 
The runtime must return {@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID} if {@code session} is different than what is used to create {@code keyboard}.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrCreateVirtualKeyboardSpaceMETA CreateVirtualKeyboardSpaceMETA}
     * 
{@code session} must be a valid {@code XrSession} handle
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code createInfo} must be a pointer to a valid {@link XrVirtualKeyboardSpaceCreateInfoMETA} structure
     * 
{@code keyboardSpace} must be a pointer to an {@code XrSpace} handle
     * 
{@code keyboard} must have been created, allocated, or retrieved from {@code session}
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_OUT_OF_MEMORY ERROR_OUT_OF_MEMORY}
     * 
{@link XR10#XR_ERROR_LIMIT_REACHED ERROR_LIMIT_REACHED}
     * 
{@link XR10#XR_ERROR_POSE_INVALID ERROR_POSE_INVALID}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardSpaceCreateInfoMETA}
     *
     * @param session       the {@code XrSession}.
     * @param keyboard      the {@code XrVirtualKeyboardMETA} handle.
     * @param createInfo    the {@link XrVirtualKeyboardSpaceCreateInfoMETA}.
     * @param keyboardSpace the returned space handle.
     */
    @NativeType("XrResult")
    public static int xrCreateVirtualKeyboardSpaceMETA(XrSession session, XrVirtualKeyboardMETA keyboard, @NativeType("XrVirtualKeyboardSpaceCreateInfoMETA const *") XrVirtualKeyboardSpaceCreateInfoMETA createInfo, @NativeType("XrSpace *") PointerBuffer keyboardSpace) {
        if (CHECKS) {
            check(keyboardSpace, 1);
        }
        return nxrCreateVirtualKeyboardSpaceMETA(session, keyboard, createInfo.address(), memAddress(keyboardSpace));
    }

    // --- [ xrSuggestVirtualKeyboardLocationMETA ] ---

    /** Unsafe version of: {@link #xrSuggestVirtualKeyboardLocationMETA SuggestVirtualKeyboardLocationMETA} */
    public static int nxrSuggestVirtualKeyboardLocationMETA(XrVirtualKeyboardMETA keyboard, long locationInfo) {
        long __functionAddress = keyboard.getCapabilities().xrSuggestVirtualKeyboardLocationMETA;
        if (CHECKS) {
            check(__functionAddress);
            XrVirtualKeyboardLocationInfoMETA.validate(locationInfo);
        }
        return callPPI(keyboard.address(), locationInfo, __functionAddress);
    }

    /**
     * Suggest a virtual keyboard location.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrSuggestVirtualKeyboardLocationMETA SuggestVirtualKeyboardLocationMETA} function is defined as:
     * 
     * 

     * XrResult xrSuggestVirtualKeyboardLocationMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     const XrVirtualKeyboardLocationInfoMETA*    locationInfo);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrSuggestVirtualKeyboardLocationMETA SuggestVirtualKeyboardLocationMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code locationInfo} must be a pointer to a valid {@link XrVirtualKeyboardLocationInfoMETA} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_POSE_INVALID ERROR_POSE_INVALID}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardLocationInfoMETA}
     *
     * @param keyboard     the {@code XrVirtualKeyboardMETA} handle.
     * @param locationInfo the desired {@link XrVirtualKeyboardLocationInfoMETA}.
     */
    @NativeType("XrResult")
    public static int xrSuggestVirtualKeyboardLocationMETA(XrVirtualKeyboardMETA keyboard, @NativeType("XrVirtualKeyboardLocationInfoMETA const *") XrVirtualKeyboardLocationInfoMETA locationInfo) {
        return nxrSuggestVirtualKeyboardLocationMETA(keyboard, locationInfo.address());
    }

    // --- [ xrGetVirtualKeyboardScaleMETA ] ---

    /** Unsafe version of: {@link #xrGetVirtualKeyboardScaleMETA GetVirtualKeyboardScaleMETA} */
    public static int nxrGetVirtualKeyboardScaleMETA(XrVirtualKeyboardMETA keyboard, long scale) {
        long __functionAddress = keyboard.getCapabilities().xrGetVirtualKeyboardScaleMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(keyboard.address(), scale, __functionAddress);
    }

    /**
     * Get virtual keyboard scale.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrGetVirtualKeyboardScaleMETA GetVirtualKeyboardScaleMETA} function is defined as:
     * 
     * 

     * XrResult xrGetVirtualKeyboardScaleMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     float*                                      scale);
     * 
     * 
Description
     * 
     * 
With both the pose and scale, the application has all the information to draw the virtual keyboard render model.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrGetVirtualKeyboardScaleMETA GetVirtualKeyboardScaleMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code scale} must be a pointer to a {@code float} value
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     *
     * @param keyboard the {@code XrVirtualKeyboardMETA} handle.
     * @param scale    a float value of the current scale of the keyboard.
     */
    @NativeType("XrResult")
    public static int xrGetVirtualKeyboardScaleMETA(XrVirtualKeyboardMETA keyboard, @NativeType("float *") FloatBuffer scale) {
        if (CHECKS) {
            check(scale, 1);
        }
        return nxrGetVirtualKeyboardScaleMETA(keyboard, memAddress(scale));
    }

    // --- [ xrSetVirtualKeyboardModelVisibilityMETA ] ---

    /** Unsafe version of: {@link #xrSetVirtualKeyboardModelVisibilityMETA SetVirtualKeyboardModelVisibilityMETA} */
    public static int nxrSetVirtualKeyboardModelVisibilityMETA(XrVirtualKeyboardMETA keyboard, long modelVisibility) {
        long __functionAddress = keyboard.getCapabilities().xrSetVirtualKeyboardModelVisibilityMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(keyboard.address(), modelVisibility, __functionAddress);
    }

    /**
     * Set virtual keyboard model visibility.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrSetVirtualKeyboardModelVisibilityMETA SetVirtualKeyboardModelVisibilityMETA} function is defined as:
     * 
     * 

     * XrResult xrSetVirtualKeyboardModelVisibilityMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     const XrVirtualKeyboardModelVisibilitySetInfoMETA* modelVisibility);
     * 
     * 
Description
     * 
     * 
Note that the runtime has final control of the model visibility. The runtime may also change the visible state in certain situations. To get the actual visibility state of the render model, the application should wait for the {@link XrEventDataVirtualKeyboardShownMETA} and {@link XrEventDataVirtualKeyboardHiddenMETA} events.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrSetVirtualKeyboardModelVisibilityMETA SetVirtualKeyboardModelVisibilityMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code modelVisibility} must be a pointer to a valid {@link XrVirtualKeyboardModelVisibilitySetInfoMETA} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardModelVisibilitySetInfoMETA}
     *
     * @param keyboard        the {@code XrVirtualKeyboardMETA} handle.
     * @param modelVisibility the {@link XrVirtualKeyboardModelVisibilitySetInfoMETA}.
     */
    @NativeType("XrResult")
    public static int xrSetVirtualKeyboardModelVisibilityMETA(XrVirtualKeyboardMETA keyboard, @NativeType("XrVirtualKeyboardModelVisibilitySetInfoMETA const *") XrVirtualKeyboardModelVisibilitySetInfoMETA modelVisibility) {
        return nxrSetVirtualKeyboardModelVisibilityMETA(keyboard, modelVisibility.address());
    }

    // --- [ xrGetVirtualKeyboardModelAnimationStatesMETA ] ---

    /** Unsafe version of: {@link #xrGetVirtualKeyboardModelAnimationStatesMETA GetVirtualKeyboardModelAnimationStatesMETA} */
    public static int nxrGetVirtualKeyboardModelAnimationStatesMETA(XrVirtualKeyboardMETA keyboard, long animationStates) {
        long __functionAddress = keyboard.getCapabilities().xrGetVirtualKeyboardModelAnimationStatesMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(keyboard.address(), animationStates, __functionAddress);
    }

    /**
     * Get model animation states.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrGetVirtualKeyboardModelAnimationStatesMETA GetVirtualKeyboardModelAnimationStatesMETA} function is defined as:
     * 
     * 

     * XrResult xrGetVirtualKeyboardModelAnimationStatesMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     XrVirtualKeyboardModelAnimationStatesMETA*  animationStates);
     * 
     * 
Description
     * 
     * 
This function follows the two-call idiom for filling the {@code animationStates} array in the {@link XrVirtualKeyboardModelAnimationStatesMETA} structure. Note that new animations may be added after the runtime processes inputs from {@link #xrSendVirtualKeyboardInputMETA SendVirtualKeyboardInputMETA}. Therefore, after sending new keyboard inputs the application should query the buffer size again before getting any animation data.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrGetVirtualKeyboardModelAnimationStatesMETA GetVirtualKeyboardModelAnimationStatesMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code animationStates} must be a pointer to an {@link XrVirtualKeyboardModelAnimationStatesMETA} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_SIZE_INSUFFICIENT ERROR_SIZE_INSUFFICIENT}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardModelAnimationStatesMETA}
     *
     * @param keyboard        the {@code XrVirtualKeyboardMETA} handle.
     * @param animationStates the {@link XrVirtualKeyboardModelAnimationStatesMETA}.
     */
    @NativeType("XrResult")
    public static int xrGetVirtualKeyboardModelAnimationStatesMETA(XrVirtualKeyboardMETA keyboard, @NativeType("XrVirtualKeyboardModelAnimationStatesMETA *") XrVirtualKeyboardModelAnimationStatesMETA animationStates) {
        return nxrGetVirtualKeyboardModelAnimationStatesMETA(keyboard, animationStates.address());
    }

    // --- [ xrGetVirtualKeyboardDirtyTexturesMETA ] ---

    /**
     * Unsafe version of: {@link #xrGetVirtualKeyboardDirtyTexturesMETA GetVirtualKeyboardDirtyTexturesMETA}
     *
     * @param textureIdCapacityInput the capacity of the {@code textureIds} array, or 0 to indicate a request to retrieve the required capacity.
     */
    public static int nxrGetVirtualKeyboardDirtyTexturesMETA(XrVirtualKeyboardMETA keyboard, int textureIdCapacityInput, long textureIdCountOutput, long textureIds) {
        long __functionAddress = keyboard.getCapabilities().xrGetVirtualKeyboardDirtyTexturesMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(keyboard.address(), textureIdCapacityInput, textureIdCountOutput, textureIds, __functionAddress);
    }

    /**
     * Get model textures that are dirty.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrGetVirtualKeyboardDirtyTexturesMETA GetVirtualKeyboardDirtyTexturesMETA} function is defined as:
     * 
     * 

     * XrResult xrGetVirtualKeyboardDirtyTexturesMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     uint32_t                                    textureIdCapacityInput,
     *     uint32_t*                                   textureIdCountOutput,
     *     uint64_t*                                   textureIds);
     * 
     * 
Description
     * 
     * 
This function follows the two-call idiom for filling the {@code textureIds} array. Note that new texture data may be added after the runtime processes inputs from {@link #xrSendVirtualKeyboardInputMETA SendVirtualKeyboardInputMETA}. Therefore, after sending new keyboard inputs the application should query the buffer size again before getting any texture data.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrGetVirtualKeyboardDirtyTexturesMETA GetVirtualKeyboardDirtyTexturesMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code textureIdCountOutput} must be a pointer to a {@code uint32_t} value
     * 
If {@code textureIdCapacityInput} is not 0, {@code textureIds} must be a pointer to an array of {@code textureIdCapacityInput} {@code uint64_t} values
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_SIZE_INSUFFICIENT ERROR_SIZE_INSUFFICIENT}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     *
     * @param keyboard             the {@code XrVirtualKeyboardMETA} handle.
     * @param textureIdCountOutput filled in by the runtime with the count of texture IDs written or the required capacity in the case that {@code textureIdCapacityInput} is insufficient.
     * @param textureIds           the array of texture IDs that need to be updated.
     */
    @NativeType("XrResult")
    public static int xrGetVirtualKeyboardDirtyTexturesMETA(XrVirtualKeyboardMETA keyboard, @NativeType("uint32_t *") IntBuffer textureIdCountOutput, @NativeType("uint64_t *") @Nullable LongBuffer textureIds) {
        if (CHECKS) {
            check(textureIdCountOutput, 1);
        }
        return nxrGetVirtualKeyboardDirtyTexturesMETA(keyboard, remainingSafe(textureIds), memAddress(textureIdCountOutput), memAddressSafe(textureIds));
    }

    // --- [ xrGetVirtualKeyboardTextureDataMETA ] ---

    /** Unsafe version of: {@link #xrGetVirtualKeyboardTextureDataMETA GetVirtualKeyboardTextureDataMETA} */
    public static int nxrGetVirtualKeyboardTextureDataMETA(XrVirtualKeyboardMETA keyboard, long textureId, long textureData) {
        long __functionAddress = keyboard.getCapabilities().xrGetVirtualKeyboardTextureDataMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPI(keyboard.address(), textureId, textureData, __functionAddress);
    }

    /**
     * Get the data to update a model texture.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrGetVirtualKeyboardTextureDataMETA GetVirtualKeyboardTextureDataMETA} function is defined as:
     * 
     * 

     * XrResult xrGetVirtualKeyboardTextureDataMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     uint64_t                                    textureId,
     *     XrVirtualKeyboardTextureDataMETA*           textureData);
     * 
     * 
Description
     * 
     * 
This function follows the two-call idiom for filling the {@code textureData} array in the {@link XrVirtualKeyboardTextureDataMETA} structure. Note that new texture data may be added after the runtime processes inputs from {@link #xrSendVirtualKeyboardInputMETA SendVirtualKeyboardInputMETA}. Therefore, after sending new keyboard inputs the application should query the buffer size again before getting any texture data.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrGetVirtualKeyboardTextureDataMETA GetVirtualKeyboardTextureDataMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code textureData} must be a pointer to an {@link XrVirtualKeyboardTextureDataMETA} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_SIZE_INSUFFICIENT ERROR_SIZE_INSUFFICIENT}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardTextureDataMETA}
     *
     * @param keyboard    the {@code XrVirtualKeyboardMETA} handle.
     * @param textureId   the ID of the texture that the application is querying data for.
     * @param textureData the returned {@link XrVirtualKeyboardTextureDataMETA}.
     */
    @NativeType("XrResult")
    public static int xrGetVirtualKeyboardTextureDataMETA(XrVirtualKeyboardMETA keyboard, @NativeType("uint64_t") long textureId, @NativeType("XrVirtualKeyboardTextureDataMETA *") XrVirtualKeyboardTextureDataMETA textureData) {
        return nxrGetVirtualKeyboardTextureDataMETA(keyboard, textureId, textureData.address());
    }

    // --- [ xrSendVirtualKeyboardInputMETA ] ---

    /** Unsafe version of: {@link #xrSendVirtualKeyboardInputMETA SendVirtualKeyboardInputMETA} */
    public static int nxrSendVirtualKeyboardInputMETA(XrVirtualKeyboardMETA keyboard, long info, long interactorRootPose) {
        long __functionAddress = keyboard.getCapabilities().xrSendVirtualKeyboardInputMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(keyboard.address(), info, interactorRootPose, __functionAddress);
    }

    /**
     * Send virtual keyboard input.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrSendVirtualKeyboardInputMETA SendVirtualKeyboardInputMETA} function is defined as:
     * 
     * 

     * XrResult xrSendVirtualKeyboardInputMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     const XrVirtualKeyboardInputInfoMETA*       info,
     *     XrPosef*                                    interactorRootPose);
     * 
     * 
Description
     * 
     * 
The application can use values like a pointer pose as the {@code interactorRootPose} for {@code XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_*} or {@code XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_*} input sources, a point on a controller model for {@code XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_*} input sources and the hand index tip pose for {@code XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_*}. Different input poses can be used to accommodate application specific controller or hand models.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrSendVirtualKeyboardInputMETA SendVirtualKeyboardInputMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code info} must be a pointer to a valid {@link XrVirtualKeyboardInputInfoMETA} structure
     * 
{@code interactorRootPose} must be a pointer to an {@link XrPosef} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_POSE_INVALID ERROR_POSE_INVALID}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrPosef}, {@link XrVirtualKeyboardInputInfoMETA}
     *
     * @param keyboard           the {@code XrVirtualKeyboardMETA} handle.
     * @param info               the {@link XrVirtualKeyboardInputInfoMETA} detailing the input being sent to the runtime.
     * @param interactorRootPose an {@link XrPosef} defining the root pose of the input source. The runtime may modify this value to aid keyboard input perception.
     */
    @NativeType("XrResult")
    public static int xrSendVirtualKeyboardInputMETA(XrVirtualKeyboardMETA keyboard, @NativeType("XrVirtualKeyboardInputInfoMETA const *") XrVirtualKeyboardInputInfoMETA info, @NativeType("XrPosef *") XrPosef interactorRootPose) {
        return nxrSendVirtualKeyboardInputMETA(keyboard, info.address(), interactorRootPose.address());
    }

    // --- [ xrChangeVirtualKeyboardTextContextMETA ] ---

    /** Unsafe version of: {@link #xrChangeVirtualKeyboardTextContextMETA ChangeVirtualKeyboardTextContextMETA} */
    public static int nxrChangeVirtualKeyboardTextContextMETA(XrVirtualKeyboardMETA keyboard, long changeInfo) {
        long __functionAddress = keyboard.getCapabilities().xrChangeVirtualKeyboardTextContextMETA;
        if (CHECKS) {
            check(__functionAddress);
            XrVirtualKeyboardTextContextChangeInfoMETA.validate(changeInfo);
        }
        return callPPI(keyboard.address(), changeInfo, __functionAddress);
    }

    /**
     * Change virtual keyboard text context.
     * 
     * 
C Specification
     * 
     * 
The {@link #xrChangeVirtualKeyboardTextContextMETA ChangeVirtualKeyboardTextContextMETA} function is defined as:
     * 
     * 

     * XrResult xrChangeVirtualKeyboardTextContextMETA(
     *     XrVirtualKeyboardMETA                       keyboard,
     *     const XrVirtualKeyboardTextContextChangeInfoMETA* changeInfo);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
The {@link METAVirtualKeyboard XR_META_virtual_keyboard} extension must be enabled prior to calling {@link #xrChangeVirtualKeyboardTextContextMETA ChangeVirtualKeyboardTextContextMETA}
     * 
{@code keyboard} must be a valid {@code XrVirtualKeyboardMETA} handle
     * 
{@code changeInfo} must be a pointer to a valid {@link XrVirtualKeyboardTextContextChangeInfoMETA} structure
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link XR10#XR_SUCCESS SUCCESS}
     * 
{@link XR10#XR_SESSION_LOSS_PENDING SESSION_LOSS_PENDING}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link XR10#XR_ERROR_FUNCTION_UNSUPPORTED ERROR_FUNCTION_UNSUPPORTED}
     * 
{@link XR10#XR_ERROR_VALIDATION_FAILURE ERROR_VALIDATION_FAILURE}
     * 
{@link XR10#XR_ERROR_RUNTIME_FAILURE ERROR_RUNTIME_FAILURE}
     * 
{@link XR10#XR_ERROR_HANDLE_INVALID ERROR_HANDLE_INVALID}
     * 
{@link XR10#XR_ERROR_INSTANCE_LOST ERROR_INSTANCE_LOST}
     * 
{@link XR10#XR_ERROR_SESSION_LOST ERROR_SESSION_LOST}
     * 
{@link XR10#XR_ERROR_FEATURE_UNSUPPORTED ERROR_FEATURE_UNSUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link XrVirtualKeyboardTextContextChangeInfoMETA}
     *
     * @param keyboard   the {@code XrVirtualKeyboardMETA} handle.
     * @param changeInfo the {@link XrVirtualKeyboardTextContextChangeInfoMETA} detailing prior input text context to the runtime.
     */
    @NativeType("XrResult")
    public static int xrChangeVirtualKeyboardTextContextMETA(XrVirtualKeyboardMETA keyboard, @NativeType("XrVirtualKeyboardTextContextChangeInfoMETA const *") XrVirtualKeyboardTextContextChangeInfoMETA changeInfo) {
        return nxrChangeVirtualKeyboardTextContextMETA(keyboard, changeInfo.address());
    }

}