package com.insanityengine.ghia.renderer;
   
   import java.awt.*;
   import java.awt.image.*;
   import java.awt.event.*;
   import java.applet.*;
   
   import com.insanityengine.ghia.m3.*;
   import com.insanityengine.ghia.libograf.*;
  import com.insanityengine.ghia.pixels.*;
  
  /***
   *
   * <P>
   * </P>
   *
   * @author BrianHammond
   *
   * $Header: /usr/local/cvsroot/ghia/src/java/com/insanityengine/ghia/renderer/Scantron.java,v 1.1 2005/03/25 02:45:25 brian Exp $
   *
   */
  public class Scantron {
  
  	/*** 
  	 * 
  	 * Constructor
  	 * 
  	 */
  	public Scantron() {
  	}
  
  	/*** 
  	 * 
  	 * Constructor
  	 * 
  	 */
  	public Scantron( int width, int height ) {
  		init( width, height );
  	}
  	
  	/*** 
  	 * 
  	 * isReady
  	 * 
  	 * @return a boolean
  	 * 
  	 */
  	public final boolean isReady() {
  		return ( null != lx );
  	}
  
  	/*** 
  	 * 
  	 * init
  	 * 
  	 * @param height
  	 * 
  	 */
  	public final void init( int width, int height ) {
  		this.w = width;
  		this.h = height;
  
  		lx	= new float[ h ];
  		lz	= new float[ h ];
  		ltx	= new float[ h ];
  		lty	= new float[ h ];
  		rx	= new float[ h ];
  		rz	= new float[ h ];
  		rtx	= new float[ h ];
  		rty	= new float[ h ];
  		used = new boolean[ h ];
  	}
  
  	/*** 
  	 * 
  	 * hasCandy
  	 * 
  	 * @param i
  	 * 
  	 * @return a boolean
  	 * 
  	 */
  	public final boolean hasCandy( int i ) {
  		return ( used[ i ] );
  	}
  
  	/*** 
  	 * 
  	 * getDistance
  	 * 
  	 * @param i
  	 * 
  	 * @return a float
  	 * 
  	 */
  	public final float getDistance( int i ) {
  		return 1 + rx[ i ] - lx[ i ];
  	}
  
 	public final float getLx( int i ) {   return lx[ i ]; }
 	public final float getLz( int i ) {   return lz[ i ]; }
 	public final float getLtx( int i ) {  return ltx[ i ]; }
 	public final float getLty( int i ) {  return lty[ i ]; }
 	
 	public final float getRx( int i ) {   return rx[ i ]; }
 	public final float getRz( int i ) {   return rz[ i ]; }
 	public final float getRtx( int i ) {  return rtx[ i ]; }
 	public final float getRty( int i ) {  return rty[ i ]; }
 
 	/*** 
 	 * 
 	 * reset
 	 * 
 	 */
 	public final void reset() {
 		int cleared = 1;
 		rx[ 0 ] = -M3_Constants.bigNumber;
 		lx[ 0 ] = +M3_Constants.bigNumber;
 		used[ 0 ] = false;
 
 		// use speedy array copy trick:
 		for ( cleared = 1 ; cleared < h / 2 ; cleared *= 2 ) {
 			System.arraycopy( rx, 0, rx, cleared, cleared );
 			System.arraycopy( lx, 0, lx, cleared, cleared );
 			System.arraycopy( used, 0, used, cleared, cleared );
 		}
 		
 		// clear any remaining elements
 		System.arraycopy( rx, 0, rx, cleared, h - cleared );
 		System.arraycopy( lx, 0, lx, cleared, h - cleared );
 		System.arraycopy( used, 0, used, cleared, h - cleared );
 	}
 	
 	/*** 
 	 * 
 	 * setL
 	 * 
 	 * @param i
 	 * @param x
 	 * @param z
 	 * @param tx
 	 * @param ty
 	 * 
 	 */
 	public final void setL( int i, float _x, float _z, float _tx, float _ty ) {
 		if ( _x < lx[ i ] ) {
 			used[ i ] = true;
 			lx[ i ] = _x; 
 			lz[ i ] = _z; 
 			ltx[ i ] = _tx; 
 			lty[ i ] = _ty;
 		}
 	}
 	
 	/*** 
 	 * 
 	 * setR
 	 * 
 	 * @param i
 	 * @param x
 	 * @param z
 	 * @param tx
 	 * @param ty
 	 * 
 	 */
 	public final void setR( int i, float _x, float _z, float _tx, float _ty ) {
 		if ( _x < rx[ i ] ) {
 			used[ i ] = true;
 			rx[ i ] = _x; 
 			rz[ i ] = _z; 
 			rtx[ i ] = _tx; 
 			rty[ i ] = _ty;
 		}
 	}
 
 	/*** 
 	 * 
 	 * set
 	 * 
 	 * @param i
 	 * @param x
 	 * @param z
 	 * @param tx
 	 * @param ty
 	 * 
 	 */
 	public final void set( int i, float _x, float _z, float _tx, float _ty ) {
 		if ( _x < lx[ i ] ) {
 			used[ i ] = true;
 			lx[ i ] = _x; 
 			lz[ i ] = _z; 
 			ltx[ i ] = _tx; 
 			lty[ i ] = _ty;
 		}
 		if ( _x > rx[ i ] ) {
 			used[ i ] = true;
 			rx[ i ] = _x; 
 			rz[ i ] = _z; 
 			rtx[ i ] = _tx; 
 			rty[ i ] = _ty;
 		}
 	}
 
 	/*** 
 	 * 
 	 * set
 	 * 
 	 */
 	public final void set( 
 		int i,
 		float _lx, float _lz, float _ltx, float _lty,
 		float _rx, float _rz, float _rtx, float _rty
 	) {
 		if ( _lx < lx[ i ] ) {
 			used[ i ] = true;
 			lx[ i ] = _lx; 
 			lz[ i ] = _lz; 
 			ltx[ i ] = _ltx; 
 			lty[ i ] = _lty;
 		}
 		if ( _rx > rx[ i ] ) {
 			used[ i ] = true;
 			rx[ i ] = _rx; 
 			rz[ i ] = _rz; 
 			rtx[ i ] = _rtx; 
 			rty[ i ] = _rty;
 		}
 	}
 
 	/*** 
 	 * 
 	 * scanPolyEdge
 	 * 
 	 * @param p0in
 	 * @param p1in
 	 * 
 	 */
 	public final void scanPolyEdge( Pt3 p0_in, Pt3 p1_in ) {
 		if ( p0_in.y == p1_in.y ) {
 			horizonalLine( p0_in, p1_in );
 		} else {
 			reallyScan( p0_in, p1_in );
 		}
 	}
 
 	////
 
 	private int w, h;
 
 	private float lx[], lz[], ltx[], lty[];
 	private float rx[], rz[], rtx[], rty[];
 
 	private boolean used[];
 
 	/*** 
 	 * 
 	 * horizonalLine
 	 * 
 	 * @param p0in
 	 * @param p1in
 	 * 
 	 */
 	private final void horizonalLine( Pt3 p0_in, Pt3 p1_in ) {
 		if ( p0_in.y >= 0 && p0_in.y < h ) {
 			setL( ( int ) p0_in.y, p0_in.x, p0_in.z, p0_in.s, p0_in.t );
 			setR( ( int ) p1_in.y, p1_in.x, p1_in.z, p1_in.s, p1_in.t );
 		}
 	}
 
 	/*** 
 	 * 
 	 * reallyScan
 	 * 
 	 * @param p0in
 	 * @param p1in
 	 * 
 	 */
 	private final void reallyScan( Pt3 p0_in, Pt3 p1_in ) {
 
 		Pt3 p0 = p0_in;
 		Pt3 p1 = p1_in;
 
 		x0 = ( int ) p0.x;
 		y0 = ( int ) p0.y;
 		
 		x1 = ( int ) p1.x;
 		y1 = ( int ) p1.y;
 	
 		diffx = ( x1 - x0 );
 		diffy = ( y1 - y0 );
 		
 		adiffx = ( diffx < 0 ) ? -diffx : diffx;
 		adiffy = ( diffy < 0 ) ? -diffy : diffy;
 
 		boolean recalc = false;
 		boolean useX = true;
 
 		if ( adiffx < adiffy && 0 != diffx ) {
 			useX = true;
 			if ( diffx < 0 ) {
 				recalc = true;
 			}
 		} else {
 			useX = false;
 			if ( diffy < 0 ) {
 				recalc = true;
 			}
 		}		
 
 		if ( recalc ) {
 			p1 = p0_in;
 			p0 = p1_in;
 		
 			x0 = ( int ) p0.x;
 			y0 = ( int ) p0.y;
 			
 			x1 = ( int ) p1.x;
 			y1 = ( int ) p1.y;
 		
 			diffx = ( x1 - x0 );
 			diffy = ( y1 - y0 );
 		}
 
 		z = p0.z;
 		dz = p1.z - z;
 		tx = p0.s;
 		ty = p0.t;
 		
 		if ( useX ) {
 			
 			zinc = dz / ( adiffy + adiffx );
 			o_inc = diffy / ( float ) ( 1 + adiffx );
 
 			tx_inc = ( p1.s - p0.s ) / ( adiffx + adiffy );
 			ty_inc = ( p1.t - p0.t ) / ( adiffx + adiffy );
 		
 			if ( diffy < 0 ) linc = -1;
 			else linc = 1;
 
 			for ( x = x0, o = y0 ; x != x1 + 1  ; o += o_inc, x++ ) {
 				
 				next = ( int ) ( o + o_inc + linc );
 				for ( j = ( int ) o ; j != next ; j += linc ) {
 					if ( j > 0 && j < h ) {
 						//scanner[ j ].set( x, z, tx, ty );
 						set( j, x, z, tx, ty );
 					}
 					
 					z += zinc;
 					tx += tx_inc;
 					ty += ty_inc;
 				}
 				
 			}
 			
 		} else {
 			
 			zinc = dz / ( adiffy + 1 );
 			o_inc = diffx / ( float ) ( 1 + adiffy );
 			
 			tx_inc = ( p1.s - p0.s ) / ( 1 + adiffy );
 			ty_inc = ( p1.t - p0.t ) / ( 1 + adiffy );
 		
 			for ( y = y0, o = x0 ; y != y1 + 1 ; o += o_inc, y++ ) {
 				
 				if ( y > 0 && y < h ) {
 					//scanner[ y ].set( 
 					set( 
 						y,
 						o,         z,        tx, ty,
 						o + o_inc, z + zinc, tx, ty
 					);
 				}
 				
 				z += zinc;
 				tx += tx_inc;
 				ty += ty_inc;
 			}
 		}
 	}
 	
 	// pulled from scanPolyEdge
 		int x0, y0;
 		int x1, y1;
 		int diffx, diffy;
 		int adiffx, adiffy;
 
 		int x, y, j;
 
 		// for that tricky depth thang
 		float zinc;
 		float z;
 		float dz;
 
 		// for boppin' 'round in x/y space
 		float o, o_inc;
 		int next, inc, linc;
 
 		// for movin' around in yucky ole texture space...
 		float tx;
 		float ty;
 		float tx_inc, ty_inc;
 
 };
 
 /***
  *
  * $Log: Scantron.java,v $
  * Revision 1.1  2005/03/25 02:45:25  brian
  * split up a bit
  *
  *
  */