enpose_api.h

 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum EnposeStatus {
    ENPOSE_OK = 0,           
    ENPOSE_ERR_INVALID_ARG = -1, 
    ENPOSE_ERR_IO = -2,      
    ENPOSE_ERR_PANIC = -3    
} EnposeStatus;
 
typedef struct EnposeDeviceInfo {
    char ip[46];        
    uint32_t serial;    
    bool compatible;    
} EnposeDeviceInfo;
 
typedef struct EnposeMarkerPose {
    uint64_t timestamp;     
    uint16_t marker_id;     
    double x;               
    double y;
    double z;
    double rotation[9];     
    double position_rmse;   
    double rotation_rmse;   
    uint8_t sensors;        
    uint8_t observed_emitters;
} EnposeMarkerPose;
 
typedef struct EnposePoseStream EnposePoseStream;
 
EnposeStatus enpose_discover(EnposeDeviceInfo **out_devices, size_t *out_count);
 
void enpose_device_info_array_free(EnposeDeviceInfo *devices, size_t count);
 
EnposePoseStream *enpose_pose_stream_connect(const char *ip, bool create_thread);
 
EnposeStatus enpose_pose_stream_receive(EnposePoseStream *stream,
                                        bool block,
                                        EnposeMarkerPose **out_poses,
                                        size_t *out_count);
 
void enpose_marker_pose_array_free(EnposeMarkerPose *poses, size_t count);
 
void enpose_pose_stream_free(EnposePoseStream *stream);
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
/*
 * Compile-time check that these declarations still describe the same memory
 * layout as the Rust definitions they mirror (rust/src/ffi.rs carries the
 * layout table and the list of mirrors). A field reordered or retyped on
 * either side breaks the build here — in every C and C++ translation unit that
 * includes this header, the C++ wrapper included — instead of silently
 * misreading every device and pose at run time.
 *
 * Field widths are checked alongside the offsets: widening a field can leave
 * every offset and the total size untouched by consuming the padding next to
 * it (uint16_t -> uint32_t for marker_id, say), while the two sides then
 * disagree about how many of those bytes carry the value.
 *
 * 64-bit targets only: a 32-bit x86 ABI aligns double to 4 and produces a
 * different, equally valid layout. Skipped as well on pre-C11 compilers, which
 * have no static assertion to use.
 */
#if defined(UINTPTR_MAX) && UINTPTR_MAX == 0xFFFFFFFFFFFFFFFFULL
 
#if defined(__cplusplus)
#define ENPOSE_STATIC_ASSERT(cond, msg) static_assert(cond, msg)
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#define ENPOSE_STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
#else
/* Pre-C11: no static assertion to use. Expand to a harmless repeated
 * declaration rather than to nothing, which would leave a stray semicolon at
 * file scope. */
#define ENPOSE_STATIC_ASSERT(cond, msg) extern int enpose_static_assert_unavailable
#endif
 
ENPOSE_STATIC_ASSERT(sizeof(EnposeStatus) == sizeof(int), "EnposeStatus is a C int");
ENPOSE_STATIC_ASSERT(sizeof(bool) == 1, "bool crosses the ABI as one byte");
 
/* Offset and width of one field, in one line. */
#define ENPOSE_ASSERT_FIELD(type, field, off, width)                       \
    ENPOSE_STATIC_ASSERT(offsetof(type, field) == (off), #type "." #field " offset"); \
    ENPOSE_STATIC_ASSERT(sizeof(((type *)0)->field) == (width), #type "." #field " width")
 
ENPOSE_STATIC_ASSERT(sizeof(EnposeDeviceInfo) == 56, "EnposeDeviceInfo size");
ENPOSE_ASSERT_FIELD(EnposeDeviceInfo, ip, 0, 46);
ENPOSE_ASSERT_FIELD(EnposeDeviceInfo, serial, 48, 4);
ENPOSE_ASSERT_FIELD(EnposeDeviceInfo, compatible, 52, 1);
 
ENPOSE_STATIC_ASSERT(sizeof(EnposeMarkerPose) == 136, "EnposeMarkerPose size");
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, timestamp, 0, 8);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, marker_id, 8, 2);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, x, 16, 8);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, y, 24, 8);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, z, 32, 8);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, rotation, 40, 72);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, position_rmse, 112, 8);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, rotation_rmse, 120, 8);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, sensors, 128, 1);
ENPOSE_ASSERT_FIELD(EnposeMarkerPose, observed_emitters, 129, 1);
 
#undef ENPOSE_ASSERT_FIELD
 
#undef ENPOSE_STATIC_ASSERT
 
#endif /* 64-bit target */