render.c

seismic software,very useful

                 int v0, int h0, int fence_transp, int hsize, Vec hmap,
                 Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                 int vstride, int zsize, int zframe, int zstride, int zdir,
                 int zinv, int frame4, int stride4, int frame5, int stride5,
                 int skew)
{
    register Buffer vdata;
    Buffer   hdata;
    register Buffer vimage;
    Buffer   himage;
    register Buffer eimage;
    register int vindex;
    int      hindex;
    register Shadow vshadow;
    Shadow   hshadow;
    register Shadow eshadow;
    register Zbuffer vzbuffer;
    Zbuffer  hzbuffer;
    register Vec vmap0;
    register Vec emap;
    register Buffer cmap;
    int      ih;
    register int z;
    register Vec vinterp0;
    register int vstep;
    register Buffer vdata11, vdata12, vdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    hdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    himage = image + wide * v0 + h0;
    hshadow = shadow + wide * v0 + h0;
    eshadow = shadow + wide * hite;
    hzbuffer = zbuffer + wide * v0 + h0;
    hindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = vmap + vsize;
    vstep = wide;
    cmap = map;
    for( ih = 0, hmap += hsize - 1; ih < hsize; ih++, hmap-- ){
        vdata = hdata + *hmap;
        vindex = hindex + *hmap;
        for( vmap0 = vmap, vimage = himage, vshadow = hshadow;
             vmap0 < emap && vimage < eimage; vimage += vstep, vshadow += vstep ){
            if (vdata[*vmap0] > *vimage ){
                *vshadow = vindex + *vmap0;
            }
            *vimage = *(tmap + (*vimage << 8) + vdata[*vmap0++]);
        }
        himage += 1 - skew * wide;
        hshadow += 1 - skew * wide;
    }
}

void RenderFrontFenceHorz(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                     unsigned char *map, unsigned char *tmap, int wide,
                     int hite, int v0, int h0, int fence_transp, int hsize,
                     Vec hmap, Vec hinterp, int hstride, int vsize, Vec vmap,
                     Vec vinterp, int vstride, int zsize, int zframe,
                     int zstride, int zdir, int zinv, int frame4, int stride4,
                     int frame5, int stride5, int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    int      vindex;
    register int hindex;
    Shadow   vshadow;
    register Shadow hshadow;
    register Shadow eshadow;
    Zbuffer  vzbuffer;
    register Zbuffer hzbuffer;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;
    register int z;
    register Vec hinterp0;
    register Buffer hdata11, hdata12, hdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vzbuffer = zbuffer + wide * v0 + h0 + vsize * skew;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    z = zinv;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        hindex = vindex + *vmap;
        for( hmap0 = hmap, himage = vimage, hshadow = vshadow, hzbuffer =
             vzbuffer; hmap0 < emap && himage < eimage;
             hmap0++, himage++, hshadow++, hzbuffer++ ){
            if (z > (int) *hzbuffer && (int) hdata[*hmap0] > fence_transp ){
                *himage = cmap[hdata[*hmap0]];
                *hshadow = (hindex + *hmap0);
                *hzbuffer = z;
            }
        }
        vimage += wide - skew;
        vshadow += wide - skew;
        vzbuffer += wide - skew;
    }
}

void RenderTopFenceHorz(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                   unsigned char *map, unsigned char *tmap, int wide, int hite,
                   int v0, int h0, int fence_transp, int hsize, Vec hmap,
                   Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                   int vstride, int zsize, int zframe, int zstride, int zdir,
                   int zinv, int frame4, int stride4, int frame5, int stride5,
                   int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    int      vindex;
    register int hindex;
    Shadow   vshadow;
    register Shadow hshadow;
    register Shadow eshadow;
    Zbuffer  vzbuffer;
    register Zbuffer hzbuffer;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;
    register int z;
    register Vec hinterp0;
    register Buffer hdata11, hdata12, hdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vzbuffer = zbuffer + wide * v0 + h0 + vsize * skew;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        hindex = vindex + *vmap;
        z = iv;
        for( hmap0 = hmap, himage = vimage, hshadow = vshadow, hzbuffer =
             vzbuffer; hmap0 < emap && himage < eimage;
             hmap0++, himage++, hshadow++, hzbuffer++ ){
            if (z > (int) *hzbuffer && (int) hdata[*hmap0] > fence_transp ){
                *himage = cmap[hdata[*hmap0]];
                *hshadow = (hindex + *hmap0);
                *hzbuffer = z;
            }
        }
        vimage += wide - skew;
        vshadow += wide - skew;
        vzbuffer += wide - skew;
    }
}

void RenderSideFenceVert(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                    unsigned char *map, unsigned char *tmap, int wide, int hite,
                    int v0, int h0, int fence_transp, int hsize, Vec hmap,
                    Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                    int vstride, int zsize, int zframe, int zstride, int zdir,
                    int zinv, int frame4, int stride4, int frame5, int stride5,
                    int skew)
{
    register Buffer vdata;
    Buffer   hdata;
    register Buffer vimage;
    Buffer   himage;
    register Buffer eimage;
    register int vindex;
    int      hindex;
    register Shadow vshadow;
    Shadow   hshadow;
    register Shadow eshadow;
    register Zbuffer vzbuffer;
    Zbuffer  hzbuffer;
    register Vec vmap0;
    register Vec emap;
    register Buffer cmap;
    int      ih;
    register int z;
    register Vec vinterp0;
    register int vstep;
    register Buffer vdata11, vdata12, vdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    hdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    himage = image + wide * v0 + h0;
    hshadow = shadow + wide * v0 + h0;
    eshadow = shadow + wide * hite;
    hzbuffer = zbuffer + wide * v0 + h0;
    hindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = vmap + vsize;
    vstep = wide;
    cmap = map;
    for( ih = 0, hmap += hsize - 1; ih < hsize; ih++, hmap-- ){
        vdata = hdata + *hmap;
        vindex = hindex + *hmap;
        z = hsize - ih - 1;
        for( vmap0 = vmap, vimage = himage, vshadow = hshadow, vzbuffer =
             hzbuffer; vmap0 < emap && vimage < eimage;
             vmap0++, vimage += vstep, vshadow += vstep, vzbuffer += vstep ){
            if (z > (int) *vzbuffer && (int) vdata[*vmap0] > fence_transp ){
                *vimage = cmap[vdata[*vmap0]];
                *vshadow = (vindex + *vmap0);
                *vzbuffer = z;
            }
        }
        himage += 1 - skew * wide;
        hshadow += 1 - skew * wide;
        hzbuffer += 1 - skew * wide;
    }
}

void RenderFrontFenceInterpHorz(Buffer data, Buffer image, Shadow shadow,
                           Zbuffer zbuffer, unsigned char *map,
                           unsigned char *tmap, int wide, int hite, int v0,
                           int h0, int fence_transp, int hsize, Vec hmap,
                           Vec hinterp, int hstride, int vsize, Vec vmap,
                           Vec vinterp, int vstride, int zsize, int zframe,
                           int zstride, int zdir, int zinv, int frame4,
                           int stride4, int frame5, int stride5, int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    int      vindex;
    register int hindex;
    Shadow   vshadow;
    register Shadow hshadow;
    register Shadow eshadow;
    Zbuffer  vzbuffer;
    register Zbuffer hzbuffer;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;
    register int z;
    register Vec hinterp0;
    register Buffer hdata11, hdata12, hdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vzbuffer = zbuffer + wide * v0 + h0 + vsize * skew;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    z = zinv;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        hdata21 = hdata + hstride;
        hdata12 = hdata + vstride;
        hdata11 = hdata + hstride + vstride;
        vinterp1 = *vinterp++;
        vinterp2 = (MAP_INTERP - vinterp1);
        hindex = vindex + *vmap;
        for( hmap0 = hmap, himage = vimage, hshadow = vshadow, hzbuffer =
             vzbuffer, hinterp0 = hinterp; hmap0 < emap && himage < eimage;
             hmap0++, himage++, hshadow++, hzbuffer++, hinterp0++ ){
            if (z > (int) *hzbuffer && (int) hdata[*hmap0] > fence_transp ){
                hinterp1 = *hinterp0;
                hinterp2 = (MAP_INTERP - hinterp1);
                *himage = cmap[
                               ((int) hdata[*hmap0] * vinterp2 * hinterp2
                                + (int) hdata21[*hmap0] * vinterp2 * hinterp1
                                + (int) hdata12[*hmap0] * vinterp1 * hinterp2
                                +
                                (int) hdata11[*hmap0] * vinterp1 * hinterp1) /
                               RENDER_INTERP];
                *hshadow = (hindex + *hmap0);
                *hzbuffer = z;
            }
        }
        vimage += wide - skew;
        vshadow += wide - skew;
        vzbuffer += wide - skew;
    }
}

void RenderTopFenceInterpHorz(Buffer data, Buffer image, Shadow shadow,
                         Zbuffer zbuffer, unsigned char *map,
                         unsigned char *tmap, int wide, int hite, int v0,
                         int h0, int fence_transp, int hsize, Vec hmap,
                         Vec hinterp, int hstride, int vsize, Vec vmap,
                         Vec vinterp, int vstride, int zsize, int zframe,
                         int zstride, int zdir, int zinv, int frame4,
                         int stride4, int frame5, int stride5, int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    int      vindex;
    register int hindex;
    Shadow   vshadow;
    register Shadow hshadow;
    register Shadow eshadow;
    Zbuffer  vzbuffer;
    register Zbuffer hzbuffer;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;
    register int z;
    register Vec hinterp0;
    register Buffer hdata11, hdata12, hdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vzbuffer = zbuffer + wide * v0 + h0 + vsize * skew;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        hdata21 = hdata + hstride;
        hdata12 = hdata + vstride;
        hdata11 = hdata + hstride + vstride;
        vinterp1 = *vinterp++;
        vinterp2 = (MAP_INTERP - vinterp1);
        hindex = vindex + *vmap;
        z = iv;
        for( hmap0 = hmap, himage = vimage, hshadow = vshadow, hzbuffer =
             vzbuffer, hinterp0 = hinterp; hmap0 < emap && himage < eimage;
             hmap0++, himage++, hshadow++, hzbuffer++, hinterp0++ ){
            if (z > (int) *hzbuffer && (int) hdata[*hmap0] > fence_transp ){
                hinterp1 = *hinterp0;
                hinterp2 = (MAP_INTERP - hinterp1);
                *himage = cmap[
                               ((int) hdata[*hmap0] * vinterp2 * hinterp2
                                + (int) hdata21[*hmap0] * vinterp2 * hinterp1
                                + (int) hdata12[*hmap0] * vinterp1 * hinterp2
                                +
                                (int) hdata11[*hmap0] * vinterp1 * hinterp1) /
                               RENDER_INTERP];
                *hshadow = (hindex + *hmap0);
                *hzbuffer = z;
            }
        }
        vimage += wide - skew;
        vshadow += wide - skew;
        vzbuffer += wide - skew;
    }
}

void RenderSideFenceInterpVert(Buffer data, Buffer image, Shadow shadow,
                          Zbuffer zbuffer, unsigned char *map,
                          unsigned char *tmap, int wide, int hite, int v0,
                          int h0, int fence_transp, int hsize, Vec hmap,
                          Vec hinterp, int hstride, int vsize, Vec vmap,
                          Vec vinterp, int vstride, int zsize, int zframe,
                          int zstride, int zdir, int zinv, int frame4,
                          int stride4, int frame5, int stride5, int skew)
{
    register Buffer vdata;
    Buffer   hdata;
    register Buffer vimage;
    Buffer   himage;
    register Buffer eimage;
    register int vindex;
    int      hindex;
    register Shadow vshadow;
    Shadow   hshadow;
    register Shadow eshadow;
    register Zbuffer vzbuffer;
    Zbuffer  hzbuffer;
    register Vec vmap0;
    register Vec emap;
    register Buffer cmap;
    int      ih;
    register int z;
    register Vec vinterp0;
    register int vstep;
    register Buffer vdata11, vdata12, vdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    hdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    himage = image + wide * v0 + h0;
    hshadow = shadow + wide * v0 + h0;
    eshadow = shadow + wide * hite;
    hzbuffer = zbuffer + wide * v0 + h0;
    hindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = vmap + vsize;
    vstep = wide;
    cmap = map;
    for( ih = 0, hmap += hsize - 1, hinterp += hsize - 1; ih < hsize;
         ih++, hmap-- ){
        vdata = hdata + *hmap;
        vdata21 = vdata + vstride;
        vdata12 = vdata + hstride;
        vdata11 = vdata + vstride + hstride;
        hinterp1 = *hinterp--;
        hinterp2 = (MAP_INTERP - hinterp1);
        vindex = hindex + *hmap;
        z = hsize - ih - 1;
        for( vmap0 = vmap, vimage = himage, vshadow = hshadow, vzbuffer =
             hzbuffer, vinterp0 = vinterp; vmap0 < emap && vimage < eimage;
             vmap0++, vimage += vstep, vshadow += vstep, vzbuffer +=
             vstep, vinterp0++ ){
            if (z > (int) *vzbuffer && (int) vdata[*vmap0] > fence_transp ){
                vinterp1 = *vinterp0;
                vinterp2 = (MAP_INTERP - vinterp1);
                *vimage = cmap[
                               ((int) vdata[*vmap0] * hinterp2 * vinterp2
                                + (int) vdata21[*vmap0] * hinterp2 * vinterp1
                                + (int) vdata12[*vmap0] * hinterp1 * vinterp2
                                +
                                (int) vdata11[*vmap0] * hinterp1 * vinterp1) /
                               RENDER_INTERP];
                *vshadow = (vindex + *vmap0);
                *vzbuffer = z;
            }
        }
        himage += 1 - skew * wide;
        hshadow += 1 - skew * wide;
        hzbuffer += 1 - skew * wide;
    }
}