private void incrementalize_x(float p1[], float p2[],
                                float p[], float dp[], int x) {
    float delta = p2[X] - p1[X];
    if (delta == 0) delta = 1;
    float fraction = x + 0.5f - p1[X];
    if (smooth) {
      delta /= SUBXRES;
      fraction /= SUBXRES;
    }

    if (interpX) {
      dp[X] = (p2[X] - p1[X]) / delta;
      p[X] = p1[X] + dp[X] * fraction;
    }
    if (interpZ) {
      dp[Z] = (p2[Z] - p1[Z]) / delta;
      p[Z] = p1[Z] + dp[Z] * fraction;
      //System.out.println(p2[Z]+" " +p1[Z]+" " +dp[Z]);
    }

    if (interpARGB) {
      dp[R] = (p2[R] - p1[R]) / delta;
      dp[G] = (p2[G] - p1[G]) / delta;
      dp[B] = (p2[B] - p1[B]) / delta;
      dp[A] = (p2[A] - p1[A]) / delta;
      p[R] = p1[R] + dp[R] * fraction;
      p[G] = p1[G] + dp[G] * fraction;
      p[B] = p1[B] + dp[B] * fraction;
      p[A] = p1[A] + dp[A] * fraction;
    }

    if (interpUV) {
      if (FRY) System.out.println("delta, frac = " + delta + ", " + fraction);
      dp[U] = (p2[U] - p1[U]) / delta;
      dp[V] = (p2[V] - p1[V]) / delta;

      //if (smooth) {
      //p[U] = p1[U];
      // offset for the damage that will be done by the
      // 8 consecutive calls to scanline
      // agh.. this won't work b/c not always 8 calls before render
      // maybe lastModY - firstModY + 1 instead?
      if (FRY) System.out.println("before inc x p[V] = " + p[V] + " " + p1[V] + " " + p2[V]);
      //p[V] = p1[V] - SUBXRES1 * fraction;

      //} else {
      p[U] = p1[U] + dp[U] * fraction;
      p[V] = p1[V] + dp[V] * fraction;
      //}
    }
  }