Пример #1
0
        public MathUtilsError GetUpdatedOrientation(double Time,
                                                    Quat HMDOrientation,
                                                    double HMDOrientationV,
                                                    Quat ViconOrientation,
                                                    bool ViconDataValid,
                                                    out Quat Output)
        {
            Type   cType = typeof(Quat);
            IntPtr ptr   = Marshal.AllocHGlobal(Marshal.SizeOf(cType));

            try
            {
                MathUtilsError Result = UpdateOrientation2(m_Impl,
                                                           Time,
                                                           HMDOrientation,
                                                           HMDOrientationV,
                                                           ViconOrientation,
                                                           ViconDataValid,
                                                           ptr);

                Output = (Quat)Marshal.PtrToStructure(ptr, cType);
                return(Result);
            }
            finally
            {
                Marshal.FreeHGlobal(ptr);
            }
        }
Пример #2
0
        public MathUtilsError GetUpdatedOrientationWindowed(double Time,
                                                            Quat HMDOrientation,
                                                            bool HMDDataValid,
                                                            Quat ViconOrientation,
                                                            uint ViconFrameNumber,
                                                            bool ViconDataValid,
                                                            out Quat Output)
        {
            Type   cType = typeof(Quat);
            IntPtr ptr   = Marshal.AllocHGlobal(Marshal.SizeOf(cType));

            try
            {
                MathUtilsError Result = UpdateOrientation3(m_Impl,
                                                           Time,
                                                           HMDOrientation,
                                                           HMDDataValid,
                                                           ViconOrientation,
                                                           ViconFrameNumber,
                                                           ViconDataValid,
                                                           1.0f,
                                                           20,
                                                           ptr);

                Output = (Quat)Marshal.PtrToStructure(ptr, cType);
                return(Result);
            }
            finally
            {
                Marshal.FreeHGlobal(ptr);
            }
        }
Пример #3
0
        public MathUtilsError GetVelocity(Quat HMDRotation, double i_T, out double o_V)
        {
            MathUtilsError Result = CalculateAngularVelocity(m_Impl,
                                                             HMDRotation,
                                                             i_T,
                                                             out o_V);

            return(Result);
        }
Пример #4
0
        public static string StateInString(MathUtilsError FusionState, bool bRequiredVelocityCalculation)
        {
            string FusionError = "";

            switch (FusionState)
            {
            case MathUtilsError.ESuccess:
                if (bRequiredVelocityCalculation)
                {
                    FusionError = "Success - Calculated Velocity";
                }
                else
                {
                    FusionError = "Success";
                }
                break;

            case MathUtilsError.EQuaternionWasNan:
                FusionError = "Quaternion is Nan";
                break;

            case MathUtilsError.EZeroTimeDelta:
                FusionError = "Zero Time Delta";
                break;

            case MathUtilsError.EInputIsIdentity:
                FusionError = "Input Is Identity";
                break;

            case MathUtilsError.ELastRotationIdentity:
                FusionError = "Last Rotation Is Identity";
                break;

            case MathUtilsError.ENoVelocity:
                FusionError = "No Velocity";
                break;

            case MathUtilsError.EUninitialized:
                FusionError = "Uninitialized";
                break;
            }
            return(FusionError);
        }