 
                 h_tcStart[slice].x = 1.f + (h_start[slice].x - sx + 0.5f)*h_tcStep[slice].x;
                 h_tcStart[slice].y = 1.f + (h_start[slice].y - sy + 0.5f)*h_tcStep[slice].y;
-
-                h_tc3[slice] = 1.f-(slice+0.5f)*1.f/Base::vd->vox[Base::principal];
                 break;
             case 1:
                 h_tcStep[slice].x = -1.f/(ex-sx);

    tc_inc.x *= scale;
    tc_inc.y *= scale;

    // composite slices for this image line
    for(int sl =0; sl<nslice; ++sl)
    {
        if(earlyRayTerm && isOpaque(ray.d))
            break;;

        if(tc.x >= 0.f && tc.x < 1.f
                && tc.y >= 0.f && tc.y < 1.f)
        {
#if 0
            float2 mm = minmax(tc.x, tc.y, z, principal);
            float op = tex2D(tex_minmaxTable, mm.x, mm.y);
            if(op == 0.f)
            {
                tc.x += 16*tc_inc.x;
                tc.y += 16*tc_inc.y;
                if(principal == 0)
                    z += 16*c_zStep;
                else
                    z -= 16*c_zStep;
            }
#endif
                ray.accumulate(tc.x, tc.y, z);
        }
        tc.x += tc_inc.x;
        tc.y += tc_inc.y;
#if VOLTEX3D != 3

#endif
}

__device__ float2 texcoord(int2 p, int slice)
{
    return make_float2((p.x-c_start[slice].x)*c_tcStep[slice].x+c_tcStart[slice].x,
            (p.y-c_start[slice].y)*c_tcStep[slice].y+c_tcStart[slice].y);
}

template<typename Scalar, int BPV, typename Pixel, int sliceStep, int principal, bool earlyRayTerm, bool preInt>
__global__ void compositeSORC(
      uchar4 * __restrict__ img, int width, int height,
