Method computeOverlappingTriangles

src/collision/HeightField.cpp:139–216

Test collision with the triangles of the height field shape. The idea is to use the AABB of the body when need to test and see against which triangles of the height-field we need to test for collision. We compute the sub-grid points that are inside the other body's AABB and then for each rectangle in the sub-grid we generate two triangles that we use to test collision.

// to test for collision. We compute the sub-grid points that are inside the other body's AABB
// and then for each rectangle in the sub-grid we generate two triangles that we use to test collision.
void HeightField::computeOverlappingTriangles(const AABB& aabb, Array<Vector3>& triangleVertices,
                                              Array<Vector3>& triangleVerticesNormals,
                                              Array<uint32>& shapeIds, const Vector3& scale) const {

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

    // Compute the integer grid coordinates inside the area we need to test for collision
    uint32 minGridCoords[3];
    uint32 maxGridCoords[3];
    computeMinMaxGridCoordinates(minGridCoords, maxGridCoords, aabb);

    // Compute the starting and ending coords of the sub-grid according to the up axis
    uint32 iMin = clamp(minGridCoords[0], 0, mNbColumns - 1);
    uint32 iMax = clamp(maxGridCoords[0], 0, mNbColumns - 1);
    uint32 jMin = clamp(minGridCoords[2], 0, mNbRows - 1);
    uint32 jMax = clamp(maxGridCoords[2], 0, mNbRows - 1);

   assert(iMin < mNbColumns);
   assert(iMax < mNbColumns);
   assert(jMin < mNbRows);
   assert(jMax < mNbRows);

   // For each sub-grid points (except the last ones one each dimension)
   for (uint32 i = iMin; i < iMax; i++) {
       for (uint32 j = jMin; j < jMax; j++) {

           // 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;

           // Generate the first triangle for the current grid rectangle
           triangleVertices.add(p1);
           triangleVertices.add(p2);
           triangleVertices.add(p3);

           // Compute the triangle normal
           Vector3 triangle1Normal = (p2 - p1).cross(p3 - p1).getUnit();

           // Use the triangle face normal as vertices normals (this is an aproximation. The correct
           // solution would be to compute all the normals of the neighbor triangles and use their
           // weighted average (with incident angle as weight) at the vertices. However, this solution
           // seems too expensive (it requires to compute the normal of all neighbor triangles instead
           // and compute the angle of incident edges with asin(). Maybe we could also precompute the
           // vertices normal at the HeightFieldShape constructor but it will require extra memory to
           // store them.
           triangleVerticesNormals.add(triangle1Normal);
           triangleVerticesNormals.add(triangle1Normal);
           triangleVerticesNormals.add(triangle1Normal);

           // Compute the shape ID
           shapeIds.add(computeTriangleShapeId(i, j, 0));

           // Generate the second triangle for the current grid rectangle
           triangleVertices.add(p3);
           triangleVertices.add(p2);
           triangleVertices.add(p4);