package com.insanityengine.ghia.renderer.Edjo;
   
   import java.awt.*;
   import java.awt.image.*;
   import java.awt.event.*;
   import java.applet.*;
   
   import com.insanityengine.ghia.renderer.*;
   import com.insanityengine.ghia.m3.*;
  import com.insanityengine.ghia.libograf.*;
  import com.insanityengine.ghia.pixels.*;
  
  /***
   *
   * <P>
   * This renderer uses the BufferBase for the bulk of it's functionality
   * but implements the tricky drawPolygon method
   * </P>
   *
   *
   * @author BrianHammond
   *
   * $Header: /usr/local/cvsroot/ghia/src/java/com/insanityengine/ghia/renderer/Edjo/Edjo.java,v 1.7 2005/03/26 04:59:18 brian Exp $
   *
   */
  public class Edjo extends RendererBase {
  
  	/***
    	 *	  
    	 * Constructor	  
    	 *	  
    	 */
  	public Edjo() {
  	}
  
  	/***
  	 *
  	 * Draw a polygon
  	 *
  	 * @param count of points
  	 * @param ptz the array of Pt3 to draw
  	 *
  	 */
  	public void drawPolygon( int number, Pt3 ptz[] ) {
  		if ( onScreen( number, ptz ) ) {
  			setupEdges( number, ptz );
  			scanEdges();
  		}
  	}
  
  	////////////////////////////////////////
  
  	private int edgeCount;
  	private Edge edges[] = null;
  
  	private Hit minHit = new Hit();
  	private Hit maxHit = new Hit();
  	private Hit tmpHit = new Hit();
  
  	Hit texStart = new Hit();
  	Hit texStop  = new Hit();
  
  	private int shadeMask;
  
  	/*** 
  	 * 
  	 * onScreen
  	 * 
  	 * @param number
  	 * @param ptz
  	 * 
  	 * @return a boolean
  	 * 
  	 */
  	private final boolean onScreen( int number, Pt3 ptz[] ) {
  		if ( normal.z < 0 ) return false;
  		frustrum.toScreen( number, ptz );
  		if ( frustrum.offScreen( number, ptz ) ) return false;
  		return true;
  	}
  
  	/*** 
  	 * 
  	 * setupEdges
  	 * 
  	 * @param number
  	 * @param ptz
  	 * 
  	 */
  	private final void setupEdges( int number, Pt3 ptz[] ) {
  		if ( null == edges ) {
  			edges = new Edge[ ptz.length ];
  			for ( int i = 0 ; i < edges.length ; i++ ) {
  				edges[ i ] = new Edge();
  			}
  		}
  		
  		edgeCount = 0;
  		for ( int i = 0, next ; i < number ; i++ ) {
 
 			next = i + 1;
 			if ( next >= number ) {
 				next = 0;
 			}
 			edges[ edgeCount++ ].set( ptz[ i ], ptz[ next ] );
 		}
 	
 		// setup the shading mask	
 		int n = ( int ) ( 255 * normal.z );
 		shadeMask = ( 0xFF << 24 | n << 16 | n << 8 | n );
 	}
 
 	/*** 
 	 * 
 	 * scanEdges
 	 * 
 	 */
 	private final void scanEdges() {
 
 		int y = ( int ) findMin();
 		int maxY = ( int ) ( findMax() );
 
 		if ( 0 == y && 0 == maxY ) return;
 
 		if ( ++maxY >= h ) maxY = h - 1;
 
 		for ( ; y < maxY ; y++ ) {
 			if ( 0 <= y && findHits( y ) ) {
 				scanLine( y );
 			}
 		}
 	}
 
 	/*** 
 	 * 
 	 * findMin
 	 * 
 	 * @return a float
 	 * 
 	 */
 	private final float findMin() {
 		float min = edges[ 0 ].getMin();
 		for ( int i = 1 ; i < edgeCount ; i++ ) {
 			if ( edges[ i ].getMin() < min ) {
 				min = edges[ i ].getMin();
 			}
 		}
 		return min;
 	}
 
 	/*** 
 	 * 
 	 * findMax
 	 * 
 	 * @return a float
 	 * 
 	 */
 	private final float findMax() {
 		float max = edges[ 0 ].getMax();
 		for ( int i = 1 ; i < edgeCount ; i++ ) {
 			if ( edges[ i ].getMax() > max ) {
 				max = edges[ i ].getMax();
 			}
 		}
 		return max;
 	}
 	
 	/*** 
 	 * 
 	 * findHits
 	 * 
 	 * @return a boolean
 	 * 
 	 */
 	public final boolean findHits( int y ) {
 		boolean found = false;
 		for ( int i = 0 ; i < edgeCount ; i++ ) {
 			if ( edges[ i ].hit( y, tmpHit ) ) {
 				if ( !found ) {
 					found = true;
 					maxHit.copy( tmpHit );
 					minHit.copy( tmpHit );
 				} else {
 					if ( tmpHit.min < minHit.min ) minHit.copy( tmpHit );
 					if ( tmpHit.max > minHit.max ) maxHit.copy( tmpHit );
 				}
 			}
 			
 		}
 		return found;
 	}
 
 	/*** 
 	 * 
 	 * scanLine
 	 * 
 	 * @param y
 	 * 
 	 */
 	private final void scanLine( int y ) {
 		if ( skin == null ) {
 			simpleScanLine( y );
 		} else {
 			textureScanLine( y );
 		}
 	}
 	
 	/*** 
 	 * 
 	 * simpleScanLine
 	 * 
 	 * @param y
 	 * 
 	 */
 	private void simpleScanLine( int y ) {
 		
 		// first and last x values at this line...
 		int min = ( int ) minHit.min;
 		int max = ( int ) maxHit.max;
 
 		int len = max - min;
 		
 		// walk the z
 		float zstart = minHit.what.zAt( minHit.when );
 		float zstop  = maxHit.what.zAt( maxHit.when );
 		float zstep  = ( zstop - zstart ) / len;
 
 		// move up to zero and adjust starting texture coordinates
 		// appropriately
 		if ( min < 0 ) {
 			zstart += zstep * -min;
 			min = 0;
 		} 
 		
 		// don't draw past the end of the line
 		if ( max >= w ) max = w - 1;
 
 		// pixel index
 		int idx = y * w + min;
 		max = idx + max - min;
 
 		for ( ; idx < max ; idx++, zstart += zstep ) {
 			if ( zbuffer.set( idx, zstart ) ) {
 				pixels[ idx ] = 0xFF0000FF & shadeMask;
 			}
 		}
 	}
 	
 	/*** 
 	 * 
 	 * textureScanLine
 	 * 
 	 * @param y
 	 * 
 	 */
 	private final void textureScanLine( int y ) {
 		
 		// first and last x values at this line...
 		int min = ( int ) minHit.min;
 		int max = ( int ) maxHit.max;
 
 		int len = max - min;
 		
 		// walk the z
 		float zstart = minHit.what.zAt( minHit.when );
 		float zstop  = maxHit.what.zAt( maxHit.when );
 		float zstep  = ( zstop - zstart ) / len;
 
 		// get the texture coordinates
 		minHit.tex( texStart );
 		maxHit.tex( texStop );
 
 		// calculate the texture steps
 		float sStep = ( texStop.min - texStart.min ) / len;
 		float tStep = ( texStop.max - texStart.max ) / len;
 
 		// move up to zero and adjust starting texture coordinates
 		// appropriately
 		if ( min < 0 ) {
 			texStart.min += sStep * -min;
 			texStart.max += tStep * -min;
 			zstart += zstep * -min;
 			min = 0;
 		} 
 		
 		// don't draw past the end of the line
 		if ( max >= w ) max = w - 1;
 
 		// pixel index
 		int idx = y * w + min;
 		max = idx + max - min;
 
 		/*
 		// some texturing slyness
 		int textIdx = skin.getScaledIdx( texStart.min, texStart.max );
 		int textInc = skin.getScaledIdx( sStep, tStep );
 		int maxText = skin.getMax();
 		*/
 
 		for ( 
 			; 
 			idx < max 
 			; 
 			idx++,
 			zstart += zstep,
 			//textIdx += textInc
 			texStart.min += sStep, texStart.max += tStep
 		) {
 			if ( zbuffer.set( idx, zstart ) ) {
 				/*
 					if ( textIdx >= maxText ) {
 						textIdx %= maxText;
 					} else 
 					if ( textIdx < 0 ) {
 						textIdx = ( textIdx + maxText ) % maxText;
 					}
 					
 					pixels[ idx ] = skin.getPixels()[ textIdx ] & shadeMask ;
 				*/
 				pixels[ idx ] = skin.getPixelAtCoord( texStart.min, texStart.max ) & shadeMask;
 			}
 		}
 	}
 
 };
 
 /***
  *
  * $Log: Edjo.java,v $
  * Revision 1.7  2005/03/26 04:59:18  brian
  * got too fancy with textures in this spot...
  *
  * Revision 1.6  2005/03/26 03:46:55  brian
  * break it up a bit
  *
  * Revision 1.5  2005/03/26 03:35:45  brian
  * texturing strongly broken...
  *
  * Revision 1.4  2005/03/25 13:42:41  brian
  * actually works
  *
  * Revision 1.3  2005/03/25 13:37:55  brian
  * significantly less broken
  *
  * Revision 1.2  2005/03/25 04:13:20  brian
  * still does not work
  *
  * Revision 1.1  2005/03/25 04:02:19  brian
  * does not work
  *
  *
  */