types.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020-2023 Tilt Five, Inc.
 *
 * 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.
 */
 
#pragma once
 
 
#ifndef __cplusplus
#include <stdbool.h>
#include <stdint.h>
#else
#include <cstdint>
#endif
 
 
 
#define T5_MAX_STRING_PARAM_LEN (260)
 
#define T5_MIN_CAM_IMAGE_BUFFER_WIDTH (768)
 
#define T5_MIN_CAM_IMAGE_BUFFER_HEIGHT (600)
 
#define T5_MAX_GAMEBOARD_POSES (1)
 
typedef struct {
    float x;
    float y;
} T5_Vec2;
 
typedef struct {
    uint32_t x;
    uint32_t y;
} T5_Offset;
 
typedef struct {
    uint32_t width;
    uint32_t height;
} T5_Extent;
 
typedef struct {
    T5_Offset offset;
    T5_Extent extent;
} T5_Rect;
 
typedef struct {
    float x;
    float y;
} T5_Offsetf;
 
typedef struct {
    float width;
    float height;
} T5_Extentf;
 
typedef struct {
    T5_Offsetf offset;
    T5_Extentf extent;
} T5_Rectf;
 
typedef struct {
    float x;
    float y;
    float z;
} T5_Vec3;
 
typedef struct {
    float w;
    float x;
    float y;
    float z;
} T5_Quat;
 
typedef enum {
    kT5_MatrixOrder_RowMajor    = 1,
    kT5_MatrixOrder_ColumnMajor = 2,
} T5_MatrixOrder;
 
typedef enum {
    kT5_DepthRange_MinusOneToOne = 1,
    kT5_DepthRange_ZeroToOne     = 2,
} T5_DepthRange;
 
typedef enum {
    kT5_CartesianCoordinateHandedness_Left  = 1,
    kT5_CartesianCoordinateHandedness_Right = 2,
} T5_CartesianCoordinateHandedness;
 
typedef struct T5_ContextImpl* T5_Context;
 
typedef struct T5_GlassesImpl* T5_Glasses;
 
typedef uint8_t T5_WandHandle;
 
typedef enum {
    kT5_GraphicsApi_None = 1,
 
    kT5_GraphicsApi_GL = 2,
 
    kT5_GraphicsApi_D3D11 = 3,
 
    kT5_GraphicsApi_Vulkan = 4,
 
    kT5_GraphicsApi_D3D12 = 5,
 
 
    kT5_GraphicsApi_GL_TI = 12,
 
    kT5_GraphicsApi_D3D11_TI = 13,
 
    kT5_GraphicsApi_Vulkan_TI = 14,
 
    kT5_GraphicsApi_D3D12_TI = 15,
} T5_GraphicsApi;
 
typedef enum {
    kT5_GraphicsApi_GL_TextureMode_Pair = 1,
 
    kT5_GraphicsApi_GL_TextureMode_Array = 2,
} T5_GraphicsApi_GL_TextureMode;
 
typedef struct {
    T5_GraphicsApi_GL_TextureMode textureMode;
 
    uint32_t leftEyeArrayIndex;
 
    uint32_t rightEyeArrayIndex;
} T5_GraphicsContextGL;
 
typedef enum {
    kT5_GraphicsApi_Vulkan_TextureMode_Image = 1,
 
    kT5_GraphicsApi_Vulkan_TextureMode_ImageView = 2,
} T5_GraphicsApi_Vulkan_TextureMode;
 
typedef struct {
    void* instance;
 
    void* physicalDevice;
 
    void* device;
 
    void* queue;
 
    uint32_t queueFamilyIndex;
 
    T5_GraphicsApi_Vulkan_TextureMode textureMode;
} T5_GraphicsContextVulkan;
 
typedef struct {
    void* device;
 
    void* queue;
} T5_GraphicsContextD3D12;
 
typedef enum {
    kT5_GameboardType_None = 1,
 
    kT5_GameboardType_LE = 2,
 
    kT5_GameboardType_XE = 3,
 
    kT5_GameboardType_XE_Raised = 4,
} T5_GameboardType;
 
typedef struct {
    float viewableExtentPositiveX;
 
    float viewableExtentNegativeX;
 
    float viewableExtentPositiveY;
 
    float viewableExtentNegativeY;
 
    float viewableExtentPositiveZ;
} T5_GameboardSize;
 
typedef struct {
    const char* applicationId;
 
    const char* applicationVersion;
 
    uint8_t sdkType;
 
    uint64_t reserved;
} T5_ClientInfo;
 
typedef enum {
    kT5_ConnectionState_ExclusiveConnection = 1,
 
    kT5_ConnectionState_ExclusiveReservation = 2,
 
    kT5_ConnectionState_NotExclusivelyConnected = 3,
 
    kT5_ConnectionState_Disconnected = 4,
} T5_ConnectionState;
 
typedef enum {
    kT5_GlassesPoseUsage_GlassesPresentation = 1,
 
    kT5_GlassesPoseUsage_SpectatorPresentation = 2,
} T5_GlassesPoseUsage;
 
typedef struct {
    uint64_t timestampNanos;
 
    T5_Vec3 posGLS_STAGE;
 
    T5_Quat rotToGLS_STAGE;
 
    T5_GameboardType gameboardType;
} T5_GlassesPose;
 
typedef struct {
    uint64_t timestampNanos;
 
    T5_Vec3 posBOARD_STAGE;
 
    T5_Quat rotToBOARD_STAGE;
 
    T5_GameboardType gameboardType;
 
    uint64_t id;
} T5_GameboardPose;
 
typedef struct {
    uint8_t cameraIndex;
 
    bool enabled;
} T5_CameraStreamConfig;
 
typedef struct {
    void* leftTexHandle;
 
    void* rightTexHandle;
 
    uint16_t texWidth_PIX;
 
    uint16_t texHeight_PIX;
 
    bool isSrgb;
 
    bool isUpsideDown;
 
    struct {
        float startX_VCI;
        float startY_VCI;
        float width_VCI;
        float height_VCI;
    } vci;
 
    T5_Quat rotToLVC_STAGE;
 
    T5_Vec3 posLVC_STAGE;
 
    T5_Quat rotToRVC_STAGE;
 
    T5_Vec3 posRVC_STAGE;
} T5_FrameInfo;
 
typedef struct {
    struct {
        void* texture;
 
        T5_Extent dimensions;
 
        uint16_t arraySize;
    } texture;
 
    struct {
        T5_Rect rect;
 
        uint16_t arrayIndex;
    } subImage;
 
    int64_t format;
 
    T5_Rectf vci;
} T5_TextureInfo;
 
typedef struct {
    uint16_t imageWidth;
 
    uint16_t imageHeight;
 
    uint16_t imageStride;
 
    uint8_t cameraIndex;
 
    uint8_t illuminationMode;
 
    uint32_t bufferSize;
 
    uint8_t* pixelData;
 
    T5_Vec3 posCAM_STAGE;
 
    T5_Quat rotToCAM_STAGE;
} T5_CamImage;
 
typedef struct {
    T5_Vec2 pixelCoord_PIX;
 
    T5_Vec2 pixelCoord_IMG;
 
    uint8_t cameraIndex;
} T5_PixelDewarp;
 
typedef struct {
    bool enabled;
 
} T5_WandStreamConfig;
 
typedef enum {
    kT5_WandStreamEventType_Connect = 1,
 
    kT5_WandStreamEventType_Disconnect = 2,
 
    kT5_WandStreamEventType_Desync = 3,
 
    kT5_WandStreamEventType_Report = 4,
} T5_WandStreamEventType;
 
typedef enum {
    kT5_Hand_Unknown = 0,
 
    kT5_Hand_Left = 1,
 
    kT5_Hand_Right = 2,
} T5_Hand;
 
typedef struct {
    uint64_t timestampNanos;
 
    bool analogValid;
 
    bool batteryValid;
 
    bool buttonsValid;
 
    bool poseValid;
 
    float trigger;
 
    T5_Vec2 stick;
 
    // TODO(khunt) : Determine units
    uint8_t battery;
 
    struct {
        bool t5;
        bool one;
        bool two;
        bool three;
        bool a;
        bool b;
        bool x;
        bool y;
    } buttons;
 
    T5_Quat rotToWND_STAGE;
 
    T5_Vec3 posAim_STAGE;
 
    T5_Vec3 posFingertips_STAGE;
 
    T5_Vec3 posGrip_STAGE;
 
    T5_Hand hand;
} T5_WandReport;
 
typedef struct {
    T5_WandHandle wandId;
 
    T5_WandStreamEventType type;
 
    uint64_t timestampNanos;
 
    T5_WandReport report;
} T5_WandStreamEvent;
 
typedef enum {
    kT5_ParamGlasses_Float_IPD = 1,
 
    kT5_ParamGlasses_UTF8_FriendlyName = 6,
} T5_ParamGlasses;
 
typedef enum {
    kT5_ParamSys_UTF8_Service_Version = 1,
 
    kT5_ParamSys_Integer_CPL_AttRequired = 2,
} T5_ParamSys;
 
typedef struct {
    double matrix[16];
 
    double fieldOfView;
 
    double aspectRatio;
 
    uint16_t framebufferWidth;
 
    uint16_t framebufferHeight;
} T5_ProjectionInfo;