various HMP related MDL7 SDK questions

// determine skin type
int skinType = s->isExtern ? M7SKINTYP_EXT_FILE : 0;

// create new skin
hmp.Skin(skinType, "test123");

// save skins
if (h->numSkins > 0)
{
    for (int i = 0; i < h->numSkins; i++)
    {
        // get skin
        HmpSkin* s = (h->skins)[i];

        // determine skin type
        int skinType = 0;
        {
            if (s->isExtern)
                skinType = M7SKINTYP_EXT_FILE;

            if (s->mat)
                skinType |= M7SKINTYP_MATERIAL;
        }

        // create new skin
        hmp.Skin(skinType, s->name);

        // prepare skin size parameters
        int sizex = s->isExtern ? (int)strlen(s->externFile)+1 : 0;
        int sizey = s->isExtern ? 1 : 0;
        int bypp = s->isExtern ? 1 : 0;
        bool mips = false;

        // set skin size
        hmp.SkinSize(sizex, sizey, bypp, mips);

        // skin bits
        if (s->isExtern)
            hmp.SkinBits((BYTE*)s->externFile, 0, 0, 0);

        // material, if any
        if (s->mat)
        {
            // convert bgr var colors from material to rgb float triplets
            float diffuse[3], ambient[3], specular[3], emissive[3];
            rgbForBgrVar(diffuse, &(s->mat->diffuse_blue));
            rgbForBgrVar(ambient, &(s->mat->ambient_blue));
            rgbForBgrVar(specular, &(s->mat->specular_blue));
            rgbForBgrVar(emissive, &(s->mat->emissive_blue));

            // transfer rgb triplets to skin
            hmp.SkinMaterial(diffuse, ambient, specular, emissive, _FLOAT(s->mat->power));
        }

        // finish skin
        hmp.SkinDone();
    }
}

// get lowest and highest height
float lowest, highest;
hmp_minmaxz(h, &lowest, &highest);

// magnitude is height distance between lowest and highest
float magnitude = highest - lowest;

// z values have to be between 0...65535, so we have to set
// implicit scale and offset parameters

float lowerBound = 0.0f, upperBound = 65535.0f;

// scale
{
	hmp.Head().scale[0] = h->width / upperBound;
	hmp.Head().scale[1] = h->height / upperBound;
	hmp.Head().scale[2] = magnitude / upperBound;
}

// offset
{
	hmp.Head().scale_origin[0] = -h->width/2;
	hmp.Head().scale_origin[1] = -h->height/2;
	hmp.Head().scale_origin[2] = lowest;
}

long width,height; // original size of the bitmap
long bytespp; // original bytes per pixel (1..4)

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);
}