struct Vertex {
    float x, y, z;
    float u, v;
    //
    Vector normal;
};

struct Polygon {
    int n_vertex_num;
    Vertex vertex[7];
};

struct Mip_Map {
    int n_Width, n_Height;
    unsigned char *texture;
    int A_1, A_2, A_3, B_1;
};

struct Texture {
    int n_Width;
    int n_Height;
    int n_mip_num_x;
    int n_mip_num_y;
    unsigned __int32 *palette;
    Mip_Map *mip_map;
};

float Calc_Mip_Factor(Polygon *p, Texture *texture)
{
    float scr_area, txt_area;
    float x1, y1, u1, v1;
    float x2, y2, u2, v2;
    float mip_map_factor;
    int i, v_num, tW, tH;

    v_num = p->n_vertex_num;
    tW = texture->n_Width;
    tH = texture->n_Height;
    scr_area = 0;
    txt_area = 0;

    x1 = p->vertex[v_num - 1].x;
    y1 = p->vertex[v_num - 1].y;
    u1 = p->vertex[v_num - 1].u * tW;
    v1 = p->vertex[v_num - 1].v * tH;

    for(i = 0; i < v_num; i ++) {    
        x2 = p->vertex[i].x;
        y2 = p->vertex[i].y;
        u2 = p->vertex[i].u * tW;
        v2 = p->vertex[i].v * tH;
        //
        scr_area += x1 * y2 - y1 * x2;
        txt_area += u1 * v2 - v1 * u2;
        //
        x1 = x2;
        y1 = y2;
        u1 = u2;
        v1 = v2;
    }

    mip_map_factor = (float)fabs(txt_area / scr_area);
    // spocita 1 / plocha texelu

    return mip_map_factor;
}

// prevede mipfactor na potrebne zmenseni textury
int MipFactor_ToScale(float mip_map_factor)
{
    if(mip_map_factor > 262000)
        return 9;
    else if(mip_map_factor > 65500)
        return 8;
    else if(mip_map_factor > 16000)
        return 7;
    else if(mip_map_factor > 4000)
        return 6;
    else if(mip_map_factor > 1000)
        return 5;
    else if(mip_map_factor > 250)
        return 4;
    else if(mip_map_factor > 70)
        return 3;
    else if(mip_map_factor > 20)
        return 2;
    else if(mip_map_factor > 5)
        return 1;

    return 0;
}

#define MIPMAPNO_MIPMAPPING 0
#define ORDINARY_MIPMAPPING 1
#define BIDIRECT_MIPMAPPING 0
// aspon jedno musi byt 1, ostatni 0
// (prepinac stylu mipmappingu)

float Calc_Mip_Factor_X(POLYGON *p, TEXTURE *texture)
{
    float x[2], y[2], u[2];
    float a, b, c;

    a = (float)texture->Width;

    x[0] = p->vertex[1].x - p->vertex[0].x;
    x[1] = p->vertex[2].x - p->vertex[0].x;

    y[0] = p->vertex[1].y - p->vertex[0].y;
    y[1] = p->vertex[2].y - p->vertex[0].y;

    u[0] = p->vertex[1].u * a - p->vertex[0].u * a;
    u[1] = p->vertex[2].u * a - p->vertex[0].u * a;

    a = y[0] * u[1] - y[1] * u[0];
    b = u[0] * x[1] - u[1] * x[0];
    c = x[0] * y[1] - x[1] * y[0];
    // cross product - normala polygonu

    if(c == 0) 
        return 0;
    
    a /= c;
    b /= c;

    return (float)(a * a + b * b);
    // spocita 1 / plocha texelu v souradnici u
}

static char multab[4][4096]; // 4096 = 64^2

void PreCalc_Multabs()
{
    int u, v, total;
    int i;

    for(u = 0; u < 64; u ++) {
        for(v = 0; v < 64; v ++) {
            i = u + (v << 6);

            multab[0][i] = (((63 - u) * (63 - v)) >> 6);
            multab[1][i] = ((u * (63 - v)) >> 6);
            multab[2][i] = (((63 - u) * v) >> 6);
            multab[3][i] = ((u * v) >> 6);

            total = multab[0][i] + multab[1][i]
                + multab[2][i] + multab[3][i];

            if(total < 63)
                multab[0][i] += 63 - total;
        }
    }
}

int W_0, W_1;
int A_1, A_2, A_3, B_1;
unsigned char    *_texture;
unsigned __int32 *_palette;

// vykresli texturovany bilinearne filtrovany segment o delce =< 16pix.
static void _fastcall Interpolate_Segment_Bilerp(int u1, int du, int v1, int dv,
    unsigned __int32 *video, unsigned __int32 *v2)
{
    int frac, tex;
    do {
        tex = ((u1 >> 16) & A_1) + ((v1 >> B_1) & A_2);
        // adresa texelu

        frac = ((u1 >> 10) & 0x3f) + ((v1 >> 4) & 0xfc0);
        // desetinna cast adresy (6 bitu z V + 6 bitu z U)

        *video = _palette[(_texture[tex] << 6) + multab[0][frac]] +
                 _palette[(_texture[(tex + 1) & A_3] << 6) + multab[1][frac]] +
                 _palette[(_texture[(tex + W_0) & A_3] << 6) + multab[2][frac]] +
                 _palette[(_texture[(tex + W_1) & A_3] << 6) + multab[3][frac]];
        // bilinearni interpolace

        video ++;
        // nova pozice

        u1 += du;
        v1 += dv;
        // interpolace souradnic
    } while(video < v2);
}

// vykresli texturovany bilinearne filtrovany segment o delce =< 16pix.
static void _fastcall Interpolate_Segment_Bilerp(int u1, int du, int v1, int dv,
    unsigned __int32 *video, unsigned __int32 *v2)
{
    int frac, tex_x, tex_y;
    do {
        tex_x = (u1 >> 16);
        tex_y = (v1 >> B_1);
        // adresa texelu

        frac = ((u1 >> 10) & 0x3f) + ((v1 >> 4) & 0xfc0);
        // desetinna cast adresy (6 bitu z V + 6 bitu z U)

        *video = _palette[(_texture[(tex_x & A_1) +
                 (tex_y & A_2)] << 6) + multab[0][frac]] +
                 _palette[(_texture[((tex_x + 1) & A_1) +
                 (tex_y & A_2)] << 6) + multab[1][frac]] +
                 _palette[(_texture[(tex_x & A_1) +
                 ((tex_y + 1) & A_2)] << 6) + multab[2][frac]] +
                 _palette[(_texture[((tex_x + 1) & A_1) +
                 ((tex_y + 1) & A_2)] << 6) + multab[3][frac]];
        // bilinearni interpolace

        video ++;
        // nova pozice

        u1 += du;
        v1 += dv;
        // interpolace souradnic
    } while(video < v2);
}