From 394cbc465e776137834eea830038b43ea98f6268 Mon Sep 17 00:00:00 2001 From: cnlohr Date: Wed, 8 Mar 2017 00:30:48 -0500 Subject: Switch types over to avoiding extra struct keyword. Switch poses to "SurvivePose" type. --- include/libsurvive/poser.h | 22 ++++++------ include/libsurvive/survive.h | 8 ++--- include/libsurvive/survive_types.h | 17 +++++---- src/survive_cal.c | 6 ++-- src/survive_cal.h | 14 ++++---- src/survive_cal_lhfind.c | 14 ++++---- src/survive_config.c | 5 ++- src/survive_config.h | 4 +-- src/survive_data.c | 4 +-- src/survive_internal.h | 34 ++++++++---------- src/survive_process.c | 12 +++---- src/survive_vive.c | 74 ++++++++++++++++++++------------------ 12 files changed, 109 insertions(+), 105 deletions(-) diff --git a/include/libsurvive/poser.h b/include/libsurvive/poser.h index 4894acf..c514953 100644 --- a/include/libsurvive/poser.h +++ b/include/libsurvive/poser.h @@ -11,22 +11,22 @@ typedef enum PoserType_t POSERDATA_FULL_SCENE, //Full, statified X, Y sweep data for both lighthouses. } PoserType; -struct PoserData +typedef struct { PoserType pt; uint8_t data[0]; -}; +} PoserData; -struct PoserDataIMU +typedef struct { PoserType pt; uint8_t datamask; //0 = accel present, 1 = gyro present, 2 = mag present. FLT accel[3]; FLT gyro[3]; FLT mag[3]; -}; +} PoserDataIMU; -struct PoserDataLight +typedef struct { PoserType pt; int sensor_id; @@ -34,21 +34,21 @@ struct PoserDataLight uint32_t timecode; //In object-local ticks. FLT length; //In seconds FLT angle; //In radians from center of lighthouse. -}; +} PoserDataLight; -struct PoserDataFullScene +typedef struct { PoserType pt; //If "lengths[...]" < 0, means not a valid piece of sweep information. FLT lengths[SENSORS_PER_OBJECT][NUM_LIGHTHOUSES][2]; - FLT angles [SENSORS_PER_OBJECT][NUM_LIGHTHOUSES][2]; //2 Axes + FLT angles [SENSORS_PER_OBJECT][NUM_LIGHTHOUSES][2]; //2 Axes (Angles in LH space) - struct PoserDataIMU lastimu; -}; + PoserDataIMU lastimu; +} PoserDataFullScene; //When you register your posers using the internal system, -typedef int (*PoserCB)( struct SurviveObject * so, struct PoserData * pd ); +typedef int (*PoserCB)( SurviveObject * so, PoserData * pd ); #endif diff --git a/include/libsurvive/survive.h b/include/libsurvive/survive.h index 536c7fb..20e50ca 100644 --- a/include/libsurvive/survive.h +++ b/include/libsurvive/survive.h @@ -4,14 +4,14 @@ #include #include "poser.h" -struct SurviveContext; +typedef struct SurviveContext SurviveContext; //DANGER: This structure may be redefined. Note that it is logically split into 64-bit chunks //for optimization on 32- and 64-bit systems. struct SurviveObject { - struct SurviveContext * ctx; + SurviveContext * ctx; char codename[4]; //3 letters, null-terminated. Currently HMD, WM0, WM1. char drivername[4]; //3 letters for driver. Currently "HTC" @@ -27,8 +27,8 @@ struct SurviveObject //Pose Information, also "resolver" field. FLT PoseConfidence; //0..1 - FLT Position[3]; - FLT Rotation[4]; + SurvivePose OutPose; + SurvivePose FromLHPose[NUM_LIGHTHOUSES]; //Optionally filled out by poser, contains computed position from each lighthouse. void * PoserData; //Initialized to zero, configured by poser, can be anything the poser wants. PoserCB * PoserFn; diff --git a/include/libsurvive/survive_types.h b/include/libsurvive/survive_types.h index 593819f..6137774 100644 --- a/include/libsurvive/survive_types.h +++ b/include/libsurvive/survive_types.h @@ -9,6 +9,11 @@ #endif #endif +typedef struct SurvivePose +{ + FLT Pos[3]; + FLT Rot[4]; +} SurvivePose; //Careful with this, you can't just add another one right now, would take minor changes in survive_data.c and the cal tools. //It will also require a recompile. TODO: revisit this and correct the comment once fixed. @@ -17,13 +22,13 @@ #define INTBUFFSIZE 64 #define SENSORS_PER_OBJECT 32 -struct SurviveObject; -struct SurviveContext; +typedef struct SurviveObject SurviveObject; +typedef struct SurviveContext SurviveContext; -typedef void (*text_feedback_func)( struct SurviveContext * ctx, const char * fault ); -typedef void (*light_process_func)( struct SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length ); -typedef void (*imu_process_func)( struct SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id ); -typedef void (*angle_process_func)( struct SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle ); +typedef void (*text_feedback_func)( SurviveContext * ctx, const char * fault ); +typedef void (*light_process_func)( SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length ); +typedef void (*imu_process_func)( SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id ); +typedef void (*angle_process_func)( SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle ); #endif diff --git a/src/survive_cal.c b/src/survive_cal.c index 33d1faa..2acf51c 100644 --- a/src/survive_cal.c +++ b/src/survive_cal.c @@ -27,8 +27,8 @@ static void reset_calibration( struct SurviveCalData * cd ); void ootx_packet_clbk_d(ootx_decoder_context *ct, ootx_packet* packet) { - struct SurviveContext * ctx = (struct SurviveContext*)(ct->user); - struct SurviveCalData * cd = ctx->calptr; + SurviveContext * ctx = (SurviveContext*)(ct->user); + SurviveCalData * cd = ctx->calptr; int id = ct->user1; SV_INFO( "Got OOTX packet %d %p", id, cd ); @@ -36,7 +36,7 @@ void ootx_packet_clbk_d(ootx_decoder_context *ct, ootx_packet* packet) lighthouse_info_v6 v6; init_lighthouse_info_v6(&v6, packet->data); - struct BaseStationData * b = &ctx->bsd[id]; + BaseStationData * b = &ctx->bsd[id]; //print_lighthouse_info_v6(&v6); b->BaseStationID = v6.id; diff --git a/src/survive_cal.h b/src/survive_cal.h index bb4eb32..a5e372e 100644 --- a/src/survive_cal.h +++ b/src/survive_cal.h @@ -21,21 +21,21 @@ #include "ootx_decoder.h" #include "survive_internal.h" -void survive_cal_install( struct SurviveContext * ctx ); -int survive_cal_get_status( struct SurviveContext * ctx, char * description, int description_length ); +void survive_cal_install( SurviveContext * ctx ); +int survive_cal_get_status( SurviveContext * ctx, char * description, int description_length ); //void survive_cal_teardown( struct SurviveContext * ctx ); //Called from survive_default_light_process -void survive_cal_light( struct SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length ); -void survive_cal_angle( struct SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle ); +void survive_cal_light( SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length ); +void survive_cal_angle( SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle ); #define MAX_SENSORS_TO_CAL 96 #define DRPTS 1024 #define MAX_CAL_PT_DAT (MAX_SENSORS_TO_CAL*NUM_LIGHTHOUSES*2) struct SurviveCalData { - struct SurviveContext * ctx; + SurviveContext * ctx; //OOTX Data is sync'd off of the sync pulses coming from the lighthouses. ootx_decoder_context ootx_decoders[NUM_LIGHTHOUSES]; @@ -57,7 +57,7 @@ struct SurviveCalData int senid_of_checkpt; //This is a point on a watchman that can be used to check the lh solution. - struct SurviveObject * hmd; + SurviveObject * hmd; //Stage: // 0: Idle @@ -68,7 +68,7 @@ struct SurviveCalData //The following function is not included in the core survive_cal and must be compiled from a camfind file. //It should use data for stage 4 and report if it found the -int survive_cal_lhfind( struct SurviveCalData * cd ); +int survive_cal_lhfind( SurviveCalData * cd ); #endif diff --git a/src/survive_cal_lhfind.c b/src/survive_cal_lhfind.c index 93d9dc0..a1bb2cc 100644 --- a/src/survive_cal_lhfind.c +++ b/src/survive_cal_lhfind.c @@ -7,13 +7,13 @@ #define MIN_HITS_FOR_VALID 10 -FLT static RunOpti( struct SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat ); +FLT static RunOpti( SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat ); //Values used for RunTest() -int survive_cal_lhfind( struct SurviveCalData * cd ) +int survive_cal_lhfind( SurviveCalData * cd ) { - struct SurviveContext * ctx = cd->ctx; + SurviveContext * ctx = cd->ctx; int cycle, i; int lh = 0; FLT dx, dy, dz; @@ -137,8 +137,8 @@ int survive_cal_lhfind( struct SurviveCalData * cd ) } cd->ctx->bsd[lh].PositionSet = 1; - copy3d( cd->ctx->bsd[lh].Position, LighthousePos ); - quatcopy( cd->ctx->bsd[lh].Quaternion, LighthouseQuat ); + copy3d( cd->ctx->bsd[lh].Pose.Pos, LighthousePos ); + quatcopy( cd->ctx->bsd[lh].Pose.Rot, LighthouseQuat ); } return 0; //Return 0 if success. @@ -149,14 +149,14 @@ int survive_cal_lhfind( struct SurviveCalData * cd ) -static FLT RunOpti( struct SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat ) +static FLT RunOpti( SurviveCalData * cd, int lh, int print, FLT * LighthousePos, FLT * LighthouseQuat ) { int i, p; FLT UsToTarget[3]; FLT LastUsToTarget[3]; FLT mux = .9; quatsetnone( LighthouseQuat ); - struct SurviveObject * hmd = cd->hmd; + SurviveObject * hmd = cd->hmd; FLT * hmd_points = hmd->sensor_locations; FLT * hmd_normals = hmd->sensor_normals; diff --git a/src/survive_config.c b/src/survive_config.c index f30bf87..352a15b 100644 --- a/src/survive_config.c +++ b/src/survive_config.c @@ -66,12 +66,11 @@ void config_init() { } -void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx) { +void config_set_lighthouse(BaseStationData* bsd, uint8_t idx) { config_group *cg = lh_config+idx; config_set_uint32(cg,"index", idx); config_set_uint32(cg,"id", bsd->BaseStationID); - config_set_float_a(cg,"position", bsd->Position, 3); - config_set_float_a(cg,"quaternion", bsd->Quaternion, 4); + config_set_float_a(cg,"pose", &bsd->Pose.Pos[0], 7); config_set_float_a(cg,"fcalphase", bsd->fcalphase, 2); config_set_float_a(cg,"fcaltilt", bsd->fcaltilt,2); config_set_float_a(cg,"fcalcurve", bsd->fcalcurve,2); diff --git a/src/survive_config.h b/src/survive_config.h index 234db68..cd16c76 100644 --- a/src/survive_config.h +++ b/src/survive_config.h @@ -40,7 +40,7 @@ void config_init(); //void config_open(const char* path, const char* mode); void config_read(const char* path); //void config_write_lighthouse(struct BaseStationData* bsd, uint8_t length); -void config_set_lighthouse(struct BaseStationData* bsd, uint8_t idx); +void config_set_lighthouse(BaseStationData* bsd, uint8_t idx); void config_save(const char* path); const FLT config_set_float(config_group *cg, const char *tag, const FLT value); @@ -52,4 +52,4 @@ uint16_t config_read_float_array(config_group *cg, const char *tag, FLT** values uint32_t config_read_uint32(config_group *cg, const char *tag, const uint32_t def); const char* config_read_str(config_group *cg, const char *tag, const char *def); -#endif \ No newline at end of file +#endif diff --git a/src/survive_data.c b/src/survive_data.c index ac640c6..63cc5c2 100644 --- a/src/survive_data.c +++ b/src/survive_data.c @@ -6,9 +6,9 @@ #include //This is the disambiguator function, for taking light timing and figuring out place-in-sweep for a given photodiode. -void handle_lightcap( struct SurviveObject * so, struct LightcapElement * le ) +void handle_lightcap( SurviveObject * so, LightcapElement * le ) { - struct SurviveContext * ctx = so->ctx; + SurviveContext * ctx = so->ctx; //int32_t deltat = (uint32_t)le->timestamp - (uint32_t)so->last_master_time; //if( so->codename[0] != 'H' ) diff --git a/src/survive_internal.h b/src/survive_internal.h index 9d04d93..83a429c 100644 --- a/src/survive_internal.h +++ b/src/survive_internal.h @@ -29,20 +29,20 @@ struct SurviveContext; -struct SurviveUSBInterface; +struct SurvivecalData; typedef int (*DeviceDriverCb)( struct SurviveContext * ctx, void * driver ); typedef int (*DeviceDriverMagicCb)( struct SurviveContext * ctx, void * driver, int magic_code, void * data, int datalen ); //This is defined in survive.h -struct SurviveObject; -struct SurviveCalData; +typedef struct SurviveObject SurviveObject; +typedef struct SurviveCalData SurviveCalData; -struct BaseStationData +typedef struct { uint8_t PositionSet:1; - FLT Position[3]; - FLT Quaternion[4]; + + SurvivePose Pose; uint8_t OOTXSet:1; uint32_t BaseStationID; @@ -51,7 +51,7 @@ struct BaseStationData FLT fcalcurve[2]; FLT fcalgibpha[2]; FLT fcalgibmag[2]; -}; +} BaseStationData; struct SurviveContext { @@ -62,11 +62,11 @@ struct SurviveContext angle_process_func angleproc; //Calibration data: - struct BaseStationData bsd[NUM_LIGHTHOUSES]; + BaseStationData bsd[NUM_LIGHTHOUSES]; - struct SurviveCalData * calptr; //If and only if the calibration subsystem is attached. + SurviveCalData * calptr; //If and only if the calibration subsystem is attached. - struct SurviveObject ** objs; + SurviveObject ** objs; int objs_ct; void ** drivers; @@ -76,25 +76,21 @@ struct SurviveContext int driver_ct; }; -int survive_add_object( struct SurviveContext * ctx, struct SurviveObject * obj ); +int survive_add_object( SurviveContext * ctx, SurviveObject * obj ); -void survive_add_driver( struct SurviveContext * ctx, void * payload, DeviceDriverCb poll, DeviceDriverCb close, DeviceDriverMagicCb magic ); +void survive_add_driver( SurviveContext * ctx, void * payload, DeviceDriverCb poll, DeviceDriverCb close, DeviceDriverMagicCb magic ); //For lightcap, etc. Don't change this structure at all. Regular vive is dependent on it being exactly as-is. -struct LightcapElement +typedef struct { uint8_t sensor_id; uint8_t type; uint16_t length; uint32_t timestamp; -} __attribute__((packed)); +} __attribute__((packed)) LightcapElement; //This is the disambiguator function, for taking light timing and figuring out place-in-sweep for a given photodiode. -void handle_lightcap( struct SurviveObject * so, struct LightcapElement * le ); - - -//Accept Data from backend. -void survive_data_cb( struct SurviveUSBInterface * si ); +void handle_lightcap( SurviveObject * so, LightcapElement * le ); #endif diff --git a/src/survive_process.c b/src/survive_process.c index 75453da..edabfff 100644 --- a/src/survive_process.c +++ b/src/survive_process.c @@ -6,9 +6,9 @@ //XXX TODO: Once data is avialble in the context, use the stuff here to handle converting from time codes to //proper angles, then from there perform the rest of the solution. -void survive_default_light_process( struct SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length ) +void survive_default_light_process( SurviveObject * so, int sensor_id, int acode, int timeinsweep, uint32_t timecode, uint32_t length ) { - struct SurviveContext * ctx = so->ctx; + SurviveContext * ctx = so->ctx; int base_station = acode >> 2; int axis = acode & 1; @@ -25,7 +25,7 @@ void survive_default_light_process( struct SurviveObject * so, int sensor_id, in //Need to now do angle correction. #if 1 - struct BaseStationData * bsd = &ctx->bsd[base_station]; + BaseStationData * bsd = &ctx->bsd[base_station]; //XXX TODO: This seriously needs to be worked on. See: https://github.com/cnlohr/libsurvive/issues/18 angle += bsd->fcalphase[axis]; @@ -39,9 +39,9 @@ void survive_default_light_process( struct SurviveObject * so, int sensor_id, in } -void survive_default_angle_process( struct SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle ) +void survive_default_angle_process( SurviveObject * so, int sensor_id, int acode, uint32_t timecode, FLT length, FLT angle ) { - struct SurviveContext * ctx = so->ctx; + SurviveContext * ctx = so->ctx; if( ctx->calptr ) { survive_cal_angle( so, sensor_id, acode, timecode, length, angle ); @@ -51,7 +51,7 @@ void survive_default_angle_process( struct SurviveObject * so, int sensor_id, in } -void survive_default_imu_process( struct SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id ) +void survive_default_imu_process( SurviveObject * so, int16_t * accelgyro, uint32_t timecode, int id ) { //TODO: Writeme! } diff --git a/src/survive_vive.c b/src/survive_vive.c index 47886c9..6be5114 100644 --- a/src/survive_vive.c +++ b/src/survive_vive.c @@ -24,13 +24,6 @@ struct SurviveViveData; -//USB Subsystem -void survive_usb_close( struct SurviveContext * t ); -int survive_usb_init( struct SurviveViveData * sv, struct SurviveObject * hmd, struct SurviveObject *wm0, struct SurviveObject * wm1 ); -int survive_usb_poll( struct SurviveContext * ctx ); -int survive_get_config( char ** config, struct SurviveViveData * ctx, int devno, int interface, int send_extra_magic ); - - const short vidpids[] = { 0x0bb4, 0x2c87, 0, //The main HTC HMD device 0x28de, 0x2000, 0, //Valve lighthouse @@ -60,15 +53,18 @@ const char * devnames[] = { #define USB_IF_LIGHTCAP 4 #define MAX_INTERFACES 5 -typedef void (*usb_callback)( struct SurviveUSBInterface * ti ); +typedef struct SurviveUSBInterface SurviveUSBInterface; +typedef struct SurviveViveData SurviveViveData; + +typedef void (*usb_callback)( SurviveUSBInterface * ti ); struct SurviveUSBInterface { - struct SurviveViveData * sv; - struct SurviveContext * ctx; + SurviveViveData * sv; + SurviveContext * ctx; struct libusb_transfer * transfer; - struct SurviveObject * assoc_obj; + SurviveObject * assoc_obj; int actual_len; uint8_t buffer[INTBUFFSIZE]; usb_callback cb; @@ -78,16 +74,24 @@ struct SurviveUSBInterface struct SurviveViveData { - struct SurviveContext * ctx; + SurviveContext * ctx; //XXX TODO: UN-STATICIFY THIS. - struct SurviveUSBInterface uiface[MAX_INTERFACES]; + SurviveUSBInterface uiface[MAX_INTERFACES]; //USB Subsystem struct libusb_context* usbctx; struct libusb_device_handle * udev[MAX_USB_DEVS]; }; +void survive_data_cb( SurviveUSBInterface * si ); + +//USB Subsystem +void survive_usb_close( SurviveContext * t ); +int survive_usb_init( SurviveViveData * sv, SurviveObject * hmd, SurviveObject *wm0, SurviveObject * wm1 ); +int survive_usb_poll( SurviveContext * ctx ); +int survive_get_config( char ** config, SurviveViveData * ctx, int devno, int interface, int send_extra_magic ); + @@ -115,10 +119,10 @@ static void handle_transfer(struct libusb_transfer* transfer) -static int AttachInterface( struct SurviveViveData * sv, struct SurviveObject * assocobj, int which_interface_am_i, libusb_device_handle * devh, int endpoint, usb_callback cb, const char * hname ) +static int AttachInterface( SurviveViveData * sv, SurviveObject * assocobj, int which_interface_am_i, libusb_device_handle * devh, int endpoint, usb_callback cb, const char * hname ) { - struct SurviveContext * ctx = sv->ctx; - struct SurviveUSBInterface * iface = &sv->uiface[which_interface_am_i]; + SurviveContext * ctx = sv->ctx; + SurviveUSBInterface * iface = &sv->uiface[which_interface_am_i]; iface->ctx = ctx; iface->sv = sv; iface->which_interface_am_i = which_interface_am_i; @@ -680,7 +684,7 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata ) } - struct LightcapElement les[10]; + LightcapElement les[10]; int lese = 0; //les's end //Second, go through all LEDs and extract the lightevent from them. @@ -711,7 +715,7 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata ) //reverse sorted, but that is to minimize operations. To read it //in sorted order simply read it back backwards. //Use insertion sort, since we should most of the time, be in order. - struct LightcapElement * le = &les[lese++]; + LightcapElement * le = &les[lese++]; le->sensor_id = led; le->type = 0xfe; @@ -725,7 +729,7 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata ) int swap = lese-2; while( swap >= 0 && les[swap].timestamp < les[swap+1].timestamp ) { - struct LightcapElement l; + LightcapElement l; memcpy( &l, &les[swap], sizeof( l ) ); memcpy( &les[swap], &les[swap+1], sizeof( l ) ); memcpy( &les[swap+1], &l, sizeof( l ) ); @@ -744,17 +748,17 @@ static void handle_watchman( struct SurviveObject * w, uint8_t * readdata ) return; end: { - struct SurviveContext * ctx = w->ctx; + SurviveContext * ctx = w->ctx; SV_INFO( "Light decoding fault: %d\n", fault ); } } } -void survive_data_cb( struct SurviveUSBInterface * si ) +void survive_data_cb( SurviveUSBInterface * si ) { int size = si->actual_len; - struct SurviveContext * ctx = si->ctx; + SurviveContext * ctx = si->ctx; #if 0 int i; printf( "%16s: %d: ", si->hname, len ); @@ -767,7 +771,7 @@ void survive_data_cb( struct SurviveUSBInterface * si ) #endif int iface = si->which_interface_am_i; - struct SurviveObject * obj = si->assoc_obj; + SurviveObject * obj = si->assoc_obj; uint8_t * readdata = si->buffer; int id = POP1; @@ -818,7 +822,7 @@ void survive_data_cb( struct SurviveUSBInterface * si ) case USB_IF_WATCHMAN1: case USB_IF_WATCHMAN2: { - struct SurviveObject * w = obj; + SurviveObject * w = obj; if( id == 35 ) { handle_watchman( w, readdata); @@ -844,7 +848,7 @@ void survive_data_cb( struct SurviveUSBInterface * si ) int i; for( i = 0; i < 7; i++ ) { - handle_lightcap( obj, (struct LightcapElement*)&readdata[i*8] ); + handle_lightcap( obj, (LightcapElement*)&readdata[i*8] ); } break; } @@ -875,7 +879,7 @@ static int jsoneq(const char *json, jsmntok_t *tok, const char *s) { } -static int ParsePoints( struct SurviveContext * ctx, struct SurviveObject * so, char * ct0conf, FLT ** floats_out, jsmntok_t * t, int i ) +static int ParsePoints( SurviveContext * ctx, SurviveObject * so, char * ct0conf, FLT ** floats_out, jsmntok_t * t, int i ) { int k; int pts = t[i+1].size; @@ -914,9 +918,9 @@ static int ParsePoints( struct SurviveContext * ctx, struct SurviveObject * so, return 0; } -static int LoadConfig( struct SurviveViveData * sv, struct SurviveObject * so, int devno, int iface, int extra_magic ) +static int LoadConfig( SurviveViveData * sv, SurviveObject * so, int devno, int iface, int extra_magic ) { - struct SurviveContext * ctx = sv->ctx; + SurviveContext * ctx = sv->ctx; char * ct0conf = 0; int len = survive_get_config( &ct0conf, sv, devno, iface, extra_magic ); @@ -1002,21 +1006,21 @@ static int LoadConfig( struct SurviveViveData * sv, struct SurviveObject * so, i } -int survive_vive_close( struct SurviveContext * ctx, void * driver ) +int survive_vive_close( SurviveContext * ctx, void * driver ) { - struct SurviveViveData * sv = driver; + SurviveViveData * sv = driver; survive_vive_usb_close( sv ); } -int DriverRegHTCVive( struct SurviveContext * ctx ) +int DriverRegHTCVive( SurviveContext * ctx ) { int i, r; - struct SurviveObject * hmd = calloc( 1, sizeof( struct SurviveObject ) ); - struct SurviveObject * wm0 = calloc( 1, sizeof( struct SurviveObject ) ); - struct SurviveObject * wm1 = calloc( 1, sizeof( struct SurviveObject ) ); - struct SurviveViveData * sv = calloc( 1, sizeof( struct SurviveViveData ) ); + SurviveObject * hmd = calloc( 1, sizeof( SurviveObject ) ); + SurviveObject * wm0 = calloc( 1, sizeof( SurviveObject ) ); + SurviveObject * wm1 = calloc( 1, sizeof( SurviveObject ) ); + SurviveViveData * sv = calloc( 1, sizeof( SurviveViveData ) ); sv->ctx = ctx; -- cgit v1.2.3