/**
 * View an area of camera framebuffer for zoom, rotate, etc
 * TBD should rotate/scale about image center, not upper left (0,0)
 * (could add auto pan/zoom of camera as needed...)
 * @author: Phil Gage
 */
class Viewport {

    /** Camera to view */
    AbstractCamera camera;       // parent camera
    FrameBuffer framebuffer;     // view image
    boolean fileOutput = true;   // true for TGA file output
    boolean rectify = true;      // true for Cyl distort rectification
    String path = "";            // path for TGA files
    int width, height;           // view size
    double xScale, yScale;       // scale
    double cosAngle, sinAngle;   // rotate
    double xOffset, yOffset;     // translate
    Color tempColor = new Color();

    Viewport (AbstractCamera camera, int width, int height) {
        this.camera = camera;
        this.width = width;
        this.height = height;
        framebuffer = new FrameBuffer(width, height);
        xScale = camera.width / width;
        yScale = camera.height / height;
        xOffset = 0.0;
        yOffset = 0.0;
        cosAngle = 1.0;
        sinAngle = 0.0;
    }

    /** Rotate to angle in degrees */
    void rotate (double angle) {
        cosAngle = Math.cos(angle*Constants.DTOR);
        sinAngle = Math.sin(angle*Constants.DTOR);
    }

    /** Set scale factor */
    void scale (double x, double y) {
        xScale = x;
        yScale = y;
    }

    /** Set translate offset */
    void translate (double x, double y) {
        xOffset = x;
        yOffset = y;
    }

    /** Convert from View coordinates to Camera X coordinate */
    int transformX (double x, double y) {
        x = x * cosAngle - y * sinAngle;  // rotate
        x *= xScale;   // scale
        x += xOffset;  // translate
/*
        if (rectify) {
            double xc = x - camera.width/2.0;
            double yc = y - camera.height/2.0;
            double zc = 100.0; //?
            double az = Math.atan2(xc,zc);
            double el = Math.atan2(yc,Math.sqrt(xc*xc+yc*yc));
            x = az*camera.width/camera.fov;
            y = el*camera.height/camera.vfov;
        }
*/
        return (int)x;
    }

    /** Convert from View coordinates to Camera Y coordinate */
    int transformY (double x, double y) {
        y = x * sinAngle + y * cosAngle;  // rotate
        y *= yScale;   // scale
        y += yOffset;  // translate
/*
        if (rectify) {
            double xc = x - camera.width/2.0;
            double yc = y - camera.height/2.0;
            double zc = 100.0; //?
            double az = Math.atan2(xc,zc);
            double el = Math.atan2(yc,Math.sqrt(xc*xc+yc*yc));
            x = az*camera.width/camera.fov;
            y = el*camera.height/camera.vfov;
        }
*/
        return (int)y;
    }

    /** Render view image from camera using current transform */
/*
    void render (int frame) {
        int tx, ty;
        for (int y=0; y<height; y++) {
            for (int x=0; x<width; x++) {
                tx = transformX(x,y);
                ty = transformY(x,y);
                if (rectify) {
                    double xc = tx - camera.width/2.0;
                    double yc = ty - camera.height/2.0;
//                    double yc = ty;
                    double zc = 100.0; //?
                    double az = Math.atan2(xc,zc);
                    double el = Math.atan2(yc,Math.sqrt(xc*xc+yc*yc));
//                    double el = Math.atan2(yc,400.0);
//                    tx = (int)(az*camera.width/camera.fov);
                    ty = (int)(el*camera.height/camera.vfov);
   ty = (int)(0.1*(double)(ty) + 0.9*yc); //?????
   ty = (int)(ty + camera.height/2.0); //????
                }
                camera.getPixel (tx,ty,tempColor);
                framebuffer.setPixel (x, y, tempColor);
            }
        }
        // If file output turned on, write frame TGA file
        if (fileOutput)
            output(frame);
    }
*/

    void render (int frame) {
        int tx, ty;
        double f = camera.width/2.0/Math.tan(camera.fov/2.0);
        for (int y=0; y<height; y++) {
            for (int x=0; x<width; x++) {
                tx = transformX(x,y);
                ty = transformY(x,y);
                if (rectify) {
                    double xc = tx - camera.width/2.0;
                    double yc = ty - camera.height/2.0;
//                    double yc = ty;
//                    double zc = 100.0; //?
                    double zc = f; //?
                    double len = Math.sqrt(xc*xc+yc*yc+zc*zc);
                    xc = xc / len;
                    yc = yc / len;
                    zc = zc / len;
                    double az = Math.atan2(xc,zc);
//                    double el = Math.atan2(yc,Math.sqrt(xc*xc+yc*yc));
                    double el = Math.atan2(yc,1.0);
//                    double el = Math.atan2(yc,400.0);
//                    tx = (int)(az*camera.width/camera.fov);
//                    ty = (int)(el*camera.height/camera.vfov);
//   ty = (int)(0.1*(double)(ty) + 0.9*yc); //?????
//   ty = (int)(ty + camera.height/2.0); //????
                    tx = (int)(az*camera.width/camera.fov+camera.width/2.0);
                    ty = (int)(el*camera.height/camera.vfov+camera.height/2.0);
                }
                camera.getPixel (tx,ty,tempColor);
                framebuffer.setPixel (x, y, tempColor);
            }
        }
        // If file output turned on, write frame TGA file
        if (fileOutput)
            output(frame);
    }
    /** Output current frame TGA file */
    void output (int frame) {
        framebuffer.savetga (path + "frame" + frame + ".tga");
    }

    /** Override to change viewport for animation frames */
    void animate (int frame) {
    }

}