From 7a2e20caac9db6f789a7b3fab344b9758af45335 Mon Sep 17 00:00:00 2001 From: Harvey Harrison Date: Sun, 19 Apr 2015 21:02:06 -0700 Subject: j3dcore: flatten the directory structure a bit Signed-off-by: Harvey Harrison --- src/javax/media/j3d/CachedFrustum.java | 234 +++++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) create mode 100644 src/javax/media/j3d/CachedFrustum.java (limited to 'src/javax/media/j3d/CachedFrustum.java') diff --git a/src/javax/media/j3d/CachedFrustum.java b/src/javax/media/j3d/CachedFrustum.java new file mode 100644 index 0000000..c3d6e90 --- /dev/null +++ b/src/javax/media/j3d/CachedFrustum.java @@ -0,0 +1,234 @@ +/* + * Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package javax.media.j3d; + +import javax.vecmath.Point3d; +import javax.vecmath.Vector4d; + +/** + * The CachedFrustum class is used to pre compute data for a set of view + * frustum planes which allows more efficient intersection testing. + * + * The CachedFrustum caches data for frustums for effecient intersection + * testing. + */ + +// this class assumes the planes are in the following order: + // left plane = frustumPlanes[0] + // right plane = frustumPlanes[1] + // top plane = frustumPlanes[2] + // bottom plane = frustumPlanes[3] + // front plane = frustumPlanes[4] + // back plane = frustumPlanes[5] + +class CachedFrustum { + + static final double EPSILON = 1.0E-8; + Vector4d[] clipPlanes; + Point3d[] verts; + Point3d upper,lower; // bounding box of frustum + Point3d center; // center of frustum + + + /** + * Constructs and initializes a new CachedFrustum using the values + * provided in the argument. + * @param planes array specifying the frustum's clip plane position + */ + CachedFrustum(Vector4d[] planes) { + int i; + if( planes.length < 6 ) { + throw new IllegalArgumentException(J3dI18N.getString("CachedFrustum0")); + } + clipPlanes = new Vector4d[6]; + verts = new Point3d[8]; + upper = new Point3d(); + lower = new Point3d(); + center = new Point3d(); + + for(i=0;i<8;i++){ + verts[i] = new Point3d(); + } + + for(i=0;i<6;i++){ + clipPlanes[i] = new Vector4d( planes[i] ); + } + computeValues(clipPlanes); + } + + /** + * Constructs and initializes a new default CachedFrustum + * @param planes array specifying the frustum's clip planes + */ + CachedFrustum() { + int i; + clipPlanes = new Vector4d[6]; + upper = new Point3d(); + lower = new Point3d(); + verts = new Point3d[8]; + center = new Point3d(); + + for(i=0;i<8;i++){ + verts[i] = new Point3d(); + } + for(i=0;i<6;i++){ + clipPlanes[i] = new Vector4d(); + } + + } + + /** + * Returns a string containing the values of the CachedFrustum. + */ + @Override + public String toString() { + return( clipPlanes[0].toString()+"\n"+ + clipPlanes[1].toString()+"\n"+ + clipPlanes[2].toString()+"\n"+ + clipPlanes[3].toString()+"\n"+ + clipPlanes[4].toString()+"\n"+ + clipPlanes[5].toString()+"\n"+ + "corners="+"\n"+ + verts[0].toString()+"\n"+ + verts[1].toString()+"\n"+ + verts[2].toString()+"\n"+ + verts[3].toString()+"\n"+ + verts[4].toString()+"\n"+ + verts[5].toString()+"\n"+ + verts[6].toString()+"\n"+ + verts[7].toString() + ); + } + + + /** + * Sets the values of the CachedFrustum based on a new set of frustum planes. + * @param planes array specifying the frustum's clip planes + */ + void set(Vector4d[] planes) { + int i; + + if( planes.length != 6 ) { + throw new IllegalArgumentException(J3dI18N.getString("CachedFrustum1")); + } + + for(i=0;i<6;i++){ + clipPlanes[i].set( planes[i] ); + } + + computeValues(clipPlanes); + } + + /** + * Computes cached values. + * @param planes array specifying the frustum's clip planes + */ + private void computeValues(Vector4d[] planes) { + + int i; + + // compute verts + + computeVertex( 0, 3, 4, verts[0]); // front-bottom-left + computeVertex( 0, 2, 4, verts[1]); // front-top-left + computeVertex( 1, 2, 4, verts[2]); // front-top-right + computeVertex( 1, 3, 4, verts[3]); // front-bottom-right + computeVertex( 0, 3, 5, verts[4]); // back-bottom-left + computeVertex( 0, 2, 5, verts[5]); // back-top-left + computeVertex( 1, 2, 5, verts[6]); // back-top-right + computeVertex( 1, 3, 5, verts[7]); // back-bottom-right + + // compute bounding box + + upper.x = verts[0].x; + upper.y = verts[0].y; + upper.z = verts[0].z; + lower.x = verts[0].x; + lower.y = verts[0].y; + lower.z = verts[0].z; + + center.x = verts[0].x; + center.y = verts[0].y; + center.z = verts[0].z; + + // find min and max in x-y-z directions + + for(i=1;i<8;i++) { + if( verts[i].x > upper.x) upper.x = verts[i].x; // xmax + if( verts[i].x < lower.x) lower.x = verts[i].x; // xmin + + if( verts[i].y > upper.y) upper.y = verts[i].y; // ymay + if( verts[i].y < lower.y) lower.y = verts[i].y; // ymin + + if( verts[i].z > upper.z) upper.z = verts[i].z; // zmaz + if( verts[i].z < lower.z) lower.z = verts[i].z; // zmin + + center.x += verts[i].x; + center.y += verts[i].y; + center.z += verts[i].z; + } + + center.x = center.x*0.125; + center.y = center.y*0.125; + center.z = center.z*0.125; + + } + + private void computeVertex( int a, int b, int c, Point3d vert) { + double det; + + det = clipPlanes[a].x*clipPlanes[b].y*clipPlanes[c].z + clipPlanes[a].y*clipPlanes[b].z*clipPlanes[c].x + + clipPlanes[a].z*clipPlanes[b].x*clipPlanes[c].y - clipPlanes[a].z*clipPlanes[b].y*clipPlanes[c].x - + clipPlanes[a].y*clipPlanes[b].x*clipPlanes[c].z - clipPlanes[a].x*clipPlanes[b].z*clipPlanes[c].y; + + + if( det*det < EPSILON ){ + // System.err.println("************** Two planes are parallel : det = " + det); + return; // two planes are parallel + } + + det = 1.0/det; + + vert.x = (clipPlanes[b].y*clipPlanes[c].z - clipPlanes[b].z*clipPlanes[c].y) * -clipPlanes[a].w; + vert.y = (clipPlanes[b].z*clipPlanes[c].x - clipPlanes[b].x*clipPlanes[c].z) * -clipPlanes[a].w; + vert.z = (clipPlanes[b].x*clipPlanes[c].y - clipPlanes[b].y*clipPlanes[c].x) * -clipPlanes[a].w; + + vert.x += (clipPlanes[c].y*clipPlanes[a].z - clipPlanes[c].z*clipPlanes[a].y) * -clipPlanes[b].w; + vert.y += (clipPlanes[c].z*clipPlanes[a].x - clipPlanes[c].x*clipPlanes[a].z) * -clipPlanes[b].w; + vert.z += (clipPlanes[c].x*clipPlanes[a].y - clipPlanes[c].y*clipPlanes[a].x) * -clipPlanes[b].w; + + vert.x += (clipPlanes[a].y*clipPlanes[b].z - clipPlanes[a].z*clipPlanes[b].y) * -clipPlanes[c].w; + vert.y += (clipPlanes[a].z*clipPlanes[b].x - clipPlanes[a].x*clipPlanes[b].z) * -clipPlanes[c].w; + vert.z += (clipPlanes[a].x*clipPlanes[b].y - clipPlanes[a].y*clipPlanes[b].x) * -clipPlanes[c].w; + + vert.x = vert.x*det; + vert.y = vert.y*det; + vert.z = vert.z*det; + + } + +} -- cgit v1.2.3