Changeset 665


Ignore:
Timestamp:
May 15, 2011, 5:32:56 PM (9 years ago)
Author:
Sam Hocevar
Message:

imlib: refactor GetClip?, SetClip? etc. to use vec2i.

Location:
abuse/trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/TODO

    r662 r665  
    5959  - AddDirty !!
    6060  - update_dirty
     61  - scale_put, scale_put_trans
     62  - tint_area, darken_area
     63
     64Jwindow::_x1 _x2
    6165
    6266JCFont::tl,th -> m_size
  • abuse/trunk/src/automap.cpp

    r655 r665  
    109109  // we will slam on as fast as possible
    110110
    111   screen->SetClip(window_xstart, window_ystart, window_xend+1, window_yend+1);
     111  screen->SetClip(vec2i(window_xstart, window_ystart),
     112                  vec2i(window_xend + 1, window_yend + 1));
    112113#if 0
    113114  for (i=draw_xstart,j=draw_ystart,x=sx,y=sy; y<=ey; j+=AUTOTILE_HEIGHT,y++)
     
    154155
    155156  // set the clip back to full window size because soemthing else could mess with the area
    156   automap_window->m_surf->SetClip(0,0,screen->Size().x,screen->Size().y);
     157  automap_window->m_surf->SetClip(vec2i(0), screen->Size());
    157158}
    158159
  • abuse/trunk/src/console.cpp

    r659 r665  
    5858    con_win=wm->new_window(lastx,lasty,screen_w(),screen_h(),NULL,name);
    5959    redraw();
    60     con_win->m_surf->SetClip(con_win->x1(),con_win->y1(),con_win->x2()+1,con_win->y2()+1);
     60    con_win->m_surf->SetClip(vec2i(con_win->x1(), con_win->y1()),
     61                             vec2i(con_win->x2() + 1, con_win->y2() + 1));
    6162  }
    6263}
  • abuse/trunk/src/dev.cpp

    r659 r665  
    373373  screen->AddDirty(x, y, x + new_width, y + new_height);
    374374
    375   int cx1, cy1, cx2, cy2;
    376   screen->GetClip(cx1, cy1, cx2, cy2);
    377   if (cx1>cx2 || cy1>cy2 || x>cx2-1 || y>cy2-1 || x+new_width<=cx1 || y+new_height<=cy1) return ;
    378   if (x<cx1)
    379   {
    380     ix_start=(cx1-x)*xstep;
    381     new_width-=(cx1-x);
    382     x=cx1;
     375  vec2i caa, cbb;
     376  screen->GetClip(caa, cbb);
     377  if (caa.x > cbb.x || caa.y > cbb.y || x>=cbb.x || y>=cbb.y || x+new_width<=caa.x || y+new_height<=caa.y) return ;
     378  if (x<caa.x)
     379  {
     380    ix_start=(caa.x-x)*xstep;
     381    new_width-=(caa.x-x);
     382    x=caa.x;
    383383  } else ix_start=0;
    384   if (x+new_width>cx2)
    385     new_width-=x+new_width-cx2;
    386   if (y<cy1)
    387   {
    388     iy_start=(cy1-y)*ystep;
    389     new_height-=(cy1-y);
    390     y=cy1;
     384  if (x+new_width>cbb.x)
     385    new_width-=x+new_width-cbb.x;
     386  if (y<caa.y)
     387  {
     388    iy_start=(caa.y-y)*ystep;
     389    new_height-=(caa.y-y);
     390    y=caa.y;
    391391  } else iy_start=0;
    392   if (y+new_height>cy2)
    393     new_height-=y+new_height-cy2;
     392  if (y+new_height>cbb.y)
     393    new_height-=y+new_height-cbb.y;
    394394
    395395  screen->Lock();
     
    414414  screen->AddDirty(x, y, x + new_width, y + new_height);
    415415
    416   int cx1, cy1, cx2, cy2;
    417   screen->GetClip(cx1, cy1, cx2, cy2);
    418   if (cx1>cx2 || cy1>cy2 || x>cx2-1 || y>cy2-1 || x+new_width<=cx1 || y+new_height<=cy1) return ;
    419   if (x<cx1)
    420   {
    421     ix_start=(cx1-x)*xstep;
    422     new_width-=(cx1-x);
    423     x=cx1;
     416  vec2i caa, cbb;
     417  screen->GetClip(caa, cbb);
     418  if (caa.x > cbb.x || caa.y > cbb.y || x >= cbb.x || y >= cbb.y || x+new_width<=caa.x || y+new_height<=caa.y) return ;
     419  if (x<caa.x)
     420  {
     421    ix_start=(caa.x-x)*xstep;
     422    new_width-=(caa.x-x);
     423    x=caa.x;
    424424  } else ix_start=0;
    425   if (x+new_width>cx2)
    426     new_width-=x+new_width-cx2;
    427   if (y<cy1)
    428   {
    429     iy_start=(cy1-y)*ystep;
    430     new_height-=(cy1-y);
    431     y=cy1;
     425  if (x+new_width>cbb.x)
     426    new_width-=x+new_width-cbb.x;
     427  if (y<caa.y)
     428  {
     429    iy_start=(caa.y-y)*ystep;
     430    new_height-=(caa.y-y);
     431    y=caa.y;
    432432  } else iy_start=0;
    433   if (y+new_height>cy2)
    434     new_height-=y+new_height-cy2;
     433  if (y+new_height>cbb.y)
     434    new_height-=y+new_height-cbb.y;
    435435
    436436  uint8_t d;
  • abuse/trunk/src/director.cpp

    r645 r665  
    4343int text_draw(int y, int x1, int y1, int x2, int y2, char const *buf, JCFont *font, uint8_t *cmap, char color)
    4444{
    45   int cx1, cy1, cx2, cy2, word_size, word_len;
    46   main_screen->GetClip(cx1, cy1, cx2, cy2);
    47   main_screen->InClip(x1,y1,x2+1,y2+1);
     45    vec2i caa, cbb;
     46    main_screen->GetClip(caa, cbb);
     47    main_screen->InClip(vec2i(x1, y1), vec2i(x2 + 1, y2 + 1));
     48
    4849  int h=font->height()+2,w=font->width(),x=x1,dist;
    4950  y+=y1;
    5051  char const *word_start;
     52  int word_size, word_len;
    5153
    5254  while (buf && *buf)
     
    115117
    116118  }
    117   main_screen->SetClip(cx1,cy1,cx2,cy2);
    118   return (y<=y1);
     119  main_screen->SetClip(caa, cbb);
     120  return y <= y1;
    119121}
    120122
  • abuse/trunk/src/game.cpp

    r658 r665  
    553553      if(xoff / ftile_width()>x || xoff / ftile_width()+(viewx2 - viewx1)/ftile_width()+1 < x ||
    554554      yoff / ftile_height()>y || yoff / ftile_height()+(viewy2 - viewy1)/ftile_height()+1 < y) return;
    555       int cx1, cy1, cx2, cy2;
    556       main_screen->GetClip(cx1, cy1, cx2, cy2);
    557       main_screen->SetClip(viewx1, viewy1, viewx2 + 1, viewy2 + 1);
     555      vec2i caa, cbb;
     556      main_screen->GetClip(caa, cbb);
     557      main_screen->SetClip(vec2i(viewx1, viewy1), vec2i(viewx2 + 1, viewy2 + 1));
    558558      im->PutImage(main_screen, vec2i((x - xoff / ftile_width())*ftile_width()+viewx1 - xoff % ftile_width(),
    559559            (y - yoff / ftile_height())*ftile_height()+viewy1 - yoff % ftile_height()));
    560       main_screen->SetClip(cx1, cy1, cx2, cy2);
     560      main_screen->SetClip(caa, cbb);
    561561    }
    562562  }
     
    575575      if(xo / btile_width()>x || xo / btile_width()+(viewx2 - viewx1)/btile_width()+1 < x ||
    576576      yo / btile_height()>y || yo / btile_height()+(viewy2 - viewy1)/btile_height()+1 < y) return;
    577       int cx1, cy1, cx2, cy2;
    578       main_screen->GetClip(cx1, cy1, cx2, cy2);
    579       main_screen->SetClip(viewx1, viewy1, viewx2 + 1, viewy2 + 1);
     577      vec2i caa, cbb;
     578      main_screen->GetClip(caa, cbb);
     579      main_screen->SetClip(vec2i(viewx1, viewy1), vec2i(viewx2 + 1, viewy2 + 1));
    580580      main_screen->PutImage(im, vec2i((x - xo / btile_width())*btile_width()+viewx1 - xo % btile_width(),
    581581            (y - yo / btile_height())*btile_height()+viewy1 - yo % btile_height()), 0);
    582       main_screen->SetClip(cx1, cy1, cx2, cy2);
     582      main_screen->SetClip(caa, cbb);
    583583    }
    584584  }
     
    683683  backtile *bt;
    684684  int x1, y1, x2, y2, x, y, xo, yo, nxoff, nyoff;
    685   int cx1, cy1, cx2, cy2;
    686   main_screen->GetClip(cx1, cy1, cx2, cy2);
     685  vec2i caa, cbb;
     686  main_screen->GetClip(caa, cbb);
    687687
    688688  if(!current_level || state == MENU_STATE)
     
    691691    {
    692692      if(state == SCENE_STATE)
    693         main_screen->SetClip(v->cx1, v->cy1, v->cx2 + 1, v->cy2 + 1);
     693        main_screen->SetClip(vec2i(v->cx1, v->cy1), vec2i(v->cx2 + 1, v->cy2 + 1));
    694694      image *tit = cache.img(title_screen);
    695695      main_screen->PutImage(tit, main_screen->Size() / 2 - tit->Size() / 2);
    696696      if(state == SCENE_STATE)
    697         main_screen->SetClip(cx1, cy1, cx2, cy2);
     697        main_screen->SetClip(caa, cbb);
    698698      wm->flush_screen();
    699699    }
     
    760760  current_vyadd = yoff - v->cy1;
    761761
    762   main_screen->SetClip(v->cx1, v->cy1, v->cx2 + 1, v->cy2 + 1);
     762  main_screen->SetClip(vec2i(v->cx1, v->cy1), vec2i(v->cx2 + 1, v->cy2 + 1));
    763763
    764764  nxoff = xoff * bg_xmul / bg_xdiv;
     
    861861  if(dev & DRAW_FG_LAYER)
    862862  {
    863     int ncx1, ncy1, ncx2, ncy2;
    864     main_screen->GetClip(ncx1, ncy1, ncx2, ncy2);
     863    vec2i ncaa, ncbb;
     864    main_screen->GetClip(ncaa, ncbb);
    865865
    866866    int scr_w = main_screen->Size().x;
     
    874874      for(y = y1, draw_y = yo; y <= y2; y++, draw_y += yinc)
    875875      {
    876     if(!(draw_y < ncy1 ||draw_y + yinc > ncy2))
     876    if (!(draw_y < ncaa.y || draw_y + yinc > ncbb.y))
    877877    {
    878878      uint16_t *cl = current_level->get_fgline(y)+x1;
     
    880880      for(x = x1, draw_x = xo; x <= x2; x++, cl++, sl1 += xinc, draw_x += xinc)
    881881      {
    882         if(!(draw_x < ncx1 || draw_x + xinc > ncx2))
     882        if(!(draw_x < ncaa.x || draw_x + xinc > ncbb.x))
    883883        {
    884884          int fort_num;
     
    10871087  post_render();
    10881088
    1089   main_screen->SetClip(cx1, cy1, cx2 + 1, cy2 + 1);
    1090 
    1091 
     1089  main_screen->SetClip(caa, cbb);
    10921090
    10931091
  • abuse/trunk/src/imlib/filter.cpp

    r579 r665  
    8181void Filter::PutImage(image *screen, image *im, vec2i pos)
    8282{
    83     int cx1, cy1, cx2, cy2, x1 = 0, y1 = 0,
    84         x2 = im->Size().x, y2 = im->Size().y;
    85     screen->GetClip(cx1, cy1, cx2, cy2);
     83    vec2i aa = vec2i(0), bb = im->Size(), caa, cbb;
     84    screen->GetClip(caa, cbb);
    8685
    8786    // See if the image gets clipped off the screen
    88     if(pos.x >= cx2 || pos.y >= cy2 ||
    89        pos.x + (x2 - x1) <= cx1 || pos.y + (y2 - y1) <= cy1)
     87    if (!(pos < cbb && pos + (bb - aa) > caa))
    9088        return;
    9189
    92     x1 += Max(cx1 - pos.x, 0);
    93     y1 += Max(cy1 - pos.y, 0);
    94     pos.x = Max(pos.x, cx1);
    95     pos.y = Max(pos.y, cy1);
    96     x2 = Min(x2, cx2 - pos.x + x1);
    97     y2 = Min(y2, cy2 - pos.y + y1);
     90    aa += Max(caa - pos, 0);
     91    pos = Max(pos, caa);
     92    bb = Min(bb, cbb - pos + aa);
    9893
    99     if(x1 >= x2 || y1 >= y2)
     94    if (!(aa < bb))
    10095        return;
    10196
    102     int xl = x2 - x1;
    103     int yl = y2 - y1;
     97    vec2i span = bb - aa;
    10498
    105     screen->AddDirty(pos.x, pos.y, pos.x + xl, pos.y + yl);
     99    screen->AddDirty(pos.x, pos.y, pos.x + span.x, pos.y + span.y);
    106100
    107101    screen->Lock();
    108102    im->Lock();
    109103
    110     for(int j = 0; j < yl; j++)
     104    for (int j = 0; j < span.y; j++)
    111105    {
    112         uint8_t *source = im->scan_line(y1 + j) + x1;
    113         uint8_t *dest = screen->scan_line(pos.y + j) + pos.x;
     106        uint8_t *src = im->scan_line(aa.y + j) + aa.x;
     107        uint8_t *dst = screen->scan_line(pos.y + j) + pos.x;
    114108
    115         for(int i = 0; i < xl; i++, source++, dest++)
    116             if (*source)
    117                 *dest = m_table[*source];
     109        for (int i = 0; i < span.x; i++, src++, dst++)
     110            if (*src)
     111                *dst = m_table[*src];
    118112    }
    119113
  • abuse/trunk/src/imlib/image.cpp

    r664 r665  
    181181    unsigned int dcy, dcx;
    182182
    183     int cx1, cy1, cx2, cy2;
    184 
    185183    // check to see if the line is completly clipped off
    186     GetClip(cx1, cy1, cx2, cy2);
    187     if ((p1.x < cx1 && p2.x < cx1) || (p1.x >= cx2 && p2.x >= cx2) ||
    188         (p1.y < cy1 && p2.y < cy1) || (p1.y >= cy2 && p2.y >= cy2))
     184    vec2i caa, cbb;
     185    GetClip(caa, cbb);
     186    if (!(p1 >= caa && p2 >= caa && p1 < cbb && p2 < cbb))
    189187        return;
    190188
     
    195193
    196194    // clip the left side
    197     if (p1.x < cx1)
     195    if (p1.x < caa.x)
    198196    {
    199197        vec2i m = p2 - p1;
     
    204202        {
    205203            int b = p1.y - m.y * p1.x / m.x;
    206             p1.y = b + m.y * cx1 / m.x;
    207         }
    208         p1.x = cx1;
     204            p1.y = b + m.y * caa.x / m.x;
     205        }
     206        p1.x = caa.x;
    209207    }
    210208
    211209    // clip the right side
    212     if (p2.x >= cx2)
     210    if (p2.x >= cbb.x)
    213211    {
    214212        vec2i m = p2 - p1;
     
    218216        {
    219217            int b = p1.y - m.y * p1.x / m.x;
    220             p2.y = b + m.y * (cx2 - 1) / m.x;
    221         }
    222         p2.x = cx2 - 1;
     218            p2.y = b + m.y * (cbb.x - 1) / m.x;
     219        }
     220        p2.x = cbb.x - 1;
    223221    }
    224222
     
    229227
    230228    // clip the bottom
    231     if (p2.y >= cy2)
     229    if (p2.y >= cbb.y)
    232230    {
    233231        vec2i m = p2 - p1;
     
    237235        {
    238236            int b = p1.y - (p2.y - p1.y) * p1.x / m.x;
    239             p2.x = (cy2 - 1 - b) * m.x / m.y;
    240         }
    241         p2.y = cy2 - 1;
     237            p2.x = (cbb.y - 1 - b) * m.x / m.y;
     238        }
     239        p2.y = cbb.y - 1;
    242240    }
    243241
    244242    // clip the top
    245     if (p1.y < cy1)
     243    if (p1.y < caa.y)
    246244    {
    247245        vec2i m = p2 - p1;
     
    251249        {
    252250            int b = p1.y - m.y * p1.x / m.x;
    253             p1.x = (cy1 - b) * m.x / m.y;
    254         }
    255         p1.y = cy1;
     251            p1.x = (caa.y - b) * m.x / m.y;
     252        }
     253        p1.y = caa.y;
    256254    }
    257255
    258256    // see if it got cliped into the box, out out
    259     if (p1.x < cx1 || p2.x < cx1 || p1.x >= cx2 || p2.x >= cx2
    260          || p1.y < cy1 || p2.y < cy1 || p1.y >= cy2 || p2.y >= cy2)
     257    if (!(p1 >= caa && p2 >= caa && p1 < cbb && p2 < cbb))
    261258        return;
    262259
    263260    if (p1.x > p2.x)
    264261    {
    265         xc = p2.x; xi = p1.x;
     262        xc = p2.x;
     263        xi = p1.x;
    266264    }
    267265    else
     
    329327    CHECK(aa < bb);
    330328
    331     int cx1, cy1, cx2, cy2;
    332     GetClip(cx1, cy1, cx2, cy2);
     329    vec2i caa, cbb;
     330    GetClip(caa, cbb);
    333331
    334332    // see if the are to be put is outside of actual image, if so adjust
     
    342340
    343341    // see if the image gets clipped off the screen
    344     if (pos.x >= cx2 || pos.y >= cy2 || pos.x + (bb.x - aa.x) <= cx1 || pos.y + (bb.y - aa.y) <= cy1)
    345         return;
    346 
    347     aa += Max(vec2i(cx1, cy1) - pos, vec2i(0));
    348     pos += Max(vec2i(cx1, cy1) - pos, vec2i(0));
    349     bb = Min(bb, vec2i(cx2, cy2) - pos + aa);
     342    if (!(pos < cbb && pos + (bb - aa) > caa))
     343        return;
     344
     345    aa += Max(caa - pos, vec2i(0));
     346    pos += Max(caa - pos, vec2i(0));
     347    bb = Min(bb, cbb - pos + aa);
    350348    if (!(aa < bb))
    351349        return;
     
    383381    if (m_special)
    384382    {
    385         int cx1, cy1, cx2, cy2;
    386         m_special->GetClip(cx1, cy1, cx2, cy2);
    387 
    388         if (!(pos < vec2i(cx2, cy2) && pos > aa - bb))
     383        vec2i caa, cbb;
     384        m_special->GetClip(caa, cbb);
     385
     386        if (!(pos < cbb && pos > aa - bb))
    389387            return;
    390388
    391         aa += Max(vec2i(cx1, cy1) - pos, vec2i(0));
    392         pos += Max(vec2i(cx1, cy1) - pos, vec2i(0));
    393         bb = Min(bb, vec2i(cx2, cy2) - pos + aa);
     389        aa += Max(caa - pos, vec2i(0));
     390        pos += Max(caa - pos, vec2i(0));
     391        bb = Min(bb, cbb - pos + aa);
    394392    }
    395393    else if (!(pos <= m_size && pos >= -aa))
     
    443441}
    444442
    445 void image::SetClip(int x1, int y1, int x2, int y2)
     443void image::SetClip(vec2i aa, vec2i bb)
    446444{
    447445    // If the image does not already have an Image descriptor, allocate one
     
    452450    // set the image descriptor what the clip
    453451    // should be it will adjust to fit within the image.
     452    m_special->SetClip(aa, bb);
     453}
     454
     455void image::GetClip(vec2i &aa, vec2i &bb)
     456{
     457    if (m_special)
     458        m_special->GetClip(aa, bb);
     459    else
     460    {
     461        aa = vec2i(0);
     462        bb = m_size;
     463    }
     464}
     465
     466void image::InClip(vec2i aa, vec2i bb)
     467{
     468    if (m_special)
     469    {
     470        aa = Min(aa, vec2i(m_special->x1_clip(), m_special->y1_clip()));
     471        bb = Max(bb, vec2i(m_special->x2_clip(), m_special->y2_clip()));
     472    }
     473
     474    SetClip(aa, bb);
     475}
     476
     477void image::SetClip(int x1, int y1, int x2, int y2)
     478{
     479   // If the image does not already have an Image descriptor, allocate one
     480   // with no dirty rectangle keeping.
     481   if (!m_special)
     482       m_special = new image_descriptor(m_size.x, m_size.y, 0);
     483
     484   // set the image descriptor what the clip
     485   // should be it will adjust to fit within the image.
    454486    m_special->SetClip(x1, y1, x2, y2);
    455487}
     
    825857  if (m_special)
    826858  {
    827     int cx1, cy1, cx2, cy2;
    828     m_special->GetClip(cx1, cy1, cx2, cy2);
    829     x1=Max(x1, cx1); y1=Max(cy1, y1); x2=Min(x2, cx2 - 1); y2=Min(y2, cy2 - 1);
     859    vec2i caa, cbb;
     860    m_special->GetClip(caa, cbb);
     861    x1=Max(x1, caa.x); y1=Max(caa.y, y1); x2=Min(x2, cbb.x - 1); y2=Min(y2, cbb.y - 1);
    830862  }
    831863  int16_t xsrc, ysrc, xdst, ydst, xtot=x2-x1-abs(xd)+1, ytot, xt;
     
    10071039image *image::copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    10081040{
    1009   int x, y, cx1, cy1, cx2, cy2, ry, rx, bo, dity, ditx;
     1041  int x, y, ry, rx, bo, dity, ditx;
    10101042  image *ret;
    10111043  uint8_t *sl1, *sl2;
    1012   GetClip(cx1, cy1, cx2, cy2);
    1013   if (y1<cy1) y1=cy1;
    1014   if (x1<cx1) x1=cx1;
    1015   if (y2>cy2 - 1) y2=cy2 - 1;
    1016   if (x2>cx2 - 1) x2=cx2 - 1;
     1044  vec2i caa, cbb;
     1045  GetClip(caa, cbb);
     1046  if (y1<caa.y) y1=caa.y;
     1047  if (x1<caa.x) x1=caa.x;
     1048  if (y2>cbb.y - 1) y2=cbb.y - 1;
     1049  if (x2>cbb.x - 1) x2=cbb.x - 1;
    10171050  CHECK(x2>=x1 && y2>=y1);
    10181051  if (x2<x1 || y2<y1) return NULL;
  • abuse/trunk/src/imlib/image.h

    r664 r665  
    5757    inline int y2_clip() { return m_bb.y; }
    5858    void ClearDirties();
     59    void GetClip(vec2i &aa, vec2i &bb)
     60    {
     61        aa = m_aa; bb = m_bb;
     62    }
     63    void SetClip(vec2i aa, vec2i bb)
     64    {
     65        m_aa = Max(aa, vec2i(0));
     66        m_bb = Min(Max(bb, m_aa + vec2i(1)), m_size);
     67    }
    5968    void GetClip(int &x1, int &y1, int &x2, int &y2)
    6069    {
     
    127136    void burn_led(int16_t x, int16_t y, int32_t num, int16_t color,
    128137                  int16_t scale = 1);
     138    void SetClip(vec2i aa, vec2i bb);
     139    void GetClip(vec2i &aa, vec2i &bb);
     140    void InClip(vec2i aa, vec2i bb);
    129141    void SetClip(int x1, int y1, int x2, int y2);
    130142    void GetClip(int &x1, int &y1, int &x2, int &y2);
  • abuse/trunk/src/imlib/jwindow.h

    r659 r665  
    113113    int x2() { return _x2; }
    114114    int y2() { return _y2; }
    115     void clip_in() { m_surf->SetClip(x1(), y1(), x2() + 1, y2() + 1); }
    116     void clip_out() { m_surf->SetClip(0, 0, l, h); }
     115    void clip_in() { m_surf->SetClip(vec2i(x1(), y1()), vec2i(x2() + 1, y2() + 1)); }
     116    void clip_out() { m_surf->SetClip(vec2i(0), vec2i(l, h)); }
    117117    char *read(int id) { return inm->get(id)->read(); }
    118118    void local_close();
  • abuse/trunk/src/imlib/pmenu.cpp

    r659 r665  
    2929  active=NULL;
    3030
    31   int cx1, cy1, cx2, cy2;
    32   screen->GetClip(cx1, cy1, cx2, cy2);
    33   if (cx1<X) cx1=X;
    34   int w = cx2 - cx1 - Jwindow::left_border() - Jwindow::right_border();
     31  vec2i caa, cbb;
     32  screen->GetClip(caa, cbb);
     33  if (caa.x<X) caa.x=X;
     34  int w = cbb.x - caa.x - Jwindow::left_border() - Jwindow::right_border();
    3535  int h = Jwindow::top_border() + Jwindow::bottom_border();
    3636
     
    146146  int w,h;
    147147  calc_size(w,h);
    148   int cx1, cy1, cx2, cy2;
    149   main_screen->GetClip(cx1, cy1, cx2, cy2);
     148  vec2i caa, cbb;
     149  main_screen->GetClip(caa, cbb);
    150150  // FIXME: is this correct? it looks like it used to be incorrect
    151151  // before the GetClip refactoring...
    152   if (w+x>cx2-1)
    153     x=cx2-1-w;
     152  if (w+x>cbb.x-1)
     153    x=cbb.x-1-w;
    154154
    155155  if (win)
     
    189189  int w,h,i=0;
    190190  calc_size(w,h);
    191   int cx1, cy1, cx2, cy2;
    192   main_screen->GetClip(cx1, cy1, cx2, cy2);
    193   if (parent->m_pos.x + w + x >= cx2)
    194     x=cx2-1-w-parent->m_pos.x;
    195   if (h+y+parent->m_pos.y>=cy2)
    196   {
    197     if (parent->m_pos.y+parent->h+wm->font()->height()>=cy2)
     191  vec2i caa, cbb;
     192  main_screen->GetClip(caa, cbb);
     193  if (parent->m_pos.x + w + x >= cbb.x)
     194    x=cbb.x-1-w-parent->m_pos.x;
     195  if (h+y+parent->m_pos.y>=cbb.y)
     196  {
     197    if (parent->m_pos.y+parent->h+wm->font()->height()>=cbb.y)
    198198      y=-h;
    199199    else y=y-h+wm->font()->height()+5;
     
    322322  int w,h;
    323323  calc_size(w,h);
    324   int cx1, cy1, cx2, cy2;
    325   main_screen->GetClip(cx1, cy1, cx2, cy2);
    326324
    327325  x=win->m_pos.x;
     
    384382pmenu_item *pmenu::inarea(int mx, int my, image *screen)
    385383{
    386   int cx1, cy1, cx2, cy2;
    387   screen->GetClip(cx1, cy1, cx2, cy2);
    388384  mx-=bar->m_pos.x;
    389385  my-=bar->m_pos.y;
  • abuse/trunk/src/imlib/scroller.cpp

    r659 r665  
    5757void show_icon(image *screen, int x, int y, int icw, int ich, uint8_t *buf)
    5858{
    59   int cx1, cy1, cx2, cy2;
    60   screen->GetClip(cx1, cy1, cx2, cy2);
     59  vec2i caa, cbb;
     60  screen->GetClip(caa, cbb);
     61
    6162  uint8_t remap[3];
    6263  remap[0]=wm->medium_color();
     
    6768  for (int yc=ich; yc; yc--,y++)
    6869  {
    69     if (y >= cy1 && y < cy2)
     70    if (y >= caa.y && y < cbb.y)
    7071    {
    7172      uint8_t *sl=screen->scan_line(y)+x;
    7273      for (int xc=icw,xo=x; xc; xc--,xo++,sl++,buf++)
    7374      {
    74     if (xo >= cx1 && xo < cx2)
     75    if (xo >= caa.x && xo < cbb.x)
    7576      *sl=remap[*buf];
    7677      }
     
    494495  if (tex)
    495496  {
    496     int cx1, cy1, cx2, cy2;
    497     screen->GetClip(cx1, cy1, cx2, cy2);
    498     screen->SetClip(m_pos.x,m_pos.y,m_pos.x+l,m_pos.y+h);
     497    vec2i caa, cbb;
     498    screen->GetClip(caa, cbb);
     499    screen->SetClip(m_pos, m_pos + vec2i(l, h));
    499500    int tw=(l+tex->Size().x-1)/tex->Size().x;
    500501    int th=(h+tex->Size().y-1)/tex->Size().y;
     
    504505        screen->PutImage(tex, vec2i(dx, dy));
    505506
    506     screen->SetClip(cx1, cy1, cx2, cy2);
     507    screen->SetClip(caa, cbb);
    507508  } else screen->Bar(m_pos, m_pos + vec2i(l - 1, h - 1), wm->black());
    508509
  • abuse/trunk/src/imlib/supmorph.cpp

    r579 r665  
    262262            int blur_threshold)
    263263{
    264   if (f_left)
    265   {
     264    if (!f_left)
     265        return 0;
     266
    266267    int i,px,py,ix,iy;
    267     int x1, y1, x2, y2;
    268     screen->GetClip(x1, y1, x2, y2);
     268    vec2i caa, cbb;
     269    screen->GetClip(caa, cbb);
    269270    screen->AddDirty(x, y, x + w, y + h);
    270271    stepper *ss;
     
    277278      px=ix+x;
    278279      py=iy+y;
    279       if (px>=x1 && px < x2 && py>=y1 && py < y2)
     280      if (px>=caa.x && px < cbb.x && py>=caa.y && py < cbb.y)
    280281      {
    281282        hole[ix+iy*w]=*(screen->scan_line(py)+px)=fil->Lookup(ss->r>>(19),
     
    298299      for (ix=1; ix<w-1; ix++,ll++,tl++,nl++)
    299300      {
    300     if (x+ix>=x1 && x+ix < x2 && y+iy>=y1 && y+iy < y2)
     301    if (x+ix>=caa.x && x+ix < cbb.x && y+iy>=caa.y && y+iy < cbb.y)
    301302    {
    302303      int t=0;
     
    335336    }
    336337    return 1;
    337   } else return 0;
    338338}
    339339
  • abuse/trunk/src/imlib/transimage.cpp

    r631 r665  
    154154    int ysteps, mul = 0;
    155155
    156     screen->GetClip(pos1.x, pos1.y, pos2.x, pos2.y);
     156    screen->GetClip(pos1, pos2);
    157157
    158158    if (N == SCANLINE)
  • abuse/trunk/src/light.cpp

    r643 r665  
    775775
    776776  if (ambient==63) return ;
    777   int cx1, cy1, cx2, cy2;
    778   sc->GetClip(cx1, cy1, cx2, cy2);
    779 
    780   light_patch *first = make_patch_list(cx2 - cx1, cy2 - cy1, screenx, screeny);
     777  vec2i caa, cbb;
     778  sc->GetClip(caa, cbb);
     779
     780  light_patch *first = make_patch_list(cbb.x - caa.x, cbb.y - caa.y, screenx, screeny);
    781781
    782782  int prefix_x=(screenx&7);
     
    784784  if (prefix)
    785785    prefix=8-prefix;
    786   int suffix_x = cx2 - 1 - cx1 - (screenx & 7);
    787 
    788   int suffix=(cx2 - cx1 - prefix) & 7;
    789 
    790   int32_t remap_size=((cx2 - cx1 - prefix - suffix)>>lx_run);
     786  int suffix_x = cbb.x - 1 - caa.x - (screenx & 7);
     787
     788  int suffix = (cbb.x - caa.x - prefix) & 7;
     789
     790  int32_t remap_size=((cbb.x - caa.x - prefix - suffix)>>lx_run);
    791791
    792792  uint8_t *remap_line=(uint8_t *)malloc(remap_size);
     
    797797
    798798  int scr_w=main_screen->Size().x;
    799   uint8_t *screen_line=main_screen->scan_line(cy1)+cx1;
    800 
    801   for (int y = cy1; y < cy2; )
     799  uint8_t *screen_line=main_screen->scan_line(caa.y)+caa.x;
     800
     801  for (int y = caa.y; y < cbb.y; )
    802802  {
    803803    int x,count;
     
    807807
    808808    int todoy=4-((screeny+y)&3);
    809     if (y + todoy >= cy2)
    810       todoy = cy2 - y;
    811 
    812     int calcy=((y+screeny)&(~3))-cy1;
     809    if (y + todoy >= cbb.y)
     810      todoy = cbb.y - y;
     811
     812    int calcy=((y+screeny)&(~3))-caa.y;
    813813
    814814
     
    816816    {
    817817      light_patch *lp=f;
    818       for (; (lp->y1>y-cy1 || lp->y2<y-cy1 ||
     818      for (; (lp->y1>y-caa.y || lp->y2<y-caa.y ||
    819819                  lp->x1>suffix_x || lp->x2<suffix_x); lp=lp->next);
    820       uint8_t * caddr=(uint8_t *)screen_line + cx2 - cx1 - suffix;
     820      uint8_t * caddr=(uint8_t *)screen_line + cbb.x - caa.x - suffix;
    821821      uint8_t *r=light_lookup+(((int32_t)calc_light_value(lp,suffix_x+screenx,calcy)<<8));
    822822      switch (todoy)
     
    840840    {
    841841      light_patch *lp=f;
    842       for (; (lp->y1>y-cy1 || lp->y2<y-cy1 ||
     842      for (; (lp->y1>y-caa.y || lp->y2<y-caa.y ||
    843843                  lp->x1>prefix_x || lp->x2<prefix_x); lp=lp->next);
    844844
     
    868868    {
    869869      light_patch *lp=f;
    870       for (; (lp->y1>y-cy1 || lp->y2<y-cy1 || lp->x1>x || lp->x2<x); lp=lp->next);
     870      for (; (lp->y1>y-caa.y || lp->y2<y-caa.y || lp->x1>x || lp->x2<x); lp=lp->next);
    871871      *rem=calc_light_value(lp,x+screenx,calcy);
    872872    }
     
    925925  else min_light_level=(int)ambient+ambient_ramp;
    926926
    927   int cx1, cy1, cx2, cy2;
    928   sc->GetClip(cx1, cy1, cx2, cy2);
     927  vec2i caa, cbb;
     928  sc->GetClip(caa, cbb);
    929929
    930930
     
    932932  {
    933933    uint8_t *src=sc->scan_line(0);
    934     uint8_t *dst=out->scan_line(out_y+cy1*2)+cx1*2+out_x;
     934    uint8_t *dst=out->scan_line(out_y+caa.y*2)+caa.x*2+out_x;
    935935    int d_skip=out->Size().x-sc->Size().x*2;
    936936    int x,y;
     
    952952  }
    953953
    954   light_patch *first = make_patch_list(cx2 - cx1, cy2 - cy1, screenx, screeny);
     954  light_patch *first = make_patch_list(cbb.x - caa.x, cbb.y - caa.y, screenx, screeny);
    955955
    956956  int scr_w=sc->Size().x;
     
    961961  if (prefix)
    962962    prefix=8-prefix;
    963   int suffix_x = cx2 - 1 - cx1 - (screenx & 7);
    964 
    965   int suffix = (cx2 - cx1 - prefix) & 7;
    966 
    967   int32_t remap_size = ((cx2 - cx1 - prefix - suffix)>>lx_run);
     963  int suffix_x = cbb.x - 1 - caa.x - (screenx & 7);
     964
     965  int suffix = (cbb.x - caa.x - prefix) & 7;
     966
     967  int32_t remap_size = ((cbb.x - caa.x - prefix - suffix)>>lx_run);
    968968
    969969  uint8_t *remap_line=(uint8_t *)malloc(remap_size);
    970970
    971971  light_patch *f=first;
    972   uint8_t *in_line=sc->scan_line(cy1)+cx1;
    973   uint8_t *out_line=out->scan_line(cy1*2+out_y)+cx1*2+out_x;
    974 
    975 
    976   for (int y = cy1; y < cy2; )
     972  uint8_t *in_line=sc->scan_line(caa.y)+caa.x;
     973  uint8_t *out_line=out->scan_line(caa.y*2+out_y)+caa.x*2+out_x;
     974
     975
     976  for (int y = caa.y; y < cbb.y; )
    977977  {
    978978    int x,count;
     
    982982
    983983    int todoy=4-((screeny+y)&3);
    984     if (y + todoy >= cy2)
    985       todoy = cy2 - y;
    986 
    987     int calcy=((y+screeny)&(~3))-cy1;
     984    if (y + todoy >= cbb.y)
     985      todoy = cbb.y - y;
     986
     987    int calcy=((y+screeny)&(~3))-caa.y;
    988988
    989989
     
    991991    {
    992992      light_patch *lp=f;
    993       for (; (lp->y1>y-cy1 || lp->y2<y-cy1 ||
     993      for (; (lp->y1>y-caa.y || lp->y2<y-caa.y ||
    994994                  lp->x1>suffix_x || lp->x2<suffix_x); lp=lp->next);
    995       uint8_t * caddr=(uint8_t *)in_line + cx2 - cx1 - suffix;
    996       uint8_t * daddr=(uint8_t *)out_line+(cx2 - cx1 - suffix)*2;
     995      uint8_t * caddr=(uint8_t *)in_line + cbb.x - caa.x - suffix;
     996      uint8_t * daddr=(uint8_t *)out_line+(cbb.x - caa.x - suffix)*2;
    997997
    998998      uint8_t *r=light_lookup+(((int32_t)calc_light_value(lp,suffix_x+screenx,calcy)<<8));
     
    10251025    {
    10261026      light_patch *lp=f;
    1027       for (; (lp->y1>y-cy1 || lp->y2<y-cy1 ||
     1027      for (; (lp->y1>y-caa.y || lp->y2<y-caa.y ||
    10281028                  lp->x1>prefix_x || lp->x2<prefix_x); lp=lp->next);
    10291029
     
    10641064    {
    10651065      light_patch *lp=f;
    1066       for (; (lp->y1>y-cy1 || lp->y2<y-cy1 || lp->x1>x || lp->x2<x); lp=lp->next);
     1066      for (; (lp->y1>y-caa.y || lp->y2<y-caa.y || lp->x1>x || lp->x2<x); lp=lp->next);
    10671067      *rem=calc_light_value(lp,x+screenx,calcy);
    10681068    }
  • abuse/trunk/src/menu.cpp

    r662 r665  
    4747void tint_area(int x1, int y1, int x2, int y2, int r_to, int g_to, int b_to, int percent)
    4848{
    49   int x,y;
    50   int cx1, cy1, cx2, cy2;
    51   main_screen->GetClip(cx1, cy1, cx2, cy2);
    52   if (x1<cx1) x1=cx1;
    53   if (y1<cy1) y1=cy1;
    54   if (x2>cx2-1) x2=cx2-1;
    55   if (y2>cy2-1) y2=cy2-1;
    56   if (x2<x1 || y2<y1) return ;
     49  vec2i caa, cbb;
     50  main_screen->GetClip(caa, cbb);
     51  if (x1 < caa.x) x1 = caa.x;
     52  if (y1 < caa.y) y1 = caa.y;
     53  if (x2 > cbb.x - 1) x2 = cbb.x - 1;
     54  if (y2 > cbb.y - 1) y2 = cbb.y - 1;
     55  if (x2 < x1 || y2 < y1) return;
    5756
    5857  percent=256-percent;
    5958
    6059  main_screen->Lock();
    61   for (y=y1; y<=y2; y++)
     60  for (int y=y1; y<=y2; y++)
    6261  {
    6362    uint8_t *sl=main_screen->scan_line(y)+x1;
    64     for (x=x1; x<=x2; x++,sl++)
     63    for (int x=x1; x<=x2; x++,sl++)
    6564    {
    6665      uint8_t *paddr=(uint8_t *)pal->addr()+(*sl)*3;
     
    7776void darken_area(int x1, int y1, int x2, int y2, int amount)
    7877{
    79   int x,y;
    80   int cx1, cy1, cx2, cy2;
    81   main_screen->GetClip(cx1, cy1, cx2, cy2);
    82   if (x1<cx1) x1=cx1;
    83   if (y1<cy1) y1=cy1;
    84   if (x2>cx2-1) x2=cx2-1;
    85   if (y2>cy2-1) y2=cy2-1;
    86   if (x2<x1 || y2<y1) return ;
     78  vec2i caa, cbb;
     79  main_screen->GetClip(caa, cbb);
     80  if (x1 < caa.x) x1 = caa.x;
     81  if (y1 < caa.y) y1 = caa.y;
     82  if (x2 > cbb.x - 1) x2 = cbb.x - 1;
     83  if (y2 > cbb.y - 1) y2 = cbb.y - 1;
     84  if (x2 < x1 || y2 < y1) return;
    8785
    8886  main_screen->Lock();
    89   for (y=y1; y<=y2; y++)
     87  for (int y=y1; y<=y2; y++)
    9088  {
    9189    uint8_t *sl=main_screen->scan_line(y)+x1;
    92     for (x=x1; x<=x2; x++,sl++)
     90    for (int x=x1; x<=x2; x++,sl++)
    9391    {
    9492      uint8_t *paddr=(uint8_t *)pal->addr()+(*sl)*3;
  • abuse/trunk/src/particle.cpp

    r643 r665  
    171171void part_frame::draw(image *screen, int x, int y, int dir)
    172172{
    173   int cx1, cy1, cx2, cy2;
    174   screen->GetClip(cx1, cy1, cx2, cy2);
    175   if (x + x1 >= cx2 || x + x2 < cx1 || y + y1 >= cy2 || y + y2 < cy1) return;
     173    vec2i caa, cbb;
     174    screen->GetClip(caa, cbb);
     175
     176    if (x + x1 >= cbb.x || x + x2 < caa.x || y + y1 >= cbb.y || y + y2 < caa.y)
     177       return;
    176178
    177179  part *pon=data;
    178   cy1 -= y;
    179   cy2 -= y;
     180  caa.y -= y;
     181  cbb.y -= y;
    180182
    181183  int i=t;
    182   while (i && pon->y<cy1) { pon++; i--; }
     184  while (i && pon->y<caa.y) { pon++; i--; }
    183185  if (!i) return ;
    184186  screen->Lock();
    185187  if (dir>0)
    186188  {
    187     while (i && pon->y < cy2)
     189    while (i && pon->y < cbb.y)
    188190    {
    189191      long dx=x-pon->x;
    190       if (dx >= cx1 && dx < cx2)
     192      if (dx >= caa.x && dx < cbb.x)
    191193      *(screen->scan_line(pon->y+y)+dx)=pon->color;
    192194      i--;
     
    195197  } else
    196198  {
    197     while (i && pon->y < cy2)
     199    while (i && pon->y < cbb.y)
    198200    {
    199201      long dx=pon->x+x;
    200       if (dx >= cx1 && dx < cx2)
     202      if (dx >= caa.x && dx < cbb.x)
    201203        *(screen->scan_line(pon->y+y)+dx)=pon->color;
    202204      i--;
     
    209211void scatter_line(int x1, int y1, int x2, int y2, int c, int s)
    210212{
    211     int cx1, cy1, cx2, cy2;
    212     main_screen->GetClip(cx1, cy1, cx2, cy2);
     213    vec2i caa, cbb;
     214    main_screen->GetClip(caa, cbb);
    213215
    214216    int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
     
    224226        x = ( xo >> 16 ) + ( jrand() >> s ) - xm;
    225227        y = ( yo >> 16 ) + ( jrand() >> s ) - ym;
    226         if( !( x < cx1 || y < cy1 || x >= cx2 || y >= cy2 ) )
     228        if( !( x < caa.x || y < caa.y || x >= cbb.x || y >= cbb.y ) )
    227229        {
    228230            *(main_screen->scan_line( y ) + x ) = c;
     
    238240void ascatter_line(int x1, int y1, int x2, int y2, int c1, int c2, int s)
    239241{
    240     int cx1, cy1, cx2, cy2;
    241     main_screen->GetClip(cx1, cy1, cx2, cy2);
     242    vec2i caa, cbb;
     243    main_screen->GetClip(caa, cbb);
    242244
    243245    int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;
     
    259261        // FIXME: these clip values seemed wrong to me before the GetClip
    260262        // refactoring.
    261         if( !( x <= cx1 || y <= cy1 || x >= cx2 - 1 || y >= cy2 - 1) )
     263        if( !( x <= caa.x || y <= caa.y || x >= cbb.x - 1 || y >= cbb.y - 1) )
    262264        {
    263265            addr = main_screen->scan_line( y ) + x;
  • abuse/trunk/src/transp.cpp

    r555 r665  
    1919void transp_put(image *im, image *screen, uint8_t *table, int x, int y)
    2020{
    21   int cx1, cy1, cx2, cy2;
    22   screen->GetClip(cx1, cy1, cx2, cy2);
    23   int xs=0,ys=0,xl=im->Size().x,yl=im->Size().y;
    24   if (x<cx1)
    25   {
    26     int chop=cx1-x;
    27     xs+=chop;
    28     xl-=chop;
    29     x+=chop;
    30   }
    31   if (y<cy1)
    32   {
    33     int chop=cy1-y;
    34     ys+=chop;
    35     yl-=chop;
    36     y+=chop;
    37   }
    38   if (x + xl >= cx2)
    39     xl = cx2 - 1 - x;
    40   if (y + yl >= cy2)
    41     yl = cy2 - 1 - y;
     21    vec2i caa, cbb;
     22    screen->GetClip(caa, cbb);
    4223
    43   if (xl<0 || yl<0) return ;
    44   screen->AddDirty(x, y, x + xl, y + yl);
     24    vec2i aa(0), bb = im->Size();
     25    vec2i pos(x, y);
    4526
    46   int ye=ys+yl;
    47   int xe=xs+xl;
     27    aa += Max(caa - pos, vec2i(0));
     28    bb -= Max(caa - pos, vec2i(0));
     29    pos = Max(caa, pos);
    4830
    49   uint8_t *isl=im->scan_line(ys)+xs;
     31    bb = Min(bb, cbb - vec2i(1) - pos);
     32
     33    if (!(bb >= vec2i(0)))
     34        return;
     35    screen->AddDirty(pos.x, pos.y, pos.x + bb.x, pos.y + bb.y);
     36
     37  int ye=aa.y+bb.y;
     38  int xe=aa.x+bb.x;
     39
     40  uint8_t *isl=im->scan_line(aa.y)+aa.x;
    5041  uint8_t *ssl=screen->scan_line(y)+x;
    5142  int iw=im->Size().x,sw=screen->Size().x;
    5243
    53   for (int iy=ys; iy<ye; iy++,y++,isl+=iw,ssl+=sw)
     44  for (int iy=aa.y; iy<ye; iy++,y++,isl+=iw,ssl+=sw)
    5445  {
    5546    uint8_t *s=ssl,*i=isl;
    56     for (int ix=xs; ix<xe; ix++,s++,i++)
     47    for (int ix=aa.x; ix<xe; ix++,s++,i++)
    5748    {
    5849      if (*i)
Note: See TracChangeset for help on using the changeset viewer.