Exemple #1
0
        public void EndDraw()
        {
            if (preview.Curve.ArcLength > 2 * SamplingRate)
            {
                if (EmitNewCurveF == null)
                {
                    // store undo/redo record for new primitive
                    SOMaterial  mat     = (CurveMaterialF == null) ? scene.DefaultCurveSOMaterial : CurveMaterialF();
                    PolyCurveSO CurveSO = preview.BuildSO(mat, 1.0f);
                    scene.History.PushChange(
                        new AddSOChange()
                    {
                        scene = scene, so = CurveSO, bKeepWorldPosition = false
                    });

                    // link ?
                    if (AttachCurveToSurface)
                    {
                        scene.History.PushChange(
                            new SOAddFrameLinkChangeOp(CurveSO, Target as TransformableSO));
                    }

                    scene.History.PushInteractionCheckpoint();
                }
                else
                {
                    EmitNewCurveF(preview);
                }
            }

            preview.Destroy();
            preview = null;

            //SavedSettings.Save("DrawSurfaceCurveTool_width", width);
        }
Exemple #2
0
 public void CancelDraw()
 {
     if (preview != null)
     {
         preview.Destroy();
         preview = null;
     }
 }
Exemple #3
0
        void CreateNewCurve()
        {
            if (AttachCurveToSurface)
            {
                preview = new LocalCurvePreview(Target as TransformableSO);
            }
            else
            {
                preview = new CurvePreview();
            }

            preview.Closed = this.Closed;

            SOMaterial useMat = (CurveMaterialF == null) ? scene.DefaultCurveSOMaterial : CurveMaterialF();

            preview.Create(useMat, scene.RootGameObject,
                           (overlay) ? FPlatform.WidgetOverlayLayer : -1);
        }
Exemple #4
0
        public virtual void EndDraw()
        {
            in_draw = false;
            if (preview == null)
            {
                return;
            }
            if (preview.Curve.VertexCount > 2 && preview.Curve.ArcLength > 2 * SamplingRateScene)
            {
                // update Closed state because in some cases we change this during drawing
                // (ie when drawing multi-point curve, but closing at end)
                preview.Closed = this.Closed;

                if (EmitNewCurveF == null)
                {
                    // store undo/redo record for new primitive
                    SOMaterial  mat     = (CurveMaterialF == null) ? Scene.DefaultCurveSOMaterial : CurveMaterialF();
                    PolyCurveSO CurveSO = preview.BuildSO(mat, 1.0f);
                    Scene.History.PushChange(
                        new AddSOChange()
                    {
                        scene = Scene, so = CurveSO, bKeepWorldPosition = false
                    });

                    // link ?
                    if (AttachCurveToSurface)
                    {
                        Scene.History.PushChange(
                            new SOAddFrameLinkChangeOp(CurveSO, Target));
                    }

                    Scene.History.PushInteractionCheckpoint();
                }
                else
                {
                    EmitNewCurveF(preview);
                }
            }

            preview.Destroy();
            preview = null;

            //SavedSettings.Save("DrawSurfaceCurveTool_width", width);
        }
        void CreateNewCurve()
        {
            if (AttachCurveToTarget && Target != null)
            {
                preview = new LocalCurvePreview(Target);
            }
            else
            {
                preview = new CurvePreview();
            }

            preview.Closed = this.Closed;

            SOMaterial useMat = (CurveMaterialF == null) ? Scene.DefaultCurveSOMaterial : CurveMaterialF();

            preview.Create(useMat, Scene.RootGameObject,
                           (overlay) ? FPlatform.WidgetOverlayLayer : -1);

            if (CurveProcessorF != null)
            {
                preview.CurveProcessorF = CurveProcessorF;
            }
        }
Exemple #6
0
        public void smooth_append(CurvePreview preview, Vector3f newPos, float fDistThresh)
        {
            // empty curve, always append
            if (preview.VertexCount == 0)
            {
                preview.AppendVertex(newPos);
                last_append_idx      = preview.VertexCount - 1;
                appended_last_update = true;
                have_temp_append     = false;
                return;
            }

            double d = (newPos - preview[last_append_idx]).Length;

            if (d < fDistThresh)
            {
                // have not gone far enough for a real new vertex!

                Vector3f usePos = new Vector3f(newPos);
                bool     bValid = false;

                // do we have enough vertices to do a good job?
                if (preview.VertexCount > 3)
                {
                    int      nLast = (have_temp_append) ? preview.VertexCount - 2 : preview.VertexCount - 1;
                    Vector3d tan   = preview.Tangent(nLast);
                    double   fDot  = tan.Dot((usePos - preview[nLast]).Normalized);
                    if (fDot > 0.9f)        // cos(25) ~= 0.9f
                    // new vtx is aligned with tangent of last "real" vertex
                    {
                        bValid = true;
                    }
                    else
                    {
                        // not aligned, try projection onto tangent
                        Line3d l = new Line3d(preview[nLast], tan);
                        double t = l.Project(newPos);
                        if (t > 0)
                        {
                            // projection of new vtx is 'ahead' so we can use it
                            usePos = (Vector3f)l.PointAt(t);
                            bValid = true;
                        }
                    }
                }

                if (bValid)
                {
                    if (appended_last_update)
                    {
                        preview.AppendVertex(usePos);
                        have_temp_append = true;
                    }
                    else if (have_temp_append)
                    {
                        preview[preview.VertexCount - 1] = usePos;
                    }
                }

                appended_last_update = false;
            }
            else
            {
                // ok we drew far enough, add this position

                if (have_temp_append)
                {
                    // re-use temp vertex
                    preview[preview.VertexCount - 1] = newPos;
                    have_temp_append = false;
                }
                else
                {
                    preview.AppendVertex(newPos);
                }
                last_append_idx      = preview.VertexCount - 1;
                appended_last_update = true;

                // do smoothing pass
                // [TODO] cannot do this until we can reproject onto surface!!
                //smoother.End = curve.VertexCount - 1;
                //smoother.Start = MathUtil.Clamp(smoother.End - 5, 0, smoother.End);
                //smoother.UpdateDeformation(2);
            }
        }