Is support to animation working on TMX lib ?

[popolony2k]

HI friends. I'm testing your excellent library since 4 days ago and I'm is a very impressive and fast library to handle TMX files.
I'm using your render samples and the raylib sample you put in your site is very useful (I tested SDL2 and RayLib).
Well, I'm trying to implement animation support and I think I managed to do something that I think is working but there's no visual effect.

Based on your raylib sample I modified the DrawLayer (refactored from you draw_layer sample) and I have added the animation support, but isn't working. The concept I thought is correct ?

Thanks in advance.

PopolonY2k

/**
 * Tile item individual information.
 */
struct __stTileItemInfo  {
    long      nMillis;
    int       nCounter;
    tmx_tile  *pNextTile;
};

void Renderer :: DrawLayer( tmx_map *pMap, tmx_layer *pLayer ) {

    unsigned int  gid;
    float         opacity;

    opacity = pLayer -> opacity;

    for( unsigned long i = 0; i < pMap -> height; i++ ) {
        for( unsigned long j = 0; j < pMap -> width; j++ ) {
            gid = ( pLayer -> content.gids[( i * pMap -> width ) + j] ) & TMX_FLIP_BITS_REMOVAL;

            if( pMap -> tiles[gid] != NULL ) {
                tmx_tileset   *pTs;
                tmx_tile      *pTile = pMap -> tiles[gid];
                tmx_image     *pIm   = pTile -> image;
                unsigned int    x    = pTile -> ul_x;
                unsigned int    y    = pTile -> ul_y;
                unsigned int    w;
                unsigned int    h;
                unsigned int    flags;
                void            *pImage;

                // Perform tile animation
                if( pTile -> animation_len )  {
                    long              nMillis;
                    timespec          ts;
                    __stTileItemInfo  *pTileInfo = NULL;

                    clock_gettime( CLOCK_REALTIME, &ts );
                    nMillis   = ( ts.tv_sec * 1000 + lround( ts.tv_nsec / 1.0e6 ) );
                    pTileInfo = ( __stTileItemInfo * ) pTile -> user_data.pointer;

                    if( !pTileInfo )  {
                        // TODO: Release memory at the end (smart pointers ???)
                        pTileInfo = new __stTileItemInfo;
                        memset( pTileInfo, 0, sizeof( __stTileItemInfo ) );
                        pTile -> user_data.pointer = pTileInfo;
                    }

                    if( nMillis > pTileInfo -> nMillis )  {
                        unsigned int nNextTileGID;

                        if( pTileInfo -> nCounter < pTile -> animation_len )  {
                            pTileInfo -> nCounter++;
                            nNextTileGID = ( pMap -> ts_head -> firstgid + pTile -> animation[pTileInfo -> nCounter].tile_id );
                        }
                        else  {
                            nNextTileGID = gid;
                            pTileInfo -> nCounter = 0;
                        }

                        printf( "TC %d \n", pTileInfo -> nCounter );
                        printf( "TID %d \n", pTile -> animation[pTileInfo -> nCounter].tile_id );
                        printf( "NGID %d \n", nNextTileGID );

                        pTileInfo -> nMillis   = ( pTile -> animation[pTileInfo -> nCounter].duration + nMillis );
                        pTileInfo -> pNextTile = pMap -> tiles[nNextTileGID];
                        pTile = pTileInfo -> pNextTile;

                        if( !pTile )
                            pTile = pMap -> tiles[gid];
                    }
                    else  {
                        pTile = ( ( __stTileItemInfo * ) pTile -> user_data.pointer ) -> pNextTile;
                    }
                }

                pTs = pTile -> tileset;
                w   = pTs -> tile_width;
                h   = pTs -> tile_height;

                if( pIm ) {
                    pImage = pIm -> resource_image;
                }
                else {
                    pImage = pTs -> image -> resource_image;
                }

                flags = ( pLayer -> content.gids[( i * pMap -> width ) + j] ) & ~TMX_FLIP_BITS_REMOVAL;
                DrawTile( pImage, x, y, w, h,
                          ( j * pTs -> tile_width ),
                          ( i * pTs -> tile_height ),
                          opacity, flags );
            }
        }
    }
}

[popolony2k]

Thanks friends by this excellent library. I finally realized the mistake I made. In fact I was not updating x, y tile position in my example.

There are some "flickerings" on image but is a initial code.

The fixed code is like below.

If you want update your example code to put this animation support, fell free to do it.

void Renderer :: DrawLayer( tmx_map *pMap, tmx_layer *pLayer ) {

    unsigned int  gid;
    float         opacity;

    opacity = pLayer -> opacity;

    for( unsigned long i = 0; i < pMap -> height; i++ ) {
        for( unsigned long j = 0; j < pMap -> width; j++ ) {
            tmx_tile      *pTile;

            gid   = ( pLayer -> content.gids[( i * pMap -> width ) + j] ) & TMX_FLIP_BITS_REMOVAL;
            pTile = pMap -> tiles[gid];

            if( pTile != NULL ) {
                tmx_image     *pIm = pTile -> image;
                tmx_tileset   *pTs;
                void          *pImage;
                unsigned int  x;
                unsigned int  y;
                unsigned int  w;
                unsigned int  h;
                unsigned int  flags;

                // Perform tile animation
                if( pTile -> animation_len )  {
                    long              nMillis;
                    timespec          ts;
                    __stTileItemInfo  *pTileInfo = NULL;

                    clock_gettime( CLOCK_REALTIME, &ts );
                    nMillis   = ( ts.tv_sec * 1000 + lround( ts.tv_nsec / 1.0e6 ) );
                    pTileInfo = ( __stTileItemInfo * ) pTile -> user_data.pointer;

                    if( !pTileInfo )  {
                        // TODO: Release memory at the end (smart pointers ???)
                        pTileInfo = new __stTileItemInfo;
                        memset( pTileInfo, 0, sizeof( __stTileItemInfo ) );
                        pTileInfo -> nMillis   = nMillis;
                        pTileInfo -> pNextTile = pTile;
                        pTile -> user_data.pointer = pTileInfo;
                    }

                    if( nMillis > pTileInfo -> nMillis )  {
                        unsigned int nNextTileGID;

                        if( pTileInfo -> nCounter < pTile -> animation_len )  {
                            pTileInfo -> nCounter++;
                            nNextTileGID = ( pMap -> ts_head -> firstgid + pTile -> animation[pTileInfo -> nCounter].tile_id );
                        }
                        else  {
                            nNextTileGID = gid;
                            pTileInfo -> nCounter = 0;
                        }

                        printf( "TC %d \n", pTileInfo -> nCounter );
                        printf( "TID %d \n", pTile -> animation[pTileInfo -> nCounter].tile_id );
                        printf( "NGID %d \n", nNextTileGID );

                        pTileInfo -> nMillis   = ( pTile -> animation[pTileInfo -> nCounter].duration + nMillis );
                        pTileInfo -> pNextTile = pMap -> tiles[nNextTileGID];
                        pTile = pTileInfo -> pNextTile;

                        if( !pTile )
                            pTile = pMap -> tiles[gid];
                    }
                    else  {
                        pTile = ( ( __stTileItemInfo * ) pTile -> user_data.pointer ) -> pNextTile;
                    }
                }

                pTs = pTile -> tileset;
                x   = pTile -> ul_x;
                y   = pTile -> ul_y;
                w   = pTs -> tile_width;
                h   = pTs -> tile_height;

                if( pIm ) {
                    pImage = pIm -> resource_image;
                }
                else {
                    pImage = pTs -> image -> resource_image;
                }

                flags = ( pLayer -> content.gids[( i * pMap -> width ) + j] ) & ~TMX_FLIP_BITS_REMOVAL;
                DrawTile( pImage, x, y, w, h,
                          ( j * pTs -> tile_width ),
                          ( i * pTs -> tile_height ),
                          opacity, flags );
            }
        }
    }
}