示例#1
0
        private void LateUpdate()
        {
            if (!clickVisualFeedTarget || (!_targetDirty && !_mouseDown))
            {
                return;
            }

            if ((Time.time - _mouseDownTime) > maxHoldForClick || ((Input.mousePosition.ToVector2() - _mouseDownPosition).magnitude > maxMousePositionPixOffsetForClick))
            {
                _mouseDown = false;
            }

            if (transition == ClickableElementTransition.Fade)
            {
                var a = clickVisualFeedTarget.color.a;

                var target = _mouseDown ? 0.75f : 1;

                a = QcMath.LerpBySpeed(a, target, 5);

                clickVisualFeedTarget.TrySetAlpha(a);

                _targetDirty = (Math.Abs(a - 1) > float.Epsilon);
            }
        }
示例#2
0
        public Vector3 GetSharpNormal()
        {
            sharpNormal = QcMath.GetNormalOfTheTriangle(
                vertexes[0].LocalPos,
                vertexes[1].LocalPos,
                vertexes[2].LocalPos);

            return(sharpNormal);
        }
 public void UpdateSpeed(ref float speed)
 {
     if (speed < startSpeed)
     {
         QcMath.IsLerpingBySpeed(ref speed, startSpeed, startSpeed * 0.3f);
     }
     else
     {
         speed += accelerationPerSecond * Time.deltaTime;
     }
 }
示例#4
0
        public Vector3 GetNormalByArea(float accuracyFix = 1)
        {
            var p0 = vertexes[0].LocalPos * accuracyFix;
            var p1 = vertexes[1].LocalPos * accuracyFix;
            var p2 = vertexes[2].LocalPos * accuracyFix;

            sharpNormal = QcMath.GetNormalOfTheTriangle(
                p0,
                p1,
                p2);

            return(sharpNormal * Vector3.Cross(p0 - p1, p0 - p2).magnitude);
        }
示例#5
0
        public static void SHADER_POSITION_AND_PREVIEW_UPDATE(StrokeVector st, bool hidePreview, float size)
        {
            PainterDataAndConfig.BRUSH_POINTED_UV.GlobalValue = st.uvTo.ToVector4(0, _previewAlpha);

            if (hidePreview && Math.Abs(_previewAlpha) < float.Epsilon)
            {
                return;
            }

            QcMath.IsLerpingBySpeed(ref _previewAlpha, hidePreview ? 0 : 1, 4f);

            PainterDataAndConfig.BRUSH_WORLD_POS_FROM.GlobalValue = _prevPosPreview.ToVector4(size);
            PainterDataAndConfig.BRUSH_WORLD_POS_TO.GlobalValue   = st.posTo.ToVector4((st.posTo - _prevPosPreview).magnitude); //new Vector4(st.posTo.x, st.posTo.y, st.posTo.z, (st.posTo - prevPosPreview).magnitude));
            _prevPosPreview = st.posTo;
        }
示例#6
0
        private bool ProcessLinesOnTriangle(PainterMesh.Triangle t)
        {
            t.wasProcessed = true;
            const float precision = 0.05f;

            var acc = (targetTransform.InverseTransformPoint(CurrentViewTransform().position) - collisionPosLocal).magnitude;

            acc *= precision;

            var v0 = t.vertexes[0];
            var v1 = t.vertexes[1];
            var v2 = t.vertexes[2];

            var v0p = v0.meshPoint.distanceToPointed;
            var v1p = v1.meshPoint.distanceToPointed;
            var v2p = v2.meshPoint.distanceToPointed;

            if (QcMath.IsPointOnLine(v0p, v1p, Vector3.Distance(v0.LocalPos, v1.LocalPos), acc))
            {
                ProcessPointOnALine(v0, v1, t);
                return(true);
            }

            if (QcMath.IsPointOnLine(v1p, v2p, Vector3.Distance(v1.LocalPos, v2.LocalPos), acc))
            {
                ProcessPointOnALine(v1, v2, t);
                return(true);
            }

            if (QcMath.IsPointOnLine(v2p, v0p, Vector3.Distance(v2.LocalPos, v0.LocalPos), acc))
            {
                ProcessPointOnALine(v2, v0, t);
                return(true);
            }


            return(false);
        }
示例#7
0
        public void UpdatePositions()
        {
            var m   = MeshMGMT;
            var cfg = TexMgmtData;

            if (!cfg)
            {
                return;
            }

            var showGrid = MeshEditorManager.target.NeedsGrid() || TexMGMT.FocusedPainter.NeedsGrid();

            SetEnabled(showGrid, cfg.snapToGrid && showGrid);

            if (!showGrid)
            {
                return;
            }

            if (cfg.gridSize <= 0)
            {
                cfg.gridSize = 1;
            }

            switch (gSide)
            {
            case Gridside.xy:
                rendy.transform.rotation = ZGrid;
                break;

            case Gridside.xz:
                rendy.transform.rotation = YGrid;
                break;

            case Gridside.zy:
                rendy.transform.rotation = XGrid;
                break;
            }

            _xzPlane.distance = -onGridPos.y;
            _xyPlane.distance = -onGridPos.z;
            _zyPlane.distance = -onGridPos.x;

            var hit = Vector3.zero;

            switch (gSide)
            {
            case Gridside.xy:
                hit = MouseToPlane(_xyPlane);
                break;

            case Gridside.xz:
                hit = MouseToPlane(_xzPlane);
                break;

            case Gridside.zy:
                hit = MouseToPlane(_zyPlane);
                break;
            }

            if (cfg.snapToGrid)
            {
                hit = QcMath.RoundDiv(hit, cfg.gridSize);
            }

            if (hit != Vector3.zero)
            {
                switch (gSide)
                {
                case Gridside.xy:

                    onGridPos.x = hit.x;
                    onGridPos.y = hit.y;

                    break;

                case Gridside.xz:
                    onGridPos.x = hit.x;
                    onGridPos.z = hit.z;
                    break;

                case Gridside.zy:

                    onGridPos.z = hit.z;
                    onGridPos.y = hit.y;
                    break;
                }
            }

            var tf    = transform;
            var dotTf = dot.transform;
            var rndTf = rendy.transform;

            tf.position = onGridPos + Vector3.one * 0.01f;

            var position = tf.position;

            _dotPositionProperty.GlobalValue = new Vector4(onGridPos.x, onGridPos.y, onGridPos.z);

            dotTf.rotation = CurrentViewTransform().rotation;

            var cam = CurrentViewTransform();

            var dist = Mathf.Max(0.1f, (cam.position - position).magnitude * 2);

            dotTf.localScale = Vector3.one * (dist / 64f);
            rndTf.localScale = new Vector3(dist, dist, dist);

            float scale = !cfg.snapToGrid ? Mathf.Max(1, Mathf.ClosestPowerOfTwo((int)(dist / 8))) : cfg.gridSize;

            var dx = gSide != Gridside.zy ? position.x : -position.z;

            var dy = gSide != Gridside.xz ? position.y : position.z;

            dx -= Mathf.Round(dx / scale) * scale;
            dy -= Mathf.Round(dy / scale) * scale;

            var mat = rendy.sharedMaterial;

            mat.Set(_dxProp, dx / dist)
            .Set(_dyProp, dy / dist)
            .Set(_sizeProp, dist / scale);

            if (MeshEditorManager.target)
            {
                MeshMGMT.UpdateLocalSpaceMousePosition();
            }
        }
示例#8
0
 public bool LerpBySpeed(float targetValue, float speed) => QcMath.IsLerpingBySpeed(ref colorAlpha, targetValue, speed);