Ejemplo n.º 1
0
    private void UpdateARObjectTransform(Mat rvec, Mat tvec, int id)
    {
        // Find the object of this id
        if (idDict.ContainsKey(id))
        {
            arGameObject = GameObject.Find(idDict[id]);
        }
        // Convert to unity pose data.
        double[] rvecArr = new double[3];
        rvec.get(0, 0, rvecArr);
        double[] tvecArr = new double[3];
        tvec.get(0, 0, tvecArr);
        PoseData poseData = ARUtils.ConvertRvecTvecToPoseData(rvecArr, tvecArr);


        // Changes in pos/rot below these thresholds are ignored.
        if (enableLowPassFilter)
        {
            ARUtils.LowpassPoseData(ref oldPoseData, ref poseData, positionLowPass, rotationLowPass);
        }
        oldPoseData = poseData;

        // Convert to transform matrix.
        ARM = ARUtils.ConvertPoseDataToMatrix(ref poseData, true, true);


        ARM = arCamera.transform.localToWorldMatrix * ARM;
        ARUtils.SetTransformFromMatrix(arGameObject.transform, ref ARM);


        //Only move and do not rotate
        Vector3 rawRotation = arGameObject.transform.rotation.eulerAngles;

        arGameObject.transform.rotation = Quaternion.Euler(new Vector3(0, adjustRotation(rawRotation[1]), 0));
    }
        public void AddToPoseList(ref PoseData a_newPose)
        {
            if (PoseList == null)
                PoseList = new List<PoseData>();

            PoseList.Add(a_newPose);
        }
Ejemplo n.º 3
0
        public override bool Run()
        {
            bool result = true;

            Actor.OverlayComponent.UpdateInteractionFreeParts(AwarenessLevel.OverlayNone);
            Actor.LookAtManager.DisableLookAts();
            for (int i = 0; i < shots; i++)
            {
                if (Actor.HasExitReason(ExitReason.UserCanceled))
                {
                    result = false;
                    break;
                }

                PoseData poseData = GetRandomPose();
                if (poseData == null)
                {
                    result = false;
                    break;
                }
                PoseManager.SetCurrentPose(Actor, poseData.Key);
                Target.PlaySoloAnimation(this.Actor.SimDescription.IsHuman, this.Actor, poseData.Key, true, ProductVersion.BaseGame);
                Actor.ResetAllAnimation();
                Target.PlaySoloAnimation(this.Actor.SimDescription.IsHuman, this.Actor, poseData.Key, true, ProductVersion.BaseGame);
                Actor.ResetAllAnimation();
                bool userCanceled = Actor.WaitForExitReason(simMinutesToPose, ExitReason.UserCanceled);
                if (userCanceled)
                {
                    result = false;
                    break;
                }
            }
            Actor.LookAtManager.EnableLookAts();
            return(result);
        }
Ejemplo n.º 4
0
        public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix)
        {
            var mirror = Microsoft.Xna.Framework.Graphics.SpriteEffects.None;

            int frameOffset = 0;

            switch (poseData.Pose)
            {
            case (CreaturePose.Stand):
                frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedStand);
                break;

            case (CreaturePose.Walk):
                frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedWalk);
                break;

            case (CreaturePose.Attack):
                frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedAttack);
                break;

            case (CreaturePose.Cast):
                frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedCast);
                break;
            }

            scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) =>
            {
                scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection);
            });
            scene.DrawSprite(Sprite, frameOffset, pos, mirror, color, 0);
            scene.PopSpriteBatch();
        }
Ejemplo n.º 5
0
 public void SetPose(CreatureRender render, Facing facing, PoseData poseData, Vector2 origin)
 {
     Render   = render;
     Facing   = facing;
     PoseData = poseData;
     Origin   = origin;
 }
Ejemplo n.º 6
0
 public void Play()
 {
     currentPose = SelectedPoses[0];
     SetupWinScreen();
     SetupCurrentPose();
     PoseImage.gameObject.SetActive(true);
 }
Ejemplo n.º 7
0
        public void RegisterConfig(JointDeltaConfig config)
        {
            bool containsKeyAlready = _requestors.ContainsKey(config.InstanceID);

            Assert.IsFalse(containsKeyAlready,
                           "Trying to register multiple configs with the same id into " +
                           "JointDeltaProvider.");

            _requestors.Add(config.InstanceID, new List <HandJointId>(config.JointIDs));

            // Check if any new joints added, if so then add to cache
            foreach (var joint in config.JointIDs)
            {
                if (!_poseDataCache.ContainsKey(joint))
                {
                    _poseDataCache.Add(joint, new PoseData[2]
                    {
                        new PoseData(), new PoseData()
                    });

                    // New joint tracked, so write current data
                    PoseData toWrite = _poseDataCache[joint][CurDataIndex];
                    toWrite.IsValid = Hand.GetJointPose(joint, out toWrite.Pose);
                }
            }
        }
Ejemplo n.º 8
0
        private void UpdateData()
        {
            if (Hand.CurrentDataVersion <= _lastUpdateDataVersion)
            {
                return;
            }
            _lastUpdateDataVersion = Hand.CurrentDataVersion;

            // Swap read and write indices each data version
            CurDataIndex = 1 - CurDataIndex;

            // Only fetch pose data for currently tracked joints
            _trackedJoints.Clear();
            foreach (var key in _requestors.Keys)
            {
                IList <HandJointId> joints = _requestors[key];
                _trackedJoints.UnionWithNonAlloc(joints);
            }

            // Fetch pose data for tracked joints, and
            // invalidate data for untracked joints
            foreach (var joint in _poseDataCache.Keys)
            {
                PoseData toWrite = _poseDataCache[joint][CurDataIndex];
                toWrite.IsValid = _trackedJoints.Contains(joint) &&
                                  Hand.GetJointPose(joint, out toWrite.Pose);
            }
        }
Ejemplo n.º 9
0
    virtual protected void onDetectionRun()
    {
        //Add/remove quads to match how many we saw
        if (quadInstances.Count > ArucoTracking.marker_count)
        {
            //Clear out any instances we don't need anymore
            for (int i = quadInstances.Count - 1; i >= ArucoTracking.marker_count; i--)
            {
                GameObject.Destroy(quadInstances[i]);
                quadInstances.RemoveAt(i);
            }
        }
        else if (ArucoTracking.marker_count > quadInstances.Count)
        {
            int to_add = ArucoTracking.marker_count - quadInstances.Count;
            for (int i = 0; i < to_add; i++)
            {
                quadInstances.Add(makeMarkerObject());
            }
        }

        for (int i = 0; i < ArucoTracking.marker_count; i++)
        {
            PoseData pose = trackingRunner.poseDict[ArucoTracking.ids[i]];
            quadInstances[i].transform.localPosition = pose.pos;
            quadInstances[i].transform.localRotation = pose.rot;
        }
    }
Ejemplo n.º 10
0
        public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix)
        {
            SpriteReference abyssalTendril = SpriteLoader.Instance.AddSprite("content/abyssal_tendril_bush");

            var mirror = Microsoft.Xna.Framework.Graphics.SpriteEffects.None;

            bool tendrilDown     = IsTendrilDown(poseData.Pose);
            bool tendrilDownLast = IsTendrilDown(poseData.PoseLast);
            int  frameOffset     = 0;

            switch (poseData.Pose)
            {
            case (CreaturePose.Attack):
                frameOffset = 3 + (poseData.PoseFrame / 2) % 4;
                break;

            case (CreaturePose.Cast):
                frameOffset = 3 + (poseData.PoseFrame / 4) % 4;
                break;
            }

            if (tendrilDown != tendrilDownLast && poseData.PoseFrame < 15)
            {
                frameOffset = 1 + (poseData.PoseFrame / 10) % 2;
            }

            scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) =>
            {
                scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection);
            });
            scene.DrawSprite(abyssalTendril, frameOffset, pos - new Vector2(0, 16), mirror, color, 0);
            scene.PopSpriteBatch();
        }
Ejemplo n.º 11
0
    private void UpdateARObjectTransform_2(Mat rvec, Mat tvec)
    {
        // Convert to unity pose data.
        double[] rvecArr = new double[3];
        rvec.get(0, 0, rvecArr);
        double[] tvecArr = new double[3];
        tvec.get(0, 0, tvecArr);
        PoseData poseData = ARUtils.ConvertRvecTvecToPoseData(rvecArr, tvecArr);

        // Changes in pos/rot below these thresholds are ignored.
        if (enableLowPassFilter)
        {
            ARUtils.LowpassPoseData(ref oldPoseData, ref poseData, positionLowPass, rotationLowPass);
        }
        oldPoseData = poseData;

        // Convert to transform matrix.
        ARM = ARUtils.ConvertPoseDataToMatrix(ref poseData, true, true);

        //if (shouldMoveARCamera) {

        //  ARM = arGameObject.transform.localToWorldMatrix * ARM.inverse;

        //  ARUtils.SetTransformFromMatrix(arCamera.transform, ref ARM);

        //} else {

        ARM = arCamera.transform.localToWorldMatrix * ARM;

        ARUtils.SetTransformFromMatrix(arGameObject.transform, ref ARM);
        //}
    }
Ejemplo n.º 12
0
    public PoseDiff CompareWithController(ControllerInput controller, float progress)
    {
        int firstPhase  = (int)Mathf.Floor(progress / phaseLength);
        int secondPhase = firstPhase + 1;

        if (data.count == 1)
        {
            secondPhase = 0;
        }

        PoseData firstPose  = data.poses [firstPhase];
        PoseData secondPose = data.poses [secondPhase];

        PoseData desiredPose = new PoseData();

        float subProgress = progress % phaseLength;

        subProgress /= phaseLength;             //normalize it;

        desiredPose.leftWing  = firstPose.leftWing + (secondPose.leftWing - firstPose.leftWing) * subProgress;
        desiredPose.rightWing = firstPose.rightWing + (secondPose.rightWing - firstPose.rightWing) * subProgress;

        desiredPose.head.x = firstPose.head.x + (secondPose.head.x - firstPose.head.x) * subProgress;
        desiredPose.head.y = firstPose.head.y + (secondPose.head.y - firstPose.head.y) * subProgress;

        desiredPose.tail.x = firstPose.tail.x + (secondPose.tail.x - firstPose.tail.x) * subProgress;
        desiredPose.tail.y = firstPose.tail.y + (secondPose.tail.y - firstPose.tail.y) * subProgress;

        PoseData controllerPose = CalculateFromController(controller);

        return(CalculatePoseDiffs(desiredPose, controllerPose));
    }
Ejemplo n.º 13
0
    private void onDetectionRun()
    {
        if (trackingRunner.poseDict.ContainsKey(markerId))
        {
            if (!persist)
            {
                gameObject.SetActive(true);
            }
            PoseData pose = trackingRunner.poseDict[markerId];
            if (parentCamera == null)
            {
                gameObject.transform.localPosition = pose.pos;
            }
            else
            {
                Vector3 posePos = pose.pos;
                posePos.z = -posePos.z;
                gameObject.transform.position = parentCamera.cameraToWorldMatrix.MultiplyPoint(posePos);
            }

            gameObject.transform.localRotation = pose.rot * baseRotation;
        }
        else
        {
            if (!persist)
            {
                gameObject.SetActive(false);
            }
        }
    }
Ejemplo n.º 14
0
    public static Dictionary <int, PoseData> createUnityPoseData(int marker_count, int[] ids, double[] rvecs, double[] tvecs)
    {
        Dictionary <int, PoseData> out_dict = new Dictionary <int, PoseData>();

        if (marker_count == 0)
        {
            return(out_dict);
        }

        Vector3 rvec = new Vector3();

        for (int i = 0; i < marker_count; i++)
        {
            PoseData data = new PoseData();
            data.pos.Set((float)tvecs[i * 3], (float)tvecs[i * 3 + 1], (float)tvecs[i * 3 + 2]);


            rvec.Set((float)rvecs[i * 3], (float)rvecs[i * 3 + 1], (float)rvecs[i * 3 + 2]);

            float theta = rvec.magnitude;
            rvec.Normalize();

            //the rvec from OpenCV is a compact axis-angle format. The direction of the vector is the axis, and the length of it is the angle to rotate about (i.e. theta)
            //From this stackoverflow answer: http://stackoverflow.com/questions/12933284/rodrigues-into-eulerangles-and-vice-versa
            data.rot = Quaternion.AngleAxis(theta * Mathf.Rad2Deg, rvec);

            out_dict[ids[i]] = data;
        }

        return(out_dict);
    }
Ejemplo n.º 15
0
	public PoseDiff CompareWithController(ControllerInput controller, float progress)
	{
		int firstPhase = (int)Mathf.Floor(progress/phaseLength);
		int secondPhase = firstPhase + 1;

		if (data.count == 1)
		{
			secondPhase = 0;
		}

		PoseData firstPose = data.poses [firstPhase];
		PoseData secondPose = data.poses [secondPhase];

		PoseData desiredPose = new PoseData();

		float subProgress = progress % phaseLength;
		subProgress /= phaseLength;	//normalize it;

		desiredPose.leftWing = firstPose.leftWing + (secondPose.leftWing - firstPose.leftWing) * subProgress;
		desiredPose.rightWing = firstPose.rightWing + (secondPose.rightWing - firstPose.rightWing) * subProgress;

		desiredPose.head.x = firstPose.head.x + (secondPose.head.x - firstPose.head.x) * subProgress;
		desiredPose.head.y = firstPose.head.y + (secondPose.head.y - firstPose.head.y) * subProgress;

		desiredPose.tail.x = firstPose.tail.x + (secondPose.tail.x - firstPose.tail.x) * subProgress;
		desiredPose.tail.y = firstPose.tail.y + (secondPose.tail.y - firstPose.tail.y) * subProgress;

		PoseData controllerPose = CalculateFromController(controller);

		return CalculatePoseDiffs (desiredPose, controllerPose);
	}
Ejemplo n.º 16
0
        protected static int GetFrameOffset(PoseData poseData)
        {
            int frameOffset = 0;

            switch (poseData.Pose)
            {
            case (CreaturePose.Stand):
                frameOffset = 1;
                break;

            case (CreaturePose.Walk):
                double lerp = LerpHelper.ForwardReverse(0, 2, (poseData.Frame / 50.0) % 1);
                frameOffset = (int)Math.Round(lerp);
                break;

            case (CreaturePose.Attack):
                frameOffset = 3;
                break;

            case (CreaturePose.Cast):
                frameOffset = 4;
                break;
            }

            return(frameOffset);
        }
Ejemplo n.º 17
0
        public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix)
        {
            var mirror       = Microsoft.Xna.Framework.Graphics.SpriteEffects.None;
            int facingOffset = 0;

            switch (facing)
            {
            case (Facing.North):
                facingOffset = 2;
                break;

            case (Facing.East):
                facingOffset = 1;
                mirror       = Microsoft.Xna.Framework.Graphics.SpriteEffects.FlipHorizontally;
                break;

            case (Facing.South):
                facingOffset = 0;
                break;

            case (Facing.West):
                facingOffset = 1;
                break;
            }

            scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) =>
            {
                scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection);
            });
            scene.DrawSprite(Sprite, facingOffset, pos, mirror, color, 0);
            scene.PopSpriteBatch();
        }
Ejemplo n.º 18
0
        public static bool CreateVirtualVehicleAtOrigin(this IFleetManagerClient fleetManager, IPAddress ipAddress)
        {
            PoseData pose = new PoseData()
            {
                X = 0, Y = 0, Heading = 0
            };

            return(fleetManager.CreateVirtualVehicle(ipAddress, pose));
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Get the previous frame's pose
        /// </summary>
        /// <param name="joint">The joint for which to retrieve data</param>
        /// <param name="pose">The previous pose</param>
        /// <returns>True if data available</returns>
        public bool GetPrevJointPose(HandJointId joint, out Pose pose)
        {
            UpdateData();

            PoseData poseData = _poseDataCache[joint][PrevDataIndex];

            pose = poseData.Pose;
            return(poseData.IsValid);
        }
Ejemplo n.º 20
0
        public override bool Run()
        {
            PoseData poseData = PoseData.SelectPoseFromList();

            if (poseData == null)
            {
                return(false);
            }
            return(PoseManager.Pose(Actor, Target, poseData.Key));
        }
        //public void ReceiveRigData(Vector3 playerPos, RigData _rigData)
        //{
        //	transform.position = playerPos;
        //	rigData = _rigData;
        //}

        public void SetTransformToPose(Transform target, PoseData pose)
        {
            if (pose.IsNull())
            {
                return;
            }

            target.localPosition = pose.GetPosition();
            target.localRotation = pose.GetRotation();
        }
Ejemplo n.º 22
0
        public PoseData GetRandomPose()
        {
            PoseData pose  = null;
            int      count = PoseData.sData.Count;

            if (count > 0)
            {
                pose = RandomUtil.GetRandomObjectFromList <PoseData>(PoseList);
            }
            return(pose);
        }
Ejemplo n.º 23
0
        private void GeneratePoses()
        {
            var data = Pose.GeneratePoses();

            for (int i = 0; i < data.Count; i++)
            {
                PoseData.Add(new Pose {
                    Name = data[i].Name, Comment = data[i].Comment, Position = data[i].Position, Score = data[i].Score
                });
            }
        }
Ejemplo n.º 24
0
    //Applies the given offset to the positions of all markers in the dictionary, in the coordinate space of the markers (i.e. camera space)
    //Modifies the dictionary values directly
    public static void addCamSpaceOffset(Dictionary <int, PoseData> dict, Vector3 offset)
    {
        List <int> keys = new List <int>(dict.Keys);

        foreach (int key in keys)
        {
            PoseData data = dict[key];

            data.pos += offset;
            dict[key] = data;
        }
    }
Ejemplo n.º 25
0
    public static PoseData getPoseData()
    {
        PoseData          pd = new PoseData();
        CubemanController cm = GameObject.Find("Cubeman").GetComponent <CubemanController>();

        GameObject[] bones = cm.GetBones();
        for (int i = 0; i < 20; i++)
        {
            pd.bonePos[i] = bones[i].transform.position;
            pd.bonePos[i] = bones[i].transform.localEulerAngles;
        }
        return(pd);
    }
Ejemplo n.º 26
0
    public static PoseDiff CalculatePoseDiffs(PoseData a, PoseData b)
    {
        PoseDiff result = new PoseDiff();

        result = CalculateDiffs(a.leftWing, b.leftWing, result);
        result = CalculateDiffs(a.rightWing, b.rightWing, result);
        //result = CalculateDiffs (a.head.x, b.head.x, result);
        //result = CalculateDiffs (a.head.y, b.head.y, result);
        //result = CalculateDiffs (a.tail.x, b.tail.x, result);
        //result = CalculateDiffs (a.tail.y, b.tail.y, result);

        return(result);
    }
Ejemplo n.º 27
0
    public static PoseData CalculateFromController(ControllerInput controller)
    {
        PoseData result = new PoseData();

        result.leftWing  = controller.GetAxis(ControllerAction.L2);
        result.rightWing = controller.GetAxis(ControllerAction.R2);
        result.head.x    = controller.GetAxis(ControllerAction.LEFT_STICK_X);
        result.head.y    = controller.GetAxis(ControllerAction.LEFT_STICK_Y);
        result.tail.x    = controller.GetAxis(ControllerAction.RIGHT_STICK_X);
        result.tail.y    = controller.GetAxis(ControllerAction.RIGHT_STICK_Y);

        return(result);
    }
Ejemplo n.º 28
0
            public RigData(PoseData _head)
            {
                quality = 1;
                Head    = _head;
                Left    = PoseData.empty;
                Right   = PoseData.empty;

                LeftShoulder  = PoseData.empty;
                RightShoulder = PoseData.empty;

                LeftElbow  = PoseData.empty;
                RightElbow = PoseData.empty;
            }
Ejemplo n.º 29
0
            public RigData(PoseData _head, PoseData _left, PoseData _right)
            {
                quality = 2;
                Head    = _head;
                Left    = _left;
                Right   = _right;

                LeftShoulder  = PoseData.empty;
                RightShoulder = PoseData.empty;

                LeftElbow  = PoseData.empty;
                RightElbow = PoseData.empty;
            }
Ejemplo n.º 30
0
        public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix)
        {
            var mirror       = GetMirror(facing);
            int facingOffset = GetFacingOffset(facing);
            int frameOffset  = GetFrameOffset(poseData);

            scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) =>
            {
                scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection);
            });
            scene.DrawSprite(Sprite, facingOffset + frameOffset, pos, mirror, color, 0);
            scene.PopSpriteBatch();
        }
        private void DrawSceneGUI(SceneView sceneView)
        {
            if (gameObject != null && editedData != null)
            {
                if (selectedOption == 1)
                {
                    DrawSelectedContactPoint();
                    DrawCalculatedContactPoints();
                }

                if (_bDrawTrajectory)
                {
                    Handles.color = Color.cyan;
                    Handles.DrawWireCube(gameObject.transform.position, Vector3.one * 0.1f);
                    Trajectory t = new Trajectory(editedData.trajectoryPointsTimes.Count);
                    editedData.GetTrajectoryInTime(ref t, currentAnimaionTime);
                    Handles.color = Color.green;
                    t.TransformToWorldSpace(gameObject.transform);
                    MM_Gizmos.DrawTrajectory_Handles(
                        editedData.trajectoryPointsTimes.ToArray(),
                        gameObject.transform.position,
                        gameObject.transform.forward,
                        t,
                        0.04f,
                        0.2f
                        );
                }

                if (_bDrawPose)
                {
                    PoseData p = new PoseData(editedData[0].pose.Count);
                    editedData.GetPoseInTime(ref p, currentAnimaionTime);
                    p.TransformToWorldSpace(gameObject.transform);
                    MM_Gizmos.DrawPose(p, Color.blue, Color.yellow);
                }

                if (selectedOption == 1)
                {
                    float length = 200f;
                    float height = 25f;
                    Rect  r      = new Rect(
                        sceneView.position.width / 2f - length / 2f,
                        30f,
                        length,
                        height
                        );
                    DrawContactGizmosSelectRect(r);
                }
            }
        }
Ejemplo n.º 32
0
	public static PoseDiff CalculatePoseDiffs(PoseData a, PoseData b)
	{
		PoseDiff result = new PoseDiff ();

		result = CalculateDiffs (a.leftWing, b.leftWing, result);
		result = CalculateDiffs (a.rightWing, b.rightWing, result);
		//result = CalculateDiffs (a.head.x, b.head.x, result);
		//result = CalculateDiffs (a.head.y, b.head.y, result);
		//result = CalculateDiffs (a.tail.x, b.tail.x, result);
		//result = CalculateDiffs (a.tail.y, b.tail.y, result);

		return result;
	}
Ejemplo n.º 33
0
	public static PoseData CalculateFromController(ControllerInput controller)
	{
		PoseData result = new PoseData ();

		result.leftWing = controller.GetAxis (ControllerAction.L2);
		result.rightWing = controller.GetAxis (ControllerAction.R2);
		result.head.x = controller.GetAxis (ControllerAction.LEFT_STICK_X);
		result.head.y = controller.GetAxis (ControllerAction.LEFT_STICK_Y);
		result.tail.x = controller.GetAxis (ControllerAction.RIGHT_STICK_X);
		result.tail.y = controller.GetAxis (ControllerAction.RIGHT_STICK_Y);

		return result;
	}
Ejemplo n.º 34
0
    private void PositionCamera(TrackableBehaviour trackableBehaviour,
        PoseData camToTargetPose)
    {
        camera.transform.localPosition =
                    trackableBehaviour.transform.rotation *
                    Quaternion.AngleAxis(90, Vector3.left) *
                    Quaternion.Inverse(camToTargetPose.orientation) *
                    (-camToTargetPose.position) +
                    trackableBehaviour.transform.position;

            camera.transform.rotation =
                    trackableBehaviour.transform.rotation *
                    Quaternion.AngleAxis(90, Vector3.left) *
                    Quaternion.Inverse(camToTargetPose.orientation);
    }
Ejemplo n.º 35
0
    private void PositionTrackable(TrackableBehaviour trackableBehaviour,
        PoseData camToTargetPose)
    {
        trackableBehaviour.transform.position =
                    camera.transform.TransformPoint(camToTargetPose.position);

            trackableBehaviour.transform.rotation =
                    camera.transform.rotation *
                    camToTargetPose.orientation *
                    Quaternion.AngleAxis(270, Vector3.left);
    }