Вопрос о реализации параллакс-скроллинга в C ++ / SDL / OpenGL - PullRequest
Новая
       18

Вопрос о реализации параллакс-скроллинга в C ++ / SDL / OpenGL

1 голос
/ 04 сентября 2011

Я работал в проекте с командой для класса Software Engineering, и мы думаем, что использование прокрутки параллакса поможет нашей игре выглядеть действительно красиво, но мы не совсем уверены, является ли наша идея для реализации правильной, поэтомуЯ надеюсь, что кто-то даст нам некоторое руководство по нашему плану.

Во-первых, у нас есть три класса, Level, Tileset, Layer, у первого есть два вектора Layers и Tilesets, поэтому наша идея - загрузить вседанные из файла TMX первого уровня в векторе>, но мы рисуем только ту часть карты, которая в данный момент находится в камере, поэтому внутри цикла мы рисуем каждый слой, но мы не уверены, как определить скорость для каждогослой, так что прокрутка параллакса работает, как и предполагалось.

PD: Если кому-то нужна дополнительная информация, не сомневайтесь в вопросе.

Ответы [ 2 ]

1 голос
/ 09 октября 2011

Извините за поздний ответ.Я уже выяснил проблему, я оставляю новый код, так что, возможно, кто-то найдет это полезным.Проблема заключалась в обработке разного смещения в каждой строке карты тайлов, но теперь она решена. 

void Tilemap::drawTilemap(int indexTileset)
{
    GLfloat offsetXTemp = offset.x;

    offsetXTemp = transformOffsetXToIntervalValues(offset.x);

    GLfloat variableSizeTile = 32.f;

    GLfloat widthTilesetImage = tilesetList.at(indexTileset).getWidthImage();
    GLfloat heightTilesetImage = tilesetList.at(indexTileset).getHeightImage();

    int widthMap = (1280 / (int)sizeTiles) + 1;
    int heigthMap = (int) ceil( 720.0f / sizeTiles );

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glEnableClientState( GL_VERTEX_ARRAY );
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );  

    glBindTexture( GL_TEXTURE_2D, tilesetList.at(indexTileset).getTexture() );

    GLfloat posXPrevious = 0.0f, posXPreviousOnTexture = 0.0f;

    for (int i = 0; i < heigthMap; i++)
    {
        int startX = (int)floor(offset.x/sizeTiles);
        posXPrevious = 0.0f;

        posXPrevious -= offsetXTemp;
        variableSizeTile = 32.f;

        for (int j = 0; j < widthMap; j++) 
        {
            if ( startX == widthLevelInTiles )
            {
                break;
            }

            int frameIndex = layerMap[i][startX].getID();

            if ( frameIndex == 0 )
            { 
                startX++;
                variableSizeTile = 32.f;
                posXPrevious = posXPrevious + variableSizeTile;

                continue; 
            }

            if ( j == 0 && offsetXTemp != sizeTiles)
            {
                posXPreviousOnTexture = offsetXTemp/widthTilesetImage;
                variableSizeTile -= offsetXTemp;
                posXPrevious = 0.0f;
            }

            else 
            { 
                variableSizeTile = 32.f; 
                posXPreviousOnTexture = 0.0f;
            }

            if ( j == 40 )
            {
                variableSizeTile = offsetXTemp;
            }

            frameIndex -= 1;

            const GLfloat tileX = posXPrevious;
            const GLfloat tileY = sizeTiles * i;
            posXPrevious = tileX + variableSizeTile;

            const GLfloat verts[] = {
                    tileX, tileY,
                    tileX + variableSizeTile, tileY,
                    tileX + variableSizeTile, tileY + sizeTiles,
                    tileX, tileY + sizeTiles
            };

            const GLfloat textureWidth = variableSizeTile / (GLfloat)widthTilesetImage;
            const GLfloat textureHeight = sizeTiles / (GLfloat)heightTilesetImage;
            const int numFramePerRow = (int)widthTilesetImage / (int)sizeTiles;
            const GLfloat textureX = ( (frameIndex % numFramePerRow) * sizeTiles/(GLfloat)widthTilesetImage ) 
                                    + posXPreviousOnTexture;
            const GLfloat textureY = ( frameIndex / numFramePerRow ) * textureHeight;

            const GLfloat texVerts[] = {
                    textureX, textureY,
                    textureX + textureWidth, textureY,
                    textureX + textureWidth, textureY + textureHeight,
                    textureX, textureY + textureHeight
            };

            glVertexPointer(2, GL_FLOAT, 0, verts);
            glTexCoordPointer(2, GL_FLOAT, 0, texVerts);
            glDrawArrays(GL_QUADS, 0, 4);

            startX++;
        }   
    }

    glDisableClientState( GL_VERTEX_ARRAY );            
    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
}
0 голосов
/ 04 сентября 2011

Реализуете ли вы 2D-игру с боковой прокруткой, в которой несколько слоев фона должны перемещаться так, чтобы создать надлежащее впечатление глубины?

Если это так, одним из подходов может быть определение расстояния от зрителя для каждого слоя. Выберите опорную точку, которая достаточно далеко, чтобы смоделировать для нее бесконечное расстояние, и вычислите пересечения вектора вида с этой точкой через ваши слои. Когда зритель перемещается, сделайте то же самое для новой позиции зрителя. Используйте расстояние между пересечениями старого и нового опорных векторов, чтобы определить скорость слоев.

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

...