struct Face {
    int n_id, n_used;
    int n_material;
    //
    Vertex *vertex[3];
    //
    Plane normal;
    //
    float f_rad_energy;
    float f_illumination;
};
// face má navíc radiativní a iluminativní energii ...

void Radiosity_Loop(World *p_world, int n_loops)
{
    Face *p_emitter;
    Vector v_start;
    int i, j, k, l;
    float f_form;
    int n_faces;

    while(n_loops --) {
        for(i = 0, p_emitter = 0; i < p_world->n_object_num; i ++) {
            for(j = 0; j < p_world->object[i].n_face_num; j ++) {
                if(!p_emitter || p_world->object[i].face[j].f_rad_energy >
                   p_emitter->f_rad_energy)
                    p_emitter = &p_world->object[i].face[j];
            }
        }
        // najde face s nejvetsi radiativni energii

        v_start.x = (p_emitter->vertex[0]->x +
            p_emitter->vertex[1]->x + p_emitter->vertex[2]->x) / 3;
        v_start.y = (p_emitter->vertex[0]->y +
            p_emitter->vertex[1]->y + p_emitter->vertex[2]->y) / 3;
        v_start.z = (p_emitter->vertex[0]->z +
            p_emitter->vertex[1]->z + p_emitter->vertex[2]->z) / 3;
        // stred prvniho facu

        for(i = 0; i < p_world->n_object_num; i ++) {
            for(j = 0; j < p_world->object[i].n_face_num; j ++) {
                f_form = f_FormFactor(p_world, v_start, p_emitter,
                    &p_world->object[i].face[j]);
                if(f_form > 0) {
                    p_world->object[i].face[j].f_rad_energy +=
                        p_emitter->f_rad_energy * f_form * .2f;
                    p_world->object[i].face[j].f_illumination +=
                        p_emitter->f_rad_energy * f_form * .8f;
                }
                // 90 % bude svetlost, 10 % se odrazi dal ...
            }
        }

        p_emitter->f_rad_energy = 0;
        // tohle je důležité !!
    }

    for(i = 0; i < p_world->n_object_num; i ++) {
        for(j = 0; j < p_world->object[i].n_vertex_num; j ++){
            n_faces = 0;
            // nastaví počet faců na 0

            p_world->object[i].vertex[j].i = 0;

            for(k = 0; k < p_world->object[i].n_face_num; k ++) {
                for(l = 0; l < 3; l ++) {
                    if(p_world->object[i].face[k].vertex[l] ==
                       &p_world->object[i].vertex[j]) {
                        n_faces ++;
                        p_world->object[i].vertex[j].i +=
                            p_world->object[i].face[k].f_illumination;
                    }
                }
            }
            // přičítá svetlost

            p_world->object[i].vertex[j].i /= (float)n_faces;
        }
    }
    // spočítá osvětlení per vertex
}

float f_FormFactor(World *p_world, Vector v_start, Face *p_emitter, Face *p_receiver)
{
    Vector v_end, v_ray;
    float f_form;

    v_end.x = (p_receiver->vertex[0]->x + p_receiver->vertex[1]->x +
        p_receiver->vertex[2]->x) / 3;
    v_end.y = (p_receiver->vertex[0]->y + p_receiver->vertex[1]->y +
        p_receiver->vertex[2]->y) / 3;
    v_end.z = (p_receiver->vertex[0]->z + p_receiver->vertex[1]->z +
        p_receiver->vertex[2]->z) / 3;
    // stred druheho facu

    if(v_end.x * p_emitter->normal.a + v_end.y * p_emitter->normal.b +
       v_end.z * p_emitter->normal.c + p_emitter->normal.d > 0.1)
        return 0.0;
    // jen přivrácené facy ...

    v_ray.x = v_end.x - v_start.x;
    v_ray.y = v_end.y - v_start.y;
    v_ray.z = v_end.z - v_start.z;
    // paprsek

    f_form = f_Visibility(p_world, v_start, v_end, v_ray);
    // zakladem je viditelnost

    f_form /= Pi * _Len(v_ray);
    // vydelime to pi * vzdalenost

    _Normalize(v_ray);
    return f_form * _PlDot(v_ray, p_emitter->normal) *
        (- _PlDot(v_ray, p_receiver->normal));
    // a zavrsime dvema skalarnimi souciny (nepocitame s diferencialni
    // plochou, budeme si tise myslet ze je plocha vsech patchu 1 ...)
}

n_color = (((n_color >> 16) * (i1 >> 16) > 0xff00)? 0xff0000 :
          (((n_color >> 16) * (i1 >> 16)) >> 8) << 16) |
          (((n_color & 0x00ff00) * (i1 >> 16) > 0x00ff0000)? 0x00ff00 :
          (((n_color & 0x00ff00) * (i1 >> 16)) >> 8) & 0x00ff00) |
          (((n_color & 0x0000ff) * (i1 >> 16) > 0x0000ff00)? 0x0000ff :
          (((n_color & 0x0000ff) * (i1 >> 16)) >> 8) & 0x0000ff);

static const int n_hemicube_size = 256;

static unsigned __int32 p_s_hemicube_buffer[n_hemicube_size * n_hemicube_size];
static unsigned __int32 p_s_hemicube_buffer_side[4][n_hemicube_size *
                                                    n_hemicube_size / 2];
static float p_hemicube_formfactor[n_hemicube_size * n_hemicube_size];
static float p_hemicube_formfactor_side[n_hemicube_size * n_hemicube_size / 2];

static float f_hemicube_max = 1;

void Calc_HemicubeFormFactors()
{
    float f_half_pixel_width;
    float f_pixel_area;
    float dx, dy;
    int x, y;
    float f;

    f_half_pixel_width = (1.0f / n_hemicube_size);
    //
    f_pixel_area = (2.0f / n_hemicube_size);
    f_pixel_area *= f_pixel_area;
    // 2 je velikost hemicube

    for(x = 0; x < n_hemicube_size; x ++) {
        for (y = 0; y < n_hemicube_size; y ++) {
            dx = ((x - n_hemicube_size / 2) / (n_hemicube_size / 2.0f)) +
                f_half_pixel_width;
            dy = ((y - n_hemicube_size / 2) / (n_hemicube_size / 2.0f)) +
                f_half_pixel_width;

            f = (dx * dx + dy * dy + 1);
            f *= f * Pi;

            p_hemicube_formfactor[x + y * n_hemicube_size] = f_pixel_area / f;
        }
    }
    // vrchni ...

    for(x = 0; x < n_hemicube_size; x ++) {
        for(y = 0; y < n_hemicube_size / 2; y ++) {
            dx = (x - n_hemicube_size / 2) / (n_hemicube_size / 2.0f) +
                f_half_pixel_width;
            dy = (n_hemicube_size / 2 - 1 - y) / (n_hemicube_size / 2.0f) +
                f_half_pixel_width;

            f = (dx * dx + dy * dy + 1);
            f *= f * Pi;

            p_hemicube_formfactor_side[x + y * n_hemicube_size] =
                (f_pixel_area * (dy + f_half_pixel_width)) / f;
        }
    }
    // strana

    for(x = 0, f_hemicube_max = 0; x < n_hemicube_size; x ++) {
        for(y = 0; y < n_hemicube_size / 2; y ++) {
            if(f_hemicube_max < p_hemicube_formfactor_side[x + y * n_hemicube_size])
                f_hemicube_max = p_hemicube_formfactor_side[x + y * n_hemicube_size];
        }
    }
    //
    for(x = 0; x < n_hemicube_size; x ++) {
        for(y = 0; y < n_hemicube_size; y ++) {
            if(f_hemicube_max < p_hemicube_formfactor[x + y * n_hemicube_size])
                f_hemicube_max = p_hemicube_formfactor[x + y * n_hemicube_size];
        }
    }
    // hledá největší položku ...

#define __SUM_TEST
#ifdef __SUM_TEST
        float f_sum;

        for(y = 0, f_sum = 0; y < n_hemicube_size; y ++) {
            for(x = 0; x < n_hemicube_size / 2; x ++)
                f_sum += p_hemicube_formfactor_side[y + x * n_hemicube_size];
        }
        // strana

        f_sum *= 4;
        // strany jsou 4

        for(x = 0; x < n_hemicube_size; x ++) {
            for(y = 0; y < n_hemicube_size; y ++)
                f_sum += p_hemicube_formfactor[x + y * n_hemicube_size];
        }
        // vrch

        // tady musi byt f_sum == 1, mě to vyjde 1.00435f
#endif
}

void Render_Hemicube(Vector v_pos, Vector v_normal, Mesh *p_svet, Vector v_radiative)
{
    Vector v_up, v_right;
    Matrix m_camera;
    int i, j;

    Matrix_Init(&m_camera);

    if(fabs(v_normal.x) < .01 &&
       fabs(v_normal.y) - 1 < .01 && fabs(v_normal.z) < .01) {
        v_up.x = 0; 
        v_up.y = 0; 
        v_up.z = 1;
    } else {
        v_up.x = 0; 
        v_up.y = 1; 
        v_up.z = 0;
    }
    // najde smysluplný vektor nahoru ...

    _Normalize(v_normal);
    _Cross(v_up, v_normal, v_right);
    _Cross(v_right, v_normal, v_up);
    _Normalize(v_right);
    _Normalize(v_up);

    Matrix_Init(&m_camera);
    //
    m_camera[0][0] = v_right.x;
    m_camera[0][1] = v_right.y;
    m_camera[0][2] = v_right.z;
    m_camera[1][0] = v_up.x;
    m_camera[1][1] = v_up.y;
    m_camera[1][2] = v_up.z;
    m_camera[2][0] = v_normal.x;
    m_camera[2][1] = v_normal.y;
    m_camera[2][2] = v_normal.z;
    m_camera[3][0] = v_pos.x;
    m_camera[3][1] = v_pos.y;
    m_camera[3][2] = v_pos.z;
    // kamera, která se dívá dopředu

    Set_FormFactors(p_hemicube_formfactor, v_radiative);

    SubWindow(n_hemicube_size, n_hemicube_size);
    Clipper(n_hemicube_size, n_hemicube_size);
    Init_Screen();
    for(i = 0; i < p_svet->n_object_num; i ++) {
        DrawObject(&p_svet->p_object[i].m_object, &m_camera,
            &p_svet->p_object[i], p_svet->p_material, p_svet->p_lightmap);
    }
    Release_Screen_LinearBuff(p_s_hemicube_buffer);
    // vykreslí pohled patche do přední roviny ...

    Matrix_Rotate_X(&m_camera, -Pi / 2);
    // otočí kameru tak, aby byla rovnoběžně s rovinou ...

    Set_FormFactors(p_hemicube_formfactor_side, v_radiative);

    SubWindow(n_hemicube_size, n_hemicube_size);
    Clipper(n_hemicube_size, n_hemicube_size / 2);
    for(i = 0; i < 4; i ++) {
        Init_Screen();
        for(j = 0; j < p_svet->n_object_num; j ++) {
            DrawObject(&p_svet->p_object[j].m_object, &m_camera,
                &p_svet->p_object[j], p_svet->p_material, p_svet->p_lightmap);
        }
        Release_Screen_LinearBuff(p_s_hemicube_buffer_side[i]);
        // vykreslí pohled patche do boční roviny ...

        Matrix_Rotate_Y(&m_camera, -Pi / 2);
        // otočí kameru k další rovině ...
    }
}

void Copy_HemicubeToScreen2(unsigned __int32 *p_buffer, int n_buffer_w)
{
    Vector v;
    int w, h;
    int x, y;
    float f;

    //Modulate_HemicubeBuffers();

    w = (int)(2 * n_hemicube_size);
    h = w;

    for(y = 0; y < h; y ++) {
        for(x = 0; x < w; x ++) {
            v.x = -(w - x * 2) / (float)w;
            v.y = -(h - y * 2) / (float)h;
            if((f = v.x * v.x + v.y * v.y) > 1)
                continue;
            v.z = (float)sqrt(1 - f);
            // sestrojí vektor, koukající do hemicube ...

            if(v.z > fabs(v.x) && v.z > fabs(v.y)) {
                p_buffer[x + y * n_buffer_w] =
                    p_s_hemicube_buffer[
                        (int)((v.x / v.z * .5f + .5f) *
                        n_hemicube_size) +
                        (int)((v.y / v.z * .5f + .5f) *
                        n_hemicube_size) * n_hemicube_size];
                // největší je z - přední strana
            } else if(fabs(v.x) > fabs(v.y)) {
                if(v.x < 0) {
                    p_buffer[x + y * n_buffer_w] =
                        p_s_hemicube_buffer_side[1]
                        [(int)((-v.y / v.x * .5f + .5f) *
                         (n_hemicube_size - 1)) +
                         (int)((v.z / v.x * .5f + .5f) *
                         (n_hemicube_size - 1)) * n_hemicube_size];
                    // 1
                } else {
                    p_buffer[x + y * n_buffer_w] =
                        p_s_hemicube_buffer_side[3]
                        [(int)((-v.y / v.x * .5f + .5f) *
                         (n_hemicube_size - 1)) +
                         (int)((-v.z / v.x * .5f + .5f) *
                         (n_hemicube_size - 1)) * n_hemicube_size];
                    // 3
                }
                // největší je x - strana 1 nebo 3
            } else {
                if(v.y < 0) {
                    p_buffer[x + y * n_buffer_w] =
                        p_s_hemicube_buffer_side[2]
                        [(int)((v.x / v.y * .5f + .5f) *
                         (n_hemicube_size - 1)) +
                         (int)((v.z / v.y * .5f + .5f) *
                         (n_hemicube_size - 1)) * n_hemicube_size];
                    // 2
                } else {
                    p_buffer[x + y * n_buffer_w] =
                        p_s_hemicube_buffer_side[0]
                        [(int)((v.x / v.y * .5f + .5f) *
                         (n_hemicube_size - 1)) +
                         (int)((-v.z / v.y * .5f + .5f) *
                         (n_hemicube_size - 1)) * n_hemicube_size];
                    // 0
                }
                // největší je y - strana 0 nebo 2
            }
        }
    }
}

TLightmapTex *p_Lightmap(int n_width, int n_height)
{
    TLightmapTex *p_lightmap;

    if(!(p_lightmap = (TLightmapTex*)malloc(sizeof(TLightmapTex))))
        return 0;
    // naalokuje data pro lightmapu ...

    p_lightmap->n_width = n_width;
    p_lightmap->n_height = n_height;
    // nastaví rozměry lightmapy ...

    if(!(p_lightmap->p_frontline = (int*)malloc(n_width * sizeof(int))))
        return 0;
    memset(p_lightmap->p_frontline, 0, n_width * sizeof(int));
    // naalokuje a vynuluje data pro vkládání dílků ...

    if(!(p_lightmap->p_bytes = (float*)malloc(n_width *
       n_height * sizeof(float) * 6)))
        return 0;
    memset(p_lightmap->p_bytes, 0, n_width * n_height * sizeof(float) * 6);
    // naalokuje buffer pro texely a vymaže ho ...

    return p_lightmap;
}

void Raytrace_Tile(Group *p_group, Mapping_Info *p_mapping_info, World *p_world,
                   int n_x, int n_y, int n_h, int n_w, int n_p_w,
                   float *p_buffer)
{
    float f_radiative[3];
    Vector v_texel_pos;
    Vector v_pos_v;
    int b_contain;
    //float r, g, b;
    //Vector v_ray;
    int x, y, i;
    //float a;
    //int j;

    for(y = 0; y < n_h; y ++) {
        v_pos_v = p_mapping_info->v_org;
        v_pos_v.x += p_mapping_info->v_v.x * (float)y /
            (float)n_h * p_mapping_info->f_height;
        v_pos_v.y += p_mapping_info->v_v.y * (float)y /
            (float)n_h * p_mapping_info->f_height;
        v_pos_v.z += p_mapping_info->v_v.z * (float)y /
            (float)n_h * p_mapping_info->f_height;
        //
        for(x = 0; x < n_w; x ++) {
            v_texel_pos.x = p_mapping_info->v_u.x * (float)x /
                (float)n_w * p_mapping_info->f_width + v_pos_v.x;
            v_texel_pos.y = p_mapping_info->v_u.y * (float)x /
                (float)n_w * p_mapping_info->f_width + v_pos_v.y;
            v_texel_pos.z = p_mapping_info->v_u.z * (float)x /
                (float)n_w * p_mapping_info->f_width + v_pos_v.z;
            // spočítá pozici texelu lightmapy ve worldspace

            switch(p_mapping_info->n_plane) {
            case Plane_xy:
                v_texel_pos.z = -(v_texel_pos.x * p_group->p_face[0]->normal.a +
                                  v_texel_pos.y * p_group->p_face[0]->normal.b +
                                  p_group->p_face[0]->normal.d) /
                                  p_group->p_face[0]->normal.c;
                break;
            case Plane_xz:
                v_texel_pos.y = -(v_texel_pos.x * p_group->p_face[0]->normal.a +
                                  v_texel_pos.z * p_group->p_face[0]->normal.c +
                                  p_group->p_face[0]->normal.d) /
                                  p_group->p_face[0]->normal.b;
                break;
            case Plane_yz:
                v_texel_pos.x = -(v_texel_pos.y * p_group->p_face[0]->normal.b +
                                  v_texel_pos.z * p_group->p_face[0]->normal.c +
                                  p_group->p_face[0]->normal.d) /
                                  p_group->p_face[0]->normal.a;
                break;
            }
            // promítne pozici texelu z našeho
            // obdélníku do roviny, ve které leží facy ...

            f_radiative[0] = 0;
            f_radiative[1] = 0;
            f_radiative[2] = 0;

            b_contain = false;
            for(i = 0; i < p_group->n_face_used; i ++) {
                if(b_Contain_Point(v_texel_pos, p_group->p_face[i])) {
                    if(p_group->p_face[i]->f_radiative_r > 0.01 ||
                       p_group->p_face[i]->f_radiative_g > 0.01 ||
                       p_group->p_face[i]->f_radiative_b > 0.01) {
                        f_radiative[0] = p_group->p_face[i]->f_radiative_r;
                        f_radiative[1] = p_group->p_face[i]->f_radiative_g;
                        f_radiative[2] = p_group->p_face[i]->f_radiative_b;
                    }
                    b_contain = true;
                    break;
                }
            }
            // zkontroluje, jestli face obsahuje bod ..

            p_buffer[ ((x + n_x) + (y + n_y) * n_p_w) * 6     ] = f_radiative[0];
            p_buffer[(((x + n_x) + (y + n_y) * n_p_w) * 6) + 1] = f_radiative[1];
            p_buffer[(((x + n_x) + (y + n_y) * n_p_w) * 6) + 2] = f_radiative[2];
            // HDR illumination color

            p_buffer[(((x + n_x) + (y + n_y) * n_p_w) * 6) + 3] = f_radiative[0];
            p_buffer[(((x + n_x) + (y + n_y) * n_p_w) * 6) + 4] = f_radiative[1];
            p_buffer[(((x + n_x) + (y + n_y) * n_p_w) * 6) + 5] = f_radiative[2];
            // HDR radiative color

            // převede barvu do RGB a uloží do příslušného dílku v textuře ...
        }
    }
}

static void _fastcall Interpolate_Segment_Bilerp(int u1, int du, int v1, int dv,
    int lu1, int ldu, int lv1, int ldv,
    unsigned __int32 *video, unsigned __int32 *v2, int x, int y)
{
    register int frac, tex, col;

    y = (y & 3) << 2;
    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)

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

        tex = (((lu1 + dither_u[frac = (y | (x & 3))]) >> 16) & LA_1) +
              (((lv1 + dither_v[frac]) >> LB_1) & LA_2);
        tex = (tex << 1) + (tex << 2);

        int b = (int)(((col & 0x0000ff) * _lightmap[tex + 2]) / 256);
        b = (b > 0x0000ff)? 0x0000ff : b & 0x0000ff;
        col >>= 8;
        int r = (col & 0x00ff00);
        r = ((r * _lightmap[tex]) > 0xff0000)? 0xff0000 :
            (int)(r * _lightmap[tex]) & 0xff0000;
        int g = (col & 0x0000ff);
        g = ((g * _lightmap[tex + 1]) > 0x00ff00)? 0x00ff00 :
            (int)(g * _lightmap[tex + 1]) & 0x00ff00;

        *video ++ = r | g | b;
        // osvětlí ...

        x ++;
        // nova pozice

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

static float *p_cur_form_factors;
// pointer na odpovídající form-faktory hemicube

static float f_radiative_r;
static float f_radiative_g;
static float f_radiative_b;
// radiativní energie


static void _fastcall Interpolate_Segment_Radiate(int u1, int du, int v1, int dv,
    int lu1, int ldu, int lv1, int ldv,
    unsigned __int32 *video, unsigned __int32 *v2, int x, int y)
{
    register int frac, tex, col;

    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)

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

        tex = (((lu1 + dither_u[frac = (((y & 3) << 2) | (x & 3))]) >> 16) & LA_1) +
              (((lv1 + dither_v[frac]) >> LB_1) & LA_2);
        tex = (tex << 1) + (tex << 2);
        // určí index texelu v lightmapě

        float f_form_factor = p_cur_form_factors[x + y * n_Width];

        _lightmap[tex + 3] += f_radiative_r * f_form_factor * __reflectance__ *
            ((float)((col >> 16) & 0xff) / 256 + (__bleeding__ - 1)) / __bleeding__;
        _lightmap[tex + 4] += f_radiative_g * f_form_factor * __reflectance__ *
            ((float)((col >> 8) & 0xff) / 256 + (__bleeding__ - 1)) / __bleeding__;
        _lightmap[tex + 5] += f_radiative_b * f_form_factor * __reflectance__ *
            ((float)(col & 0xff) / 256 + (__bleeding__ - 1)) / __bleeding__;
        //
        _lightmap[tex    ] += f_radiative_r * f_form_factor * (1 - __reflectance__);
        _lightmap[tex + 1] += f_radiative_g * f_form_factor * (1 - __reflectance__);
        _lightmap[tex + 2] += f_radiative_b * f_form_factor * (1 - __reflectance__);
        // radiate (pocitam s tim ze nikdy nepretece)

        int b = (int)(((col & 0x0000ff) * _lightmap[tex + 2]) / 256);
        b = (b > 0x0000ff)? 0x0000ff : b & 0x0000ff;
        col >>= 8;
        int r = (col & 0x00ff00);
        r = ((r * _lightmap[tex]) > 0xff0000)? 0xff0000 :
            (int)(r * _lightmap[tex]) & 0xff0000;
        int g = (col & 0x0000ff);
        g = ((g * _lightmap[tex + 1]) > 0x00ff00)? 0x00ff00 :
            (int)(g * _lightmap[tex + 1]) & 0x00ff00;

        *video ++ = r | g | b;
        // osvětlí ...

        x ++;
        // nova pozice

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

float f_Find_GreatestRadiativeEnergy(Mesh *p_mesh, Vector *v_texel_pos,
    Vector *v_texel_normal, int *n, Vector *v_rad_color)
{
    float f_max_energy, f_energy;
    int n_max_j, n_max_page;
    Group *p_group;
    int x, y;
    int i, j;

    while(1) {
        f_max_energy = -1;
        n_max_j = -1;
        n_max_page = -1;
        for(i = 0; i < p_mesh->n_lightmap_num; i ++) {
            for(j = 0; j < p_mesh->p_lightmap[i].n_width *
               p_mesh->p_lightmap[i].n_height; j ++) {
                if((f_energy = f_Energy(
                   p_mesh->p_lightmap[i].p_buffer[(j * 6) + 3],
                   p_mesh->p_lightmap[i].p_buffer[(j * 6) + 4],
                   p_mesh->p_lightmap[i].p_buffer[(j * 6) + 5])) > f_max_energy) {
                    f_max_energy = f_energy;
                    n_max_j = j;
                    n_max_page = i;
                }
            }
        }
        // najde maximální radiativní energii v nějaké lightmapě ...

        if(n_max_j == -1)
            return -1;

        for(i = 0; i < p_mesh->p_g_data->n_group_num; i ++) {
            if(p_mesh->p_g_data->p_group[i].t_rect.n_page != n_max_page)
                continue;

            x = n_max_j % p_mesh->p_lightmap[n_max_page].n_width;
            y = n_max_j / p_mesh->p_lightmap[n_max_page].n_width;
            // souřadnice pixelu ...

            p_group = &p_mesh->p_g_data->p_group[i];
            //
            x -= p_group->t_rect.x;
            y -= p_group->t_rect.y;
            //
            if(x >= 0 && x <= p_group->t_rect.w &&
               y >= 0 && y <= p_group->t_rect.h) {
                // našli jsme group, do kterého pixel patří ...

                v_texel_pos->x = p_mesh->p_m_info[i].v_org.x +

                    p_mesh->p_m_info[i].v_v.x * (float)(y + .5f) /
                    (float)p_group->t_rect.h *
                    p_mesh->p_m_info[i].f_height +

                    p_mesh->p_m_info[i].v_u.x * (float)(x + .5f) /
                    (float)p_group->t_rect.w *
                    p_mesh->p_m_info[i].f_width;
                //
                v_texel_pos->y = p_mesh->p_m_info[i].v_org.y +

                    p_mesh->p_m_info[i].v_v.y * (float)(y + .5f) /
                    (float)p_group->t_rect.h *
                    p_mesh->p_m_info[i].f_height +

                    p_mesh->p_m_info[i].v_u.y * (float)(x + .5f) /
                    (float)p_group->t_rect.w *
                    p_mesh->p_m_info[i].f_width;
                //
                v_texel_pos->z = p_mesh->p_m_info[i].v_org.z +

                    p_mesh->p_m_info[i].v_v.z * (float)(y + .5f) /
                    (float)p_group->t_rect.h *
                    p_mesh->p_m_info[i].f_height +

                    p_mesh->p_m_info[i].v_u.z * (float)(x + .5f) /
                    (float)p_group->t_rect.w *
                    p_mesh->p_m_info[i].f_width;
                //
                switch(p_mesh->p_m_info[i].n_plane) {
                case Plane_xy:
                    v_texel_pos->z =
                        -(v_texel_pos->x * p_group->p_face[0]->normal.a +
                        v_texel_pos->y * p_group->p_face[0]->normal.b +
                        p_group->p_face[0]->normal.d) /
                        p_group->p_face[0]->normal.c;
                    break;
                case Plane_xz:
                    v_texel_pos->y =
                        -(v_texel_pos->x * p_group->p_face[0]->normal.a +
                        v_texel_pos->z * p_group->p_face[0]->normal.c +
                        p_group->p_face[0]->normal.d) /
                        p_group->p_face[0]->normal.b;
                    break;
                case Plane_yz:
                    v_texel_pos->x =
                        -(v_texel_pos->y * p_group->p_face[0]->normal.b +
                        v_texel_pos->z * p_group->p_face[0]->normal.c +
                        p_group->p_face[0]->normal.d) /
                        p_group->p_face[0]->normal.a;
                    break;
                }
                // spočítá pozici texelu ve světě ...

                *n = p_group->p_face[0]->n_id;
                // id facu

                v_texel_normal->x = p_group->p_face[0]->normal.a;
                v_texel_normal->y = p_group->p_face[0]->normal.b;
                v_texel_normal->z = p_group->p_face[0]->normal.c;
                // normála texelu

                *v_rad_color = v_Energy(
                    p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 3],
                    p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 4],
                    p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 5]);
                // vrátí radiativní energii ...

                p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 3] = 0;
                p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 4] = 0;
                p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 5] = 0;
                // odstraní radiativní energii ...

                return f_max_energy;
            }
        }

        p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 3] = 0;
        p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 4] = 0;
        p_mesh->p_lightmap[n_max_page].p_buffer[(n_max_j * 6) + 5] = 0;
        // vznikla chyba rasterizéru a radiace se vykreslila kousek mimo face,
        // takže nikam nepatří ... odstraníme ji a zkusíme to s další ...
    }

    return -1;
}