public BaseBlenderGameObject RemoveObjectForPlacement(string name)
    {
        Queue <BaseBlenderGameObject> tmpQueue = new Queue <BaseBlenderGameObject>();

        BaseBlenderGameObject removedBGO = null;

        while (blenderGameObjectsReadyForPlacement.Count > 0)
        {
            var bgo = blenderGameObjectsReadyForPlacement.Dequeue();

            if (bgo.name.Equals(name, System.StringComparison.OrdinalIgnoreCase))
            {
                removedBGO = bgo;
            }
            else
            {
                tmpQueue.Enqueue(bgo);
            }
        }

        blenderGameObjectsReadyForPlacement = tmpQueue;

        if (blenderGameObjectsReadyForPlacement.Count == 0)
        {
            placeableBounds.SetActive(false);
        }

        if (removedBGO)
        {
            removedBGO.gameObject.SetActive(true);
        }

        return(removedBGO);
    }
 private void BlenderServiceManager_OnBlenderGameObjectUpdated(BaseBlenderGameObject bgo)
 {
     SceneStatus.Instance.SetText("");
     if (bgo.IsAnchored)
     {
         if (PlacementManager.Instance.RemoveObjectForPlacement(bgo.name))
         {
             SceneStatus.Instance.SetText("Blender object placed", MEDIUM);
             PlayPlacementSoundEffect(bgo.transform.position);
         }
     }
 }
    public void AddObjectForPlacement(BaseBlenderGameObject bgo)
    {
        blenderGameObjectsReadyForPlacement.Enqueue(bgo);

        if (blenderGameObjectsReadyForPlacement.Count == 1)
        {
            StartTapRecognizer();

            UpdateTracking();
        }

        bgo.gameObject.SetActive(false);
    }
 private void BlenderServiceManager_OnBlenderGameObjectCreated(BaseBlenderGameObject bgo)
 {
     if (bgo.IsAnchored)
     {
         SceneStatus.Instance.SetText("");
         if (bgo.GetComponent <WorldAnchor>())
         {
             if (PlacementManager.Instance.RemoveObjectForPlacement(bgo.name))
             {
                 SceneStatus.Instance.SetText("Blender object placed", MEDIUM);
                 PlayPlacementSoundEffect(bgo.transform.position);
             }
         }
     }
     else
     {
         SceneStatus.Instance.SetText("Blender object ready for placement\nAir-tap on a suitable surface to place", MEDIUM);
         PlacementManager.Instance.AddObjectForPlacement(bgo);
     }
 }
    private void PlacementManager_OnObjectPlaced(BaseBlenderGameObject bgo)
    {
        SceneStatus.Instance.SetText("");

        BaseBlenderGameObject.Anchored onAnchoredHandler = null;
        onAnchoredHandler = (BaseBlenderGameObject caller, byte[] data) =>
        {
            Debug.Log("PlacementManager_OnObjectPlaced.BaseBlenderGameObject.Anchored");

            caller.OnAnchored -= onAnchoredHandler;
            BlenderServiceManager.Instance.SendBlenderGameObjectWorldAnchor(caller, data);
        };

        Debug.Log("PlacementManager_OnObjectPlaced");

        bgo.OnAnchored += onAnchoredHandler;
        bgo.AnchorAtPosition(bgo.transform.position);

        PlayPlacementSoundEffect(bgo.transform.position);
    }
    private void TapRecognizer_TappedEvent(InteractionSourceKind source, int tapCount, Ray headRay)
    {
        if (IsPlacing)
        {
            // place object
            BaseBlenderGameObject bgo = blenderGameObjectsReadyForPlacement.Dequeue();

            bgo.gameObject.SetActive(true);
            bgo.transform.position = placeableBounds.transform.position - (Vector3.up * placeableBounds.transform.localScale.y / 2f);

            OnObjectPlaced(bgo);

            if (blenderGameObjectsReadyForPlacement.Count > 0)
            {
                UpdateTracking();
            }
            else
            {
                placeableBounds.SetActive(false);
            }
        }
    }
Example #7
0
    public void SendBlenderGameObjectWorldAnchor(BaseBlenderGameObject bgo, byte[] worldAnchor)
    {
        Debug.LogFormat("SendBlenderGameObjectWorldAnchor {0} {1}", bgo.name, worldAnchor.Length);

        byte[] data = null;

        using (MemoryStream ms = new MemoryStream())
        {
            using (BinaryWriter br = new BinaryWriter(ms))
            {
                br.Write(TYPE_OBJECT_WORLDANCHOR);
                br.Write(0); // placeholder for packet size
                br.Write(bgo.name);
                br.Write(worldAnchor.Length);
                br.Write(worldAnchor);
            }

            data = ms.ToArray();
            UpdateSize(ref data, 1);
        }

        blenderService.SendData(data);
    }
Example #8
0
    public void SendOperation(BaseBlenderGameObject bgo, ObjectOperations op, Vector3 val)
    {
        byte[] data = null;

        using (MemoryStream ms = new MemoryStream())
        {
            using (BinaryWriter br = new BinaryWriter(ms))
            {
                br.Write(TYPE_OBJECT_OPERATION);
                br.Write(0); // placeholder for packet size
                br.Write(bgo.name);
                br.Write((byte)op);
                br.Write(val.x);
                br.Write(val.y);
                br.Write(val.z);
            }

            data = ms.ToArray();
            UpdateSize(ref data, 1);
        }

        Debug.Log("Sending TYPE_OBJECT_OPERATION packet");
        blenderService.SendData(data);
    }