BYTE* pixelsForBmap (BMAP* b, BOOL* locked, BYTE** stripped)
{
    BYTE* pixels = NULL;

    if (b && locked && stripped)
    {
        // if bmap was loaded from file, just take the (original) pixels
        if (b->pixels)
            pixels = b->pixels;
        else
        {
            // bmap was created during runtime, therefore no
            // "original" pixels are available

            // we need to lock image to access finalbits!

            bmap_lock(b, 0);
            *locked = true;

            // in the case of an 8888 image (BGRA), we can simply take
            // the finalbits

            if (b->bytespp == 4)
                pixels = (BYTE*)(b->finalbits);
            else
            {
                // problem: 24bit image is specified, but is stored internally
                // different. We have to extract the stuff!

                int n = b->width * b->height * 3;
                *stripped = (BYTE*)sys_malloc(sizeof(BYTE) * n);

                for (int i = 0; i < n; i++)
                    (*stripped)[i] = ((BYTE*)(b->finalbits))[((i / 3) * 4) + (i % 3)];

                pixels = (*stripped);
            }
        }
    }

    return(pixels);
}

int numv_x = (int) head->fnumverts_x;
int numv_y = head->numverts / numv_x;

...

float x_size = head->ftrisize_x * (numv_x - 1);
float y_size = head->ftrisize_y * (numv_y - 1); 
float x_step = x_size / (numv_x-1); 
float y_step = y_size / (numv_y-1); 

...

//'hmp.fr' == current frame data
if ( x_step == 0 || y_step == 0)
{
    float min_x = (float) hmp.fr->min.p_pos[0] * head->scale[0] + head->scale_origin[0];
    float min_y = (float) hmp.fr->min.p_pos[1] * head->scale[1] + head->scale_origin[1];
    
    float max_x = (float) hmp.fr->max.p_pos[0] * head->scale[0] + head->scale_origin[0];
    float max_y = (float) hmp.fr->max.p_pos[1] * head->scale[1] + head->scale_origin[1];
    
    x_size = (max_x-min_x);
    y_size = (max_y-min_y); 
    x_step = x_size / (numv_x - 1);
    y_step = y_size / (numv_y - 1);
}