package com.insanityengine.ghia.pixels;
   
   import java.awt.Image;
   import java.awt.image.*;
   
   import com.insanityengine.ghia.m3.*;
   
   /***
    *
   * <P>
   * Think of the Image as a tasty treat with an object wrapper.
   * An ImageSkin strips off the skin and (re)encapsulate the meat.
   * </P>
   *
   * <P>
   * Pretty sick, huh? It is meant to make it easier to muck around 
   * with the image bits of the Image
   * </P>
   *
   * @author BrianHammond
   *
   * $Header: /usr/local/cvsroot/ghia/src/java/com/insanityengine/ghia/pixels/ImageSkin.java,v 1.7 2005/03/26 04:50:12 brian Exp $
   *
   */
  
  public class ImageSkin implements PixelBufferReadInterface {
  
  	/***
  	 *
  	 * Constructor
  	 *
  	 * @param width of the ImageSkin
  	 * @param height of the ImageSkin
  	 * @param pixels to use
  	 *
  	 */
  	public ImageSkin( int width, int height, int[] pixels ) {
  		init( width, height, pixels );
  	}
  
  	/***
  	 *
  	 * Constructor
  	 *
  	 * @param image to skin
  	 * @param observer to us
  	 *
  	 */
  	public ImageSkin( Image image, ImageObserver observer ) {
  		init( image, observer );
  	}
  
  	/***
  	 *
  	 * Constructor
  	 *
  	 * @param pixelBuffer to skin
  	 *
  	 */
  	public ImageSkin( PixelBufferReadInterface pixelBuffer ) {
  		init( pixelBuffer );
  	}
  
  	/***
  	 *
  	 * Use these new goodies for your guts
  	 *
  	 * @param width of the ImageSkin
  	 * @param height of the ImageSkin
  	 * @param pixels to use
  	 *
  	 */
  	public void init( int w, int h, int[] pixels ) {
  		this.w = w;
  		this.h = h;
  		this.pixels = pixels;
  		clamp.setPixels( w, h, pixels );
  		wrap.setPixels( w, h, pixels );
  	}
  
  	/***
  	 *
  	 * Use a PixelGrabber to pull out the guts of the image
  	 *
  	 * @param image to skin
  	 * @param observer to us
  	 *
  	 */
  	public void init( Image image, ImageObserver observer ) {
  		if ( null == image ) {
  			System.out.println( "ImageSkin: null image" );
  			return;
  		}
  
  		w = image.getWidth( observer );
  		h = image.getHeight( observer );
  
  		if ( w < 0 || h < 0 ) {
  			System.out.println( "ImageSkin: bad image " + observer );
 			return;
 		}
 		
 		max = w * h;
 		pixels = new int[ max ];
 		PixelGrabber pg = new PixelGrabber( image, 0, 0, w, h, pixels, 0, w );
 		try { 
 			pg.grabPixels(); 
 		} catch ( Exception e ) {
 			e.printStackTrace();
 			return;
 		} 
 
 		init( w, h, pixels );
 	}
 
 	/***
 	 *
 	 * 
 	 *
 	 * @param pixelBuffer to skin
 	 *
 	 */
 	public void init( PixelBufferReadInterface pixelBuffer ) {
 		init( 
 			pixelBuffer.getWidth()
 			,
 			pixelBuffer.getHeight()
 			, 
 			pixelBuffer.getPixels()
 		);
 	}
 
 	/***
 	 * 
 	 * Convert a coordinate (x,y) to an index with bounds checking
 	 * ala clamp
 	 * 
 	 * @param x coordinate
 	 * @param y coordinate
 	 * 
 	 * @return the equivalent index
 	 * 
 	 */
 	int getIdx( int x, int y ) {
 		if ( x < 0 ) x = 0;
 		if ( y < 0 ) y = 0;
 
 		if ( x >= w ) x = w - 1;
 		if ( y >= h ) y = h - 1;
 
 		return x + y * w;
 	}
 
 	/***
 	 * 
 	 * Convert a coordinate (tx,ty) where tx and ty reside on 
 	 * the interval betwen 0 and 1 and convert to a corresponding 
 	 * (x,y). Performs bounds checking
 	 * 
 	 * @param x coordinate
 	 * @param y coordinate
 	 * 
 	 * @return the equivalent index
 	 * 
 	 */
 	public final int getScaledIdx( float tx, float ty ) {
 		return getIdx( ( int ) ( w * tx ), ( int ) ( h * ty ) );
 	}
 
 	/***
 	 * 
 	 * Get the pixel value at (x,y) using the current PixelGetter
 	 * 
 	 * @param x coordinate
 	 * @param y coordinate
 	 * 
 	 * @return the appropriate pixel value
 	 * 
 	 */
 	public final int getPixelAt( int x, int y ) {
 		return type.getPixelAt( x, y );
 	}
 
 	/*** 
 	 * 
 	 * getPixelAtCoord
 	 * 
 	 * @param tx
 	 * @param ty
 	 * 
 	 * @return a int
 	 * 
 	 */
 	public final int getPixelAtCoord( float tx, float ty ) {
 		return getPixelAt(
 			( int ) ( w * tx )
 			,
 			( int ) ( h * ty )
 		);
 	}
 
 	/***
 	 * 
 	 * Set the current PixelGetter via funtion index
 	 * 
 	 * @param funk tion to use
 	 * 
 	 */
 	public final void setFunction( int funk ) {
 		switch ( funk ) {
 			case M3_Constants.TEXT_WRAP: type = wrap; break;
 			default: type = clamp;
 		}
 	}
 
 	/***
 	 * 
 	 * Determines the width of the buffer.
 	 * 
 	 * @return the width of this buffer
 	 * 
 	 */
 	public final int getWidth() { 
 		return w; 
 	}
 
 	/***
 	 *
 	 * Determines the height of the buffer.
 	 *
 	 * @return the height of this buffer
 	 *
 	 */
 	public final int getHeight() { 
 		return h; 
 	}
 
 	/***
 	 *
 	 * Get the pixels
 	 *
 	 * @return the pixels
 	 *
 	 */
 	public int[] getPixels() {
 		return pixels;
 	}
 	
 	/***
 	 *
 	 * Set the PixelGetter class for subsequent calls to get
 	 * getPixelAt
 	 *
 	 * @param pgetter to use 
 	 *
 	 */
 	public final void setPixelGetter( PixelGetter pgetter ) {
 		type = pgetter;
 		type.setPixels( w, h, pixels );
 	}
 
 	/***
 	 * 
 	 * Needed to implement PixelBufferReadInterface
 	 *
 	 */
 	public int getClearColor() {
 		return 0;
 	}
 
 	/*** 
 	 * 
 	 * getMax
 	 * 
 	 * @return a int
 	 * 
 	 */
 	public int getMax() { 
 		return max;
 	}
 
 	/*** 
 	 * 
 	 * toString
 	 * 
 	 * @return a String
 	 * 
 	 */
 	public String toString() {
 		return (
 			super.toString() 
 			+ "[" 
 			+ "size=" + w + "x" + h
 			+ "]"
 		);
 	}
 
 	////////////////////////////
 	
 	private int w = 0, h = 0, max = 0;
 	private int[] pixels = null;
 
 	private ClampPixelGetter clamp = new ClampPixelGetter();
 	private WrapPixelGetter wrap = new WrapPixelGetter();
 	private PixelGetter type = clamp;
 	
 	private final static int [] nonPixels = { 0xFF0000DA };
 };
 
 /***
  *
  * $Log: ImageSkin.java,v $
  * Revision 1.7  2005/03/26 04:50:12  brian
  * more fun
  *
  * Revision 1.6  2005/03/26 03:37:04  brian
  * make methods public
  *
  * Revision 1.5  2005/03/21 05:42:13  brian
  * add toString method
  *
  * Revision 1.4  2005/03/19 17:50:02  brian
  * repackaging
  *
  * Revision 1.3  2005/02/17 03:31:13  brian
  * good stuff???
  *
  * Revision 1.2  2004/09/02 15:43:46  brian
  * redefine PixelBufferReadInterface so BufferFx can use it as an interface rather than the RenderInterface
  *
  * Revision 1.1  2004/09/02 13:17:16  brian
  * the big reorg
  *
  * Revision 1.9  2004/09/01 01:10:42  brian
  * fix class level javadoc placement
  *
  * Revision 1.8  2004/09/01 00:11:06  brian
  * author, log and header stuff
  *
  *
  */