1

我一直在与一个软件工程课程的团队一起工作，我们认为使用视差滚动将有助于我们的游戏看起来非常好，但我们不确定我们的实现想法是否正确，所以我希望有人会给我们一些关于我们计划的指导。

首先，我们有三个类，Level，Tileset，Layer，第一个有Layers和Tilesets两个vector，所以我们的想法是把第一层的一个TMX文件中的所有数据加载到一个vector>中，但是我们只画了地图的一部分，它当前在相机中，所以在一个循环中我们绘制每一层，但我们不确定如何为每一层定义一个速度，所以视差滚动就像它应该的那样工作。

PD：如果有人需要更多信息，请不要怀疑。

4

2 回答 2

1

抱歉回复晚了。我已经发现了问题，我留下了新代码，所以也许有人会觉得这很有用。问题是在瓦片地图的每一行中处理不同的偏移量，但现在它已经解决了。

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 );
}
于 2011-10-09T19:13:33.200 回答
0

您是否正在实现一个 2D 横向滚动游戏，其中几个背景层应该以一种能够产生适当深度印象的方式移动？

如果是这样，一种方法可能是为每一层定义与观察者的距离。选择一个足够远的参考点来模拟它的无限距离，并通过图层计算视图矢量与该点的交点。当查看器移动时，对新的查看器位置执行相同的操作。使用旧参考向量和新参考向量的交点之间的距离来确定层的速度。

一个更简单的方法是只使用一些控件来调整滚动速度（或调整前层的滚动速度和其他层的速度比例）并玩弄它直到你认为它看起来不错。

于 2011-09-03T22:19:08.093 回答