package com.insanityengine.ghia.m3;
   
   /***
    *
    * <P>
    * A 2d line (segment) class using Pt2's
    * </P>
    *
    * <PRE>
   *
   * A note on splitting and "front"/"back" assignment:
   *
   * Let the Splitting Line be called S
   * Let the Line being split be called L
   * Let the normal of S be N, where
   *   S.N.x = +( S.stop.y - S.start.y )
   *   S.N.y = -( S.stop.x - S.start.x )
   * 
   * Let      numerator =  N * (L.start - S.start)
   * Let    denominator = -N * (L.end   - L.start)
   * Let t.intersection = numerator/denominator
   * 
   * If the denominator is 0, the lines are parallel.
   * If the denominator is is not 0, the lines intersect.
   * 
   * If the numerator>0, L is in "front" of S; otherwise,
   * L is in "back" of S.
   * 
   * If t.intersection is between L's t.min and t.max, then
   * the line is split.  A new Line L2 is created based on
   * L with t.start=t.intersection and t.stop=L's t.max.
   * Modify L's t.max to be t.intersection.
   * 
   * If the numerator>0, L is in "front" of S, and L2 is in
   * "back" of S; otherwise, L is in "back" of S and L2 is in
   * "front" of S.
   * 
   * In terms of generalized binary trees, "front" corresponds to
   * "left" and "back" corresponds to "right".   
   *
   * </PRE>
   *
   * @author BrianHammond
   *
   * $Header: /usr/local/cvsroot/ghia/src/java/com/insanityengine/ghia/m3/Lying.java,v 1.4 2005/03/19 17:50:02 brian Exp $
   *  
   */
  public class Lying {
  
  	/***
  	 * 
  	 * Constructor
  	 *
  	 */
  	public Lying() {
  	}
  
  	/***
  	 * 
  	 * Constructor
  	 *
  	 */
  	public Lying( Lying other ) {
  		setStart( other.getStart() );
  		setStop( other.getStop() );
  	}
  
  	/***
  	 * 
  	 * Constructor
  	 *
  	 */
  	public Lying( Pt2 start, Pt2 stop ) {
  		setStart( start );
  		setStop( stop );
  	}
  
  	/***
  	  *
  	  * Set the value
  	  *
  	  * @param newValue to use
  	  *
  	  */
  	public Pt2 getStart() { return start; }
  
  	/***
  	  *
  	  * Set the value
  	  *
  	  * @param newValue to use
  	  *
  	  */
  	public void setStart( Pt2 newValue ) { start.set( newValue ); }
  	
  	/***
  	  *
  	  * Set the value
  	  *
 	  * @param newValue to use
 	  *
 	  */
 	public Pt2 getStop() { return stop; }
 
 	/***
 	  *
 	  * Set the value
 	  *
 	  * @param newValue to use
 	  *
 	  */
 	public void setStop( Pt2 newValue ) { stop.set( newValue ); }
 
 	/***
 	  *
 	  * Set the value
 	  *
 	  * @param newValue to use
 	  *
 	  */
 	public Pt2 getNormal() { return normal; }
 
 	/***
 	 *
 	 * Flip the start and stop pairs
 	 *
 	 */
 	public void flip() {
 		Pt2 tmp = start;
 		start = stop;
 		stop = start;
 	}
 
 	/***
 	 *
 	 * Evaluate the normal using the current start
 	 * and stop points
 	 *
 	 * @return the normal
 	 *
 	 */
 	public Pt2 evalNormal() {
 		diff.set(
 			stop.getX() - start.getX()
 			,
 			stop.getY() - start.getY()
 		);
 		normal.set( +diff.getY() , -diff.getX() ).normalize();
 		return normal;
 	}
 
 	/***
 	 *
 	 * Determine when two lines intersect, return the point passed
 	 * in or null if no intersection occurs on the segments or cuz
 	 * they are parallel
 	 *
 	 * @param other line
 	 * @param hit storage
 	 *
 	 * @return the point passed if they intersect or null if not
 	 *
 	 */
 	public Pt2 intersectAt( Lying other, Pt2 hit ) {
 		float t = this.intersect( other );
 		float f = other.intersect( this );
 		
 		if ( t < 0 || t > 1 || f < 0 || f > 1 ) {
 			hit = null;
 		} else {
 			hit.set(
 				t * diff.getX()
 				,
 				t * diff.getY()
 			);
 		}
 		return hit;
 	}
 
 	/***
 	 *
 	 * When will this line intersect the other line
 	 *
 	 * @param other line 
 	 *
 	 * @return time of intersection or M3_Constants.bigNumber, if parallel
 	 *
 	 */
 	public float intersect( Lying other ) {
 		float d = denominator( other );
 		if ( 0 == d ) {
 			d = M3_Constants.bigNumber;
 		} else {
 			d = numerator( other ) / d;
 		}
 		return d;
 	}
 
 	/***
 	 *
 	 * The numerator =  S.N * (L.start - S.start)
 	 * 
 	 * If the numerator&gt;0, L is in "front" of S; otherwise,
 	 * L is in "back" of S.
 	 *
 	 * @param other lying to test
 	 *
 	 * @return the numerator value
 	 *
 	 */
 	public float numerator( Lying other ) {
 		return ( float ) (
 			other.getNormal().getX() * ( getStart().getX() - other.getStart().getX() )
 			+
 			other.getNormal().getY() * ( getStart().getY() - other.getStart().getY() )
 		);
 	}
 
 
 	/***
 	 *
 	 * The denominator = -S.N * (L.end - L.start)
 	 *
 	 * If the denominator returns 0, then the lines are parallel
 	 * otherwise, they intersect 
 	 *
 	 * @param other lying to test
 	 *
 	 * @return the denominator value
 	 *
 	 */
 	public float denominator( Lying other ) {
 		return ( float ) (
 			-other.getNormal().getX() * diff.getX()
 			+ 
 			-other.getNormal().getY() * diff.getY()
 		);
 	};
 
 	/***
 	 *
 	 * Get the angle from start to stop
 	 *
 	 * @return the angle from start to stop
 	 *
 	 */
 	public double getAngle() {
 		return stop.getAngle( start );
 	}
 
 	///////////////////
 
 	private Pt2 start = new Pt2();
 	private Pt2 stop = new Pt2();
 	private Pt2 diff = new Pt2();
 	private Pt2 normal = new Pt2();
 }
 
 /***
  *
  * $Log: Lying.java,v $
  * 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/27 00:21:12  brian
  * actually compiles now...
  *
  *
  */