Vector Light, Point, Normal; // pozice svetla, bodu kde urcujeme jeho intenzitu a normala
float f_LightIntensity = 255; // intenzita svetla
float f_PointIntensity; // intenzita svetla v nasem bode
Vector u; // pomocny vektor

u = Point - Light;
_Normalize(u);
// vektor od svetla do bodu

f_PointIntensity = f_LightIntensity * (u.x * Normal.x + u.y * Normal.y + u.z * Normal.z);
// vypocet svetlosti

fi = (mx_len - len + min_len) / mx_len;
fi = (fi < 0)? 0 : fi;

x = cur_face->vertex[j]->normal.x;
y = cur_face->vertex[j]->normal.y;
z = cur_face->vertex[j]->normal.z;
//
tx = x * m[0][0] + y * m[1][0] + z * m[2][0];
ty = x * m[0][1] + y * m[1][1] + z * m[2][1];
//
face.vertex[j]->u = (tx + 1) / 2;
face.vertex[j]->v = (ty + 1) / 2;

Offset[x][y] = (bump[x - 1][y] - bump[x + 1][y]) +
               (bump[x][y - 1] - bump[x][y + 1]) * bump_width;

struct Vertex {
    float x, y, z; // normalni souradnice
    float u, v;    // souradnice textury
    //
    float i, j, k; // souradnice v lightspace
    //
    Vector normal;  // normala vertexu
};

void ShadowObject(Matrix *m_object, Matrix *m_camera, Object *p_object)
{
    Face *cur_face, face;
    int n_material_id;
    float tx, ty, tz;
    float x, y, z;
    Polygon poly;
    Vertex v[3];
    int i, j;

    face.vertex[0] = &v[0];
    face.vertex[1] = &v[1];
    face.vertex[2] = &v[2];
    // nastaví vertexy pro naši dočasnou face

    Matrix_Inverse(m_camera, &m);
    Matrix_Multiply(&m, m_object, &m);
    Matrix_Inverse(&m, &im);
    // spočítá transformační matice

    for(i = 0; i < p_object->n_face_num; i ++){
        if((p_object->face[i].normal.c * im[3][2] +
           p_object->face[i].normal.a * im[3][0] +
           p_object->face[i].normal.b * im[3][1] +
           p_object->face[i].normal.d) > 0.1)
            continue;
        // byckface culling

        cur_face = &p_object->face[i];
        n_material_id = cur_face->n_material;
        for(j = 0; j < 3; j ++){
            x = cur_face->vertex[j]->x;
            y = cur_face->vertex[j]->y;
            z = cur_face->vertex[j]->z;
            //
            tx = x * m[0][0] + y * m[1][0] + 
                 z * m[2][0] +     m[3][0];
            ty = x * m[0][1] + y * m[1][1] + 
                 z * m[2][1] +     m[3][1];
            tz = x * m[0][2] + y * m[1][2] + 
                 z * m[2][2] +     m[3][2];
            //
            face.vertex[j]->x = tx;
            face.vertex[j]->y = ty;
            face.vertex[j]->z = tz;

            cur_face->vertex[j]->i = tx;
            cur_face->vertex[j]->j = ty;
            cur_face->vertex[j]->k = tz;
            // uloží se souřadnice zpátky do face
        }

        poly = Clip_Face(&face, &pyramid);
        // prožene face pyramidou

        if(poly.n_vertex_num) { // pokud je face vidět, bude to nenulové číslo
            for(j = 0; j < poly.n_vertex_num; j ++) {
                if(poly.vertex[j].z < 0.1) {
                    poly.n_vertex_num = 0;
                    break;
                }
                // pokud je z - souřadnice moc malá, zahodíme polygon

                poly.vertex[j].x = (n_Width / 2) + (poly.vertex[j].x *
                    z_delta) / poly.vertex[j].z;
                poly.vertex[j].y = (n_Height / 2) + (poly.vertex[j].y *
                    z_delta) / poly.vertex[j].z;
                // perspektivní korekce
            }

            ShadowPolygon(&poly, cur_face->n_id);
            // vykreslí polygon na obrazovku
        }
    }
}

int Compute_Interpolation_Consts(Polygon *pp, int nWidth, int nHeight)
{
    float x[3], y[3], z[3];
    float i[3], j[3], k[3];
    float u[3], v[3];
    float c;
    int l;

    for(l = 0; l < 3; l ++) {    
        z[l] = 1 / pp->vertex[l].z; 
        u[l] = pp->vertex[l].u * z[l] * nWidth;
        v[l] = pp->vertex[l].v * z[l] * nHeight;
        x[l] = pp->vertex[l].x;
        y[l] = pp->vertex[l].y;
        //
        k[l] = pp->vertex[l].k * z[l];
        i[l] = pp->vertex[l].i * z[l];
        j[l] = pp->vertex[l].j * z[l];
    }
    .
    .

void Draw_Segment(int c, int l, float z, float u, float v,
    float i, float j, float k, unsigned __int32 *video)
{
    int xs = (n_Width >> 1) * 0x10000;
    int ys = (n_Height >> 1) * 0x10000;
    int du, u1, u2;
    int dv, v1, v2;
    int di, i1, i2;
    int dj, j1, j2;
    float z1, zs;

    z1 = (0x10000 / z);
    // převod zpátky na lineární, do 16:16 fp

    u1 = (int)(u * z1);
    v1 = (int)(v * z1);
    // u a v se převede trošku jinak

    zs = (0x10000 * z_delta) / k;
    i1 = xs + (int)(i * zs);
    j1 = ys + (int)(j * zs);
    // shadow proměnné

    while(c >= 16) {
        z += dzdx * 16;
        u += dudx * 16;
        v += dvdx * 16;
        //
        i += didx * 16;
        j += djdx * 16;
        k += dkdx * 16;
        // pro optimalizaci přepočítáme jen kazdý 16. pixel

        z1 = (0x10000 / z);
        // určení dalšího lineárního z
        
        u2 = (int)(u * z1);
        v2 = (int)(v * z1);
        // u a v se převede trošku jinak

        zs = (0x10000 * z_delta) / k;
        i2 = xs + (int)(i * zs);
        j2 = ys + (int)(j * zs);
        // shadow proměnné

        du = (u2 - u1) / 16;
        dv = (v2 - v1) / 16;
        di = (i2 - i1) / 16;
        dj = (j2 - j1) / 16;
        // spočítá delty

        Interpolate_Segment(u1, du, v1, dv, i1, di, j1, dj, video, video + 16);
        // kreslící smyčka

        c -= 16;
        // sníží počet pixelů o 16
        
        video += 16;
        // posune se dál

        u1 = u2;
        v1 = v2;
        i1 = i2;
        j1 = j2;
        // využije předpočítané hodnoty
    }

    if(c > 0) { // kreslí zbytek lajny (pokud délka není násobkem 16)
    .
    .

static void _fastcall Interpolate_Segment_Bilerp(int u1, int du, int v1, int dv,
    int i1, int di, int j1, int dj, unsigned __int32 *video, unsigned __int32 *v2)
{
    unsigned __int32 texel;
    int frac, tex;
    int i, j;

    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)

        texel = _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

        i = i1 >> 16;
        j = j1 >> 16;
        if(i > 1 && i < Width - 1 && j > 1 && j < Height - 1) {
            if(_sh_buffer[i + 1 + Width * (j + 1)] != _cur_id &&
               _sh_buffer[i + 1 + Width * (j - 1)] != _cur_id &&
               _sh_buffer[i + 1 + Width * j] != _cur_id &&
               _sh_buffer[i + Width * j] != _cur_id &&
               _sh_buffer[i - 1 + Width * (j + 1)] != _cur_id &&
               _sh_buffer[i - 1 + Width * (j - 1)] != _cur_id &&
               _sh_buffer[i - 1 + Width * j] != _cur_id &&
               _sh_buffer[i + Width * (j + 1)] != _cur_id &&
               _sh_buffer[i + Width * (j - 1)] != _cur_id) {
                texel = ((((texel & 0xff00ff) * n_ambient) & 0xff00ff00) |
                         (((texel & 0x00ff00) * n_ambient) & 0x00ff0000)) >> 8;
            }
        } else {
            texel = ((((texel & 0xff00ff) * n_ambient) & 0xff00ff00) |
                     (((texel & 0x00ff00) * n_ambient) & 0x00ff0000)) >> 8;
        }
        // zeslabi svetlo podle stinu

        *video ++ = texel;
        // nova pozice

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