// Decompiled by Jad v1.5.7b. Copyright 1997-99 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Camera.java

class Camera extends Object3D
{
    static final long serialVersionUID = 4754289789178680517L;
    
	/*static*/ float DECAL = 12; // 3;
	/*static*/ float SCALE = 1; // 0.5f;
	
	float shaper_fovy  = 25.0f;
	float shaper_zNear = 0.01f;
	float shaper_zFar  = 1E5f; // 500.0f;
        
    Camera()
    {
        super("Camera");
        //<-2.2,0.7,-2> and pointed it at <-0.61,0.3,-0.6>
    //    location = LA.newVector(2,0.7,-2);
    //    lookAt = new cVector(0.6,0.3,-0.6);
        location = LA.newVector(6,2,4);
        lookAt = new cVector(0.0,0.5,0);
        direction = new cVector();
        toParent = LA.newMatrix();
        fromParent = LA.newMatrix();
        toScreen = //toParent; // may 2013
                    LA.newMatrix();
        fromScreen = //fromParent; // may 2013
                    LA.newMatrix();
        initCamera();
        perspective = true;
    }

    Camera(int viewCode)
    {
        super("Camera" + CameraPane.Name(viewCode));
        this.viewCode = viewCode;
        lookAt = new cVector();
        direction = new cVector();
        toParent = LA.newMatrix();
        fromParent = LA.newMatrix();
        toScreen = //toParent; // may 2013
                    LA.newMatrix();
        fromScreen = //fromParent; // may 2013
                    LA.newMatrix();
        switch (viewCode)
        {
        case 0:
            location = LA.newVector(0, 0, 20);
            perspective = true;
            break;
        case 1: // '\001'
            location = LA.newVector(0, 0, 4); // Needed for translation direction
            perspective = false;
            break;
        case 2: // '\002'
            location = LA.newVector(0, 4, 0);
            //UP = LA.newVector(1, 0, 0);
            perspective = false;
            //LA.matXRotate(toScreen, LA.toRadians(-90));
            //LA.matXRotate(fromScreen, LA.toRadians(90));
            break;
        case 3: // '\003'
            location = LA.newVector(4, 0, 0); // Needed for translation direction
            //LA.matZRotate(toScreen, LA.toRadians(-90));
            //LA.matXRotate(toScreen, LA.toRadians(-90));
            //LA.matXRotate(fromScreen, LA.toRadians(90));
            //LA.matZRotate(fromScreen, LA.toRadians(90));
            perspective = false;
            break;
        case 4: // Default light
            location = LA.newVector(-5, 15, 10);
            perspective = false;
            break;
        }
        
	computeTransform();
        initCamera();
    }

    Camera(cVector from)
    {
        super("Camera" + 0);
        viewCode = 0;
        location = new cVector();
        lookAt = new cVector();
        direction = new cVector();
        toParent = LA.newMatrix();
        fromParent = LA.newMatrix();
        toScreen = //toParent; // may 2013
                    LA.newMatrix();
        fromScreen = //fromParent; // may 2013
                    LA.newMatrix();
        setLocation(from);
	computeTransform();
        initCamera();
		perspective = true;
    }

    private void initCamera()
    {
        focalLength = 1;
        setAspect(4, 3);
        background = LA.newVector(0.8, 0.8, 0.8);
    }

    void CreateMaterial(boolean multiply)
    {
        super.CreateMaterial(multiply);
        
        material.shift = 90;
        material.cameralight = 0.2f;
        material.shadowbias = 10;
    }

    void setAspect(int width, int height)
    {
        //hAspect = width;
        //vAspect = height;
        aspect = (double)width / (double)height;
    }

    void setLocation(cVector from)
    {
        //setAim(from, lookAt);
        LA.vecCopy(from, location);
	//computeTransform();
    }

    void setFocus(cVector focus)
    {
        //setAim(location, focus);
        LA.vecCopy(focus, lookAt);
	//computeTransform();
    }

    cVector UP = LA.newVector(0, 1, 0);
    cVector UP2 = LA.newVector(1, 0, 0);
    
    // actual dynamic up vector
    cVector up = new cVector();
    
    cVector away = new cVector();
    cVector right = new cVector();
    
    double temp[][] = LA.newMatrix();
    
    void setAim(cVector from, cVector towards)
    {
        LA.vecCopy(from, location);
        LA.vecCopy(towards, lookAt);
        
        // refresh toScreen matrix
	computeTransform();
    }
    
	void RotatePosition(float dx, float dy)
	{
        if(hAspect != 0) return;
        
        if (CameraPane.IMAGEFLIP)
        {
            dx = -dx;
        }
        
        if (CameraPane.ROTATECAMERA)
        {
            float t = dx;
            dx = dy;
            dy = -t;
        }
        
            cStatic.point1.set(location);
            cStatic.point2.set(lookAt);
		LA.vecSub(location, lookAt, location);
		
                // avril 2014
   //     TransformToLocal(location);
                
		double angle = -dx / 200.0;
		quat.set(UP, angle);
		quat.rotate(location);
		
		angle = -dy / 200.0;
		quat.set(right, angle);
		quat.rotate(location);
		
                // avril 2014
   //     TransformToWorld(location);
        
		LA.vecAdd(location, lookAt, location);

		tempvec.set(right);
		
		computeTransform();

		if (tempvec.dot(right) < 0)
		{
			UP.mul(-1);
			computeTransform();
		}

            if(hAspect != 0)
            {
                location.set(cStatic.point1);
                lookAt.set(cStatic.point2);
            }
        }
	
	cVector tempvec = new cVector();
	cQuat quat = new cQuat();
	
	public double Distance()
	{
		LA.vecSub(location, lookAt, tempvec);
		return tempvec.length();
	}
	
	void Translate(float dx, float dy, float scale)
	{
        if(hAspect != 0) return;
        
        if (CameraPane.IMAGEFLIP)
        {
            dx = -dx;
        }
        
        if (CameraPane.ROTATECAMERA)
        {
            float t = dx;
            dx = dy;
            dy = -t;
        }
        
            cStatic.point1.set(location);
            cStatic.point2.set(lookAt);
            
		double dist = Distance();
		double factor = 1;
		
                scale /= shaper_fovy/60;
                
		//if (perspective)
			factor = dist;
		
		LA.vecCopy(up, tempvec);
		tempvec.x *= factor*dy/scale;
		tempvec.y *= factor*dy/scale;
		tempvec.z *= factor*dy/scale;
		
		LA.vecAdd(location, tempvec, location);
		LA.vecAdd(lookAt, tempvec, lookAt);
		
		dx *= -1;
		
		LA.vecCopy(right, tempvec);
		tempvec.x *= factor*dx/scale;
		tempvec.y *= factor*dx/scale;
		tempvec.z *= factor*dx/scale;
		
		LA.vecAdd(location, tempvec, location);
		LA.vecAdd(lookAt, tempvec, lookAt);
		
		computeTransform();
            if(hAspect != 0)
            {
                location.set(cStatic.point1);
                lookAt.set(cStatic.point2);
            }
	}
	
	void BackForth(float dx, float dy, float scale)
	{
        if(hAspect != 0) return;
            cStatic.point1.set(location);
            cStatic.point2.set(lookAt);
		if (!perspective)
		{
			//zoom *= Math.exp(dy);
			
			//return;
		}
		
                if (scale == 0)
                {
                    // Zoom
                    double factor = Math.exp(-dy/300.0); // (1 + dy/100);

                    LA.vecSub(location, lookAt, location);

                    cVector p = location;

                    p.x *= factor;
                    p.y *= factor;
                    p.z *= factor;

                    LA.vecAdd(location, lookAt, location);
                }
                else
                {
                    LA.vecSub(location, lookAt, direction);

                    //scale /= Distance();
           //         scale /= shaper_fovy/20;

                    location.x -= dy * direction.x / scale;
                    //location.y -= dy * direction.y / scale;
                    location.z -= dy * direction.z / scale;
                    lookAt.x -= dy * direction.x / scale;
                    //lookAt.y -= dy * direction.y / scale;
                    lookAt.z -= dy * direction.z / scale;
                }

		computeTransform();
        if(hAspect != 0)
        {
            // Doesn't work
            location.set(cStatic.point1);
            lookAt.set(cStatic.point2);
        }
	}
	
	void RotateInterest(float dx, float dy)
	{
            right.mul(-1);
            
            cStatic.point1.set(location);
            location.set(lookAt);
            lookAt.set(cStatic.point1);
            
            if (viewCode == 0 && locationBuf != null)
            {
                cStatic.point1.set(locationBuf);
                locationBuf.set(lookAtBuf);
                lookAtBuf.set(cStatic.point1);
            }
         //   UP.mul(-1);
            
            RotatePosition(dx,-dy);
            
         //   UP.mul(-1);
            right.mul(-1);
            
            cStatic.point1.set(location);
            location.set(lookAt);
            lookAt.set(cStatic.point1);
            
            if (viewCode == 0 && locationBuf != null)
            {
                cStatic.point1.set(locationBuf);
                locationBuf.set(lookAtBuf);
                lookAtBuf.set(cStatic.point1);
            }
            
            computeTransform();
	}
	
    //synchronized // june 2014
            void computeTransform()
    {
        //new Exception().printStackTrace();
        if (toScreen == toParent) // dec 2013
        {
            toScreen = LA.newMatrix();
            fromScreen = LA.newMatrix();
        }
        
        if (locationBuf == null)
        {
            locationBuf = new cVector();
            locationBuf.set(location);
            lookAtBuf = new cVector();
            lookAtBuf.set(lookAt);
            upBuf = new cVector();
            upBuf.set(UP);
//            up2Buf = new cVector();
//            up2Buf.set(UP2);
        }
        else
        {
            double K = 0.25;
            
            if (!CameraPane.capsLocked)
                K = 1;
            
            locationBuf.y = location.y * K + locationBuf.y * (1 - K);
            lookAtBuf.y = lookAt.y * K + lookAtBuf.y * (1 - K);
            
            K = 0.1;
            
            upBuf.x = UP.x * K + upBuf.x * (1 - K);
            upBuf.y = UP.y * K + upBuf.y * (1 - K);
            upBuf.z = UP.z * K + upBuf.z * (1 - K);
            upBuf.normalize();
//            up2Buf.x = UP2.x * K + up2Buf.x * (1 - K);
//            up2Buf.y = UP2.y * K + up2Buf.y * (1 - K);
//            up2Buf.z = UP2.z * K + up2Buf.z * (1 - K);
            
            K = 1;
            
            locationBuf.x = location.x * K + locationBuf.x * (1 - K);
            locationBuf.z = location.z * K + locationBuf.z * (1 - K);
            lookAtBuf.x = lookAt.x * K + lookAtBuf.x * (1 - K);
            lookAtBuf.z = lookAt.z * K + lookAtBuf.z * (1 - K);
        }
        
        cVector up2 = up;
        cVector right2 = right;
        
	up2.x = upBuf.x;
	up2.y = upBuf.y;
	up2.z = upBuf.z;
        LA.vecSub(lookAtBuf, locationBuf, away);
        LA.vecNormalize(away);
        LA.vecCross(away, up2, right2);
		if (right2.length2() < 0.0001)
		{
                    //System.out.println("right2.length2() < 0.0001");
			// UP failed
			up2.x = UP2.x;
			up2.y = UP2.y;
			up2.z = UP2.z;
			LA.vecCross(away, up2, right2);
			if (!(right2.length2() > 0))
                        {
                            System.out.println("NO UP VECTOR: " + up2);
                            System.out.println("lookAtBuf: " + lookAtBuf);
                            System.out.println("locationBuf: " + locationBuf);
                    System.exit(0);

                            // old problem...
                            assert (right2.length2() <= 0 || right2.length2() > 0); // weirdest thing ever
                            up2.x = UP.x = 0;
                            up2.y = UP.y = 1;
                            up2.z = UP.z = 0;
                            LA.vecCross(away, up2, right2);
                        }
		}
        LA.vecNormalize(right2);
        LA.vecCross(right2, away, up2);
		if (LA.vecLen2(up2) != 0)
		{
			LA.vecNormalize(up2);
			LA.matIdentity(toScreen);
			LA.matIdentity(fromScreen);
			for (int i=0; i < 3; i++)
			{
				toScreen[i][0] = right2.get(i);
				toScreen[i][1] = up2.get(i);
				toScreen[i][2] = -away.get(i);
				fromScreen[0][i] = right2.get(i);
				fromScreen[1][i] = up2.get(i);
				fromScreen[2][i] = -away.get(i);
			}
		}

        for (int i=0; i < 3; i++)
            fromScreen[3][i] = locationBuf.get(i);

        for (int i=0; i < 3; i++)
            temp[3][i] = -locationBuf.get(i);

        LA.matConcat(temp, toScreen, toScreen);

        if (CameraPane.ROTATECAMERA)
        {
            double[][] rotate = { { 0,1,0,0 }, { -1,0,0,0}, { 0,0,1,0}, { 0,0,0,1 } };
            //double[][] rotate_1 = { { 0,-1,0,0 }, { 1,0,0,0}, { 0,0,1,0}, { 0,0,0,1 } };
        
            LA.matConcat(fromScreen, rotate, fromScreen);
            //LA.matConcat(toScreen, rotate_1, toScreen);
        }
        
        if (CameraPane.IMAGEFLIP)
        {
            double[][] flip = { { -1,0,0,0 }, { 0,1,0,0}, { 0,0,1,0}, { 0,0,0,1 } };
        
            LA.matConcat(fromScreen, flip, fromScreen);
        }
        
		//if (this == CameraPane.lightCamera)
			//CameraPane.lighttouched = true;
        LA.matInvert(fromScreen, toScreen);
    }

//    void Draw(CameraPane display, Object3D /*Composite*/ root, boolean selected)
//    {
//        // don't draw anything aout 2013
//    }
    
    public void generatePOV(StringBuffer buf, int width, int height)
    {
        double imageAspect = (double)width / (double)height;
        if (imageAspect > aspect)
            width = (int)((double)height * aspect);
        else
            height = (int)((double)width / aspect);
        double right = width;
        double up = height;
        if (perspective)
        {
            right = aspect;
            up = 1;
        }
        buf.append("// ");
        buf.append(perspective ? "perspective" : "orthographic");
        buf.append(": aspect ");
        buf.append(hAspect);
        buf.append(" wide by ");
        buf.append(vAspect);
        buf.append(" high\n");
        buf.append("camera {\n");
        if (!perspective)
            buf.append("  orthographic\n");
        buf.append("  location ");
        LA.toPOVRay(location, buf);
        buf.append("\n  sky <0,0,1>\n");
        if (perspective)
        {
            buf.append("  right <");
            buf.append(hAspect);
            buf.append("/");
            buf.append(vAspect);
            buf.append(",0,0>\n  up <0,0,1>\n");
        } else
        {
            buf.append("  right <");
            buf.append(width);
            buf.append(",0,0>\n  up <0,0,");
            buf.append(height);
            buf.append(">\n");
        }
        buf.append("  direction <0,");
        buf.append(focalLength);
        buf.append(",0>\n  look_at ");
        LA.toPOVRay(lookAt, buf);
        buf.append("\n}\n");
        buf.append("light_source { ");
        LA.toPOVRay(location, buf);
        buf.append(" color rgb <1,1,1> }\n");
        buf.append("light_source { <0,0,500> color rgb <1,1,1> }\n\n");
    }

    static final int viewTop = 1;
    static final int viewFront = 2;
    static final int viewSide = 3;
    int viewCode;
    
    cVector location;
    cVector lookAt;
    
    transient cVector locationBuf;
    transient cVector lookAtBuf;
    transient cVector upBuf;
    //transient cVector up2Buf;
    
    cVector direction;
    
    double[][] toScreen;
    double[][] fromScreen;
    
    boolean perspective;
    int hAspect = 0; // Free camera
    int vAspect;
    double aspect;
    double focalLength;
    cVector background;
}