public static void SendAudioFrame(AirXRCameraRig cameraRig, float[] data, int sampleCount, int channels, double timestamp)
 {
     if (cameraRig.isBoundToClient)
     {
         AXRServerPlugin.EncodeAudioFrame(cameraRig.playerID, data, data.Length / channels, channels, AudioSettings.dspTime);
     }
 }
    public void AirXRCameraRigActivated(AirXRCameraRig cameraRig)
    {
        // The sample onairvr client app just sends back what it receives.
        // (https://github.com/onairvr/onairvr-client-for-oculus-mobile)

        string pingMessage = "ping from " + System.Environment.MachineName;

        cameraRig.SendUserData(System.Text.Encoding.UTF8.GetBytes(pingMessage));
    }
 public void AirXRCameraRigHasBeenUnbound(AirXRCameraRig cameraRig)
 {
     // NOTE : This event occurs in OnDestroy() of AirXRCameraRig during unloading scene.
     //        You should be careful because some objects in the scene might be destroyed already on this event.
     if (music != null)
     {
         music.Stop();
     }
 }
 public void ReleaseCameraRig(AirXRCameraRig cameraRig)
 {
     if (_cameraRigsAvailable.ContainsKey(cameraRig.type) && _cameraRigsRetained.ContainsKey(cameraRig.type))
     {
         if (_cameraRigsRetained[cameraRig.type].Contains(cameraRig))
         {
             _cameraRigsRetained[cameraRig.type].Remove(cameraRig);
             _cameraRigsAvailable[cameraRig.type].Add(cameraRig);
         }
     }
 }
    void AirXRCameraRigManager.PredictionEventHandler.OnProfileDataReceived(AirXRCameraRig cameraRig, byte[] cbor)
    {
        if (bypassPrediction || _zmqReportEndpoint == null)
        {
            return;
        }

        _msg.InitPool(cbor.Length);
        Array.Copy(cbor, _msg.Data, _msg.Data.Length);

        _zmqReportEndpoint.TrySend(ref _msg, TimeSpan.Zero, false);
    }
    void AirXRCameraRigManager.PredictionEventHandler.OnStopPrediction(AirXRCameraRig cameraRig)
    {
        if (_zmqReportEndpoint == null)
        {
            return;
        }

        _zmqReportEndpoint.Close();
        _zmqReportEndpoint.Dispose();
        _zmqReportEndpoint = null;

        predictedMotionProvider.Close();
    }
    public static void SetVibration(AirXRCameraRig cameraRig, Device device, AnimationCurve frequency, AnimationCurve amplitude)
    {
        switch (device)
        {
        case Device.LeftHandTracker:
            renderVibration(cameraRig, (byte)AXRInputDeviceID.LeftHandTracker, (byte)AXRHandTrackerFeedbackControl.Vibration, frequency, amplitude);
            break;

        case Device.RightHandTracker:
            renderVibration(cameraRig, (byte)AXRInputDeviceID.RightHandTracker, (byte)AXRHandTrackerFeedbackControl.Vibration, frequency, amplitude);
            break;
        }
    }
 public AirXRCameraRig RetainCameraRig(AirXRCameraRig cameraRig)
 {
     if (_cameraRigsAvailable.ContainsKey(cameraRig.type) && _cameraRigsRetained.ContainsKey(cameraRig.type))
     {
         if (_cameraRigsAvailable[cameraRig.type].Contains(cameraRig))
         {
             _cameraRigsAvailable[cameraRig.type].Remove(cameraRig);
             _cameraRigsRetained[cameraRig.type].Add(cameraRig);
             return(cameraRig);
         }
     }
     return(null);
 }
    private static void renderVibration(AirXRCameraRig cameraRig, byte device, byte control, AnimationCurve frequency, AnimationCurve amplitude)
    {
        var fps      = cameraRig.GetConfig().framerate;
        var duration = Mathf.Max(frequency.keys[frequency.keys.Length - 1].time, amplitude.keys[amplitude.keys.Length - 1].time);

        for (float t = 0.0f; t < duration; t += 1.0f / fps)
        {
            cameraRig.inputStream.PendVibration(device, control, frequency.Evaluate(t), amplitude.Evaluate(t));
        }

        // make sure to end with no vibration
        cameraRig.inputStream.PendVibration(device, control, 0, 0);
    }
    public static void SetVibration(AirXRCameraRig cameraRig, Device device, float frequency, float amplitude)
    {
        switch (device)
        {
        case Device.LeftHandTracker:
            cameraRig.inputStream.PendVibration((byte)AXRInputDeviceID.LeftHandTracker, (byte)AXRHandTrackerFeedbackControl.Vibration, frequency, amplitude);
            break;

        case Device.RightHandTracker:
            cameraRig.inputStream.PendVibration((byte)AXRInputDeviceID.RightHandTracker, (byte)AXRHandTrackerFeedbackControl.Vibration, frequency, amplitude);
            break;
        }
    }
    public static int GetScreenTouchCount(AirXRCameraRig cameraRig)
    {
        var count = 0;

        for (byte control = (byte)AXRTouchScreenControl.TouchIndexStart; control <= (byte)AXRTouchScreenControl.TouchIndexEnd; control++)
        {
            if (cameraRig.inputStream.IsActive((byte)AXRInputDeviceID.TouchScreen, control) ||
                cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.TouchScreen, control))
            {
                count++;
            }
        }
        return(count);
    }
    public static Vector2 Get(AirXRCameraRig cameraRig, Axis2D axis)
    {
        switch (axis)
        {
        case Axis2D.LThumbstick:
            return(cameraRig.inputStream.GetAxis2D((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DLThumbstick));

        case Axis2D.RThumbstick:
            return(cameraRig.inputStream.GetAxis2D((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DRThumbstick));

        default:
            return(Vector2.zero);
        }
    }
    public static bool IsDeviceAvailable(AirXRCameraRig cameraRig, Device device)
    {
        switch (device)
        {
        case Device.HeadTracker:
            return(true);

        case Device.LeftHandTracker:
        case Device.RightHandTracker:
            return(cameraRig.inputStream.GetState((byte)device, (byte)AXRHandTrackerControl.Status) != 0);

        default:
            return(false);
        }
    }
 public void AddUnboundCameraRig(AirXRCameraRig cameraRig)
 {
     if (_cameraRigsAvailable.ContainsKey(cameraRig.type) == false)
     {
         _cameraRigsAvailable.Add(cameraRig.type, new List <AirXRCameraRig>());
     }
     if (_cameraRigsRetained.ContainsKey(cameraRig.type) == false)
     {
         _cameraRigsRetained.Add(cameraRig.type, new List <AirXRCameraRig>());
     }
     if (_cameraRigsAvailable[cameraRig.type].Contains(cameraRig) == false &&
         _cameraRigsRetained[cameraRig.type].Contains(cameraRig) == false)
     {
         _cameraRigsAvailable[cameraRig.type].Add(cameraRig);
     }
 }
    // implements AirXRCameraRigManager.PredictionEventHandler
    void AirXRCameraRigManager.PredictionEventHandler.OnStartPrediction(AirXRCameraRig cameraRig, string profileReportEndpoint, string motionOutputEndpoint)
    {
        if (bypassPrediction || _zmqReportEndpoint != null)
        {
            return;
        }

        string endpoint = convertZmqEndpoint(profileReportEndpoint);

        if (string.IsNullOrEmpty(endpoint) == false)
        {
            _zmqReportEndpoint = new PushSocket();
            _zmqReportEndpoint.Connect(endpoint);
        }

        predictedMotionProvider.Connect(convertZmqEndpoint(motionOutputEndpoint));
    }
    public void RemoveCameraRig(AirXRCameraRig cameraRig)
    {
        if (_cameraRigsAvailable.ContainsKey(cameraRig.type) == false ||
            _cameraRigsRetained.ContainsKey(cameraRig.type) == false)
        {
            return;
        }

        if (_cameraRigsAvailable[cameraRig.type].Contains(cameraRig))
        {
            _cameraRigsAvailable[cameraRig.type].Remove(cameraRig);
        }
        else if (_cameraRigsRetained[cameraRig.type].Contains(cameraRig))
        {
            _cameraRigsRetained[cameraRig.type].Remove(cameraRig);
        }
    }
    internal void UnregisterCameraRig(AirXRCameraRig cameraRig, bool applicationQuit = false)
    {
        _cameraRigList.RemoveCameraRig(cameraRig);

        if (applicationQuit == false && cameraRig.isBoundToClient)
        {
            cameraRig.PreHandOverStreams();
            AirXRServerStreamHandover.HandOverStreamsForNextScene(new AirXRServerStreamHandover.Streams(cameraRig.playerID, cameraRig.mediaStream, cameraRig.inputStream));

            if (Delegate != null)
            {
                if (cameraRig.isStreaming)
                {
                    Delegate.AirXRCameraRigDeactivated(cameraRig);
                }
                Delegate.AirXRCameraRigHasBeenUnbound(cameraRig);
            }
            cameraRig.PostHandOverStreams();
        }
    }
    public static float Get(AirXRCameraRig cameraRig, Axis axis)
    {
        switch (axis)
        {
        case Axis.LIndexTrigger:
            return(cameraRig.inputStream.GetAxis((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisLIndexTrigger));

        case Axis.RIndexTrigger:
            return(cameraRig.inputStream.GetAxis((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisRIndexTrigger));

        case Axis.LHandTrigger:
            return(cameraRig.inputStream.GetAxis((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisLHandTrigger));

        case Axis.RHandTrigger:
            return(cameraRig.inputStream.GetAxis((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisRHandTrigger));

        default:
            return(0);
        }
    }
    private AirXRCameraRig notifyCameraRigWillBeBound(int playerID)
    {
        var config = AirXRClientConfig.Get(playerID);

        var cameraRigs = new List <AirXRCameraRig>();

        _cameraRigList.GetAvailableCameraRigs(config.type, cameraRigs);

        AirXRCameraRig selected = null;

        if (Delegate != null)
        {
            Delegate.AirXRCameraRigWillBeBound(playerID, config, cameraRigs, out selected);
            AirXRClientConfig.Set(playerID, config);
        }
        else if (cameraRigs.Count > 0)
        {
            selected = cameraRigs[0];
        }
        return(selected);
    }
    public static byte GetDeviceProperty(AirXRCameraRig cameraRig, Device device, Property prop)
    {
        switch (prop)
        {
        case Property.Battery:
            var deviceID = parseDevice(device);
            switch (deviceID)
            {
            case AXRInputDeviceID.HeadTracker:
                return(cameraRig.inputStream.GetByteAxis((byte)deviceID, (byte)AXRHeadTrackerControl.Battery));

            case AXRInputDeviceID.LeftHandTracker:
            case AXRInputDeviceID.RightHandTracker:
                return(cameraRig.inputStream.GetByteAxis((byte)deviceID, (byte)AXRHandTrackerControl.Battery));

            default:
                return(255);
            }

        default:
            break;
        }
        return(0);
    }
 public void AirXRCameraRigDeactivated(AirXRCameraRig cameraRig)
 {
 }
    // implements AirXRCameraRigManager.EventHandler
    public void AirXRCameraRigWillBeBound(int clientHandle, AirXRClientConfig config, List <AirXRCameraRig> availables, out AirXRCameraRig selected)
    {
        selected = availables.Count > 0 ? availables[0] : null;

        if (selected)
        {
            music.Play();
        }
    }
 public void AirXRCameraRigUserDataReceived(AirXRCameraRig cameraRig, byte[] userData)
 {
     Debug.Log("User data received: " + System.Text.Encoding.UTF8.GetString(userData));
 }
    public static Touch GetScreenTouch(AirXRCameraRig cameraRig, int index)
    {
        var i = 0;

        for (byte control = (byte)AXRTouchScreenControl.TouchIndexStart; control <= (byte)AXRTouchScreenControl.TouchIndexEnd; control++)
        {
            if (cameraRig.inputStream.IsActive((byte)AXRInputDeviceID.TouchScreen, control) == false &&
                cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.TouchScreen, control) == false)
            {
                continue;
            }

            if (i == index)
            {
                Touch touch = new Touch();
                touch.fingerID = control;

                byte state = 0;
                cameraRig.inputStream.GetTouch2D((byte)AXRInputDeviceID.TouchScreen, control, ref touch.position, ref state);

                if (cameraRig.inputStream.GetActivated((byte)AXRInputDeviceID.TouchScreen, control))
                {
                    touch.phase = TouchPhase.Began;
                }
                else
                {
                    switch ((AXRTouchPhase)state)
                    {
                    case AXRTouchPhase.Ended:
                        touch.phase = TouchPhase.Ended;
                        break;

                    case AXRTouchPhase.Canceled:
                        touch.phase = TouchPhase.Canceled;
                        break;

                    case AXRTouchPhase.Stationary:
                        touch.phase = TouchPhase.Stationary;
                        break;

                    case AXRTouchPhase.Moved:
                        touch.phase = TouchPhase.Moved;
                        break;

                    default:
                        Assert.IsTrue(false);
                        break;
                    }
                }

                return(touch);
            }
            else
            {
                i++;
            }
        }
        return(new Touch {
            fingerID = Touch.InvalidFingerID
        });
    }
 // implements AirXRCameraRigMananger.EventHandler
 public void AirXRCameraRigWillBeBound(int clientHandle, AirXRClientConfig config, List <AirXRCameraRig> availables, out AirXRCameraRig selected)
 {
     if (availables.Contains(_primaryCameraRig))
     {
         selected = _primaryCameraRig;
     }
     else if (availables.Count > 0)
     {
         selected = availables[0];
     }
     else
     {
         selected = null;
     }
 }
 public void AirXRCameraRigHasBeenUnbound(AirXRCameraRig cameraRig)
 {
 }
 public void AirXRCameraRigUserDataReceived(AirXRCameraRig cameraRig, byte[] data)
 {
 }
    public static bool GetUp(AirXRCameraRig cameraRig, Button button)
    {
        switch (button)
        {
        case Button.LIndexTrigger:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisLIndexTrigger));

        case Button.RIndexTrigger:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisRIndexTrigger));

        case Button.LHandTrigger:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisLHandTrigger));

        case Button.RHandTrigger:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.AxisRHandTrigger));

        case Button.A:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonA));

        case Button.B:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonB));

        case Button.X:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonX));

        case Button.Y:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonY));

        case Button.Start:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonStart));

        case Button.Back:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonBack));

        case Button.LThumbstick:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonLThumbstick));

        case Button.RThumbstick:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.ButtonRThumbstick));

        case Button.LThumbstickUp:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DLThumbstick, AXRInputDirection.Up));

        case Button.LThumbstickDown:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DLThumbstick, AXRInputDirection.Down));

        case Button.LThumbstickLeft:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DLThumbstick, AXRInputDirection.Left));

        case Button.LThumbstickRight:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DLThumbstick, AXRInputDirection.Right));

        case Button.RThumbstickUp:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DRThumbstick, AXRInputDirection.Up));

        case Button.RThumbstickDown:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DRThumbstick, AXRInputDirection.Down));

        case Button.RThumbstickLeft:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DRThumbstick, AXRInputDirection.Left));

        case Button.RThumbstickRight:
            return(cameraRig.inputStream.GetDeactivated((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DRThumbstick, AXRInputDirection.Right));

        default:
            return(false);
        }
    }
 public AirXRGameEventEmitter(AirXRCameraRig cameraRig)
 {
     _cameraRig = cameraRig;
 }
Ejemplo n.º 30
0
 public AirXRServerInputStream(AirXRCameraRig owner)
 {
     this.owner = owner;
 }