prj/tech/libsrc/g2/genlil.c

   1 /*
   2  * $Source: x:/prj/tech/libsrc/g2/RCS/genlil.c $
   3  * $Revision: 1.6 $
   4  * $Author: KEVIN $
   5  * $Date: 1996/12/20 11:01:04 $
   6  *
   7  * This file is part of the g2 library.
   8  *
   9  */
  10
  11 #include <g2d.h>
  12 #include <tmapd.h>
  13
  14 void gen_flat8_lit_il(int x, int xf, fix u, fix v)
  15 {
  16    g2s_tmap_info *ti=&g2d_tmap_info;
  17    int y;
  18    fix i, du, dv, di, err, err_mask;
  19    int row;
  20    uchar *bits;
  21    gdupix_func *pix_func;
  22    gdlpix_func *lpix8_func;
  23    uint offset_max;
  24
  25    y = ti->y;
  26    if (x>=xf)
  27       return;
  28
  29    bits = ti->bm->bits;
  30    row = ti->bm->row;
  31    offset_max = ti->bm->h * row - 1;
  32    du = ti->dux;
  33    dv = ti->dvx;
  34    di = ti->dix;
  35    i = ti->i;
  36    err = 0;
  37    err_mask = (g2d_error_dither) ? (FIX_UNIT-1) : 0;
  38    pix_func = ti->pix_func;
  39    lpix8_func = ti->lpix_func;
  40
  41    if (ti->bm->flags&BMF_TRANS) {
  42       do {
  43          uint offset = fix_int(v)*row + fix_int(u);
  44          uchar c;
  45          if (offset>offset_max) offset = 0;
  46          c=bits[offset];
  47          if (c)
  48             pix_func(lpix8_func(i+err, c), x, y);
  49          u += du;
  50          v += dv;
  51          i += di;
  52          err = (err+i)&err_mask;
  53          x++;
  54       } while (x<xf);
  55    } else {
  56       do {
  57          uint offset = fix_int(v)*row + fix_int(u);
  58          uchar c;
  59          if (offset>offset_max) offset = 0;
  60          c=bits[offset];
  61          pix_func(lpix8_func(i+err, c), x, y);
  62          u += du;
  63          v += dv;
  64          i += di;
  65          err = (err+i)&err_mask;
  66          x++;
  67       } while (x<xf);
  68    }
  69 }
  70
  71 void gen_flat8_lit_il_wrap(int x, int xf, fix u, fix v)
  72 {
  73    g2s_tmap_info *ti=&g2d_tmap_info;
  74    int y;
  75    fix i, du, dv, di, err, err_mask;
  76    fix u_mask, v_mask;
  77    int row;
  78    uchar *bits;
  79    gdupix_func *pix_func;
  80    gdlpix_func *lpix8_func;
  81    grs_bitmap *bm;
  82
  83    y = ti->y;
  84    if (x>=xf)
  85       return;
  86
  87    bm = ti->bm;
  88    y = ti->y;
  89    bits = bm->bits;
  90    row = bm->row;
  91    u_mask = fix_make(bm->w-1,0);
  92    v_mask = fix_make(bm->h-1,0)<<bm->wlog;
  93    v <<= bm->wlog;
  94    du = ti->dux;
  95    dv = ti->dvx<<bm->wlog;
  96    di = ti->dix;
  97    i = ti->i;
  98    pix_func = ti->pix_func;
  99    lpix8_func = ti->lpix_func;
 100    err = 0;
 101    err_mask = (g2d_error_dither) ? (FIX_UNIT-1) : 0;
 102
 103    if (ti->bm->flags&BMF_TRANS) {
 104       do {
 105          uint offset = ((ulong )((v&v_mask) + (u&u_mask)))>>16;
 106          uchar c = bits[offset];
 107          if (c)
 108             pix_func(lpix8_func(i+err, c), x, y);
 109          u += du;
 110          v += dv;
 111          i += di;
 112          err = (err+i)&err_mask;
 113          x++;
 114       } while (x<xf);
 115    } else {
 116       do {
 117          uint offset = ((ulong )((v&v_mask) + (u&u_mask)))>>16;
 118          pix_func(lpix8_func(i+err, bits[offset]), x, y);
 119          u += du;
 120          v += dv;
 121          i += di;
 122          err = (err+i)&err_mask;
 123          x++;
 124       } while (x<xf);
 125    }
 126 }
 127
 128 void gen_flat16_lit_il(int x, int xf, fix u, fix v)
 129 {
 130    g2s_tmap_info *ti=&g2d_tmap_info;
 131    int y;
 132    fix i, du, dv, di, err, err_mask;
 133    int row;
 134    ushort *bits;
 135    gdupix_func *pix_func;
 136    gdlpix_func *lpix16_func;
 137    uint offset_max;
 138
 139    y = ti->y;
 140    if (x>=xf)
 141       return;
 142
 143    bits = (ushort *)ti->bm->bits;
 144    row = ti->bm->row;
 145    offset_max = ti->bm->h * row - 1;
 146    du = ti->dux;
 147    dv = ti->dvx;
 148    di = ti->dix;
 149    i = ti->i;
 150    pix_func = ti->pix_func;
 151    lpix16_func = ti->lpix_func;
 152    err = 0;
 153    err_mask = (g2d_error_dither) ? (FIX_UNIT-1) : 0;
 154
 155    if (ti->bm->flags&BMF_TRANS) {
 156       do {
 157          uint offset = fix_int(v)*row + fix_int(u);
 158          ushort c;
 159          if (offset>offset_max) offset = 0;
 160          c=bits[offset];
 161          if (c)
 162             pix_func(lpix16_func(i+err, c), x, y);
 163          u += du;
 164          v += dv;
 165          i += di;
 166          err = (err+i)&err_mask;
 167          x++;
 168       } while (x<xf);
 169    } else {
 170       do {
 171          uint offset = fix_int(v)*row + fix_int(u);
 172          ushort c;
 173          if (offset>offset_max) offset = 0;
 174          c=bits[offset];
 175          pix_func(lpix16_func(i+err, c), x, y);
 176          u += du;
 177          v += dv;
 178          i += di;
 179          err = (err+i)&err_mask;
 180          x++;
 181       } while (x<xf);
 182    }
 183 }
 184
 185 void gen_flat16_lit_il_wrap(int x, int xf, fix u, fix v)
 186 {
 187    g2s_tmap_info *ti=&g2d_tmap_info;
 188    int y;
 189    fix i, du, dv, di, err, err_mask;
 190    fix u_mask, v_mask;
 191    int row;
 192    ushort *bits;
 193    gdupix_func *pix_func;
 194    gdlpix_func *lpix16_func;
 195    grs_bitmap *bm;
 196
 197    y = ti->y;
 198    if (x>=xf)
 199       return;
 200
 201    bm = ti->bm;
 202    y = ti->y;
 203    bits = (ushort *)bm->bits;
 204    row = bm->row;
 205    u_mask = fix_make(bm->w-1,0);
 206    v_mask = fix_make(bm->h-1,0)<<bm->wlog;
 207    v <<= bm->wlog;
 208    du = ti->dux;
 209    dv = ti->dvx<<bm->wlog;
 210    di = ti->dix;
 211    i = ti->i;
 212    pix_func = ti->pix_func;
 213    lpix16_func = ti->lpix_func;
 214    err = 0;
 215    err_mask = (g2d_error_dither) ? (FIX_UNIT-1) : 0;
 216
 217    if (ti->bm->flags&BMF_TRANS) {
 218       do {
 219          uint offset = ((ulong )((v&v_mask) + (u&u_mask)))>>16;
 220          ushort c = bits[offset];
 221          if (c)
 222             pix_func(lpix16_func(i+err, c), x, y);
 223          u += du;
 224          v += dv;
 225          i += di;
 226          err = (err+i)&err_mask;
 227          x++;
 228       } while (x<xf);
 229    } else {
 230       do {
 231          uint offset = ((ulong )((v&v_mask) + (u&u_mask)))>>16;
 232          pix_func(lpix16_func(i+err, bits[offset]), x, y);
 233          u += du;
 234          v += dv;
 235          i += di;
 236          err = (err+i)&err_mask;
 237          x++;
 238       } while (x<xf);
 239    }
 240 }