/* * gleem -- OpenGL Extremely Easy-To-Use Manipulators. * Copyright (C) 1998-2003 Kenneth B. Russell (kbrussel@alum.mit.edu) * * Copying, distribution and use of this software in source and binary * forms, with or without modification, is permitted provided that the * following conditions are met: * * Distributions of source code must reproduce the copyright notice, * this list of conditions and the following disclaimer in the source * code header files; and Distributions of binary code must reproduce * the copyright notice, this list of conditions and the following * disclaimer in the documentation, Read me file, license file and/or * other materials provided with the software distribution. * * The names of Sun Microsystems, Inc. ("Sun") and/or the copyright * holder may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT A WARRANTY OF ANY * KIND. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE, NON-INTERFERENCE, ACCURACY OF * INFORMATIONAL CONTENT OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. THE * COPYRIGHT HOLDER, SUN AND SUN'S LICENSORS SHALL NOT BE LIABLE FOR * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL THE * COPYRIGHT HOLDER, SUN OR SUN'S LICENSORS BE LIABLE FOR ANY LOST * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, * CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND * REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR * INABILITY TO USE THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGES. YOU ACKNOWLEDGE THAT THIS SOFTWARE IS NOT * DESIGNED, LICENSED OR INTENDED FOR USE IN THE DESIGN, CONSTRUCTION, * OPERATION OR MAINTENANCE OF ANY NUCLEAR FACILITY. THE COPYRIGHT * HOLDER, SUN AND SUN'S LICENSORS DISCLAIM ANY EXPRESS OR IMPLIED * WARRANTY OF FITNESS FOR SUCH USES. */ package gleem; import gleem.linalg.*; /** Container class for camera's parameters. */ public class CameraParameters { private Vec3f position = new Vec3f(); private Vec3f forwardDirection = new Vec3f(); private Vec3f upDirection = new Vec3f(); private Rotf orientation = new Rotf(); private Mat4f modelviewMatrix = new Mat4f(); private Mat4f projectionMatrix = new Mat4f(); float vertFOV; float imagePlaneAspectRatio; int xSize; int ySize; public CameraParameters() {} public CameraParameters(Vec3f position, Vec3f forwardDirection, Vec3f upDirection, Rotf orientation, Mat4f modelviewMatrix, Mat4f projectionMatrix, float vertFOV, float imagePlaneAspectRatio, int xSize, int ySize) { setPosition(position); setForwardDirection(forwardDirection); setUpDirection(upDirection); setOrientation(orientation); setModelviewMatrix(modelviewMatrix); setProjectionMatrix(projectionMatrix); setVertFOV(vertFOV); setImagePlaneAspectRatio(imagePlaneAspectRatio); setXSize(xSize); setYSize(ySize); } public void set(CameraParameters params) { setPosition(params.getPosition()); setForwardDirection(params.getForwardDirection()); setUpDirection(params.getUpDirection()); setOrientation(params.getOrientation()); setModelviewMatrix(params.getModelviewMatrix()); setProjectionMatrix(params.getProjectionMatrix()); setVertFOV(params.getVertFOV()); setImagePlaneAspectRatio(params.getImagePlaneAspectRatio()); setXSize(params.getXSize()); setYSize(params.getYSize()); } public Object clone() { CameraParameters params = new CameraParameters(); params.set(this); return params; } public CameraParameters copy() { return (CameraParameters) clone(); } /** Sets 3-space origin of camera */ public void setPosition(Vec3f position) { this.position.set(position); } /** Gets 3-space origin of camera */ public Vec3f getPosition() { return position; } /** Sets 3-space forward direction of camera. Does not need to be normalized. */ public void setForwardDirection(Vec3f fwd) { forwardDirection.set(fwd); } /** Gets 3-space forward direction of camera. */ public Vec3f getForwardDirection() { return forwardDirection; } /** Sets 3-space upward direction of camera. This must be orthogonal to the viewing direction, but does not need to be normalized. */ public void setUpDirection(Vec3f up) { upDirection.set(up); } /** Gets 3-space upward direction of camera. */ public Vec3f getUpDirection() { return upDirection; } /** Sets orientation of camera. NOTE: user is responsible for ensuring this corresponds with the up and forward vectors. */ public void setOrientation(Rotf orientation) { this.orientation.set(orientation); } /** Gets orientation of camera. */ public Rotf getOrientation() { return orientation; } /** Sets the modelview matrix corresponding to the orientation and position of the camera. NOTE: user is responsible for ensuring this corresponds to the rest of the camera parameters. */ public void setModelviewMatrix(Mat4f matrix) { modelviewMatrix.set(matrix); } /** Gets the modelview matrix corresponding to the orientation and position of the camera. */ public Mat4f getModelviewMatrix() { return modelviewMatrix; } /** Sets the projection matrix corresponding to the camera's field-of-view and aspect ratio parameters. NOTE: user is responsible for ensuring this matrix corresponds to these parameters.*/ public void setProjectionMatrix(Mat4f matrix) { projectionMatrix.set(matrix); } /** Gets the projection matrix corresponding to the camera's field-of-view and aspect ratio parameters. */ public Mat4f getProjectionMatrix() { return projectionMatrix; } /** Takes HALF of the vertical angular span of the frustum, specified in radians. For example, if your <b>fovy</b> argument to gluPerspective() is 90, then this would be Math.PI / 4. */ public void setVertFOV(float vertFOV) { this.vertFOV = vertFOV; } /** Returns HALF of the vertical angular span of the frustum, specified in radians. */ public float getVertFOV() { return vertFOV; } /** Sets the aspect ratio of the image plane. Note that this does not necessarily have to correspond to the aspect ratio of the window. */ public void setImagePlaneAspectRatio(float ratio) { imagePlaneAspectRatio = ratio; } /** Gets the aspect ratio of the image plane. */ public float getImagePlaneAspectRatio() { return imagePlaneAspectRatio; } /** Sets the horizontal size of the window, in pixels */ public void setXSize(int xSize) { this.xSize = xSize; } /** Gets the horizontal size of the window, in pixels */ public int getXSize() { return xSize; } /** Sets the vertical size of the window, in pixels */ public void setYSize(int ySize) { this.ySize = ySize; } /** Gets the vertical size of the window, in pixels */ public int getYSize() { return ySize; } }