Example #1
0
        /// <summary>
        /// Animate camera so that focusPoint moves to center of camera
        /// Camera target is also set to focusPoint
        /// </summary>
        public void AnimatePanFocus(Vector3f focusPoint, CoordSpace eSpace, float duration)
        {
            if (duration > 0 && ShowTargetDuringAnimations)
            {
                UseCamera.SetTargetVisible(true);
            }

            Vector3f       focusPointS = (eSpace == CoordSpace.WorldCoords) ? UseScene.ToSceneP(focusPoint) : focusPoint;
            Vector3f       startFocusS = UseScene.ToSceneP(UseCamera.GetTarget());
            Action <float> tweenF      = (t) => {
                Vector3f newTargetS = Vector3f.Lerp(startFocusS, focusPointS, t);
                UseCamera.Manipulator().PanFocusOnScenePoint(UseScene, UseCamera, newTargetS);
            };

            if (duration > 0)
            {
                TweenAnimator anim = new TweenAnimator(tweenF, duration)
                {
                    OnCompletedF = () => { UseCamera.SetTargetVisible(false); }
                };
                UseScene.ObjectAnimator.Register(anim);
            }
            else
            {
                tweenF(1.0f);
            }
        }
Example #2
0
 public TransformSOChange(SceneObject target, Frame3f before, Frame3f after, CoordSpace coords)
 {
     this.so     = target;
     this.before = before;
     this.after  = after;
     this.space  = coords;
 }
Example #3
0
 public TransformSOChange(SceneObject target, Frame3f newFrame, CoordSpace coords)
 {
     this.so     = target;
     this.before = target.GetLocalFrame(coords);
     this.after  = newFrame;
     this.space  = coords;
 }
Example #4
0
        /// <summary>
        /// Assuming pointIn is in space eFrom of fromSO, transform to eTo
        /// </summary>
        public static Vector3f TransformTo(Vector3f pointIn, TransformableSO fromSO, CoordSpace eFrom, CoordSpace eTo)
        {
            // this is not the most efficient but we can optimize later!
            Frame3f tmp = new Frame3f(pointIn);

            return(TransformTo(tmp, fromSO, eFrom, eTo).Origin);
        }
Example #5
0
        public static void TranslateInFrame(TransformableSO so, Vector3f translate, CoordSpace eSpace = CoordSpace.ObjectCoords)
        {
            Frame3f f = so.GetLocalFrame(eSpace);

            f.Origin += translate;
            so.SetLocalFrame(f, eSpace);
        }
Example #6
0
        /// <summary>
        /// Animate camera so that focusPoint moves to center of camera, at distance distanceW along cam.Forward
        /// Camera target is also set to focusPoint
        /// </summary>
        public void AnimatePanZoomFocus(Vector3f focusPoint, CoordSpace eSpace, float distanceW, float duration)
        {
            if (duration > 0 && ShowTargetDuringAnimations)
            {
                UseCamera.SetTargetVisible(true);
            }

            Vector3f focusPointS = (eSpace == CoordSpace.WorldCoords) ? UseScene.ToSceneP(focusPoint) : focusPoint;
            Vector3f startFocusS = UseScene.ToSceneP(UseCamera.GetTarget());
            float    startDistW  = UseCamera.GetPosition().Distance(UseCamera.GetTarget());

            Action <float> tweenF = (t) => {
                float    smooth_t   = MathUtil.WyvillRise01(t);
                Vector3f newTargetS = Vector3f.Lerp(startFocusS, focusPointS, smooth_t);
                UseCamera.Manipulator().PanFocusOnScenePoint(UseScene, UseCamera, newTargetS);

                float curDist = UseCamera.GetPosition().Distance(UseCamera.GetTarget());
                float toDist  = MathUtil.Lerp(startDistW, distanceW, smooth_t);
                float dolly   = toDist - curDist;
                UseCamera.Manipulator().SceneZoom(UseScene, UseCamera, -dolly);
            };

            if (duration > 0)
            {
                TweenAnimator anim = new TweenAnimator(tweenF, duration)
                {
                    OnCompletedF = () => { UseCamera.SetTargetVisible(false); }
                };
                UseScene.ObjectAnimator.Register(anim);
            }
            else
            {
                tweenF(1.0f);
            }
        }
Example #7
0
        public static Frame3f GetSOLocalFrame(SceneObject so, CoordSpace eSpace)
        {
            if (eSpace == CoordSpace.SceneCoords)
            {
                // new code maps object frame up to scene
                // [TODO] this is not the most efficient approach! can at least get the object
                //   frame directly, and avoid first local-to-obj xform
                Frame3f objF   = Frame3f.Identity;
                Frame3f result = SceneTransforms.ObjectToScene(so, objF);

                // [RMS] old code that mapped up to world, and then down to scene
                //   Problem with this code is that it is unstable - if scene-to-world xform changes,
                //   then scene frame will numerically change. Which is a problem.
                //Frame3f sceneW = UnityUtil.GetGameObjectFrame(so.GetScene().RootGameObject, CoordSpace.WorldCoords);
                //Frame3f objW = UnityUtil.GetGameObjectFrame(so.RootGameObject, CoordSpace.WorldCoords);
                //Frame3f result = sceneW.ToFrame(objW);
                //// world coords have scene scale applied, we don't want that in scene coords
                //if (so.GetScene().GetSceneScale() != 1.0f)
                //    result = result.Scaled(1.0f / so.GetScene().GetSceneScale());

                return(result);
            }
            else
            {
                return(UnityUtil.GetGameObjectFrame(so.RootGameObject, eSpace));
            }
        }
Example #8
0
        // same as above but does not post OnPointUpdated
        protected bool SetPointPosition_Internal(int id, Frame3f frameS, CoordSpace space)
        {
            if (space == CoordSpace.WorldCoords)
            {
                frameS = SceneTransforms.WorldToScene(this.Scene, frameS);
            }
            else if (space == CoordSpace.ObjectCoords)
            {
                frameS = SceneTransforms.ObjectToScene(TargetSO, frameS);
            }

            ControlPoint pt;

            if (GizmoPoints.TryGetValue(id, out pt) == false)
            {
                throw new Exception("MultiSurfacePointTool.SetPointPosition_Internal: point with id " + id + " does not exist!");
            }

            // ignore tiny movements
            if (pt.currentFrameS.Origin.EpsilonEqual(frameS.Origin, 0.0001f))
            {
                return(false);
            }
            pt.currentFrameS = frameS;

            if (pt.initialized == false)
            {
                initialize_point(pt);
            }

            return(true);
        }
Example #9
0
        /// <summary>
        /// Assuming pointIn is in space eFrom of fromSO, transform to eTo
        /// </summary>
        public static Vector3f TransformTo(Vector3f pointIn, SceneObject fromSO, CoordSpace eFrom, CoordSpace eTo)
        {
            // this is not the most efficient but we can optimize later!
            Frame3f f   = new Frame3f(pointIn);
            Frame3f fTo = TransformTo(f, fromSO, eFrom, eTo);

            return(fTo.Origin);
        }
Example #10
0
        // same as LocalFrame, but LocalFrame may be tilted up/down, which we want to undo
        public virtual Frame3f GetLevelViewFrame(CoordSpace eSpace)
        {
            // otherwise we can't just set y to 0...
            Debug.Assert(eSpace == CoordSpace.WorldCoords);
            Frame3f viewF  = UnityUtil.GetGameObjectFrame(ActiveCamera.GameObject(), eSpace);
            float   fAngle = VRUtil.PlaneAngleSigned(Vector3f.AxisZ, viewF.Z, 1);

            return(new Frame3f(viewF.Origin, Quaternionf.AxisAngleD(Vector3f.AxisY, fAngle)));
        }
Example #11
0
 public TransformSOChange(SceneObject target, Frame3f before, Frame3f after, CoordSpace coords)
 {
     this.so          = target;
     this.before      = before;
     this.after       = after;
     this.space       = coords;
     this.scaleBefore = target.GetLocalScale();
     this.scaleAfter  = this.scaleBefore;
 }
Example #12
0
 public TransformSOChange(SceneObject target, Frame3f before, Frame3f after, CoordSpace coords, Vector3f scaleBefore, Vector3f scaleAfter)
 {
     this.so          = target;
     this.before      = before;
     this.after       = after;
     this.space       = coords;
     this.scaleBefore = scaleBefore;
     this.scaleAfter  = scaleAfter;
 }
Example #13
0
 public TransformSOChange(SceneObject target, Vector3f newScale)
 {
     this.so          = target;
     this.before      = target.GetLocalFrame(CoordSpace.ObjectCoords);
     this.after       = before;
     this.space       = CoordSpace.ObjectCoords;
     this.scaleBefore = target.GetLocalScale();
     this.scaleAfter  = newScale;
 }
Example #14
0
 virtual public void SetLocalFrame(Frame3f newFrame, CoordSpace eSpace)
 {
     SceneUtil.SetSOLocalFrame(this, eSpace, newFrame);
     increment_timestamp();
     if (OnTransformModified != null)
     {
         OnTransformModified(this);
     }
 }
Example #15
0
        public void SetLocalFrame(Frame3 newFrame, CoordSpace eSpace)
        {
            Debug.Assert(eSpace == CoordSpace.ObjectCoords);

            Frame3 updateFrame = objectFrame;

            curRotation          = newFrame.Rotation;
            updateFrame.Rotation = curRotation * objectFrame.Rotation;
            updateFrame.Origin   = newFrame.Origin;
            target.SetLocalFrame(updateFrame, eSpace);
        }
Example #16
0
 //
 // TransformableSceneObject impl
 //
 public Frame3 GetLocalFrame(CoordSpace eSpace)
 {
     if (eSpace == CoordSpace.SceneCoords)
     {
         return(parentScene.WorldToSceneF(new Frame3(RootGameObject.transform, false)));
     }
     else
     {
         return(MathUtil.GetGameObjectFrame(RootGameObject, eSpace));
     }
 }
        override public void SetLocalFrame(Frame3f newFrame, CoordSpace eSpace)
        {
            Util.gDevAssert(eSpace == CoordSpace.ObjectCoords);

            Frame3f updateFrame = objectFrame;

            curRotation          = newFrame.Rotation;
            updateFrame.Rotation = curRotation * objectFrame.Rotation;
            updateFrame.Origin   = newFrame.Origin;
            target.SetLocalFrame(updateFrame, eSpace);
        }
Example #18
0
        /// <summary>
        /// Animate camera so that centerPt moves to center of camera, and height is visible.
        /// Camera target is also set to centerPt
        /// </summary>
        public void AnimateFitHeightToView(Vector3f centerPt, float height, CoordSpace eSpace, float duration)
        {
            if (eSpace != CoordSpace.WorldCoords)
            {
                height = UseScene.ToWorldDimension(height);
            }
            float    fFitDistW   = UseCamera.Manipulator().GetFitHeightCameraDistance(height);
            Vector3f focusPointW = (eSpace == CoordSpace.WorldCoords) ? centerPt : UseScene.ToWorldP(centerPt);

            AnimatePanZoomFocus(focusPointW, CoordSpace.WorldCoords, fFitDistW, duration);
        }
Example #19
0
        public override void AddIndicator(Indicator i)
        {
            base.AddIndicator(i);
            CoordSpace eSpace = i.InSpace;

            if (eSpace == CoordSpace.ObjectCoords || eSpace == CoordSpace.WorldCoords)
            {
                throw new Exception("SOSceneIndicatorSet.AddIndicator: only scene-space indicators not supported!");
            }

            UnityUtil.AddChild(sceneParentGO, i.RootGameObject, false);
        }
Example #20
0
 public void UpdateSection(Frame3f frame, CoordSpace space)
 {
     if (space != CoordSpace.ObjectCoords)
     {
         frameL = SceneTransforms.TransformTo(frame, SO, space, CoordSpace.ObjectCoords);
     }
     else
     {
         frameL = frame;
     }
     update();
 }
Example #21
0
        private static float[] Convert(float[] quat, CoordSpace coordSpace)
        {
            float[] res = new float[2];

            if (coordSpace == CoordSpace.World)
            {
                quat = QuatUtils.Inverse(quat);
            }

            float[] forward = QuatUtils.TransformVecLH(quat, new float[] { 0f, 0f, 1f });

            float lXZ = (float)Math.Sqrt(forward[0] * forward[0] + forward[2] * forward[2]);

            //Azimuth
            if (lXZ < 0.00001f)
            {
                res[0] = (float)Math.Sign(forward[0]) * (float)Math.PI;
            }
            else
            {
                res[0] = (float)Math.Asin((double)forward[0] / (double)lXZ);
            }

            if (forward[2] < 0)
            {
                res[0] = (float)Math.Sign(res[0]) * (float)Math.PI - res[0];
            }

            //Elevation
            if (lXZ < 0.00001f)
            {
                res[0] = (float)(Math.PI * Math.Sign(forward[1]));
            }
            else
            {
                res[1] = (float)Math.Atan(forward[1] / lXZ);
            }

            if (coordSpace == CoordSpace.World)
            {
                res[0] = -res[0];
                res[0] = -res[1];
            }

            //Convert radians to degrees
            res[0] *= Mathf.Rad2Deg;
            res[1] *= Mathf.Rad2Deg;

            return(res);
        }
Example #22
0
 public static Frame3f GetGameObjectFrame(GameObject go, CoordSpace eSpace)
 {
     if (eSpace == CoordSpace.WorldCoords)
     {
         return(new Frame3f(go.transform.position, go.transform.rotation));
     }
     else if (eSpace == CoordSpace.ObjectCoords)
     {
         return(new Frame3f(go.transform.localPosition, go.transform.localRotation));
     }
     else
     {
         throw new ArgumentException("not possible without refernce to scene!");
     }
 }
Example #23
0
 public static Frame3 GetGameObjectFrame(GameObject go, CoordSpace eSpace)
 {
     if (eSpace == CoordSpace.WorldCoords)
     {
         return(new Frame3(go.transform, false));
     }
     else if (eSpace == CoordSpace.ObjectCoords)
     {
         return(new Frame3(go.transform, true));
     }
     else
     {
         throw new ArgumentException("not possible without refernce to scene!");
     }
 }
Example #24
0
        public RepositionPivotChangeOp(Frame3f toPivot, DMeshSO target, CoordSpace space = CoordSpace.ObjectCoords)
        {
            Util.gDevAssert(space != CoordSpace.WorldCoords);       // not supported for now

            Target     = target;
            toFrame    = toPivot;
            this.space = space;
            if (space == CoordSpace.ObjectCoords)
            {
                initialFrame = Target.GetLocalFrame(CoordSpace.ObjectCoords);
            }
            else
            {
                initialFrame = Target.GetLocalFrame(CoordSpace.SceneCoords);
            }
        }
Example #25
0
        // should not use this anymore...
        public void PanFocus(Vector3f focusPoint, CoordSpace eSpace = CoordSpace.WorldCoords, float duration = 0.5f)
        {
            Vector3f focusPointW = (eSpace == CoordSpace.WorldCoords) ? focusPoint : UseScene.ToWorldP(focusPoint);

            // figure out the pan that we would apply to camera, then apply the delta to the scene
            Vector3f curPos = UseCamera.GetPosition();
            Vector3f curDir = UseCamera.GetWorldFrame().Z;
            float    fDist  = Vector3.Dot((focusPointW - curPos), curDir);
            Vector3f newPos = focusPointW - fDist * curDir;
            Vector3f delta  = curPos - newPos;

            StartCoroutine(
                SmoothTranslate(UseScene.RootGameObject.GetPosition() + delta, duration));
            StartCoroutine(
                SmoothMoveTarget(focusPointW + delta, duration / 10.0f));
        }
Example #26
0
        private static float[] Convert(float[] quat, CoordSpace coordSpace)
        {
            float[] res = new float[2];

            if (coordSpace == CoordSpace.World)
            {
                quat = QuatUtils.Inverse(quat);
            }

            float[] forward = QuatUtils.TransformVecLH(quat, new float[] { 0f, 0f, 1f });
            float[] right   = QuatUtils.TransformVecLH(quat, new float[] { 1f, 0f, 0f });

            float lf_XZ = (float)Math.Sqrt(forward[0] * forward[0] + forward[2] * forward[2]);
            float lr_XZ = (float)Math.Sqrt(right[0] * right[0] + right[2] * right[2]);

            //Tilt
            if (lr_XZ < 0.00001f)
            {
                res[0] = -(float)(Math.PI * Math.Sign(right[1]));
            }
            else
            {
                res[0] = -(float)Math.Atan(right[1] / lr_XZ);
            }

            //Elevation
            if (lf_XZ < 0.00001f)
            {
                res[0] = (float)(Math.PI * Math.Sign(forward[1]));
            }
            else
            {
                res[1] = (float)Math.Atan(forward[1] / lf_XZ);
            }

            if (coordSpace == CoordSpace.World)
            {
                res[0] = -res[0];
                res[0] = -res[1];
            }

            //Convert radians to degrees
            res[0] *= Mathf.Rad2Deg;
            res[1] *= Mathf.Rad2Deg;

            return(res);
        }
Example #27
0
        public void UpdateMeasurePoint(Vector3d point, CoordSpace eSpace, int nPointNum, bool isFixedPoint = true)
        {
            if (eSpace == CoordSpace.ObjectCoords)
            {
                throw new NotSupportedException("TwoPointMeasureTool.UpdateMeasurePoint");
            }

            Vector3d pointS = (eSpace == CoordSpace.SceneCoords) ? point : scene.ToSceneP(point);

            int i = MathUtil.Clamp(nPointNum, 0, 1);

            setPointsS[i]        = pointS;
            snappedPointsS[i]    = setPointsS[i];
            point_initialized[i] = true;

            if (isFixedPoint)
            {
                return;
            }

            // snap
            List <SceneObject> targets = (SpecificTargets != null) ? SpecificTargets : new List <SceneObject>(scene.SceneObjects);

            float fAvgSnapDist = 0;
            int   avgcount     = 0;

            foreach (var so in targets)
            {
                fAvgSnapDist += VRUtil.GetVRRadiusForVisualAngle(so.GetLocalFrame(CoordSpace.WorldCoords).Origin,
                                                                 scene.ActiveCamera.GetPosition(), snapThresholdAngle);
                avgcount++;
            }
            if (avgcount == 0)
            {
                return;
            }
            fAvgSnapDist /= avgcount;

            SORayHit nearestW;
            Vector3d pointW = (eSpace == CoordSpace.WorldCoords) ? point : scene.ToWorldP(point);

            if (SceneUtil.FindNearestPoint(targets, pointW, fAvgSnapDist, out nearestW, CoordSpace.WorldCoords))
            {
                snappedPointsS[i] = scene.ToSceneP(nearestW.hitPos);
            }
        }
Example #28
0
        public Frame3 GetLocalFrame(CoordSpace eSpace)
        {
            Frame3 targetFrame = target.GetLocalFrame(eSpace);

            if (eSpace == CoordSpace.WorldCoords)
            {
                return(new Frame3(targetFrame.Origin, parentScene.RootGameObject.transform.rotation));
            }
            else if (eSpace == CoordSpace.SceneCoords)
            {
                return(new Frame3(targetFrame.Origin, parentScene.RootGameObject.transform.localRotation));
            }
            else
            {
                return(new Frame3(targetFrame.Origin, curRotation * Quaternion.identity));
            }
        }
Example #29
0
 public static Frame3f GetGameObjectFrame(this MMDModel go, CoordSpace eSpace)
 {
     if (eSpace == CoordSpace.WorldCoords)
     {
         return(new Frame3f(go.Position, go.Rotation));
     }
     else if (eSpace == CoordSpace.ObjectCoords)
     {
         //return new Frame3f(go.transform.localPosition, go.transform.localRotation);
         //Util.DebugWrite("ObjectCoords" + go.Rotation.ToString( ) );
         return(new Frame3f(go.Position, go.Rotation));
     }
     else
     {
         throw new ArgumentException("not possible without refernce to scene!");
     }
 }
        override public Frame3f GetLocalFrame(CoordSpace eSpace)
        {
            Frame3f targetFrame = target.GetLocalFrame(eSpace);

            if (eSpace == CoordSpace.WorldCoords)
            {
                return(new Frame3f(targetFrame.Origin, parentScene.RootGameObject.GetRotation()));
            }
            else if (eSpace == CoordSpace.SceneCoords)
            {
                return(new Frame3f(targetFrame.Origin, parentScene.RootGameObject.GetLocalRotation()));
            }
            else
            {
                return(new Frame3f(targetFrame.Origin, curRotation * Quaternionf.Identity));
            }
        }
Example #31
0
        private static float[] Convert(float[] quat, CoordSpace coordSpace)
        {
            float[] res = new float[2];

            if (coordSpace == CoordSpace.World)
                quat = QuatUtils.Inverse(quat);

            float[] forward = QuatUtils.TransformVecLH(quat, new float[] { 0f, 0f, 1f });

            float lXZ = (float)Math.Sqrt(forward[0] * forward[0] + forward[2] * forward[2]);

            //Azimuth
            if (lXZ < 0.00001f)
                res[0] = (float)Math.Sign(forward[0]) * (float)Math.PI;
            else
                res[0] = (float)Math.Asin((double)forward[0] / (double)lXZ);

            if (forward[2] < 0)
                res[0] = (float)Math.Sign(res[0]) * (float)Math.PI - res[0];

            //Elevation
            if (lXZ < 0.00001f)
                res[0] = (float)(Math.PI * Math.Sign(forward[1]));
            else
                res[1] = (float)Math.Atan(forward[1] / lXZ);

            if (coordSpace == CoordSpace.World)
            {
                res[0] = -res[0];
                res[0] = -res[1];
            }

            return res;
        }
Example #32
0
 /// <summary>
 /// Converts the rotation quaternion to tilt-elevation representation
 /// </summary>
 /// <returns>The tilt-elevation representation of the quaternion, {tilt, elevation}</returns>
 /// <param name="quat">The quaternion to convert</param>
 /// <param name="coordSpace">Use <c>CoordSpace.Body</c> to convert regarding to Device axes or 
 /// <c>CoordSpace.World</c> to convert regarding to world axes</param> 
 public static Vector2 Convert(Quaternion quat, CoordSpace coordspace = CoordSpace.Body)
 {
     float[] te = Convert(new float[] { quat.w, quat.x, quat.y, quat.z }, coordspace);
     return new Vector2(te[0], te[1]);
 }
Example #33
0
        private static float[] Convert(float[] quat, CoordSpace coordSpace)
        {
            float[] res = new float[2];

            if (coordSpace == CoordSpace.World)
                quat = QuatUtils.Inverse(quat);

            float[] forward = QuatUtils.TransformVecLH(quat, new float[] { 0f, 0f, 1f });
            float[] right = QuatUtils.TransformVecLH(quat, new float[] { 1f, 0f, 0f });

            float lf_XZ = (float)Math.Sqrt(forward[0] * forward[0] + forward[2] * forward[2]);
            float lr_XZ = (float)Math.Sqrt(right[0] * right[0] + right[2] * right[2]);

            //Tilt
            if (lr_XZ < 0.00001f)
                res[0] = -(float)(Math.PI * Math.Sign(right[1]));
            else
                res[0] = -(float)Math.Atan(right[1] / lr_XZ);

            //Elevation
            if (lf_XZ < 0.00001f)
                res[0] = (float)(Math.PI * Math.Sign(forward[1]));
            else
                res[1] = (float)Math.Atan(forward[1] / lf_XZ);

            if (coordSpace == CoordSpace.World)
            {
                res[0] = -res[0];
                res[0] = -res[1];
            }

            return res;
        }