Beispiel #1
0
        private void InsertCurve(Vector3[] points, ControlPointSetting setting, ControlPointMode mode, int curveIndex, float length, bool enforceNeighbour)
        {
            Array.Resize(ref m_points, m_points.Length + points.Length);
            Array.Resize(ref m_settings, m_settings.Length + points.Length / 3);
            Array.Resize(ref m_modes, m_modes.Length + points.Length / 3);

            int pointIndex = curveIndex * 3;
            int modeIndex  = (pointIndex + 1) / 3;

            for (int i = m_points.Length - 1; i >= pointIndex + points.Length; --i)
            {
                m_points[i] = m_points[i - points.Length];
            }

            for (int i = m_modes.Length - 1; i >= modeIndex + points.Length / 3; --i)
            {
                m_settings[i] = m_settings[i - points.Length / 3];
                m_modes[i]    = m_modes[i - points.Length / 3];
                RaiseControlPointModeChanged(i);
            }

            for (int i = pointIndex; i < pointIndex + points.Length; ++i)
            {
                m_points[i] = points[i - pointIndex];
            }

            for (int i = modeIndex; i < modeIndex + points.Length / 3; ++i)
            {
                m_settings[i] = setting;
                m_modes[i]    = mode;
                RaiseControlPointModeChanged(i);
            }

            Vector3 dir = transform.InverseTransformDirection(GetDirection(0.0f, curveIndex));

            for (int i = pointIndex - 1; i >= 0; i--)
            {
                m_points[i] -= dir * length;
            }

            if (enforceNeighbour)
            {
                EnforceMode(pointIndex + points.Length + 1);
            }
            else
            {
                EnforceMode(pointIndex + points.Length - 1);
            }

            if (m_loop)
            {
                m_points[m_points.Length - 1] = m_points[0];
                m_settings[0] = m_settings[m_settings.Length - 1];
                m_modes[m_modes.Length - 1] = m_modes[0];
                RaiseControlPointModeChanged(m_modes.Length - 1);
                EnforceMode(1);
            }

            SyncCtrlPoints();
        }
Beispiel #2
0
        protected void AppendCurve(Vector3[] points, ControlPointSetting setting, ControlPointMode mode, bool enforceNeighbour)
        {
            Array.Resize(ref m_points, m_points.Length + points.Length);
            Array.Resize(ref m_settings, m_settings.Length + points.Length / 3);
            Array.Resize(ref m_modes, m_modes.Length + points.Length / 3);

            for (int i = 0; i < points.Length; i++)
            {
                m_points[m_points.Length - points.Length + i] = points[i];
            }

            for (int i = 0; i < points.Length / 3; i++)
            {
                m_settings[m_settings.Length - points.Length / 3 + i] = setting;
                m_modes[m_modes.Length - points.Length / 3 + i]       = mode;
                RaiseControlPointModeChanged(m_modes.Length - points.Length / 3 + i);
            }

            if (enforceNeighbour)
            {
                EnforceMode(m_points.Length - points.Length - 2);
            }
            else
            {
                EnforceMode(m_points.Length - points.Length);
            }

            if (m_loop)
            {
                m_points[0]   = m_points[m_points.Length - 1];
                m_settings[0] = m_settings[m_settings.Length - 1];
                m_modes[0]    = m_modes[m_modes.Length - 1];
                RaiseControlPointModeChanged(0);
                EnforceMode(m_points.Length - 1);
            }
            SyncCtrlPoints();
        }
Beispiel #3
0
        protected void Subdivide(int firstCurveIndex, int lastCurveIndex, int curveCount)
        {
            int firstPointIndex = firstCurveIndex * 3;
            int lastPointIndex  = lastCurveIndex * 3 + 3;
            int pointsLength    = m_points.Length;

            int midPointsCount    = lastPointIndex - firstPointIndex - 1;
            int newMidPointsCount = curveCount * 3 - 1;
            int deltaPoints       = newMidPointsCount - midPointsCount;

            Vector3[] midPoints  = new Vector3[newMidPointsCount];
            Vector3   firstPoint = m_points[firstPointIndex];
            Vector3   lastPoint  = m_points[lastPointIndex];

            ControlPointSetting midPointSetting = m_settings[(firstPointIndex + 1) / 3];
            ControlPointMode    midMode         = m_modes[(firstPointIndex + 1) / 3];

            float deltaT = 1.0f / (newMidPointsCount + 1);
            float t      = 0.0f;

            for (int i = 0; i < newMidPointsCount; ++i)
            {
                t           += deltaT;
                midPoints[i] = Vector3.Lerp(firstPoint, lastPoint, t);
            }

            if (deltaPoints > 0)
            {
                Array.Resize(ref m_points, m_points.Length + deltaPoints);
                Array.Resize(ref m_settings, m_settings.Length + deltaPoints / 3);
                Array.Resize(ref m_modes, m_modes.Length + deltaPoints / 3);

                for (int i = pointsLength - 1; i >= lastPointIndex; i--)
                {
                    m_points[i + deltaPoints] = m_points[i];
                }

                for (int i = pointsLength / 3; i >= (lastPointIndex + 1) / 3; i--)
                {
                    m_settings[i + deltaPoints / 3] = m_settings[i];
                    m_modes[i + deltaPoints / 3]    = m_modes[i];
                    RaiseControlPointModeChanged(i + deltaPoints / 3);
                }
            }
            else if (deltaPoints < 0)
            {
                for (int i = lastPointIndex; i < pointsLength; i++)
                {
                    m_points[i + deltaPoints] = m_points[i];
                }

                for (int i = (lastPointIndex + 1) / 3; i < (pointsLength + 1) / 3; i++)
                {
                    m_settings[i + deltaPoints / 3] = m_settings[i];
                    m_modes[i + deltaPoints / 3]    = m_modes[i];
                    RaiseControlPointModeChanged(i + deltaPoints / 3);
                }

                Array.Resize(ref m_points, m_points.Length + deltaPoints);
                Array.Resize(ref m_settings, m_settings.Length + deltaPoints / 3);
                Array.Resize(ref m_modes, m_modes.Length + deltaPoints / 3);
            }

            for (int i = 0; i < newMidPointsCount; ++i)
            {
                m_points[firstPointIndex + i + 1] = midPoints[i];
            }
            for (int i = 0; i < newMidPointsCount / 3; ++i)
            {
                m_settings[(firstPointIndex + 1) / 3 + i + 1] = midPointSetting;
                m_modes[(firstPointIndex + 1) / 3 + i + 1]    = midMode;
                RaiseControlPointModeChanged((firstPointIndex + 1) / 3 + i + 1);
            }

            int prevPointIndex = firstPointIndex - 1;
            int nextPointIndex = firstPointIndex + newMidPointsCount + 2;

            if (m_loop)
            {
                if (prevPointIndex == -1)
                {
                    prevPointIndex = m_points.Length - 1;
                }
                if (nextPointIndex == m_points.Length)
                {
                    nextPointIndex = 0;
                }
            }

            if (nextPointIndex < m_points.Length)
            {
                EnforceMode(nextPointIndex);
            }

            if (prevPointIndex >= 0)
            {
                EnforceMode(prevPointIndex);
            }

            SyncCtrlPoints();
        }