Method raycast

src/collision/HeightField.cpp:258–320

Raycast method with feedback information Note that only the first triangle hit by the ray in the mesh will be returned, even if the ray hits many triangles.

/// Note that only the first triangle hit by the ray in the mesh will be returned, even if
/// the ray hits many triangles.
bool HeightField::raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, TriangleRaycastSide testSide,
                          MemoryAllocator& allocator, const Vector3& scale) const {

    RP3D_PROFILE("HeightField::raycast()", mProfiler);

    bool isHit = false;

    // Compute the grid coordinates where the ray is entering the AABB of the height field
    int32 i, j;
    Vector3 outHitGridPoint;
    if (computeEnteringRayGridCoordinates(ray, i, j, outHitGridPoint)) {

        const int32 nbCellsI = mNbColumns - 1;
        const int32 nbCellsJ = mNbRows - 1;

        const Vector3 aabbSize = mBounds.getExtent();

        const Vector3 rayDirection = ray.point2 - ray.point1;

        int32 stepI = rayDirection.x > 0 ? 1 : (rayDirection.x < 0 ? -1 : 0);
        int32 stepJ = rayDirection.z > 0 ? 1 : (rayDirection.z < 0 ? -1 : 0);
        decimal nextI = static_cast<decimal>(stepI >= 0 ? i + 1 : i);
        decimal nextJ = static_cast<decimal>(stepJ >= 0 ? j + 1 : j);
        decimal sizeI = aabbSize.x / nbCellsI;
        decimal sizeJ = aabbSize.z / nbCellsJ;
        decimal tMaxI = ((nextI * sizeI) - outHitGridPoint.x) / rayDirection.x;
        decimal tMaxJ = ((nextJ * sizeJ) - outHitGridPoint.z) / rayDirection.z;
        decimal tDeltaI = sizeI / std::abs(rayDirection.x);
        decimal tDeltaJ = sizeJ / std::abs(rayDirection.z);

        decimal smallestHitFraction = ray.maxFraction;

        while (i >= 0 && i < nbCellsI && j >= 0 && j < nbCellsJ) {

           // Compute the four point of the current quad
           const Vector3 p1 = getVertexAt(i, j) * scale;
           const Vector3 p2 = getVertexAt(i, j + 1) * scale;
           const Vector3 p3 = getVertexAt(i + 1, j) * scale;
           const Vector3 p4 = getVertexAt(i + 1, j + 1) * scale;

           // Raycast against the first triangle of the cell
           uint32 shapeId = computeTriangleShapeId(i, j, 0);
           isHit |= raycastTriangle(ray, p1, p2, p3, shapeId, collider, raycastInfo, smallestHitFraction, testSide, allocator);

           // Raycast against the second triangle of the cell
           shapeId = computeTriangleShapeId(i, j, 1);
           isHit |= raycastTriangle(ray, p3, p2, p4, shapeId, collider, raycastInfo, smallestHitFraction, testSide, allocator);

           if (stepI == 0 && stepJ == 0) break;

           if (tMaxI < tMaxJ) {
                tMaxI += tDeltaI;
                i += stepI;
            }
            else {
                tMaxJ += tDeltaJ;
                j += stepJ;
            }