/*
 * Copyright (c) 1998 Kevan Stannard. All Rights Reserved.
 *
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
 * without fee is hereby granted. 
 * 
 * Please note that this software comes with
 * NO WARRANTY 
 *
 * BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED
 * BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 * PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
 * TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
 * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 
 * 
 * IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER
 * PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 * INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
 * THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED
 * BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER
 * OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

import java.applet.*;
import java.awt.*;

/**
 * Sphere is simply a 'point' type sphere.
 *
 * @version 1.0
 * @author  Kevan Stannard
 */

public class Sphere extends Object3D
{
	double density;
	double radius;

	//
	// create the rotation matrices
	//

	Matrix2D xRotationMatrix = new Matrix2D(3,3);
	Matrix2D yRotationMatrix = new Matrix2D(3,3);
	Matrix2D zRotationMatrix = new Matrix2D(3,3);

	//
	// set rotation defaults
	//

	double xTheta;
	double yTheta;
	double zTheta;

    //
    // trig tables
    //

    private final int NUM_VALUES = 255;
    double cosTable[] = new double[NUM_VALUES];
    double sinTable[] = new double[NUM_VALUES];

	public Sphere()
	{
		this(50, 32);

        // initialise the trig tables

        for (int i=0; i<NUM_VALUES; i++)
        {
            cosTable[i] = Math.cos(i);
            sinTable[i] = Math.sin(i);
        }
	}

	public Sphere(double radius, double density)
	{
		this.radius = radius;
		this.density = density;
		init();
	}

	public void init()
	{
		//
		// Create the vertices for a 3d sphere object
		// Using spherical coordinates:
		//

		double ro = radius;
		for (double theta=0; theta<Math.PI; theta += Math.PI/density)
		{
			for (double phi=0; phi<Math.PI*2; phi += Math.PI/density)
			{
				double x = ro * Math.sin(phi) * Math.cos(theta);
				double y = ro * Math.sin(phi) * Math.sin(theta);
				double z = ro * Math.cos(phi);

				addVertex(x,y,z);
			}
		}

		//
		// initialise rotation matrices
		//

		double xRand = 100;
		double yRand = 100;
		double zRand = 100;

		xTheta = 2*Math.PI/xRand;
		yTheta = 2*Math.PI/yRand;
		zTheta = 2*Math.PI/zRand;

		setXRotation(xTheta);
		setYRotation(yTheta);
		setZRotation(zTheta);
	}

	public void setXRotation(double theta)
	{
		double cosTheta = Math.cos(theta);
		double sinTheta = Math.sin(theta);
		//double cosTheta = cosTable[theta];
		//double sinTheta = sinTable[theta];

		xRotationMatrix.setElement(0,0,1);
		xRotationMatrix.setElement(0,1,0);
		xRotationMatrix.setElement(0,2,0);

		xRotationMatrix.setElement(1,0,0);
		xRotationMatrix.setElement(1,1,cosTheta);
		xRotationMatrix.setElement(1,2,sinTheta);

		xRotationMatrix.setElement(2,0,0);
		xRotationMatrix.setElement(2,1,-sinTheta);
		xRotationMatrix.setElement(2,2,cosTheta);
	}

	public void setYRotation(double theta)
	{
		double cosTheta = Math.cos(theta);
		double sinTheta = Math.sin(theta);
		//double cosTheta = cosTable[theta];
		//double sinTheta = sinTable[theta];

		yRotationMatrix.setElement(0,0,cosTheta);
		yRotationMatrix.setElement(0,1,0);
		yRotationMatrix.setElement(0,2,-sinTheta);

		yRotationMatrix.setElement(1,0,0);
		yRotationMatrix.setElement(1,1,1);
		yRotationMatrix.setElement(1,2,0);

		yRotationMatrix.setElement(2,0,sinTheta);
		yRotationMatrix.setElement(2,1,0);
		yRotationMatrix.setElement(2,2,cosTheta);
	}

	public void setZRotation(double theta)
	{
		double cosTheta = Math.cos(theta);
		double sinTheta = Math.sin(theta);
		//double cosTheta = cosTable[theta];
		//double sinTheta = sinTable[theta];

		zRotationMatrix.setElement(0,0,cosTheta);
		zRotationMatrix.setElement(0,1,sinTheta);
		zRotationMatrix.setElement(0,2,0);

		zRotationMatrix.setElement(1,0,-sinTheta);
		zRotationMatrix.setElement(1,1,cosTheta);
		zRotationMatrix.setElement(1,2,0);

		zRotationMatrix.setElement(2,0,0);
		zRotationMatrix.setElement(2,1,0);
		zRotationMatrix.setElement(2,2,1);
	}

	public void rotateX()
	{
		for (int v=0; v<numVertices; v++)
		{
			vertices[v].matrixMultiply(xRotationMatrix);
		}
	}
	public void rotateY()
	{
		for (int v=0; v<numVertices; v++)
		{
			vertices[v].matrixMultiply(yRotationMatrix);
		}
	}

	public void rotateZ()
	{
		for (int v=0; v<numVertices; v++)
		{
			vertices[v].matrixMultiply(zRotationMatrix);
		}
	}

	public void rotate()
	{
		for (int v=0; v<numVertices; v++)
		{
			vertices[v].matrixMultiply(xRotationMatrix);
			vertices[v].matrixMultiply(yRotationMatrix);
			vertices[v].matrixMultiply(zRotationMatrix);
		}
	}
	public void show(Graphics g, int xpos, int ypos, int w, int h)
	{
		for (int v=0; v<numVertices; v++)
		{
			if (vertices[v].z >0)
			{
				int x = xpos + (int) vertices[v].x;
 				int y = ypos + (int) vertices[v].y;

                                // Bug in Netscape causes getClipRect to
                                // return a null value, so, we pass the width and
                                // height as parameters instead

				//int width = g.getClipRect().width;
				//int height = g.getClipRect().height;

                                int width = w;
                                int height = h;

				if (x<0) x = 0;
				if (y<0) y = 0;
				if (x>width-1) x = width-1;
				if (y>height-1) y = height-1;

				g.drawLine(x, y, x, y);
			}
		}
	}


}