diff options
Diffstat (limited to 'LibOVR/Src/OVR_Sensor2ImplUtil.h')
| -rw-r--r-- | LibOVR/Src/OVR_Sensor2ImplUtil.h | 676 |
1 files changed, 676 insertions, 0 deletions
diff --git a/LibOVR/Src/OVR_Sensor2ImplUtil.h b/LibOVR/Src/OVR_Sensor2ImplUtil.h new file mode 100644 index 0000000..ffe9b6a --- /dev/null +++ b/LibOVR/Src/OVR_Sensor2ImplUtil.h @@ -0,0 +1,676 @@ +/************************************************************************************ + +Filename : OVR_Sensor2ImplUtil.h +Content : DK2 sensor device feature report utils. +Created : January 27, 2014 +Authors : Lee Cooper + +Copyright : Copyright 2014 Oculus VR, Inc. All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); +you may not use the Oculus VR Rift SDK except in compliance with the License, +which is provided at the time of installation or download, or which +otherwise accompanies this software in either electronic or hard copy form. + +You may obtain a copy of the License at + +http://www.oculusvr.com/licenses/LICENSE-3.1 + +Unless required by applicable law or agreed to in writing, the Oculus VR SDK +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. + +*************************************************************************************/ + +#ifndef OVR_Sensor2ImplUtil_h +#define OVR_Sensor2ImplUtil_h + +#include "OVR_Device.h" +#include "OVR_SensorImpl_Common.h" +#include "Kernel/OVR_Alg.h" + +namespace OVR { + +using namespace Alg; + +// Tracking feature report. +struct TrackingImpl +{ + enum { PacketSize = 13 }; + UByte Buffer[PacketSize]; + + TrackingReport Settings; + + TrackingImpl() + { + for (int i=0; i<PacketSize; i++) + { + Buffer[i] = 0; + } + + Buffer[0] = 12; + } + + TrackingImpl(const TrackingReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 12; + EncodeUInt16 ( Buffer+1, Settings.CommandId ); + Buffer[3] = Settings.Pattern; + Buffer[4] = UByte(Settings.Enable << 0 | + Settings.Autoincrement << 1 | + Settings.UseCarrier << 2 | + Settings.SyncInput << 3 | + Settings.VsyncLock << 4 | + Settings.CustomPattern << 5); + Buffer[5] = 0; + EncodeUInt16 ( Buffer+6, Settings.ExposureLength ); + EncodeUInt16 ( Buffer+8, Settings.FrameInterval ); + EncodeUInt16 ( Buffer+10, Settings.VsyncOffset ); + Buffer[12] = Settings.DutyCycle; + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.Pattern = Buffer[3]; + Settings.Enable = (Buffer[4] & 0x01) != 0; + Settings.Autoincrement = (Buffer[4] & 0x02) != 0; + Settings.UseCarrier = (Buffer[4] & 0x04) != 0; + Settings.SyncInput = (Buffer[4] & 0x08) != 0; + Settings.VsyncLock = (Buffer[4] & 0x10) != 0; + Settings.CustomPattern = (Buffer[4] & 0x20) != 0; + Settings.ExposureLength = DecodeUInt16(Buffer+6); + Settings.FrameInterval = DecodeUInt16(Buffer+8); + Settings.VsyncOffset = DecodeUInt16(Buffer+10); + Settings.DutyCycle = Buffer[12]; + } +}; + +// Display feature report. +struct DisplayImpl +{ + enum { PacketSize = 16 }; + UByte Buffer[PacketSize]; + + DisplayReport Settings; + + DisplayImpl() + { + for (int i=0; i<PacketSize; i++) + { + Buffer[i] = 0; + } + + Buffer[0] = 13; + } + + DisplayImpl(const DisplayReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 13; + EncodeUInt16 ( Buffer+1, Settings.CommandId ); + Buffer[3] = Settings.Brightness; + Buffer[4] = UByte( (Settings.ShutterType & 0x0F) | + (Settings.CurrentLimit & 0x03) << 4 | + (Settings.UseRolling ? 0x40 : 0) | + (Settings.ReverseRolling ? 0x80 : 0)); + Buffer[5] = UByte( (Settings.HighBrightness ? 0x01 : 0) | + (Settings.SelfRefresh ? 0x02 : 0) | + (Settings.ReadPixel ? 0x04 : 0) | + (Settings.DirectPentile ? 0x08 : 0)); + EncodeUInt16 ( Buffer+8, Settings.Persistence ); + EncodeUInt16 ( Buffer+10, Settings.LightingOffset ); + EncodeUInt16 ( Buffer+12, Settings.PixelSettle ); + EncodeUInt16 ( Buffer+14, Settings.TotalRows ); + } + + void Unpack() + { + + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.Brightness = Buffer[3]; + Settings.ShutterType = DisplayReport::ShutterTypeEnum(Buffer[4] & 0x0F); + Settings.CurrentLimit = DisplayReport::CurrentLimitEnum((Buffer[4] >> 4) & 0x02); + Settings.UseRolling = (Buffer[4] & 0x40) != 0; + Settings.ReverseRolling = (Buffer[4] & 0x80) != 0; + Settings.HighBrightness = (Buffer[5] & 0x01) != 0; + Settings.SelfRefresh = (Buffer[5] & 0x02) != 0; + Settings.ReadPixel = (Buffer[5] & 0x04) != 0; + Settings.DirectPentile = (Buffer[5] & 0x08) != 0; + Settings.Persistence = DecodeUInt16(Buffer+8); + Settings.LightingOffset = DecodeUInt16(Buffer+10); + Settings.PixelSettle = DecodeUInt16(Buffer+12); + Settings.TotalRows = DecodeUInt16(Buffer+14); + } +}; + +// MagCalibration feature report. +struct MagCalibrationImpl +{ + enum { PacketSize = 52 }; + UByte Buffer[PacketSize]; + + MagCalibrationReport Settings; + + MagCalibrationImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 14; + } + + MagCalibrationImpl(const MagCalibrationReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + Buffer[0] = 14; + EncodeUInt16(Buffer+1, Settings.CommandId); + Buffer[3] = Settings.Version; + + for (int i = 0; i < 3; i++) + for (int j = 0; j < 4; j++) + { + SInt32 value = SInt32(Settings.Calibration.M[i][j] * 1e4f); + EncodeSInt32(Buffer + 4 + 4 * (4 * i + j), value); + } + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.Version = Buffer[3]; + + for (int i = 0; i < 3; i++) + for (int j = 0; j < 4; j++) + { + SInt32 value = DecodeSInt32(Buffer + 4 + 4 * (4 * i + j)); + Settings.Calibration.M[i][j] = (float)value * 1e-4f; + } + } +}; + +//------------------------------------------------------------------------------------- +// PositionCalibration feature report. +// - Sensor interface versions before 5 do not support Normal and Rotation. + +struct PositionCalibrationImpl +{ + enum { PacketSize = 30 }; + UByte Buffer[PacketSize]; + + PositionCalibrationReport Settings; + + PositionCalibrationImpl() + { + for (int i=0; i<PacketSize; i++) + { + Buffer[i] = 0; + } + + Buffer[0] = 15; + } + + PositionCalibrationImpl(const PositionCalibrationReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 15; + EncodeUInt16(Buffer+1, Settings.CommandId); + Buffer[3] = Settings.Version; + + Vector3d position = Settings.Position * 1e6; + EncodeSInt32(Buffer+4, (SInt32) position.x); + EncodeSInt32(Buffer+8, (SInt32) position.y); + EncodeSInt32(Buffer+12, (SInt32) position.z); + + Vector3d normal = Settings.Normal * 1e6; + EncodeSInt16(Buffer+16, (SInt16) normal.x); + EncodeSInt16(Buffer+18, (SInt16) normal.y); + EncodeSInt16(Buffer+20, (SInt16) normal.z); + + double rotation = Settings.Rotation * 1e4; + EncodeSInt16(Buffer+22, (SInt16) rotation); + + EncodeUInt16(Buffer+24, Settings.PositionIndex); + EncodeUInt16(Buffer+26, Settings.NumPositions); + EncodeUInt16(Buffer+28, UInt16(Settings.PositionType)); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.Version = Buffer[3]; + + Settings.Position.x = DecodeSInt32(Buffer + 4) * 1e-6; + Settings.Position.y = DecodeSInt32(Buffer + 8) * 1e-6; + Settings.Position.z = DecodeSInt32(Buffer + 12) * 1e-6; + + Settings.Normal.x = DecodeSInt16(Buffer + 16) * 1e-6; + Settings.Normal.y = DecodeSInt16(Buffer + 18) * 1e-6; + Settings.Normal.z = DecodeSInt16(Buffer + 20) * 1e-6; + + Settings.Rotation = DecodeSInt16(Buffer + 22) * 1e-4; + + Settings.PositionIndex = DecodeUInt16(Buffer + 24); + Settings.NumPositions = DecodeUInt16(Buffer + 26); + + Settings.PositionType = PositionCalibrationReport::PositionTypeEnum(DecodeUInt16(Buffer + 28)); + } +}; + +struct PositionCalibrationImpl_Pre5 +{ + enum { PacketSize = 22 }; + UByte Buffer[PacketSize]; + + PositionCalibrationReport Settings; + + PositionCalibrationImpl_Pre5() + { + for (int i=0; i<PacketSize; i++) + { + Buffer[i] = 0; + } + + Buffer[0] = 15; + } + + PositionCalibrationImpl_Pre5(const PositionCalibrationReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 15; + EncodeUInt16(Buffer+1, Settings.CommandId); + Buffer[3] = Settings.Version; + + Vector3d position = Settings.Position * 1e6; + EncodeSInt32(Buffer+4 , (SInt32) position.x); + EncodeSInt32(Buffer+8 , (SInt32) position.y); + EncodeSInt32(Buffer+12, (SInt32) position.z); + + EncodeUInt16(Buffer+16, Settings.PositionIndex); + EncodeUInt16(Buffer+18, Settings.NumPositions); + EncodeUInt16(Buffer+20, UInt16(Settings.PositionType)); + } + + void Unpack() + { + + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.Version = Buffer[3]; + + Settings.Position.x = DecodeSInt32(Buffer + 4) * 1e-6; + Settings.Position.y = DecodeSInt32(Buffer + 8) * 1e-6; + Settings.Position.z = DecodeSInt32(Buffer + 12) * 1e-6; + + Settings.PositionIndex = DecodeUInt16(Buffer + 16); + Settings.NumPositions = DecodeUInt16(Buffer + 18); + Settings.PositionType = PositionCalibrationReport::PositionTypeEnum(DecodeUInt16(Buffer + 20)); + } +}; + +// CustomPattern feature report. +struct CustomPatternImpl +{ + enum { PacketSize = 12 }; + UByte Buffer[PacketSize]; + + CustomPatternReport Settings; + + CustomPatternImpl() + { + for (int i=0; i<PacketSize; i++) + { + Buffer[i] = 0; + } + + Buffer[0] = 16; + } + + CustomPatternImpl(const CustomPatternReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 16; + EncodeUInt16(Buffer+1, Settings.CommandId); + Buffer[3] = Settings.SequenceLength; + EncodeUInt32(Buffer+4 , Settings.Sequence); + EncodeUInt16(Buffer+8 , Settings.LEDIndex); + EncodeUInt16(Buffer+10, Settings.NumLEDs); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.SequenceLength = Buffer[3]; + Settings.Sequence = DecodeUInt32(Buffer+4); + Settings.LEDIndex = DecodeUInt16(Buffer+8); + Settings.NumLEDs = DecodeUInt16(Buffer+10); + } +}; + +// Manufacturing feature report. +struct ManufacturingImpl +{ + enum { PacketSize = 16 }; + UByte Buffer[PacketSize]; + + ManufacturingReport Settings; + + ManufacturingImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 18; + } + + ManufacturingImpl(const ManufacturingReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + Buffer[0] = 18; + EncodeUInt16(Buffer+1, Settings.CommandId); + Buffer[3] = Settings.NumStages; + Buffer[4] = Settings.Stage; + Buffer[5] = Settings.StageVersion; + EncodeUInt16(Buffer+6, Settings.StageLocation); + EncodeUInt32(Buffer+8, Settings.StageTime); + EncodeUInt32(Buffer+12, Settings.Result); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.NumStages = Buffer[3]; + Settings.Stage = Buffer[4]; + Settings.StageVersion = Buffer[5]; + Settings.StageLocation = DecodeUInt16(Buffer+6); + Settings.StageTime = DecodeUInt32(Buffer+8); + Settings.Result = DecodeUInt32(Buffer+12); + } +}; + +// UUID feature report. +struct UUIDImpl +{ + enum { PacketSize = 23 }; + UByte Buffer[PacketSize]; + + UUIDReport Settings; + + UUIDImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 19; + } + + UUIDImpl(const UUIDReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + Buffer[0] = 19; + EncodeUInt16(Buffer+1, Settings.CommandId); + for (int i = 0; i < 20; ++i) + Buffer[3 + i] = Settings.UUIDValue[i]; + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + for (int i = 0; i < 20; ++i) + Settings.UUIDValue[i] = Buffer[3 + i]; + } +}; + +// LensDistortion feature report. +struct LensDistortionImpl +{ + enum { PacketSize = 64 }; + UByte Buffer[PacketSize]; + + LensDistortionReport Settings; + + LensDistortionImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 22; + } + + LensDistortionImpl(const LensDistortionReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + Buffer[0] = 19; + EncodeUInt16(Buffer+1, Settings.CommandId); + + Buffer[3] = Settings.NumDistortions; + Buffer[4] = Settings.DistortionIndex; + Buffer[5] = Settings.Bitmask; + EncodeUInt16(Buffer+6, Settings.LensType); + EncodeUInt16(Buffer+8, Settings.Version); + EncodeUInt16(Buffer+10, Settings.EyeRelief); + + for (int i = 0; i < 11; ++i) + EncodeUInt16(Buffer+12+2*i, Settings.KCoefficients[i]); + + EncodeUInt16(Buffer+34, Settings.MaxR); + EncodeUInt16(Buffer+36, Settings.MetersPerTanAngleAtCenter); + + for (int i = 0; i < 4; ++i) + EncodeUInt16(Buffer+38+2*i, Settings.ChromaticAberration[i]); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + + Settings.NumDistortions = Buffer[3]; + Settings.DistortionIndex = Buffer[4]; + Settings.Bitmask = Buffer[5]; + Settings.LensType = DecodeUInt16(Buffer+6); + Settings.Version = DecodeUInt16(Buffer+8); + Settings.EyeRelief = DecodeUInt16(Buffer+10); + + for (int i = 0; i < 11; ++i) + Settings.KCoefficients[i] = DecodeUInt16(Buffer+12+2*i); + + Settings.MaxR = DecodeUInt16(Buffer+34); + Settings.MetersPerTanAngleAtCenter = DecodeUInt16(Buffer+36); + + for (int i = 0; i < 4; ++i) + Settings.ChromaticAberration[i] = DecodeUInt16(Buffer+38+2*i); + } +}; + +// KeepAliveMux feature report. +struct KeepAliveMuxImpl +{ + enum { PacketSize = 6 }; + UByte Buffer[PacketSize]; + + KeepAliveMuxReport Settings; + + KeepAliveMuxImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 17; + } + + KeepAliveMuxImpl(const KeepAliveMuxReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + Buffer[0] = 17; + EncodeUInt16(Buffer+1, Settings.CommandId); + Buffer[3] = Settings.INReport; + EncodeUInt16(Buffer+4, Settings.Interval); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer+1); + Settings.INReport = Buffer[3]; + Settings.Interval = DecodeUInt16(Buffer+4); + } +}; + +// Temperature feature report. +struct TemperatureImpl +{ + enum { PacketSize = 24 }; + UByte Buffer[PacketSize]; + + TemperatureReport Settings; + + TemperatureImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 20; + } + + TemperatureImpl(const TemperatureReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 20; + EncodeUInt16(Buffer + 1, Settings.CommandId); + Buffer[3] = Settings.Version; + + Buffer[4] = Settings.NumBins; + Buffer[5] = Settings.Bin; + Buffer[6] = Settings.NumSamples; + Buffer[7] = Settings.Sample; + + EncodeSInt16(Buffer + 8 , SInt16(Settings.TargetTemperature * 1e2)); + EncodeSInt16(Buffer + 10, SInt16(Settings.ActualTemperature * 1e2)); + + EncodeUInt32(Buffer + 12, Settings.Time); + + Vector3d offset = Settings.Offset * 1e4; + PackSensor(Buffer + 16, (SInt16) offset.x, (SInt16) offset.y, (SInt16) offset.z); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer + 1); + Settings.Version = Buffer[3]; + + Settings.NumBins = Buffer[4]; + Settings.Bin = Buffer[5]; + Settings.NumSamples = Buffer[6]; + Settings.Sample = Buffer[7]; + + Settings.TargetTemperature = DecodeSInt16(Buffer + 8) * 1e-2; + Settings.ActualTemperature = DecodeSInt16(Buffer + 10) * 1e-2; + + Settings.Time = DecodeUInt32(Buffer + 12); + + SInt32 x, y, z; + UnpackSensor(Buffer + 16, &x, &y, &z); + Settings.Offset = Vector3d(x, y, z) * 1e-4; + } +}; + +// GyroOffset feature report. +struct GyroOffsetImpl +{ + enum { PacketSize = 18 }; + UByte Buffer[PacketSize]; + + GyroOffsetReport Settings; + + GyroOffsetImpl() + { + memset(Buffer, 0, sizeof(Buffer)); + Buffer[0] = 21; + } + + GyroOffsetImpl(const GyroOffsetReport& settings) + : Settings(settings) + { + Pack(); + } + + void Pack() + { + + Buffer[0] = 21; + Buffer[1] = UByte(Settings.CommandId & 0xFF); + Buffer[2] = UByte(Settings.CommandId >> 8); + Buffer[3] = UByte(Settings.Version); + + Vector3d offset = Settings.Offset * 1e4; + PackSensor(Buffer + 4, (SInt32) offset.x, (SInt32) offset.y, (SInt32) offset.z); + + EncodeSInt16(Buffer + 16, SInt16(Settings.Temperature * 1e2)); + } + + void Unpack() + { + Settings.CommandId = DecodeUInt16(Buffer + 1); + Settings.Version = GyroOffsetReport::VersionEnum(Buffer[3]); + + SInt32 x, y, z; + UnpackSensor(Buffer + 4, &x, &y, &z); + Settings.Offset = Vector3d(x, y, z) * 1e-4f; + + Settings.Temperature = DecodeSInt16(Buffer + 16) * 1e-2; + } +}; + +} // namespace OVR + +#endif // OVR_Sensor2ImplUtil_h |