static int getf(ohmd_device* device, ohmd_float_value type, float* out)
{
rift_priv* priv = rift_priv_get(device);
switch(type){
case OHMD_DISTORTION_K: {
for (int i = 0; i < 6; i++) {
out[i] = priv->display_info.distortion_k[i];
}
break;
}
case OHMD_ROTATION_QUAT: {
*(quatf*)out = priv->sensor_fusion.orient;
break;
}
case OHMD_POSITION_VECTOR:
out[0] = out[1] = out[2] = 0;
break;
default:
ohmd_set_error(priv->base.ctx, "invalid type given to getf (%d)", type);
return -1;
break;
}
return 0;
}
static void set_coordinate_frame(rift_priv* priv, rift_coordinate_frame coordframe)
{
priv->coordinate_frame = coordframe;
// set the RIFT_SCF_SENSOR_COORDINATES in the sensor config to match whether coordframe is hmd or sensor
SETFLAG(priv->sensor_config.flags, RIFT_SCF_SENSOR_COORDINATES, coordframe == RIFT_CF_SENSOR);
// encode send the new config to the Rift
unsigned char buf[FEATURE_BUFFER_SIZE];
int size = encode_sensor_config(buf, &priv->sensor_config);
if(send_feature_report(priv, buf, size) == -1){
ohmd_set_error(priv->base.ctx, "send_feature_report failed in set_coordinate frame");
return;
}
// read the state again, set the hw_coordinate_frame to match what
// the hardware actually is set to just incase it doesn't stick.
size = get_feature_report(priv, RIFT_CMD_SENSOR_CONFIG, buf);
if(size <= 0){
LOGW("could not set coordinate frame");
priv->hw_coordinate_frame = RIFT_CF_HMD;
return;
}
decode_sensor_config(&priv->sensor_config, buf, size);
priv->hw_coordinate_frame = (priv->sensor_config.flags & RIFT_SCF_SENSOR_COORDINATES) ? RIFT_CF_SENSOR : RIFT_CF_HMD;
if(priv->hw_coordinate_frame != coordframe) {
LOGW("coordinate frame didn't stick");
}
}
void* ohmd_allocfn(ohmd_context* ctx, char* e_msg, size_t size)
{
void* ret = calloc(1, size);
if(!ret)
ohmd_set_error(ctx, "%s", e_msg);
return ret;
}
ohmd_device* OHMD_APIENTRY ohmd_list_open_device(ohmd_context* ctx, int index)
{
if(index >= 0 && index < ctx->list.num_devices){
ohmd_device_desc* desc = &ctx->list.devices[index];
ohmd_driver* driver = (ohmd_driver*)desc->driver_ptr;
ohmd_device* device = driver->open_device(driver, desc);
if (device == NULL)
return NULL;
ctx->active_devices[ctx->num_active_devices++] = device;
return device;
}
ohmd_set_error(ctx, "no device with index: %d", index);
return NULL;
}
static ohmd_device* open_device(ohmd_driver* driver, ohmd_device_desc* desc)
{
rift_priv* priv = ohmd_alloc(driver->ctx, sizeof(rift_priv));
if(!priv)
goto cleanup;
priv->base.ctx = driver->ctx;
// Open the HID device
priv->handle = hid_open_path(desc->path);
if(!priv->handle)
goto cleanup;
if(hid_set_nonblocking(priv->handle, 1) == -1){
ohmd_set_error(driver->ctx, "failed to set non-blocking on device");
goto cleanup;
}
unsigned char buf[FEATURE_BUFFER_SIZE];
int size;
// Read and decode the sensor range
size = get_feature_report(priv, RIFT_CMD_RANGE, buf);
decode_sensor_range(&priv->sensor_range, buf, size);
dump_packet_sensor_range(&priv->sensor_range);
// Read and decode display information
size = get_feature_report(priv, RIFT_CMD_DISPLAY_INFO, buf);
decode_sensor_display_info(&priv->display_info, buf, size);
dump_packet_sensor_display_info(&priv->display_info);
// Read and decode the sensor config
size = get_feature_report(priv, RIFT_CMD_SENSOR_CONFIG, buf);
decode_sensor_config(&priv->sensor_config, buf, size);
dump_packet_sensor_config(&priv->sensor_config);
// if the sensor has display info data, use HMD coordinate frame
priv->coordinate_frame = priv->display_info.distortion_type != RIFT_DT_NONE ? RIFT_CF_HMD : RIFT_CF_SENSOR;
// apply sensor config
set_coordinate_frame(priv, priv->coordinate_frame);
// set keep alive interval to n seconds
pkt_keep_alive keep_alive = { 0, KEEP_ALIVE_VALUE };
size = encode_keep_alive(buf, &keep_alive);
send_feature_report(priv, buf, size);
// Update the time of the last keep alive we have sent.
priv->last_keep_alive = ohmd_get_tick();
// update sensor settings with new keep alive value
// (which will have been ignored in favor of the default 1000 ms one)
size = get_feature_report(priv, RIFT_CMD_SENSOR_CONFIG, buf);
decode_sensor_config(&priv->sensor_config, buf, size);
dump_packet_sensor_config(&priv->sensor_config);
// Set default device properties
ohmd_set_default_device_properties(&priv->base.properties);
// Set device properties
priv->base.properties.hsize = priv->display_info.h_screen_size;
priv->base.properties.vsize = priv->display_info.v_screen_size;
priv->base.properties.hres = priv->display_info.h_resolution;
priv->base.properties.vres = priv->display_info.v_resolution;
priv->base.properties.lens_sep = priv->display_info.lens_separation;
priv->base.properties.lens_vpos = priv->display_info.v_center;
priv->base.properties.fov = DEG_TO_RAD(125.5144f); // TODO calculate.
priv->base.properties.ratio = ((float)priv->display_info.h_resolution / (float)priv->display_info.v_resolution) / 2.0f;
// calculate projection eye projection matrices from the device properties
ohmd_calc_default_proj_matrices(&priv->base.properties);
// set up device callbacks
priv->base.update = update_device;
priv->base.close = close_device;
priv->base.getf = getf;
// initialize sensor fusion
ofusion_init(&priv->sensor_fusion);
return &priv->base;
cleanup:
if(priv)
free(priv);
return NULL;
}
static ohmd_device* open_device(ohmd_driver* driver, ohmd_device_desc* desc)
{
rift_priv* priv = ohmd_alloc(driver->ctx, sizeof(rift_priv));
if(!priv)
goto cleanup;
priv->base.ctx = driver->ctx;
// Open the HID device
priv->handle = hid_open_path(desc->path);
if(!priv->handle) {
char* path = _hid_to_unix_path(desc->path);
ohmd_set_error(driver->ctx, "Could not open %s. "
"Check your rights.", path);
free(path);
goto cleanup;
}
if(hid_set_nonblocking(priv->handle, 1) == -1){
ohmd_set_error(driver->ctx, "failed to set non-blocking on device");
goto cleanup;
}
unsigned char buf[FEATURE_BUFFER_SIZE];
int size;
// if the sensor has display info data, use HMD coordinate frame
priv->coordinate_frame = priv->display_info.distortion_type != RIFT_DT_NONE ? RIFT_CF_HMD : RIFT_CF_SENSOR;
// enable calibration
SETFLAG(priv->sensor_config.flags, RIFT_SCF_USE_CALIBRATION, 1);
SETFLAG(priv->sensor_config.flags, RIFT_SCF_AUTO_CALIBRATION, 1);
// apply sensor config
set_coordinate_frame(priv, priv->coordinate_frame);
// set keep alive interval to n seconds
pkt_keep_alive keep_alive = { 0, KEEP_ALIVE_VALUE };
size = dp_encode_keep_alive(buf, &keep_alive);
send_feature_report(priv, buf, size);
// Update the time of the last keep alive we have sent.
priv->last_keep_alive = ohmd_get_tick();
// Set default device properties
ohmd_set_default_device_properties(&priv->base.properties);
// Set device properties
//NOTE: These values are estimations, no one has taken one appart to check
priv->base.properties.hsize = 0.1698f;
priv->base.properties.vsize = 0.0936f;
priv->base.properties.hres = 1920;
priv->base.properties.vres = 1080;
priv->base.properties.lens_sep = 0.0849f;
priv->base.properties.lens_vpos = 0.0468f;;
priv->base.properties.fov = DEG_TO_RAD(110.0); // TODO calculate.
priv->base.properties.ratio = ((float)1920 / (float)1080) / 2.0f;
// calculate projection eye projection matrices from the device properties
ohmd_calc_default_proj_matrices(&priv->base.properties);
// set up device callbacks
priv->base.update = update_device;
priv->base.close = close_device;
priv->base.getf = getf;
// initialize sensor fusion
ofusion_init(&priv->sensor_fusion);
return &priv->base;
cleanup:
if(priv)
free(priv);
return NULL;
}
static ohmd_device* open_device(ohmd_driver* driver, ohmd_device_desc* desc)
{
rift_priv* priv = ohmd_alloc(driver->ctx, sizeof(rift_priv));
if(!priv)
goto cleanup;
priv->base.ctx = driver->ctx;
// Open the HID device
priv->handle = hid_open_path(desc->path);
if(!priv->handle)
goto cleanup;
if(hid_set_nonblocking(priv->handle, 1) == -1){
ohmd_set_error(driver->ctx, "failed to set non-blocking on device");
goto cleanup;
}
unsigned char buf[FEATURE_BUFFER_SIZE];
int size;
// Set default values.
ohmd_set_default_device_properties(&priv->base);
// Read and decode the sensor range
size = get_feature_report(priv, RIFT_CMD_RANGE, buf);
decode_sensor_range(&priv->sensor_range, buf, size);
dump_packet_sensor_range(&priv->sensor_range);
// Read and decode display information
size = get_feature_report(priv, RIFT_CMD_DISPLAY_INFO, buf);
decode_sensor_display_info(&priv->display_info, buf, size);
dump_packet_sensor_display_info(&priv->display_info);
// Read and decode the sensor config
size = get_feature_report(priv, RIFT_CMD_SENSOR_CONFIG, buf);
decode_sensor_config(&priv->sensor_config, buf, size);
dump_packet_sensor_config(&priv->sensor_config);
// if the sensor has display info data, use HMD coordinate frame
priv->coordinate_frame = priv->display_info.distortion_type != RIFT_DT_NONE ? RIFT_CF_HMD : RIFT_CF_SENSOR;
// apply sensor config
set_coordinate_frame(priv, priv->coordinate_frame);
// set keep alive interval to n seconds
pkt_keep_alive keep_alive = { 0, KEEP_ALIVE_VALUE };
size = encode_keep_alive(buf, &keep_alive);
send_feature_report(priv, buf, size);
// Update the time of the last keep alive we have sent.
priv->last_keep_alive = ohmd_get_tick();
// update sensor settings with new keep alive value
// (which will have been ignored in favor of the default 1000 ms one)
size = get_feature_report(priv, RIFT_CMD_SENSOR_CONFIG, buf);
decode_sensor_config(&priv->sensor_config, buf, size);
dump_packet_sensor_config(&priv->sensor_config);
// Also sets the exported values.
calc_derived_values(priv);
priv->base.update = update_device;
priv->base.close = close_device;
priv->base.getf = getf;
ofusion_init(&priv->sensor_fusion);
return &priv->base;
cleanup:
if(priv)
free(priv);
return NULL;
}
