fiddlerwoaroof/crawl - Change PHZTAI6CW7JHKFW77MKDK75UCNWBXFK7VDD3D5ORVXUFWV3C3EVQC

Clean up tiles code to use the VertBuffer classes.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@8321 c06c8d41-db1a-0410-9941-cceddc491573

Created by ennewalker on January 7, 2009

PHZTAI6CW7JHKFW77MKDK75UCNWBXFK7VDD3D5ORVXUFWV3C3EVQC

Dependencies

In channels

main

Change contents

Deletion in crawl-ref/source/tiletex.h at line 15 [11.6812]
B:BD[11.7000] → [11.7000:7017]
```
    TEX_DEFAULT,
```
Insertion in crawl-ref/source/tiletex.h at line 16 [11.6812]
[11.7031]
[11.7046]
```
    TEX_DEFAULT,
```
Replacement in crawl-ref/source/tiletex.h at line 67 [11.6812]
∅:D[12.402] → [13.320:367]
B:BD[13.320] → [13.320:367]
```
    inline const tile_info &get_info(int idx);
```
[12.402]
[13.367]
```
    inline const tile_info &get_info(int idx) const;
```

Replacement in crawl-ref/source/tiletex.h at line 73 [11.6812]

B:BD[13.653] → [13.653:716]

                           bool centre = true, int ymax = -1);

[13.653]

[13.716]

                           bool centre = true, int ymax = -1) const;

Replacement in crawl-ref/source/tiletex.h at line 80 [11.6812]

B:BD[13.778] → [13.778:834]

inline const tile_info &TilesTexture::get_info(int idx)

[13.778]

[13.834]

inline const tile_info &TilesTexture::get_info(int idx) const

Replacement in crawl-ref/source/tiletex.h at line 91 [11.6812]

B:BD[13.1234] → [13.1234:1294]

                                     bool centre, int ymax)

[13.1234]

[13.1294]

                                     bool centre, int ymax) const

Replacement in crawl-ref/source/tiletex.cc at line 145 [11.8197]

B:BD[11.10918] → [11.10918:10984]

                int index = ((unsigned char*)img->pixels)[src++];

[11.10918]

[11.10984]

                unsigned int index = ((unsigned char*)img->pixels)[src++];

Insertion in crawl-ref/source/tilereg.h at line 92 [11.45514]
[11.47488]
[11.47488]
```
    void set_transform();
```
Deletion in crawl-ref/source/tilereg.h at line 237 [11.45514]
B:BD[11.49671] → [10.1289:1420]
∅:D[10.1420] → [11.49785:49786]
∅:D[13.4823] → [11.49785:49786]
B:BD[11.49785] → [11.49785:49786]
```
    void add_quad(TextureID tex, unsigned int idx, int x, int y, int ofs_x = 0, int ofs_y = 0, bool centre = true, int ymax = -1);
```

Deletion in crawl-ref/source/tilereg.h at line 238 [11.45514]

B:BD[11.49813] → [11.49813:49969]


    struct tile_vert
    {
        float pos_x;
        float pos_y;
        float tex_x;
        float tex_y;
    };
    std::vector<tile_vert> m_verts;

Insertion in crawl-ref/source/tilereg.h at line 239 [11.45514]
[14.652]
[11.49969]
```
    bool m_dirty;
```

Replacement in crawl-ref/source/tilereg.h at line 290 [11.45514]

B:BD[11.50995] → [10.1465:1747]

∅:D[12.1303] → [15.598:657]

∅:D[10.1747] → [15.598:657]

B:BD[11.51522] → [15.598:657]

    void draw_background(unsigned int bg, int x, int y);
    void draw_mcache(mcache_entry *entry, int x, int y);
    void draw_player(int x, int y);
    void draw_foreground(unsigned int bg, unsigned int fg, int x, int y);
    void draw_doll(const dolls_data &doll, int x, int y);
    void draw_cursor(cursor_type type, unsigned int tile);

[11.50995]

[11.51642]

    void pack_background(unsigned int bg, int x, int y);
    void pack_mcache(mcache_entry *entry, int x, int y);
    void pack_player(int x, int y);
    void pack_foreground(unsigned int bg, unsigned int fg, int x, int y);
    void pack_doll(const dolls_data &doll, int x, int y);
    void pack_cursor(cursor_type type, unsigned int tile);
    void pack_buffers();

Insertion in crawl-ref/source/tilereg.h at line 307 [11.45514]

[16.621]

    TileBuffer m_buf_dngn;
    TileBuffer m_buf_doll;
    TileBuffer m_buf_main;
    bool m_dirty;

Replacement in crawl-ref/source/tilereg.h at line 359 [11.45514]
∅:D[10.1939] → [11.52909:52932]
B:BD[11.52909] → [11.52909:52932]
```
    void pack_verts();
```
[10.1939]
[10.1940]
```
    void pack_buffers();
```
Deletion in crawl-ref/source/tilereg.h at line 364 [11.45514]
B:BD[11.53100] → [10.2003:2025]
```
    int m_base_verts;
```
Replacement in crawl-ref/source/tilereg.h at line 367 [11.45514]
B:BD[11.53202] → [11.53202:53226]
```
    coord_def m_cursor;
```
[11.53202]
[11.53226]
```
    TileBuffer m_buf_dngn;
    TileBuffer m_buf_main;
```
Replacement in crawl-ref/source/tilereg.h at line 370 [11.45514]
B:BD[11.53227] → [11.53227:53252]
```
    bool m_need_to_pack;
```
[11.53227]
[11.53252]
```
    coord_def m_cursor;
```
Insertion in crawl-ref/source/tilereg.h at line 420 [11.45514]
[11.54153]
[11.54153]
```
    void pack_buffers();
```

Insertion in crawl-ref/source/tilereg.h at line 427 [11.45514]

[11.54323]


    ShapeBuffer m_buf_map;
    LineBuffer m_buf_lines;
    bool m_dirty;

Replacement in crawl-ref/source/tilereg.cc at line 53 [11.54399]
B:BD[11.55452] → [11.55452:55492]
```
const int map_colours[MAX_MAP_COL][3] =
```
[11.55452]
[11.55492]
```
const VColour map_colours[MAX_MAP_COL] =
```

Replacement in crawl-ref/source/tilereg.cc at line 55 [11.54399]

B:BD[11.55494] → [11.55494:55647]

    {  0,   0,   0}, // BLACK
    {128, 128, 128}, // DKGREY
    {160, 160, 160}, // MDGREY
    {192, 192, 192}, // LTGREY
    {255, 255, 255}, // WHITE

[11.55494]

[11.55647]

    VColour(  0,   0,   0, 255), // BLACK
    VColour(128, 128, 128, 255), // DKGREY
    VColour(160, 160, 160, 255), // MDGREY
    VColour(192, 192, 192, 255), // LTGREY
    VColour(255, 255, 255, 255), // WHITE

Replacement in crawl-ref/source/tilereg.cc at line 61 [11.54399]

B:BD[11.55648] → [11.55648:55778]

    {  0,  64, 255}, // BLUE  (actually cyan-blue)
    {128, 128, 255}, // LTBLUE
    {  0,  32, 128}, // DKBLUE (maybe too dark)

[11.55648]

[11.55778]

    VColour(  0,  64, 255, 255), // BLUE  (actually cyan-blue)
    VColour(128, 128, 255, 255), // LTBLUE
    VColour(  0,  32, 128, 255), // DKBLUE (maybe too dark)

Replacement in crawl-ref/source/tilereg.cc at line 65 [11.54399]

B:BD[11.55779] → [11.55779:55873]

    {  0, 255,   0}, // GREEN
    {128, 255, 128}, // LTGREEN
    {  0, 128,   0}, // DKGREEN

[11.55779]

[11.55873]

    VColour(  0, 255,   0, 255), // GREEN
    VColour(128, 255, 128, 255), // LTGREEN
    VColour(  0, 128,   0, 255), // DKGREEN

Replacement in crawl-ref/source/tilereg.cc at line 69 [11.54399]

B:BD[11.55874] → [11.55874:55982]

    {  0, 255, 255}, // CYAN
    { 64, 255, 255}, // LTCYAN (maybe too pale)
    {  0, 128, 128}, // DKCYAN

[11.55874]

[11.55982]

    VColour(  0, 255, 255, 255), // CYAN
    VColour( 64, 255, 255, 255), // LTCYAN (maybe too pale)
    VColour(  0, 128, 128, 255), // DKCYAN

Replacement in crawl-ref/source/tilereg.cc at line 73 [11.54399]

B:BD[11.55983] → [11.55983:56087]

    {255,   0,   0}, // RED
    {255, 128, 128}, // LTRED (actually pink)
    {128,   0,   0}, // DKRED

[11.55983]

[11.56087]

    VColour(255,   0,   0, 255), // RED
    VColour(255, 128, 128, 255), // LTRED (actually pink)
    VColour(128,   0,   0, 255), // DKRED

Replacement in crawl-ref/source/tilereg.cc at line 77 [11.54399]

B:BD[11.56088] → [11.56088:56212]

    {192,   0, 255}, // MAGENTA (actually blue-magenta)
    {255, 128, 255}, // LTMAGENTA
    { 96,   0, 128}, // DKMAGENTA

[11.56088]

[11.56212]

    VColour(192,   0, 255, 255), // MAGENTA (actually blue-magenta)
    VColour(255, 128, 255, 255), // LTMAGENTA
    VColour( 96,   0, 128, 255), // DKMAGENTA

Replacement in crawl-ref/source/tilereg.cc at line 81 [11.54399]

B:BD[11.56213] → [11.56213:56327]

    {255, 255,   0}, // YELLOW
    {255, 255,  64}, // LTYELLOW (maybe too pale)
    {128, 128,   0}, // DKYELLOW

[11.56213]

[11.56327]

    VColour(255, 255,   0, 255), // YELLOW
    VColour(255, 255,  64, 255), // LTYELLOW (maybe too pale)
    VColour(128, 128,   0, 255), // DKYELLOW

Replacement in crawl-ref/source/tilereg.cc at line 85 [11.54399]
B:BD[11.56328] → [11.56328:56358]
```
    {165,  91,   0}, // BROWN
```
[11.56328]
[11.56358]
```
    VColour(165,  91,   0, 255), // BROWN
```

Insertion in crawl-ref/source/tilereg.cc at line 190 [11.54399]

[11.58279]

}
void Region::set_transform()
{
    glLoadIdentity();
    glTranslatef(sx + ox, sy + oy, 0);
    glScalef(dx, dy, 1);

Insertion in crawl-ref/source/tilereg.cc at line 208 [11.54399]
[14.927]
[11.58435]
```
    m_dirty = true;
```

Replacement in crawl-ref/source/tilereg.cc at line 219 [11.54399]

B:BD[11.58662] → [14.975:993]

    m_cy_to_gy(0)

[11.58662]

[11.58706]

    m_cy_to_gy(0),
    m_buf_dngn(&im->m_textures[TEX_DUNGEON]),
    m_buf_doll(&im->m_textures[TEX_DOLL]),
    m_buf_main(&im->m_textures[TEX_DEFAULT])

Insertion in crawl-ref/source/tilereg.cc at line 235 [11.54399]
[11.58958]
[11.58958]
```
    m_dirty = true;
```

Deletion in crawl-ref/source/tilereg.cc at line 250 [11.54399]

B:BD[11.60500] → [11.60500:60503]

B:BD[11.60503] → [10.2720:2838]

∅:D[10.2838] → [11.60616:60763]

∅:D[13.4961] → [11.60616:60763]

B:BD[11.60616] → [11.60616:60763]

B:BD[11.60763] → [13.4962:5006]

B:BD[13.5006] → [17.1566:1624]

∅:D[17.1624] → [13.5065:5323]

B:BD[13.5065] → [13.5065:5323]

∅:D[13.5323] → [11.61112:61113]

B:BD[11.61112] → [11.61112:61113]

B:BD[11.61164] → [11.61164:61508]

}
void TileRegion::add_quad(TextureID tex, unsigned int idx, int x, int y, int ofs_x, int ofs_y, bool centre, int ymax)
{
    // Generate quad
    //
    // 0 - 3
    // |   |
    // 1 - 2
    //
    // Data Layout:
    // float2 (position)
    // float2 (texcoord)
    float pos_sx = x;
    float pos_sy = y;
    float pos_ex, pos_ey, tex_sx, tex_sy, tex_ex, tex_ey;
    m_image->m_textures[tex].get_coords(idx, ofs_x, ofs_y,
                                        pos_sx, pos_sy, pos_ex, pos_ey,
                                        tex_sx, tex_sy, tex_ex, tex_ey,
                                        centre, ymax);
    tile_vert v;
    v.pos_x = pos_sx;
    v.pos_y = pos_sy;
    v.tex_x = tex_sx;
    v.tex_y = tex_sy;
    m_verts.push_back(v);
    v.pos_y = pos_ey;
    v.tex_y = tex_ey;
    m_verts.push_back(v);
    v.pos_x = pos_ex;
    v.tex_x = tex_ex;
    m_verts.push_back(v);
    v.pos_y = pos_sy;
    v.tex_y = tex_sy;
    m_verts.push_back(v);

Replacement in crawl-ref/source/tilereg.cc at line 252 [11.54399]

B:BD[11.61511] → [10.2839:2906]

void DungeonRegion::draw_background(unsigned int bg, int x, int y)

[11.61511]

[11.61596]

void DungeonRegion::pack_background(unsigned int bg, int x, int y)

Replacement in crawl-ref/source/tilereg.cc at line 258 [11.54399]
B:BD[11.61763] → [11.61763:61811]
```
        add_quad(TEX_DUNGEON, flv.floor, x, y);
```
[11.61763]
[11.61811]
```
        m_buf_dngn.add(flv.floor, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 265 [11.54399]
∅:D[12.1403] → [11.62000:62058]
∅:D[10.2971] → [11.62000:62058]
∅:D[13.5397] → [11.62000:62058]
B:BD[11.62000] → [11.62000:62058]
```
        add_quad(TEX_DUNGEON, TILE_BLOOD + offset, x, y);
```
[10.2971]
[11.62058]
```
        m_buf_dngn.add(TILE_BLOOD + offset, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 268 [11.54399]
B:BD[11.62065] → [11.62065:62106]
```
    add_quad(TEX_DUNGEON, bg_idx, x, y);
```
[11.62065]
[11.62106]
```
    m_buf_dngn.add(bg_idx, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 271 [11.54399]
B:BD[11.62136] → [11.62136:62184]
```
        add_quad(TEX_DUNGEON, TILE_HALO, x, y);
```
[11.62136]
[11.62184]
```
        m_buf_dngn.add(TILE_HALO, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 274 [11.54399]
B:BD[11.62247] → [11.62247:62300]
```
        add_quad(TEX_DUNGEON, TILE_SANCTUARY, x, y);
```
[11.62247]
[11.62300]
```
        m_buf_dngn.add(TILE_SANCTUARY, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 279 [11.54399]

B:BD[11.62497] → [11.62497:62567]

        add_quad(TEX_DUNGEON, TILE_TRAVEL_EXCLUSION_CENTRE_BG, x, y);

[11.62497]

[11.62567]

        m_buf_dngn.add(TILE_TRAVEL_EXCLUSION_CENTRE_BG, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 281 [11.54399]

B:BD[11.62634] → [11.62634:62697]

        add_quad(TEX_DUNGEON, TILE_TRAVEL_EXCLUSION_BG, x, y);

[11.62634]

[11.62697]

        m_buf_dngn.add(TILE_TRAVEL_EXCLUSION_BG, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 284 [11.54399]
B:BD[11.62726] → [4.336:383]
```
        add_quad(TEX_DUNGEON, TILE_RAY, x, y);
```
[11.62726]
[4.383]
```
        m_buf_dngn.add(TILE_RAY, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 286 [11.54399]

B:BD[4.420] → [4.420:480]

        add_quad(TEX_DUNGEON, TILE_RAY_OUT_OF_RANGE, x, y);

[4.420]

[11.62778]

        m_buf_dngn.add(TILE_RAY_OUT_OF_RANGE, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 289 [11.54399]
B:BD[11.62781] → [10.2972:3018]
```
void DungeonRegion::draw_player(int x, int y)
```
[11.62781]
[11.62845]
```
void DungeonRegion::pack_player(int x, int y)
```
Replacement in crawl-ref/source/tilereg.cc at line 413 [11.54399]
B:BD[11.66900] → [11.66900:66929]
```
    draw_doll(result, x, y);
```
[11.66900]
[11.67479]
```
    pack_doll(result, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 416 [11.54399]

B:BD[11.67482] → [10.3019:3087]

void DungeonRegion::draw_doll(const dolls_data &doll, int x, int y)

[11.67482]

[11.67562]

void DungeonRegion::pack_doll(const dolls_data &doll, int x, int y)

Replacement in crawl-ref/source/tilereg.cc at line 462 [11.54399]

B:BD[11.68599] → [13.5952:6019]

        add_quad(TEX_DOLL, doll.parts[p], x, y, 0, 0, true, ymax);

[11.68599]

[11.69357]

        m_buf_doll.add(doll.parts[p], x, y, 0, 0, true, ymax);

Replacement in crawl-ref/source/tilereg.cc at line 466 [11.54399]

B:BD[11.69366] → [10.3088:3155]

void DungeonRegion::draw_mcache(mcache_entry *entry, int x, int y)

[11.69366]

[11.69468]

void DungeonRegion::pack_mcache(mcache_entry *entry, int x, int y)

Replacement in crawl-ref/source/tilereg.cc at line 472 [11.54399]
B:BD[12.1685] → [12.1685:1717]
```
        draw_doll(*doll, x, y);
```
[12.1685]
[11.69668]
```
        pack_doll(*doll, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 480 [11.54399]

∅:D[18.245] → [12.1929:2009]

B:BD[12.1929] → [12.1929:2009]

        add_quad(TEX_DOLL, dinfo[i].idx, x, y, dinfo[i].ofs_x, dinfo[i].ofs_y);

[18.245]

[18.246]

        m_buf_doll.add(dinfo[i].idx, x, y, dinfo[i].ofs_x, dinfo[i].ofs_y);

Replacement in crawl-ref/source/tilereg.cc at line 484 [11.54399]

B:BD[11.71634] → [10.3156:3240]

void DungeonRegion::draw_foreground(unsigned int bg, unsigned int fg, int x, int y)

[11.71634]

[11.71716]

void DungeonRegion::pack_foreground(unsigned int bg, unsigned int fg, int x, int y)

Replacement in crawl-ref/source/tilereg.cc at line 491 [11.54399]
B:BD[11.72913] → [12.2205:2250]
```
        add_quad(TEX_DEFAULT, fg_idx, x, y);
```
[11.72913]
[11.73543]
```
        m_buf_main.add(fg_idx, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 498 [11.54399]

B:BD[11.73881] → [11.73881:73938]

            add_quad(TEX_DEFAULT, TILE_MASK_LAVA, x, y);

[11.73881]

[11.73938]

            m_buf_main.add(TILE_MASK_LAVA, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 503 [11.54399]

B:BD[11.74068] → [11.74068:74134]

            add_quad(TEX_DEFAULT, TILE_MASK_SHALLOW_WATER, x, y);

[11.74068]

[19.1778]

            m_buf_main.add(TILE_MASK_SHALLOW_WATER, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 508 [11.54399]

B:BD[19.1919] → [19.1919:1991]

            add_quad(TEX_DEFAULT, TILE_MASK_SHALLOW_WATER_MURKY, x, y);

[19.1919]

[11.74134]

            m_buf_main.add(TILE_MASK_SHALLOW_WATER_MURKY, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 513 [11.54399]

B:BD[11.74258] → [11.74258:74321]

            add_quad(TEX_DEFAULT, TILE_MASK_DEEP_WATER, x, y);

[11.74258]

[11.74321]

            m_buf_main.add(TILE_MASK_DEEP_WATER, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 518 [11.54399]

B:BD[19.2118] → [19.2118:2187]

            add_quad(TEX_DEFAULT, TILE_MASK_DEEP_WATER_MURKY, x, y);

[19.2118]

[19.2187]

            m_buf_main.add(TILE_MASK_DEEP_WATER_MURKY, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 523 [11.54399]
B:BD[11.74366] → [11.74366:74418]
```
        add_quad(TEX_DEFAULT, TILE_TRAP_NET, x, y);
```
[11.74366]
[11.74418]
```
        m_buf_main.add(TILE_TRAP_NET, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 526 [11.54399]

B:BD[11.74451] → [11.74451:74510]

        add_quad(TEX_DEFAULT, TILE_SOMETHING_UNDER, x, y);

[11.74451]

[11.74510]

        m_buf_main.add(TILE_SOMETHING_UNDER, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 532 [11.54399]
B:BD[11.74587] → [11.74587:74636]
```
        add_quad(TEX_DEFAULT, TILE_HEART, x, y);
```
[11.74587]
[11.74636]
```
        m_buf_main.add(TILE_HEART, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 537 [11.54399]
B:BD[11.74737] → [11.74737:74788]
```
        add_quad(TEX_DEFAULT, TILE_NEUTRAL, x, y);
```
[11.74737]
[11.74788]
```
        m_buf_main.add(TILE_NEUTRAL, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 542 [11.54399]
B:BD[11.74885] → [11.74885:74939]
```
        add_quad(TEX_DEFAULT, TILE_STAB_BRAND, x, y);
```
[11.74885]
[11.74939]
```
        m_buf_main.add(TILE_STAB_BRAND, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 547 [11.54399]

B:BD[11.75040] → [11.75040:75098]

        add_quad(TEX_DEFAULT, TILE_MAY_STAB_BRAND, x, y);

[11.75040]

[11.75098]

        m_buf_main.add(TILE_MAY_STAB_BRAND, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 553 [11.54399]

B:BD[11.75169] → [11.75169:75237]

        add_quad(TEX_DEFAULT, TILE_POISON, x, y, -status_shift, 0);

[11.75169]

[11.75237]

        m_buf_main.add(TILE_POISON, x, y, -status_shift, 0);

Replacement in crawl-ref/source/tilereg.cc at line 559 [11.54399]

B:BD[11.75310] → [11.75310:75369]

        add_quad(TEX_DEFAULT, TILE_ANIMATED_WEAPON, x, y);

[11.75310]

[11.75369]

        m_buf_main.add(TILE_ANIMATED_WEAPON, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 563 [11.54399]
∅:D[20.6346] → [11.75407:75455]
B:BD[11.75407] → [11.75407:75455]
```
        add_quad(TEX_DEFAULT, TILE_MESH, x, y);
```
[20.6346]
[11.75455]
```
        m_buf_main.add(TILE_MESH, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 566 [11.54399]
∅:D[20.6418] → [11.75490:75548]
B:BD[11.75490] → [11.75490:75548]
```
        add_quad(TEX_DEFAULT, TILE_MAGIC_MAP_MESH, x, y);
```
[20.6418]
[11.75548]
```
        m_buf_main.add(TILE_MAGIC_MAP_MESH, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 571 [11.54399]
B:BD[11.75701] → [11.75701:75754]
```
        add_quad(TEX_DEFAULT, TILE_NEW_STAIR, x, y);
```
[11.75701]
[11.75754]
```
        m_buf_main.add(TILE_NEW_STAIR, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 574 [11.54399]

B:BD[11.75815] → [3.239:309]

        add_quad(TEX_DEFAULT, TILE_TRAVEL_EXCLUSION_CENTRE_FG, x, y);

[11.75815]

[11.75885]

        m_buf_main.add(TILE_TRAVEL_EXCLUSION_CENTRE_FG, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 576 [11.54399]

B:BD[11.75951] → [3.310:373]

        add_quad(TEX_DEFAULT, TILE_TRAVEL_EXCLUSION_FG, x, y);

[11.75951]

[11.76014]

        m_buf_main.add(TILE_TRAVEL_EXCLUSION_FG, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 581 [11.54399]

B:BD[11.76116] → [11.76116:76175]

        add_quad(TEX_DEFAULT, TILE_TUTORIAL_CURSOR, x, y);

[11.76116]

[11.76175]

        m_buf_main.add(TILE_TUTORIAL_CURSOR, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 591 [11.54399]
B:BD[11.76423] → [11.76423:76466]
```
        add_quad(TEX_DEFAULT, type, x, y);
```
[11.76423]
[11.76466]
```
        m_buf_main.add(type, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 598 [11.54399]

B:BD[2.664] → [2.664:732]

            add_quad(TEX_DEFAULT, TILE_MDAM_LIGHTLY_DAMAGED, x, y);

[2.664]

[2.732]

            m_buf_main.add(TILE_MDAM_LIGHTLY_DAMAGED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 600 [11.54399]

B:BD[2.782] → [2.782:853]

            add_quad(TEX_DEFAULT, TILE_MDAM_MODERATELY_DAMAGED, x, y);

[2.782]

[2.853]

            m_buf_main.add(TILE_MDAM_MODERATELY_DAMAGED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 602 [11.54399]

B:BD[2.905] → [2.905:973]

            add_quad(TEX_DEFAULT, TILE_MDAM_HEAVILY_DAMAGED, x, y);

[2.905]

[2.973]

            m_buf_main.add(TILE_MDAM_HEAVILY_DAMAGED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 604 [11.54399]

B:BD[2.1023] → [2.1023:1092]

            add_quad(TEX_DEFAULT, TILE_MDAM_SEVERELY_DAMAGED, x, y);

[2.1023]

[2.1092]

            m_buf_main.add(TILE_MDAM_SEVERELY_DAMAGED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 606 [11.54399]

B:BD[2.1144] → [2.1144:1208]

            add_quad(TEX_DEFAULT, TILE_MDAM_ALMOST_DEAD, x, y);

[2.1144]

[2.1208]

            m_buf_main.add(TILE_MDAM_ALMOST_DEAD, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 610 [11.54399]

B:BD[15.679] → [15.679:748]

void DungeonRegion::draw_cursor(cursor_type type, unsigned int tile)

[15.679]

[15.748]

void DungeonRegion::pack_cursor(cursor_type type, unsigned int tile)

Replacement in crawl-ref/source/tilereg.cc at line 616 [11.54399]

B:BD[11.76475] → [15.852:923]

    add_quad(TEX_DEFAULT, tile, gc.x - m_cx_to_gx, gc.y - m_cy_to_gy);

[11.76475]

[15.923]

    m_buf_main.add(tile, gc.x - m_cx_to_gx, gc.y - m_cy_to_gy);

Replacement in crawl-ref/source/tilereg.cc at line 619 [11.54399]
∅:D[15.926] → [11.76475:76504]
B:BD[11.76475] → [11.76475:76504]
```
void DungeonRegion::render()
```
[15.926]
[11.76504]
```
void DungeonRegion::pack_buffers()
```

Replacement in crawl-ref/source/tilereg.cc at line 621 [11.54399]

B:BD[11.76506] → [11.76506:76728]

    if (m_tileb.size() == 0)
        return;
    glLoadIdentity();
    glTranslatef(sx + ox, sy + oy, 0);
    glScalef(dx, dy, 1);
    m_verts.clear();
    m_verts.reserve(4 * crawl_view.viewsz.x * crawl_view.viewsz.y);

[11.76506]

[11.76728]

    m_buf_dngn.clear();
    m_buf_doll.clear();
    m_buf_main.clear();

Replacement in crawl-ref/source/tilereg.cc at line 625 [11.54399]

B:BD[11.76729] → [11.76729:76894]

    GLState state;
    state.array_vertex = true;
    state.array_texcoord = true;
    state.blend = true;
    state.texture = true;
    GLStateManager::set(state);

[11.76729]

[11.76894]

    if (m_tileb.empty())
        return;

Replacement in crawl-ref/source/tilereg.cc at line 633 [11.54399]

B:BD[11.77076] → [11.77076:77115]

            draw_background(bg, x, y);

[11.77076]

[11.77115]

            unsigned int fg = m_tileb[tile];
            unsigned int fg_idx = fg & TILE_FLAG_MASK;

Replacement in crawl-ref/source/tilereg.cc at line 636 [11.54399]
B:BD[11.77116] → [11.77116:77149]
```
            tile += 2;
        }
```
[11.77116]
[11.77182]
```
            pack_background(bg, x, y);
```

Replacement in crawl-ref/source/tilereg.cc at line 638 [11.54399]

B:BD[11.77183] → [11.77183:77477]

B:BD[11.77478] → [11.77478:77515]

B:BD[11.77589] → [11.77589:77639]

B:BD[11.77639] → [12.2251:2257]

∅:D[12.2257] → [11.77639:77703]

B:BD[11.77639] → [11.77639:77703]

B:BD[11.77703] → [12.2258:2362]

    if (m_verts.size() > 0)
    {
        m_image->m_textures[TEX_DUNGEON].bind();
        glVertexPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].pos_x);
        glTexCoordPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].tex_x);
        glDrawArrays(GL_QUADS, 0, m_verts.size());
    }
    tile = 0;
    m_verts.clear();
    for (int y = 0; y < crawl_view.viewsz.y; y++)
    {
        for (int x = 0; x < crawl_view.viewsz.x; x++)
        {
            unsigned int fg = m_tileb[tile] & TILE_FLAG_MASK;
            if (fg >= TILEP_MCACHE_START)

[11.77183]

[11.77852]

            if (fg_idx >= TILEP_MCACHE_START)

Replacement in crawl-ref/source/tilereg.cc at line 640 [11.54399]

B:BD[11.77866] → [12.2363:2417]

                mcache_entry *entry = mcache.get(fg);

[11.77866]

[12.2417]

                mcache_entry *entry = mcache.get(fg_idx);

Replacement in crawl-ref/source/tilereg.cc at line 642 [11.54399]

B:BD[12.2444] → [12.2444:2490]

                    draw_mcache(entry, x, y);

[12.2444]

[12.2490]

                    pack_mcache(entry, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 644 [11.54399]

B:BD[12.2511] → [12.2511:2577]

                    add_quad(TEX_DOLL, TILEP_MONS_UNKNOWN, x, y);

[12.2511]

[12.2577]

                    m_buf_doll.add(TILEP_MONS_UNKNOWN, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 646 [11.54399]
B:BD[12.2591] → [12.2591:2632]
```
            else if (fg == TILEP_PLAYER)
```
[12.2591]
[12.2632]
```
            else if (fg_idx == TILEP_PLAYER)
```
Replacement in crawl-ref/source/tilereg.cc at line 648 [11.54399]
B:BD[12.2646] → [12.2646:2681]
```
                draw_player(x, y);
```
[12.2646]
[11.77926]
```
                pack_player(x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 650 [11.54399]
B:BD[11.77940] → [12.2682:2724]
```
            else if (fg >= TILE_MAIN_MAX)
```
[11.77940]
[12.2724]
```
            else if (fg_idx >= TILE_MAIN_MAX)
```

Replacement in crawl-ref/source/tilereg.cc at line 652 [11.54399]

B:BD[12.2738] → [12.2738:2784]

                add_quad(TEX_DOLL, fg, x, y);

[12.2738]

[12.2784]

                m_buf_doll.add(fg_idx, x, y);

Deletion in crawl-ref/source/tilereg.cc at line 654 [11.54399]
∅:D[12.2798] → [11.77940:77974]
B:BD[11.77940] → [11.77940:77974]
B:BD[11.78263] → [11.78263:78269]
```
            tile += 2;
        }
    }
```

Replacement in crawl-ref/source/tilereg.cc at line 655 [11.54399]

B:BD[11.78660] → [11.78660:78951]

    if (m_verts.size() > 0)
    {
        m_image->m_textures[TEX_DOLL].bind();
        glVertexPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].pos_x);
        glTexCoordPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].tex_x);
        glDrawArrays(GL_QUADS, 0, m_verts.size());
    }

[11.78371]

[11.78951]

            pack_foreground(bg, fg, x, y);

Deletion in crawl-ref/source/tilereg.cc at line 657 [11.54399]

B:BD[11.78952] → [11.78952:79238]

    tile = 0;
    m_verts.clear();
    for (int y = 0; y < crawl_view.viewsz.y; y++)
        for (int x = 0; x < crawl_view.viewsz.x; x++)
        {
            unsigned int fg = m_tileb[tile];
            unsigned int bg = m_tileb[tile + 1];
            draw_foreground(bg, fg, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 660 [11.54399]

B:BD[11.79272] → [15.927:1060]

    draw_cursor(CURSOR_TUTORIAL, TILE_TUTORIAL_CURSOR);
    draw_cursor(CURSOR_MOUSE, see_grid(m_cursor[CURSOR_MOUSE]) ? TILE_CURSOR

[11.79272]

[15.1060]

    pack_cursor(CURSOR_TUTORIAL, TILE_TUTORIAL_CURSOR);
    pack_cursor(CURSOR_MOUSE, see_grid(m_cursor[CURSOR_MOUSE]) ? TILE_CURSOR

Replacement in crawl-ref/source/tilereg.cc at line 667 [11.54399]
B:BD[15.1243] → [15.1243:1295]
```
        add_quad(TEX_DEFAULT, TILE_TUTORIAL_CURSOR,
```
[15.1243]
[15.1295]
```
        m_buf_main.add(TILE_TUTORIAL_CURSOR,
```

Deletion in crawl-ref/source/tilereg.cc at line 670 [11.54399]

B:BD[15.1388] → [15.1388:1394]

B:BD[15.1394] → [16.741:1030]

    }
    if (m_verts.size() > 0)
    {
        m_image->m_textures[TEX_DEFAULT].bind();
        glVertexPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].pos_x);
        glTexCoordPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].tex_x);
        glDrawArrays(GL_QUADS, 0, m_verts.size());

Deletion in crawl-ref/source/tilereg.cc at line 672 [11.54399]
B:BD[16.1037] → [16.1037:1058]
```
    m_verts.clear();
```
Replacement in crawl-ref/source/tilereg.cc at line 684 [11.54399]
B:BD[16.1459] → [16.1459:1501]
```
        add_quad(TEX_DEFAULT, idx, x, y);
```
[16.1459]
[16.1501]
```
        m_buf_main.add(idx, x, y);
```
Replacement in crawl-ref/source/tilereg.cc at line 686 [11.54399]
∅:D[15.1395] → [11.79272:79300]
∅:D[16.1507] → [11.79272:79300]
B:BD[11.79272] → [11.79272:79300]
```
    if (m_verts.size() > 0)
```
[16.1507]
[11.79300]
```
}
void DungeonRegion::render()
{
    if (m_dirty)
```

Replacement in crawl-ref/source/tilereg.cc at line 692 [11.54399]

B:BD[11.79306] → [11.79306:79560]

        m_image->m_textures[TEX_DEFAULT].bind();
        glVertexPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].pos_x);
        glTexCoordPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].tex_x);
        glDrawArrays(GL_QUADS, 0, m_verts.size());

[11.79306]

[11.79560]

        pack_buffers();
        m_dirty = false;

Insertion in crawl-ref/source/tilereg.cc at line 695 [11.54399]

[11.79566]


    set_transform();
    m_buf_dngn.draw();
    m_buf_doll.draw();
    m_buf_main.draw();

Replacement in crawl-ref/source/tilereg.cc at line 1044 [11.54399]

∅:D[14.1149] → [11.88336:88400]

B:BD[11.88336] → [11.88336:88400]

    m_flavour(NULL), m_cursor(NO_CURSOR), m_need_to_pack(false)

[14.1149]

[11.88400]

    m_flavour(NULL),
    m_buf_dngn(&im->m_textures[TEX_DUNGEON]),
    m_buf_main(&im->m_textures[TEX_DEFAULT]),
    m_cursor(NO_CURSOR)

Replacement in crawl-ref/source/tilereg.cc at line 1059 [11.54399]
B:BD[11.88523] → [11.88523:88544]
```
    m_verts.clear();
```
[11.88523]
[11.88544]
```
    m_buf_dngn.clear();
    m_buf_main.clear();
```
Replacement in crawl-ref/source/tilereg.cc at line 1082 [11.54399]
B:BD[11.88988] → [11.88988:89015]
```
    m_need_to_pack = true;
```
[11.88988]
[11.89015]
```
    m_dirty = true;
```
Replacement in crawl-ref/source/tilereg.cc at line 1095 [11.54399]
B:BD[11.89230] → [11.89230:89257]
```
    m_need_to_pack = true;
```
[11.89230]
[11.89257]
```
    m_dirty = true;
```

Replacement in crawl-ref/source/tilereg.cc at line 1100 [11.54399]

B:BD[11.89293] → [11.89293:89339]

    if (m_need_to_pack)
        pack_verts();

[11.89293]

[11.89339]

    if (m_dirty)
    {
        pack_buffers();
        m_dirty = false;
    }

Replacement in crawl-ref/source/tilereg.cc at line 1106 [11.54399]
B:BD[11.89340] → [11.89340:89369]
```
    if (m_verts.size() == 0)
```
[11.89340]
[11.89369]
```
    if (m_buf_dngn.empty() && m_buf_main.empty())
```

Deletion in crawl-ref/source/tilereg.cc at line 1108 [11.54399]

B:BD[11.89385] → [11.89385:89875]


    glLoadIdentity();
    glTranslatef(sx + ox, sy + oy, 0);
    glScalef(dx, dy, 1);
    GLState state;
    state.array_vertex = true;
    state.array_texcoord = true;
    state.blend = true;
    state.texture = true;
    GLStateManager::set(state);
    m_image->m_textures[TEX_DUNGEON].bind();
    glVertexPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].pos_x);
    glTexCoordPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].tex_x);
    glDrawArrays(GL_QUADS, 0, m_base_verts);

Replacement in crawl-ref/source/tilereg.cc at line 1109 [11.54399]

B:BD[11.89876] → [11.89876:89994]

    m_image->m_textures[TEX_DEFAULT].bind();
    glDrawArrays(GL_QUADS, m_base_verts, m_verts.size() - m_base_verts);

[11.89876]

[14.1150]

    set_transform();
    m_buf_dngn.draw();
    m_buf_main.draw();

Replacement in crawl-ref/source/tilereg.cc at line 1148 [11.54399]
B:BD[11.90846] → [13.6300:6359]
```
    add_quad(TEX_DEFAULT, idx, x, y, ofs_x, ofs_y, false);
```
[11.90846]
[11.90987]
```
    m_buf_main.add(idx, x, y, ofs_x, ofs_y, false);
```
Replacement in crawl-ref/source/tilereg.cc at line 1151 [11.54399]
B:BD[11.90990] → [11.90990:91025]
```
void InventoryRegion::pack_verts()
```
[11.90990]
[11.91025]
```
void InventoryRegion::pack_buffers()
```
Replacement in crawl-ref/source/tilereg.cc at line 1153 [11.54399]
B:BD[11.91027] → [11.91027:91076]
```
    m_need_to_pack = false;
    m_verts.clear();
```
[11.91027]
[11.91076]
```
    m_buf_dngn.clear();
    m_buf_main.clear();
```

Replacement in crawl-ref/source/tilereg.cc at line 1176 [11.54399]

B:BD[8.1583] → [8.1583:1644]

                add_quad(TEX_DUNGEON, env.tile_default.floor

[8.1583]

[8.1644]

                m_buf_dngn.add(env.tile_default.floor

Replacement in crawl-ref/source/tilereg.cc at line 1180 [11.54399]

B:BD[11.91704] → [11.91704:91765]

                add_quad(TEX_DUNGEON, TILE_ITEM_SLOT, x, y);

[11.91704]

[11.91765]

                m_buf_dngn.add(TILE_ITEM_SLOT, x, y);

Deletion in crawl-ref/source/tilereg.cc at line 1183 [11.54399]

B:BD[11.91781] → [11.91781:91873]


    // Make note of how many verts are used by the base
    m_base_verts = m_verts.size();

Replacement in crawl-ref/source/tilereg.cc at line 1200 [11.54399]

B:BD[11.92262] → [11.92262:92340]

                    add_quad(TEX_DEFAULT, TILE_ITEM_SLOT_EQUIP_CURSED, x, y);

[11.92262]

[11.92340]

                    m_buf_main.add(TILE_ITEM_SLOT_EQUIP_CURSED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1202 [11.54399]

B:BD[11.92361] → [11.92361:92432]

                    add_quad(TEX_DEFAULT, TILE_ITEM_SLOT_EQUIP, x, y);

[11.92361]

[6.347]

                    m_buf_main.add(TILE_ITEM_SLOT_EQUIP, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1205 [11.54399]

B:BD[19.2310] → [6.349:409]

                    add_quad(TEX_DEFAULT, TILE_MESH, x, y);

[19.2310]

[19.2504]

                    m_buf_main.add(TILE_MESH, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1208 [11.54399]

B:BD[6.461] → [6.461:529]

                add_quad(TEX_DEFAULT, TILE_ITEM_SLOT_CURSED, x, y);

[6.461]

[11.92565]

                m_buf_main.add(TILE_ITEM_SLOT_CURSED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1212 [11.54399]

B:BD[11.92665] → [11.92665:92735]

                add_quad(TEX_DEFAULT, TILE_ITEM_SLOT_SELECTED, x, y);

[11.92665]

[11.92735]

                m_buf_main.add(TILE_ITEM_SLOT_SELECTED, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1215 [11.54399]

B:BD[11.92783] → [11.92783:92841]

                add_quad(TEX_DEFAULT, TILE_CURSOR, x, y);

[11.92783]

[11.92841]

                m_buf_main.add(TILE_CURSOR, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1218 [11.54399]

B:BD[11.92869] → [11.92869:92925]

                add_quad(TEX_DEFAULT, item.tile, x, y);

[11.92869]

[11.92925]

                m_buf_main.add(item.tile, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1253 [11.54399]

B:BD[7.1830] → [7.1830:1902]

                add_quad(TEX_DEFAULT, item.special, x, y, 0, 0, false);

[7.1830]

[11.93826]

                m_buf_main.add(item.special, x, y, 0, 0, false);

Replacement in crawl-ref/source/tilereg.cc at line 1256 [11.54399]

B:BD[11.93873] → [21.553:632]

                add_quad(TEX_DEFAULT, TILE_TRIED, x, y, 0, TILE_Y / 2, false);

[11.93873]

[22.1391]

                m_buf_main.add(TILE_TRIED, x, y, 0, TILE_Y / 2, false);

Replacement in crawl-ref/source/tilereg.cc at line 1259 [11.54399]

B:BD[22.1440] → [22.1440:1496]

                add_quad(TEX_DEFAULT, TILE_MESH, x, y);

[22.1440]

[11.93930]

                m_buf_main.add(TILE_MESH, x, y);

Replacement in crawl-ref/source/tilereg.cc at line 1275 [11.54399]
B:BD[11.94240] → [11.94240:94271]
```
        m_need_to_pack = true;
```
[11.94240]
[11.94271]
```
        m_dirty = true;
```
Replacement in crawl-ref/source/tilereg.cc at line 1285 [11.54399]
B:BD[11.94475] → [11.94475:94502]
```
    m_need_to_pack = true;
```
[11.94475]
[11.94502]
```
    m_dirty = true;
```
Insertion in crawl-ref/source/tilereg.cc at line 1641 [11.54399]
[17.2320]
[11.105539]
```
    m_dirty(true),
```

Deletion in crawl-ref/source/tilereg.cc at line 1692 [11.54399]

B:BD[11.107406] → [11.107406:107540]


struct map_vertex
{
    float x;
    float y;
    unsigned char r;
    unsigned char g;
    unsigned char b;
    unsigned char a;
};

Replacement in crawl-ref/source/tilereg.cc at line 1693 [11.54399]
B:BD[11.107541] → [11.107541:107566]
```
void MapRegion::render()
```
[11.107541]
[11.107566]
```
void MapRegion::pack_buffers()
```

Replacement in crawl-ref/source/tilereg.cc at line 1695 [11.54399]

B:BD[11.107568] → [11.107568:108183]

    if (m_min_gx > m_max_gx || m_min_gy > m_max_gy)
        return;
    // [enne] - GL_POINTS should probably be used here, but there's (apparently)
    // a bug in the OpenGL driver that I'm using and it doesn't respect
    // glPointSize unless GL_SMOOTH_POINTS is on.  GL_SMOOTH_POINTS is
    // *terrible* for performance if it has to fall back on software rendering,
    // so instead we'll just make quads.
    glLoadIdentity();
    glTranslatef(sx + ox, sy + oy, 0);
    glScalef(dx, dx, 1);
    std::vector<map_vertex> verts;
    verts.reserve(4 * (m_max_gx - m_min_gx + 1) * (m_max_gy - m_min_gy + 1));

[11.107568]

[11.108183]

    m_buf_map.clear();
    m_buf_lines.clear();

Deletion in crawl-ref/source/tilereg.cc at line 1704 [11.54399]

B:BD[11.108417] → [11.108417:108418]

B:BD[11.108418] → [10.4179:4255]

∅:D[10.4255] → [11.108512:108934]

B:BD[11.108512] → [11.108512:108934]


            int pos_x = x - m_min_gx;
            int pos_y = y - m_min_gy;
            map_vertex v;
            v.r = map_colours[c][0];
            v.g = map_colours[c][1];
            v.b = map_colours[c][2];
            v.a = 255;
            v.x = pos_x;
            v.y = pos_y;
            verts.push_back(v);
            v.x = pos_x;
            v.y = pos_y + 1;
            verts.push_back(v);
            v.x = pos_x + 1;
            v.y = pos_y + 1;
            verts.push_back(v);

Replacement in crawl-ref/source/tilereg.cc at line 1705 [11.54399]

B:BD[11.108935] → [11.108935:109021]

            v.x = pos_x + 1;
            v.y = pos_y;
            verts.push_back(v);

[11.108935]

[11.109021]

            float pos_x = x - m_min_gx;
            float pos_y = y - m_min_gy;
            m_buf_map.add(pos_x, pos_y, pos_x + 1, pos_y + 1, map_colours[c]);

Deletion in crawl-ref/source/tilereg.cc at line 1710 [11.54399]

B:BD[11.109037] → [11.109037:109412]


    GLState state;
    state.array_vertex = true;
    state.array_colour = true;
    GLStateManager::set(state);
    glVertexPointer(2, GL_FLOAT, sizeof(map_vertex), &verts[0].x);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(map_vertex), &verts[0].r);
    glDrawArrays(GL_QUADS, 0, verts.size());
    // TODO enne - make sure we're drawing within the map square here...

Deletion in crawl-ref/source/tilereg.cc at line 1714 [11.54399]
B:BD[11.109503] → [11.109503:109584]
```
    verts.clear();
    glLoadIdentity();
    glTranslatef(sx + ox, sy + oy, 0);
```
Deletion in crawl-ref/source/tilereg.cc at line 1715 [11.54399]
B:BD[11.109585] → [11.109585:109603]
```
    map_vertex v;
```

Replacement in crawl-ref/source/tilereg.cc at line 1716 [11.54399]

B:BD[11.109645] → [11.109645:109747]

    v.r = map_colours[c][0];
    v.g = map_colours[c][1];
    v.b = map_colours[c][2];
    v.a = 255;

[11.109645]

[11.109747]

    float pos_sx = (m_win_start.x - m_min_gx);
    float pos_sy = (m_win_start.y - m_min_gy);
    float pos_ex = (m_win_end.x - m_min_gx) + 1 / (float)dx;
    float pos_ey = (m_win_end.y - m_min_gy) + 1 / (float)dy;

Replacement in crawl-ref/source/tilereg.cc at line 1721 [11.54399]

B:BD[11.109748] → [10.4256:4342]

∅:D[10.4342] → [11.109854:109878]

B:BD[11.109854] → [11.109854:109878]

    v.x = dx * (m_win_start.x - m_min_gx);
    v.y = dy * (m_win_start.y - m_min_gy);
    verts.push_back(v);

[11.109748]

[11.109878]

    m_buf_lines.add_square(pos_sx, pos_sy, pos_ex, pos_ey, map_colours[c]);
}

Replacement in crawl-ref/source/tilereg.cc at line 1724 [11.54399]
B:BD[11.109879] → [10.4343:4388]
∅:D[10.4388] → [11.109934:109958]
B:BD[11.109934] → [11.109934:109958]
```
    v.y = dy * (m_win_end.y - m_min_gy) + 1;
    verts.push_back(v);
```
[11.109879]
[11.109958]
```
void MapRegion::render()
{
    if (m_min_gx > m_max_gx || m_min_gy > m_max_gy)
        return;
```
Replacement in crawl-ref/source/tilereg.cc at line 1729 [11.54399]
B:BD[11.109959] → [10.4389:4434]
∅:D[10.4434] → [11.110014:110038]
B:BD[11.110014] → [11.110014:110038]
```
    v.x = dx * (m_win_end.x - m_min_gx) + 1;
    verts.push_back(v);
```
[11.109959]
[11.110038]
```
    if (m_dirty)
    {
        pack_buffers();
        m_dirty = false;
    }
```

Replacement in crawl-ref/source/tilereg.cc at line 1735 [11.54399]

B:BD[11.110039] → [10.4435:4478]

∅:D[10.4478] → [11.110092:110307]

B:BD[11.110092] → [11.110092:110307]

    v.y = dy * (m_win_start.y - m_min_gy);
    verts.push_back(v);
    glVertexPointer(2, GL_FLOAT, sizeof(map_vertex), &verts[0].x);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(map_vertex), &verts[0].r);
    glDrawArrays(GL_LINE_LOOP, 0, verts.size());

[11.110039]

[11.110307]

    set_transform();
    m_buf_map.draw();
    m_buf_lines.draw();

Insertion in crawl-ref/source/tilereg.cc at line 1745 [11.54399]
[11.110477]
[11.110477]
```
    m_dirty = true;
```
Insertion in crawl-ref/source/tilereg.cc at line 1769 [11.54399]
[11.110998]
[11.110998]
```
    m_dirty = true;
```
Insertion in crawl-ref/source/tilereg.cc at line 1789 [11.54399]
[11.111287]
[11.111287]
```
    m_buf_map.clear();
    m_buf_lines.clear();
```

Replacement in crawl-ref/source/tilereg.cc at line 2511 [11.54399]

B:BD[23.6996] → [23.6996:7083]

    glLoadIdentity();
    glTranslatef(sx + ox, sy + oy, 0);
    glScalef(dx, dy, 1);

[23.6996]

[23.7083]

    set_transform();

Replacement in crawl-ref/source/tilebuf.h at line 61 [23.12469]
B:BD[23.13426] → [23.13426:13443]
```
class VertBuffer
```
[23.13426]
[23.13443]
```
class VertBuffer : public std::vector<V>
```
Insertion in crawl-ref/source/tilebuf.h at line 64 [23.12469]
[23.13453]
[23.13453]
```
    typedef V Vert;
```

Replacement in crawl-ref/source/tilebuf.h at line 68 [23.12469]

B:BD[23.13507] → [23.13507:13536]

    void add(const V& vert);

[23.13507]

[23.13536]

    // Vertices are fat, so to avoid an extra copy of all the data members,
    // pre-construct the vertex and return a reference to it.

Deletion in crawl-ref/source/tilebuf.h at line 71 [23.12469]
B:BD[23.13555] → [23.13555:13556]
Replacement in crawl-ref/source/tilebuf.h at line 72 [23.12469]
B:BD[23.13579] → [23.13579:13597]
```
    void clear();
```
[23.13579]
[23.13597]
Deletion in crawl-ref/source/tilebuf.h at line 74 [23.12469]
B:BD[23.13608] → [23.13608:13636]
```
    std::vector<V> m_verts;
```
Insertion in crawl-ref/source/tilebuf.h at line 92 [23.12469]
[9.1484]
[23.14040]

Insertion in crawl-ref/source/tilebuf.h at line 94 [23.12469]

[23.14081]

    void add(int idx, int x, int y, int ox = 0, int oy = 0, bool centre = true, int ymax = -1);

Deletion in crawl-ref/source/tilebuf.h at line 123 [23.12469]
B:BD[23.14834] → [23.14834:14903]
```
{
}
template<class V>
inline void VertBuffer<V>::add(const V& vert)
```
Deletion in crawl-ref/source/tilebuf.h at line 124 [23.12469]
B:BD[23.14905] → [23.14905:14934]
```
    m_verts.push_back(vert);
```

Deletion in crawl-ref/source/tilebuf.h at line 128 [23.12469]

B:BD[23.14991] → [23.14991:15138]

{
    int last = m_verts.size();
    m_verts.resize(last + 1);
    return (m_verts[last]);
}
template<class V>
inline void VertBuffer<V>::clear()

Replacement in crawl-ref/source/tilebuf.h at line 129 [23.12469]

B:BD[23.15140] → [23.15140:15161]

    m_verts.clear();

[23.15140]

[23.15161]

    size_t last = std::vector<V>::size();
    std::vector<V>::resize(last + 1);
    return ((*this)[last]);

Insertion in crawl-ref/source/tilebuf.cc at line 30 [23.15207]
[23.15848]
[23.15848]
```
#if DEBUG
```
Insertion in crawl-ref/source/tilebuf.cc at line 47 [23.15207]
[23.16178]
[23.16178]
```
#endif
```
Replacement in crawl-ref/source/tilebuf.cc at line 52 [23.15207]
B:BD[23.16230] → [23.16230:16259]
```
    if (m_verts.size() == 0)
```
[23.16230]
[23.16259]
```
    if (size() == 0)
```
Replacement in crawl-ref/source/tilebuf.cc at line 55 [23.15207]
B:BD[23.16276] → [23.16276:16320]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.16276]
[23.16320]
```
    ASSERT(_valid(size(), m_prim));
```

Replacement in crawl-ref/source/tilebuf.cc at line 66 [23.15207]

B:BD[23.16525] → [23.16525:16710]

    glVertexPointer(2, GL_FLOAT, sizeof(PTVert), &m_verts[0].pos_x);
    glTexCoordPointer(2, GL_FLOAT, sizeof(PTVert), &m_verts[0].tex_x);
    glDrawArrays(m_prim, 0, m_verts.size());

[23.16525]

[23.16710]

    glVertexPointer(2, GL_FLOAT, sizeof(Vert), &(*this)[0].pos_x);
    glTexCoordPointer(2, GL_FLOAT, sizeof(Vert), &(*this)[0].tex_x);
    glDrawArrays(m_prim, 0, size());

Replacement in crawl-ref/source/tilebuf.cc at line 74 [23.15207]
B:BD[23.16764] → [23.16764:16793]
```
    if (m_verts.size() == 0)
```
[23.16764]
[23.16793]
```
    if (size() == 0)
```
Replacement in crawl-ref/source/tilebuf.cc at line 77 [23.15207]
B:BD[23.16810] → [23.16810:16854]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.16810]
[23.16854]
```
    ASSERT(_valid(size(), m_prim));
```
Replacement in crawl-ref/source/tilebuf.cc at line 84 [23.15207]
B:BD[23.16980] → [23.16980:17006]
```
    state.texture = true;
```
[23.16980]
[23.17006]
```
    state.texture = false;
```

Replacement in crawl-ref/source/tilebuf.cc at line 87 [23.15207]

B:BD[23.17039] → [23.17039:17227]

    glVertexPointer(2, GL_FLOAT, sizeof(PCVert), &m_verts[0].pos_x);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PCVert), &m_verts[0].col);
    glDrawArrays(m_prim, 0, m_verts.size());

[23.17039]

[23.17227]

    glVertexPointer(2, GL_FLOAT, sizeof(Vert), &(*this)[0].pos_x);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vert), &(*this)[0].col);
    glDrawArrays(m_prim, 0, size());

Replacement in crawl-ref/source/tilebuf.cc at line 95 [23.15207]
B:BD[23.17282] → [23.17282:17311]
```
    if (m_verts.size() == 0)
```
[23.17282]
[23.17311]
```
    if (size() == 0)
```
Replacement in crawl-ref/source/tilebuf.cc at line 98 [23.15207]
B:BD[23.17328] → [23.17328:17372]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.17328]
[23.17372]
```
    ASSERT(_valid(size(), m_prim));
```

Replacement in crawl-ref/source/tilebuf.cc at line 110 [23.15207]

B:BD[23.17608] → [23.17608:17870]

    glVertexPointer(2, GL_FLOAT, sizeof(PTCVert), &m_verts[0].pos_x);
    glTexCoordPointer(2, GL_FLOAT, sizeof(PTCVert), &m_verts[0].tex_x);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PTCVert), &m_verts[0].col);
    glDrawArrays(m_prim, 0, m_verts.size());

[23.17608]

[23.17870]

    glVertexPointer(2, GL_FLOAT, sizeof(Vert), &(*this)[0].pos_x);
    glTexCoordPointer(2, GL_FLOAT, sizeof(Vert), &(*this)[0].tex_x);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vert), &(*this)[0].col);
    glDrawArrays(m_prim, 0, size());

Replacement in crawl-ref/source/tilebuf.cc at line 129 [23.15207]
B:BD[23.18220] → [23.18220:18264]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.18220]
[23.18264]
```
    ASSERT(_valid(size(), m_prim));
```
Replacement in crawl-ref/source/tilebuf.cc at line 135 [23.15207]
B:BD[23.18390] → [23.18390:18434]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.18390]
[23.18434]
```
    ASSERT(_valid(size(), m_prim));
```

Insertion in crawl-ref/source/tilebuf.cc at line 161 [23.15207]

[23.19120]


    size_t last = std::vector<Vert>::size();
    std::vector<Vert>::resize(last + 4);

Replacement in crawl-ref/source/tilebuf.cc at line 166 [23.15207]
B:BD[23.19127] → [23.19127:19159]
```
        PTVert &v = get_next();
```
[23.19127]
[23.19159]
```
        Vert &v = (*this)[last];
```
Replacement in crawl-ref/source/tilebuf.cc at line 173 [23.15207]
B:BD[23.19275] → [23.19275:19307]
```
        PTVert &v = get_next();
```
[23.19275]
[23.19307]
```
        Vert &v = (*this)[last + 1];
```
Replacement in crawl-ref/source/tilebuf.cc at line 180 [23.15207]
B:BD[23.19423] → [23.19423:19455]
```
        PTVert &v = get_next();
```
[23.19423]
[23.19455]
```
        Vert &v = (*this)[last + 2];
```
Replacement in crawl-ref/source/tilebuf.cc at line 187 [23.15207]
B:BD[23.19571] → [23.19571:19603]
```
        PTVert &v = get_next();
```
[23.19571]
[23.19603]
```
        Vert &v = (*this)[last + 3];
```
Insertion in crawl-ref/source/tilebuf.cc at line 193 [23.15207]
[23.19713]
[23.19713]
```
    ASSERT(_valid(size(), m_prim));
}
```

Replacement in crawl-ref/source/tilebuf.cc at line 197 [23.15207]

B:BD[23.19714] → [23.19714:19758]

    ASSERT(_valid(m_verts.size(), m_prim));

[23.19714]

[23.19758]

void TileBuffer::add(int idx, int x, int y, int ox, int oy, bool centre, int ymax)
{
    float pos_sx = x;
    float pos_sy = y;
    float pos_ex, pos_ey, tex_sx, tex_sy, tex_ex, tex_ey;
    TilesTexture *tex = (TilesTexture *)m_tex;
    tex->get_coords(idx, ox, oy, pos_sx, pos_sy, pos_ex, pos_ey,
                    tex_sx, tex_sy, tex_ex, tex_ey, centre, ymax);
    size_t last = std::vector<Vert>::size();
    std::vector<Vert>::resize(last + 4);
    {
        Vert &v = (*this)[last];
        v.pos_x = pos_sx;
        v.pos_y = pos_sy;
        v.tex_x = tex_sx;
        v.tex_y = tex_sy;
    }
    {
        Vert &v = (*this)[last + 1];
        v.pos_x = pos_sx;
        v.pos_y = pos_ey;
        v.tex_x = tex_sx;
        v.tex_y = tex_ey;
    }
    {
        Vert &v = (*this)[last + 2];
        v.pos_x = pos_ex;
        v.pos_y = pos_ey;
        v.tex_x = tex_ex;
        v.tex_y = tex_ey;
    }
    {
        Vert &v = (*this)[last + 3];
        v.pos_x = pos_ex;
        v.pos_y = pos_sy;
        v.tex_x = tex_ex;
        v.tex_y = tex_sy;
    }

Replacement in crawl-ref/source/tilebuf.cc at line 242 [23.15207]
B:BD[23.19761] → [23.19761:19811]
```
void TileBuffer::set_tex(const TilesTexture *tex)
```
[23.19761]
[23.19811]
```
void TileBuffer::set_tex(const TilesTexture *new_tex)
```
Replacement in crawl-ref/source/tilebuf.cc at line 244 [23.15207]
B:BD[23.19813] → [23.19813:19847]
```
    ASSERT(tex);
    m_tex = tex;
```
[23.19813]
[23.19847]
```
    ASSERT(new_tex);
    m_tex = new_tex;
```

Insertion in crawl-ref/source/tilebuf.cc at line 251 [23.15207]

[23.19945]

// [enne] - GL_POINTS should probably be used here, but there's (apparently)
// a bug in the OpenGL driver that I'm using and it doesn't respect
// glPointSize unless GL_SMOOTH_POINTS is on.  GL_SMOOTH_POINTS is
// *terrible* for performance if it has to fall back on software rendering,
// so instead we'll just make quads.

Replacement in crawl-ref/source/tilebuf.cc at line 264 [23.15207]
B:BD[23.20142] → [23.20142:20174]
```
        PCVert &v = get_next();
```
[23.20142]
[23.20174]
```
        Vert &v = get_next();
```
Replacement in crawl-ref/source/tilebuf.cc at line 270 [23.15207]
B:BD[23.20259] → [23.20259:20291]
```
        PCVert &v = get_next();
```
[23.20259]
[23.20291]
```
        Vert &v = get_next();
```
Replacement in crawl-ref/source/tilebuf.cc at line 276 [23.15207]
B:BD[23.20376] → [23.20376:20408]
```
        PCVert &v = get_next();
```
[23.20376]
[23.20408]
```
        Vert &v = get_next();
```
Replacement in crawl-ref/source/tilebuf.cc at line 282 [23.15207]
B:BD[23.20493] → [23.20493:20525]
```
        PCVert &v = get_next();
```
[23.20493]
[23.20525]
```
        Vert &v = get_next();
```
Replacement in crawl-ref/source/tilebuf.cc at line 288 [23.15207]
B:BD[23.20605] → [23.20605:20649]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.20605]
[23.20649]
```
    ASSERT(_valid(size(), m_prim));
```
Replacement in crawl-ref/source/tilebuf.cc at line 302 [23.15207]
B:BD[23.20939] → [23.20939:20971]
```
        PCVert &v = get_next();
```
[23.20939]
[23.20971]
```
        Vert &v = get_next();
```
Replacement in crawl-ref/source/tilebuf.cc at line 308 [23.15207]
B:BD[23.21056] → [23.21056:21088]
```
        PCVert &v = get_next();
```
[23.21056]
[23.21088]
```
        Vert &v = get_next();
```
Replacement in crawl-ref/source/tilebuf.cc at line 314 [23.15207]
B:BD[23.21168] → [23.21168:21212]
```
    ASSERT(_valid(m_verts.size(), m_prim));
```
[23.21168]
[23.21212]
```
    ASSERT(_valid(size(), m_prim));
```

Insertion in crawl-ref/source/makefile_tiles.unix at line 323 [24.5756330]

[13.1278420]

[24.5763499]


# STL is bad in debug.  Always compile this file with optimizations.
tilebuf.o: tilebuf.cc $(TILEDEFHDRS)
	${CXX} ${CFLAGS} -O2 -c $< -o $@

Insertion in crawl-ref/source/makefile_tiles.mgw at line 252 [24.5750607]

[24.5755896]

[5.3148]

# STL is bad in debug.  Always compile this file with optimizations.
$(OPATH)/tilebuf.o: tilebuf.cc $(TILEDEFHDRS)
		${CXX} ${CFLAGS} -O2 -o $@ -c $<

Clean up tiles code to use the VertBuffer classes.

Dependencies

In channels

Change contents

Deletion in crawl-ref/source/tiletex.h at line 15 [11.6812]

Insertion in crawl-ref/source/tiletex.h at line 16 [11.6812]

Replacement in crawl-ref/source/tiletex.h at line 67 [11.6812]

Replacement in crawl-ref/source/tiletex.h at line 73 [11.6812]

Replacement in crawl-ref/source/tiletex.h at line 80 [11.6812]

Replacement in crawl-ref/source/tiletex.h at line 91 [11.6812]

Replacement in crawl-ref/source/tiletex.cc at line 145 [11.8197]

Insertion in crawl-ref/source/tilereg.h at line 92 [11.45514]

Deletion in crawl-ref/source/tilereg.h at line 237 [11.45514]

Deletion in crawl-ref/source/tilereg.h at line 238 [11.45514]

Insertion in crawl-ref/source/tilereg.h at line 239 [11.45514]

Replacement in crawl-ref/source/tilereg.h at line 290 [11.45514]

Insertion in crawl-ref/source/tilereg.h at line 307 [11.45514]

Replacement in crawl-ref/source/tilereg.h at line 359 [11.45514]

Deletion in crawl-ref/source/tilereg.h at line 364 [11.45514]

Replacement in crawl-ref/source/tilereg.h at line 367 [11.45514]

Replacement in crawl-ref/source/tilereg.h at line 370 [11.45514]

Insertion in crawl-ref/source/tilereg.h at line 420 [11.45514]

Insertion in crawl-ref/source/tilereg.h at line 427 [11.45514]

Replacement in crawl-ref/source/tilereg.cc at line 53 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 55 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 61 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 65 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 69 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 73 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 77 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 81 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 85 [11.54399]

Insertion in crawl-ref/source/tilereg.cc at line 190 [11.54399]

Insertion in crawl-ref/source/tilereg.cc at line 208 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 219 [11.54399]

Insertion in crawl-ref/source/tilereg.cc at line 235 [11.54399]

Deletion in crawl-ref/source/tilereg.cc at line 250 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 252 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 258 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 265 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 268 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 271 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 274 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 279 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 281 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 284 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 286 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 289 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 413 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 416 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 462 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 466 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 472 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 480 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 484 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 491 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 498 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 503 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 508 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 513 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 518 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 523 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 526 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 532 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 537 [11.54399]

Replacement in crawl-ref/source/tilereg.cc at line 542 [11.54399]