Exemple #1
0
        private static void UpdateTimeScale()
        {
            var value = 1f;

            foreach (var kv in timeScaleList)
            {
                value *= kv.Value;
            }
            Time.timeScale = value;
            OnScaleChange?.Invoke(value);
        }
Exemple #2
0
 public void ScaleChanged(Vector3 scale)
 {
     OnScaleChange?.Invoke(scale);
 }
Exemple #3
0
        public override void Update(Camera cam)
        {
            if (!Visible)
            {
                return;
            }

            var ori = Rotation;// : Quaternion.Identity;

            Vector3 xdir = Vector3.UnitX;
            Vector3 ydir = Vector3.UnitY;
            Vector3 zdir = Vector3.UnitZ;

            Vector3[]    axes    = { xdir, ydir, zdir };
            Vector3[]    sides1  = { ydir, zdir, xdir };
            Vector3[]    sides2  = { zdir, xdir, ydir };
            WidgetAxis[] sideax1 = { WidgetAxis.Y, WidgetAxis.Z, WidgetAxis.X };
            WidgetAxis[] sideax2 = { WidgetAxis.Z, WidgetAxis.X, WidgetAxis.Y };



            Quaternion iori   = Quaternion.Invert(ori);
            Vector3    camrel = iori.Multiply(Position - cam.Position);
            Vector3    cdir   = Vector3.Normalize(camrel);
            Ray        ray    = cam.MouseRay;

            ray.Position  = iori.Multiply(ray.Position);
            ray.Direction = iori.Multiply(ray.Direction);


            float dist = camrel.Length();
            float size = GetWorldSize(Size, dist, cam);

            float axhitrad   = 0.09f * size;
            float axhitstart = 0.4f * size;
            float axhitend   = 1.33f * size;
            float innertri   = 0.7f * size;
            float outertri   = 1.0f * size;

            //test for single and double axes hits
            BoundingBox bb   = new BoundingBox();
            float       hitd = float.MaxValue;
            float       d;
            Vector3     hitp;
            WidgetAxis  hitax = WidgetAxis.None;

            for (int i = 0; i < 3; i++)
            {
                WidgetAxis ax = (WidgetAxis)(1 << i);
                Vector3    s  = sides1[i] * axhitrad + sides2[i] * axhitrad;
                bb.Minimum = camrel - s + axes[i] * axhitstart;
                bb.Maximum = camrel + s + axes[i] * axhitend;
                if (ray.Intersects(ref bb, out d)) //single axis
                {
                    if (d < hitd)
                    {
                        hitd  = d;
                        hitax = ax;
                    }
                }

                Vector3 s1 = axes[i];
                Vector3 s2 = sides1[i];
                if (GetAxisRayHit(s1, s2, camrel, ray, out hitp))
                {
                    //test if hitp is within the inner triangle - uniform scale
                    //test if hitp is within the outer triangle - 2 axes scale
                    float hitpl = hitp.Length();
                    if (hitpl > hitd)
                    {
                        continue;
                    }
                    Vector3 hitrel = hitp - camrel;
                    float   d1     = Vector3.Dot(hitrel, s1);
                    float   d2     = Vector3.Dot(hitrel, s2);

                    if ((d1 > 0) && (d2 > 0))
                    {
                        if ((d1 < innertri) && (d2 < innertri) && ((d1 + d2) < innertri))
                        {
                            hitd  = hitpl;
                            hitax = WidgetAxis.XYZ;
                        }
                        else if ((d1 < outertri) && (d2 < outertri) && ((d1 + d2) < outertri))
                        {
                            hitd  = hitpl;
                            hitax = ax | sideax1[i];
                        }
                    }
                }
            }
            if (LockXY)
            {
                switch (hitax)
                {
                case WidgetAxis.X:
                case WidgetAxis.Y:
                    hitax = WidgetAxis.XY;
                    break;

                case WidgetAxis.XZ:
                case WidgetAxis.YZ:
                    hitax = WidgetAxis.XYZ;
                    break;
                }
            }


            MousedAxis = hitax;


            if (IsDragging && !WasDragging)
            {
                //drag start. mark the start vector and axes
                DraggedAxis        = MousedAxis;
                DragStartScale     = Scale;
                DraggedAxisDir     = axes[0];
                DraggedAxisSideDir = axes[1];

                switch (DraggedAxis)
                {
                case WidgetAxis.XZ: DraggedAxisSideDir = axes[2]; break;

                case WidgetAxis.YZ: DraggedAxisDir = axes[1]; DraggedAxisSideDir = axes[2]; break;

                case WidgetAxis.Y: DraggedAxisDir = axes[1]; break;

                case WidgetAxis.Z: DraggedAxisDir = axes[2]; break;
                }
                switch (DraggedAxis) //find the best second axis to use, for single axis motion only.
                {
                case WidgetAxis.X:
                case WidgetAxis.Y:
                case WidgetAxis.Z:
                    int   curax = GetAxisIndex(DraggedAxis);
                    int   minax = 0;
                    float mindp = float.MaxValue;
                    for (int i = 0; i < 3; i++)
                    {
                        if (i != curax)
                        {
                            float dp = Math.Abs(Vector3.Dot(cdir, axes[i]));
                            if (dp < mindp)
                            {
                                mindp = dp;
                                minax = i;
                            }
                        }
                    }
                    DraggedAxisSideDir = axes[minax];
                    break;
                }
                if (DraggedAxis == WidgetAxis.XYZ)
                {
                    //all axes, move in the screen plane
                    float ad1 = Math.Abs(Vector3.Dot(cdir, Vector3.UnitY));
                    float ad2 = Math.Abs(Vector3.Dot(cdir, Vector3.UnitZ));
                    DraggedAxisDir     = Vector3.Normalize(Vector3.Cross(cdir, (ad1 > ad2) ? Vector3.UnitY : Vector3.UnitZ));
                    DraggedAxisSideDir = Vector3.Normalize(Vector3.Cross(cdir, DraggedAxisDir));
                }


                bool hit = GetAxisRayHit(DraggedAxisDir, DraggedAxisSideDir, camrel, ray, out DragStartVec);
                if ((MousedAxis == WidgetAxis.None) || !hit)
                {
                    IsDragging = false;
                }
            }
            else if (IsDragging)
            {
                //continue drag.
                Vector3 newvec;
                bool    hit = GetAxisRayHit(DraggedAxisDir, DraggedAxisSideDir, camrel, ray, out newvec);
                if (hit)
                {
                    Vector3 diff = newvec - DragStartVec;
                    switch (DraggedAxis)
                    {
                    case WidgetAxis.X: diff.Y = 0; diff.Z = 0; break;

                    case WidgetAxis.Y: diff.X = 0; diff.Z = 0; break;

                    case WidgetAxis.Z: diff.X = 0; diff.Y = 0; break;
                    }

                    //diff = ori.Multiply(diff);
                    Vector3 ods = DragStartVec - camrel;                   // ori.Multiply(DragStartVec);
                    float   odl = Math.Max(ods.Length(), 0.0001f);         //don't divide by 0
                    float   ndl = Math.Max((ods + diff).Length(), 0.001f); //don't scale to 0 size
                    float   dl  = ndl / odl;

                    if (diff.Length() < 10000.0f) //limit movement in one go, to avoid crazy values...
                    {
                        Vector3 oldscale = Scale;
                        Vector3 sv       = Vector3.One;
                        switch (DraggedAxis)
                        {
                        case WidgetAxis.X: sv = new Vector3(dl, 1, 1); break;

                        case WidgetAxis.Y: sv = new Vector3(1, dl, 1); break;

                        case WidgetAxis.Z: sv = new Vector3(1, 1, dl); break;

                        case WidgetAxis.XY: sv = new Vector3(dl, dl, 1); break;

                        case WidgetAxis.YZ: sv = new Vector3(1, dl, dl); break;

                        case WidgetAxis.XZ: sv = new Vector3(dl, 1, dl); break;

                        case WidgetAxis.XYZ: sv = new Vector3(dl); break;
                        }
                        Scale = DragStartScale * sv;

                        if (Scale != oldscale)
                        {
                            OnScaleChange?.Invoke(Scale, oldscale);
                        }
                    }
                }
            }

            WasDragging = IsDragging;
        }
Exemple #4
0
 private void ScaleWidget_OnScaleChange(Vector3 newscale, Vector3 oldscale)
 {
     OnScaleChange?.Invoke(newscale, oldscale);
 }
 private void Start()
 {
     positionAttribute.OnChanged += (x) => OnPositionChange?.Invoke(x);
     rotationAttribute.OnChanged += (x) => OnRotationChange?.Invoke(x);
     scaleAttribute.OnChanged    += (x) => OnScaleChange?.Invoke(x);
 }
        private void ScaleChange(object sender, EventArgs e)
        {
            Utils.SaveSetting("PhaseInspector.Scale", scaleBar.Value);

            OnScaleChange?.Invoke(scaleBar.Value);
        }