Место считывания нарушения доступа с использованием двумерного массива, сопоставленного с 1D

Question

Я пытаюсь проверить наличие соседей в массиве и без проверки границ, программа выдаст исключение. Мне нужно проверить, по крайней мере, bottomLeft, bottomRight, topLeft topRight углы. Я работаю в DirectXTDK, и эта функция предназначена для сглаживания ландшафта.

bool Terrain::SmoothenHeightMap(ID3D11Device* device)
{
    bool result;

    int index, nx, nz;
    float height = 0.0;
    int neighbours[8] = {}; // array starts at 0, inclusive
    int n = 8;

    /* Initialise corner of height map */ // 1.
    int bottomLeftCorner = 0;
    int bottomRightCorner = (m_terrainHeight * (m_terrainHeight - 1));
    int topLeftCorner = (m_terrainWidth - 1);
    int topRightCorner = m_terrainHeight * (m_terrainHeight - 1) + (m_terrainWidth - 1);

    m_frequency = (6.283 / m_terrainHeight) / m_wavelength; //we want a wavelength of 1 to be a single wave over the whole terrain.  A single wave is 2 pi which is about 6.283
    // m_terrainHeight is actually the z axis

    for (int j = 0; j < m_terrainHeight; j++)
    {
        for (int i = 0; i < m_terrainWidth; i++)
        {
            index = (m_terrainHeight * j) + i; 

            float sum = m_heightMap[index].y;

            // with more than 128 square dimensions, initial neighbours on bottom row might not exist
            // can refractor this better if it works

            if (m_heightMap[(m_terrainHeight * (j - 1)) + (i - 1)].x != NULL) {
                neighbours[0] = m_heightMap[(m_terrainHeight * (j + 1)) + (i - 1)].y; // top left
                neighbours[1] = m_heightMap[(m_terrainHeight * (j + 1)) + (i)].y;     // top middle
                neighbours[2] = m_heightMap[(m_terrainHeight * (j + 1)) + (i + 1)].y; // top right
                neighbours[3] = m_heightMap[(m_terrainHeight * (j)) + (i - 1)].y;     // middle left
                neighbours[4] = m_heightMap[(m_terrainHeight * (j)) + (i + 1)].y;     // middle right
                neighbours[5] = m_heightMap[(m_terrainHeight * (j - 1)) + (i - 1)].y; // bottom left
                neighbours[6] = m_heightMap[(m_terrainHeight * (j - 1)) + (i)].y;     // bottom middle
                neighbours[7] = m_heightMap[(m_terrainHeight * (j - 1)) + (i + 1)].y; // bottom right
            }




            for (int z = 0; z < n; z++)
            {
                if (neighbours[z] < 0 || neighbours[z] >= m_terrainHeight * m_terrainWidth) // if out of map, take y of current index for sum
                {
                    sum += m_heightMap[index].y;
                }
                else
                {
                    sum += neighbours[z]; // if exists, include in sum
                }
            }

            // smoothen based on neighbours
            m_heightMap[index].y = sum / 9.0f; // current point n is no. of neighbours +1 for current vertex point// total of 9 points in a 3*3 grid
        }
    }


    result = CalculateNormals();
    if (!result)
    {
        return false;
    }

    result = InitializeBuffers(device);
    if (!result)
    {
        return false;
    }
}

Указанный код используется для сглаживания ландшафта с использованием карты высот до go через точки, которые хранятся в структурах. Ниже приведена структура:

struct HeightMapType
    {
        float x, y, z;
        float nx, ny, nz;
        float u, v;
    };

, которая используется путем создания указателя на нее с именем m_heightmap.

HeightMapType* m_heightMap;

Answer 1

Мне удалось решить эту проблему путем проверки углов следующим образом:

if (m_heightMap[index].z + 1 >= m_terrainHeight || m_heightMap[index].z <= 0) {
                // if no neighbours, set height to that of current index/element
                neighbours[0], neighbours [1], neighbours[2] = m_heightMap[index].y;
                }
            else {
                neighbours[0] = m_heightMap[(m_terrainHeight * (j + 1)) + (i - 1)].y; // top left
                neighbours[1] = m_heightMap[(m_terrainHeight * (j + 1)) + (i)].y;     // top middle
                neighbours[2] = m_heightMap[(m_terrainHeight * (j + 1)) + (i + 1)].y; // top right
            }
            neighbours[3] = m_heightMap[(m_terrainHeight * (j)) + (i - 1)].y;     // middle left
            neighbours[4] = m_heightMap[(m_terrainHeight * (j)) + (i + 1)].y;     // middle right
            if (m_heightMap[index].z <= 0 || m_heightMap[index].z + 1 >= m_terrainHeight) {
                // if no neighbours, set height to that of current index/element
                neighbours[5], neighbours[6], neighbours[7] = m_heightMap[index].y;
            }
            else {
                neighbours[5] = m_heightMap[(m_terrainHeight * (j - 1)) + (i - 1)].y; // bottom left
                neighbours[6] = m_heightMap[(m_terrainHeight * (j - 1)) + (i)].y;     // bottom middle
                neighbours[7] = m_heightMap[(m_terrainHeight * (j - 1)) + (i + 1)].y; // bottom right
            }

Answer 2

Поскольку у меня нет всего блока кода, я могу рассказать вам о возможном способе обнаружения ошибки.

Как я вижу на скриншоте, строка ошибки не может найти значения или местоположения связанный с массивом. Я рекомендую вам отлаживать код и переходить каждый раз для l oop, чтобы получить значения при выполнении m_terrainHeight * (j-1) + (i-1). Возможно, приведенное выше выражение оценивается как неожиданное значение.

Повторите один и тот же построчный процесс выполнения для всех выделений и выполнений, чтобы проверить, получаете ли вы ожидаемые значения.

Пожалуйста, поделитесь всем блоком кода для лучшего понимания выпуск.