Changeset 670


Ignore:
Timestamp:
May 16, 2011, 2:37:27 AM (9 years ago)
Author:
Sam Hocevar
Message:

imlib: started refactoring the dirty rectangle system.

Location:
abuse/trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/TODO

    r669 r670  
    5757--------
    5858- move to vec2i:
    59   - AddDirty !!
    60   - update_dirty
    6159  - scale_put, scale_put_trans
    6260  - tint_area, darken_area
     
    7775refactor image::Line to merge loops
    7876
     77event::redraw::x1,y1...
     78view::cx1,cx2...
     79
  • abuse/trunk/src/automap.cpp

    r668 r670  
    2626
    2727  long sx,ex,sy,ey,x,y,window_xstart,window_ystart,
    28                        window_xend,window_yend,centerx,centery,
     28                       window_xend,window_yend,
    2929                       draw_xstart,draw_ystart,
    3030                       i,j;
     
    3838  window_xend=automap_window->x2();
    3939  window_yend=automap_window->y2();
    40   centerx=(window_xstart+window_xend)/2;
    41   centery=(window_ystart+window_yend)/2;
     40  vec2i center((window_xstart+window_xend)/2, (window_ystart+window_yend)/2);
    4241
    4342  sx=x/f_wid-w/2;                // start drawing with this foretile
     
    4847  if (sx<0)                       // does the map scroll past the left side ?
    4948  { sx=0;                         // yes, start drawing at 0
    50     draw_xstart=centerx-(x*AUTOTILE_WIDTH/f_wid);
     49    draw_xstart=center.x-(x*AUTOTILE_WIDTH/f_wid);
    5150  }
    5251  else
    53     draw_xstart=centerx-(x*AUTOTILE_WIDTH/f_wid-sx*AUTOTILE_WIDTH);
     52    draw_xstart=center.x-(x*AUTOTILE_WIDTH/f_wid-sx*AUTOTILE_WIDTH);
    5453
    5554  if (sy<0)
    5655  {
    5756    sy=0;
    58     draw_ystart=centery-(y*AUTOTILE_HEIGHT/f_hi);
     57    draw_ystart=center.y-(y*AUTOTILE_HEIGHT/f_hi);
    5958  }
    6059  else
    61     draw_ystart=centery-(y*AUTOTILE_HEIGHT/f_hi-sy*AUTOTILE_HEIGHT);
     60    draw_ystart=center.y-(y*AUTOTILE_HEIGHT/f_hi-sy*AUTOTILE_HEIGHT);
    6261
    6362  // if view position hasn't changed, only update the blinking dot and return
     
    6564  {
    6665   automap_window->m_surf->Lock();
    67    automap_window->m_surf->AddDirty(centerx,centery,centerx + 1,centery + 1);
     66   automap_window->m_surf->AddDirty(center, center + vec2i(1));
    6867    if ((tick++)&4)
    69       automap_window->m_surf->PutPixel(vec2i(centerx,centery),255);
     68      automap_window->m_surf->PutPixel(center, 255);
    7069    else
    71       automap_window->m_surf->PutPixel(vec2i(centerx,centery),27);
     70      automap_window->m_surf->PutPixel(center, 27);
    7271   automap_window->m_surf->Unlock();
    7372    return ;
     
    9594    ex=foreground_width()-1; */
    9695
    97 
    98 
    99 
    100   // we are going to redraw the whole map, so make the dirty rect work easier by marking
    101   // everything dirty
    102   screen->AddDirty(window_xstart,window_ystart,window_xend+1,window_yend+1);
    103 
    104 
    105 
     96  // we are going to redraw the whole map, so make the dirty rect work
     97  // easier by marking everything dirty
     98  screen->AddDirty(vec2i(window_xstart, window_ystart),
     99                   vec2i(window_xend + 1, window_yend + 1));
    106100
    107101  // draw the tiles that will be around the border of the automap with PutImage
     
    149143  automap_window->m_surf->Lock();
    150144  if ((tick++)&4)
    151     automap_window->m_surf->PutPixel(vec2i(centerx,centery),255);
     145    automap_window->m_surf->PutPixel(center, 255);
    152146  else
    153     automap_window->m_surf->PutPixel(vec2i(centerx,centery),27);
     147    automap_window->m_surf->PutPixel(center, 27);
    154148  automap_window->m_surf->Unlock();
    155149
  • abuse/trunk/src/dev.cpp

    r668 r670  
    371371  int32_t xstep=(im->Size().x<<16)/new_width,
    372372       ystep=(im->Size().y<<16)/new_height,iy,ix,sx,ix_start,iy_start;
    373   screen->AddDirty(x, y, x + new_width, y + new_height);
     373  screen->AddDirty(vec2i(x, y), vec2i(x + new_width, y + new_height));
    374374
    375375  vec2i caa, cbb;
     
    412412  int32_t xstep=(im->Size().x<<16)/new_width,
    413413       ystep=(im->Size().y<<16)/new_height,iy,ix,sx,ix_start,iy_start;
    414   screen->AddDirty(x, y, x + new_width, y + new_height);
     414  screen->AddDirty(vec2i(x, y), vec2i(x + new_width, y + new_height));
    415415
    416416  vec2i caa, cbb;
  • abuse/trunk/src/endgame.cpp

    r668 r670  
    129129
    130130  }
    131   screen->AddDirty(x1, sy, x2 + 1, sy + mask_height);
     131  screen->AddDirty(vec2i(x1, sy), vec2i(x2 + 1, sy + mask_height));
    132132}
    133133
  • abuse/trunk/src/game.cpp

    r668 r670  
    667667
    668668  if(small_render)
    669     main_screen->AddDirty(v->cx1, v->cy1, (v->cx2 - v->cx1 + 1)*2 + v->cx1 + 1, v->cy1+(v->cy2 - v->cy1 + 1)*2 + 1);
     669    main_screen->AddDirty(vec2i(v->cx1, v->cy1), vec2i((v->cx2 - v->cx1 + 1)*2 + v->cx1 + 1, v->cy1+(v->cy2 - v->cy1 + 1)*2 + 1));
    670670  else
    671     main_screen->AddDirty(v->cx1, v->cy1, v->cx2 + 1, v->cy2 + 1);
     671    main_screen->AddDirty(vec2i(v->cx1, v->cy1), vec2i(v->cx2 + 1, v->cy2 + 1));
    672672
    673673  if(v->draw_solid != -1)      // fill the screen and exit..
     
    17861786                            case EV_REDRAW:
    17871787                            {
    1788                                 main_screen->AddDirty(ev.redraw.x1, ev.redraw.y1,
    1789                                     ev.redraw.x2 + 1, ev.redraw.y2 + 1);
     1788                                main_screen->AddDirty(vec2i(ev.redraw.x1, ev.redraw.y1),
     1789                                    vec2i(ev.redraw.x2 + 1, ev.redraw.y2 + 1));
    17901790                            } break;
    17911791                            case EV_MESSAGE:
     
    20452045void Game::draw(int scene_mode)
    20462046{
    2047     main_screen->AddDirty(0, 0, xres + 1, yres + 1);
     2047    main_screen->AddDirty(vec2i(0), vec2i(xres, yres));
    20482048
    20492049    main_screen->clear();
  • abuse/trunk/src/imlib/filter.cpp

    r665 r670  
    9797    vec2i span = bb - aa;
    9898
    99     screen->AddDirty(pos.x, pos.y, pos.x + span.x, pos.y + span.y);
     99    screen->AddDirty(pos, pos + span);
    100100
    101101    screen->Lock();
  • abuse/trunk/src/imlib/image.cpp

    r667 r670  
    160160        for(int j = 0; j < m_size.y; j++)
    161161            memset(scan_line(j), color, m_size.x);
    162     AddDirty(0, 0, m_size.x, m_size.y);
     162    AddDirty(vec2i(0), m_size);
    163163    Unlock();
    164164}
     
    272272    yi = p2.y; yc = p1.y;
    273273
    274     AddDirty(xc, yc, xi + 1, yi + 1);
     274    AddDirty(vec2i(xc, yc), vec2i(xi + 1, yi + 1));
    275275    dcx = p1.x; dcy = p1.y;
    276276    xc = (p2.x - p1.x);
     
    351351    vec2i span = bb - aa;
    352352
    353     AddDirty(pos.x, pos.y, pos.x + span.x, pos.y + span.y);
     353    AddDirty(pos, pos + span);
    354354
    355355    Lock();
     
    457457void image_descriptor::ReduceDirties()
    458458{
    459     dirty_rect *p = (dirty_rect *)dirties.first();
    460     int x1 = 6000, y1 = 6000, x2 = -1, y2 = -1;
    461 
    462     for (int i = dirties.Count(); i--; )
    463     {
    464         x1 = Min(x1, p->dx1); y1 = Min(y1, p->dy1);
    465         x2 = Max(x1, p->dx1); y2 = Max(y1, p->dy1);
     459    vec2i aa(6000), bb(-1);
     460
     461    for (dirty_rect *p = (dirty_rect *)dirties.first(); p; )
     462    {
     463        aa = Min(aa, p->m_aa);
     464        bb = Max(bb, p->m_bb);
    466465        dirty_rect *tmp = (dirty_rect *)p->Next();
    467466        dirties.unlink(p);
     
    469468        p = tmp;
    470469    }
    471     dirties.add_front(new dirty_rect(x1, y1, x2, y2));
    472 }
    473 
    474 void image_descriptor::delete_dirty(int x1, int y1, int x2, int y2)
     470    dirties.add_front(new dirty_rect(aa, bb));
     471}
     472
     473void image_descriptor::DeleteDirty(vec2i aa, vec2i bb)
    475474{
    476475    int ax1, ay1, ax2, ay2;
     
    480479        return;
    481480
    482     x1 = Max(0, x1); x2 = Min(m_size.x, x2);
    483     y1 = Max(0, y1); y2 = Min(m_size.y, y2);
    484 
    485     if (x1 >= x2 || y1 >= y2)
     481    aa = Max(aa, vec2i(0));
     482    bb = Min(bb, m_size);
     483
     484    if (!(aa < bb))
    486485        return;
    487486
     
    495494
    496495        // are the two touching?
    497         if (x2 <= p->dx1 || y2 <= p->dy1 || x1 > p->dx2 || y1 > p->dy2)
     496        if (!(bb > p->m_aa && aa <= p->m_bb))
    498497            continue;
    499498
    500499        // does it take a x slice off? (across)
    501         if (x2 >= p->dx2 + 1 && x1 <= p->dx1)
    502         {
    503             if (y2 >= p->dy2 + 1 && y1 <= p->dy1)
     500        if (bb.x >= p->m_bb.x + 1 && aa.x <= p->m_aa.x)
     501        {
     502            if (bb.y >= p->m_bb.y + 1 && aa.y <= p->m_aa.y)
    504503            {
    505504                dirties.unlink(p);
    506505                delete p;
    507506            }
    508             else if (y2 >= p->dy2 + 1)
    509                 p->dy2 = y1 - 1;
    510             else if (y1 <= p->dy1)
    511                 p->dy1 = y2;
     507            else if (bb.y >= p->m_bb.y + 1)
     508                p->m_bb.y = aa.y - 1;
     509            else if (aa.y <= p->m_aa.y)
     510                p->m_aa.y = bb.y;
    512511            else
    513512            {
    514                 dirties.add_front(new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
    515                 p->dy1 = y2;
     513                dirties.add_front(new dirty_rect(p->m_aa, vec2i(p->m_bb.x, aa.y - 1)));
     514                p->m_aa.y = bb.y;
    516515            }
    517516        }
    518517        // does it take a y slice off (down)
    519         else if (y2 - 1>=p->dy2 && y1<=p->dy1)
    520         {
    521             if (x2 - 1>=p->dx2)
    522                 p->dx2=x1-1;
    523             else if (x1<=p->dx1)
    524                 p->dx1=x2;
     518        else if (bb.y - 1 >= p->m_bb.y && aa.y <= p->m_aa.y)
     519        {
     520            if (bb.x - 1 >= p->m_bb.x)
     521                p->m_bb.x = aa.x - 1;
     522            else if (aa.x <= p->m_aa.x)
     523                p->m_aa.x = bb.x;
    525524            else
    526525            {
    527                 dirties.add_front(new dirty_rect(p->dx1, p->dy1, x1-1, p->dy2));
    528                 p->dx1=x2;
     526                dirties.add_front(new dirty_rect(p->m_aa, vec2i(aa.x - 1, p->m_bb.y)));
     527                p->m_aa.x = bb.x;
    529528            }
    530529        }
     
    532531        else
    533532        {
    534             if (x2 - 1>=p->dx2)      { ax1=p->dx1; ax2=x1; }
    535             else if (x1<=p->dx1) { ax1=x2; ax2=p->dx2+1; }
    536             else                { ax1=p->dx1; ax2=x1; }
    537             if (y2 - 1>=p->dy2)      { ay1=y1; ay2=p->dy2+1; }
    538             else if (y1<=p->dy1) { ay1=p->dy1; ay2=y2; }
    539             else                { ay1=y1; ay2=y2; }
    540             dirties.add_front(new dirty_rect(ax1, ay1, ax2-1, ay2-1));
    541 
    542             if (x2 - 1>=p->dx2 || x1<=p->dx1)  { ax1=p->dx1; ax2=p->dx2+1; }
    543             else                         { ax1=x2; ax2=p->dx2+1; }
    544 
    545             if (y2 - 1>=p->dy2)
    546             { if (ax1==p->dx1) { ay1=p->dy1; ay2=y1; }
    547                           else { ay1=y1; ay2=p->dy2+1;   } }
    548             else if (y1<=p->dy1) { if (ax1==p->dx1) { ay1=y2; ay2=p->dy2+1; }
    549                                              else  { ay1=p->dy1; ay2=y2; } }
    550             else           { if (ax1==p->dx1) { ay1=p->dy1; ay2=y1; }
    551                              else { ay1=y1; ay2=y2; } }
    552             dirties.add_front(new dirty_rect(ax1, ay1, ax2 - 1, ay2 - 1));
    553 
    554             if (x1>p->dx1 && x2 - 1<p->dx2)
     533            if (bb.x - 1 >= p->m_bb.x) { ax1=p->m_aa.x; ax2 = aa.x; }
     534            else if (aa.x<=p->m_aa.x) { ax1=bb.x; ax2=p->m_bb.x+1; }
     535            else { ax1=p->m_aa.x; ax2=aa.x; }
     536
     537            if (bb.y - 1>=p->m_bb.y) { ay1=aa.y; ay2=p->m_bb.y+1; }
     538            else if (aa.y<=p->m_aa.y) { ay1=p->m_aa.y; ay2=bb.y; }
     539            else { ay1=aa.y; ay2=bb.y; }
     540
     541            dirties.add_front(new dirty_rect(vec2i(ax1, ay1), vec2i(ax2 - 1, ay2 - 1)));
     542
     543            if (bb.x - 1>=p->m_bb.x || aa.x<=p->m_aa.x)  { ax1=p->m_aa.x; ax2=p->m_bb.x+1; }
     544            else { ax1=bb.x; ax2=p->m_bb.x+1; }
     545
     546            if (bb.y - 1>=p->m_bb.y)
     547            { if (ax1==p->m_aa.x) { ay1=p->m_aa.y; ay2=aa.y; }
     548              else { ay1=aa.y; ay2=p->m_bb.y+1;   } }
     549            else if (aa.y<=p->m_aa.y) { if (ax1==p->m_aa.x) { ay1=bb.y; ay2=p->m_bb.y+1; }
     550                                        else  { ay1=p->m_aa.y; ay2=bb.y; } }
     551            else { if (ax1==p->m_aa.x) { ay1=p->m_aa.y; ay2=aa.y; }
     552                   else { ay1=aa.y; ay2=bb.y; } }
     553            dirties.add_front(new dirty_rect(vec2i(ax1, ay1), vec2i(ax2 - 1, ay2 - 1)));
     554
     555            if (aa.x > p->m_aa.x && bb.x - 1 < p->m_bb.x)
    555556            {
    556                 if (y1>p->dy1 && y2 - 1<p->dy2)
     557                if (aa.y > p->m_aa.y && bb.y - 1 < p->m_bb.y)
    557558                {
    558                     dirties.add_front(new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
    559                     dirties.add_front(new dirty_rect(p->dx1, y2, p->dx2, p->dy2));
     559                    dirties.add_front(new dirty_rect(p->m_aa, vec2i(p->m_bb.x, aa.y - 1)));
     560                    dirties.add_front(new dirty_rect(vec2i(p->m_aa.x, bb.y), p->m_bb));
    560561                }
    561                 else if (y1<=p->dy1)
    562                     dirties.add_front(new dirty_rect(p->dx1, y2, p->dx2, p->dy2));
     562                else if (aa.y <= p->m_aa.y)
     563                    dirties.add_front(new dirty_rect(vec2i(p->m_aa.x, bb.y), p->m_bb));
    563564                else
    564                     dirties.add_front(new dirty_rect(p->dx1, p->dy1, p->dx2, y1-1));
     565                    dirties.add_front(new dirty_rect(p->m_aa, vec2i(p->m_bb.x, aa.y - 1)));
    565566            }
    566             else if (y1>p->dy1 && y2 - 1<p->dy2)
    567                 dirties.add_front(new dirty_rect(p->dx1, y2, p->dx2, p->dy2));
     567            else if (aa.y > p->m_aa.y && bb.y - 1 < p->m_bb.y)
     568                dirties.add_front(new dirty_rect(vec2i(p->m_aa.x, bb.y), p->m_bb));
    568569            dirties.unlink(p);
    569570            delete p;
     
    573574
    574575// specifies that an area is a dirty
    575 void image_descriptor::AddDirty(int x1, int y1, int x2, int y2)
     576void image_descriptor::AddDirty(vec2i aa, vec2i bb)
    576577{
    577578    dirty_rect *p;
     
    579580        return;
    580581
    581     x1 = Max(0, x1); x2 = Min(m_size.x, x2);
    582     y1 = Max(0, y1); y2 = Min(m_size.y, y2);
    583 
    584     if (x1 >= x2 || y1 >= y2)
     582    aa = Max(aa, vec2i(0));
     583    bb = Min(bb, m_size);
     584
     585    if (!(aa < bb))
    585586        return;
    586587
    587588    int i = dirties.Count();
    588589    if (!i)
    589         dirties.add_front(new dirty_rect(x1, y1, x2 - 1, y2 - 1));
     590        dirties.add_front(new dirty_rect(aa, bb - vec2i(1)));
    590591    else if (i >= MAX_DIRTY)
    591592    {
    592         dirties.add_front(new dirty_rect(x1, y1, x2 - 1, y2 - 1));
     593        dirties.add_front(new dirty_rect(aa, bb - vec2i(1)));
    593594        ReduceDirties();  // reduce to one dirty rectangle, we have to many
    594595    }
     
    599600
    600601        // check to see if this new rectangle completly encloses the check rectangle
    601         if (x1<=p->dx1 && y1<=p->dy1 && x2>=p->dx2+1 && y2>=p->dy2+1)
     602        if (aa.x<=p->m_aa.x && aa.y<=p->m_aa.y && bb.x>=p->m_bb.x+1 && bb.y>=p->m_bb.y+1)
    602603        {
    603604          dirty_rect *tmp=(dirty_rect*) p->Next();
     
    608609          else p=tmp;
    609610        }
    610         else if (!(x2 - 1 <p->dx1 || y2 - 1 <p->dy1 || x1>p->dx2 || y1>p->dy2))
    611         {
    612 
    613 
    614 
    615 /*          if (x1<=p->dx1) { a+=p->dx1-x1; ax1=x1; } else ax1=p->dx1;
    616           if (y1<=p->dy1) { a+=p->dy1-y1; ay1=y1; } else ay1=p->dy1;
    617           if (x2 - 1 >=p->dx2) { a+=x2 - 1 -p->dx2; ax2=x2 - 1; } else ax2=p->dx2;
    618           if (y2 - 1 >=p->dy2) { a+=y2 - 1 -p->dy2; ay2=y2 - 1; } else ay2=p->dy2;
     611        else if (!(bb.x - 1 <p->m_aa.x || bb.y - 1 <p->m_aa.y || aa.x>p->m_bb.x || aa.y>p->m_bb.y))
     612        {
     613
     614
     615
     616/*          if (x1<=p->m_aa.x) { a+=p->m_aa.x-x1; ax1=x1; } else ax1=p->m_aa.x;
     617          if (y1<=p->m_aa.y) { a+=p->m_aa.y-y1; ay1=y1; } else ay1=p->m_aa.y;
     618          if (x2 - 1 >=p->m_bb.x) { a+=x2 - 1 -p->m_bb.x; ax2=x2 - 1; } else ax2=p->m_bb.x;
     619          if (y2 - 1 >=p->m_bb.y) { a+=y2 - 1 -p->m_bb.y; ay2=y2 - 1; } else ay2=p->m_bb.y;
    619620
    620621      if (a<50)
    621       { p->dx1=ax1;                         // then expand the dirty
    622         p->dy1=ay1;
    623         p->dx2=ax2;
    624         p->dy2=ay2;
     622      { p->m_aa.x=ax1;                         // then expand the dirty
     623        p->m_aa.y=ay1;
     624        p->m_bb.x=ax2;
     625        p->m_bb.y=ay2;
    625626        return ;
    626627      }
    627628      else */
    628629            {
    629               if (x1<p->dx1)
    630                 AddDirty(x1, Max(y1, p->dy1), p->dx1, Min(y2, p->dy2 + 1));
    631               if (x2>p->dx2+1)
    632                 AddDirty(p->dx2+1, Max(y1, p->dy1), x2, Min(y2, p->dy2 + 1));
    633               if (y1<p->dy1)
    634                 AddDirty(x1, y1, x2, p->dy1);
    635               if (y2 - 1>p->dy2)
    636                 AddDirty(x1, p->dy2+1, x2, y2);
     630              if (aa.x < p->m_aa.x)
     631                AddDirty(vec2i(aa.x, Max(aa.y, p->m_aa.y)),
     632                         vec2i(p->m_aa.x, Min(bb.y, p->m_bb.y + 1)));
     633              if (bb.x > p->m_bb.x + 1)
     634                AddDirty(vec2i(p->m_bb.x + 1, Max(aa.y, p->m_aa.y)),
     635                         vec2i(bb.x, Min(bb.y, p->m_bb.y + 1)));
     636              if (aa.y < p->m_aa.y)
     637                AddDirty(aa, vec2i(bb.x, p->m_aa.y));
     638              if (bb.y - 1 > p->m_bb.y)
     639                AddDirty(vec2i(aa.x, p->m_bb.y + 1), bb);
    637640              return ;
    638641            }
    639             p=(dirty_rect *)p->Next();
    640           } else p=(dirty_rect *)p->Next();
     642            p = (dirty_rect *)p->Next();
     643          } else p = (dirty_rect *)p->Next();
    641644
    642645      }
    643       CHECK(x1 < x2 && y1 < y2);
    644       dirties.add_end(new dirty_rect(x1, y1, x2 - 1, y2 - 1));
     646      CHECK(aa < bb);
     647      dirties.add_end(new dirty_rect(aa, bb - vec2i(1)));
    645648    }
    646649}
     
    672675        memset(scan_line(y) + p1.x, color, (p2.x - p1.x + 1));
    673676    Unlock();
    674     AddDirty(p1.x, p1.y, p2.x + 1, p2.y + 1);
     677    AddDirty(p1, p2 + vec2i(1));
    675678}
    676679
     
    705708  Unlock();
    706709
    707   AddDirty(x1, y1, x2 + 1, y2 + 1);
     710  AddDirty(vec2i(x1, y1), vec2i(x2 + 1, y2 + 1));
    708711}
    709712
     
    816819    if (yd<0) { ysrc++; ydst++; } else { ysrc--; ydst--; }
    817820  }
    818   AddDirty(x1, y1, x2 + 1, y2 + 1);
     821  AddDirty(vec2i(x1, y1), vec2i(x2 + 1, y2 + 1));
    819822}
    820823
  • abuse/trunk/src/imlib/image.h

    r667 r670  
    2525{
    2626public :
    27     int16_t dx1, dy1, dx2, dy2;
    28     dirty_rect(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
     27    dirty_rect(vec2i aa, vec2i bb)
    2928    {
    30         dx1 = x1; dy1 = y1; dx2 = x2; dy2 = y2;
    31         if (x2 < x1 || y2 < y1)
     29        m_aa = aa;
     30        m_bb = bb;
     31        if (!(bb >= aa))
    3232            printf("add incorrect dirty\n");
    3333    }
    34     virtual int compare(void *n1) { return ((dirty_rect *)n1)->dy1 > dy1; }
     34    virtual int compare(void *n1)
     35    {
     36        return ((dirty_rect *)n1)->m_aa.y > m_aa.y;
     37    }
     38
     39    vec2i m_aa, m_bb;
    3540};
    3641
    3742class image_descriptor
    3843{
    39 private:
    40     vec2i m_size, m_aa, m_bb;
    41 
    4244public:
    4345    uint8_t keep_dirt,
     
    7880    }
    7981    void ReduceDirties();
    80     void AddDirty(int x1, int y1, int x2, int y2);
    81     void delete_dirty(int x1, int y1, int x2, int y2);
     82    void AddDirty(vec2i aa, vec2i bb);
     83    void DeleteDirty(vec2i aa, vec2i bb);
    8284    void Resize(vec2i size)
    8385    {
     
    8688        m_bb = size;
    8789    }
     90
     91private:
     92    vec2i m_size, m_aa, m_bb;
    8893};
    8994
     
    150155    }
    151156
    152     void AddDirty(int x1, int y1, int x2, int y2)
     157    void AddDirty(vec2i aa, vec2i bb)
    153158    {
    154         if (m_special) m_special->AddDirty(x1, y1, x2, y2);
     159        if (m_special) m_special->AddDirty(aa, bb);
    155160    }
    156     void delete_dirty(int x1, int y1, int x2, int y2)
     161    void DeleteDirty(vec2i aa, vec2i bb)
    157162    {
    158         if(m_special) m_special->delete_dirty(x1, y1, x2, y2);
     163        if(m_special) m_special->DeleteDirty(aa, bb);
    159164    }
    160165    void ClearDirties()
  • abuse/trunk/src/imlib/jwindow.cpp

    r669 r670  
    7272        {
    7373            p->hide();
    74             m_surf->AddDirty(p->m_pos.x, p->m_pos.y, p->m_pos.x + p->l, p->m_pos.y + p->h);
     74            m_surf->AddDirty(p->m_pos, p->m_pos + vec2i(p->l, p->h));
    7575        }
    7676    }
     
    9393        Jwindow *k;
    9494        for (k = m_first; k->next != j; k = k->next)
    95             k->m_surf->AddDirty(j->m_pos.x - k->m_pos.x, j->m_pos.y - k->m_pos.y,
    96                                   j->m_pos.x + j->l - k->m_pos.x, j->m_pos.y + j->h - k->m_pos.y);
    97         k->m_surf->AddDirty(j->m_pos.x - k->m_pos.x, j->m_pos.y - k->m_pos.y,
    98                               j->m_pos.x + j->l - k->m_pos.x, j->m_pos.y + j->h - k->m_pos.y);
     95            k->m_surf->AddDirty(j->m_pos - k->m_pos,
     96                                j->m_pos + vec2i(j->l, j->h) - k->m_pos);
     97        k->m_surf->AddDirty(j->m_pos - k->m_pos,
     98                            j->m_pos + vec2i(j->l, j->h) - k->m_pos);
    9999        k->next = j->next;
    100100    }
    101     m_surf->AddDirty(j->m_pos.x, j->m_pos.y, j->m_pos.x + j->l, j->m_pos.y + j->h);
     101    m_surf->AddDirty(j->m_pos, j->m_pos + vec2i(j->l, j->h));
    102102    j->hide();
    103103}
     
    108108    {
    109109        j->show();
    110         j->m_surf->AddDirty(0, 0, j->l, j->h);
     110        j->m_surf->AddDirty(vec2i(0), vec2i(j->l, j->h));
    111111    }
    112112}
     
    183183      for (p=m_first; p!=j; p=p->next)
    184184        p->m_surf->AddDirty(j->x-p->x,j->y-p->y,j->x+j->l-p->x,j->y+j->h-p->y); */
    185       j->m_surf->AddDirty(0, 0, j->l, j->h);
     185      j->m_surf->AddDirty(vec2i(0), vec2i(j->l, j->h));
    186186      flush_screen();
    187187    }
     
    214214  {
    215215    for (Jwindow *j = m_first; j; j = j->next)
    216        j->m_surf->AddDirty(ev.redraw.x1 - j->m_pos.x, ev.redraw.y1 - j->m_pos.y,
    217                              ev.redraw.x2 + 1 - j->m_pos.x, ev.redraw.y2 + 1 - j->m_pos.y);
    218     m_surf->AddDirty(ev.redraw.x1, ev.redraw.y1, ev.redraw.x2 + 1, ev.redraw.y2 + 1);
     216       j->m_surf->AddDirty(vec2i(ev.redraw.x1, ev.redraw.y1) - j->m_pos,
     217                           vec2i(ev.redraw.x2 + 1, ev.redraw.y2 + 1) - j->m_pos.x);
     218    m_surf->AddDirty(vec2i(ev.redraw.x1, ev.redraw.y1),
     219                     vec2i(ev.redraw.x2 + 1, ev.redraw.y2 + 1));
    219220    flush_screen();
    220221    ev.type=EV_SPURIOUS;   // we took care of this one by ourselves.
     
    231232{
    232233  Jwindow *p;
    233   m_surf->AddDirty(j->m_pos.x, j->m_pos.y, j->m_pos.x + j->l, j->m_pos.y + j->h);
     234  m_surf->AddDirty(j->m_pos, j->m_pos + vec2i(j->l, j->h));
    234235  for (p=m_first; p!=j; p=p->next)
    235     p->m_surf->AddDirty(j->m_pos.x - p->m_pos.x, j->m_pos.y - p->m_pos.y, j->m_pos.x + j->l - p->m_pos.x, j->m_pos.y + j->h - p->m_pos.y);
     236    p->m_surf->AddDirty(j->m_pos - p->m_pos,
     237                        j->m_pos - p->m_pos + vec2i(j->l, j->h));
    236238  j->resize(l,h);
    237239  if (!frame_suppress)
     
    241243void WindowManager::move_window(Jwindow *j, int x, int y)
    242244{
    243     m_surf->AddDirty(j->m_pos.x, j->m_pos.y, j->m_pos.x + j->l, j->m_pos.y + j->h);
     245    m_surf->AddDirty(j->m_pos, j->m_pos + vec2i(j->l, j->h));
    244246    for(Jwindow *p = m_first; p != j; p = p->next)
    245         p->m_surf->AddDirty(j->m_pos.x - p->m_pos.x, j->m_pos.y - p->m_pos.y,
    246                               j->m_pos.x + j->l - p->m_pos.x, j->m_pos.y + j->h - p->m_pos.y);
     247        p->m_surf->AddDirty(j->m_pos - p->m_pos,
     248                            j->m_pos - p->m_pos + vec2i(j->l, j->h));
    247249    j->m_pos.x = x;
    248250    j->m_pos.y = y;
    249     j->m_surf->AddDirty(0, 0, j->l, j->h);
     251    j->m_surf->AddDirty(vec2i(0), vec2i(j->l, j->h));
    250252}
    251253
     
    299301        Jwindow * search;
    300302        for(search = m_first; search->next != win; search = search->next)
    301             search->m_surf->AddDirty(win->m_pos.x - search->m_pos.x,
    302                                      win->m_pos.y - search->m_pos.y,
    303                                      win->m_pos.x + win->l - search->m_pos.x,
    304                                      win->m_pos.y + win->h - search->m_pos.y);
    305         search->m_surf->AddDirty(win->m_pos.x - search->m_pos.x,
    306                                  win->m_pos.y - search->m_pos.y,
    307                                  win->m_pos.x + win->l - search->m_pos.x,
    308                                  win->m_pos.y + win->h - search->m_pos.y);
     303            search->m_surf->AddDirty(win->m_pos - search->m_pos,
     304                                     win->m_pos - search->m_pos
     305                                                + vec2i(win->l, win->h));
     306        search->m_surf->AddDirty(win->m_pos - search->m_pos,
     307                                 win->m_pos - search->m_pos
     308                                            + vec2i(win->l, win->h));
    309309        search->next = win->next;
    310310    }
    311311
    312     m_surf->AddDirty(win->m_pos.x, win->m_pos.y, win->m_pos.x + win->l, win->m_pos.y + win->h);
     312    m_surf->AddDirty(win->m_pos, win->m_pos + vec2i(win->l, win->h));
    313313}
    314314
     
    342342    for (Jwindow *p = m_first; p; p = p->next)
    343343        if (!p->is_hidden())
    344             m_surf->delete_dirty(p->m_pos.x, p->m_pos.y, p->m_pos.x + p->l, p->m_pos.y + p->h);
     344            m_surf->DeleteDirty(p->m_pos, p->m_pos + vec2i(p->l, p->h));
    345345    update_dirty(m_surf);
    346346
     
    360360        }
    361361
    362 //          m_surf->delete_dirty(p->m_pos.x, p->m_pos.y, p->m_pos.x+p->l, p->m_pos.y+p->h);
     362//      m_surf->DeleteDirty(p->m_pos, p->m_pos + vec2i(p->l, p->h));
    363363        for (Jwindow *q = p->next; q; q = q->next)
    364364            if (!q->is_hidden())
    365                 p->m_surf->delete_dirty(q->m_pos.x - p->m_pos.x, q->m_pos.y - p->m_pos.y,
    366                                         q->m_pos.x + q->l - p->m_pos.x,
    367                                         q->m_pos.y + q->h - p->m_pos.y);
     365                p->m_surf->DeleteDirty(q->m_pos - p->m_pos,
     366                                       q->m_pos - p->m_pos + vec2i(q->l, q->h));
    368367        update_dirty(p->m_surf, p->m_pos.x, p->m_pos.y);
    369368        if (has_mouse())
  • abuse/trunk/src/imlib/scroller.cpp

    r668 r670  
    7878    }
    7979  }
    80   screen->AddDirty(x, y, x + icw, y + ich);
     80  screen->AddDirty(vec2i(x, y), vec2i(x + icw, y + ich));
    8181  screen->Unlock();
    8282}
  • abuse/trunk/src/imlib/supmorph.cpp

    r665 r670  
    268268    vec2i caa, cbb;
    269269    screen->GetClip(caa, cbb);
    270     screen->AddDirty(x, y, x + w, y + h);
     270    screen->AddDirty(vec2i(x, y), vec2i(x + w, y + h));
    271271    stepper *ss;
    272272    memset(hole,0,w*h);
  • abuse/trunk/src/imlib/transimage.cpp

    r665 r670  
    140140    }
    141141
    142     screen->AddDirty(Max(pos.x, pos1.x), pos.y,
    143                      Min(pos.x + m_size.x, pos2.x), pos.y + m_size.y);
     142    screen->AddDirty(vec2i(Max(pos.x, pos1.x), pos.y),
     143                     vec2i(Min(pos.x + m_size.x, pos2.x), pos.y + m_size.y));
    144144    return parser;
    145145}
  • abuse/trunk/src/imlib/video.cpp

    r555 r670  
    2525    CHECK(im->m_special);
    2626
    27     if(im->m_special->keep_dirt == 0)
     27    if (im->m_special->keep_dirt == 0)
    2828    {
    2929        put_image(im, xoff, yoff);
     
    3333        int count = im->m_special->dirties.Count();
    3434        dirty_rect *dr = (dirty_rect *)(im->m_special->dirties.first());
    35         while(count > 0)
     35        while (count > 0)
    3636        {
    37             put_part_image(im, xoff + dr->dx1, yoff + dr->dy1,
    38                            dr->dx1, dr->dy1, dr->dx2 + 1, dr->dy2 + 1);
     37            put_part_image(im, xoff + dr->m_aa.x, yoff + dr->m_aa.y,
     38                           dr->m_aa.x, dr->m_aa.y,
     39                           dr->m_bb.x + 1, dr->m_bb.y + 1);
    3940            dirty_rect *tmp = dr;
    4041            dr = (dirty_rect *)(dr->Next());
  • abuse/trunk/src/menu.cpp

    r668 r670  
    7070    }
    7171  }
    72   main_screen->AddDirty(x1, y1, x2 + 1, y2 + 1);
     72  main_screen->AddDirty(vec2i(x1, y1), vec2i(x2 + 1, y2 + 1));
    7373  main_screen->Unlock();
    7474}
     
    9797    }
    9898  }
    99   main_screen->AddDirty(x1, y1, x2 + 1, y2 + 1);
     99  main_screen->AddDirty(vec2i(x1, y1), vec2i(x2 + 1, y2 + 1));
    100100  main_screen->Unlock();
    101101}
     
    103103void dark_widget(int x1, int y1, int x2, int y2, int br, int dr, int amount)
    104104{
    105   main_screen->AddDirty(x1, y1, x2 + 1, y2 + 1);
     105  main_screen->AddDirty(vec2i(x1, y1), vec2i(x2 + 1, y2 + 1));
    106106  main_screen->Line(vec2i(x1, y1), vec2i(x1, y2), br);
    107107  main_screen->Line(vec2i(x1 + 1, y1), vec2i(x2, y1), br);
     
    153153
    154154
    155   main_screen->AddDirty(mx, my, mx + mw, my + mh);
     155  main_screen->AddDirty(vec2i(mx, my), vec2i(mx + mw, my + mh));
    156156
    157157  if (title)
     
    660660    inm->clear_current();
    661661
    662     main_screen->AddDirty(0, 0, 320, 200);
     662    main_screen->AddDirty(vec2i(0), vec2i(320, 200));
    663663
    664664    Event ev;
  • abuse/trunk/src/transp.cpp

    r665 r670  
    3333    if (!(bb >= vec2i(0)))
    3434        return;
    35     screen->AddDirty(pos.x, pos.y, pos.x + bb.x, pos.y + bb.y);
     35    screen->AddDirty(pos, pos + bb);
    3636
    3737  int ye=aa.y+bb.y;
Note: See TracChangeset for help on using the changeset viewer.