/* -------------------------------------------------------------------
    * Java source file for the class StandingWave
    * 
    * Copyright (c), 2004, Masahiro Takatsuka
    * All Rights Researved.
    * 
    * Original Author: Masahiro Takatsuka
    * $Author: takatsukam $
    * 
   * $Date: 2004/11/23 21:46:43 $
   * 
   * $Id: StandingWave.java,v 1.1 2004/11/23 21:46:43 takatsukam Exp $
   * 
   * Reference:		Document no:
   * ___				___
   * 
   * To Do:
   * ___
   * 
  ------------------------------------------------------------------- */
  
  /* --------------------------- Package ---------------------------- */
  package net.jbeans.physics.model.standingwave;
  
  /* ------------------ Import classes (packages) ------------------- *//package-summary/html">class="comment"> ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment"> ------------------ Import classes (packages) ------------------- */
  import java.io.*;
  import java.util.*;
  import javax.media.j3d.*;
  import javax.vecmath.*;
  import javax.swing.event.*;
  
  import net.jbeans.j3d.data.*;
  import net.jbeans.j3d.event.*;
  import net.jbeans.j3d.modeler.geometry.*;
  
  import net.jbeans.j3d.renderer.*;
  import net.jbeans.ui.*;
  import net.jbeans.ui.window.*;
  
  import javax.swing.*;
  import java.awt.event.*;
  import javax.swing.event.*;
  
  /*====================================================================
                   Implementation of class StandingWave                 
  ====================================================================*/
  /***
   * generally describe StandingWave in here
   * 
   * @version $Revision: 1.1 $
   * @author Masahiro Takatsuka (masa@takatsuka.org)
   * @see Serializable
   */
  
  public class StandingWave implements Serializable {
  	private static double sZmax = -Double.MAX_VALUE;
  	private static double sZmin = Double.MAX_VALUE;
  
      transient protected EventListenerList modelListeners;
  	transient protected EventListenerList dimListeners;
  	
  	int x = 20;
  	int y = 20;
  	double xmin = -5;
  	double ymin = -5;
  	double xmax = 5;
  	double ymax = 5;
  	double[] coords;
  	double[][] coordsC;
  
  	private static double f(double x, double y, double t) {
  		double r = Math.sqrt(x*x + y*y);
  		double ans = Math.sin(r + t) * Math.sqrt(r);
  		if (ans > sZmax) {
  			sZmax = ans;
  		} if (ans < sZmin) {
  			sZmin = ans;
  		}
  		return ans;
  	}
  
  	public StandingWave() {
  		initialize();
  	}
  
  	private void initialize() {
  		this.modelListeners = new EventListenerList();
  		this.dimListeners = new EventListenerList();		
  		setX(this.x);
  		setY(this.y);
  	}
  
      /***
       * Serialization methods
       */
      private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
  		s.defaultReadObject();
  		initialize();
      }
 
 	/***
      * adds an GeometryListener to the shape
      */
     public void addSurfaceListener(ChangeListener l) {
         this.modelListeners.add(ChangeListener.class, l);
     }
 
     /***
      * removes an GeometryListener from the shape.
      */
     public void removeSurfaceListener(ChangeListener l) {
         this.modelListeners.remove(ChangeListener.class, l);
     }
 
     /***
      * Notify all listeners that have registered interest for
      * notification on this event type.
      */
     protected void fireSurfaceChanged() {
         Object[] listeners = this.modelListeners.getListenerList();
         // Process the listeners last to first, notifying
         // those that are interested in this event
         for (int i = listeners.length - 2; i >= 0; i -= 2) {
             if (listeners[i] == ChangeListener.class) {
                 // Lazily create the event:
                 ((ChangeListener)listeners[i+1]).stateChanged(new ChangeEvent(this));
             }
         }
     }
 
 	/***
      * adds an GeometryListener to the shape
      */
     public void addSurfaceDimensionListener(ChangeListener l) {
         this.dimListeners.add(ChangeListener.class, l);
     }
 
     /***
      * removes an GeometryListener from the shape.
      */
     public void removeSurfaceDimensionListener(ChangeListener l) {
         this.dimListeners.remove(ChangeListener.class, l);
     }
 
     /***
      * Notify all listeners that have registered interest for
      * notification on this event type.
      */
     protected void fireSurfaceDimensionChanged() {
         Object[] listeners = this.dimListeners.getListenerList();
         // Process the listeners last to first, notifying
         // those that are interested in this event
         for (int i = listeners.length - 2; i >= 0; i -= 2) {
             if (listeners[i] == ChangeListener.class) {
                 // Lazily create the event:
                 ((ChangeListener)listeners[i+1]).stateChanged(new ChangeEvent(this));
             }
         }
     }
 	
 	public void setX(int x) {
 		this.x = x;
 		int cnt = this.x * this.y;
 		this.coords = new double[cnt * 4];
 		this.coordsC = new double[4][cnt];
 		fireSurfaceDimensionChanged();
 	}
 
 	public int getX() {
 		return this.x;
 	}
 
 	public void setY(int y) {
 		this.y = y;
 		int cnt = this.x * this.y;
 		this.coords = new double[cnt * 4];
 		this.coordsC = new double[4][cnt];
 		fireSurfaceDimensionChanged();
 	}
 
 	public int getY() {
 		return this.y;
 	}
 
 	public void setTime(double t) {
 		t /= 10.0;
 		int cnt = this.x * this.y;
 		double dx = (this.xmax-this.xmin) / (this.x-1);
 		double dy = (this.ymax-this.ymin) / (this.y-1);
 
 		// set points' coordinates.
 		for (int i = 0; i < this.y; i++) {
 			for (int j = 0; j < this.x; j++) {
 				int idx = i * this.x + j;
 				int index = idx * 4;
 				this.coords[index ] = j * dx;
 				this.coords[index + 1] = i * dy;
 				this.coords[index + 2] = f(this.coords[index], this.coords[index + 1], t);
 				this.coords[index + 3] = (this.coords[index + 2] - sZmin) / (sZmax - sZmin);
 				this.coordsC[0][idx] = this.coords[index];
 				this.coordsC[1][idx] = this.coords[index + 1];
 				this.coordsC[2][idx] = this.coords[index + 2];
 				this.coordsC[3][idx] = this.coords[index + 3];
 			}
 		}
 		fireSurfaceChanged();
 	}
 
 	public double[] getSurfaceCoordinatesWithColorsInSingle() {
 		return this.coords;
 	}
 
 	public double[] getSurfaceCoordinatesX() {
 		return this.coordsC[0];
 	}
 
 	public double[] getSurfaceCoordinatesY() {
 		return this.coordsC[1];
 	}
 
 	public double[] getSurfaceCoordinatesZ() {
 		return this.coordsC[2];
 	}
 
 	public double[] getSurfaceColors() {
 		return this.coordsC[3];
 	}
 }