Оптимизация простого движка 2D-плиток (+ потенциальное исправление)

Предисловие

Да, здесь есть, что рассказать … но я сделаю все возможное, чтобы это было как можно лучше организовано, информативно и прямо к делу!

С использованием Библиотека HGE в C ++ я создал простой движок плиток.
И до сих пор я реализовал следующие проекты:

• CTile класс, представляющий одну плитку в пределах CTileLayer, содержащий информацию о строке / столбце, а также HGE::hgeQuad (который хранит информацию о вершине, цвете и текстуре, посмотреть здесь для деталей).
• CTileLayer класс, представляющий двумерную «плоскость» плиток (которые хранятся в виде одномерного массива CTile объекты), содержащий количество строк / столбцов, информацию о мировых координатах X / Y, информацию о ширине / высоте пикселя плитки и общую ширину / высоту слоя в пикселях.

CTileLayer отвечает за рендеринг любых плиток, которые полностью или частично видны в границах «окна просмотра» виртуальной камеры, и за то, чтобы не делать это для любых плиток, находящихся за пределами этого видимого диапазона. После создания он предварительно рассчитывает всю информацию, которая будет сохранена в каждом CTile объект, так что ядро ​​движка имеет больше места для дыхания и может сосредоточиться строго на цикле рендеринга. Конечно, он также обрабатывает правильное освобождение каждой содержащейся плитки.

вопросы

Проблема, с которой я сейчас сталкиваюсь, сводится к следующим проблемам архитектуры / оптимизации:

1. В моем цикле рендеринга, несмотря на то, что я не рендерил плитки, находящиеся за пределами видимого диапазона, я все еще перекручивание через все плитки, что, по-видимому, оказывает существенное влияние на производительность для больших карт листов (т. е. любая вещь размером более 100×100 строк / столбцов при размерах плитки 64×64 по-прежнему снижает частоту кадров на 50% и более).
2. В конце концов, я намереваюсь создать необычный редактор тайлкарт, который будет совпадать с этим движком.
   Тем не менее, поскольку я храню всю двумерную информацию в одном или нескольких одномерных массивах, я понятия не имею, насколько возможно было бы реализовать какую-то функцию прямоугольного выбора. & функция копирования / вставки, без некоторых ОСНОВНОЙ снижение производительности — вовлечение циклов по каждой клетке дважды за кадр. И все же, если бы я использовал 2D-массивы, было бы чуть меньше, но более универсальное падение FPS!

ошибка

Как уже говорилось ранее … В моем коде рендеринга для CTileLayer объект, я оптимизировал, какие плитки должны быть нарисованы на основе того, находятся ли они в пределах диапазона просмотра. Это прекрасно работает, и для больших карт я заметил падение только на 3-8 FPS (по сравнению с падением на 100+ FPS без этой оптимизации).

Но я думаю, что я рассчитываю этот диапазон неправильно, потому что после прокрутки на полпути по карте вы можете начать видеть пробел (на самом верху & крайние левые стороны), где плитки не отображаются, как будто диапазон отсечения увеличивается быстрее, чем камера может двигаться (даже если они обе перемещаются с одинаковой скоростью).

Этот промежуток постепенно увеличивается в размере по мере продвижения в X & Ось Y вы идете, в конечном итоге съедая почти половину вершины & левые стороны экрана на большой карте.
Мой код рендеринга для этого показан ниже …

Код

//
// [Allocate]
// For pre-calculating tile information
// - Rows/Columns   = Map Dimensions (in tiles)
// - Width/Height   = Tile Dimensions (in pixels)
//
void CTileLayer::Allocate(UINT numColumns, UINT numRows, float tileWidth, float tileHeight)
{
m_nColumns = numColumns;
m_nRows = numRows;

float x, y;
UINT column = 0, row = 0;
const ULONG nTiles = m_nColumns * m_nRows;
hgeQuad quad;

m_tileWidth = tileWidth;
m_tileHeight = tileHeight;
m_layerWidth = m_tileWidth * m_nColumns;
m_layerHeight = m_tileHeight * m_nRows;

if(m_tiles != NULL) Free();
m_tiles = new CTile[nTiles];

for(ULONG l = 0; l < nTiles; l++)
{
m_tiles[l] = CTile();
m_tiles[l].column = column;
m_tiles[l].row = row;
x = (float(column) * m_tileWidth) + m_offsetX;
y = (float(row) * m_tileHeight) + m_offsetY;

quad.blend = BLEND_ALPHAADD | BLEND_COLORMUL | BLEND_ZWRITE;
quad.tex = HTEXTURE(nullptr); //Replaced for the sake of brevity (in the engine's code, I used a globally allocated texture array and did some random tile generation here)

for(UINT i = 0; i < 4; i++)
{
quad.v[i].z = 0.5f;
quad.v[i].col = 0xFF7F7F7F;
}
quad.v[0].x = x;
quad.v[0].y = y;
quad.v[0].tx = 0;
quad.v[0].ty = 0;
quad.v[1].x = x + m_tileWidth;
quad.v[1].y = y;
quad.v[1].tx = 1.0;
quad.v[1].ty = 0;
quad.v[2].x = x + m_tileWidth;
quad.v[2].y = y + m_tileHeight;
quad.v[2].tx = 1.0;
quad.v[2].ty = 1.0;
quad.v[3].x = x;
quad.v[3].y = y + m_tileHeight;
quad.v[3].tx = 0;
quad.v[3].ty = 1.0;
memcpy(&m_tiles[l].quad, &quad, sizeof(hgeQuad));

if(++column > m_nColumns - 1) {
column = 0;
row++;
}
}
}

//
// [Render]
// For drawing the entire tile layer
// - X/Y          = world position
// - Top/Left     = screen 'clipping' position
// - Width/Height = screen 'clipping' dimensions
//
bool CTileLayer::Render(HGE* hge, float cameraX, float cameraY, float cameraTop, float cameraLeft, float cameraWidth, float cameraHeight)
{
// Calculate the current number of tiles
const ULONG nTiles = m_nColumns * m_nRows;

// Calculate min & max X/Y world pixel coordinates
const float scalarX = cameraX / m_layerWidth;  // This is how far (from 0 to 1, in world coordinates) along the X-axis we are within the layer
const float scalarY = cameraY / m_layerHeight; // This is how far (from 0 to 1, in world coordinates) along the Y-axis we are within the layer
const float minX = cameraTop + (scalarX * float(m_nColumns) - m_tileWidth); // Leftmost pixel coordinate within the world
const float minY = cameraLeft + (scalarY * float(m_nRows) - m_tileHeight);  // Topmost pixel coordinate within the world
const float maxX = minX + cameraWidth + m_tileWidth;                        // Rightmost pixel coordinate within the world
const float maxY = minY + cameraHeight + m_tileHeight;                      // Bottommost pixel coordinate within the world

// Loop through all tiles in the map
for(ULONG l = 0; l < nTiles; l++)
{
CTile tile = m_tiles[l];
// Calculate this tile's X/Y world pixel coordinates
float tileX = (float(tile.column) * m_tileWidth) - cameraX;
float tileY = (float(tile.row) * m_tileHeight) - cameraY;

// Check if this tile is within the boundaries of the current camera view
if(tileX > minX && tileY > minY && tileX < maxX && tileY < maxY) {
// It is, so draw it!
hge->Gfx_RenderQuad(&tile.quad, -cameraX, -cameraY);
}
}

return false;
}

//
// [Free]
// Gee, I wonder what this does? lol...
//
void CTileLayer::Free()
{
delete [] m_tiles;
m_tiles = NULL;
}

1. Что можно сделать, чтобы исправить эти архитектурные проблемы / проблемы оптимизации, не оказывая значительного влияния на другие оптимизации рендеринга?
2. Почему эта ошибка происходит? Как это можно исправить?

Спасибо за ваше время!