Function GetGridCellVertices

engine/physics/src/physics/box2d/box2d_physics.cpp:1022–1094

    }

    static int GetGridCellVertices(GridShapeData* shape_data, int index, b2Vec2* vertices)
    {
        // Original code checked if the shape was enabled, but I'm not sure we can do that now.
        // The grid has only a single body that holds sub-shapes for all grid polygons,
        // so we would have to perhaps keep track of this in the grid shape data to avoid
        // going deeper into this function.
        //
        // if (!b2Body_IsEnabled(shape_data->m_CellBodyId))
        // {
        //     return 0;
        // }

        const GridShapeData::Cell& cell = shape_data->m_Cells[index];
        if (cell.m_Index == B2GRIDSHAPE_EMPTY_CELL)
        {
            return 0;
        }

        const HullSet::Hull& hull = shape_data->m_HullSet->m_Hulls[cell.m_Index];
        assert(hull.m_Count <= B2_MAX_POLYGON_VERTICES);

        int row = index / shape_data->m_ColumnCount;
        int col = index - (shape_data->m_ColumnCount * row);

        float halfWidth = shape_data->m_CellWidth * shape_data->m_ColumnCount * 0.5f;
        float halfHeight = shape_data->m_CellHeight * shape_data->m_RowCount * 0.5f;

        b2Vec2 t = {shape_data->m_CellWidth * col - halfWidth, shape_data->m_CellHeight * row - halfHeight};
        t.x += shape_data->m_CellWidth * 0.5f;
        t.y += shape_data->m_CellHeight * 0.5f;
        t += shape_data->m_Position;

        const HullFlags& flags = shape_data->m_CellFlags[index];
        float xScale = flags.m_FlipHorizontal ? -1.0f : 1.0f;
        float yScale = flags.m_FlipVertical ? -1.0f : 1.0f;
        float tmpX = 0.0;

        for (uint32_t i = 0; i < hull.m_Count; ++i)
        {
            vertices[i] = shape_data->m_HullSet->m_Vertices[hull.m_Index + i];
            if (flags.m_Rotate90)
            {
                // Clockwise rotation (x, y) -> (y, -x)
                // Also tile isn't necessary a square, that's why we should swap width and height
                // We apply flip before rotation, which means scale is part of size and should be swapped as well
                tmpX = vertices[i].x;
                vertices[i].x = vertices[i].y * (yScale * shape_data->m_CellWidth);
                vertices[i].y = -1 * tmpX * (xScale * shape_data->m_CellHeight);
            }
            else
            {
                vertices[i].x *= xScale * shape_data->m_CellWidth;
                vertices[i].y *= yScale * shape_data->m_CellHeight;
            }
            vertices[i] += t;
        }

        // Reverse order when single flipped