SCR_ShapeNextPointHelper.c

Go to the documentation of this file.

 
//  TODO:
//      - in shape's length (straightLine parameter)
 
class SCR_ShapeNextPointHelper
{
    protected ref array<vector> m_aAnchorPoints;                
    protected ref array<vector> m_aTesselatedPoints;            
    protected ref array<int> m_aAnchorPointIndices;             
    protected ref array<ref array<vector>> m_aSegments;         
    protected ref array<ref array<vector>> m_aSections;         
//  protected ref array<ref array<float>> m_aSectionLengths;    //!< format [anchor0to1shapeLength, anchor1to2shapeLength] - shape length = length following the spline
    protected int m_iSegmentsCount;                             
    protected int m_iAnchorPointsCount;                         
//  protected int m_iTesselatedPointsCount;                     //!< count of m_aTesselatedPoints
 
    protected int m_iCurrentSectionIndex;
    protected int m_iCurrentSectionPointIndex;
    protected int m_iCurrentSegmentIndex;
    protected vector m_vCurrentPosition;
    protected vector m_vCurrentDirection;
 
    protected float m_fDoneLength;
    protected float m_fTotalLength;
 
    //------------------------------------------------------------------------------------------------
    array<vector> GetAnchorPoints()
    {
        return SCR_ArrayHelperT<vector>.GetCopy(m_aAnchorPoints);
    }
 
    //------------------------------------------------------------------------------------------------
    array<int> GetAnchorPointIndices()
    {
        return SCR_ArrayHelperT<int>.GetCopy(m_aAnchorPointIndices);
    }
 
    //------------------------------------------------------------------------------------------------
    array<vector> GetTesselatedPoints()
    {
        return SCR_ArrayHelperT<vector>.GetCopy(m_aTesselatedPoints);
    }
 
    //------------------------------------------------------------------------------------------------
    vector GetCurrentPosition()
    {
        return m_vCurrentPosition;
    }
 
    //------------------------------------------------------------------------------------------------
    vector GetCurrentDirection()
    {
        return m_vCurrentDirection;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetShapeLength()
    {
        return m_fTotalLength;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetDoneShapeLength()
    {
        return m_fDoneLength;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetRemainingShapeLength()
    {
        return m_fTotalLength - m_fDoneLength;
    }
 
    //------------------------------------------------------------------------------------------------
    // bruteforce for now, optimisation later
    protected float CalculateCurrentSegmentIndex()
    {
        float currentSegmentIndex;
        for (int i; i < m_iCurrentSectionIndex; ++i)
        {
            currentSegmentIndex += m_aSections[i].Count() - 1;
        }
 
        return currentSegmentIndex + m_iCurrentSectionPointIndex;
    }
 
    //------------------------------------------------------------------------------------------------
    // bruteforce for now, optimisation later
    protected float CalculateDoneLength()
    {
        float doneLength;
        foreach (int i, array<vector> segment : m_aSegments)
        {
            if (i >= m_iCurrentSegmentIndex)
            {
                doneLength += vector.Distance(segment[0], m_vCurrentPosition);
                return doneLength;
            }
 
            doneLength += vector.Distance(segment[0], segment[1]);
        }
 
        return -1;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetNextPoint(float distance, out vector result, int anchorLimit = -1, bool straightLine = true, bool doNotMove = false, bool xzMode = false)
    {
        if (distance <= 0)
        {
            Print("SCR_ShapeNextPointHelper.GetNextPoint's distance parameter cannot be zero or negative!", LogLevel.ERROR);
            return false; // wrong distance
        }
 
        if (anchorLimit == -1)
            anchorLimit = m_iAnchorPointsCount - 1;
 
        if (anchorLimit < 1 || anchorLimit >= m_iAnchorPointsCount)
        {
            Print("SCR_ShapeNextPointHelper.GetNextPoint's anchorLimit parameter is invalid (must be in range 1.." + m_iAnchorPointsCount + ", was " + anchorLimit + ")", LogLevel.ERROR);
            return false;
        }
 
        if (anchorLimit <= m_iCurrentSectionIndex)
        {
            Print("SCR_ShapeNextPointHelper.GetNextPoint's anchorLimit parameter is already passed (" + anchorLimit + " requested, " + m_iCurrentSectionIndex + " current)", LogLevel.WARNING);
            return false;
        }
 
        float distanceSq = distance * distance;
 
        int currentSectionIndex = m_iCurrentSectionIndex;
        int currentSectionPoint = m_iCurrentSectionPointIndex + 1;
//      float addedLength;
 
        if (!m_aSections[currentSectionIndex].IsIndexValid(currentSectionPoint))
        {
            currentSectionIndex++;
            currentSectionPoint = 1; // because end point of previous section = first point of next section
        }
 
        vector prevPoint = m_aSections[m_iCurrentSectionIndex][m_iCurrentSectionPointIndex];
 
        array<vector> sectionPoints;
//      array<float> sectionSegmentsLength;
        for (; currentSectionIndex < anchorLimit; currentSectionIndex++)
        {
            sectionPoints = m_aSections[currentSectionIndex];
//          sectionSegmentsLength = m_aSectionLengths[currentSectionIndex];
 
            for (int pointIndex = currentSectionPoint, sectionPointsCount = sectionPoints.Count(); pointIndex < sectionPointsCount; pointIndex++)
            {
                vector nextPoint = sectionPoints[pointIndex];
//              if (straightLine)
//              {
                    if (
                        (xzMode && vector.DistanceSqXZ(m_vCurrentPosition, nextPoint) > distanceSq) ||  // 2D mode
                        (!xzMode && vector.DistanceSq(m_vCurrentPosition, nextPoint) > distanceSq))     // 3D mode
                    {
                        vector endToStartDir = vector.Direction(nextPoint, prevPoint);
                        if (xzMode) // 2D mode - there must exist a better formula, todo later
                        {
                            vector endToStartDirXZ = endToStartDir;
                            endToStartDirXZ[1] = 0;
                            vector sameLevelCentre = m_vCurrentPosition;
                            sameLevelCentre[1] = nextPoint[1];
                            float removedRatio;
                            if (vector.DistanceXZ(nextPoint, prevPoint) != 0)
                                removedRatio =
                                    Math3D.IntersectionRaySphere(nextPoint, endToStartDirXZ.Normalized(), sameLevelCentre, distance)
                                    / vector.DistanceXZ(nextPoint, prevPoint);
 
                            result = nextPoint + removedRatio * endToStartDirXZ;
                            result[1] = prevPoint[1] + (1 - removedRatio) * (nextPoint[1] - prevPoint[1]);
                        }
                        else        // 3D mode
                        {
                            endToStartDir.Normalize(); // "variable reuse"
                            result = nextPoint + endToStartDir * Math3D.IntersectionRaySphere(nextPoint, endToStartDir, m_vCurrentPosition, distance);
                        }
 
                        if (!doNotMove)
                        {
                            m_vCurrentPosition = result;
                            m_vCurrentDirection = vector.Direction(prevPoint, nextPoint).Normalized(); // TODO: on vertices
                            m_iCurrentSectionIndex = currentSectionIndex;
                            m_iCurrentSectionPointIndex = pointIndex - 1;
//                          m_fDoneLength += addedLength + vector.Distance(prevPoint, result);
 
                            m_iCurrentSegmentIndex = CalculateCurrentSegmentIndex();
                            m_fDoneLength = CalculateDoneLength();
                        }
 
                        return true;
                    }
//              }
//              else // in shape's length
//              {
//                  if (addedLength + sectionSegmentsLength[pointIndex] > distance)
//                  {
//                      float remainder = distance - addedLength;
//                      vector prevToNextDirNormalised = vector.Direction(prevPoint, nextPoint).Normalized();
//                      result = prevPoint + prevToNextDirNormalised * remainder;
//
//                      if (!doNotMove)
//                      {
//                          m_vCurrentPosition = result;
//                          m_iCurrentSectionIndex = currentSectionIndex;
//                          m_iCurrentSectionPointIndex = pointIndex - 1;
//                          m_fDoneLength += distance;
//                      }
//
//                      return true;
//                  }
//              }
 
//              addedLength += sectionSegmentsLength[pointIndex];
                prevPoint = nextPoint;
            }
 
            currentSectionPoint = 1; // because end point of previous section = first point of next section
        }
 
        return false; // shape end
    }
 
    //------------------------------------------------------------------------------------------------
    protected float GetShapeDistanceToNextAnchor()
    {
        float result = vector.Distance(m_vCurrentPosition, m_aSegments[m_iCurrentSegmentIndex][1]);
        if (result == 0)
            return 0;
 
        array<vector> segment;
        for (int i = m_iCurrentSegmentIndex + 1; i < m_iSegmentsCount; i++)
        {
            segment = m_aSegments[i];
            result += vector.Distance(segment[0], segment[1]);
            if (m_aAnchorPoints.Contains(segment[1]))
                return result;
        }
//TODO
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    float GetStraightDistanceToNextAnchor()
    {
        if (m_iCurrentSectionIndex + 1 >= m_iAnchorPointsCount)
            return vector.Distance(m_vCurrentPosition, m_aAnchorPoints[m_iAnchorPointsCount - 1]);
        else
            return vector.Distance(m_vCurrentPosition, m_aAnchorPoints[m_iCurrentSectionIndex + 1]);
    }
 
    //------------------------------------------------------------------------------------------------
    bool SetOnAnchor(int anchorIndex)
    {
        if (anchorIndex < 0 || anchorIndex >= m_iAnchorPointsCount)
            return false;
 
        m_vCurrentPosition = m_aAnchorPoints[anchorIndex];
 
        vector prevPoint;
        vector nextPoint;
        if (anchorIndex == 0)                                   // start
        {
            m_vCurrentDirection = vector.Direction(m_aSegments[0][0], m_aSegments[0][1]).Normalized();
        }
        else if (anchorIndex == m_iAnchorPointsCount - 1)       // end
        {
            m_vCurrentDirection = vector.Direction(m_aSegments[m_iSegmentsCount - 1][0], m_aSegments[m_iSegmentsCount - 1][1]).Normalized();
        }
        else                                                    // middle
        {
            // just a direction of prevNorm to nextNorm, not accurate - TODO: fix
            m_vCurrentDirection = vector.Direction(
                vector.Direction(m_vCurrentPosition, m_aAnchorPoints[anchorIndex - 1]).Normalized(),
                vector.Direction(m_vCurrentPosition, m_aAnchorPoints[anchorIndex + 1]).Normalized()
            ).Normalized();
        }
 
        m_iCurrentSectionIndex = anchorIndex;
        m_iCurrentSectionPointIndex = 0;
 
        m_iCurrentSegmentIndex = CalculateCurrentSegmentIndex();
        m_fDoneLength = CalculateDoneLength();
 
        return true;
    }
 
//  //------------------------------------------------------------------------------------------------
//  //! Sets to the provided position IF on the shape
//  //! \param[in] position the wanted (relative) position
//  //! \return true on success, false on failure
//  bool SetPos(vector position)
//  {
//      foreach (int segmentIndex, array<vector> segment : m_aSegments)
//      {
//          if (
//              (segmentIndex == m_iSegmentsCount - 1 || position != segment[1]) &&             // on start point, not on end
//              Math3D.PointLineSegmentDistanceSqr(position, segment[0], segment[1]) < 0.001)   // on segment
//          {
//              m_vCurrentPosition = position;
//              m_iCurrentSegmentIndex = segmentIndex;
//              return true;
//          }
//      }
//
//      return false;
//  }
 
    //------------------------------------------------------------------------------------------------
    bool IsValid()
    {
        return m_iAnchorPointsCount > 1 && m_fTotalLength > 0;
    }
 
    //------------------------------------------------------------------------------------------------
    void Reset()
    {
        if (m_iAnchorPointsCount > 0)
            SetOnAnchor(0);
    }
 
    //--- constructors
 
    //------------------------------------------------------------------------------------------------
    static SCR_ShapeNextPointHelper CreateFromPoints(notnull array<vector> anchorPoints, notnull array<vector> tesselatedPoints)
    {
        int anchorPointsCount = anchorPoints.Count();
        if (anchorPointsCount < 2)
            return null;
 
        int tesselatedPointsCount = tesselatedPoints.Count();
        if (tesselatedPointsCount < anchorPointsCount)
            return null;
 
        // must have same first and last points
        if (anchorPoints[0] != tesselatedPoints[0])
            return null;
 
//      if (anchorPoints[anchorPointsCount - 1] != tesselatedPoints[tesselatedPointsCount - 1])
//          return null;
 
        int anchorIndex;
        vector anchorPos = anchorPoints[anchorIndex];
        foreach (vector tesselatedPoint : tesselatedPoints)
        {
            if (anchorIndex >= anchorPointsCount) // found too many matches
                break;  // wrong detection
 
            if (tesselatedPoint == anchorPoints[anchorIndex])
            {
                ++anchorIndex; // must break after the first point
                if (anchorIndex < anchorPointsCount)
                    anchorPos = anchorPoints[anchorIndex];
            }
        }
 
        if (anchorIndex != anchorPointsCount) // did not find all points
            return null;
 
        // everything OK? let's go
 
        SCR_ShapeNextPointHelper result = new SCR_ShapeNextPointHelper();
 
        result.m_aAnchorPoints = SCR_ArrayHelperT<vector>.GetCopy(anchorPoints);
        result.m_aAnchorPointIndices = {};
        result.m_aTesselatedPoints = SCR_ArrayHelperT<vector>.GetCopy(tesselatedPoints);
        result.m_aSections = {};
//      m_aSectionLengths = {};
        array<vector> anchorSection;
        array<float> sectionSegmentLengths;
        result.m_aSegments = {};
        anchorIndex = 0;
        vector nextAnchor = result.m_aAnchorPoints[anchorIndex];
 
        vector prevPoint;
        foreach (int i, vector currPoint : result.m_aTesselatedPoints)
        {
            float segmentLength = vector.Distance(currPoint, prevPoint);
 
            if (i > 0)                                      // normal point or anchor point
            {
                anchorSection.Insert(currPoint);
                sectionSegmentLengths.Insert(segmentLength);
                result.m_aSegments.Insert({ prevPoint, currPoint });
            }
 
            if (currPoint == nextAnchor)                    // anchor point (including first and last ones)
            {
                result.m_aAnchorPointIndices.Insert(i);
                if (i > 0)                                  // everything but the first point
                {
                    result.m_aSections.Insert(anchorSection);
                    sectionSegmentLengths.Insert(segmentLength);
//                  m_aSectionLengths.Insert(sectionSegmentLengths);
                }
 
                anchorSection = { currPoint };
                sectionSegmentLengths = {};
 
                ++anchorIndex; // if last point, foreach ends and m_aAnchorPoints[maxIndex + 1] never occurs
                if (anchorIndex >= anchorPointsCount)
                    anchorIndex = 0;
 
                nextAnchor = result.m_aAnchorPoints[anchorIndex];
            }
 
            result.m_fTotalLength += segmentLength;
 
            prevPoint = currPoint;
        }
 
        result.m_iAnchorPointsCount = anchorPointsCount;
//      result.m_iTesselatedPointsCount = tesselatedPointsCount;
        result.m_iSegmentsCount = tesselatedPointsCount - 1;
 
        result.SetOnAnchor(0); // sets m_vCurrentPosition & m_vCurrentDirection
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static SCR_ShapeNextPointHelper CreateFromShape(notnull ShapeEntity shapeEntity, bool reverse = false)
    {
        array<vector> anchorPoints = {};
        array<vector> tesselatedPoints = {};
 
        shapeEntity.GetPointsPositions(anchorPoints);
        shapeEntity.GenerateTesselatedShape(tesselatedPoints);
 
        bool isShapeClosed = shapeEntity.IsClosed();
 
#ifdef WORKBENCH
        WorldEditorAPI worldEditorAPI = ((WorldEditor)Workbench.GetModule(WorldEditor)).GetApi();
        if (worldEditorAPI)
        {
            IEntitySource shapeEntitySource = worldEditorAPI.EntityToSource(shapeEntity);
            if (shapeEntitySource)
                shapeEntitySource.Get("IsClosed", isShapeClosed);
        }
#endif // WORKBENCH
 
        if (isShapeClosed)
        {
            anchorPoints.Insert(anchorPoints[0]);
            if (!SplineShapeEntity.Cast(shapeEntity)) // spline already has the first tesselated point as last point
                tesselatedPoints.Insert(tesselatedPoints[0]);
        }
 
        if (reverse)
        {
            SCR_ArrayHelperT<vector>.Reverse(anchorPoints);
            SCR_ArrayHelperT<vector>.Reverse(tesselatedPoints);
        }
 
        return CreateFromPoints(anchorPoints, tesselatedPoints);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void SCR_ShapeNextPointHelper();
}