//@ Build New Curve
    public bool BuildupCurve(int iSeqSpline, E_TYPE_SPLINE eTypeCurve, float fDivisionWeight)
    {
        bool bResultBuild = m_listProcessorSpline[iSeqSpline].BuildupCurve_spline(eTypeCurve, fDivisionWeight);

        if (true == bResultBuild)
        {
            Vector3[] arrv3LineCurve = m_listProcessorSpline[iSeqSpline].getSectionSpline();
            newAssignLineguide__(iSeqSpline, arrv3LineCurve);
        }

        return(bResultBuild);
    }
    //@ Build New Curve
    public bool BuildupCurveCurrent(E_TYPE_SPLINE eTypeCurve, float fDivisionWeight)
    {
        _Clear_LineDraw_Pnts();
        bool bResultBuild = _splineGenerator_active.BuildupCurve_spline(eTypeCurve, fDivisionWeight);

        if (true == bResultBuild)
        {
            Vector3[] arrv3LineCurve = _splineGenerator_active.getSectionSpline();
            newAssignLineguide__(m_iCurveActivate, arrv3LineCurve);
        }

        return(bResultBuild);
    }
    //@ Build New Curve
    public bool BuildupCurveAll(E_TYPE_SPLINE eTypeCurve, float fDivisionWeight)
    {
        bool bBuildupall = true;
        int  iSeqSpline  = 0;

        foreach (CSplineGenerator splinegenerator in m_listProcessorSpline)
        {
            splinegenerator.BuildupCurve_spline(eTypeCurve, fDivisionWeight);
            Vector3[] arrv3LineCurve = splinegenerator.getSectionSpline();
            newAssignLineguide__(iSeqSpline, arrv3LineCurve);
            iSeqSpline++;
        }

        return(bBuildupall);
    }
Пример #4
0
 public void SetTypeSplineCurve(E_TYPE_SPLINE typeSplineCurve)
 {
     m_typeSplineCurve = typeSplineCurve;
 }
Пример #5
0
    //@ Process // BuildupCurve_spline()
    public bool BuildupCurve_spline(E_TYPE_SPLINE eTypeCurve, float fDivisionWeight)
    {
        if (m_listCurvepathunit.Count > 0)
        {
            m_listPath_Spline.Clear();

            foreach (CCurvePathUnit flypathUnit in m_listCurvepathunit)
            {
                if (flypathUnit)
                {
                    m_listPath_Spline.Add(flypathUnit.getPosUnit());
                }
            }
        }

        if (m_listPath_Spline.Count < 1)
        {
            Debug.Log("Cant Buildup CurveList. no Instant Custom Point!!//");
            return(false);
        }

        float fDivisionWeight__ = -1.0f;

        if (fDivisionWeight < 0)
        {
            fDivisionWeight__ = m_fDivisionWeight_LineCurve;
        }
        else
        {
            fDivisionWeight__ = m_fDivisionWeight_LineCurve = fDivisionWeight;
        } // if(fDivisionWeight < 0)


        if (E_TYPE_SPLINE.SPLINE_NULL == eTypeCurve)
        {
            eTypeCurve = m_typeSplineCurve;

            if (E_TYPE_SPLINE.SPLINE_NULL == eTypeCurve)
            {
                eTypeCurve = DEFLT_TYPE_SPLINECURVE;
            }
        } // if (E_TYPE_SPLINE.SPLINE_NULL == eTypeCurve)

        m_typeSplineCurve = eTypeCurve;

        bool bBuildCurve = false;

        switch (m_typeSplineCurve)
        {
        case E_TYPE_SPLINE.SPLINE_ROUNDEDNONUNIFORMSPLINE:
        {
            RNS __ProcessCurve_rns = new RNS();
            foreach (Vector3 v3PntCurve in m_listPath_Spline)
            {
                __ProcessCurve_rns.AddNode(v3PntCurve);
            }

            bBuildCurve = __ProcessCurve_rns.BuildSpline_rns();
            if (false == bBuildCurve)
            {
                Debug.Log("FALSE !! __ProcessCurve_rns.BuildSpline_rns()");
                return(false);
            }

            m_ProcessCurve_Activate = __ProcessCurve_rns;
        }
        break;

        case E_TYPE_SPLINE.SPLINE_SMOOTHNONUNIFORMSPLINE:
        {
            SNS __ProcessCurve_sns = new SNS();

            foreach (Vector3 v3PntCurve in m_listPath_Spline)
            {
                __ProcessCurve_sns.AddNode(v3PntCurve);
            }

            bBuildCurve = __ProcessCurve_sns.BuildSpline_sns();
            if (false == bBuildCurve)
            {
                Debug.Log("FALSE !! __ProcessCurve_sns.BuildSpline_sns()");
                return(false);
            }

            m_ProcessCurve_Activate = __ProcessCurve_sns;
        }
        break;

        case E_TYPE_SPLINE.SPLINE_TIMEDUNIFORMSPLINE:
        {
            TNS __ProcessCurve_tns = new TNS();

            foreach (Vector3 v3PntCurve in m_listPath_Spline)
            {
                __ProcessCurve_tns.AddNode(v3PntCurve);
            }

            bBuildCurve = __ProcessCurve_tns.BuildSpline_tns();

            if (false == bBuildCurve)
            {
                Debug.Log("FALSE !! __ProcessCurve_tns.BuildSpline_tns()");
                return(false);
            }

            m_ProcessCurve_Activate = __ProcessCurve_tns;
        }
        break;

        default:
        {
            Debug.Log("m_typeSplineCurve is not valid type.");

            m_ProcessCurve_Activate = null;
            return(false);
        }
        } // switch(m_typeSplineCurve)

        int iCntTime_Division = (int)(m_ProcessCurve_Activate.m_fmaxDistance * fDivisionWeight__ * multiply_adjust_divisionWeight);

        m_arrSectionCurve = new Vector3[iCntTime_Division];

        //@ First, Last Position are we just knew.
        m_arrSectionCurve[0] = m_listPath_Spline[0];
        m_arrSectionCurve[iCntTime_Division - 1] = m_listPath_Spline[m_listPath_Spline.Count - 1];

        for (int iSeq = 1; iSeq <= iCntTime_Division - 1; ++iSeq)
        {
            float fT = (float)iSeq / (float)iCntTime_Division;

            Vector3 v3PosNew_Curve = new Vector3();
            v3PosNew_Curve          = m_ProcessCurve_Activate.GetPositionSpline(fT);
            m_arrSectionCurve[iSeq] = v3PosNew_Curve;
        }

        m_bBuildedCurve = true;

        return(true);
    } // public bool BuildupCurve_spline(E_TYPE_SPLINE eTypeCurve)