/**
 * spxlSliceOfPixels02
 * 2010-02-07 by subpixel
 * http://subpixels.com
 *
 * Demo using direct buffers for taking slices from the
 * pixels[] array for further procesing.
 *
 * See Java docs on Buffers:
 * - http://java.sun.com/j2se/1.5.0/docs/api/java/nio/Buffer.html
 * - http://java.sun.com/j2se/1.5.0/docs/api/java/nio/ByteBuffer.html
 * - http://java.sun.com/j2se/1.5.0/docs/api/java/nio/IntBuffer.html
 */

import java.nio.*;

static final int WIDTH = 640;
static final int HEIGHT = 480;

int totalPixels; // width * height
int maxDimension; // The larger of height and width

// Full buffer - as in full sreen buffer (all pixels)
ByteBuffer FBB;
IntBuffer FIB;

// Slice buffer - buffer containing a single row (or column) of pixels
ByteBuffer SBB;
IntBuffer SIB;

void setup()
{
  size(WIDTH, HEIGHT, P3D);

  totalPixels = width * height;  
  maxDimension = max(width, height);

  // Magic "direct buffer" allocated OUTSITE of the heap,
  // for the entire pixel array,
  // and an IntBuffer "view" of the ByteBuffer; same data,
  // Note: 4 bytes (A,R,G,B) per pixel
  FBB = ByteBuffer.allocateDirect(totalPixels * 4);
  FIB = FBB.asIntBuffer();
  
  // Magic "direct buffer" allocated OUTSITE of the heap,
  // for a slice of the pixels array (one row or column),
  // and an IntBuffer "view" of the ByteBuffer; same data,
  // Note: 4 bytes (A,R,G,B) per pixel
  SBB = ByteBuffer.allocateDirect(maxDimension * 4);
  SIB = SBB.asIntBuffer();
  
  background(0);
}

void draw()
{
  putStuffOnScreen();
  
  loadPixels(); // Processing rule to do this before accessing pixels[]
  
  int row = mouseY;
  int column = mouseX;
  
  processAllPixels();
  processSingleRow(row);
  processSingleColumn(column);
  simpleProcessAllPixels();
}

void processAllPixels()
{
  // Copy all pixels into the full buffer
  FIB.clear(); // Set position = 0, limit = capacity, ready for filling
  FIB.put(pixels); // Bulk put entire array into buffer
  FIB.flip(); // Prepare for processing

  // Do something with row slices
  // NOTE: the "slice" created IS the data in
  // the full buffer, not a copy of the data
  {
    IntBuffer FIBslice;
    for (int i = 0; i < totalPixels; i += width)
    {
	FIB.position(i); // Position to start of row
	FIBslice = FIB.slice();
	FIBslice.limit(width); // Don't want to access beyond row's data
	processSlice(FIBslice);
    }
  }

  // Do something with column slices
  // NOTE: processSingleColumn makes a COPY of the data, since is is
  // in a different arrangement than appears in the full buffer
  for (int column = 0; column < width; column++)
    processSingleColumn(column);
}

void processSingleRow(int row)
{
  // Copy single row of pixels into the slice buffer
  SIB.clear(); // Reset position and limit ready for filling
  SIB.put(pixels, row * width, width); // Bulk put one row into buffer
  SIB.flip(); // Prepare for processing
  processSlice(SIB);
}

void processSingleColumn(int column)
{
  // Copy single column of pixels into the slice buffer
  SIB.clear(); // Reset position and limit ready for filling

  // Note that totalPixels isn't an "exact" limit here, but
  // catches going past the last row perfectly well.
  for (int i = column; i < totalPixels; i += width)
    SIB.put(pixels[i]); // Put single pixel's int into buffer

  SIB.flip(); // Prepare for processing
  processSlice(SIB);
}

void processSlice(IntBuffer slice)
{
  int pixel;
  
  while (slice.hasRemaining())
  {
    pixel = slice.get();
    processPixel(pixel);
  }
}

void simpleProcessAllPixels()
{
  // Process rows
  for (int base = 0; base < totalPixels; base += width)
    processSlice(pixels, base, width, 1);

  // Process columns
  for (int base = 0; base < width; base++)
    processSlice(pixels, base, height, 1);
}

// Process a slice of n=elements items from pixelArray[], starting
// at {base} and moving in increments of {step}
void processSlice(int[] pixelArray, int base, int elements, int step)
{
  final int end = base + elements * step;
  for (int i = base; i < end; i += step)
    processPixel(pixelArray[i]);
}

void processPixel(int pixel)
{
  // Pixel processing code needs to go here!
}

void putStuffOnScreen()
{
  background(0);

  translate(width / 2, height / 2);
  rotateZ(PI/6);
  rotateX(PI/3);
  rotateY(millis() * 0.0001);
  
  stroke(255, 255, 0);
  strokeWeight(3);
  noFill();
  sphereDetail(20);
  sphere(250);
}