package com.insanityengine.ghia.renderer;
   
   import com.insanityengine.ghia.m3.*;
   import com.insanityengine.ghia.libograf.*;
   import com.insanityengine.ghia.pixels.*;
   
   /*** 
    * 
    * <P>
   * This is a straight up port of Michael Abrash's DDA from chapter 56
   * of the _Graphics Programming Black Book (Special Edition)_
   * </P>
   * 
   * $Header: /usr/local/cvsroot/ghia/src/java/com/insanityengine/ghia/renderer/Abrashed.java,v 1.3 2005/03/25 02:59:21 brian Exp $
   * 
   * @author BrianHammond
   * 
   */
  public class Abrashed extends BufferBase implements RendererInterface {
  
  
  	/*** 
  	 * 
  	 * render
  	 * 
  	 * @param context
  	 * 
  	 */
  	public void render( LiboGraf context ) {
  		invokeDrawers( context );
  		copyTo( context.getGraphics() );
  	}
  
  	//////////////////////////////////////////////////
  	// DrawerRegistryInterface
  	
  	/***
  	 *
  	 * Some renderers are big babys about when it is ok to mess with their goodies.
  	 * Hence this cheesy add/remove Drawer mess
  	 *
  	 * @param drawer to call per frame
  	 *
  	 */
  	public void addDrawer( DrawingInterface drawer ) {
  		registry.addDrawer( drawer );
  	}
  
  	/***
  	 *
  	 * Some renderers are big babys about when it is ok to mess with their goodies.
  	 * Hence this cheesy add/remove Drawer mess
  	 *
  	 * @param drawer to call per frame
  	 *
  	 */
  	public void removeDrawer( DrawingInterface drawer ) {
  		registry.removeDrawer( drawer );
  	}
  
  	/***
  	 *
  	 * Invoke any registered DrawingInterfaces
  	 *
  	 */
  	public void invokeDrawers( LiboGraf context ) {
  		registry.invokeDrawers( context );
  	}
  
  	/*** 
  	 * 
  	 * drawPolygon
  	 * 
  	 * @param number
  	 * @param ptz
  	 * 
  	 */
  	public void drawPolygon( int number, Pt3 ptz[] ) {
  
  		if ( normal.z < 0 ) return;
  		frustrum.toScreen( number, ptz );
  		if ( frustrum.offScreen( number, ptz ) ) return;
  
  		float MinY, MaxY;
  		
  		int i;
  		int MinVert = 0;
  		
  		NumVerts = number;
  		VertexPtr = ptz;
  		
  		/* Nothing to draw if less than 3 vertices */
  		if ( number < 3 ) {
  			return;
  		}
  		
  		/* 
  			Scan through the destination polygon vertices and find the top of the
  			left and right edges, taking advantage of our knowledge that vertices
 			run in a clockwise direction (else this polygon wouldn't be visible
 			due to backface removal) 
 		*/
 		MinVert = MaxVert = 0;
 		MaxY = MinY = VertexPtr[ 0 ].getY();
 		for ( i = 1 ; i < NumVerts ; i++ ) {
 			if ( VertexPtr[ i ].getY() < MinY ) {
 				MinY = VertexPtr[ i ].getY();
 				MinVert = i;
 			}
 			if ( VertexPtr[ i ].getY() > MaxY ) {
 				MaxY = VertexPtr[ i ].getY();
 				MaxVert = i;
 			}
 		}
 		
 		/* Reject flat (0-pixel-high) polygons */
 		if ( MinY >= MaxY ) {
 			return;
 		}
 		
 		/* 
 			The destination Y coordinate is not edge specific; it applies to
 			both edges, since we always step Y by 1 
 		*/
 		DestY = MinY;
 		
 		/* 
 			Set up to scan the initial left and right edges of the source and
 			destination polygons. We always step the destination polygon edges
 			by one in Y, so calculate the corresponding destination X step for
 			each edge, and then the corresponding source image X and Y steps 
 		*/
 
 		// set up left edge first
 		LeftEdge.Direction = -1;
 		LeftEdge.setUpEdge( MinVert );
 		
 		// set up right edge
 		RightEdge.Direction = 1;
 		RightEdge.setUpEdge( MinVert );
 		
 		/* 
 			Step down destination edges one scan line at a time. At each scan
 			line, find the corresponding edge points in the source image. Scan
 			between the edge points in the source, drawing the corresponding
 			pixels across the current scan line in the destination polygon. (We
 			know which way the left and right edges run through the vertex list
 			because visible (non-backface-culled) polygons always have the
 			vertices in clockwise order as seen from the viewpoint) 
 		*/
 		for ( DestY = MinY; DestY < h ; DestY++ ) {
 			
 			// Draw only if inside Y bounds of clip rectangle 
 			if ( DestY >= 0 ) {
 				ScanOutLine( LeftEdge, RightEdge );
 			}
 			
 			/* 
 				Advance the source and destination polygon edges, ending if we've
 			   	scanned all the way to the bottom of the polygon 
 			*/
 			if ( !stepEdge( LeftEdge ) || !stepEdge( RightEdge ) ) break;
 		}
 	}
 
 	////////////////////////////////////////////////////////////////////////////////
 
 	private class EdgeScan {
 	   	/* 
 			through edge list:
 			+1 for a right edge (forward through vertex list)
 			-1 for a left  edge (backwardthrough vertex list)
 		*/
 		int Direction;
 		
 		float RemainingScans;	// height left to scan out in dest
 		int CurrentEnd;			// vertex # of end of current edge
 		
 		float SourceX;			// current X location in source for this edge
 		float SourceY;			// current Y location in source for this edge
 		float SourceZ;			// current Z location in source for this edge
 		float SourceStepX;		// X step in source for Y step in dest of 1
 		float SourceStepY;		// Y step in source for Y step in dest of 1
 		float SourceStepZ;		// Z step in source for Y step in dest of 1
 		
 		/* 
 		   variables used for all-integer Bresenham's-type X stepping through the dest, 
 		   needed for precise pixel placement to avoid gaps 
 		*/
 		int DestX;				// current X location in dest for this edge
 		int DestXIntStep;		// whole part of dest X step per scan-line Y step
 		int DestXDirection;		// -1 or 1 to indicate way X steps (left/right)
 		int DestXErrTerm;		// current error term for dest X stepping
 		int DestXAdjUp;			// amount to add to error term per scan line move
 		int DestXAdjDown;		// amount to subtract from error term when the error term turns over
 
 		/*** 
 		 * 
 		 * Sets up an edge to be scanned; the edge starts at StartVert and proceeds
 		 * in direction Edge.Direction through the vertex list. Edge.Direction
 		 * must be set prior to call; -1 to scan a left edge (backward through
 		 * the vertex list), 1 to scan a right edge (forward through the
 		 * vertex list). Automatically skips over 0-height edges. Returns
 		 * 1 for success, or 0 if there are no more edges to scan. 
 		 * 
 		 * @param StartVert
 		 * 
 		 * @return a boolean
 		 * 
 		 */
 		boolean setUpEdge( int StartVert ) {
 			
 			int NextVert;
 			
 			for ( ; StartVert != MaxVert  ; ) {
 				NextVert = StartVert + Direction;
 				if ( NextVert >= NumVerts ) {
 					NextVert = 0;
 				} else 
 				if ( NextVert < 0 ) {
 					NextVert = NumVerts - 1;
 				}
 				
 				/* 
 				  	Calculate the variables for this edge and done if this is not a
 				   	zero-height edge 
 				*/
 				RemainingScans = VertexPtr[ NextVert ].getY() - VertexPtr[ StartVert ].getY();
 				if ( RemainingScans != 0 ) {
 					return calcStepz( ( int ) RemainingScans, StartVert, NextVert );
 				}
 				StartVert = NextVert;   /* keep looking for a non-0-height edge */
 			}
 			
 			return false;
 		}
 
 		/*** 
 		 * 
 		 * calcStepz
 		 * 
 		 * @param RemainingScans
 		 * @param StartVert
 		 * @param NextVert
 		 * 
 		 * @return true
 		 * 
 		 */
 		private final boolean calcStepz( int RemainingScans, int StartVert, int NextVert ) {
 			if ( 0 == RemainingScans ) RemainingScans = 1;
 			
 			float DestYHeight = RemainingScans;
 			CurrentEnd = NextVert;
 			
 			SourceX = VertexPtr[ StartVert ].getS();
 			SourceY = VertexPtr[ StartVert ].getT();
 			SourceZ = VertexPtr[ StartVert ].getZ();
 			
 			SourceStepX = ( VertexPtr[ NextVert ].getS() - SourceX );
 			SourceStepY = ( VertexPtr[ NextVert ].getT() - SourceY );
 			SourceStepZ = ( VertexPtr[ NextVert ].getZ() - SourceZ );
 
 			SourceStepX /= DestYHeight;
 			SourceStepY /= DestYHeight;
 			SourceStepZ /= DestYHeight;
 
 			/* Set up Bresenham-style variables for dest X stepping */
 			DestX = ( int ) VertexPtr[ StartVert ].getX();
 			int DestXWidth = ( int ) ( VertexPtr[ NextVert ].getX() - VertexPtr[ StartVert ].getX() );
 			if ( DestXWidth < 0 ) {
 				/* Set up for drawing right to left */
 				DestXDirection = -1;
 				DestXWidth = -DestXWidth;
 				DestXErrTerm = 1 - RemainingScans;
 				DestXIntStep = ( int ) -( DestXWidth / RemainingScans );
 			} else {
 				/* Set up for drawing left to right */
 				DestXDirection = 1;
 				DestXErrTerm = 0;
 				DestXIntStep = ( int ) +( DestXWidth / RemainingScans );
 			}
 			DestXAdjUp = DestXWidth % RemainingScans;
 			DestXAdjDown = RemainingScans;
 
 			return true;
 		}
 			
 		
 	};
 
 	/*** 
 	 * 
 	 * ScanOutLine:  Texture-map-draw the scan line between two edges. 
 	 * 
 	 * @param LeftEdge
 	 * @param RightEdge
 	 * 
 	 */
 	private void ScanOutLine( EdgeScan LeftEdge, EdgeScan RightEdge ) {
 		float SourceX = LeftEdge.SourceX;
 		float SourceY = LeftEdge.SourceY;
 		float SourceZ = LeftEdge.SourceZ;
 		
 		float DestX = LeftEdge.DestX;
 		float DestXMax = RightEdge.DestX;
 		
 		float DestWidth;
 		float SourceXStep, SourceYStep, SourceZStep;
 		
 		/* Nothing to do if fully X clipped */
 		if ( ( DestXMax <= 0 ) || ( DestX  >= w ) ) {
 			return;
 		}
 		if ( ( DestXMax - DestX ) <= 0 ) {
 			return;  /* nothing to draw */
 		}
 		
 		/* 
 		   Width of destination scan line, for scaling. Note:
 		   because this is an integer-based scaling, it can have
 		   a total error of as much as nearly one pixel. For more
 		   precise scaling, also maintain a fixed-point DestX in
 		   each edge, and use it for scaling. If this is done,
 		   it will also be necessary to nudge the source start
 		   coordinates to the right by an amount corresponding
 		   to the distance from the the real (fixed-point) DestX
 		   and the first pixel (at an integer X) to be drawn)
 		 */
 		DestWidth = DestXMax - DestX;
 		
 		// Calculate source steps that correspond to each dest X step (across the scan line)
 		SourceXStep = ( RightEdge.SourceX - SourceX ) / DestWidth; 
 		SourceYStep = ( RightEdge.SourceY - SourceY ) / DestWidth;
 		SourceZStep = ( RightEdge.SourceZ - SourceZ ) / DestWidth;
 	   
 		// Clip right edge if necessary 
 		if ( DestXMax >= w ) {
 			DestXMax = w - 1;
 		} 
 		
 		// Clip left edge if necssary
 		if ( DestX  < 0 ) {
 			SourceX += SourceXStep * ( 0 - DestX );
 			SourceY += SourceYStep * ( 0 - DestX );
 			SourceZ += SourceZStep * ( 0 - DestX );
 			DestX = 0;
 		} 
 
 		int pix = 0x00FF0000;
 		int idx = ( int ) DestX + ( ( ( int ) DestY ) * w );
 
 		/* 
 		   Scan across the destination scan line, updating the
 		   source image position accordingly
 		 */
 		for (; DestX < DestXMax; DestX++, idx++ ) {
 			/* 
 				Get currently mapped pixel out of image and
 				draw it to screen 
 			 */
 			if ( zbuffer.set( idx, SourceZ ) ) {
 		  		if ( null != skin ) {
 			  		pix = ( int ) skin.getPixelAt( ( int ) SourceX, ( int ) SourceY );
 				}
 				pixels[ idx ] = pix;
 			}
 							
 			// Point to the next source pixel
 			SourceX += SourceXStep; 
 			SourceY += SourceYStep;
 			SourceZ += SourceZStep;
 		}
 	}
 			
 
 	/* 
 	   Steps an edge one scan line in the destination, and the
 	   corresponding distance in the source. If an edge runs out,
 	   starts a new edge if there is one. Returns 1 for success,
 	   or 0 if there are no more edges to scan.
 	 */
 	private boolean stepEdge( EdgeScan Edge ) { 
 		/* 
 		   
 			Count off the scan line we stepped last time; if this
 			edge is finished, try to start another one
 
 		*/ 
 		Edge.RemainingScans--;
 		if ( Edge.RemainingScans == 0 ) { 
 			/* Set up the next edge; done if there is no next edge */ 
 			if ( !Edge.setUpEdge( Edge.CurrentEnd ) ) { 
 				return false;	/* no more edges; done drawing polygon */ 
 			} 
 			return true;     /* all set to draw the new edge */
 		} 
 	
 		/* Step the current source edge */ 
 		Edge.SourceX += Edge.SourceStepX; 
 		Edge.SourceY += Edge.SourceStepY; 
 		
 		/* 
 		   Step dest X with Bresenham-style variables, to get
 		   precise dest pixel placement and avoid gaps
 		*/
 		Edge.DestX += Edge.DestXIntStep;
 		
 		/* whole pixel step */ 
 		/* Do error term stuff for fractional pixel X step handling */ 
 		Edge.DestXErrTerm += Edge.DestXAdjUp;
 		if ( Edge.DestXErrTerm > 0 ) {
 			 Edge.DestX += Edge.DestXDirection;
 			 Edge.DestXErrTerm -= Edge.DestXAdjDown; 
 		} 
 		
 		return true;
 	}
 
 	private int MaxVert, NumVerts;
 	private float DestY;
 	private Pt3 VertexPtr[];
 	private int TexMapWidth;
 
 	private DrawerRegistry registry = new DrawerRegistry();
 
 	private EdgeScan LeftEdge = new EdgeScan();
 	private EdgeScan RightEdge  = new EdgeScan();
 	
 };
 
 /***
  *
  * $Log: Abrashed.java,v $
  * Revision 1.3  2005/03/25 02:59:21  brian
  * still doesn;t work...
  *
  * Revision 1.2  2005/03/25 01:44:06  brian
  * added ScanOutLine
  *
  * Revision 1.1  2005/03/24 22:48:32  brian
  * dda ala abrash
  *
  *
  */