* The footprint of a ray and any prefix is called a _cellray_.

 * Any prefix of the footprint of a ray is called a _cellray_.

// These store certain unique subsequences of ray_coords.
// Filled during precomputation (_create_blockrays)
std::vector<coord_def> compressed_ray;
// 3D bit array indexed by coordinate and cellray index.
// Bit los_blockrays[x][y][i] is set iff a wall at (x,y) blocks
// the cellray starting at compressed_ray[i].

// These store all unique minimal cellrays. For each i,
// cellray i ends in cellray_ends[i] and passes through
// thoses cells p that have blockrays(p)[i] set. In other
// words, blockrays(p)[i] is set iff an opaque cell p blocks
// the cellray with index i.
std::vector<coord_def> cellray_ends;

blockrays_t los_blockrays;

blockrays_t blockrays;

       delete los_blockrays(*qi);

       delete blockrays(*qi);

    // determine nonduplicated rays
    std::vector<int> nondupe_cellrays = _find_nonduped_cellrays();
    const int num_nondupe_rays        = nondupe_cellrays.size();
    const int num_cellrays            = ray_coords.size();
    blockrays_t full_los_blockrays;

    // First, we calculate blocking information for all cell rays.
    // Cellrays are numbered according to the index of their end
    // cell in ray_coords.
    const int n_cellrays = ray_coords.size();
    blockrays_t all_blockrays;

    {
        full_los_blockrays(*qi) = new bit_array(num_cellrays);
        los_blockrays(*qi) = new bit_array(num_nondupe_rays);
    }

        all_blockrays(*qi) = new bit_array(n_cellrays);

    // first build all the rays: easier to do blocking calculations there

            coord_def p = ray[i];
            // every cell blocks all following cellrays

            // Every cell is contained in (thus blocks)
            // all following cellrays.

                full_los_blockrays(p)->set(ray.start+j);

                all_blockrays(ray[i])->set(ray.start + j);

    // we've built the basic blockray array; now compress it, keeping

    // We've built the basic blockray array; now compress it, keeping

    // we want to only keep the cellrays from nondupe_cellrays.
    compressed_ray.resize(num_nondupe_rays);
    for (int i = 0; i < num_nondupe_rays; ++i)
        compressed_ray[i] = ray_coords[nondupe_cellrays[i]];

    // Determine nonduplicated rays and store their end points.
    std::vector<int> nondupe_cellrays = _find_nonduped_cellrays();
    const int n_nondupe_rays          = nondupe_cellrays.size();
    cellray_ends.resize(n_nondupe_rays);
    for (int i = 0; i < n_nondupe_rays; ++i)
        cellray_ends[i] = ray_coords[nondupe_cellrays[i]];

    // Compress blockrays accordingly.

        for (int i = 0; i < num_nondupe_rays; ++i)
            los_blockrays(*qi)->set(i, full_los_blockrays(*qi)
                                       ->get(nondupe_cellrays[i]));

    {
        blockrays(*qi) = new bit_array(n_nondupe_rays);
        for (int i = 0; i < n_nondupe_rays; ++i)
            blockrays(*qi)->set(i, all_blockrays(*qi)
                                   ->get(nondupe_cellrays[i]));
    }

    // we can throw away full_los_blockrays now

    // We can throw away all_blockrays now.

        delete full_los_blockrays(*qi);

        delete all_blockrays(*qi);

    dead_rays  = new bit_array(num_nondupe_rays);
    smoke_rays = new bit_array(num_nondupe_rays);

    dead_rays  = new bit_array(n_nondupe_rays);
    smoke_rays = new bit_array(n_nondupe_rays);

          num_cellrays, fullrays.size(), num_nondupe_rays );

          n_cellrays, fullrays.size(), n_nondupe_rays );

// The rule behind LOS is:
// Two cells can see each other if there is any line from some point
// of the first to some point of the second ("generous" LOS.)
//

    const unsigned int num_cellrays = compressed_ray.size();

    const unsigned int num_cellrays = cellray_ends.size();

    // clear out the dead rays array

        // if this cell is opaque...

            // then block the appropriate rays
            *dead_rays |= *los_blockrays(*qi);

            // Block the appropriate rays.
            *dead_rays |= *blockrays(*qi);

            // block rays which have already seen a cloud
            *dead_rays  |= (*smoke_rays & *los_blockrays(*qi));
            *smoke_rays |= *los_blockrays(*qi);

            // Block rays which have already seen a cloud.
            *dead_rays  |= (*smoke_rays & *blockrays(*qi));
            *smoke_rays |= *blockrays(*qi);

            // this ray is alive!
            const coord_def p = coord_def(sx * compressed_ray[rayidx].x,
                                          sy * compressed_ray[rayidx].y);
            // update shadow map

            // This ray is alive, thus the end cell is visible.
            const coord_def p = coord_def(sx * cellray_ends[rayidx].x,
                                          sy * cellray_ends[rayidx].y);

    // ensure precomputations are done

    // Do precomputations if necessary.

    // center is always visible

    // Center is always visible.