/*
* Copyright 1996-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 java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import javax.vecmath.Color3b;
import javax.vecmath.Color3f;
import javax.vecmath.Color4b;
import javax.vecmath.Color4f;
import javax.vecmath.Point2d;
import javax.vecmath.Point2f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Point4d;
import javax.vecmath.Point4f;
import javax.vecmath.TexCoord2f;
import javax.vecmath.TexCoord3f;
import javax.vecmath.TexCoord4f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;
/**
* The GeometryArray object contains arrays of positional coordinates,
* colors, normals and/or texture coordinates that describe
* point, line, or surface geometry. It is extended to create
* the various primitive types (e.g., lines, triangle_strips, etc.)
*/
abstract class GeometryArrayRetained extends GeometryRetained{
// XXXX: Memory footprint reduction. Should have separate object to
// to contain specific data such as a ByRef object for
// all ByRef related data. So that incases where no
// ByRef is needed, the ByRef object reference is
// set to null. Hence saving memory!
// Need object such as Texture, D3d and ByRef ...
//
// Contains a bitset indicating which components are present
int vertexFormat;
// Whether this geometry was ever rendered as transparent
int c4fAllocated = 0;
// Total Number of vertices
int vertexCount;
// number of vertices used in rendering
int validVertexCount;
// The vertex data in packed format
float vertexData[];
// vertex data in packed format for each screen in multi-screen situation
// if alpha values of each vertex are to be updated
private float mvertexData[][];
//
// The following offset/stride values are internally computed
// from the format
//
// Stride (in words) from one vertex to the next
int stride;
// Stride (in words) from one texture coordinate to the next
int texCoordStride;
// Offset (in words) within each vertex of the coordinate position
int coordinateOffset;
// Offset (in words) within each vertex of the normal
int normalOffset;
// Offset (in words) within each vertex of the color
int colorOffset;
// Offset (in words) within each vertex of the texture coordinate
int textureOffset;
// Offset (in words) within each vertex of each vertex attribute
int[] vertexAttrOffsets;
// Stride (size) of all vertex attributes
int vertexAttrStride;
// alpha value for transparency and texture blending
private float[] lastAlpha = new float[1];
float lastScreenAlpha = -1;
int colorChanged = 0;
// byte to float scale factor
static final float ByteToFloatScale = 1.0f/255.0f;
// float to byte scale factor
static final float FloatToByteScale = 255.0f;
// Set flag indicating that we are in the updater. This flag
// can be used by the various setRef methods to inhibit any
// update messages
boolean inUpdater = false;
// Array List used for messages
ArrayList<GeometryAtom> gaList = new ArrayList<GeometryAtom>(1);
// Target threads to be notified when morph changes
static final int targetThreads = (J3dThread.UPDATE_RENDER |
J3dThread.UPDATE_GEOMETRY);
// used for byReference geometry
float[] floatRefCoords = null;
double[] doubleRefCoords = null;
Point3d[] p3dRefCoords = null;
Point3f[] p3fRefCoords = null;
// Used for NIO buffer geometry
J3DBuffer coordRefBuffer = null;
FloatBuffer floatBufferRefCoords = null;
DoubleBuffer doubleBufferRefCoords = null;
// Initial index to use for rendering
int initialCoordIndex = 0;
int initialColorIndex = 0;
int initialNormalIndex = 0;
int[] initialTexCoordIndex = null;
int[] initialVertexAttrIndex = null;
int initialVertexIndex = 0;
// used for byReference colors
float[] floatRefColors = null;
byte[] byteRefColors = null;
Color3f[] c3fRefColors = null;
Color4f[] c4fRefColors = null;
Color3b[] c3bRefColors = null;
Color4b[] c4bRefColors = null;
// Used for NIO buffer colors
J3DBuffer colorRefBuffer = null;
FloatBuffer floatBufferRefColors = null;
ByteBuffer byteBufferRefColors = null;
// flag to indicate if the "by reference" component is already set
int vertexType = 0;
static final int PF = 0x1;
static final int PD = 0x2;
static final int P3F = 0x4;
static final int P3D = 0x8;
static final int VERTEX_DEFINED = PF | PD | P3F | P3D;
static final int CF = 0x10;
static final int CUB = 0x20;
static final int C3F = 0x40;
static final int C4F = 0x80;
static final int C3UB = 0x100;
static final int C4UB = 0x200;
static final int COLOR_DEFINED = CF | CUB | C3F | C4F| C3UB | C4UB;
static final int NF = 0x400;
static final int N3F = 0x800;
static final int NORMAL_DEFINED = NF | N3F;
static final int TF = 0x1000;
static final int T2F = 0x2000;
static final int T3F = 0x4000;
static final int TEXCOORD_DEFINED = TF | T2F | T3F;
static final int AF = 0x8000;
static final int VATTR_DEFINED = AF;
// Flag word indicating the type of by-ref texCoord. We will copy this to
// the vertexType field only when the references for all texture coordinate
// sets are set to non-null values.
private int texCoordType = 0;
// Flag word indicating the type of by-ref vertex attr. We will copy this to
// the vertexType field only when the references for all vertex attrs
// are set to non-null values.
private int vertexAttrType = 0;
// flag for execute geometry array when by reference
static final int COORD_FLOAT = 0x01;
static final int COORD_DOUBLE = 0x02;
static final int COLOR_FLOAT = 0x04;
static final int COLOR_BYTE = 0x08;
static final int NORMAL_FLOAT = 0x10;
static final int TEXCOORD_FLOAT = 0x20;
static final int VATTR_FLOAT = 0x40;
// used by "by reference" normals
float[] floatRefNormals = null;
Vector3f[] v3fRefNormals = null;
// Used for NIO buffer normals
J3DBuffer normalRefBuffer = null;
FloatBuffer floatBufferRefNormals = null;
// used for "by reference" vertex attrs
float[][] floatRefVertexAttrs = null;
// Used for NIO buffer vertex attrs
J3DBuffer[] vertexAttrsRefBuffer = null;
FloatBuffer[] floatBufferRefVertexAttrs = null;
// used by "by reference" tex coords
Object[] refTexCoords = null;
TexCoord2f[] t2fRefTexCoords = null;
TexCoord3f[] t3fRefTexCoords = null;
// Used for NIO buffer tex coords
J3DBuffer[] refTexCoordsBuffer = null;
//FloatBufferWrapper[] floatBufferRefTexCoords = null;
// used by interleaved array
float[] interLeavedVertexData = null;
// used by interleaved NIO buffer
J3DBuffer interleavedVertexBuffer = null;
FloatBuffer interleavedFloatBufferImpl = null;
// pointers used, when transparency is turned on
// or when its an object such as C3F, P3F etc ..
float[] mirrorFloatRefCoords = null;
double[] mirrorDoubleRefCoords = null;
float[] mirrorFloatRefNormals = null;
float[][] mirrorFloatRefVertexAttrs = null;
float[] mirrorFloatRefTexCoords = null;
Object[] mirrorRefTexCoords = null;
float[][] mirrorFloatRefColors = new float[1][];
byte[][] mirrorUnsignedByteRefColors= new byte[1][];
float[][] mirrorInterleavedColorPointer = null;
// boolean to determine if a mirror was allocated
int mirrorVertexAllocated = 0;
int mirrorColorAllocated = 0;
boolean mirrorNormalAllocated = false;
// Some dirty bits for GeometryArrays
static final int COORDINATE_CHANGED = 0x01;
static final int NORMAL_CHANGED = 0x02;
static final int COLOR_CHANGED = 0x04;
static final int TEXTURE_CHANGED = 0x08;
static final int BOUNDS_CHANGED = 0x10;
static final int INDEX_CHANGED = 0x20;
static final int STRIPCOUNT_CHANGED = 0x40;
static final int VATTR_CHANGED = 0x80;
static final int VERTEX_CHANGED = COORDINATE_CHANGED |
NORMAL_CHANGED |
COLOR_CHANGED |
TEXTURE_CHANGED |
VATTR_CHANGED;
static final int defaultTexCoordSetMap[] = {0};
int texCoordSetCount = 0;
int [] texCoordSetMap = null;
// this array contains offset to the texCoord data for each
// texture unit. -1 means no corresponding texCoord data offset
int [] texCoordSetMapOffset = null;
// Vertex attribute information
int vertexAttrCount = 0;
int[] vertexAttrSizes = null;
// This point to a list of VertexBuffers in a Vector structure
// Each element correspond to a D3D context that create this VB.
// Note that this GeometryArray can be used by multiple ctx.
int dirtyFlag;
// each bit corresponds to a unique renderer if shared context
// or a unique canvas otherwise
int resourceCreationMask = 0x0;
// Fix for Issue 5
//
// Replace the per-canvas reference count with a per-RenderBin set
// of users. The per-RenderBin set of users of this display list
// is defined as a HashMap where:
//
// key = the RenderBin
// value = a set of RenderAtomListInfo objects using this
// geometry array for display list purposes
private HashMap<RenderBin, HashSet<RenderAtomListInfo>> dlistUsers = null;
// timestamp used to create display list. This is either
// one per renderer for useSharedCtx, or one per Canvas for non-shared
// ctx
private long[] timeStampPerDlist = new long[2];
// Unique display list Id, if this geometry is shared
int dlistId = -1;
Integer dlistObj = null;
// A list of pre-defined bits to indicate which component
// in this Texture object changed.
// static final int DLIST_CREATE_CHANGED = 0x01;
static final int INIT_MIRROR_GEOMETRY = 0x02;
// A list of Universes that this Geometry is referenced in Morph from
ArrayList<VirtualUniverse> morphUniverseList = null;
// A list of ArrayLists which contain all the MorphRetained objects
// refering to this geometry. Each list corresponds to the universe
// above.
ArrayList<ArrayList<MorphRetained>> morphUserLists = null;
// The following variables are only used in compile mode
// Offset of a geometry array into the merged array
int[] geoOffset;
// vertexcount of a geometry array in a merge array
int[] compileVcount;
boolean isCompiled = false;
boolean isShared = false;
IndexedGeometryArrayRetained cloneSourceArray = null;
static final double EPS = 1.0e-13;
GeometryArrayRetained() {
dirtyFlag = INDEX_CHANGED|VERTEX_CHANGED;
lastAlpha[0] = 1.0f;
}
@Override
void setLive(boolean inBackgroundGroup, int refCount) {
dirtyFlag = VERTEX_CHANGED|INDEX_CHANGED;
isEditable = !isWriteStatic();
super.doSetLive(inBackgroundGroup, refCount);
super.markAsLive();
// Send message to RenderingAttribute structure to obtain a dlistId
// System.err.println("Geometry - "+this+"refCount = "+this.refCount);
if (this.refCount > 1) {
// Send to rendering attribute structure,
/*
J3dMessage createMessage = new J3dMessage();
createMessage.threads = J3dThread.UPDATE_RENDERING_ATTRIBUTES;
createMessage.type = J3dMessage.GEOMETRYARRAY_CHANGED;
createMessage.universe = null;
createMessage.args[0] = this;
createMessage.args[1]= new Integer(DLIST_CREATE_CHANGED);
VirtualUniverse.mc.processMessage(createMessage);
*/
isShared = true;
} // Clone geometry only for the first setLive
else {
// If geometry is indexed and use_index_coord is false, unindexify
// otherwise, set mirrorGeometry to null (from previous clearLive)
if (this instanceof IndexedGeometryArrayRetained) {
// Send to rendering attribute structure,
J3dMessage createMessage = new J3dMessage();
createMessage.threads = J3dThread.UPDATE_RENDERING_ATTRIBUTES;
createMessage.type = J3dMessage.GEOMETRY_CHANGED;
createMessage.universe = null;
createMessage.args[0] = null;
createMessage.args[1]= this;
createMessage.args[2]= new Integer(INIT_MIRROR_GEOMETRY);
VirtualUniverse.mc.processMessage(createMessage);
}
}
}
@Override
void clearLive(int refCount) {
super.clearLive(refCount);
if (this.refCount <= 0) {
isShared = false;
}
}
@Override
void computeBoundingBox() {
// System.err.println("computeBoundingBox ....");
if (boundsDirty && VirtualUniverse.mc.cacheAutoComputedBounds) {
for(ArrayList<Shape3DRetained> users : userLists) {
for(Shape3DRetained shape : users)
shape.dirtyBoundsCache();
}
}
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
// by copy
computeBoundingBox(initialVertexIndex, vertexData);
} else if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) { // USE_NIO_BUFFER
//System.err.println("vertexFormat & GeometryArray.USE_NIO_BUFFER");
if((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
computeBoundingBox(initialCoordIndex, interleavedFloatBufferImpl);
} else if((vertexType & PF) != 0) {
computeBoundingBox(floatBufferRefCoords);
} else if((vertexType & PD) != 0) {
computeBoundingBox(doubleBufferRefCoords);
}
} else if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
//System.err.println("vertexFormat & GeometryArray.INTERLEAVED");
computeBoundingBox(initialCoordIndex, interLeavedVertexData);
} else if ((vertexType & PF) != 0) {
//System.err.println("vertexType & PF");
computeBoundingBox(floatRefCoords);
} else if ((vertexType & P3F) != 0) {
//System.err.println("vertexType & P3F");
computeBoundingBox(p3fRefCoords);
} else if ((vertexType & P3D) != 0) {
//System.err.println("vertexType & P3D");
computeBoundingBox(p3dRefCoords);
} else if ((vertexType & PD) != 0) {
//System.err.println("vertexType & PD");
computeBoundingBox(doubleRefCoords);
}
}
// NullGeometry is true only for byRef case
void processCoordsChanged(boolean nullGeo) {
/*
System.err.println("processCoordsChanged : nullGeo " + nullGeo);
System.err.println("Before :processCoordsChanged : geoBounds ");
System.err.println(geoBounds);
*/
if (nullGeo) {
synchronized(geoBounds) {
geoBounds.setLower(-1.0, -1.0, -1.0);
geoBounds.setUpper(1.0, 1.0, 1.0);
boundsDirty = false;
}
synchronized(centroid) {
recompCentroid = false;
geoBounds.getCenter(this.centroid);
}
}
else {
// re-compute centroid if used
synchronized(centroid) {
recompCentroid = true;
}
synchronized(geoBounds) {
boundsDirty = true;
computeBoundingBox();
}
/*
System.err.println("After :processCoordsChanged : geoBounds ");
System.err.println(geoBounds);
*/
}
}
void computeBoundingBox(int vIndex, float[] vdata) {
int i, offset;
double xmin, xmax, ymin, ymax, zmin, zmax;
//System.err.println("Before : computeBoundingBox : geoBounds ");
// System.err.println(geoBounds);
synchronized(geoBounds) {
// If autobounds compute is false then return
// It is possible that user call getBounds() before
// this Geometry add to live scene graph.
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
// Initial offset
offset = vIndex * stride+coordinateOffset;
// Compute the bounding box
xmin = xmax = vdata[offset];
ymin = ymax = vdata[offset+1];
zmin = zmax = vdata[offset+2];
offset += stride;
for (i=1; i<validVertexCount; i++) {
if (vdata[offset] > xmax)
xmax = vdata[offset];
if (vdata[offset] < xmin)
xmin = vdata[offset];
if (vdata[offset+1] > ymax)
ymax = vdata[offset+1];
if (vdata[offset+1] < ymin)
ymin = vdata[offset+1];
if (vdata[offset+2] > zmax)
zmax = vdata[offset+2];
if (vdata[offset+2] < zmin)
zmin = vdata[offset+2];
offset += stride;
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
/*
System.err.println("After : computeBoundingBox : geoBounds ");
System.err.println(geoBounds);
*/
}
// Compute boundingbox for interleaved nio buffer
void computeBoundingBox(int vIndex, FloatBuffer vdata) {
int i, offset;
double xmin, xmax, ymin, ymax, zmin, zmax;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
// Initial offset
offset = vIndex * stride+coordinateOffset;
// Compute the bounding box
xmin = xmax = vdata.get(offset);
ymin = ymax = vdata.get(offset+1);
zmin = zmax = vdata.get(offset+2);
offset += stride;
for (i=1; i<validVertexCount; i++) {
if (vdata.get(offset) > xmax)
xmax = vdata.get(offset);
if (vdata.get(offset) < xmin)
xmin = vdata.get(offset);
if (vdata.get(offset+1) > ymax)
ymax = vdata.get(offset+1);
if (vdata.get(offset+1) < ymin)
ymin = vdata.get(offset+1);
if (vdata.get(offset+2) > zmax)
zmax = vdata.get(offset+2);
if (vdata.get(offset+2) < zmin)
zmin = vdata.get(offset+2);
offset += stride;
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
}
// compute bounding box for coord with nio buffer
void computeBoundingBox( DoubleBuffer buffer) {
int i, j, k, sIndex;
double xmin, xmax, ymin, ymax, zmin, zmax;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
sIndex = initialCoordIndex;
int maxIndex = 3*validVertexCount;
// Compute the bounding box
xmin = xmax = buffer.get(sIndex++);
ymin = ymax = buffer.get(sIndex++);
zmin = zmax = buffer.get(sIndex++);
for (i=sIndex; i<maxIndex; i+=3) {
j = i + 1;
k = i + 2;
if (buffer.get(i) > xmax)
xmax = buffer.get(i);
if (buffer.get(i) < xmin)
xmin = buffer.get(i);
if (buffer.get(j) > ymax)
ymax = buffer.get(j);
if (buffer.get(j) < ymin)
ymin = buffer.get(j);
if (buffer.get(k) > zmax)
zmax = buffer.get(k);
if (buffer.get(k) < zmin)
zmin = buffer.get(k);
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
}
// compute bounding box for coord with nio buffer
void computeBoundingBox( FloatBuffer buffer) {
int i, j, k, sIndex;
double xmin, xmax, ymin, ymax, zmin, zmax;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
sIndex = initialCoordIndex;
int maxIndex = 3*validVertexCount;
// Compute the bounding box
xmin = xmax = buffer.get(sIndex++);
ymin = ymax = buffer.get(sIndex++);
zmin = zmax = buffer.get(sIndex++);
for (i=sIndex; i<maxIndex; i+=3) {
j = i + 1;
k = i + 2;
if (buffer.get(i) > xmax)
xmax = buffer.get(i);
if (buffer.get(i) < xmin)
xmin = buffer.get(i);
if (buffer.get(j) > ymax)
ymax = buffer.get(j);
if (buffer.get(j) < ymin)
ymin = buffer.get(j);
if (buffer.get(k) > zmax)
zmax = buffer.get(k);
if (buffer.get(k) < zmin)
zmin = buffer.get(k);
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
}
void computeBoundingBox(float[] coords) {
// System.err.println("GeometryArrayRetained : computeBoundingBox(float[] coords)");
int i, j, k, sIndex;
double xmin, xmax, ymin, ymax, zmin, zmax;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
sIndex = initialCoordIndex;
int maxIndex = 3*validVertexCount;
// Compute the bounding box
xmin = xmax = coords[sIndex++];
ymin = ymax = coords[sIndex++];
zmin = zmax = coords[sIndex++];
for (i=sIndex; i<maxIndex; i+=3) {
j = i + 1;
k = i + 2;
if (coords[i] > xmax)
xmax = coords[i];
if (coords[i] < xmin)
xmin = coords[i];
if (coords[j] > ymax)
ymax = coords[j];
if (coords[j] < ymin)
ymin = coords[j];
if (coords[k] > zmax)
zmax = coords[k];
if (coords[k] < zmin)
zmin = coords[k];
}
geoBounds.setUpper(xmax, ymax, zmax);
// System.err.println("max(" + xmax + ", " + ymax + ", " + zmax + ")");
geoBounds.setLower(xmin, ymin, zmin);
// System.err.println("min(" + xmin + ", " + ymin + ", " + zmin + ")");
boundsDirty = false;
}
}
void computeBoundingBox(double[] coords) {
int i, j, k, sIndex;
double xmin, xmax, ymin, ymax, zmin, zmax;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
sIndex = initialCoordIndex;
int maxIndex = 3*validVertexCount;
// Compute the bounding box
xmin = xmax = coords[sIndex++];
ymin = ymax = coords[sIndex++];
zmin = zmax = coords[sIndex++];
for (i=sIndex; i<maxIndex; i+=3) {
j = i + 1;
k = i + 2;
if (coords[i] > xmax)
xmax = coords[i];
if (coords[i] < xmin)
xmin = coords[i];
if (coords[j] > ymax)
ymax = coords[j];
if (coords[j] < ymin)
ymin = coords[j];
if (coords[k] > zmax)
zmax = coords[k];
if (coords[k] < zmin)
zmin = coords[k];
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
}
void computeBoundingBox(Point3f[] coords) {
double xmin, xmax, ymin, ymax, zmin, zmax;
Point3f p;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
// Compute the bounding box
xmin = xmax = coords[initialCoordIndex].x;
ymin = ymax = coords[initialCoordIndex].y;
zmin = zmax = coords[initialCoordIndex].z;
for (int i=initialCoordIndex+1; i<validVertexCount; i++) {
p = coords[i];
if (p.x > xmax) xmax = p.x;
if (p.x < xmin) xmin = p.x;
if (p.y > ymax) ymax = p.y;
if (p.y < ymin) ymin = p.y;
if (p.z > zmax) zmax = p.z;
if (p.z < zmin) zmin = p.z;
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
}
void computeBoundingBox(Point3d[] coords) {
double xmin, xmax, ymin, ymax, zmin, zmax;
Point3d p;
synchronized(geoBounds) {
// If autobounds compute is false then return
if ((computeGeoBounds == 0) && (refCount > 0)) {
return;
}
if (!boundsDirty)
return;
// Compute the bounding box
xmin = xmax = coords[initialCoordIndex].x;
ymin = ymax = coords[initialCoordIndex].y;
zmin = zmax = coords[initialCoordIndex].z;
for (int i=initialCoordIndex+1; i<validVertexCount; i++) {
p = coords[i];
if (p.x > xmax) xmax = p.x;
if (p.x < xmin) xmin = p.x;
if (p.y > ymax) ymax = p.y;
if (p.y < ymin) ymin = p.y;
if (p.z > zmax) zmax = p.z;
if (p.z < zmin) zmin = p.z;
}
geoBounds.setUpper(xmax, ymax, zmax);
geoBounds.setLower(xmin, ymin, zmin);
boundsDirty = false;
}
}
@Override
synchronized void update() {
}
void setupMirrorVertexPointer(int vType) {
int i, index;
switch (vType) {
case PF:
if (floatRefCoords == null) {
if ((vertexType & VERTEX_DEFINED) == PF) {
vertexType &= ~PF;
mirrorFloatRefCoords = null;
mirrorVertexAllocated &= ~PF;
}
}
else {
vertexType |= PF;
mirrorFloatRefCoords = floatRefCoords;
mirrorVertexAllocated &= ~PF;
}
break;
case PD:
if (doubleRefCoords == null) {
if ((vertexType & VERTEX_DEFINED) == PD) {
mirrorDoubleRefCoords = null;
mirrorVertexAllocated &= ~PD;
vertexType &= ~PD;
}
vertexType &= ~PD;
}
else {
vertexType |= PD;
mirrorDoubleRefCoords = doubleRefCoords;
mirrorVertexAllocated &= ~PD;
}
break;
case P3F:
if (p3fRefCoords == null) {
vertexType &= ~P3F;
// Don't set the mirrorFloatRefCoords to null,
// may be able to re-use
// mirrorFloatRefCoords = null;
}
else {
vertexType |= P3F;
if ((mirrorVertexAllocated & PF) == 0) {
mirrorFloatRefCoords = new float[vertexCount * 3];
mirrorVertexAllocated |= PF;
}
index = initialCoordIndex * 3;
for ( i=initialCoordIndex; i<validVertexCount; i++) {
mirrorFloatRefCoords[index++] = p3fRefCoords[i].x;
mirrorFloatRefCoords[index++] = p3fRefCoords[i].y;
mirrorFloatRefCoords[index++] = p3fRefCoords[i].z;
}
}
break;
case P3D:
if (p3dRefCoords == null) {
vertexType &= ~P3D;
// Don't set the mirrorDoubleRefCoords to null,
// may be able to re-use
// mirrorDoubleRefCoords = null;
}
else {
vertexType |= P3D;
if ((mirrorVertexAllocated & PD) == 0) {
mirrorDoubleRefCoords = new double[vertexCount * 3];
mirrorVertexAllocated |= PD;
}
index = initialCoordIndex * 3;
for ( i=initialCoordIndex; i<validVertexCount; i++) {
mirrorDoubleRefCoords[index++] = p3dRefCoords[i].x;
mirrorDoubleRefCoords[index++] = p3dRefCoords[i].y;
mirrorDoubleRefCoords[index++] = p3dRefCoords[i].z;
}
}
break;
default:
break;
}
}
// If turned transparent the first time, then force it to allocate
void setupMirrorInterleavedColorPointer(boolean force) {
int index, length, offset;
int i;
if (force || (c4fAllocated != 0)) { // Color is present
length = 4 * vertexCount;
if (mirrorInterleavedColorPointer == null) {
mirrorInterleavedColorPointer = new float[1][length];
}
index = 4 * initialVertexIndex;
offset = stride * initialVertexIndex + colorOffset;
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0 &&
interLeavedVertexData != null ) { // java array
if ((vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
for (i = initialVertexIndex; i < validVertexCount; i++) {
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset];
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset+1];
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset+2];
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset+3];
offset += stride;
}
}
else {
for (i = initialVertexIndex; i < validVertexCount; i++) {
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset];
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset+1];
mirrorInterleavedColorPointer[0][index++] =
interLeavedVertexData[offset+2];
mirrorInterleavedColorPointer[0][index++] = 1.0f;
offset += stride;
}
}
} else { // NIO BUFFER
if ((vertexFormat & GeometryArray.WITH_ALPHA) != 0 &&
interleavedFloatBufferImpl != null) {
for (i = initialVertexIndex; i < validVertexCount; i++) {
interleavedFloatBufferImpl.position(offset);
interleavedFloatBufferImpl.get(mirrorInterleavedColorPointer[0],
index , 4);
index += 4;
offset += stride;
}
}
else {
for (i = initialVertexIndex; i < validVertexCount; i++) {
interleavedFloatBufferImpl.position(offset);
interleavedFloatBufferImpl.get(mirrorInterleavedColorPointer[0],
index, 3);
mirrorInterleavedColorPointer[0][index+3] = 1.0f;
index += 4;
offset += stride;
}
}
}
c4fAllocated = GeometryArray.WITH_ALPHA;
}
}
// If turned transparent the first time, then force it to allocate
void setupMirrorColorPointer(int ctype, boolean force) {
int i, srcIndex = 0, dstIndex = 0;
int multiplier;
if (c4fAllocated == 0 && !force) {
multiplier = 3;
} else {
// If the first time, we are forced to allocate 4f, then
// we need to force the allocation of the colors again
// for the case when allocation has previously occurred
// only for RGB
if (force && (c4fAllocated == 0) &&
(vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
mirrorColorAllocated = 0;
}
c4fAllocated = GeometryArray.WITH_ALPHA;
multiplier = 4;
}
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) { // java array
switch (ctype) {
case CF:
if (floatRefColors == null) {
if ((c4fAllocated == 0) && !force &&
(vertexType & COLOR_DEFINED) == CF) {
mirrorFloatRefColors[0] = null;
mirrorColorAllocated &= ~CF;
}
vertexType &= ~CF;
return;
}
vertexType |= CF;
if (c4fAllocated == 0 && !force) {
mirrorFloatRefColors[0] = floatRefColors;
mirrorColorAllocated &= ~CF;
}
else {
if ((mirrorColorAllocated & CF) == 0) {
mirrorFloatRefColors[0] = new float[4 * vertexCount];
mirrorColorAllocated |= CF;
}
if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
srcIndex = initialColorIndex * 3;
dstIndex = initialColorIndex * 4;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorFloatRefColors[0][dstIndex++] =
floatRefColors[srcIndex++];
mirrorFloatRefColors[0][dstIndex++] =
floatRefColors[srcIndex++];
mirrorFloatRefColors[0][dstIndex++] =
floatRefColors[srcIndex++];
mirrorFloatRefColors[0][dstIndex++] = 1.0f;
}
}
else {
srcIndex = initialColorIndex * 4;
System.arraycopy(floatRefColors, srcIndex,
mirrorFloatRefColors[0], srcIndex,
(4*validVertexCount));
}
}
break;
case CUB:
if (byteRefColors == null) {
if (c4fAllocated == 0 && !force &&
((vertexType & COLOR_DEFINED) == CUB) ) {
mirrorUnsignedByteRefColors[0] = null;
mirrorColorAllocated &= ~CUB;
}
vertexType &= ~CUB;
return;
}
vertexType |= CUB;
if (c4fAllocated == 0 && !force) {
mirrorUnsignedByteRefColors[0] = byteRefColors;
mirrorColorAllocated &= ~CUB;;
}
else {
if ((mirrorColorAllocated & CUB) == 0) {
mirrorUnsignedByteRefColors[0] = new byte[4 * vertexCount];
mirrorColorAllocated |= CUB;
}
if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
srcIndex = initialColorIndex * 3;
dstIndex = initialColorIndex * 4;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorUnsignedByteRefColors[0][dstIndex++] =
byteRefColors[srcIndex++];
mirrorUnsignedByteRefColors[0][dstIndex++] =
byteRefColors[srcIndex++];
mirrorUnsignedByteRefColors[0][dstIndex++] =
byteRefColors[srcIndex++];
mirrorUnsignedByteRefColors[0][dstIndex++] =
(byte)(255.0);
}
}
else {
srcIndex = initialColorIndex * 4;
System.arraycopy(byteRefColors, srcIndex,
mirrorUnsignedByteRefColors[0], srcIndex,
(4*validVertexCount));
}
}
break;
case C3F:
if (c3fRefColors == null) {
vertexType &= ~C3F;
return;
}
vertexType |=C3F ;
if ((mirrorColorAllocated & CF) == 0) {
mirrorFloatRefColors[0] = new float[vertexCount * multiplier];
mirrorColorAllocated |= CF;
}
if ((c4fAllocated & GeometryArray.WITH_ALPHA) == 0) {
dstIndex = initialColorIndex * 3;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].x;
mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].y;
mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].z;
}
} else {
dstIndex = initialColorIndex * 4;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].x;
mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].y;
mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].z;
mirrorFloatRefColors[0][dstIndex++] = 1.0f;
}
}
break;
case C4F:
if (c4fRefColors == null) {
vertexType &= ~C4F;
return;
}
vertexType |=C4F ;
if ((mirrorColorAllocated & CF) == 0) {
mirrorFloatRefColors[0] = new float[vertexCount << 2];
mirrorColorAllocated |= CF;
}
dstIndex = initialColorIndex * 4;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].x;
mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].y;
mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].z;
mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].w;
}
break;
case C3UB:
if (c3bRefColors == null) {
vertexType &= ~C3UB;
return;
}
vertexType |=C3UB ;
if ((mirrorColorAllocated & CUB) == 0) {
mirrorUnsignedByteRefColors[0] =
new byte[vertexCount * multiplier];
mirrorColorAllocated |= CUB;
}
if ((c4fAllocated & GeometryArray.WITH_ALPHA) == 0) {
dstIndex = initialColorIndex * 3;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].x;
mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].y;
mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].z;
}
} else {
dstIndex = initialColorIndex * 4;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].x;
mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].y;
mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].z;
mirrorUnsignedByteRefColors[0][dstIndex++] = (byte)255;
}
}
break;
case C4UB:
if (c4bRefColors == null) {
vertexType &= ~C4UB;
return;
}
vertexType |=C4UB ;
if ((mirrorColorAllocated & CUB) == 0) {
mirrorUnsignedByteRefColors[0] = new byte[vertexCount << 2];
mirrorColorAllocated |= CUB;
}
dstIndex = initialColorIndex * 4;
for (i = initialColorIndex; i < validVertexCount; i++) {
mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].x;
mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].y;
mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].z;
mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].w;
}
break;
default:
break;
}
}
else { //USE_NIO_BUFFER is set
if( colorRefBuffer == null) {
if (c4fAllocated == 0 && !force &&
(vertexType & COLOR_DEFINED) == CF) {
mirrorFloatRefColors[0] = null;
mirrorColorAllocated &= ~CF;
}
vertexType &= ~CF;
if (c4fAllocated == 0 && !force &&
((vertexType & COLOR_DEFINED) == CUB) ) {
mirrorUnsignedByteRefColors[0] = null;
mirrorColorAllocated &= ~CUB;
}
vertexType &= ~CUB;
return;
} else if( floatBufferRefColors != null) {
vertexType |= CF;
vertexType &= ~CUB;
if (c4fAllocated == 0 && !force) {
// NOTE: make suren mirrorFloatRefColors[0] is set right
mirrorFloatRefColors[0] = null;
mirrorColorAllocated &= ~CF;
}
else {
if ((mirrorColorAllocated & CF) == 0) {
mirrorFloatRefColors[0] = new float[4 * vertexCount];
mirrorColorAllocated |= CF;
}
floatBufferRefColors.rewind();
if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
srcIndex = initialColorIndex * 3;
dstIndex = initialColorIndex * 4;
floatBufferRefColors.position(srcIndex);
for (i = initialColorIndex; i < validVertexCount; i++) {
floatBufferRefColors.get(mirrorFloatRefColors[0], dstIndex, 3);
mirrorFloatRefColors[0][dstIndex+3] = 1.0f;
dstIndex += 4;
}
}
else {
srcIndex = initialColorIndex * 4;
dstIndex = initialColorIndex * 4;
floatBufferRefColors.position(srcIndex);
for (i = initialColorIndex; i < validVertexCount; i++) {
floatBufferRefColors.get(mirrorFloatRefColors[0], dstIndex, 4);
dstIndex+= 4;
}
}
}
} else if ( byteBufferRefColors != null) {
vertexType |= CUB;
vertexType &= ~CF;
if (c4fAllocated == 0 && !force) {
// NOTE: make sure mirrorUnsignedByteRefColors[0] is set right
mirrorUnsignedByteRefColors[0] = null;
mirrorColorAllocated &= ~CUB;;
}
else {
if ((mirrorColorAllocated & CUB) == 0) {
mirrorUnsignedByteRefColors[0] = new byte[4 * vertexCount];
mirrorColorAllocated |= CUB;
}
byteBufferRefColors.rewind();
if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
srcIndex = initialColorIndex * 3;
dstIndex = initialColorIndex * 4;
byteBufferRefColors.position(srcIndex);
for (i = initialColorIndex; i < validVertexCount; i++) {
byteBufferRefColors.get(mirrorUnsignedByteRefColors[0],
dstIndex, 3);
mirrorUnsignedByteRefColors[0][dstIndex+3] = (byte)(255.0);
dstIndex += 4;
}
}
else {
srcIndex = initialColorIndex * 4;
dstIndex = initialColorIndex * 4;
byteBufferRefColors.position(srcIndex);
for (i = initialColorIndex; i < validVertexCount; i++) {
byteBufferRefColors.get(mirrorUnsignedByteRefColors[0], dstIndex, 4);
dstIndex+= 4;
}
}
} // end of else
}//end of else if ( byteBufferRefColors != null)
}//end of NIO BUFFER case
colorChanged = 0xffff;
}
void setupMirrorNormalPointer(int ntype) {
int i, index;
switch (ntype) {
case NF:
if (floatRefNormals == null) {
if ((vertexType & NORMAL_DEFINED) == NF) {
vertexType &= ~NF;
mirrorFloatRefNormals = null;
mirrorNormalAllocated = false;
}
}
else {
vertexType |= NF;
mirrorFloatRefNormals = floatRefNormals;
mirrorNormalAllocated = false;
}
break;
case N3F:
if (v3fRefNormals == null) {
if ((vertexType & NORMAL_DEFINED) == N3F) {
vertexType &= ~N3F;
}
return;
}
else {
vertexType |= N3F;
}
if (!mirrorNormalAllocated) {
mirrorFloatRefNormals = new float[vertexCount * 3];
mirrorNormalAllocated = true;
}
index = initialNormalIndex * 3;
for (i = initialNormalIndex; i < validVertexCount; i++) {
mirrorFloatRefNormals[index++] = v3fRefNormals[i].x;
mirrorFloatRefNormals[index++] = v3fRefNormals[i].y;
mirrorFloatRefNormals[index++] = v3fRefNormals[i].z;
}
break;
default:
break; }
}
void setupMirrorTexCoordPointer(int type) {
for (int i = 0; i < texCoordSetCount; i++) {
doSetupMirrorTexCoordPointer(i, type);
}
validateTexCoordPointerType();
}
void setupMirrorTexCoordPointer(int texCoordSet, int type) {
doSetupMirrorTexCoordPointer(texCoordSet, type);
validateTexCoordPointerType();
}
// If all texCoord pointers are set to a non-null value, then set the
// texcoord type in the vertexType flag word, else clear the texcoord type
private void validateTexCoordPointerType() {
boolean allNonNull = true;
boolean allNull = true;
for (int i = 0; i < texCoordSetCount; i++) {
if (refTexCoords[i] == null) {
allNonNull = false;
} else {
allNull = false;
}
}
// Reset texCoordType if all references are null
if (allNull) {
texCoordType = 0;
}
// Copy texCoordType to vertexType if all references are non-null
vertexType &= ~TEXCOORD_DEFINED;
if (allNonNull) {
vertexType |= texCoordType;
}
}
private void doSetupMirrorTexCoordPointer(int texCoordSet, int type) {
int i, index;
switch (type) {
case TF:
texCoordType = TF;
mirrorRefTexCoords[texCoordSet] = refTexCoords[texCoordSet];
break;
case T2F:
texCoordType = T2F;
t2fRefTexCoords = (TexCoord2f[])refTexCoords[texCoordSet];
if (t2fRefTexCoords == null) {
mirrorRefTexCoords[texCoordSet] = null;
break;
}
mirrorFloatRefTexCoords = (float[])mirrorRefTexCoords[texCoordSet];
if (mirrorFloatRefTexCoords != null) {
if (mirrorFloatRefTexCoords.length < (vertexCount * 2))
mirrorRefTexCoords[texCoordSet] =
mirrorFloatRefTexCoords = new float[vertexCount * 2];
}
else {
mirrorRefTexCoords[texCoordSet] =
mirrorFloatRefTexCoords = new float[vertexCount * 2];
}
index = initialTexCoordIndex[texCoordSet] * 2;
for (i = initialTexCoordIndex[texCoordSet]; i < validVertexCount; i++) {
mirrorFloatRefTexCoords[index++] = t2fRefTexCoords[i].x;
mirrorFloatRefTexCoords[index++] = t2fRefTexCoords[i].y;
}
break;
case T3F:
texCoordType = T3F;
t3fRefTexCoords = (TexCoord3f[])refTexCoords[texCoordSet];
if (t3fRefTexCoords == null) {
mirrorRefTexCoords[texCoordSet] = null;
break;
}
mirrorFloatRefTexCoords = (float[])mirrorRefTexCoords[texCoordSet];
if (mirrorFloatRefTexCoords != null) {
if (mirrorFloatRefTexCoords.length < (vertexCount * 3))
mirrorRefTexCoords[texCoordSet] =
mirrorFloatRefTexCoords = new float[vertexCount * 3];
}
else {
mirrorRefTexCoords[texCoordSet] =
mirrorFloatRefTexCoords = new float[vertexCount * 3];
}
index = initialTexCoordIndex[texCoordSet] * 3;
for (i = initialTexCoordIndex[texCoordSet]; i < validVertexCount; i++) {
mirrorFloatRefTexCoords[index++] = t3fRefTexCoords[i].x;
mirrorFloatRefTexCoords[index++] = t3fRefTexCoords[i].y;
mirrorFloatRefTexCoords[index++] = t3fRefTexCoords[i].z;
}
break;
default:
break;
}
}
void setupMirrorVertexAttrPointer(int type) {
for (int i = 0; i < vertexAttrCount; i++) {
doSetupMirrorVertexAttrPointer(i, type);
}
validateVertexAttrPointerType();
}
void setupMirrorVertexAttrPointer(int vertexAttrNum, int type) {
doSetupMirrorVertexAttrPointer(vertexAttrNum, type);
validateVertexAttrPointerType();
}
// If all vertex attr pointers are set to a non-null value, then set the
// vertex attr type in the vertexType flag word, else clear the
// vertex attr type
private void validateVertexAttrPointerType() {
boolean allNonNull = true;
boolean allNull = true;
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
for (int i = 0; i < vertexAttrCount; i++) {
if (floatRefVertexAttrs[i] == null) {
allNonNull = false;
} else {
allNull = false;
}
}
} else {
for (int i = 0; i < vertexAttrCount; i++) {
if (floatBufferRefVertexAttrs[i] == null) {
allNonNull = false;
} else {
allNull = false;
}
}
}
// Reset vertexAttrType if all references are null
if (allNull) {
vertexAttrType = 0;
}
// Copy vertexAttrType to vertexType if all references are non-null
vertexType &= ~VATTR_DEFINED;
if (allNonNull) {
vertexType |= vertexAttrType;
}
}
private void doSetupMirrorVertexAttrPointer(int vertexAttrNum, int type) {
switch (type) {
case AF:
vertexAttrType = AF;
mirrorFloatRefVertexAttrs[vertexAttrNum] =
floatRefVertexAttrs[vertexAttrNum];
break;
default:
break;
}
}
void createGeometryArrayData(int vertexCount, int vertexFormat) {
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
createGeometryArrayData(vertexCount, vertexFormat, 1,
defaultTexCoordSetMap);
} else {
createGeometryArrayData(vertexCount, vertexFormat, 0, null);
}
}
void createGeometryArrayData(int vertexCount, int vertexFormat,
int texCoordSetCount, int[] texCoordSetMap) {
createGeometryArrayData(vertexCount, vertexFormat,
texCoordSetCount, texCoordSetMap,
0, null);
}
void createGeometryArrayData(int vertexCount, int vertexFormat,
int texCoordSetCount, int[] texCoordSetMap,
int vertexAttrCount, int[] vertexAttrSizes) {
this.vertexFormat = vertexFormat;
this.vertexCount = vertexCount;
this.validVertexCount = vertexCount;
this.texCoordSetCount = texCoordSetCount;
if (texCoordSetMap == null) {
this.texCoordSetMap = null;
}
else {
this.texCoordSetMap = Arrays.copyOf(texCoordSetMap, texCoordSetMap.length);
}
this.vertexAttrCount = vertexAttrCount;
if (vertexAttrSizes == null) {
this.vertexAttrSizes = null;
}
else {
this.vertexAttrSizes = Arrays.copyOf(vertexAttrSizes, vertexAttrSizes.length);
}
this.vertexAttrStride = this.vertexAttrStride();
this.stride = this.stride();
this.vertexAttrOffsets = this.vertexAttrOffsets();
this.texCoordSetMapOffset = this.texCoordSetMapOffset();
this.textureOffset = this.textureOffset();
this.colorOffset = this.colorOffset();
this.normalOffset = this.normalOffset();
this.coordinateOffset = this.coordinateOffset();
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
this.vertexData = new float[this.vertexCount * this.stride];
}
else { // By reference geometry
this.vertexData = null;
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
this.mirrorRefTexCoords = new Object[texCoordSetCount];
this.refTexCoords = new Object[texCoordSetCount]; // keep J3DBufferImp object in nio buffer case
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0 )
this.refTexCoordsBuffer = new J3DBuffer[texCoordSetCount]; // keep J3DBuffer object
}
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
this.floatRefVertexAttrs = new float[vertexAttrCount][];
this.mirrorFloatRefVertexAttrs = new float[vertexAttrCount][];
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
this.vertexAttrsRefBuffer = new J3DBuffer[vertexAttrCount];
this.floatBufferRefVertexAttrs = new FloatBuffer[vertexAttrCount];
}
}
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
this.initialTexCoordIndex = new int[texCoordSetCount];
}
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
this.initialVertexAttrIndex = new int[vertexAttrCount];
}
noAlpha = ((vertexFormat & GeometryArray.WITH_ALPHA) == 0);
lastAlpha[0] = 1.0f;
}
void setVertexFormat(boolean useAlpha, boolean ignoreVC, Context ctx) {
Pipeline.getPipeline().setVertexFormat(ctx,
this, vertexFormat, useAlpha, ignoreVC);
}
float[] updateAlphaInFloatRefColors(Canvas3D cv, int screen, float alpha) {
//System.err.println("updateAlphaInFloatRefColors screen = " + screen +
// " alpha " + alpha );
// update alpha only if vertex format includes alpha
if (((vertexFormat | c4fAllocated) & GeometryArray.WITH_ALPHA) == 0)
return mirrorFloatRefColors[0];
// if alpha is smaller than EPSILON, set it to EPSILON, so that
// even if alpha is equal to 0, we will not completely lose
// the original alpha value
if (alpha <= EPSILON) {
alpha = (float)EPSILON;
}
assert lastAlpha != null;
assert mirrorFloatRefColors != null;
assert mirrorFloatRefColors.length == lastAlpha.length;
// Issue 113 - reallocate lastAlpha array if needed, but no need to
// update the values here
if (lastAlpha.length <= screen) {
float[] la = new float[screen + 1];
for (int i = 0; i < lastAlpha.length; i++) {
la[i] = lastAlpha[i];
}
lastAlpha = la;
}
//System.err.println("updateAlphaInFloatRefColors screen is " + screen
// + " mirrorFloatRefColors.length " +
// mirrorFloatRefColors.length);
// allocate a copy of the color data for the screen if needed.
// this piece of code is only for multi-screens case
if (mirrorFloatRefColors.length <= screen) {
float[][] cfData = new float[screen + 1][];
for (int i = 0; i < mirrorFloatRefColors.length; i++) {
cfData[i] = mirrorFloatRefColors[i];
}
// Issue 113 - allocate entries for [oldSize..screen];
// copy cfData[0] to cfData[oldsize..screen-1] and
// lastAlpha[0] to lastAlpha[oldsize..screen-1].
for (int i = mirrorFloatRefColors.length; i < screen+1; i++) {
cfData[i] = new float[4 * vertexCount];
System.arraycopy(cfData[0], 0, cfData[i], 0, 4 * vertexCount);
lastAlpha[i] = lastAlpha[0];
}
mirrorFloatRefColors = cfData;
// Issue 113 - since we copied the data from screen 0, we don't need
// to do any further special processing.
}
assert lastAlpha[screen] >= 0.0;
/*
System.err.println("updateAlphaInFloatRefColors ** : lastAlpha[screen] " +
lastAlpha[screen]);
System.err.println("((colorChanged & (1<<screen)) == 0) " +
((colorChanged & (1<<screen)) == 0));
*/
if ((colorChanged & (1<<screen)) == 0) {
// color data is not modified
if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
// and if alpha is the same as the last one,
// just return the data
//System.err.println("updateAlphaInFloatRefColors 0 : alpha is the same as the last one " + alpha);
return mirrorFloatRefColors[screen];
} else {
// if alpha is different, update the alpha values
//System.err.println("updateAlphaInFloatRefColors 1 : alpha is different, update the alpha values " + alpha);
float m = alpha / lastAlpha[screen];
float[] cdata = mirrorFloatRefColors[screen];
// We've to traverse the whole due to BugId : 4676483
for (int i = 0, j = 0; i < vertexCount; i++, j+=4) {
cdata[j+3] = cdata[j+3] * m;
}
}
} else {
// color data is modified
if (screen == 0) {
// just update alpha values since screen 0 data is
// already updated in setupMirrorColorPointer
//System.err.println("updateAlphaInFloatRefColors 2 : just update alpha = " + alpha);
float[] cdata = mirrorFloatRefColors[screen];
// This part is also incorrect due to BugId : 4676483
// But traversing the whole array doesn't help either, as there
// isn't a mechanism to indicate the the alpha component has
// not changed by user.
int j = initialColorIndex * 4;
for (int i = initialColorIndex; i < validVertexCount; i++, j+=4) {
cdata[j+3] = cdata[j+3] * alpha;
}
} else {
// update color values from screen 0 data
//System.err.println("updateAlphaInFloatRefColors 3 : update color values from screen 0 data " + alpha);
float m;
if ((colorChanged & 1) == 0) {
// alpha is up to date in screen 0
m = alpha / lastAlpha[0];
} else {
m = alpha;
}
float[] sdata = mirrorFloatRefColors[0];
float[] cdata = mirrorFloatRefColors[screen];
int j = initialColorIndex * 4;
for (int i = initialColorIndex; i < validVertexCount; i++) {
cdata[j] = sdata[j++];
cdata[j] = sdata[j++];
cdata[j] = sdata[j++];
cdata[j] = sdata[j++] * m;
}
}
}
lastAlpha[screen] = alpha;
colorChanged &= ~(1 << screen);
dirtyFlag |= COLOR_CHANGED;
return mirrorFloatRefColors[screen];
}
byte[] updateAlphaInByteRefColors(Canvas3D cv, int screen, float alpha) {
/*
System.err.println("updateAlphaInByteRefColors screen = " + screen +
" alpha " + alpha );
*/
// update alpha only if vertex format includes alpha
if (((vertexFormat | c4fAllocated) & GeometryArray.WITH_ALPHA) == 0)
return mirrorUnsignedByteRefColors[0];
// if alpha is smaller than EPSILON, set it to EPSILON, so that
// even if alpha is equal to 0, we will not completely lose
// the original alpha value
if (alpha <= EPSILON) {
alpha = (float)EPSILON;
}
assert lastAlpha != null;
assert mirrorUnsignedByteRefColors != null;
assert mirrorUnsignedByteRefColors.length == lastAlpha.length;
// Issue 113 - reallocate lastAlpha array if needed, but no need to
// update the values here
if (lastAlpha.length <= screen) {
float[] la = new float[screen + 1];
for (int i = 0; i < lastAlpha.length; i++) {
la[i] = lastAlpha[i];
}
lastAlpha = la;
}
// allocate a copy of the color data for the screen if needed.
// this piece of code is only for multi-screens case
if (mirrorUnsignedByteRefColors.length <= screen) {
byte[][] cbData = new byte[screen + 1][];
for (int i = 0; i < mirrorUnsignedByteRefColors.length; i++) {
cbData[i] = mirrorUnsignedByteRefColors[i];
}
// Issue 113 - allocate entries for [oldSize..screen];
// copy cbData[0] to cbData[oldsize..screen-1] and
// lastAlpha[0] to lastAlpha[oldsize..screen-1].
for (int i = mirrorUnsignedByteRefColors.length; i < screen+1; i++) {
cbData[i] = new byte[4 * vertexCount];
System.arraycopy(cbData[0], 0, cbData[i], 0, 4 * vertexCount);
lastAlpha[i] = lastAlpha[0];
}
mirrorUnsignedByteRefColors = cbData;
// Issue 113 - since we copied the data from screen 0, we don't need
// to do any further special processing.
}
assert lastAlpha[screen] >= 0.0;
/*
System.err.println("updateAlphaInByteRefColors ## : lastAlpha[screen] " +
lastAlpha[screen]);
System.err.println("((colorChanged & (1<<screen)) == 0) " +
((colorChanged & (1<<screen)) == 0));
*/
if ((colorChanged & (1<<screen)) == 0) {
// color data is not modified
if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
// and if alpha is the same as the last one,
// just return the data
//System.err.println("updateAlphaInByteRefColors 0 : alpha is the same as the last one " + alpha);
return mirrorUnsignedByteRefColors[screen];
} else {
// if alpha is different, update the alpha values
//System.err.println("updateAlphaInByteRefColors 1 : alpha is different, update the alpha values " + alpha);
float m = alpha / lastAlpha[screen];
byte[] cdata = mirrorUnsignedByteRefColors[screen];
// We've to traverse the whole due to BugId : 4676483
for (int i = 0, j = 0; i < vertexCount; i++, j+=4) {
cdata[j+3] = (byte)( ((int)cdata[j+3] & 0xff) * m);
}
}
} else {
// color data is modified
if (screen == 0) {
//System.err.println("updateAlphaInByteRefColors 2 : just update alpha =" + alpha);
// just update alpha values since screen 0 data is
// already updated in setupMirrorColorPointer
byte[] cdata = mirrorUnsignedByteRefColors[screen];
// This part is also incorrect due to BugId : 4676483
// But traversing the whole array doesn't help either, as there
// isn't a mechanism to indicate the the alpha component has
// not changed by user.
int j = initialColorIndex * 4;
for (int i = initialColorIndex; i < validVertexCount; i++, j+=4) {
cdata[j+3] = (byte)(((int)cdata[j+3] & 0xff) * alpha);
}
} else {
// update color values from screen 0 data
float m;
//System.err.println("updateAlphaInByteRefColors 3 : update color values from screen 0 data " + alpha);
if ((colorChanged & 1) == 0) {
// alpha is up to date in screen 0
m = alpha / lastAlpha[0];
} else {
m = alpha;
}
byte[] sdata = mirrorUnsignedByteRefColors[0];
byte[] cdata = mirrorUnsignedByteRefColors[screen];
int j = initialColorIndex * 4;
for (int i = initialColorIndex; i < validVertexCount; i++) {
cdata[j] = sdata[j++];
cdata[j] = sdata[j++];
cdata[j] = sdata[j++];
cdata[j] = (byte)(((int)sdata[j++]& 0xff) * m);
}
}
}
lastAlpha[screen] = alpha;
colorChanged &= ~(1 << screen);
dirtyFlag |= COLOR_CHANGED;
return mirrorUnsignedByteRefColors[screen];
}
Object[] updateAlphaInVertexData(Canvas3D cv, int screen, float alpha) {
Object[] retVal = new Object[2];
retVal[0] = Boolean.FALSE;
// update alpha only if vertex format includes alpha
if ((vertexFormat & GeometryArray.COLOR) == 0) {
retVal[1] = vertexData;
return retVal;
}
// if alpha is smaller than EPSILON, set it to EPSILON, so that
// even if alpha is equal to 0, we will not completely lose
// the original alpha value
if (alpha <= EPSILON) {
alpha = (float)EPSILON;
}
retVal[0] = Boolean.TRUE;
assert lastAlpha != null;
assert mvertexData == null || mvertexData.length == lastAlpha.length;
// Issue 113 - reallocate lastAlpha array if needed, but no need to
// update the values here
if (lastAlpha.length <= screen) {
float[] la = new float[screen + 1];
for (int i = 0; i < lastAlpha.length; i++) {
la[i] = lastAlpha[i];
}
lastAlpha = la;
}
// allocate a copy of the vertex data for the screen if needed.
// Note that a copy operation only happens in the multi-screens case.
// We always use the existing vertexData for screen 0.
if (mvertexData == null || mvertexData.length <= screen) {
float[][] cfData = new float[screen + 1][];
int oldSize = 1;
if (mvertexData != null) {
oldSize = mvertexData.length;
for (int i = 0; i < mvertexData.length; i++) {
cfData[i] = mvertexData[i];
}
}
if (cfData[0] == null) {
cfData[0] = vertexData;
}
// Issue 113 - allocate entries for [oldSize..screen];
// copy cfData[0] to cfData[oldsize..screen-1] and
// lastAlpha[0] to lastAlpha[oldsize..screen-1].
if (screen > 0) {
for (int i = oldSize; i < screen+1; i++) {
cfData[i] = new float[stride * vertexCount];
System.arraycopy(cfData[0], 0, cfData[i], 0,
stride * vertexCount);
lastAlpha[i] = lastAlpha[0];
}
}
mvertexData = cfData;
// Issue 113 - since we copied the data from screen 0, we don't need
// to do any further special processing.
}
assert lastAlpha[screen] >= 0.0;
if ((colorChanged & (1<<screen)) == 0) {
// color data is not modified
if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
// and if alpha is the same as the last one,
// just return the data
retVal[1] = mvertexData[screen];
return retVal;
} else {
// if alpha is different, update the alpha values
float m = alpha / lastAlpha[screen];
float[] cdata = mvertexData[screen];
for (int i = 0, j = colorOffset; i < vertexCount;
i++, j+=stride) {
cdata[j+3] *= m;
}
}
} else {
// color data is modified
if (screen == 0) {
// just update alpha values since screen 0 data is
// already updated in setupMirrorColorPointer
float[] cdata = mvertexData[screen];
double m = alpha / lastAlpha[0];
for (int i = 0, j = colorOffset; i < vertexCount;
i++, j+=stride) {
cdata[j+3] *= m;
}
} else {
// update color values from screen 0 data
float m = alpha / lastAlpha[0];
float[] sdata = mvertexData[0];
float[] cdata = mvertexData[screen];
for (int i = 0, j = colorOffset; i < vertexCount;
i++, j+=stride) {
System.arraycopy(sdata, j, cdata, j, 3);
cdata[j+3] = sdata[j+3] * m;
}
}
}
lastAlpha[screen] = alpha;
colorChanged &= ~(1 << screen);
dirtyFlag |= COLOR_CHANGED;
retVal[1] = mvertexData[screen];
return retVal;
}
Object[] updateAlphaInInterLeavedData(Canvas3D cv, int screen, float alpha) {
Object[] retVal = new Object[2];
retVal[0] = Boolean.FALSE;
// update alpha only if vertex format includes alpha
if (((vertexFormat | c4fAllocated) & GeometryArray.WITH_ALPHA) == 0) {
retVal[1] = mirrorInterleavedColorPointer[0];
return retVal;
}
int coffset = initialColorIndex << 2; // Each color is 4 floats
// if alpha is smaller than EPSILON, set it to EPSILON, so that
// even if alpha is equal to 0, we will not completely lose
// the original alpha value
if (alpha <= EPSILON) {
alpha = (float)EPSILON;
}
retVal[0] = Boolean.TRUE;
assert lastAlpha != null;
assert mirrorInterleavedColorPointer != null;
assert mirrorInterleavedColorPointer.length == lastAlpha.length;
// Issue 113 - reallocate lastAlpha array if needed, but no need to
// update the values here
if (lastAlpha.length <= screen) {
float[] la = new float[screen + 1];
for (int i = 0; i < lastAlpha.length; i++) {
la[i] = lastAlpha[i];
}
lastAlpha = la;
}
// allocate a copy of the vertex data for the screen if needed.
// this piece of code is only for multi-screens case
if (mirrorInterleavedColorPointer.length <= screen) {
float[][] cfData = new float[screen + 1][];
for (int i = 0; i < mirrorInterleavedColorPointer.length; i++) {
cfData[i] = mirrorInterleavedColorPointer[i];
}
// Issue 113 - allocate entries for [oldSize..screen];
// copy cfData[0] to cfData[oldsize..screen-1] and
// lastAlpha[0] to lastAlpha[oldsize..screen-1].
for (int i = mirrorInterleavedColorPointer.length; i < screen+1; i++) {
cfData[i] = new float[4 * vertexCount];
System.arraycopy(cfData[0], 0, cfData[i], 0, 4 * vertexCount);
lastAlpha[i] = lastAlpha[0];
}
mirrorInterleavedColorPointer = cfData;
// Issue 113 - since we copied the data from screen 0, we don't need
// to do any further special processing.
}
assert lastAlpha[screen] >= 0.0;
if ((colorChanged & (1<<screen)) == 0) {
// color data is not modified
if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
// and if alpha is the same as the last one,
// just return the data
retVal[1] = mirrorInterleavedColorPointer[screen];
return retVal;
} else {
// if alpha is different, update the alpha values
float m = alpha / lastAlpha[screen];
float[] cdata = mirrorInterleavedColorPointer[screen];
coffset = initialColorIndex << 2;
for (int i = coffset; i < coffset + (vertexCount << 2); i+=4) {
cdata[i+3] = cdata[i+3] * m;
}
}
} else {
// color data is modified
if (screen == 0) {
// just update alpha values since screen 0 data is
// already updated in setupMirrorInterleavedColorPointer
float[] cdata = mirrorInterleavedColorPointer[screen];
for (int i = coffset; i < coffset + (vertexCount << 2); i+=4) {
cdata[i+3] = cdata[i+3] * alpha;
}
} else {
// update color values from screen 0 data
float m;
if ((colorChanged & 1) == 0) {
// alpha is up to date in screen 0
m = alpha / lastAlpha[0];
} else {
m = alpha;
}
float[] sdata = mirrorInterleavedColorPointer[0];
float[] cdata = mirrorInterleavedColorPointer[screen];
for (int i = coffset; i < coffset + (vertexCount << 2);) {
// System.arraycopy(sdata, i, cdata, i, 3);
cdata[i] = sdata[i++];
cdata[i] = sdata[i++];
cdata[i] = sdata[i++];
cdata[i] = sdata[i++] * m;
}
}
}
lastAlpha[screen] = alpha;
colorChanged &= ~(1 << screen);
dirtyFlag |= COLOR_CHANGED;
retVal[1] = mirrorInterleavedColorPointer[screen];
return retVal;
}
// pass < 0 implies underlying library supports multiTexture, so
// use the multiTexture extension to send all texture units
// data in one pass
// pass >= 0 implies one pass for one texture unit state
@Override
void execute(Canvas3D cv, RenderAtom ra, boolean isNonUniformScale,
boolean updateAlpha, float alpha,
int screen,
boolean ignoreVertexColors) {
int cdirty;
boolean useAlpha = false;
Object[] retVal;
// Check for by-copy case
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
float[] vdata;
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
// update the alpha values
retVal = updateAlphaInVertexData(cv, screen, alpha);
useAlpha = (retVal[0] == Boolean.TRUE);
vdata = (float[])retVal[1];
// D3D only
if (alpha != lastScreenAlpha) {
// handle multiple screen case
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
vdata = vertexData;
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
// geomLock is get in MasterControl when
// RenderBin render the geometry. So it is safe
// just to set the dirty flag here
dirtyFlag = 0;
}
Pipeline.getPipeline().execute(cv.ctx,
this, geoType, isNonUniformScale,
useAlpha,
ignoreVertexColors,
initialVertexIndex,
validVertexCount,
((vertexFormat & GeometryArray.COLOR) != 0)?(vertexFormat|GeometryArray.COLOR_4):vertexFormat,
texCoordSetCount, texCoordSetMap,
(texCoordSetMap == null) ? 0 : texCoordSetMap.length,
texCoordSetMapOffset,
cv.numActiveTexUnit,
vertexAttrCount, vertexAttrSizes,
vdata, null,
cdirty);
}
//By reference with java array
else if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
// interleaved data
if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
if(interLeavedVertexData == null)
return;
float[] cdata = null;
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
// update the alpha values
retVal = updateAlphaInInterLeavedData(cv, screen, alpha);
useAlpha = (retVal[0] == Boolean.TRUE);
cdata = (float[])retVal[1];
if (alpha != lastScreenAlpha) {
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
dirtyFlag = 0;
}
Pipeline.getPipeline().execute(cv.ctx,
this, geoType, isNonUniformScale,
useAlpha,
ignoreVertexColors,
initialVertexIndex,
validVertexCount,
vertexFormat,
texCoordSetCount, texCoordSetMap,
(texCoordSetMap == null) ? 0 : texCoordSetMap.length,
texCoordSetMapOffset,
cv.numActiveTexUnit,
vertexAttrCount, vertexAttrSizes,
interLeavedVertexData, cdata,
cdirty);
} // end of interleaved case
// non interleaved data
else {
// Check if a vertexformat is set, but the array is null
// if yes, don't draw anything
if ((vertexType == 0) ||
((vertexType & VERTEX_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.COLOR) != 0) &&
(vertexType & COLOR_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.NORMALS) != 0) &&
(vertexType & NORMAL_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
(vertexType & VATTR_DEFINED) == 0) ||
(((vertexFormat& GeometryArray.TEXTURE_COORDINATE) != 0) &&
(vertexType & TEXCOORD_DEFINED) == 0)) {
return;
} else {
byte[] cbdata = null;
float[] cfdata = null;
if ((vertexType & (CF | C3F | C4F )) != 0) {
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
cfdata = updateAlphaInFloatRefColors(cv, screen, alpha);
if (alpha != lastScreenAlpha) {
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
cfdata = mirrorFloatRefColors[0];
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
dirtyFlag = 0;
}
} // end of color in float format
else if ((vertexType & (CUB| C3UB | C4UB)) != 0) {
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
cbdata = updateAlphaInByteRefColors(cv, screen, alpha);
if (alpha != lastScreenAlpha) {
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
cbdata = mirrorUnsignedByteRefColors[0];
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
dirtyFlag = 0;
}
} // end of color in byte format
else {
cdirty = dirtyFlag;
}
// setup vdefined to passed to native code
int vdefined = 0;
if((vertexType & (PF | P3F)) != 0)
vdefined |= COORD_FLOAT;
if((vertexType & (PD | P3D)) != 0)
vdefined |= COORD_DOUBLE;
if((vertexType & (CF | C3F | C4F)) != 0)
vdefined |= COLOR_FLOAT;
if((vertexType & (CUB| C3UB | C4UB)) != 0)
vdefined |= COLOR_BYTE;
if((vertexType & NORMAL_DEFINED) != 0)
vdefined |= NORMAL_FLOAT;
if((vertexType & VATTR_DEFINED) != 0)
vdefined |= VATTR_FLOAT;
if((vertexType & TEXCOORD_DEFINED) != 0)
vdefined |= TEXCOORD_FLOAT;
Pipeline.getPipeline().executeVA(cv.ctx,
this, geoType, isNonUniformScale,
ignoreVertexColors,
validVertexCount,
(vertexFormat | c4fAllocated),
vdefined,
initialCoordIndex,
mirrorFloatRefCoords, mirrorDoubleRefCoords,
initialColorIndex, cfdata, cbdata,
initialNormalIndex, mirrorFloatRefNormals,
vertexAttrCount, vertexAttrSizes,
initialVertexAttrIndex, mirrorFloatRefVertexAttrs,
((texCoordSetMap == null) ? 0:texCoordSetMap.length),
texCoordSetMap,
cv.numActiveTexUnit,
initialTexCoordIndex,texCoordStride,
mirrorRefTexCoords, cdirty);
}// end of all vertex data being set
}// end of non interleaved case
}// end of by reference with java array
//By reference with nio buffer
else {
// interleaved data
if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
if ( interleavedFloatBufferImpl == null)
return;
float[] cdata = null;
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
// update the alpha values
// XXXX: to handle alpha case
retVal = updateAlphaInInterLeavedData(cv, screen, alpha);
useAlpha = (retVal[0] == Boolean.TRUE);
cdata = (float[])retVal[1];
if (alpha != lastScreenAlpha) {
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
// XXXX: to handle alpha case
cdata = null;
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
dirtyFlag = 0;
}
Pipeline.getPipeline().executeInterleavedBuffer(cv.ctx,
this, geoType, isNonUniformScale,
useAlpha,
ignoreVertexColors,
initialVertexIndex,
validVertexCount,
vertexFormat,
texCoordSetCount, texCoordSetMap,
(texCoordSetMap == null) ? 0 : texCoordSetMap.length,
texCoordSetMapOffset,
cv.numActiveTexUnit,
interleavedFloatBufferImpl, cdata,
cdirty);
} // end of interleaved case
// non interleaved data
else {
// Check if a vertexformat is set, but the array is null
// if yes, don't draw anything
if ((vertexType == 0) ||
((vertexType & VERTEX_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.COLOR) != 0) &&
(vertexType & COLOR_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.NORMALS) != 0) &&
(vertexType & NORMAL_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
(vertexType & VATTR_DEFINED) == 0) ||
(((vertexFormat& GeometryArray.TEXTURE_COORDINATE) != 0) &&
(vertexType & TEXCOORD_DEFINED) == 0)) {
return;
} else {
byte[] cbdata = null;
float[] cfdata = null;
if ((vertexType & CF ) != 0) {
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
cfdata = updateAlphaInFloatRefColors(cv,
screen, alpha);
if (alpha != lastScreenAlpha) {
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
// XXXX: handle transparency case
//cfdata = null;
cfdata = mirrorFloatRefColors[0];
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
dirtyFlag = 0;
}
} // end of color in float format
else if ((vertexType & CUB) != 0) {
synchronized (this) {
cdirty = dirtyFlag;
if (updateAlpha && !ignoreVertexColors) {
cbdata = updateAlphaInByteRefColors(
cv, screen, alpha);
if (alpha != lastScreenAlpha) {
lastScreenAlpha = alpha;
cdirty |= COLOR_CHANGED;
}
} else {
// XXXX: handle transparency case
//cbdata = null;
cbdata = mirrorUnsignedByteRefColors[0];
// if transparency switch between on/off
if (lastScreenAlpha != -1) {
lastScreenAlpha = -1;
cdirty |= COLOR_CHANGED;
}
}
dirtyFlag = 0;
}
} // end of color in byte format
else {
cdirty = dirtyFlag;
}
Buffer vcoord = null;
Buffer cdataBuffer = null;
FloatBuffer normal=null;
int vdefined = 0;
if((vertexType & PF) != 0) {
vdefined |= COORD_FLOAT;
vcoord = floatBufferRefCoords;
} else if((vertexType & PD ) != 0) {
vdefined |= COORD_DOUBLE;
vcoord = doubleBufferRefCoords;
}
if((vertexType & CF ) != 0) {
vdefined |= COLOR_FLOAT;
cdataBuffer = floatBufferRefColors;
} else if((vertexType & CUB) != 0) {
vdefined |= COLOR_BYTE;
cdataBuffer = byteBufferRefColors;
}
if((vertexType & NORMAL_DEFINED) != 0) {
vdefined |= NORMAL_FLOAT;
normal = floatBufferRefNormals;
}
if ((vertexType & VATTR_DEFINED) != 0) {
vdefined |= VATTR_FLOAT;
}
if((vertexType & TEXCOORD_DEFINED) != 0)
vdefined |= TEXCOORD_FLOAT;
Pipeline.getPipeline().executeVABuffer(cv.ctx,
this, geoType, isNonUniformScale,
ignoreVertexColors,
validVertexCount,
(vertexFormat | c4fAllocated),
vdefined,
initialCoordIndex,
vcoord,
initialColorIndex,
cdataBuffer,
cfdata, cbdata,
initialNormalIndex,
normal,
vertexAttrCount, vertexAttrSizes,
initialVertexAttrIndex,
floatBufferRefVertexAttrs,
((texCoordSetMap == null) ? 0:texCoordSetMap.length),
texCoordSetMap,
cv.numActiveTexUnit,
initialTexCoordIndex,texCoordStride,
refTexCoords, cdirty);
}// end of all vertex data being set
}// end of non interleaved case
}// end of by reference with nio-buffer case
}
void buildGA(Canvas3D cv, RenderAtom ra, boolean isNonUniformScale,
boolean updateAlpha, float alpha, boolean ignoreVertexColors,
Transform3D xform, Transform3D nxform) {
float[] vdata = null;
// NIO buffers are no longer supported in display lists
assert (vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0;
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
vdata = vertexData;
}
else if ((vertexFormat & GeometryArray.INTERLEAVED) != 0 &&
((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0)) {
vdata = interLeavedVertexData;
}
if (vdata != null) {
/*
System.err.println("calling native buildGA()");
System.err.println("geoType = "+geoType+" initialVertexIndex = "+initialVertexIndex+" validVertexCount = "+validVertexCount+" vertexFormat = "+vertexFormat+" vertexData = "+vertexData);
*/
Pipeline.getPipeline().buildGA(cv.ctx,
this, geoType, isNonUniformScale,
updateAlpha, alpha, ignoreVertexColors,
initialVertexIndex,
validVertexCount, vertexFormat,
texCoordSetCount, texCoordSetMap,
(texCoordSetMap == null) ? 0 : texCoordSetMap.length,
texCoordSetMapOffset,
vertexAttrCount, vertexAttrSizes,
(xform == null) ? null : xform.mat,
(nxform == null) ? null : nxform.mat,
vdata);
}
else {
// Check if a vertexformat is set, but the array is null
// if yes, don't draw anything
if ((vertexType == 0) ||
((vertexType & VERTEX_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.COLOR) != 0) &&
(vertexType & COLOR_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.NORMALS) != 0) &&
(vertexType & NORMAL_DEFINED) == 0) ||
(((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
(vertexType & VATTR_DEFINED) == 0) ||
(((vertexFormat& GeometryArray.TEXTURE_COORDINATE) != 0) &&
(vertexType & TEXCOORD_DEFINED) == 0)) {
return;
}
// Either non-interleaved, by-ref or nio buffer
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
// Java array case
// setup vdefined to passed to native code
int vdefined = 0;
if((vertexType & (PF | P3F)) != 0)
vdefined |= COORD_FLOAT;
if((vertexType & (PD | P3D)) != 0)
vdefined |= COORD_DOUBLE;
if((vertexType & (CF | C3F | C4F)) != 0)
vdefined |= COLOR_FLOAT;
if((vertexType & (CUB| C3UB | C4UB)) != 0)
vdefined |= COLOR_BYTE;
if((vertexType & NORMAL_DEFINED) != 0)
vdefined |= NORMAL_FLOAT;
if((vertexType & VATTR_DEFINED) != 0)
vdefined |= VATTR_FLOAT;
if((vertexType & TEXCOORD_DEFINED) != 0)
vdefined |= TEXCOORD_FLOAT;
Pipeline.getPipeline().buildGAForByRef(cv.ctx,
this, geoType, isNonUniformScale,
updateAlpha, alpha,
ignoreVertexColors,
validVertexCount,
vertexFormat,
vdefined,
initialCoordIndex,
mirrorFloatRefCoords, mirrorDoubleRefCoords,
initialColorIndex, mirrorFloatRefColors[0], mirrorUnsignedByteRefColors[0],
initialNormalIndex, mirrorFloatRefNormals,
vertexAttrCount, vertexAttrSizes,
initialVertexAttrIndex, mirrorFloatRefVertexAttrs,
((texCoordSetMap == null) ? 0:texCoordSetMap.length),
texCoordSetMap,
initialTexCoordIndex,texCoordStride,
mirrorRefTexCoords,
(xform == null) ? null : xform.mat,
(nxform == null) ? null : nxform.mat);
}
/*
// NOTE: NIO buffers are no longer supported in display lists.
// This was never enabled by default anyway (only when the
// optimizeForSpace property was set to false), so it wasn't
// well-tested. If future support is desired, we will need to
// add vertex attributes to buildGAForBuffer. There are no plans
// to ever do this.
else {
// NIO Buffer case
Object vcoord = null, cdataBuffer=null, normal=null;
int vdefined = 0;
if((vertexType & PF) != 0) {
vdefined |= COORD_FLOAT;
vcoord = floatBufferRefCoords.getBufferAsObject();
} else if((vertexType & PD ) != 0) {
vdefined |= COORD_DOUBLE;
vcoord = doubleBufferRefCoords.getBufferAsObject();
}
if((vertexType & CF ) != 0) {
vdefined |= COLOR_FLOAT;
cdataBuffer = floatBufferRefColors.getBufferAsObject();
} else if((vertexType & CUB) != 0) {
vdefined |= COLOR_BYTE;
cdataBuffer = byteBufferRefColors.getBufferAsObject();
}
if((vertexType & NORMAL_DEFINED) != 0) {
vdefined |= NORMAL_FLOAT;
normal = floatBufferRefNormals.getBufferAsObject();
}
if((vertexType & TEXCOORD_DEFINED) != 0)
vdefined |= TEXCOORD_FLOAT;
// NOTE : need to add vertex attrs
Pipeline.getPipeline().buildGAForBuffer(cv.ctx,
this, geoType, isNonUniformScale,
updateAlpha, alpha,
ignoreVertexColors,
validVertexCount,
vertexFormat,
vdefined,
initialCoordIndex,
vcoord,
initialColorIndex,cdataBuffer,
initialNormalIndex, normal,
((texCoordSetMap == null) ? 0:texCoordSetMap.length),
texCoordSetMap,
initialTexCoordIndex,texCoordStride,
refTexCoords,
(xform == null) ? null : xform.mat,
(nxform == null) ? null : nxform.mat);
}
*/
}
}
void unIndexify(IndexedGeometryArrayRetained src) {
if ((src.vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
unIndexifyJavaArray(src);
}
else {
unIndexifyNIOBuffer(src);
}
}
private void unIndexifyJavaArray(IndexedGeometryArrayRetained src) {
// System.err.println("unIndexifyJavaArray");
int vOffset = 0, srcOffset, tOffset = 0;
int index, colorStride = 0;
float[] vdata = null;
int i;
int start, end;
start = src.initialIndexIndex;
end = src.initialIndexIndex + src.validIndexCount;
// If its either "normal" data or interleaved data then ..
if (((src.vertexFormat & GeometryArray.BY_REFERENCE) == 0) ||
((src.vertexFormat & GeometryArray.INTERLEAVED) != 0)) {
if ((src.vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
vdata = src.vertexData;
if ((src.vertexFormat & GeometryArray.COLOR) != 0)
colorStride = 4;
}
else if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
vdata = src.interLeavedVertexData;
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
colorStride = 4;
else if ((src.vertexFormat & GeometryArray.COLOR) != 0)
colorStride = 3;
}
// System.err.println("===> start = "+start+" end = "+end);
for (index= start; index < end; index++) {
if ((vertexFormat & GeometryArray.NORMALS) != 0){
System.arraycopy(vdata,
src.indexNormal[index]*src.stride + src.normalOffset,
vertexData, vOffset + normalOffset, 3);
}
if (colorStride == 4){
// System.err.println("===> copying color3");
System.arraycopy(vdata,
src.indexColor[index]*src.stride + src.colorOffset,
vertexData, vOffset + colorOffset, colorStride);
} else if (colorStride == 3) {
// System.err.println("===> copying color4");
System.arraycopy(vdata,
src.indexColor[index]*src.stride + src.colorOffset,
vertexData, vOffset + colorOffset, colorStride);
vertexData[vOffset + colorOffset + 3] = 1.0f;
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
int tcOffset = vOffset + textureOffset;
int interleavedOffset = 0;
for (i = 0; i < texCoordSetCount;
i++, tcOffset += texCoordStride) {
if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
interleavedOffset = i * texCoordStride;
}
System.arraycopy(vdata,
(src.indexTexCoord[i][index])*src.stride + src.textureOffset + interleavedOffset,
vertexData, tcOffset, texCoordStride);
}
}
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
// vertex attributes can't be interleaved
assert (src.vertexFormat & GeometryArray.INTERLEAVED) == 0;
for (i = 0; i < vertexAttrCount; i++) {
int vaOffset = vOffset + vertexAttrOffsets[i];
System.arraycopy(vdata,
(src.indexVertexAttr[i][index])*src.stride + src.vertexAttrOffsets[i],
vertexData, vaOffset, vertexAttrSizes[i]);
}
}
if ((vertexFormat & GeometryArray.COORDINATES) != 0){
// System.err.println("===> copying coords");
System.arraycopy(vdata,
src.indexCoord[index]*src.stride
+ src.coordinateOffset,
vertexData,
vOffset + coordinateOffset, 3);
}
vOffset += stride;
}
} else {
if ((vertexFormat & GeometryArray.NORMALS) != 0) {
vOffset = normalOffset;
switch ((src.vertexType & NORMAL_DEFINED)) {
case NF:
for (index=start; index < end; index++) {
System.arraycopy(src.floatRefNormals,
src.indexNormal[index]*3,
vertexData,
vOffset, 3);
vOffset += stride;
}
break;
case N3F:
for (index=start; index < end; index++) {
srcOffset = src.indexNormal[index];
vertexData[vOffset] = src.v3fRefNormals[srcOffset].x;
vertexData[vOffset+1] = src.v3fRefNormals[srcOffset].y;
vertexData[vOffset+2] = src.v3fRefNormals[srcOffset].z;
vOffset += stride;
}
break;
default:
break;
}
}
if ((vertexFormat & GeometryArray.COLOR) != 0) {
vOffset = colorOffset;
int multiplier = 3;
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
multiplier = 4;
switch ((src.vertexType & COLOR_DEFINED)) {
case CF:
for (index=start; index < end; index++) {
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
System.arraycopy(src.floatRefColors,
src.indexColor[index]*multiplier,
vertexData,
vOffset, 4);
}
else {
System.arraycopy(src.floatRefColors,
src.indexColor[index]*multiplier,
vertexData,
vOffset, 3);
vertexData[vOffset+3] = 1.0f;
}
vOffset += stride;
}
break;
case CUB:
for (index=start; index < end; index++) {
srcOffset = src.indexColor[index] * multiplier;
vertexData[vOffset] = (src.byteRefColors[srcOffset] & 0xff) * ByteToFloatScale;
vertexData[vOffset+1] = (src.byteRefColors[srcOffset+1] & 0xff) * ByteToFloatScale;
vertexData[vOffset+2] = (src.byteRefColors[srcOffset+2] & 0xff) * ByteToFloatScale;
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
vertexData[vOffset+3] = (src.byteRefColors[srcOffset+3] & 0xff) * ByteToFloatScale;
}
else {
vertexData[vOffset+3] = 1.0f;
}
vOffset += stride;
}
break;
case C3F:
for (index=start; index < end; index++) {
srcOffset = src.indexColor[index];
vertexData[vOffset] = src.c3fRefColors[srcOffset].x;
vertexData[vOffset+1] = src.c3fRefColors[srcOffset].y;
vertexData[vOffset+2] = src.c3fRefColors[srcOffset].z;
vertexData[vOffset+3] = 1.0f;
vOffset += stride;
}
break;
case C4F:
for (index=start; index < end; index++) {
srcOffset = src.indexColor[index];
vertexData[vOffset] = src.c4fRefColors[srcOffset].x;
vertexData[vOffset+1] = src.c4fRefColors[srcOffset].y;
vertexData[vOffset+2] = src.c4fRefColors[srcOffset].z;
vertexData[vOffset+3] = src.c4fRefColors[srcOffset].w;
vOffset += stride;
}
break;
case C3UB:
for (index=start; index < end; index++) {
srcOffset = src.indexColor[index];
vertexData[vOffset] = (src.c3bRefColors[srcOffset].x & 0xff) * ByteToFloatScale;
vertexData[vOffset+1] = (src.c3bRefColors[srcOffset].y & 0xff) * ByteToFloatScale;
vertexData[vOffset+2] = (src.c3bRefColors[srcOffset].z & 0xff) * ByteToFloatScale;
vertexData[vOffset+3] = 1.0f;
vOffset += stride;
}
break;
case C4UB:
for (index=start; index < end; index++) {
srcOffset = src.indexColor[index];
vertexData[vOffset] = (src.c4bRefColors[srcOffset].x & 0xff) * ByteToFloatScale;
vertexData[vOffset+1] = (src.c4bRefColors[srcOffset].y & 0xff) * ByteToFloatScale;
vertexData[vOffset+2] = (src.c4bRefColors[srcOffset].z & 0xff) * ByteToFloatScale;
vertexData[vOffset+3] = (src.c4bRefColors[srcOffset].w & 0xff) * ByteToFloatScale;
vOffset += stride;
}
break;
default:
break;
}
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
vOffset = textureOffset;
switch ((src.vertexType & TEXCOORD_DEFINED)) {
case TF:
for (index=start; index < end; index++) {
for (i = 0, tOffset = vOffset;
i < texCoordSetCount; i++) {
System.arraycopy(src.refTexCoords[i],
src.indexTexCoord[i][index]*texCoordStride,
vertexData, tOffset, texCoordStride);
tOffset += texCoordStride;
}
vOffset += stride;
}
break;
case T2F:
for (index=start; index < end; index++) {
for (i = 0, tOffset = vOffset;
i < texCoordSetCount; i++) {
srcOffset = src.indexTexCoord[i][index];
vertexData[tOffset] =
((TexCoord2f[])src.refTexCoords[i])[srcOffset].x;
vertexData[tOffset+1] =
((TexCoord2f[])src.refTexCoords[i])[srcOffset].y;
tOffset += texCoordStride;
}
vOffset += stride;
}
break;
case T3F:
for (index=start; index < end; index++) {
for (i = 0, tOffset = vOffset;
i < texCoordSetCount; i++) {
srcOffset = src.indexTexCoord[i][index];
vertexData[tOffset] =
((TexCoord3f[])src.refTexCoords[i])[srcOffset].x;
vertexData[tOffset+1] =
((TexCoord3f[])src.refTexCoords[i])[srcOffset].y;
vertexData[tOffset+2] =
((TexCoord3f[])src.refTexCoords[i])[srcOffset].z;
tOffset += texCoordStride;
}
vOffset += stride;
}
break;
default:
break;
}
}
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
vOffset = 0;
switch (src.vertexType & VATTR_DEFINED) {
case AF:
for (index=start; index < end; index++) {
for (i = 0; i < vertexAttrCount; i++) {
int vaOffset = vOffset + vertexAttrOffsets[i];
System.arraycopy(src.floatRefVertexAttrs[i],
src.indexVertexAttr[i][index]*vertexAttrSizes[i],
vertexData, vaOffset, vertexAttrSizes[i]);
}
vOffset += stride;
}
break;
}
}
if ((vertexFormat & GeometryArray.COORDINATES) != 0) {
vOffset = coordinateOffset;
switch ((src.vertexType & VERTEX_DEFINED)) {
case PF:
for (index=start; index < end; index++) {
System.arraycopy(src.floatRefCoords,
src.indexCoord[index]*3,
vertexData,
vOffset, 3);
vOffset += stride;
}
break;
case PD:
for (index=start; index < end; index++) {
srcOffset = src.indexCoord[index] * 3;
vertexData[vOffset] = (float)src.doubleRefCoords[srcOffset];
vertexData[vOffset+1] = (float)src.doubleRefCoords[srcOffset+1];
vertexData[vOffset+2] = (float)src.doubleRefCoords[srcOffset+2];
vOffset += stride;
}
break;
case P3F:
for (index=start; index < end; index++) {
srcOffset = src.indexCoord[index];
vertexData[vOffset] = src.p3fRefCoords[srcOffset].x;
vertexData[vOffset+1] = src.p3fRefCoords[srcOffset].y;
vertexData[vOffset+2] = src.p3fRefCoords[srcOffset].z;
vOffset += stride;
}
break;
case P3D:
for (index=start; index < end; index++) {
srcOffset = src.indexCoord[index];
vertexData[vOffset] = (float)src.p3dRefCoords[srcOffset].x;
vertexData[vOffset+1] = (float)src.p3dRefCoords[srcOffset].y;
vertexData[vOffset+2] = (float)src.p3dRefCoords[srcOffset].z;
vOffset += stride;
}
break;
default:
break;
}
}
}
}
private void unIndexifyNIOBuffer(IndexedGeometryArrayRetained src) {
// System.err.println("unIndexifyNIOBuffer");
int vOffset = 0, srcOffset, tOffset = 0;
int index, colorStride = 0;
int i;
int start, end;
start = src.initialIndexIndex;
end = src.initialIndexIndex + src.validIndexCount;
// If its interleaved data then ..
if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
colorStride = 4;
else if ((src.vertexFormat & GeometryArray.COLOR) != 0)
colorStride = 3;
// System.err.println("===> start = "+start+" end = "+end);
for (index= start; index < end; index++) {
if ((vertexFormat & GeometryArray.NORMALS) != 0){
src.interleavedFloatBufferImpl.position(src.indexNormal[index]*src.stride + src.normalOffset);
src.interleavedFloatBufferImpl.get(vertexData, vOffset + normalOffset, 3);
}
if (colorStride == 4){
src.interleavedFloatBufferImpl.position(src.indexColor[index]*src.stride + src.colorOffset);
src.interleavedFloatBufferImpl.get(vertexData, vOffset + colorOffset, colorStride);
} else if (colorStride == 3) {
src.interleavedFloatBufferImpl.position(src.indexColor[index]*src.stride + src.colorOffset);
src.interleavedFloatBufferImpl.get(vertexData, vOffset + colorOffset, colorStride);
vertexData[vOffset + colorOffset + 3] = 1.0f;
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
int tcOffset = vOffset + textureOffset;
for (i = 0; i < texCoordSetCount;
i++, tcOffset += texCoordStride) {
src.interleavedFloatBufferImpl.position((src.indexTexCoord[i][index])*src.stride +
src.textureOffset);
src.interleavedFloatBufferImpl.get(vertexData, tcOffset, texCoordStride);
}
}
if ((vertexFormat & GeometryArray.COORDINATES) != 0){
src.interleavedFloatBufferImpl.position(src.indexCoord[index]*src.stride + src.coordinateOffset );
src.interleavedFloatBufferImpl.get(vertexData, vOffset + coordinateOffset, 3);
}
vOffset += stride;
}
} else {
if ((vertexFormat & GeometryArray.NORMALS) != 0){
vOffset = normalOffset;
if ((src.vertexType & NORMAL_DEFINED) != 0) {
for (index=start; index < end; index++) {
src.floatBufferRefNormals.position(src.indexNormal[index]*3);
src.floatBufferRefNormals.get(vertexData, vOffset, 3);
vOffset += stride;
}
}
}
if ((vertexFormat & GeometryArray.COLOR) != 0){
vOffset = colorOffset;
int multiplier = 3;
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
multiplier = 4;
switch ((src.vertexType & COLOR_DEFINED)) {
case CF:
for (index=start; index < end; index++) {
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
src.floatBufferRefColors.position(src.indexColor[index]*multiplier);
src.floatBufferRefColors.get(vertexData, vOffset, 4);
}
else {
src.floatBufferRefColors.position(src.indexColor[index]*multiplier);
src.floatBufferRefColors.get(vertexData, vOffset, 3);
vertexData[vOffset+3] = 1.0f;
}
vOffset += stride;
}
break;
case CUB:
for (index=start; index < end; index++) {
srcOffset = src.indexColor[index] * multiplier;
vertexData[vOffset] = (src.byteBufferRefColors.get(srcOffset) & 0xff) * ByteToFloatScale;
vertexData[vOffset+1] = (src.byteBufferRefColors.get(srcOffset+1) & 0xff) * ByteToFloatScale;
vertexData[vOffset+2] = (src.byteBufferRefColors.get(srcOffset+2) & 0xff) * ByteToFloatScale;
if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
vertexData[vOffset+3] = (src.byteBufferRefColors.get(srcOffset+3) & 0xff) * ByteToFloatScale;
}
else {
vertexData[vOffset+3] = 1.0f;
}
vOffset += stride;
}
break;
default:
break;
}
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
vOffset = textureOffset;
if ((src.vertexType & TEXCOORD_DEFINED) != 0) {
for (index=start; index < end; index++) {
for (i = 0, tOffset = vOffset;
i < texCoordSetCount; i++) {
FloatBuffer texBuffer = (FloatBuffer)src.refTexCoordsBuffer[i].getROBuffer();
texBuffer.position(src.indexTexCoord[i][index]*texCoordStride);
texBuffer.get(vertexData, tOffset, texCoordStride);
tOffset += texCoordStride;
}
vOffset += stride;
}
}
}
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
vOffset = 0;
if ((src.vertexType & VATTR_DEFINED) == AF) {
for (index=start; index < end; index++) {
for (i = 0; i < vertexAttrCount; i++) {
int vaOffset = vOffset + vertexAttrOffsets[i];
FloatBuffer vaBuffer = src.floatBufferRefVertexAttrs[i];
vaBuffer.position(src.indexVertexAttr[i][index]*vertexAttrSizes[i]);
vaBuffer.get(vertexData, vaOffset, vertexAttrSizes[i]);
}
vOffset += stride;
}
}
}
if ((vertexFormat & GeometryArray.COORDINATES) != 0){
vOffset = coordinateOffset;
switch ((src.vertexType & VERTEX_DEFINED)) {
case PF:
for (index=start; index < end; index++) {
src.floatBufferRefCoords.position(src.indexCoord[index]*3);
src.floatBufferRefCoords.get(vertexData, vOffset, 3);
vOffset += stride;
}
break;
case PD:
for (index=start; index < end; index++) {
srcOffset = src.indexCoord[index] * 3;
vertexData[vOffset] = (float)src.doubleBufferRefCoords.get(srcOffset);
vertexData[vOffset+1] = (float)src.doubleBufferRefCoords.get(srcOffset+1);
vertexData[vOffset+2] = (float)src.doubleBufferRefCoords.get(srcOffset+2);
vOffset += stride;
}
break;
default:
break;
}
}
}
}
/**
* Returns the vertex stride in numbers of floats as a function
* of the vertexFormat.
* @return the stride in floats for this vertex array
*/
int stride()
{
int stride = 0;
if((this.vertexFormat & GeometryArray.COORDINATES) != 0) stride += 3;
if((this.vertexFormat & GeometryArray.NORMALS) != 0) stride += 3;
if ((this.vertexFormat & GeometryArray.COLOR) != 0) {
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
// By copy
stride += 4;
} else {
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
stride += 3;
}
else {
stride += 4;
}
}
}
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
if ((this.vertexFormat &
GeometryArray.TEXTURE_COORDINATE_2) != 0) {
texCoordStride = 2;
} else if ((this.vertexFormat &
GeometryArray.TEXTURE_COORDINATE_3) != 0) {
texCoordStride = 3;
} else if ((this.vertexFormat &
GeometryArray.TEXTURE_COORDINATE_4) != 0) {
texCoordStride = 4;
}
stride += texCoordStride * texCoordSetCount;
}
if ((this.vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
stride += vertexAttrStride;
}
//System.err.println("stride() = " + stride);
return stride;
}
int[] texCoordSetMapOffset()
{
if (texCoordSetMap == null)
return null;
texCoordSetMapOffset = new int[texCoordSetMap.length];
for (int i = 0; i < texCoordSetMap.length; i++) {
if (texCoordSetMap[i] == -1) {
texCoordSetMapOffset[i] = -1;
} else {
texCoordSetMapOffset[i] = texCoordSetMap[i] * texCoordStride;
}
}
return texCoordSetMapOffset;
}
/**
* Returns the stride of the set of vertex attributes. This is the
* sum of the sizes of each vertex attribute.
* @return the stride of the vertex attribute data
*/
int vertexAttrStride() {
int sum = 0;
for (int i = 0; i < vertexAttrCount; i++) {
sum += vertexAttrSizes[i];
}
return sum;
}
/**
* Returns the offset in number of floats from the start of a vertex to
* each per-vertex vertex attribute.
* @return array of offsets in floats vertex start to the vertex attribute data
*/
int[] vertexAttrOffsets() {
int[] offsets;
// Create array of offsets to the start of each vertex attribute.
// The offset of the first attribute is always 0. If no vertex attributes exist,
// then we will allocate an array of length 1 to avoid some checking elsewhere.
if (vertexAttrCount > 0) {
offsets = new int[vertexAttrCount];
}
else {
offsets = new int[1];
}
offsets[0] = 0;
for (int i = 1; i < vertexAttrCount; i++) {
offsets[i] = offsets[i-1] + vertexAttrSizes[i-1];
}
return offsets;
}
/**
* Returns the offset in number of floats from the start of a vertex to
* the per-vertex texture coordinate data.
* texture coordinate data always follows vertex attribute data
* @return the offset in floats vertex start to the tetxure data
*/
int textureOffset()
{
int offset = vertexAttrOffsets[0];
if ((this.vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
offset += vertexAttrStride;
}
return offset;
}
/**
* Returns the offset in number of floats from the start of a vertex to
* the per-vertex color data.
* color data always follows texture data
* @param vertexFormat the vertex format for this array
* @return the offset in floats vertex start to the color data
*/
int colorOffset()
{
int offset = textureOffset;
if((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0)
offset += 2 * texCoordSetCount;
else if((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0)
offset += 3 * texCoordSetCount;
else if((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0)
offset += 4 * texCoordSetCount;
return offset;
}
/**
* Returns the offset in number of floats from the start of a vertex to
* the per-vertex normal data.
* normal data always follows color data
* @return the offset in floats from the start of a vertex to the normal
*/
int normalOffset()
{
int offset = colorOffset;
if ((this.vertexFormat & GeometryArray.COLOR) != 0) {
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
offset += 4;
} else {
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
offset += 3;
}
else {
offset += 4;
}
}
}
return offset;
}
/**
* Returns the offset in number of floats from the start of a vertex to
* the per vertex coordinate data.
* @return the offset in floats vertex start to the coordinate data
*/
int coordinateOffset()
{
int offset = normalOffset;
if ((this.vertexFormat & GeometryArray.NORMALS) != 0) offset += 3;
return offset;
}
/**
* Returns number of vertices in the GeometryArray
* @return vertexCount number of vertices in the GeometryArray
*/
int getVertexCount(){
return vertexCount;
}
/**
* Returns vertexFormat in the GeometryArray
* @return vertexFormat format of vertices in the GeometryArray
*/
@Override
int getVertexFormat(){
return vertexFormat;
}
/**
* Retrieves the number of vertex attributes in this GeometryArray
* object.
*
* @return the number of vertex attributes in this GeometryArray
* object
*/
int getVertexAttrCount() {
return vertexAttrCount;
}
/**
* Retrieves the vertex attribute sizes array from this
* GeometryArray object.
*
* @param vertexAttrSizes an array that will receive a copy of
* the vertex attribute sizes array. The array must hold at least
* <code>vertexAttrCount</code> elements.
*/
void getVertexAttrSizes(int[] vertexAttrSizes) {
for (int i = 0; i < vertexAttrCount; i++) {
vertexAttrSizes[i] = this.vertexAttrSizes[i];
}
}
void sendDataChangedMessage(boolean coordinatesChanged) {
J3dMessage[] m;
int i, j, k, numShapeMessages, numMorphMessages;
synchronized(liveStateLock) {
if (source != null && source.isLive()) {
// System.err.println("In GeometryArrayRetained - ");
// Send a message to renderBin to rebuild the display list or
// process the vertex array accordingly
// XXXX: Should I send one per universe, isn't display list
// shared by all context/universes?
int threads = J3dThread.UPDATE_RENDER;
// If the geometry type is Indexed then we need to clone the geometry
// We also need to update the cachedChangedFrequent flag
threads |= J3dThread.UPDATE_RENDERING_ATTRIBUTES;
synchronized (universeList) {
numShapeMessages = universeList.size();
m = new J3dMessage[numShapeMessages];
k = 0;
for (i = 0; i < numShapeMessages; i++, k++) {
gaList.clear();
ArrayList<Shape3DRetained> shapeList = userLists.get(i);
for (j = 0; j < shapeList.size(); j++) {
Shape3DRetained s = shapeList.get(j);
LeafRetained src = (LeafRetained)s.sourceNode;
// Should only need to update distinct localBounds.
if (coordinatesChanged && src.boundsAutoCompute) {
src.boundsDirty = true;
}
}
for (j = 0; j < shapeList.size(); j++) {
Shape3DRetained s = shapeList.get(j);
LeafRetained src = (LeafRetained)s.sourceNode;
if (src.boundsDirty) {
// update combine bounds of mirrorShape3Ds. So we need to
// use its bounds and not localBounds.
// bounds is actually a reference to
// mirrorShape3D.source.localBounds.
src.updateBounds();
src.boundsDirty = false;
}
gaList.add(Shape3DRetained.getGeomAtom(s));
}
m[k] = new J3dMessage();
m[k].type = J3dMessage.GEOMETRY_CHANGED;
// Who to send this message to ?
m[k].threads = threads;
m[k].args[0] = gaList.toArray();
m[k].args[1] = this;
m[k].args[2]= null;
m[k].args[3] = new Integer(changedFrequent);
m[k].universe = universeList.get(i);
}
VirtualUniverse.mc.processMessage(m);
}
if (morphUniverseList != null) {
synchronized (morphUniverseList) {
numMorphMessages = morphUniverseList.size();
// take care of morph that is referencing this geometry
if (numMorphMessages > 0) {
synchronized (morphUniverseList) {
for (i = 0; i < numMorphMessages; i++, k++) {
ArrayList<MorphRetained> morphList = morphUserLists.get(i);
for (j = 0; j < morphList.size(); j++) {
morphList.get(j).updateMorphedGeometryArray(this, coordinatesChanged);
}
}
}
}
}
}
}
}
}
/**
* Sets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate an array of 3 values containing the new coordinate
*/
void setCoordinate(int index, float coordinate[]) {
int offset = this.stride * index + coordinateOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
this.vertexData[offset] = coordinate[0];
this.vertexData[offset+1]= coordinate[1];
this.vertexData[offset+2]= coordinate[2];
if (isLive) {
geomLock.unLock();
}
if (inUpdater || (source == null)) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate an array of 3 values containing the new coordinate
*/
void setCoordinate(int index, double coordinate[]) {
int offset = this.stride * index + coordinateOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
this.vertexData[offset] = (float)coordinate[0];
this.vertexData[offset+1]= (float)coordinate[1];
this.vertexData[offset+2]= (float)coordinate[2];
if(isLive) {
geomLock.unLock();
}
if (inUpdater || (source == null)) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate a vector containing the new coordinate
*/
void setCoordinate(int index, Point3f coordinate) {
int offset = this.stride * index + coordinateOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
this.vertexData[offset] = coordinate.x;
this.vertexData[offset+1]= coordinate.y;
this.vertexData[offset+2]= coordinate.z;
if(isLive) {
geomLock.unLock();
}
if (inUpdater || (source == null)) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate a vector containing the new coordinate
*/
void setCoordinate(int index, Point3d coordinate) {
int offset = this.stride * index + coordinateOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
this.vertexData[offset] = (float)coordinate.x;
this.vertexData[offset+1]= (float)coordinate.y;
this.vertexData[offset+2]= (float)coordinate.z;
if(isLive) {
geomLock.unLock();
}
if (inUpdater || source == null ) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of 3*n values containing n new coordinates
*/
void setCoordinates(int index, float coordinates[]) {
int offset = this.stride * index + coordinateOffset;
int i, j, num = coordinates.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i=0, j= offset;i < num; i+=3, j+= this.stride)
{
this.vertexData[j] = coordinates[i];
this.vertexData[j+1]= coordinates[i+1];
this.vertexData[j+2]= coordinates[i+2];
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater ||source == null ) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of 3*n values containing n new coordinates
*/
void setCoordinates(int index, double coordinates[]) {
int offset = this.stride * index + coordinateOffset;
int i, j, num = coordinates.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i=0, j= offset;i < num; i+=3, j+= this.stride)
{
this.vertexData[j] = (float)coordinates[i];
this.vertexData[j+1]= (float)coordinates[i+1];
this.vertexData[j+2]= (float)coordinates[i+2];
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater ||source == null ) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of vectors containing new coordinates
*/
void setCoordinates(int index, Point3f coordinates[]) {
int offset = this.stride * index + coordinateOffset;
int i, j, num = coordinates.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
this.vertexData[j] = coordinates[i].x;
this.vertexData[j+1]= coordinates[i].y;
this.vertexData[j+2]= coordinates[i].z;
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater ||source == null ) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of vectors containing new coordinates
*/
void setCoordinates(int index, Point3d coordinates[]) {
int offset = this.stride * index + coordinateOffset;
int i, j, num = coordinates.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
this.vertexData[j] = (float)coordinates[i].x;
this.vertexData[j+1]= (float)coordinates[i].y;
this.vertexData[j+2]= (float)coordinates[i].z;
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater ||source == null ) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index for this object using coordinate data starting
* from vertex index <code>start</code> for <code>length</code> vertices.
* @param index the vertex index
* @param coordinates an array of vectors containing new coordinates
* @param start starting vertex index of data in <code>coordinates</code> .
* @param length number of vertices to be copied.
*/
void setCoordinates(int index, float coordinates[], int start, int length) {
int offset = this.stride * index + coordinateOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i= start * 3, j= offset; i < (start+length) * 3;
i+=3, j+= this.stride) {
this.vertexData[j] = coordinates[i];
this.vertexData[j+1]= coordinates[i+1];
this.vertexData[j+2]= coordinates[i+2];
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater ||source == null ) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index for this object using coordinate data starting
* from vertex index <code>start</code> for <code>length</code> vertices.
* @param index the vertex index
* @param coordinates an array of 3*n values containing n new coordinates
* @param start starting vertex index of data in <code>coordinates</code> .
* @param length number of vertices to be copied.
*/
void setCoordinates(int index, double coordinates[], int start, int length) {
int offset = this.stride * index + coordinateOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i= start*3, j= offset; i < (start+length)*3;
i+=3, j+= this.stride) {
this.vertexData[j] = (float)coordinates[i];
this.vertexData[j+1]= (float)coordinates[i+1];
this.vertexData[j+2]= (float)coordinates[i+2];
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater || (source == null)) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index for this object using coordinate data starting
* from vertex index <code>start</code> for <code>length</code> vertices.
* @param index the vertex index
* @param coordinates an array of vectors containing new coordinates
* @param start starting vertex index of data in <code>coordinates</code> .
* @param length number of vertices to be copied.
*/
void setCoordinates(int index, Point3f coordinates[], int start,
int length) {
int offset = this.stride * index + coordinateOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i=start, j= offset;i < start + length; i++, j+= this.stride) {
this.vertexData[j] = coordinates[i].x;
this.vertexData[j+1]= coordinates[i].y;
this.vertexData[j+2]= coordinates[i].z;
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater || (source == null)) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the coordinates associated with the vertices starting at
* the specified index for this object using coordinate data starting
* from vertex index <code>start</code> for <code>length</code> vertices.
* @param index the vertex index
* @param coordinates an array of vectors containing new coordinates
* @param start starting vertex index of data in <code>coordinates</code> .
* @param length number of vertices to be copied.
*/
void setCoordinates(int index, Point3d coordinates[], int start,
int length) {
int offset = this.stride * index + coordinateOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
for (i=start, j= offset;i < start + length; i++, j+= this.stride) {
this.vertexData[j] = (float)coordinates[i].x;
this.vertexData[j+1]= (float)coordinates[i].y;
this.vertexData[j+2]= (float)coordinates[i].z;
}
if(isLive) {
geomLock.unLock();
}
if (inUpdater || (source == null)) {
return;
}
if (!isLive) {
boundsDirty = true;
return;
}
// Compute geo's bounds
processCoordsChanged(false);
sendDataChangedMessage(true);
}
/**
* Sets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color an array of 3 or 4 values containing the new color
*/
void setColor(int index, float color[]) {
int offset = this.stride*index + colorOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.vertexData[offset] = color[0];
this.vertexData[offset+1] = color[1];
this.vertexData[offset+2] = color[2];
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
this.vertexData[offset+3] = color[3]*lastAlpha[0];
else
this.vertexData[offset+3] = lastAlpha[0];
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color an array of 3 or 4 values containing the new color
*/
void setColor(int index, byte color[]) {
int offset = this.stride*index + colorOffset;
boolean isLive = source!=null && source.isLive();
if(isLive) {
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.vertexData[offset] = (color[0] & 0xff) * ByteToFloatScale;
this.vertexData[offset+1] = (color[1] & 0xff) * ByteToFloatScale;
this.vertexData[offset+2] = (color[2] & 0xff) * ByteToFloatScale;
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
this.vertexData[offset+3] = ((color[3] & 0xff)* ByteToFloatScale)*lastAlpha[0];
else
this.vertexData[offset+3] = lastAlpha[0];
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector containing the new color
*/
void setColor(int index, Color3f color) {
int offset = this.stride*index + colorOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.vertexData[offset] = color.x;
this.vertexData[offset+1] = color.y;
this.vertexData[offset+2] = color.z;
this.vertexData[offset+3] = lastAlpha[0];
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector containing the new color
*/
void setColor(int index, Color4f color) {
int offset = this.stride*index + colorOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.vertexData[offset] = color.x;
this.vertexData[offset+1] = color.y;
this.vertexData[offset+2] = color.z;
this.vertexData[offset+3] = color.w*lastAlpha[0];
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector containing the new color
*/
void setColor(int index, Color3b color) {
int offset = this.stride*index + colorOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.vertexData[offset] = (color.x & 0xff) * ByteToFloatScale;
this.vertexData[offset+1] = (color.y & 0xff) * ByteToFloatScale;
this.vertexData[offset+2] = (color.z & 0xff) * ByteToFloatScale;
this.vertexData[offset+3] = lastAlpha[0];
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector containing the new color
*/
void setColor(int index, Color4b color) {
int offset = this.stride*index + colorOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.vertexData[offset] = (color.x & 0xff) * ByteToFloatScale;
this.vertexData[offset+1] = (color.y & 0xff) * ByteToFloatScale;
this.vertexData[offset+2] = (color.z & 0xff) * ByteToFloatScale;
this.vertexData[offset+3] = ((color.w & 0xff) * ByteToFloatScale)*lastAlpha[0];
if(isLive){
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
*/
void setColors(int index, float colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
{
for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
{
this.vertexData[j] = colors[i];
this.vertexData[j+1] = colors[i+1];
this.vertexData[j+2] = colors[i+2];
this.vertexData[j+3] = colors[i+3]*lastAlpha[0];
}
}
else
{
for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
{
this.vertexData[j] = colors[i];
this.vertexData[j+1] = colors[i+1];
this.vertexData[j+2] = colors[i+2];
this.vertexData[j+3] = lastAlpha[0];
}
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
*/
void setColors(int index, byte colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
{
for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
{
this.vertexData[j] = (colors[i] & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = ((colors[i+3] & 0xff) * ByteToFloatScale)*lastAlpha[0];
}
}
else
{
for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
{
this.vertexData[j] = (colors[i] & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = lastAlpha[0];
}
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors containing new colors
*/
void setColors(int index, Color3f colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
this.vertexData[j] = colors[i].x;
this.vertexData[j+1] = colors[i].y;
this.vertexData[j+2] = colors[i].z;
this.vertexData[j+3] = lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors containing new colors
*/
void setColors(int index, Color4f colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
this.vertexData[j] = colors[i].x;
this.vertexData[j+1] = colors[i].y;
this.vertexData[j+2] = colors[i].z;
this.vertexData[j+3] = colors[i].w*lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors containing new colors
*/
void setColors(int index, Color3b colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
this.vertexData[j] = (colors[i].x & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors containing new colors
*/
void setColors(int index, Color4b colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
this.vertexData[j] = (colors[i].x & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = ((colors[i].w & 0xff) * ByteToFloatScale)*lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index for this object using data in <code>color</code>s
* starting at index <code>start</code> for <code>length</code> colors.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
* @param start starting color index of data in <code>colors</code>.
* @param length number of colors to be copied.
*/
void setColors(int index, float colors[], int start, int length) {
int offset = this.stride*index + colorOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
for (i = start * 4, j = offset; i < (start + length) * 4;
i += 4, j += this.stride) {
this.vertexData[j] = colors[i];
this.vertexData[j+1] = colors[i+1];
this.vertexData[j+2] = colors[i+2];
this.vertexData[j+3] = colors[i+3]*lastAlpha[0];
}
} else {
for (i = start * 3, j = offset; i < (start + length) * 3;
i += 3, j += this.stride) {
this.vertexData[j] = colors[i];
this.vertexData[j+1] = colors[i+1];
this.vertexData[j+2] = colors[i+2];
this.vertexData[j+3] = lastAlpha[0];
}
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index for this object using data in <code>color</code>s
* starting at index <code>start</code> for <code>length</code> colors.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
* @param start starting color index of data in <code>colors</code>.
* @param length number of colors to be copied.
*/
void setColors(int index, byte colors[], int start, int length) {
int offset = this.stride*index + colorOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
for (i = start * 4, j = offset; i < (start + length) * 4;
i += 4, j += this.stride) {
this.vertexData[j] = (colors[i] & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = ((colors[i+3] & 0xff) * ByteToFloatScale)*lastAlpha[0];
}
} else {
for (i = start * 3, j = offset; i < (start + length) * 3;
i += 3, j += this.stride) {
this.vertexData[j] = (colors[i] & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = lastAlpha[0];
}
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index for this object using data in <code>color</code>s
* starting at index <code>start</code> for <code>length</code> colors.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
* @param start starting color index of data in <code>colors</code>.
* @param length number of colors to be copied.
*/
void setColors(int index, Color3f colors[], int start, int length) {
int offset = this.stride*index + colorOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = colors[i].x;
this.vertexData[j+1] = colors[i].y;
this.vertexData[j+2] = colors[i].z;
this.vertexData[j+3] = lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index for this object using data in <code>color</code>s
* starting at index <code>start</code> for <code>length</code> colors.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
* @param start starting color index of data in <code>colors</code>.
* @param length number of colors to be copied.
*/
void setColors(int index, Color4f colors[], int start, int length) {
int offset = this.stride*index + colorOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = colors[i].x;
this.vertexData[j+1] = colors[i].y;
this.vertexData[j+2] = colors[i].z;
this.vertexData[j+3] = colors[i].w*lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index for this object using data in <code>color</code>s
* starting at index <code>start</code> for <code>length</code> colors.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
* @param start starting color index of data in <code>colors</code>.
* @param length number of colors to be copied.
*/
void setColors(int index, Color3b colors[], int start, int length) {
int offset = this.stride*index + colorOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = (colors[i].x & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the colors associated with the vertices starting at
* the specified index for this object using data in <code>color</code>s
* starting at index <code>start</code> for <code>length</code> colors.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values containing n new colors
* @param start starting color index of data in <code>colors</code>.
* @param length number of colors to be copied.
*/
void setColors(int index, Color4b colors[], int start, int length) {
int offset = this.stride*index + colorOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = (colors[i].x & 0xff) * ByteToFloatScale;
this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
this.vertexData[j+3] = ((colors[i].w & 0xff) * ByteToFloatScale)*lastAlpha[0];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the normal associated with the vertex at
* the specified index.
* @param index the vertex index
* @param normal the new normal
*/
void setNormal(int index, float normal[]) {
int offset = this.stride*index + normalOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
this.vertexData[offset] = normal[0];
this.vertexData[offset+1] = normal[1];
this.vertexData[offset+2] = normal[2];
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the normal associated with the vertex at
* the specified index.
* @param index the vertex index
* @param normal the vector containing the new normal
*/
void setNormal(int index, Vector3f normal) {
int offset = this.stride*index + normalOffset;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
this.vertexData[offset] = normal.x;
this.vertexData[offset+1] = normal.y;
this.vertexData[offset+2] = normal.z;
if(isLive){
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the normals associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param normals the new normals
*/
void setNormals(int index, float normals[]) {
int offset = this.stride*index + normalOffset;
int i, j, num = normals.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
for (i=0, j= offset;i < num;i += 3, j+= this.stride)
{
this.vertexData[j] = normals[i];
this.vertexData[j+1] = normals[i+1];
this.vertexData[j+2] = normals[i+2];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the normals associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param normals the vector containing the new normals
*/
void setNormals(int index, Vector3f normals[]) {
int offset = this.stride*index + normalOffset;
int i, j, num = normals.length;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
this.vertexData[j] = normals[i].x;
this.vertexData[j+1] = normals[i].y;
this.vertexData[j+2] = normals[i].z;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the normals associated with the vertices starting at
* the specified index for this object using data in <code>normals</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param normals the new normals
* @param start starting normal index of data in <code>colors</code> .
* @param length number of normals to be copied.
*/
void setNormals(int index, float normals[], int start, int length) {
int offset = this.stride*index + normalOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
for (i = start * 3, j = offset; i < (start + length) * 3;
i+=3, j += this.stride) {
this.vertexData[j] = normals[i];
this.vertexData[j+1] = normals[i+1];
this.vertexData[j+2] = normals[i+2];
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the normals associated with the vertices starting at
* the specified index for this object using data in <code>normals</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param normals the new normals
* @param start starting normal index of data in <code>colors</code> .
* @param length number of normals to be copied.
*/
void setNormals(int index, Vector3f normals[], int start, int length) {
int offset = this.stride*index + normalOffset;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = normals[i].x;
this.vertexData[j+1] = normals[i].y;
this.vertexData[j+2] = normals[i].z;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the texture coordinates associated with the vertices starting at
* the specified index for this object using data in <code>texCoords</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param texCoords the new texture coordinates
* @param start starting texture coordinate index of data in <code>texCoords</code> .
* @param length number of texture Coordinates to be copied.
*/
void setTextureCoordinates(int texCoordSet, int index, float texCoords[],
int start, int length) {
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, k;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
for (i = start * 4, j = offset, k = 0; k < length;
j += this.stride, k++) {
this.vertexData[j] = texCoords[i++];
this.vertexData[j+1] = texCoords[i++];
this.vertexData[j+2] = texCoords[i++];
this.vertexData[j+3] = texCoords[i++];
}
} else if ((this.vertexFormat &
GeometryArray.TEXTURE_COORDINATE_3) != 0) {
for (i = start * 3, j = offset, k = 0; k < length;
j += this.stride, k++) {
this.vertexData[j] = texCoords[i++];
this.vertexData[j+1] = texCoords[i++];
this.vertexData[j+2] = texCoords[i++];
}
} else {
for (i = start * 2, j = offset, k = 0; k < length;
j += this.stride, k++) {
this.vertexData[j] = texCoords[i++];
this.vertexData[j+1] = texCoords[i++];
}
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the texture coordinates associated with the vertices starting at
* the specified index for this object using data in <code>texCoords</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param texCoords the new texture coordinates
* @param start starting texture coordinate index of data in <code>texCoords</code> .
* @param length number of texture Coordinates to be copied.
*/
void setTextureCoordinates(int texCoordSet, int index, Point2f texCoords[],
int start, int length) {
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = texCoords[i].x;
this.vertexData[j+1] = texCoords[i].y;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the texture coordinates associated with the vertices starting at
* the specified index for this object using data in <code>texCoords</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param texCoords the new texture coordinates
* @param start starting texture coordinate index of data in <code>texCoords</code> .
* @param length number of texture Coordinates to be copied.
*/
void setTextureCoordinates(int texCoordSet, int index, Point3f texCoords[],
int start, int length) {
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = texCoords[i].x;
this.vertexData[j+1] = texCoords[i].y;
this.vertexData[j+2] = texCoords[i].z;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the texture coordinates associated with the vertices starting at
* the specified index for this object using data in <code>texCoords</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param texCoords the new texture coordinates
* @param start starting texture coordinate index of data in <code>texCoords</code> .
* @param length number of texture Coordinates to be copied.
*/
void setTextureCoordinates(int texCoordSet, int index, TexCoord2f texCoords[],
int start, int length) {
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = texCoords[i].x;
this.vertexData[j+1] = texCoords[i].y;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the texture coordinates associated with the vertices starting at
* the specified index for this object using data in <code>texCoords</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param texCoords the new texture coordinates
* @param start starting texture coordinate index of data in <code>texCoords</code> .
* @param length number of texture Coordinates to be copied.
*/
void setTextureCoordinates(int texCoordSet, int index,
TexCoord3f texCoords[],
int start, int length) {
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = texCoords[i].x;
this.vertexData[j+1] = texCoords[i].y;
this.vertexData[j+2] = texCoords[i].z;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the texture coordinates associated with the vertices starting at
* the specified index for this object using data in <code>texCoords</code>
* starting at index <code>start</code> and ending at index <code>start+length</code>.
* @param index the vertex index
* @param texCoords the new texture coordinates
* @param start starting texture coordinate index of data in <code>texCoords</code> .
* @param length number of texture Coordinates to be copied.
*/
void setTextureCoordinates(int texCoordSet, int index,
TexCoord4f texCoords[],
int start, int length) {
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j;
for (i = start, j = offset; i < start+length; i++, j += this.stride) {
this.vertexData[j] = texCoords[i].x;
this.vertexData[j+1] = texCoords[i].y;
this.vertexData[j+2] = texCoords[i].z;
this.vertexData[j+3] = texCoords[i].w;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attribute associated with the vertex at the
* specified index in the specified vertex attribute number for
* this object.
*
* @param vertexAttrNum vertex attribute number in this geometry array
* @param index destination vertex index in this geometry array
* @param vertexAttr the Point2f containing the new vertex attribute
*/
void setVertexAttr(int vertexAttrNum, int index,
Point2f vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
this.vertexData[offset] = vertexAttr.x;
this.vertexData[offset+1] = vertexAttr.y;
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attribute associated with the vertex at the
* specified index in the specified vertex attribute number for
* this object.
*
* @param vertexAttrNum vertex attribute number in this geometry array
* @param index destination vertex index in this geometry array
* @param vertexAttr the Point3f containing the new vertex attribute
*/
void setVertexAttr(int vertexAttrNum, int index,
Point3f vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
this.vertexData[offset] = vertexAttr.x;
this.vertexData[offset+1] = vertexAttr.y;
this.vertexData[offset+2] = vertexAttr.z;
if (isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attribute associated with the vertex at the
* specified index in the specified vertex attribute number for
* this object.
*
* @param vertexAttrNum vertex attribute number in this geometry array
* @param index destination vertex index in this geometry array
* @param vertexAttr the Point4f containing the new vertex attribute
*/
void setVertexAttr(int vertexAttrNum, int index,
Point4f vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
this.vertexData[offset] = vertexAttr.x;
this.vertexData[offset+1] = vertexAttr.y;
this.vertexData[offset+2] = vertexAttr.z;
this.vertexData[offset+3] = vertexAttr.w;
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attributes associated with the vertices
* starting at the specified index in the specified vertex
* attribute number for this object using data in
* <code>vertexAttrs</code> starting at index <code>start</code> and
* ending at index <code>start+length</code>.
*
* @param index starting destination vertex index in this geometry array
* @param vertexAttrs source array of 1*n, 2*n, 3*n, or 4*n values
* containing n new vertex attributes
* @param start starting source vertex index in <code>vertexAttrs</code>
* array.
* @param length number of vertex attributes to be copied.
*/
void setVertexAttrs(int vertexAttrNum, int index,
float[] vertexAttrs,
int start, int length) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int size = vertexAttrSizes[vertexAttrNum];
int i, j, k;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
for (i = start * size, j = offset, k = 0; k < length; i += size, j += this.stride, k++) {
for (int ii = 0; ii < size; ii++) {
this.vertexData[j+ii] = vertexAttrs[i+ii];
}
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attributes associated with the vertices
* starting at the specified index in the specified vertex
* attribute number for this object using data in
* <code>vertexAttrs</code> starting at index <code>start</code> and
* ending at index <code>start+length</code>.
*
* @param vertexAttrNum vertex attribute number in this geometry array
* @param index starting destination vertex index in this geometry array
* @param vertexAttrs source array of Point2f objects containing new
* vertex attributes
* @param start starting source vertex index in <code>vertexAttrs</code>
* array.
* @param length number of vertex attributes to be copied.
*/
void setVertexAttrs(int vertexAttrNum, int index,
Point2f[] vertexAttrs,
int start, int length) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int i, j, k;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
for (i = start, j = offset, k = 0; k < length; i++, j += this.stride, k++) {
this.vertexData[j] = vertexAttrs[i].x;
this.vertexData[j+1] = vertexAttrs[i].y;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attributes associated with the vertices
* starting at the specified index in the specified vertex
* attribute number for this object using data in
* <code>vertexAttrs</code> starting at index <code>start</code> and
* ending at index <code>start+length</code>.
*
* @param vertexAttrNum vertex attribute number in this geometry array
* @param index starting destination vertex index in this geometry array
* @param vertexAttrs source array of Point3f objects containing new
* vertex attributes
* @param start starting source vertex index in <code>vertexAttrs</code>
* array.
* @param length number of vertex attributes to be copied.
*/
void setVertexAttrs(int vertexAttrNum, int index,
Point3f[] vertexAttrs,
int start, int length) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int i, j, k;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
for (i = start, j = offset, k = 0; k < length; i++, j += this.stride, k++) {
this.vertexData[j] = vertexAttrs[i].x;
this.vertexData[j+1] = vertexAttrs[i].y;
this.vertexData[j+2] = vertexAttrs[i].z;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Sets the vertex attributes associated with the vertices
* starting at the specified index in the specified vertex
* attribute number for this object using data in
* <code>vertexAttrs</code> starting at index <code>start</code> and
* ending at index <code>start+length</code>.
*
* @param vertexAttrNum vertex attribute number in this geometry array
* @param index starting destination vertex index in this geometry array
* @param vertexAttrs source array of Point4f objects containing new
* vertex attributes
* @param start starting source vertex index in <code>vertexAttrs</code>
* array.
* @param length number of vertex attributes to be copied.
*/
void setVertexAttrs(int vertexAttrNum, int index,
Point4f[] vertexAttrs,
int start, int length) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int i, j, k;
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
for (i = start, j = offset, k = 0; k < length; i++, j += this.stride, k++) {
this.vertexData[j] = vertexAttrs[i].x;
this.vertexData[j+1] = vertexAttrs[i].y;
this.vertexData[j+2] = vertexAttrs[i].z;
this.vertexData[j+3] = vertexAttrs[i].w;
}
if(isLive) {
geomLock.unLock();
sendDataChangedMessage(false);
}
}
/**
* Gets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate an array of 3 values that will receive the new coordinate
*/
void getCoordinate(int index, float coordinate[]) {
int offset = this.stride*index + coordinateOffset;
coordinate[0]= this.vertexData[offset];
coordinate[1]= this.vertexData[offset+1];
coordinate[2]= this.vertexData[offset+2];
}
/**
* Gets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate an array of 3 values that will receive the new coordinate
*/
void getCoordinate(int index, double coordinate[]) {
int offset = this.stride*index + coordinateOffset;
coordinate[0]= (double)this.vertexData[offset];
coordinate[1]= (double)this.vertexData[offset+1];
coordinate[2]= (double)this.vertexData[offset+2];
}
/**
* Gets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate a vector that will receive the new coordinate
*/
void getCoordinate(int index, Point3f coordinate) {
int offset = this.stride*index + coordinateOffset;
coordinate.x = this.vertexData[offset];
coordinate.y = this.vertexData[offset+1];
coordinate.z = this.vertexData[offset+2];
}
/**
* Gets the coordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param coordinate a vector that will receive the new coordinate
*/
void getCoordinate(int index, Point3d coordinate) {
int offset = this.stride*index + coordinateOffset;
coordinate.x = (double)this.vertexData[offset];
coordinate.y = (double)this.vertexData[offset+1];
coordinate.z = (double)this.vertexData[offset+2];
}
/**
* Gets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of 3*n values that will receive new coordinates
*/
void getCoordinates(int index, float coordinates[]) {
int offset = this.stride*index + coordinateOffset;
int i, j, num = coordinates.length;
for (i=0,j= offset;i < num;i +=3, j += this.stride)
{
coordinates[i] = this.vertexData[j];
coordinates[i+1]= this.vertexData[j+1];
coordinates[i+2]= this.vertexData[j+2];
}
}
/**
* Gets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of 3*n values that will receive new coordinates
*/
void getCoordinates(int index, double coordinates[]) {
int offset = this.stride*index + coordinateOffset;
int i, j, num = coordinates.length;
for (i=0,j= offset;i < num;i +=3, j += this.stride)
{
coordinates[i] = (double)this.vertexData[j];
coordinates[i+1]= (double)this.vertexData[j+1];
coordinates[i+2]= (double)this.vertexData[j+2];
}
}
/**
* Gets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of vectors that will receive new coordinates
*/
void getCoordinates(int index, Point3f coordinates[]) {
int offset = this.stride*index + coordinateOffset;
int i, j, num = coordinates.length;
for (i=0,j= offset;i < num;i++, j += this.stride)
{
coordinates[i].x = this.vertexData[j];
coordinates[i].y = this.vertexData[j+1];
coordinates[i].z = this.vertexData[j+2];
}
}
/**
* Gets the coordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param coordinates an array of vectors that will receive new coordinates
*/
void getCoordinates(int index, Point3d coordinates[]) {
int offset = this.stride*index + coordinateOffset;
int i, j, num = coordinates.length;
for (i=0,j= offset;i < num;i++, j += this.stride)
{
coordinates[i].x = (double)this.vertexData[j];
coordinates[i].y = (double)this.vertexData[j+1];
coordinates[i].z = (double)this.vertexData[j+2];
}
}
/**
* Gets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color an array of 3 or 4 values that will receive the new color
*/
void getColor(int index, float color[]) {
int offset = this.stride*index + colorOffset;
color[0]= this.vertexData[offset];
color[1]= this.vertexData[offset+1];
color[2]= this.vertexData[offset+2];
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
color[3]= this.vertexData[offset+3]/lastAlpha[0];
}
/**
* Gets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color an array of 3 or 4 values that will receive the new color
*/
void getColor(int index, byte color[]) {
int offset = this.stride*index + colorOffset;
color[0]= (byte)(this.vertexData[offset] * FloatToByteScale);
color[1]= (byte)(this.vertexData[offset+1] * FloatToByteScale);
color[2]= (byte)(this.vertexData[offset+2] * FloatToByteScale);
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
color[3]= (byte)((this.vertexData[offset+3]/lastAlpha[0]) * FloatToByteScale);
}
/**
* Gets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector that will receive the new color
*/
void getColor(int index, Color3f color) {
int offset = this.stride*index + colorOffset;
color.x = this.vertexData[offset];
color.y = this.vertexData[offset+1];
color.z = this.vertexData[offset+2];
}
/**
* Gets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector that will receive the new color
*/
void getColor(int index, Color4f color) {
int offset = this.stride*index + colorOffset;
color.x = this.vertexData[offset];
color.y = this.vertexData[offset+1];
color.z = this.vertexData[offset+2];
color.w= this.vertexData[offset+3]/lastAlpha[0];
}
/**
* Gets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector that will receive the new color
*/
void getColor(int index, Color3b color) {
int offset = this.stride*index + colorOffset;
color.x = (byte)(this.vertexData[offset] * FloatToByteScale);
color.y = (byte)(this.vertexData[offset+1] * FloatToByteScale);
color.z = (byte)(this.vertexData[offset+2] * FloatToByteScale);
}
/**
* Gets the color associated with the vertex at
* the specified index.
* @param index the vertex index
* @param color a vector that will receive the new color
*/
void getColor(int index, Color4b color) {
int offset = this.stride*index + colorOffset;
color.x = (byte)(this.vertexData[offset] * FloatToByteScale);
color.y = (byte)(this.vertexData[offset+1] * FloatToByteScale);
color.z = (byte)(this.vertexData[offset+2] * FloatToByteScale);
color.w = (byte)((this.vertexData[offset+3]/lastAlpha[0]) * FloatToByteScale);
}
/**
* Gets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values that will receive n new colors
*/
void getColors(int index, float colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
float val = 1.0f/lastAlpha[0];
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
{
for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
{
colors[i] = this.vertexData[j];
colors[i+1]= this.vertexData[j+1];
colors[i+2]= this.vertexData[j+2];
colors[i+3]= this.vertexData[j+3] * val;
}
}
else
{
for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
{
colors[i] = this.vertexData[j];
colors[i+1]= this.vertexData[j+1];
colors[i+2]= this.vertexData[j+2];
}
}
}
/**
* Gets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of 3*n or 4*n values that will receive new colors
*/
void getColors(int index, byte colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
float val = 1.0f/lastAlpha[0];
if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
{
for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
{
colors[i] = (byte)(this.vertexData[j] * FloatToByteScale);
colors[i+1]= (byte)(this.vertexData[j+1] * FloatToByteScale);
colors[i+2]= (byte)(this.vertexData[j+2] * FloatToByteScale);
colors[i+3]= (byte)((this.vertexData[j+3] * val) * FloatToByteScale);
}
}
else
{
for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
{
colors[i] = (byte)(this.vertexData[j] * FloatToByteScale);
colors[i+1]= (byte)(this.vertexData[j+1] * FloatToByteScale);
colors[i+2]= (byte)(this.vertexData[j+2] * FloatToByteScale);
}
}
}
/**
* Gets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors that will receive new colors
*/
void getColors(int index, Color3f colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
colors[i].x = this.vertexData[j];
colors[i].y = this.vertexData[j+1];
colors[i].z = this.vertexData[j+2];
}
}
/**
* Gets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors that will receive new colors
*/
void getColors(int index, Color4f colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
float val = 1.0f/lastAlpha[0];
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
colors[i].x = this.vertexData[j];
colors[i].y = this.vertexData[j+1];
colors[i].z = this.vertexData[j+2];
colors[i].w = this.vertexData[j+3] * val;
}
}
/**
* Gets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors that will receive new colors
*/
void getColors(int index, Color3b colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
colors[i].x = (byte)(this.vertexData[j] * FloatToByteScale);
colors[i].y = (byte)(this.vertexData[j+1] * FloatToByteScale);
colors[i].z = (byte)(this.vertexData[j+2] * FloatToByteScale);
}
}
/**
* Gets the colors associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param colors an array of vectors that will receive new colors
*/
void getColors(int index, Color4b colors[]) {
int offset = this.stride*index + colorOffset;
int i, j, num = colors.length;
float val = 1.0f/lastAlpha[0];
for (i=0, j= offset;i < num; i++, j+= this.stride)
{
colors[i].x = (byte)(this.vertexData[j] * FloatToByteScale);
colors[i].y = (byte)(this.vertexData[j+1] * FloatToByteScale);
colors[i].z = (byte)(this.vertexData[j+2] * FloatToByteScale);
colors[i].w = (byte)(this.vertexData[j+3] * val * FloatToByteScale);
}
}
/**
* Gets the normal associated with the vertex at
* the specified index.
* @param index the vertex index
* @param normal array that will receive the new normal
*/
void getNormal(int index, float normal[]) {
int offset = this.stride*index + normalOffset;
normal[0]= this.vertexData[offset];
normal[1]= this.vertexData[offset+1];
normal[2]= this.vertexData[offset+2];
}
/**
* Gets the normal associated with the vertex at
* the specified index.
* @param index the vertex index
* @param normal the vector that will receive the new normal
*/
void getNormal(int index, Vector3f normal) {
int offset = this.stride*index + normalOffset;
normal.x= this.vertexData[offset];
normal.y= this.vertexData[offset+1];
normal.z= this.vertexData[offset+2];
}
/**
* Gets the normals associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param normals array that will receive the new normals
*/
void getNormals(int index, float normals[]) {
int offset = this.stride*index + normalOffset;
int i, j, num = normals.length;
for (i=0, j= offset;i < num;i+=3, j+= this.stride)
{
normals[i] = this.vertexData[j];
normals[i+1]= this.vertexData[j+1];
normals[i+2]= this.vertexData[j+2];
}
}
/**
* Gets the normals associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param normals the vector that will receive the new normals
*/
void getNormals(int index, Vector3f normals[]) {
int offset = this.stride*index + normalOffset;
int i, j, num = normals.length;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
normals[i].x= this.vertexData[j];
normals[i].y= this.vertexData[j+1];
normals[i].z= this.vertexData[j+2];
}
}
/**
* Gets the texture co-ordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param texCoord array that will receive the new texture co-ordinate
*/
void getTextureCoordinate(int texCoordSet, int index, float texCoord[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
texCoord[0]= this.vertexData[offset];
texCoord[1]= this.vertexData[offset+1];
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
texCoord[2]= this.vertexData[offset+2];
} else if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4)
!= 0) {
texCoord[2]= this.vertexData[offset+2];
texCoord[3]= this.vertexData[offset+3];
}
}
/**
* Gets the texture co-ordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param texCoord the vector that will receive the new texture co-ordinates
*/
void getTextureCoordinate(int texCoordSet, int index, TexCoord2f texCoord) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
texCoord.x= this.vertexData[offset];
texCoord.y= this.vertexData[offset+1];
}
/**
* Gets the texture co-ordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param texCoord the vector that will receive the new texture co-ordinates
*/
void getTextureCoordinate(int texCoordSet, int index, TexCoord3f texCoord) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
texCoord.x= this.vertexData[offset];
texCoord.y= this.vertexData[offset+1];
texCoord.z= this.vertexData[offset+2];
}
/**
* Gets the texture co-ordinate associated with the vertex at
* the specified index.
* @param index the vertex index
* @param texCoord the vector that will receive the new texture co-ordinates
*/
void getTextureCoordinate(int texCoordSet, int index, TexCoord4f texCoord) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
texCoord.x= this.vertexData[offset];
texCoord.y= this.vertexData[offset+1];
texCoord.z= this.vertexData[offset+2];
texCoord.w= this.vertexData[offset+3];
}
/**
* Gets the texture co-ordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param texCoords array that will receive the new texture co-ordinates
*/
void getTextureCoordinates(int texCoordSet, int index, float texCoords[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, num = texCoords.length;
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
for (i=0, j= offset;i < num;i+=4, j+= this.stride)
{
texCoords[i]= this.vertexData[j];
texCoords[i+1]= this.vertexData[j+1];
texCoords[i+2]= this.vertexData[j+2];
texCoords[i+3]= this.vertexData[j+3];
}
} else if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_3)
!= 0) {
for (i=0, j= offset;i < num;i+=3, j+= this.stride)
{
texCoords[i]= this.vertexData[j];
texCoords[i+1]= this.vertexData[j+1];
texCoords[i+2]= this.vertexData[j+2];
}
} else {
for (i=0, j= offset;i < num;i+=2, j+= this.stride)
{
texCoords[i]= this.vertexData[j];
texCoords[i+1]= this.vertexData[j+1];
}
}
}
/**
* Gets the texture co-ordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param texCoords the vector that will receive the new texture co-ordinates
*/
void getTextureCoordinates(int texCoordSet, int index,
TexCoord2f texCoords[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, num = texCoords.length;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
texCoords[i].x= this.vertexData[j];
texCoords[i].y= this.vertexData[j+1];
}
}
/**
* Gets the texture co-ordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param texCoords the vector that will receive the new texture co-ordinates
*/
void getTextureCoordinates(int texCoordSet, int index, TexCoord3f texCoords[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, num = texCoords.length;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
texCoords[i].x= this.vertexData[j];
texCoords[i].y= this.vertexData[j+1];
texCoords[i].z= this.vertexData[j+2];
}
}
/**
* Gets the texture co-ordinates associated with the vertices starting at
* the specified index.
* @param index the vertex index
* @param texCoords the vector that will receive the new texture co-ordinates
*/
void getTextureCoordinates(int texCoordSet, int index, TexCoord4f texCoords[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, num = texCoords.length;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
texCoords[i].x= this.vertexData[j];
texCoords[i].y= this.vertexData[j+1];
texCoords[i].z= this.vertexData[j+2];
texCoords[i].w= this.vertexData[j+3];
}
}
void getTextureCoordinates(int texCoordSet, int index,
Point2f texCoords[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, num = texCoords.length;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
texCoords[i].x= this.vertexData[j];
texCoords[i].y= this.vertexData[j+1];
}
}
void getTextureCoordinates(int texCoordSet, int index, Point3f texCoords[]) {
int offset = this.stride*index + textureOffset +
texCoordSet * texCoordStride;
int i, j, num = texCoords.length;
for (i=0, j= offset;i < num;i++, j+= this.stride)
{
texCoords[i].x= this.vertexData[j];
texCoords[i].y= this.vertexData[j+1];
texCoords[i].z= this.vertexData[j+2];
}
}
/**
* Gets the vertex attribute associated with the vertex at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttr(int vertexAttrNum, int index,
float[] vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int size = vertexAttrSizes[vertexAttrNum];
for (int i = 0; i < size; i++) {
vertexAttr[i] = this.vertexData[offset+i];
}
}
/**
* Gets the vertex attribute associated with the vertex at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttr(int vertexAttrNum, int index,
Point2f vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
vertexAttr.x = this.vertexData[offset];
vertexAttr.y = this.vertexData[offset+1];
}
/**
* Gets the vertex attribute associated with the vertex at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttr(int vertexAttrNum, int index,
Point3f vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
vertexAttr.x = this.vertexData[offset];
vertexAttr.y = this.vertexData[offset+1];
vertexAttr.z = this.vertexData[offset+2];
}
/**
* Gets the vertex attribute associated with the vertex at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttr(int vertexAttrNum, int index,
Point4f vertexAttr) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
vertexAttr.x = this.vertexData[offset];
vertexAttr.y = this.vertexData[offset+1];
vertexAttr.z = this.vertexData[offset+2];
vertexAttr.w = this.vertexData[offset+3];
}
/**
* Gets the vertex attributes associated with the vertices starting at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttrs(int vertexAttrNum, int index,
float[] vertexAttrs) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int size = vertexAttrSizes[vertexAttrNum];
int i, j, k;
for (i = 0, j = offset;
((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
i += size, j += this.stride) {
for (k = 0; k < size; k++) {
vertexAttrs[i+k] = this.vertexData[j+k];
}
}
}
/**
* Gets the vertex attributes associated with the vertices starting at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttrs(int vertexAttrNum, int index,
Point2f[] vertexAttrs) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int i, j;
for (i = 0, j = offset;
((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
i++, j += this.stride) {
vertexAttrs[i].x = this.vertexData[j];
vertexAttrs[i].y = this.vertexData[j+1];
}
}
/**
* Gets the vertex attributes associated with the vertices starting at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttrs(int vertexAttrNum, int index,
Point3f[] vertexAttrs) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int i, j;
for (i = 0, j = offset;
((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
i++, j += this.stride) {
vertexAttrs[i].x = this.vertexData[j];
vertexAttrs[i].y = this.vertexData[j+1];
vertexAttrs[i].z = this.vertexData[j+2];
}
}
/**
* Gets the vertex attributes associated with the vertices starting at
* the specified index in the specified vertex attribute number
* for this object.
*/
public void getVertexAttrs(int vertexAttrNum, int index,
Point4f[] vertexAttrs) {
int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
int i, j;
for (i = 0, j = offset;
((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
i++, j += this.stride) {
vertexAttrs[i].x = this.vertexData[j];
vertexAttrs[i].y = this.vertexData[j+1];
vertexAttrs[i].z = this.vertexData[j+2];
vertexAttrs[i].w = this.vertexData[j+3];
}
}
/**
* Updates geometry array data.
*/
void updateData(GeometryUpdater updater) {
boolean nullGeo = false;
// Add yourself to obtain the geometry lock
// and Thread.currentThread().sleep until you get the lock
geomLock.getLock();
inUpdater = true;
updater.updateData((Geometry)source);
inUpdater = false;
if ((vertexFormat & GeometryArray.BY_REFERENCE) != 0) {
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
// XXXX: handle the nio buffer
if (!(this instanceof IndexedGeometryArrayRetained) ||
(vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) != 0) {
if (((vertexFormat & GeometryArray.INTERLEAVED) != 0)) {
setupMirrorInterleavedColorPointer(false);
nullGeo = (interleavedFloatBufferImpl == null);
}
else {
setupMirrorColorPointer((vertexType & COLOR_DEFINED), false);
nullGeo = ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0);
}
}
}
else {
if (!(this instanceof IndexedGeometryArrayRetained) ||
(vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) != 0) {
if (((vertexFormat & GeometryArray.INTERLEAVED) != 0)) {
setupMirrorInterleavedColorPointer(false);
nullGeo = (interLeavedVertexData == null);
}
else {
setupMirrorVertexPointer(vertexType & VERTEX_DEFINED);
setupMirrorColorPointer((vertexType & COLOR_DEFINED), false);
setupMirrorNormalPointer(vertexType & NORMAL_DEFINED);
setupMirrorTexCoordPointer(texCoordType);
setupMirrorVertexAttrPointer(vertexAttrType);
nullGeo = ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0);
}
}
}
//NVaidya
// User may or may not have changed indices in updater callback.
// We need to presume that the user may indeed have and, thus, will
// need to recompute maxCoordIndex unconditionally while
// geomLock is still locked.
if ((vertexFormat & GeometryArray.BY_REFERENCE_INDICES) != 0) {
assert (this instanceof IndexedGeometryArrayRetained);
if (((IndexedGeometryArrayRetained)this).getCoordIndicesRef() == null) {
nullGeo = true;
}
((IndexedGeometryArrayRetained)this).doPostUpdaterUpdate();
}
}
dirtyFlag |= VERTEX_CHANGED;
colorChanged = 0xffff;
geomLock.unLock();
if (source != null && source.isLive()) {
processCoordsChanged(nullGeo);
sendDataChangedMessage(true);
}
}
boolean intersectBoundingBox( Point3d coordinates[],
BoundingBox box,
double dist[],
Point3d iPnt) {
int i;
int out[] = new int[6];
//Do trivial vertex test.
for(i=0; i<6; i++)
out[i] = 0;
for(i=0; i<coordinates.length; i++) {
if((coordinates[i].x >= box.lower.x) && (coordinates[i].x <= box.upper.x) &&
(coordinates[i].y >= box.lower.y) && (coordinates[i].y <= box.upper.y) &&
(coordinates[i].z >= box.lower.z) && (coordinates[i].z <= box.upper.z))
// We're done! It's inside the boundingbox.
return true;
else {
if(coordinates[i].x < box.lower.x)
out[0]++; // left
if(coordinates[i].y < box.lower.y)
out[1]++; // bottom
if(coordinates[i].z < box.lower.z)
out[2]++; // back
if(coordinates[i].x > box.upper.x)
out[3]++; // right
if(coordinates[i].y > box.upper.y)
out[4]++; // top
if(coordinates[i].z > box.upper.z)
out[5]++; // front
}
}
if((out[0] == coordinates.length) || (out[1] == coordinates.length) ||
(out[2] == coordinates.length) || (out[3] == coordinates.length) ||
(out[4] == coordinates.length) || (out[5] == coordinates.length))
// we're done. primitive is outside of boundingbox.
return false;
// Setup bounding planes.
Point3d pCoor[] = new Point3d[4];
for(i=0; i<4; i++)
pCoor[i] = new Point3d();
Point3d boxCenter = new Point3d();
box.getCenter(boxCenter);
// left plane.
pCoor[0].set(box.lower.x, box.lower.y, box.lower.z);
pCoor[1].set(box.lower.x, box.lower.y, box.upper.z);
pCoor[2].set(box.lower.x, box.upper.y, box.upper.z);
pCoor[3].set(box.lower.x, box.upper.y, box.lower.z);
if (intersectPolygon(pCoor, coordinates)) {
if (dist != null) {
computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
}
return true;
}
// right plane.
pCoor[0].set(box.upper.x, box.lower.y, box.lower.z);
pCoor[1].set(box.upper.x, box.upper.y, box.lower.z);
pCoor[2].set(box.upper.x, box.upper.y, box.upper.z);
pCoor[3].set(box.upper.x, box.lower.y, box.upper.z);
if (intersectPolygon(pCoor, coordinates)) {
if (dist != null) {
computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
}
return true;
}
// bottom plane.
pCoor[0].set(box.upper.x, box.lower.y, box.upper.z);
pCoor[1].set(box.lower.x, box.lower.y, box.upper.z);
pCoor[2].set(box.lower.x, box.lower.y, box.lower.z);
pCoor[3].set(box.upper.x, box.lower.y, box.lower.z);
if (intersectPolygon(pCoor, coordinates)) {
if (dist != null) {
computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
}
return true;
}
// top plane.
pCoor[0].set(box.upper.x, box.upper.y, box.upper.z);
pCoor[1].set(box.upper.x, box.upper.y, box.lower.z);
pCoor[2].set(box.lower.x, box.upper.y, box.lower.z);
pCoor[3].set(box.lower.x, box.upper.y, box.upper.z);
if (intersectPolygon(pCoor, coordinates)) {
if (dist != null) {
computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
}
return true;
}
// front plane.
pCoor[0].set(box.upper.x, box.upper.y, box.upper.z);
pCoor[1].set(box.lower.x, box.upper.y, box.upper.z);
pCoor[2].set(box.lower.x, box.lower.y, box.upper.z);
pCoor[3].set(box.upper.x, box.lower.y, box.upper.z);
if (intersectPolygon(pCoor, coordinates)) {
if (dist != null) {
computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
}
return true;
}
// back plane.
pCoor[0].set(box.upper.x, box.upper.y, box.lower.z);
pCoor[1].set(box.upper.x, box.lower.y, box.lower.z);
pCoor[2].set(box.lower.x, box.lower.y, box.lower.z);
pCoor[3].set(box.lower.x, box.upper.y, box.lower.z);
if (intersectPolygon(pCoor, coordinates)) {
if (dist != null) {
computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
}
return true;
}
return false;
}
boolean intersectBoundingSphere(Point3d coordinates[],
BoundingSphere sphere,
double dist[],
Point3d iPnt)
{
int i, j;
Vector3d tempV3D = new Vector3d();
boolean esFlag;
//Do trivial vertex test.
for (i=0; i<coordinates.length; i++) {
tempV3D.x = coordinates[i].x - sphere.center.x;
tempV3D.y = coordinates[i].y - sphere.center.y;
tempV3D.z = coordinates[i].z - sphere.center.z;
if (tempV3D.length() <= sphere.radius) {
// We're done! It's inside the boundingSphere.
if (dist != null) {
computeMinDistance(coordinates,
sphere.getCenter(),
null, dist, iPnt);
}
return true;
}
}
for (i=0; i<coordinates.length; i++) {
if (i < (coordinates.length-1))
esFlag = edgeIntersectSphere(sphere, coordinates[i],
coordinates[i+1]);
else
esFlag = edgeIntersectSphere(sphere, coordinates[i],
coordinates[0]);
if (esFlag == true) {
if (dist != null) {
computeMinDistance(coordinates,
sphere.getCenter(),
null,
dist, iPnt);
}
return true;
}
}
if (coordinates.length < 3) {
return false; // We're done with line.
}
// Find rho.
// Compute plane normal.
Vector3d vec0 = new Vector3d(); // Edge vector from point 0 to point 1;
Vector3d vec1 = new Vector3d(); // Edge vector from point 0 to point 2 or 3;
Vector3d pNrm = new Vector3d();
Vector3d pa = new Vector3d();
Point3d q = new Point3d();
double nLenSq, pqLen, pNrmDotPa, tq;
// compute plane normal for coordinates.
for(i=0; i<coordinates.length-1;) {
vec0.x = coordinates[i+1].x - coordinates[i].x;
vec0.y = coordinates[i+1].y - coordinates[i].y;
vec0.z = coordinates[i+1].z - coordinates[i++].z;
if(vec0.length() > 0.0)
break;
}
for(j=i; j<coordinates.length-1; j++) {
vec1.x = coordinates[j+1].x - coordinates[j].x;
vec1.y = coordinates[j+1].y - coordinates[j].y;
vec1.z = coordinates[j+1].z - coordinates[j].z;
if(vec1.length() > 0.0)
break;
}
if(j == (coordinates.length-1)) {
// System.err.println("(1) Degenerate polygon.");
return false; // Degenerate polygon.
}
/*
for(i=0; i<coordinates.length; i++)
System.err.println("coordinates P" + i + " " + coordinates[i]);
for(i=0; i<coord2.length; i++)
System.err.println("coord2 P" + i + " " + coord2[i]);
*/
pNrm.cross(vec0,vec1);
nLenSq = pNrm.lengthSquared();
if( nLenSq == 0.0) {
// System.err.println("(2) Degenerate polygon.");
return false; // Degenerate polygon.
}
pa.x = coordinates[0].x - sphere.center.x;
pa.y = coordinates[0].y - sphere.center.y;
pa.z = coordinates[0].z - sphere.center.z;
pNrmDotPa = pNrm.dot(pa);
pqLen = Math.sqrt(pNrmDotPa * pNrmDotPa/ nLenSq);
if(pqLen > sphere.radius) {
return false;
}
tq = pNrmDotPa / nLenSq;
q.x = sphere.center.x + tq * pNrm.x;
q.y = sphere.center.y + tq * pNrm.y;
q.z = sphere.center.z + tq * pNrm.z;
// PolyPnt2D Test.
if (pointIntersectPolygon2D( pNrm, coordinates, q)) {
if (dist != null) {
computeMinDistance(coordinates,
sphere.getCenter(),
pNrm,
dist, iPnt);
}
return true;
}
return false;
}
boolean intersectBoundingPolytope(Point3d coordinates[],
BoundingPolytope polytope,
double dist[],
Point3d iPnt)
{
boolean debug = false;
Point4d tP4d = new Point4d();
// this is a multiplier to the halfplane distance coefficients
double distanceSign = -1.0;
if(coordinates.length == 2) {
// we'll handle line separately.
if (polytope.intersect( coordinates[0],
coordinates[1], tP4d)) {
if (dist != null) {
polytope.getCenter(iPnt);
double x = tP4d.x - iPnt.x;
double y = tP4d.y - iPnt.y;
double z = tP4d.z - iPnt.z;
dist[0] = Math.sqrt(x * x + y * y + z * z);
iPnt.x = tP4d.x;
iPnt.y = tP4d.y;
iPnt.z = tP4d.z;
}
return true;
}
return false;
}
// It is a triangle or a quad.
// first test to see if any of the coordinates are all inside of the
// intersection polytope's half planes
// essentially do a matrix multiply of the constraintMatrix K*3 with
// the input coordinates 3*1 = K*1 vector
if (debug) {
System.err.println("The value of the input vertices are: ");
for(int i=0; i < coordinates.length; i++) {
System.err.println("The " +i+ " th vertex is: " + coordinates[i]);
}
System.err.println("The value of the input bounding Polytope's planes =");
for(int i=0; i < polytope.planes.length; i++) {
System.err.println("The " +i+ " th plane is: " + polytope.planes[i]);
}
}
// the direction for the intersection cost function
double centers[] = new double[4];
centers[0] = 0.8; centers[1] = 0.9; centers[2] = 1.1; centers[3] = 1.2;
boolean intersection = true;
boolean PreTest = false;
if(PreTest) {
// for each coordinate, test it with each half plane
for( int i=0; i < coordinates.length; i++) {
for (int j=0; j < polytope.planes.length; j++) {
if ( ( polytope.planes[j].x * coordinates[i].x +
polytope.planes[j].y * coordinates[i].y +
polytope.planes[j].z*coordinates[i].z) <=
(distanceSign)*polytope.planes[j].w){
// the point satisfies this particular hyperplane
intersection = true;
} else {
// the point fails this hyper plane try with a new hyper plane
intersection = false;
break;
}
}
if(intersection) {
// a point was found to be completely inside the bounding hull
if (dist != null) {
computeMinDistance(coordinates,
polytope.getCenter(),
null,
dist, iPnt);
}
return true;
}
}
} // end of pretest
// at this point all points are outside of the bounding hull
// build the problem tableau for the linear program
int numberCols = polytope.planes.length + 2 + coordinates.length + 1;
int numberRows = 1 + coordinates.length;
double problemTableau[][] = new double[numberRows][numberCols];
// compute -Mtrans = -A*P
for( int i = 0; i < polytope.planes.length; i++) {
for( int j=0; j < coordinates.length; j++) {
problemTableau[j][i] = (-1.0)* (polytope.planes[i].x*coordinates[j].x+
polytope.planes[i].y*coordinates[j].y+
polytope.planes[i].z*coordinates[j].z);
}
}
// add the other rows
for(int i = 0; i < coordinates.length; i++) {
problemTableau[i][polytope.planes.length] = -1.0;
problemTableau[i][polytope.planes.length + 1] = 1.0;
for(int j=0; j < coordinates.length; j++) {
if ( i==j ) {
problemTableau[i][j + polytope.planes.length + 2] = 1.0;
} else {
problemTableau[i][j + polytope.planes.length + 2] = 0.0;
}
// place the last column elements the Ci's
problemTableau[i][numberCols - 1] = centers[i];
}
}
// place the final rows value
for(int j = 0; j < polytope.planes.length; j++) {
problemTableau[numberRows - 1][j] =
(distanceSign)*polytope.planes[j].w;
}
problemTableau[numberRows - 1][polytope.planes.length] = 1.0;
problemTableau[numberRows - 1][polytope.planes.length+1] = -1.0;
for(int j = 0; j < coordinates.length; j++) {
problemTableau[numberRows - 1][polytope.planes.length+2+j] = 0.0;
}
if(debug) {
System.err.println("The value of the problem tableau is: " );
for(int i=0; i < problemTableau.length; i++) {
for(int j=0; j < problemTableau[0].length; j++) {
System.err.print(problemTableau[i][j] + " ");
}
System.err.println();
}
}
double distance = generalStandardSimplexSolver(problemTableau,
Float.NEGATIVE_INFINITY);
if(debug) {
System.err.println("The value returned by the general standard simplex = " +
distance);
}
if (distance == Float.POSITIVE_INFINITY) {
return false;
}
if (dist != null) {
computeMinDistance(coordinates,
polytope.getCenter(),
null,
dist, iPnt);
}
return true;
}
// optimized version using arrays of doubles, but using the standard simplex
// method to solve the LP tableau. This version has not been optimized to
// work with a particular size input tableau and is much slower than some
// of the other variants...supposedly
double generalStandardSimplexSolver(double problemTableau[][],
double stopingValue) {
boolean debug = false;
int numRow = problemTableau.length;
int numCol = problemTableau[0].length;
boolean optimal = false;
int i, pivotRowIndex, pivotColIndex;
double maxElement, element, endElement, ratio, prevRatio;
double multiplier;
if(debug) {
System.err.println("The number of rows is : " + numRow);
System.err.println("The number of columns is : " + numCol);
}
// until the optimal solution is found continue to do
// iterations of the simplex method
while(!optimal) {
if(debug) {
System.err.println("input problem tableau is:");
for(int k=0; k < numRow; k++) {
for(int j=0; j < numCol; j++) {
System.err.println("kth, jth value is:" +k+" "+j+" : " +
problemTableau[k][j]);
}
}
}
// test to see if the current solution is optimal
// check all bottom row elements except the right most one and
// if all positive or zero its optimal
for(i = 0, maxElement = 0, pivotColIndex = -1; i < numCol - 1; i++) {
// a bottom row element
element = problemTableau[numRow - 1][i];
if( element < maxElement) {
maxElement = element;
pivotColIndex = i;
}
}
// if there is no negative non-zero element then we
// have found an optimal solution (the last row of the tableau)
if(pivotColIndex == -1) {
// found an optimal solution
//System.err.println("Found an optimal solution");
optimal = true;
}
//System.err.println("The value of maxElement is:" + maxElement);
if(!optimal) {
// Case when the solution is not optimal but not known to be
// either unbounded or infeasable
// from the above we have found the maximum negative element in
// bottom row, we have also found the column for this value
// the pivotColIndex represents this
// initialize the values for the algorithm, -1 for pivotRowIndex
// indicates no solution
prevRatio = Float.POSITIVE_INFINITY;
ratio = 0.0;
pivotRowIndex = -1;
// note if all of the elements in the pivot column are zero or
// negative the problem is unbounded.
for(i = 0; i < numRow - 1; i++) {
element = problemTableau[i][pivotColIndex]; // r value
endElement = problemTableau[i][numCol-1]; // s value
// pivot according to the rule that we want to choose the row
// with smallest s/r ratio see third case
// currently we ignore valuse of r==0 (case 1) and cases where the
// ratio is negative, i.e. either r or s are negative (case 2)
if(element == 0) {
if(debug) {
System.err.println("Division by zero has occurred");
System.err.println("Within the linear program solver");
System.err.println("Ignoring the zero as a potential pivot");
}
} else if ( (element < 0.0) || (endElement < 0.0) ){
if(debug) {
System.err.println("Ignoring cases where element is negative");
System.err.println("The value of element is: " + element);
System.err.println("The value of end Element is: " + endElement);
}
} else {
ratio = endElement/element; // should be s/r
if(debug) {
System.err.println("The value of element is: " + element);
System.err.println("The value of endElement is: " + endElement);
System.err.println("The value of ratio is: " + ratio);
System.err.println("The value of prevRatio is: " + prevRatio);
System.err.println("Value of ratio <= prevRatio is :" +
(ratio <= prevRatio));
}
if(ratio <= prevRatio) {
if(debug) {
System.err.println("updating prevRatio with ratio");
}
prevRatio = ratio;
pivotRowIndex = i;
}
}
}
// if the pivotRowIndex is still -1 then we know the pivotColumn
// has no viable pivot points and the solution is unbounded or
// infeasable (all pivot elements were either zero or negative or
// the right most value was negative (the later shouldn't happen?)
if(pivotRowIndex == -1) {
if(debug) {
System.err.println("UNABLE TO FIND SOLUTION");
System.err.println("The system is infeasable or unbounded");
}
return(Float.POSITIVE_INFINITY);
}
// we now have the pivot row and col all that remains is
// to divide through by this value and subtract the appropriate
// multiple of the pivot row from all other rows to obtain
// a tableau which has a column of all zeros and one 1 in the
// intersection of pivot row and col
// divide through by the pivot value
double pivotValue = problemTableau[pivotRowIndex][pivotColIndex];
if(debug) {
System.err.println("The value of row index is: " + pivotRowIndex);
System.err.println("The value of col index is: " + pivotColIndex);
System.err.println("The value of pivotValue is: " + pivotValue);
}
// divide through by s on the pivot row to obtain a 1 in pivot col
for(i = 0; i < numCol; i++) {
problemTableau[pivotRowIndex][i] =
problemTableau[pivotRowIndex][i] / pivotValue;
}
// subtract appropriate multiple of pivot row from all other rows
// to zero out all rows except the final row and the pivot row
for(i = 0; i < numRow; i++) {
if(i != pivotRowIndex) {
multiplier = problemTableau[i][pivotColIndex];
for(int j=0; j < numCol; j++) {
problemTableau[i][j] = problemTableau[i][j] -
multiplier * problemTableau[pivotRowIndex][j];
}
}
}
}
// case when the element is optimal
}
return(problemTableau[numRow - 1][numCol - 1]);
}
boolean edgeIntersectSphere(BoundingSphere sphere, Point3d start,
Point3d end)
{
double abLenSq, acLenSq, apLenSq, abDotAp, radiusSq;
Vector3d ab = new Vector3d();
Vector3d ap = new Vector3d();
ab.x = end.x - start.x;
ab.y = end.y - start.y;
ab.z = end.z - start.z;
ap.x = sphere.center.x - start.x;
ap.y = sphere.center.y - start.y;
ap.z = sphere.center.z - start.z;
abDotAp = ab.dot(ap);
if(abDotAp < 0.0) {
return false; // line segment points away from sphere.
}
abLenSq = ab.lengthSquared();
acLenSq = abDotAp * abDotAp / abLenSq;
if(acLenSq < abLenSq) {
return false; // C doesn't lies between end points of edge.
}
radiusSq = sphere.radius * sphere.radius;
apLenSq = ap.lengthSquared();
if((apLenSq - acLenSq) <= radiusSq) {
return true;
}
return false;
}
double det2D(Point2d a, Point2d b, Point2d p)
{
return (((p).x - (a).x) * ((a).y - (b).y) +
((a).y - (p).y) * ((a).x - (b).x));
}
// Assume coord is CCW.
boolean pointIntersectPolygon2D(Vector3d normal, Point3d[] coord,
Point3d point)
{
double absNrmX, absNrmY, absNrmZ;
Point2d coord2D[] = new Point2d[coord.length];
Point2d pnt = new Point2d();
int i, j, axis;
// Project 3d points onto 2d plane.
// Note : Area of polygon is not preserve in this projection, but
// it doesn't matter here.
// Find the axis of projection.
absNrmX = Math.abs(normal.x);
absNrmY = Math.abs(normal.y);
absNrmZ = Math.abs(normal.z);
if(absNrmX > absNrmY)
axis = 0;
else
axis = 1;
if(axis == 0) {
if(absNrmX < absNrmZ)
axis = 2;
}
else if(axis == 1) {
if(absNrmY < absNrmZ)
axis = 2;
}
// System.err.println("Normal " + normal + " axis " + axis );
for(i=0; i<coord.length; i++) {
coord2D[i] = new Point2d();
switch (axis) {
case 0:
coord2D[i].x = coord[i].y;
coord2D[i].y = coord[i].z;
break;
case 1:
coord2D[i].x = coord[i].x;
coord2D[i].y = coord[i].z;
break;
case 2:
coord2D[i].x = coord[i].x;
coord2D[i].y = coord[i].y;
break;
}
// System.err.println("i " + i + " u " + uCoor[i] + " v " + vCoor[i]);
}
switch (axis) {
case 0:
pnt.x = point.y;
pnt.y = point.z;
break;
case 1:
pnt.x = point.x;
pnt.y = point.z;
break;
case 2:
pnt.x = point.x;
pnt.y = point.y;
break;
}
// Do determinant test.
for(j=0; j<coord.length; j++) {
if(j<(coord.length-1))
if(det2D(coord2D[j], coord2D[j+1], pnt)>0.0)
;
else
return false;
else
if(det2D(coord2D[j], coord2D[0], pnt)>0.0)
;
else
return false;
}
return true;
}
boolean edgeIntersectPlane(Vector3d normal, Point3d pnt, Point3d start,
Point3d end, Point3d iPnt)
{
Vector3d tempV3d = new Vector3d();
Vector3d direction = new Vector3d();
double pD, pNrmDotrDir, tr;
// Compute plane D.
tempV3d.set(pnt);
pD = normal.dot(tempV3d);
direction.x = end.x - start.x;
direction.y = end.y - start.y;
direction.z = end.z - start.z;
pNrmDotrDir = normal.dot(direction);
// edge is parallel to plane.
if(pNrmDotrDir== 0.0) {
// System.err.println("Edge is parallel to plane.");
return false;
}
tempV3d.set(start);
tr = (pD - normal.dot(tempV3d))/ pNrmDotrDir;
// Edge intersects the plane behind the edge's start.
// or exceed the edge's length.
if((tr < 0.0 ) || (tr > 1.0 )) {
// System.err.println("Edge intersects the plane behind the start or exceed end.");
return false;
}
iPnt.x = start.x + tr * direction.x;
iPnt.y = start.y + tr * direction.y;
iPnt.z = start.z + tr * direction.z;
return true;
}
// Assume coord is CCW.
boolean edgeIntersectPolygon2D(Vector3d normal, Point3d[] coord,
Point3d[] seg)
{
double absNrmX, absNrmY, absNrmZ;
Point2d coord2D[] = new Point2d[coord.length];
Point2d seg2D[] = new Point2d[2];
int i, j, axis;
// Project 3d points onto 2d plane.
// Note : Area of polygon is not preserve in this projection, but
// it doesn't matter here.
// Find the axis of projection.
absNrmX = Math.abs(normal.x);
absNrmY = Math.abs(normal.y);
absNrmZ = Math.abs(normal.z);
if(absNrmX > absNrmY)
axis = 0;
else
axis = 1;
if(axis == 0) {
if(absNrmX < absNrmZ)
axis = 2;
}
else if(axis == 1) {
if(absNrmY < absNrmZ)
axis = 2;
}
// System.err.println("Normal " + normal + " axis " + axis );
for(i=0; i<coord.length; i++) {
coord2D[i] = new Point2d();
switch (axis) {
case 0:
coord2D[i].x = coord[i].y;
coord2D[i].y = coord[i].z;
break;
case 1:
coord2D[i].x = coord[i].x;
coord2D[i].y = coord[i].z;
break;
case 2:
coord2D[i].x = coord[i].x;
coord2D[i].y = coord[i].y;
break;
}
// System.err.println("i " + i + " u " + uCoor[i] + " v " + vCoor[i]);
}
for(i=0; i<2; i++) {
seg2D[i] = new Point2d();
switch (axis) {
case 0:
seg2D[i].x = seg[i].y;
seg2D[i].y = seg[i].z;
break;
case 1:
seg2D[i].x = seg[i].x;
seg2D[i].y = seg[i].z;
break;
case 2:
seg2D[i].x = seg[i].x;
seg2D[i].y = seg[i].y;
break;
}
// System.err.println("i " + i + " u " + uSeg[i] + " v " + vSeg[i]);
}
// Do determinant test.
boolean pntTest[][] = new boolean[2][coord.length];
boolean testFlag;
for(j=0; j<coord.length; j++) {
for(i=0; i<2; i++) {
if(j<(coord.length-1))
pntTest[i][j] = (det2D(coord2D[j], coord2D[j+1], seg2D[i])<0.0);
else
pntTest[i][j] = (det2D(coord2D[j], coord2D[0], seg2D[i])<0.0);
}
if((pntTest[0][j]==false) && (pntTest[1][j]==false))
return false;
}
testFlag = true;
for(i=0; i<coord.length; i++) {
if(pntTest[0][i]==false) {
testFlag = false;
break;
}
}
if(testFlag == true)
return true; // start point is inside polygon.
testFlag = true;
for(i=0; i<coord.length; i++) {
if(pntTest[1][i]==false) {
testFlag = false;
break;
}
}
if(testFlag == true)
return true; // end point is inside polygon.
int cnt = 0;
for(i=0; i<coord.length; i++) {
if(det2D(seg2D[0], seg2D[1], coord2D[i])<0.0)
cnt++;
}
if((cnt==0)||(cnt==coord.length))
return false;
return true;
}
// New stuffs .....
double getCompValue(Point3d v, int i) {
switch (i) {
case 0: return v.x;
case 1: return v.y;
}
// Has to return something, so set the default to z component.
return v.z;
}
double getCompValue(Point3d v0, Point3d v1, int i) {
switch (i) {
case 0: return (v0.x - v1.x);
case 1: return (v0.y - v1.y);
}
// Has to return some, so set the default to z component.
return (v0.z - v1.z);
}
boolean pointInTri(Point3d v0, Point3d u0, Point3d u1, Point3d u2,
Vector3d normal) {
double nAbsX, nAbsY, nAbsZ;
int i0, i1;
// first project onto an axis-aligned plane, that maximizes the area
// of the triangles, compute indices i0, i1.
nAbsX = Math.abs(normal.x);
nAbsY = Math.abs(normal.y);
nAbsZ = Math.abs(normal.z);
if (nAbsX > nAbsY) {
if(nAbsX > nAbsZ) {
i0 = 1; // nAbsX is greatest.
i1 = 2;
}
else {
i0 = 0; // nAbsZ is greatest.
i1 = 1;
}
} else { // nAbsX <= nAbsY
if(nAbsZ > nAbsY) {
i0 = 0; // nAbsZ is greatest.
i1 = 1;
}
else {
i0 = 0; // nAbsY is greatest.
i1 = 2;
}
}
return pointInTri(v0, u0, u1, u2, i0, i1);
}
boolean pointInTri(Point3d v0, Point3d u0, Point3d u1, Point3d u2,
int i0, int i1) {
double a, b, c, d0, d1, d2;
// is T1 completely inside T2 ?
// check if v0 is inside tri(u0,u1,u2)
a = getCompValue(u1, u0, i1);
b = -(getCompValue(u1, u0, i0));
c = -a * getCompValue(u0, i0) - b * getCompValue(u0, i1);
d0 = a * getCompValue(v0, i0) + b * getCompValue(v0, i1) + c;
a = getCompValue(u2, u1, i1);
b = -(getCompValue(u2, u1, i0));
c = -a * getCompValue(u1, i0) - b * getCompValue(u1, i1);
d1 = a * getCompValue(v0, i0) + b * getCompValue(v0, i1) + c;
a = getCompValue(u0, u2, i1);
b = -(getCompValue(u0, u2, i0));
c = -a * getCompValue(u2, i0) - b * getCompValue(u2, i1);
d2 = a * getCompValue(v0, i0) + b * getCompValue(v0, i1) + c;
if(d0*d1>0.0) {
if(d0*d2>0.0) {
return true;
}
}
return false;
}
// this edge to edge test is based on Franlin Antonio's gem:
// "Faster line segment intersection", in Graphics Gems III, pp 199-202
boolean edgeAgainstEdge(Point3d v0, Point3d u0, Point3d u1, double aX, double aY,
int i0, int i1) {
double bX, bY, cX, cY, e, d, f;
bX = getCompValue(u0, u1,i0);
bY = getCompValue(u0, u1, i1);
cX = getCompValue(v0, u0, i0);
cY = getCompValue(v0, u0, i1);
f = aY * bX - aX * bY;
d = bY * cX - bX * cY;
if((f>0 && d>=0 && d<=f) || (f<0 && d<=0 && d>=f)) {
e = aX * cY - aY * cX;
if(f>0) {
if(e>=0 && e<=f)
return true;
}
else {
if(e<=0 && e>=f)
return true;
}
}
return false;
}
boolean edgeAgainstTriEdges(Point3d v0, Point3d v1, Point3d u0,
Point3d u1, Point3d u2, int i0, int i1) {
double aX, aY;
// aX = v1[i0] - v0[i0];
// aY = v1[i1] - v0[i1];
aX = getCompValue(v1, v0, i0);
aY = getCompValue(v1, v0, i1);
// test edge u0, u1 against v0, v1
if(edgeAgainstEdge(v0, u0, u1, aX, aY, i0, i1))
return true;
// test edge u1, u2 against v0, v1
if(edgeAgainstEdge(v0, u1, u2, aX, aY, i0, i1))
return true;
// test edge u2, u0 against v0, v1
if(edgeAgainstEdge(v0, u2, u0, aX, aY, i0, i1))
return true;
return false;
}
boolean coplanarTriTri(Vector3d normal, Point3d v0, Point3d v1, Point3d v2,
Point3d u0, Point3d u1, Point3d u2) {
double nAbsX, nAbsY, nAbsZ;
int i0, i1;
// first project onto an axis-aligned plane, that maximizes the area
// of the triangles, compute indices i0, i1.
nAbsX = Math.abs(normal.x);
nAbsY = Math.abs(normal.y);
nAbsZ = Math.abs(normal.z);
if(nAbsX > nAbsY) {
if(nAbsX > nAbsZ) {
i0 = 1; // nAbsX is greatest.
i1 = 2;
}
else {
i0 = 0; // nAbsZ is greatest.
i1 = 1;
}
}
else { // nAbsX <= nAbsY
if(nAbsZ > nAbsY) {
i0 = 0; // nAbsZ is greatest.
i1 = 1;
}
else {
i0 = 0; // nAbsY is greatest.
i1 = 2;
}
}
// test all edges of triangle 1 against the edges of triangle 2
if(edgeAgainstTriEdges(v0, v1, u0, u1, u2, i0, i1))
return true;
if(edgeAgainstTriEdges(v1, v2, u0, u1, u2, i0, i1))
return true;
if(edgeAgainstTriEdges(v2, v0, u0, u1, u2, i0, i1))
return true;
// finally, test if tri1 is totally contained in tri2 or vice versa.
if(pointInTri(v0, u0, u1, u2, i0, i1))
return true;
if(pointInTri(u0, v0, v1, v2, i0, i1))
return true;
return false;
}
boolean intersectTriPnt(Point3d v0, Point3d v1, Point3d v2, Point3d u) {
Vector3d e1 = new Vector3d();
Vector3d e2 = new Vector3d();
Vector3d n1 = new Vector3d();
Vector3d tempV3d = new Vector3d();
double d1, du;
// compute plane equation of triange(coord1)
e1.x = v1.x - v0.x;
e1.y = v1.y - v0.y;
e1.z = v1.z - v0.z;
e2.x = v2.x - v0.x;
e2.y = v2.y - v0.y;
e2.z = v2.z - v0.z;
n1.cross(e1,e2);
if(n1.length() == 0.0) {
// System.err.println("(1) Degenerate triangle.");
return false; // Degenerate triangle.
}
tempV3d.set(v0);
d1 = - n1.dot(tempV3d); // plane equation 1: n1.x + d1 = 0
// put u to compute signed distance to the plane.
tempV3d.set(u);
du = n1.dot(tempV3d) + d1;
// coplanarity robustness check
if(Math.abs(du)<EPS) du = 0.0;
// no intersection occurs
if(du != 0.0) {
return false;
}
double nAbsX, nAbsY, nAbsZ;
int i0, i1;
// first project onto an axis-aligned plane, that maximizes the area
// of the triangles, compute indices i0, i1.
nAbsX = Math.abs(n1.x);
nAbsY = Math.abs(n1.y);
nAbsZ = Math.abs(n1.z);
if(nAbsX > nAbsY) {
if(nAbsX > nAbsZ) {
i0 = 1; // nAbsX is greatest.
i1 = 2;
}
else {
i0 = 0; // nAbsZ is greatest.
i1 = 1;
}
}
else { // nAbsX <= nAbsY
if(nAbsZ > nAbsY) {
i0 = 0; // nAbsZ is greatest.
i1 = 1;
}
else {
i0 = 0; // nAbsY is greatest.
i1 = 2;
}
}
// finally, test if u is totally contained in tri.
if(pointInTri(u, v0, v1, v2, i0, i1)) {
return true;
}
return false;
}
/**
* Return flag indicating whether two triangles intersect. This
* uses Tomas Moller's code for fast triangle-triangle
* intersection from his "Real-Time Rendering" book.
*
* The code is now divisionless. It tests for separating by planes
* parallel to either triangle. If neither separate the
* triangles, then two cases are considered. First case is if the
* normals to the triangles are parallel. In that case, the
* triangles are coplanar and a sequence of tests are made to see
* if edges of each triangle intersect the other triangle. If the
* normals are not parallel, then the two triangles can intersect
* only on the line of intersection of the two planes. The
* intervals of intersection of the triangles with the line of
* intersection of the two planes are computed and tested for
* overlap.
*/
boolean intersectTriTri(Point3d v0, Point3d v1, Point3d v2,
Point3d u0, Point3d u1, Point3d u2) {
// System.err.println("In intersectTriTri ...");
Vector3d e1 = new Vector3d();
Vector3d e2 = new Vector3d();
Vector3d n1 = new Vector3d();
Vector3d n2 = new Vector3d();
Vector3d tempV3d = new Vector3d();
double d1, d2;
double du0, du1, du2, dv0, dv1, dv2;
double du0du1, du0du2, dv0dv1, dv0dv2;
int index;
double vp0=0.0, vp1=0.0, vp2=0.0;
double up0=0.0, up1=0.0, up2=0.0;
double bb, cc, max;
// compute plane equation of triange(coord1)
e1.x = v1.x - v0.x;
e1.y = v1.y - v0.y;
e1.z = v1.z - v0.z;
e2.x = v2.x - v0.x;
e2.y = v2.y - v0.y;
e2.z = v2.z - v0.z;
n1.cross(e1,e2);
if(n1.length() == 0.0) {
// System.err.println("(1) Degenerate triangle.");
return false; // Degenerate triangle.
}
tempV3d.set(v0);
d1 = - n1.dot(tempV3d); // plane equation 1: n1.x + d1 = 0
// put u0, u1, and u2 into plane equation 1
// to compute signed distance to the plane.
tempV3d.set(u0);
du0 = n1.dot(tempV3d) + d1;
tempV3d.set(u1);
du1 = n1.dot(tempV3d) + d1;
tempV3d.set(u2);
du2 = n1.dot(tempV3d) + d1;
// coplanarity robustness check
if(Math.abs(du0)<EPS) du0 = 0.0;
if(Math.abs(du1)<EPS) du1 = 0.0;
if(Math.abs(du2)<EPS) du2 = 0.0;
du0du1 = du0 * du1;
du0du2 = du0 * du2;
// same sign on all of them + not equal 0 ?
// no intersection occurs
if(du0du1>0.0 && du0du2>0.0) {
// System.err.println("In intersectTriTri : du0du1>0.0 && du0du2>0.0");
return false;
}
// compute plane of triangle(coord2)
e1.x = u1.x - u0.x;
e1.y = u1.y - u0.y;
e1.z = u1.z - u0.z;
e2.x = u2.x - u0.x;
e2.y = u2.y - u0.y;
e2.z = u2.z - u0.z;
n2.cross(e1,e2);
if(n2.length() == 0.0) {
// System.err.println("(2) Degenerate triangle.");
return false; // Degenerate triangle.
}
tempV3d.set(u0);
d2 = - n2.dot(tempV3d); // plane equation 2: n2.x + d2 = 0
// put v0, v1, and v2 into plane equation 2
// to compute signed distance to the plane.
tempV3d.set(v0);
dv0 = n2.dot(tempV3d) + d2;
tempV3d.set(v1);
dv1 = n2.dot(tempV3d) + d2;
tempV3d.set(v2);
dv2 = n2.dot(tempV3d) + d2;
// coplanarity robustness check
if(Math.abs(dv0)<EPS) dv0 = 0.0;
if(Math.abs(dv1)<EPS) dv1 = 0.0;
if(Math.abs(dv2)<EPS) dv2 = 0.0;
dv0dv1 = dv0 * dv1;
dv0dv2 = dv0 * dv2;
// same sign on all of them + not equal 0 ?
// no intersection occurs
if(dv0dv1>0.0 && dv0dv2>0.0) {
// System.err.println("In intersectTriTri : dv0dv1>0.0 && dv0dv2>0.0");
return false;
}
// compute direction of intersection line.
tempV3d.cross(n1, n2);
// compute and index to the largest component of tempV3d.
max = Math.abs(tempV3d.x);
index = 0;
bb = Math.abs(tempV3d.y);
cc = Math.abs(tempV3d.z);
if(bb>max) {
max=bb;
index=1;
}
if(cc>max) {
max=cc;
index=2;
}
// this is the simplified projection onto L.
switch (index) {
case 0:
vp0 = v0.x;
vp1 = v1.x;
vp2 = v2.x;
up0 = u0.x;
up1 = u1.x;
up2 = u2.x;
break;
case 1:
vp0 = v0.y;
vp1 = v1.y;
vp2 = v2.y;
up0 = u0.y;
up1 = u1.y;
up2 = u2.y;
break;
case 2:
vp0 = v0.z;
vp1 = v1.z;
vp2 = v2.z;
up0 = u0.z;
up1 = u1.z;
up2 = u2.z;
break;
}
// compute intereval for triangle 1.
double a=0.0, b=0.0, c=0.0, x0=0.0, x1=0.0;
if(dv0dv1>0.0) {
// here we know that dv0dv2 <= 0.0 that is dv0 and dv1 are on the same side,
// dv2 on the other side or on the plane.
a = vp2; b = (vp0 - vp2) * dv2; c = (vp1 - vp2) * dv2;
x0 = dv2 - dv0; x1 = dv2 - dv1;
}
else if(dv0dv2>0.0) {
// here we know that dv0dv1<=0.0
a = vp1; b = (vp0 - vp1) * dv1; c = (vp2 - vp1) * dv1;
x0 = dv1 - dv0; x1 = dv1 - dv2;
}
else if((dv1*dv2>0.0) || (dv0 != 0.0)) {
// here we know that dv0vd1<=0.0 or that dv0!=0.0
a = vp0; b = (vp1 - vp0) * dv0; c = (vp2 - vp0) * dv0;
x0 = dv0 - dv1; x1 = dv0 - dv2;
}
else if(dv1 != 0.0) {
a = vp1; b = (vp0 - vp1) * dv1; c = (vp2 - vp1) * dv1;
x0 = dv1 - dv0; x1 = dv1 - dv2;
}
else if(dv2 != 0.0) {
a = vp2; b = (vp0 - vp2) * dv2; c = (vp1 - vp2) * dv2;
x0 = dv2 - dv0; x1 = dv2 - dv1;
}
else {
// triangles are coplanar
boolean toreturn = coplanarTriTri(n1, v0, v1, v2, u0, u1, u2);
return toreturn;
}
// compute intereval for triangle 2.
double d=0.0, e=0.0, f=0.0, y0=0.0, y1=0.0;
if(du0du1>0.0) {
// here we know that du0du2 <= 0.0 that is du0 and du1 are on the same side,
// du2 on the other side or on the plane.
d = up2; e = (up0 - up2) * du2; f = (up1 - up2) * du2;
y0 = du2 - du0; y1 = du2 - du1;
}
else if(du0du2>0.0) {
// here we know that du0du1<=0.0
d = up1; e = (up0 - up1) * du1; f = (up2 - up1) * du1;
y0 = du1 - du0; y1 = du1 - du2;
}
else if((du1*du2>0.0) || (du0 != 0.0)) {
// here we know that du0du1<=0.0 or that D0!=0.0
d = up0; e = (up1 - up0) * du0; f = (up2 - up0) * du0;
y0 = du0 - du1; y1 = du0 - du2;
}
else if(du1 != 0.0) {
d = up1; e = (up0 - up1) * du1; f = (up2 - up1) * du1;
y0 = du1 - du0; y1 = du1 - du2;
}
else if(du2 != 0.0) {
d = up2; e = (up0 - up2) * du2; f = (up1 - up2) * du2;
y0 = du2 - du0; y1 = du2 - du1;
}
else {
// triangles are coplanar
// System.err.println("In intersectTriTri : coplanarTriTri test 2");
boolean toreturn = coplanarTriTri(n2, v0, v1, v2, u0, u1, u2);
return toreturn;
}
double xx, yy, xxyy, tmp, isect1S, isect1E, isect2S, isect2E;
xx = x0 * x1;
yy = y0 * y1;
xxyy = xx * yy;
tmp = a * xxyy;
isect1S = tmp + b * x1 * yy;
isect1E = tmp + c * x0 * yy;
tmp = d * xxyy;
isect2S = tmp + e * y1 * xx;
isect2E = tmp + f * y0 * xx;
// sort so that isect1S <= isect1E
if(isect1S > isect1E) {
tmp = isect1S;
isect1S = isect1E;
isect1E = tmp;
}
// sort so that isect2S <= isect2E
if(isect2S > isect2E) {
tmp = isect2S;
isect2S = isect2E;
isect2E = tmp;
}
if(isect1E<isect2S || isect2E<isect1S) {
// System.err.println("In intersectTriTri :isect1E<isect2S || isect2E<isect1S");
// System.err.println("In intersectTriTri : return false");
return false;
}
// System.err.println("In intersectTriTri : return true");
return true;
}
boolean intersectPolygon(Point3d coord1[], Point3d coord2[]) {
int i, j;
Vector3d vec0 = new Vector3d(); // Edge vector from point 0 to point 1;
Vector3d vec1 = new Vector3d(); // Edge vector from point 0 to point 2 or 3;
Vector3d pNrm = new Vector3d();
boolean epFlag;
// compute plane normal for coord1.
for(i=0; i<coord1.length-1;) {
vec0.x = coord1[i+1].x - coord1[i].x;
vec0.y = coord1[i+1].y - coord1[i].y;
vec0.z = coord1[i+1].z - coord1[i++].z;
if(vec0.length() > 0.0)
break;
}
for(j=i; j<coord1.length-1; j++) {
vec1.x = coord1[j+1].x - coord1[j].x;
vec1.y = coord1[j+1].y - coord1[j].y;
vec1.z = coord1[j+1].z - coord1[j].z;
if(vec1.length() > 0.0)
break;
}
if(j == (coord1.length-1)) {
// System.err.println("(1) Degenerate polygon.");
return false; // Degenerate polygon.
}
/*
for(i=0; i<coord1.length; i++)
System.err.println("coord1 P" + i + " " + coord1[i]);
for(i=0; i<coord2.length; i++)
System.err.println("coord2 P" + i + " " + coord2[i]);
*/
pNrm.cross(vec0,vec1);
if(pNrm.length() == 0.0) {
// System.err.println("(2) Degenerate polygon.");
return false; // Degenerate polygon.
}
j = 0;
Point3d seg[] = new Point3d[2];
seg[0] = new Point3d();
seg[1] = new Point3d();
for(i=0; i<coord2.length; i++) {
if(i < (coord2.length-1))
epFlag = edgeIntersectPlane(pNrm, coord1[0], coord2[i],
coord2[i+1], seg[j]);
else
epFlag = edgeIntersectPlane(pNrm, coord1[0], coord2[i],
coord2[0], seg[j]);
if (epFlag) {
if(++j>1) {
break;
}
}
}
if (j==0) {
return false;
}
if (coord2.length < 3) {
boolean toreturn = pointIntersectPolygon2D(pNrm, coord1, seg[0]);
return toreturn;
} else {
boolean toreturn = edgeIntersectPolygon2D(pNrm, coord1, seg);
return toreturn;
}
}
/**
* Return true if triangle or quad intersects with ray and the
* distance is stored in dist[0] and the intersect point in iPnt
* (if iPnt is not null).
*/
boolean intersectRay(Point3d coordinates[], PickRay ray, double dist[],
Point3d iPnt) {
return intersectRayOrSegment(coordinates, ray.direction, ray.origin,
dist, iPnt, false);
}
/**
* Return true if triangle or quad intersects with segment and
* the distance is stored in dist[0].
*/
boolean intersectSegment( Point3d coordinates[], Point3d start, Point3d end,
double dist[], Point3d iPnt ) {
boolean result;
Vector3d direction = new Vector3d();
direction.x = end.x - start.x;
direction.y = end.y - start.y;
direction.z = end.z - start.z;
result = intersectRayOrSegment(coordinates, direction, start, dist, iPnt, true);
return result;
}
/**
* Return true if triangle or quad intersects with ray and the distance is
* stored in pr.
*/
boolean intersectRayOrSegment(Point3d coordinates[],
Vector3d direction, Point3d origin,
double dist[], Point3d iPnt, boolean isSegment) {
Vector3d vec0, vec1, pNrm, tempV3d;
vec0 = new Vector3d();
vec1 = new Vector3d();
pNrm = new Vector3d();
double absNrmX, absNrmY, absNrmZ, pD = 0.0;
double pNrmDotrDir = 0.0;
boolean isIntersect = false;
int i, j, k=0, l = 0;
// Compute plane normal.
for (i=0; i<coordinates.length; i++) {
if (i != coordinates.length-1) {
l = i+1;
} else {
l = 0;
}
vec0.x = coordinates[l].x - coordinates[i].x;
vec0.y = coordinates[l].y - coordinates[i].y;
vec0.z = coordinates[l].z - coordinates[i].z;
if (vec0.length() > 0.0) {
break;
}
}
for (j=l; j<coordinates.length; j++) {
if (j != coordinates.length-1) {
k = j+1;
} else {
k = 0;
}
vec1.x = coordinates[k].x - coordinates[j].x;
vec1.y = coordinates[k].y - coordinates[j].y;
vec1.z = coordinates[k].z - coordinates[j].z;
if (vec1.length() > 0.0) {
break;
}
}
pNrm.cross(vec0,vec1);
if ((vec1.length() == 0) || (pNrm.length() == 0)) {
// degenerate to line if vec0.length() == 0
// or vec0.length > 0 and vec0 parallel to vec1
k = (l == 0 ? coordinates.length-1: l-1);
isIntersect = intersectLineAndRay(coordinates[l],
coordinates[k],
origin,
direction,
dist,
iPnt);
// put the Vectors on the freelist
return isIntersect;
}
// It is possible that Quad is degenerate to Triangle
// at this point
pNrmDotrDir = pNrm.dot(direction);
// Ray is parallel to plane.
if (pNrmDotrDir == 0.0) {
// Ray is parallel to plane
// Check line/triangle intersection on plane.
for (i=0; i < coordinates.length ;i++) {
if (i != coordinates.length-1) {
k = i+1;
} else {
k = 0;
}
if (intersectLineAndRay(coordinates[i],
coordinates[k],
origin,
direction,
dist,
iPnt)) {
isIntersect = true;
break;
}
}
return isIntersect;
}
// Plane equation: (p - p0)*pNrm = 0 or p*pNrm = pD;
tempV3d = new Vector3d();
tempV3d.set(coordinates[0]);
pD = pNrm.dot(tempV3d);
tempV3d.set(origin);
// Substitute Ray equation:
// p = origin + pi.distance*direction
// into the above Plane equation
dist[0] = (pD - pNrm.dot(tempV3d))/ pNrmDotrDir;
// Ray intersects the plane behind the ray's origin.
if ((dist[0] < -EPS ) ||
(isSegment && (dist[0] > 1.0+EPS))) {
// Ray intersects the plane behind the ray's origin
// or intersect point not fall in Segment
return false;
}
// Now, one thing for sure the ray intersect the plane.
// Find the intersection point.
if (iPnt == null) {
iPnt = new Point3d();
}
iPnt.x = origin.x + direction.x * dist[0];
iPnt.y = origin.y + direction.y * dist[0];
iPnt.z = origin.z + direction.z * dist[0];
// Project 3d points onto 2d plane
// Find the axis so that area of projection is maximize.
absNrmX = Math.abs(pNrm.x);
absNrmY = Math.abs(pNrm.y);
absNrmZ = Math.abs(pNrm.z);
// All sign of (y - y0) (x1 - x0) - (x - x0) (y1 - y0)
// must agree.
double sign, t, lastSign = 0;
Point3d p0 = coordinates[coordinates.length-1];
Point3d p1 = coordinates[0];
isIntersect = true;
if (absNrmX > absNrmY) {
if (absNrmX < absNrmZ) {
for (i=0; i < coordinates.length; i++) {
p0 = coordinates[i];
p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
sign = (iPnt.y - p0.y)*(p1.x - p0.x) -
(iPnt.x - p0.x)*(p1.y - p0.y);
if (isNonZero(sign)) {
if (sign*lastSign < 0) {
isIntersect = false;
break;
}
lastSign = sign;
} else { // point on line, check inside interval
t = p1.y - p0.y;
if (isNonZero(t)) {
t = (iPnt.y - p0.y)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
t = p1.x - p0.x;
if (isNonZero(t)) {
t = (iPnt.x - p0.x)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
// Ignore degenerate line=>point happen when Quad => Triangle.
// Note that by next round sign*lastSign = 0 so it will
// not pass the interest test. This should only happen once in the
// loop because we already check for degenerate geometry before.
}
}
}
}
} else {
for (i=0; i<coordinates.length; i++) {
p0 = coordinates[i];
p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
sign = (iPnt.y - p0.y)*(p1.z - p0.z) -
(iPnt.z - p0.z)*(p1.y - p0.y);
if (isNonZero(sign)) {
if (sign*lastSign < 0) {
isIntersect = false;
break;
}
lastSign = sign;
} else { // point on line, check inside interval
t = p1.y - p0.y;
if (isNonZero(t)) {
t = (iPnt.y - p0.y)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
t = p1.z - p0.z;
if (isNonZero(t)) {
t = (iPnt.z - p0.z)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
//degenerate line=>point
}
}
}
}
}
} else {
if (absNrmY < absNrmZ) {
for (i=0; i<coordinates.length; i++) {
p0 = coordinates[i];
p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
sign = (iPnt.y - p0.y)*(p1.x - p0.x) -
(iPnt.x - p0.x)*(p1.y - p0.y);
if (isNonZero(sign)) {
if (sign*lastSign < 0) {
isIntersect = false;
break;
}
lastSign = sign;
} else { // point on line, check inside interval
t = p1.y - p0.y;
if (isNonZero(t)) {
t = (iPnt.y - p0.y)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
t = p1.x - p0.x;
if (isNonZero(t)) {
t = (iPnt.x - p0.x)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
//degenerate line=>point
}
}
}
}
} else {
for (i=0; i<coordinates.length; i++) {
p0 = coordinates[i];
p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
sign = (iPnt.x - p0.x)*(p1.z - p0.z) -
(iPnt.z - p0.z)*(p1.x - p0.x);
if (isNonZero(sign)) {
if (sign*lastSign < 0) {
isIntersect = false;
break;
}
lastSign = sign;
} else { // point on line, check inside interval
t = p1.x - p0.x;
if (isNonZero(t)) {
t = (iPnt.x - p0.x)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
t = p1.z - p0.z;
if (isNonZero(t)) {
t = (iPnt.z - p0.z)/t;
isIntersect = ((t > -EPS) && (t < 1+EPS));
break;
} else {
//degenerate line=>point
}
}
}
}
}
}
if (isIntersect) {
dist[0] *= direction.length();
}
return isIntersect;
}
static final boolean isNonZero(double v) {
return ((v > EPS) || (v < -EPS));
}
/**
* Return true if point is on the inside of halfspace test. The
* halfspace is partition by the plane of triangle or quad.
*/
boolean inside( Point3d coordinates[], PickPoint point, int ccw ) {
Vector3d vec0 = new Vector3d(); // Edge vector from point 0 to point 1;
Vector3d vec1 = new Vector3d(); // Edge vector from point 0 to point 2 or 3;
Vector3d pNrm = new Vector3d();
double pD = 0.0;
Vector3d tempV3d = new Vector3d();
int i, j;
// Compute plane normal.
for(i=0; i<coordinates.length-1;) {
vec0.x = coordinates[i+1].x - coordinates[i].x;
vec0.y = coordinates[i+1].y - coordinates[i].y;
vec0.z = coordinates[i+1].z - coordinates[i++].z;
if(vec0.length() > 0.0)
break;
}
for(j=i; j<coordinates.length-1; j++) {
vec1.x = coordinates[j+1].x - coordinates[j].x;
vec1.y = coordinates[j+1].y - coordinates[j].y;
vec1.z = coordinates[j+1].z - coordinates[j].z;
if(vec1.length() > 0.0)
break;
}
if(j == (coordinates.length-1)) {
// System.err.println("(1) Degenerate polygon.");
return false; // Degenerate polygon.
}
/*
System.err.println("Ray orgin : " + ray.origin + " dir " + ray.direction);
System.err.println("Triangle/Quad :");
for(i=0; i<coordinates.length; i++)
System.err.println("P" + i + " " + coordinates[i]);
*/
if( ccw == 0x1)
pNrm.cross(vec0,vec1);
else
pNrm.cross(vec1,vec0);
if(pNrm.length() == 0.0) {
// System.err.println("(2) Degenerate polygon.");
return false; // Degenerate polygon.
}
// Compute plane D.
tempV3d.set(coordinates[0]);
pD = pNrm.dot(tempV3d);
tempV3d.set(point.location);
return ((pD - pNrm.dot(tempV3d)) <= 0);
}
boolean intersectPntAndPnt( Point3d pnt1, Point3d pnt2 ) {
return ((pnt1.x == pnt2.x) &&
(pnt1.y == pnt2.y) &&
(pnt1.z == pnt2.z));
}
boolean intersectPntAndRay(Point3d pnt, Point3d ori, Vector3d dir,
double dist[]) {
int flag = 0;
double temp;
if(dir.x != 0.0) {
flag = 0;
dist[0] = (pnt.x - ori.x)/dir.x;
}
else if(dir.y != 0.0) {
if(pnt.x != ori.x)
return false;
flag = 1;
dist[0] = (pnt.y - ori.y)/dir.y;
}
else if(dir.z != 0.0) {
if((pnt.x != ori.x)||(pnt.y != ori.y))
return false;
flag = 2;
dist[0] = (pnt.z - ori.z)/dir.z;
}
else
return false;
if(dist[0] < 0.0)
return false;
if(flag == 0) {
temp = ori.y + dist[0] * dir.y;
if((pnt.y < (temp - EPS)) || (pnt.y > (temp + EPS)))
return false;
}
if(flag < 2) {
temp = ori.z + dist[0] * dir.z;
if((pnt.z < (temp - EPS)) || (pnt.z > (temp + EPS)))
return false;
}
return true;
}
boolean intersectLineAndRay(Point3d start, Point3d end,
Point3d ori, Vector3d dir, double dist[],
Point3d iPnt) {
double m00, m01, m10, m11;
double mInv00, mInv01, mInv10, mInv11;
double dmt, t, s, tmp1, tmp2;
Vector3d lDir;
// System.err.println("GeometryArrayRetained : intersectLineAndRay");
// System.err.println("start " + start + " end " + end );
// System.err.println("ori " + ori + " dir " + dir);
lDir = new Vector3d();
lDir.x = (end.x - start.x);
lDir.y = (end.y - start.y);
lDir.z = (end.z - start.z);
m00 = lDir.x;
m01 = -dir.x;
m10 = lDir.y;
m11 = -dir.y;
// Get the determinant.
dmt = (m00 * m11) - (m10 * m01);
if (dmt==0.0) { // No solution, check degenerate line
boolean isIntersect = false;
if ((lDir.x == 0) && (lDir.y == 0) && (lDir.z == 0)) {
isIntersect = intersectPntAndRay(start, ori, dir, dist);
if (isIntersect && (iPnt != null)) {
iPnt.set(start);
}
}
return isIntersect;
}
// Find the inverse.
tmp1 = 1/dmt;
mInv00 = tmp1 * m11;
mInv01 = tmp1 * (-m01);
mInv10 = tmp1 * (-m10);
mInv11 = tmp1 * m00;
tmp1 = ori.x - start.x;
tmp2 = ori.y - start.y;
t = mInv00 * tmp1 + mInv01 * tmp2;
s = mInv10 * tmp1 + mInv11 * tmp2;
if(s<0.0) { // Before the origin of ray.
// System.err.println("Before the origin of ray " + s);
return false;
}
if((t<0)||(t>1.0)) {// Before or after the end points of line.
// System.err.println("Before or after the end points of line. " + t);
return false;
}
tmp1 = ori.z + s * dir.z;
tmp2 = start.z + t * lDir.z;
if((tmp1 < (tmp2 - EPS)) || (tmp1 > (tmp2 + EPS))) {
// System.err.println("No intersection : tmp1 " + tmp1 + " tmp2 " + tmp2);
return false;
}
dist[0] = s;
if (iPnt != null) {
// compute point of intersection.
iPnt.x = ori.x + dir.x * dist[0];
iPnt.y = ori.y + dir.y * dist[0];
iPnt.z = ori.z + dir.z * dist[0];
}
// System.err.println("Intersected : tmp1 " + tmp1 + " tmp2 " + tmp2);
return true;
}
/**
Return true if triangle or quad intersects with cylinder. The
distance is stored in dist.
*/
boolean intersectCylinder(Point3d coordinates[], PickCylinder cyl,
double dist[], Point3d iPnt) {
Point3d origin = new Point3d();
Point3d end = new Point3d();
Vector3d direction = new Vector3d();
Point3d iPnt1 = new Point3d();
Vector3d originToIpnt = new Vector3d();
if (iPnt == null) {
iPnt = new Point3d();
}
// Get cylinder information
cyl.getOrigin (origin);
cyl.getDirection (direction);
double radius = cyl.getRadius ();
if (cyl instanceof PickCylinderSegment) {
((PickCylinderSegment)cyl).getEnd (end);
}
// If the ray intersects, we're good (do not do this if we only have
// a segment
if (coordinates.length > 2) {
if (cyl instanceof PickCylinderRay) {
if (intersectRay(coordinates,
new PickRay(origin, direction),
dist, iPnt)) {
return true;
}
}
else {
if (intersectSegment(coordinates, origin, end, dist, iPnt)) {
return true;
}
}
}
// Ray doesn't intersect, check distance to edges
double sqDistToEdge;
int j;
for (int i=0; i<coordinates.length;i++) {
j = (i < coordinates.length-1 ? i+1: 0);
if (cyl instanceof PickCylinderSegment) {
sqDistToEdge =
Utils.segmentToSegment(origin, end,
coordinates[i], coordinates[j],
iPnt1, iPnt, null);
}
else {
sqDistToEdge =
Utils.rayToSegment(origin, direction,
coordinates[i], coordinates[j],
iPnt1, iPnt, null);
}
if (sqDistToEdge <= radius*radius) {
originToIpnt.sub (iPnt1, origin);
dist[0] = originToIpnt.length();
return true;
}
}
return false;
}
/**
Return true if triangle or quad intersects with cone. The
distance is stored in dist.
*/
boolean intersectCone(Point3d coordinates[], PickCone cone,
double[] dist, Point3d iPnt) {
Point3d origin = new Point3d();
Point3d end = new Point3d();
Vector3d direction = new Vector3d();
Vector3d originToIpnt = new Vector3d();
double distance;
Point3d iPnt1 = new Point3d();
if (iPnt == null) {
iPnt = new Point3d();
}
// Get cone information
cone.getOrigin (origin);
cone.getDirection (direction);
double radius;
if (cone instanceof PickConeSegment) {
((PickConeSegment)cone).getEnd (end);
}
// If the ray intersects, we're good (do not do this if we only have
// a segment
if (coordinates.length > 2) {
if (cone instanceof PickConeRay) {
if (intersectRay(coordinates,
new PickRay (origin, direction),
dist, iPnt)) {
return true;
}
}
else {
if (intersectSegment(coordinates, origin, end, dist, iPnt)) {
return true;
}
}
}
// Ray doesn't intersect, check distance to edges
double sqDistToEdge;
int j = 0;
for (int i=0; i<coordinates.length;i++) {
j = (i < coordinates.length-1 ? i+1: 0);
if (cone instanceof PickConeSegment) {
sqDistToEdge =
Utils.segmentToSegment (origin, end,
coordinates[i], coordinates[j],
iPnt1, iPnt, null);
}
else {
sqDistToEdge =
Utils.rayToSegment (origin, direction,
coordinates[i], coordinates[j],
iPnt1, iPnt, null);
}
originToIpnt.sub(iPnt1, origin);
distance = originToIpnt.length();
radius = Math.tan (cone.getSpreadAngle()) * distance;
if (sqDistToEdge <= radius*radius) {
// System.err.println ("intersectCone: edge "+i+" intersected");
dist[0] = distance;
return true;
}
}
return false;
}
/**
Return true if point intersects with cylinder and the distance is
stored in dist.
*/
boolean intersectCylinder(Point3d pt, PickCylinder cyl,
double[] dist) {
Point3d origin = new Point3d();
Point3d end = new Point3d();
Vector3d direction = new Vector3d();
Point3d iPnt = new Point3d();
Vector3d originToIpnt = new Vector3d();
// Get cylinder information
cyl.getOrigin (origin);
cyl.getDirection (direction);
double radius = cyl.getRadius ();
double sqDist;
if (cyl instanceof PickCylinderSegment) {
((PickCylinderSegment)cyl).getEnd (end);
sqDist = Utils.ptToSegSquare(pt, origin, end, iPnt);
}
else {
sqDist = Utils.ptToRaySquare(pt, origin, direction, iPnt);
}
if (sqDist <= radius*radius) {
originToIpnt.sub (iPnt, origin);
dist[0] = originToIpnt.length();
return true;
}
return false;
}
/**
Return true if point intersects with cone and the
distance is stored in pi.
*/
boolean intersectCone(Point3d pt, PickCone cone, double[] dist)
{
Point3d origin = new Point3d();
Point3d end = new Point3d();
Vector3d direction = new Vector3d();
Point3d iPnt = new Point3d();
Vector3d originToIpnt = new Vector3d();
// Get cone information
cone.getOrigin (origin);
cone.getDirection (direction);
double radius;
double distance;
double sqDist;
if (cone instanceof PickConeSegment) {
((PickConeSegment)cone).getEnd (end);
sqDist = Utils.ptToSegSquare(pt, origin, end, iPnt);
}
else {
sqDist = Utils.ptToRaySquare(pt, origin, direction, iPnt);
}
originToIpnt.sub(iPnt, origin);
distance = originToIpnt.length();
radius = Math.tan (cone.getSpreadAngle()) * distance;
if (sqDist <= radius*radius) {
dist[0] = distance;
return true;
}
return false;
}
void setCoordRefBuffer(J3DBuffer coords) {
if (coords != null) {
switch (coords.bufferType) {
case FLOAT:
assert ((FloatBuffer)coords.getROBuffer()).isDirect();
break;
case DOUBLE:
assert ((DoubleBuffer)coords.getROBuffer()).isDirect();
break;
case NULL:
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray115"));
default:
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (3 * idx.maxCoordIndex >= coords.getROBuffer().limit()) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
} else if (coords.getROBuffer().limit() < (3*(initialCoordIndex+validVertexCount))) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
}
// lock the geometry and start to do real work
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
coordRefBuffer = coords;
if(coords == null) {
floatBufferRefCoords = null;
doubleBufferRefCoords = null;
// XXXX: if not mix java array with nio buffer
// vertexType can be used as vertexTypeBuffer
vertexType &= ~PD;
vertexType &= ~PF;
}else {
switch (coords.bufferType) {
case FLOAT:
floatBufferRefCoords = (FloatBuffer)coords.getROBuffer();
doubleBufferRefCoords = null;
vertexType |= PF;
vertexType &= ~PD;
break;
case DOUBLE:
floatBufferRefCoords = null;
doubleBufferRefCoords = (DoubleBuffer)coords.getROBuffer();
vertexType |= PD;
vertexType &= ~PF;
break;
default:
break;
}
}
// need not call setupMirrorVertexPointer() since
// we are not going to set mirror in NIO buffer case
// XXXX: if we need to mix java array with buffer,
// we may need to consider setupMirrorVertexPointer()
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && source != null) {
if (isLive) {
processCoordsChanged((coords == null));
sendDataChangedMessage(true);
} else {
boundsDirty = true;
}
}
}
J3DBuffer getCoordRefBuffer() {
return coordRefBuffer;
}
void setCoordRefFloat(float[] coords) {
// If non-null coordinate and vertType is either defined
// to be something other than PF, then issue an error
if (coords != null) {
if ((vertexType & VERTEX_DEFINED) != 0 &&
(vertexType & VERTEX_DEFINED) != PF) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (3 * idx.maxCoordIndex >= coords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
} else if (coords.length < 3 * (initialCoordIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
floatRefCoords = coords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (coords == null)
vertexType &= ~PF;
else
vertexType |= PF;
}
else {
setupMirrorVertexPointer(PF);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && source != null) {
if (isLive) {
processCoordsChanged(coords == null);
sendDataChangedMessage(true);
} else {
boundsDirty = true;
}
}
}
float[] getCoordRefFloat() {
return floatRefCoords;
}
void setCoordRefDouble(double[] coords) {
if (coords != null) {
if ((vertexType & VERTEX_DEFINED) != 0 &&
(vertexType & VERTEX_DEFINED) != PD) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (3 * idx.maxCoordIndex >= coords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
} else if (coords.length < 3 * (initialCoordIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
doubleRefCoords = coords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (coords == null)
vertexType &= ~PD;
else
vertexType |= PD;
}
else {
setupMirrorVertexPointer(PD);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && source != null) {
if (isLive) {
processCoordsChanged(coords == null);
sendDataChangedMessage(true);
} else {
boundsDirty = true;
}
}
}
double[] getCoordRefDouble() {
return doubleRefCoords;
}
void setCoordRef3f(Point3f[] coords) {
if (coords != null) {
if ((vertexType & VERTEX_DEFINED) != 0 &&
(vertexType & VERTEX_DEFINED) != P3F) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxCoordIndex >= coords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
} else if (coords.length < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
p3fRefCoords = coords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (coords == null)
vertexType &= ~P3F;
else
vertexType |= P3F;
}
else {
setupMirrorVertexPointer(P3F);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && source != null) {
if (isLive) {
processCoordsChanged(coords == null);
sendDataChangedMessage(true);
} else {
boundsDirty = true;
}
}
}
Point3f[] getCoordRef3f() {
return p3fRefCoords;
}
void setCoordRef3d(Point3d[] coords) {
if (coords != null) {
if ((vertexType & VERTEX_DEFINED) != 0 &&
(vertexType & VERTEX_DEFINED) != P3D) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxCoordIndex >= coords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
} else if (coords.length < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
p3dRefCoords = coords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (coords == null)
vertexType &= ~P3D;
else
vertexType |= P3D;
} else {
setupMirrorVertexPointer(P3D);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && source != null) {
if (isLive) {
processCoordsChanged(coords == null);
sendDataChangedMessage(true);
} else {
boundsDirty = true;
}
}
}
Point3d[] getCoordRef3d() {
return p3dRefCoords;
}
void setColorRefFloat(float[] colors) {
if (colors != null) {
if ((vertexType & COLOR_DEFINED) != 0 &&
(vertexType & COLOR_DEFINED) != CF) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.COLOR) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray123"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (getColorStride() * idx.maxColorIndex >= colors.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.length < getColorStride() * (initialColorIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
floatRefColors = colors;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (colors == null)
vertexType &= ~CF;
else
vertexType |= CF;
}
else {
setupMirrorColorPointer(CF, false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
float[] getColorRefFloat() {
return floatRefColors;
}
// set the color with nio buffer
void setColorRefBuffer(J3DBuffer colors) {
if (colors != null) {
switch(colors.bufferType) {
case FLOAT:
assert ((FloatBuffer)colors.getROBuffer()).isDirect();
break;
case BYTE:
assert ((ByteBuffer)colors.getROBuffer()).isDirect();
break;
case NULL:
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray115"));
default:
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
}
if ((vertexFormat & GeometryArray.COLOR) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray123"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (getColorStride() * idx.maxColorIndex >= colors.getROBuffer().limit()) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.getROBuffer().limit() <
getColorStride() * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
colorRefBuffer = colors;
if(colors == null) {
floatBufferRefColors = null;
byteBufferRefColors = null;
} else {
switch (colors.bufferType) {
case FLOAT:
floatBufferRefColors = (FloatBuffer)colors.getROBuffer();
byteBufferRefColors = null;
break;
case BYTE:
byteBufferRefColors = (ByteBuffer)colors.getROBuffer();
floatBufferRefColors = null;
break;
default:
break;
}
}
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if(colors == null) {
vertexType &= ~CF;
vertexType &= ~CUB;
} else {
switch (colors.bufferType) {
case FLOAT:
vertexType |= CF;
vertexType &= ~CUB;
break;
case BYTE:
vertexType |= CUB;
vertexType &= ~CF;
break;
default:
break;
}
}
}
else {
setupMirrorColorPointer(CF|CUB, false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
// return the color data in nio buffer format
J3DBuffer getColorRefBuffer() {
return colorRefBuffer;
}
void setColorRefByte(byte[] colors) {
if (colors != null) {
if ((vertexType & COLOR_DEFINED) != 0 &&
(vertexType & COLOR_DEFINED) != CUB) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.COLOR) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray123"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (getColorStride() * idx.maxColorIndex >= colors.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.length < getColorStride() * (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
byteRefColors = colors;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (colors == null)
vertexType &= ~CUB;
else
vertexType |= CUB;
}
else {
setupMirrorColorPointer(CUB, false);
}
if(isLive){
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
byte[] getColorRefByte() {
return byteRefColors;
}
void setColorRef3f(Color3f[] colors) {
if (colors != null) {
if ((vertexType & COLOR_DEFINED) != 0 &&
(vertexType & COLOR_DEFINED) != C3F) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.COLOR_3) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray92"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxColorIndex >= colors.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
c3fRefColors = colors;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (colors == null)
vertexType &= ~C3F;
else
vertexType |= C3F;
}
else {
setupMirrorColorPointer(C3F, false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
Color3f[] getColorRef3f() {
return c3fRefColors;
}
void setColorRef4f(Color4f[] colors) {
if (colors != null) {
if ((vertexType & COLOR_DEFINED) != 0 &&
(vertexType & COLOR_DEFINED) != C4F) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.COLOR_4) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray93"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxColorIndex >= colors.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
c4fRefColors = colors;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (colors == null)
vertexType &= ~C4F;
else
vertexType |= C4F;
}
else {
setupMirrorColorPointer(C4F, false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
Color4f[] getColorRef4f() {
return c4fRefColors;
}
void setColorRef3b(Color3b[] colors) {
if (colors != null) {
if ((vertexType & COLOR_DEFINED) != 0 &&
(vertexType & COLOR_DEFINED) != C3UB) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.COLOR_3) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray92"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxColorIndex >= colors.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.length < (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
c3bRefColors = colors;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (colors == null)
vertexType &= ~C3UB;
else
vertexType |= C3UB;
}
else {
setupMirrorColorPointer(C3UB, false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
Color3b[] getColorRef3b() {
return c3bRefColors;
}
void setColorRef4b(Color4b[] colors) {
if (colors != null) {
if ((vertexType & COLOR_DEFINED) != 0 &&
(vertexType & COLOR_DEFINED) != C4UB) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.COLOR_4) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray93"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained) this;
if (idx.maxColorIndex >= colors.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
} else if (colors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
c4bRefColors = colors;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (colors == null)
vertexType &= ~C4UB;
else
vertexType |= C4UB;
}
else {
setupMirrorColorPointer(C4UB, false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
Color4b[] getColorRef4b() {
return c4bRefColors;
}
void setNormalRefFloat(float[] normals) {
if (normals != null) {
if ((vertexType & NORMAL_DEFINED) != 0 &&
(vertexType & NORMAL_DEFINED) != NF) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.NORMALS) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray122"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxNormalIndex*3 >= normals.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
}
} else if (normals.length < 3 * (initialNormalIndex + validVertexCount )) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
floatRefNormals = normals;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (normals == null)
vertexType &= ~NF;
else
vertexType |= NF;
}
else {
setupMirrorNormalPointer(NF);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
float[] getNormalRefFloat() {
return floatRefNormals;
}
// setup the normal with nio buffer
void setNormalRefBuffer(J3DBuffer normals) {
FloatBuffer bufferImpl = null;
if (normals != null) {
if(normals.bufferType != J3DBuffer.Type.FLOAT)
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
bufferImpl = (FloatBuffer)normals.getROBuffer();
assert bufferImpl.isDirect();
if ((vertexFormat & GeometryArray.NORMALS) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray122"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxNormalIndex * 3 >=
((FloatBuffer)normals.getROBuffer()).limit()) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
}
} else if (bufferImpl.limit() < 3 * (initialNormalIndex + validVertexCount )) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
normalRefBuffer = normals;
if (normals == null) {
vertexType &= ~NF;
floatBufferRefNormals = null;
}
else {
vertexType |= NF;
floatBufferRefNormals = bufferImpl;
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
J3DBuffer getNormalRefBuffer() {
return normalRefBuffer;
}
void setNormalRef3f(Vector3f[] normals) {
if (normals != null) {
if ((vertexType & NORMAL_DEFINED) != 0 &&
(vertexType & NORMAL_DEFINED) != N3F) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
}
if ((vertexFormat & GeometryArray.NORMALS) == 0) {
throw new IllegalStateException(J3dI18N.getString("GeometryArray122"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxNormalIndex >= normals.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
}
} else if (normals.length < (initialNormalIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
v3fRefNormals = normals;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
if (normals == null)
vertexType &= ~N3F;
else
vertexType |= N3F;
}
else {
setupMirrorNormalPointer(N3F);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
Vector3f[] getNormalRef3f() {
return v3fRefNormals;
}
final int getColorStride() {
return ((vertexFormat & GeometryArray.WITH_ALPHA) != 0 ? 4 : 3);
}
final int getTexStride() {
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
return 2;
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
return 3;
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
return 4;
}
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray121"));
}
void setTexCoordRefFloat(int texCoordSet, float[] texCoords) {
if (texCoordType != 0 && texCoordType != TF) {
if (texCoords != null) {
throw new IllegalArgumentException(
J3dI18N.getString("GeometryArray98"));
}
return;
}
if (texCoords != null) {
int ts = getTexStride();
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxTexCoordIndices[texCoordSet]*ts >= texCoords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
}
} else if (texCoords.length < ts*(initialTexCoordIndex[texCoordSet]+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
refTexCoords[texCoordSet] = texCoords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
texCoordType = TF;
validateTexCoordPointerType();
}
else {
setupMirrorTexCoordPointer(texCoordSet, TF);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
float[] getTexCoordRefFloat(int texCoordSet) {
return ((float[])refTexCoords[texCoordSet]);
}
// set the tex coord with nio buffer
void setTexCoordRefBuffer(int texCoordSet, J3DBuffer texCoords) {
FloatBuffer bufferImpl = null;
if (texCoords != null) {
if(texCoords.bufferType != J3DBuffer.Type.FLOAT)
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
bufferImpl = (FloatBuffer)texCoords.getROBuffer();
int bufferSize = bufferImpl.limit();
assert bufferImpl.isDirect();
int ts = getTexStride();
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxTexCoordIndices[texCoordSet] * ts >= bufferSize) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
}
} else if (bufferSize < ts*(initialTexCoordIndex[texCoordSet] + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
// refTexCoordsBuffer contains J3DBuffer object for tex coord
refTexCoordsBuffer[texCoordSet] = texCoords;
if (texCoords == null) {
refTexCoords[texCoordSet] = null;
}
else {
// refTexCoords contains NIOBuffer object for tex coord
refTexCoords[texCoordSet] = bufferImpl;
}
texCoordType = TF;
validateTexCoordPointerType();
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
J3DBuffer getTexCoordRefBuffer(int texCoordSet) {
return refTexCoordsBuffer[texCoordSet];
}
void setTexCoordRef2f(int texCoordSet, TexCoord2f[] texCoords) {
if (texCoordType != 0 && texCoordType != T2F) {
if (texCoords != null) {
throw new IllegalArgumentException(
J3dI18N.getString("GeometryArray98"));
}
return;
}
if (texCoords != null) {
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) == 0) {
throw new IllegalStateException(
J3dI18N.getString("GeometryArray94"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxTexCoordIndices[texCoordSet] >= texCoords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
}
} else if (texCoords.length < (initialTexCoordIndex[texCoordSet] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
refTexCoords[texCoordSet] = texCoords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
texCoordType = T2F;
validateTexCoordPointerType();
}
else {
setupMirrorTexCoordPointer(texCoordSet, T2F);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
TexCoord2f[] getTexCoordRef2f(int texCoordSet) {
if (refTexCoords != null && refTexCoords[texCoordSet] != null &&
refTexCoords[texCoordSet] instanceof TexCoord2f[]) {
return ((TexCoord2f[])refTexCoords[texCoordSet]);
} else {
return null;
}
}
void setTexCoordRef3f(int texCoordSet, TexCoord3f[] texCoords) {
if (texCoordType != 0 && texCoordType != T3F) {
if (texCoords != null) {
throw new IllegalArgumentException(
J3dI18N.getString("GeometryArray98"));
}
return;
}
if (texCoords != null) {
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) == 0) {
throw new IllegalStateException(
J3dI18N.getString("GeometryArray95"));
}
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxTexCoordIndices[texCoordSet] >= texCoords.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
}
} else if (texCoords.length < (initialTexCoordIndex[texCoordSet] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
refTexCoords[texCoordSet] = texCoords;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
texCoordType = T3F;
validateTexCoordPointerType();
}
else {
setupMirrorTexCoordPointer(texCoordSet, T3F);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
TexCoord3f[] getTexCoordRef3f(int texCoordSet) {
if (refTexCoords != null && refTexCoords[texCoordSet] != null &&
refTexCoords[texCoordSet] instanceof TexCoord3f[]) {
return ((TexCoord3f[])refTexCoords[texCoordSet]);
} else {
return null;
}
}
/**
* Sets the float vertex attribute array reference for the
* specified vertex attribute number to the specified array.
*/
void setVertexAttrRefFloat(int vertexAttrNum, float[] vertexAttrs) {
// XXXX: Add the following test if we ever add double-precision types
/*
if (vertexAttrType != 0 && vertexAttrType != AF) {
if (vertexAttrs != null) {
// XXXX: new exception string
throw new IllegalArgumentException(
J3dI18N.getString("GeometryArray98-XXX"));
}
return;
}
*/
if (vertexAttrs != null) {
int sz = vertexAttrSizes[vertexAttrNum];
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (sz*idx.maxVertexAttrIndices[vertexAttrNum] >= vertexAttrs.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray30"));
}
} else if (vertexAttrs.length < sz*(initialVertexAttrIndex[vertexAttrNum] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray129"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
floatRefVertexAttrs[vertexAttrNum] = vertexAttrs;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
vertexAttrType = AF;
validateVertexAttrPointerType();
}
else {
setupMirrorVertexAttrPointer(vertexAttrNum, AF);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
/**
* Gets the float vertex attribute array reference for the specified
* vertex attribute number.
*/
float[] getVertexAttrRefFloat(int vertexAttrNum) {
return floatRefVertexAttrs[vertexAttrNum];
}
/**
* Sets the vertex attribute buffer reference for the specified
* vertex attribute number to the specified buffer object.
*/
void setVertexAttrRefBuffer(int vertexAttrNum, J3DBuffer vertexAttrs) {
FloatBuffer bufferImpl = null;
if (vertexAttrs != null) {
if(vertexAttrs.bufferType != J3DBuffer.Type.FLOAT)
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
bufferImpl = (FloatBuffer)vertexAttrs.getROBuffer();
int bufferSize = bufferImpl.limit();
assert bufferImpl.isDirect();
int sz = vertexAttrSizes[vertexAttrNum];
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (idx.maxVertexAttrIndices[vertexAttrNum] * sz >= bufferSize) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray30"));
}
} else if (bufferSize < sz*(initialVertexAttrIndex[vertexAttrNum] + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray129"));
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
vertexAttrsRefBuffer[vertexAttrNum] = vertexAttrs;
if (vertexAttrs == null) {
floatBufferRefVertexAttrs[vertexAttrNum] = null;
}
else {
floatBufferRefVertexAttrs[vertexAttrNum] = bufferImpl;
}
vertexAttrType = AF;
validateVertexAttrPointerType();
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
sendDataChangedMessage(false);
}
}
/**
* Gets the vertex attribute array buffer reference for the specified
* vertex attribute number.
*/
J3DBuffer getVertexAttrRefBuffer(int vertexAttrNum) {
return vertexAttrsRefBuffer[vertexAttrNum];
}
void setInterleavedVertices(float[] vertexData) {
if (vertexData != null) {
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (stride * idx.maxCoordIndex >= vertexData.length) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
for (int i = 0; i < texCoordSetCount; i++) {
if (stride * idx.maxTexCoordIndices[i] >= vertexData.length) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("IndexedGeometryArray25"));
}
}
}
if (((this.vertexFormat & GeometryArray.COLOR) != 0) &&
(stride * idx.maxColorIndex >= vertexData.length)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
if (((this.vertexFormat & GeometryArray.NORMALS) != 0) &&
(stride * idx.maxNormalIndex >= vertexData.length)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
}
} else {
if (vertexData.length < (stride * (initialVertexIndex+validVertexCount)))
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
}
}
// If the geometry has been rendered transparent, then make a copy
// of the color pointer with 4f
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VERTEX_CHANGED;
colorChanged = 0xffff;
interLeavedVertexData = vertexData;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
setupMirrorInterleavedColorPointer(false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
processCoordsChanged(vertexData == null);
sendDataChangedMessage(true);
}
}
// set the interleaved vertex with NIO buffer
void setInterleavedVertexBuffer(J3DBuffer vertexData) {
FloatBuffer bufferImpl = null;
if (vertexData != null ){
if (vertexData.bufferType != J3DBuffer.Type.FLOAT)
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
bufferImpl = (FloatBuffer)vertexData.getROBuffer();
assert bufferImpl.isDirect();
int bufferSize = bufferImpl.limit();
if (this instanceof IndexedGeometryArrayRetained) {
IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
if (stride * idx.maxCoordIndex >= bufferSize) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
for (int i = 0; i < texCoordSetCount; i++) {
if (stride * idx.maxTexCoordIndices[i] >= bufferSize) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("IndexedGeometryArray25"));
}
}
}
if (((this.vertexFormat & GeometryArray.COLOR) != 0) &&
(stride * idx.maxColorIndex >= bufferSize)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
}
if (((this.vertexFormat & GeometryArray.NORMALS) != 0) &&
(stride * idx.maxNormalIndex >= bufferSize)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
}
} else {
if (bufferSize < (stride * (initialVertexIndex+validVertexCount)))
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
}
}
// If the geometry has been rendered transparent, then make a copy
// of the color pointer with 4f
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VERTEX_CHANGED;
colorChanged = 0xffff;
interleavedVertexBuffer = vertexData;
if(vertexData == null)
interleavedFloatBufferImpl = null;
else
interleavedFloatBufferImpl = bufferImpl;
if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
setupMirrorInterleavedColorPointer(false);
}
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
processCoordsChanged(vertexData == null);
sendDataChangedMessage(true);
}
}
float[] getInterleavedVertices() {
return interLeavedVertexData;
}
J3DBuffer getInterleavedVertexBuffer() {
return interleavedVertexBuffer;
}
void setValidVertexCount(int validVertexCount) {
boolean nullGeo = false;
if (validVertexCount < 0) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray110"));
}
if ((initialVertexIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray100"));
}
if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
// Interleaved, by-ref
// use nio buffer for interleaved data
if(( vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0 && interleavedFloatBufferImpl != null){
if(interleavedFloatBufferImpl.limit() < stride * (initialVertexIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
}
}
//use java array for interleaved data
else if( interLeavedVertexData != null) {
if(interLeavedVertexData.length < stride * (initialVertexIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
}
}
else {
nullGeo = true;
}
} else if ((vertexFormat & GeometryArray.BY_REFERENCE) != 0) {
// Non-interleaved, by-ref
if ((initialCoordIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray104"));
}
if ((initialColorIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray101"));
}
if ((initialNormalIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray102"));
}
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
for (int i = 0; i < texCoordSetCount; i++) {
if ((initialTexCoordIndex[i] + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString(
"GeometryArray103"));
}
}
}
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
for (int i = 0; i < vertexAttrCount; i++) {
if ((initialVertexAttrIndex[i] + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString(
"GeometryArray130"));
}
}
}
if ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0) {
nullGeo = true;
}
if (( vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
// by reference with nio buffer
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case PF:
if(floatBufferRefCoords.limit() < 3 * (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case PD:
if(doubleBufferRefCoords.limit() < 3 * (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
}
switch ((vertexType & COLOR_DEFINED)) {
case CF:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (floatBufferRefColors.limit() < 3 * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (floatBufferRefColors.limit() < 4 * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
case CUB:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (byteBufferRefColors.limit() < 3 * (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (byteBufferRefColors.limit() < 4 * (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
}
switch ((vertexType & GeometryArrayRetained.TEXCOORD_DEFINED)) {
case TF:
FloatBuffer texBuffer;
for (int i = 0; i < texCoordSetCount; i++) {
texBuffer = (FloatBuffer)refTexCoordsBuffer[i].getROBuffer();
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
if (texBuffer.limit() < 2 * (initialTexCoordIndex[i] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
if (texBuffer.limit() < 3 * (initialTexCoordIndex[i] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
if (texBuffer.limit() < 4 * (initialTexCoordIndex[i] + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
}
}
break;
}
switch ((vertexType & GeometryArrayRetained.NORMAL_DEFINED)) {
case NF:
if (floatBufferRefNormals.limit() < 3 * (initialNormalIndex + validVertexCount )) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
break;
}
switch ((vertexType & GeometryArrayRetained.VATTR_DEFINED)) {
case AF:
for (int i = 0; i < vertexAttrCount; i++) {
int sz = vertexAttrSizes[i];
if (floatBufferRefVertexAttrs[i].limit() <
(sz * (initialVertexAttrIndex[i] + validVertexCount)) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray129"));
}
}
break;
}
}
// By reference with java array
else {
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case PF:
if (floatRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case PD:
if (doubleRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case P3F:
if (p3fRefCoords.length < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case P3D:
if (p3dRefCoords.length < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
}
switch ((vertexType & COLOR_DEFINED)) {
case CF:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (floatRefColors.length < 3 * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (floatRefColors.length < 4 * (initialColorIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
case CUB:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (byteRefColors.length < 3 * (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (byteRefColors.length < 4 * (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
case C3F:
if (c3fRefColors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
case C4F:
if (c4fRefColors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
case C3UB:
if (c3bRefColors.length < (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
case C4UB:
if (c4bRefColors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
}
switch ((vertexType & GeometryArrayRetained.TEXCOORD_DEFINED)) {
case TF:
for (int i = 0; i < texCoordSetCount; i++) {
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
if (((float[])refTexCoords[i]).length < 2 * (initialTexCoordIndex[i] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
if (((float[])refTexCoords[i]).length < 3 * (initialTexCoordIndex[i] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
if (((float[])refTexCoords[i]).length < 4 * (initialTexCoordIndex[i] + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
}
}
}
break;
case T2F:
for (int i = 0; i < texCoordSetCount; i++) {
if (((TexCoord2f[])refTexCoords[i]).length < (initialTexCoordIndex[i] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
}
break;
case T3F:
for (int i = 0; i < texCoordSetCount; i++) {
if (((TexCoord3f[])refTexCoords[i]).length < (initialTexCoordIndex[i] + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
}
break;
}
switch ((vertexType & GeometryArrayRetained.NORMAL_DEFINED)) {
case NF:
if (floatRefNormals.length < 3 * (initialNormalIndex + validVertexCount )) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
break;
case N3F:
if (v3fRefNormals.length < (initialNormalIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
}
switch ((vertexType & GeometryArrayRetained.VATTR_DEFINED)) {
case AF:
for (int i = 0; i < vertexAttrCount; i++) {
int sz = vertexAttrSizes[i];
if (floatRefVertexAttrs[i].length <
(sz * (initialVertexAttrIndex[i] + validVertexCount)) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray129"));
}
}
break;
}
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VERTEX_CHANGED;
this.validVertexCount = validVertexCount;
if(isLive){
geomLock.unLock();
}
if (!inUpdater && isLive) {
processCoordsChanged(nullGeo);
sendDataChangedMessage(true);
}
}
int getValidVertexCount() {
return validVertexCount;
}
//Used for interleaved data (array or nio buffer)
void setInitialVertexIndex(int initialVertexIndex) {
boolean nullGeo = false;
if ((initialVertexIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray100"));
}
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0 && interleavedFloatBufferImpl != null) {
if(interleavedFloatBufferImpl.limit() < stride * (initialVertexIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
}
}
// interleaved data using java array
else if(interLeavedVertexData != null) {
if (interLeavedVertexData.length < stride * (initialVertexIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
}
}
else {
nullGeo = (vertexFormat & GeometryArray.INTERLEAVED) != 0; // Only for byRef
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VERTEX_CHANGED;
this.initialVertexIndex = initialVertexIndex;
if(isLive) {
geomLock.unLock();
}
if (!inUpdater && isLive) {
processCoordsChanged(nullGeo);
sendDataChangedMessage(true);
}
}
int getInitialVertexIndex() {
return initialVertexIndex;
}
void setInitialCoordIndex(int initialCoordIndex) {
if ((initialCoordIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray104"));
}
// use NIO buffer
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case PF:
if(floatBufferRefCoords.limit() < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case PD:
if(doubleBufferRefCoords.limit() < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
}
} else {
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case PF:
if (floatRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case PD:
if (doubleRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case P3F:
if (p3fRefCoords.length < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
case P3D:
if (p3dRefCoords.length < (initialCoordIndex+validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
}
break;
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COORDINATE_CHANGED;
this.initialCoordIndex = initialCoordIndex;
dirtyFlag |= COORDINATE_CHANGED;
if(isLive) {
geomLock.unLock();
}
// Send a message, since bounds changed
if (!inUpdater && isLive) {
processCoordsChanged((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0);
sendDataChangedMessage(true);
}
}
int getInitialCoordIndex() {
return initialCoordIndex;
}
void setInitialColorIndex(int initialColorIndex) {
if ((initialColorIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray101"));
}
// NIO BUFFER CASE
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
switch ((vertexType & COLOR_DEFINED)) {
case CF:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (floatBufferRefColors.limit() < 3 * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (floatBufferRefColors.limit() < 4 * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
case CUB:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (byteBufferRefColors.limit() < 3 * (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (byteBufferRefColors.limit() < 4 * (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
}
}
// Java ARRAY CASE
else {
switch ((vertexType & COLOR_DEFINED)) {
case CF:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (floatRefColors.length < 3 * (initialColorIndex+validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (floatRefColors.length < 4 * (initialColorIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
case CUB:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
if (byteRefColors.length < 3 * (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
if (byteRefColors.length < 4 * (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
}
break;
case C3F:
if (c3fRefColors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
case C4F:
if (c4fRefColors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
case C3UB:
if (c3bRefColors.length < (initialColorIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
case C4UB:
if (c4bRefColors.length < (initialColorIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
}
break;
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= COLOR_CHANGED;
colorChanged = 0xffff;
this.initialColorIndex = initialColorIndex;
if(isLive) {
geomLock.unLock();
}
// There is no need to send message for by reference, since we
// use VA
}
int getInitialColorIndex() {
return initialColorIndex;
}
void setInitialNormalIndex(int initialNormalIndex) {
if ((initialNormalIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray102"));
}
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
if((vertexType & NORMAL_DEFINED) == NF){
if (floatBufferRefNormals.limit() < 3 * (initialNormalIndex + validVertexCount )) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
}
} else {
switch((vertexType & NORMAL_DEFINED)){
case NF:
if (floatRefNormals.length < 3 * (initialNormalIndex + validVertexCount )) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
break;
case N3F:
if (v3fRefNormals.length < (initialNormalIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
}
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= NORMAL_CHANGED;
this.initialNormalIndex = initialNormalIndex;
if(isLive) {
geomLock.unLock();
}
// There is no need to send message for by reference, since we
// use VA
}
int getInitialNormalIndex() {
return initialNormalIndex;
}
/**
* Sets the initial vertex attribute index for the specified
* vertex attribute number for this GeometryArray object.
*/
void setInitialVertexAttrIndex(int vertexAttrNum,
int initialVertexAttrIndex) {
if ((initialVertexAttrIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray130"));
}
int sz = vertexAttrSizes[vertexAttrNum];
int minLength = sz * (initialVertexAttrIndex + validVertexCount);
if ((vertexType & VATTR_DEFINED) == AF) {
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
if (floatBufferRefVertexAttrs[vertexAttrNum].limit() < minLength) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray129"));
}
} else {
if (floatRefVertexAttrs[vertexAttrNum].length < minLength ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray129"));
}
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= VATTR_CHANGED;
this.initialVertexAttrIndex[vertexAttrNum] = initialVertexAttrIndex;
if(isLive) {
geomLock.unLock();
}
// There is no need to send message for by reference, since we
// use VA
}
/**
* Gets the initial vertex attribute index for the specified
* vertex attribute number for this GeometryArray object.
*/
int getInitialVertexAttrIndex(int vertexAttrNum) {
return initialVertexAttrIndex[vertexAttrNum];
}
void setInitialTexCoordIndex(int texCoordSet, int initialTexCoordIndex) {
if ((initialTexCoordIndex + validVertexCount) > vertexCount) {
throw new IllegalArgumentException(J3dI18N.getString("GeometryArray103"));
}
if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
if((vertexType & TEXCOORD_DEFINED) == TF) {
FloatBuffer texBuffer = (FloatBuffer)refTexCoordsBuffer[texCoordSet].getROBuffer();
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
if (texBuffer.limit() < 2 * (initialTexCoordIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
if (texBuffer.limit() < 3 * (initialTexCoordIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
if (texBuffer.limit() < 4 * (initialTexCoordIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
}
}
} else {
switch ((vertexType & TEXCOORD_DEFINED)) {
case TF:
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
if (((float[])refTexCoords[texCoordSet]).length < 2 * (initialTexCoordIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
if (((float[])refTexCoords[texCoordSet]).length < 3 * (initialTexCoordIndex + validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
if (((float[])refTexCoords[texCoordSet]).length < 4 * (initialTexCoordIndex + validVertexCount)) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
}
break;
case T2F:
if (((TexCoord2f[])refTexCoords[texCoordSet]).length < (initialTexCoordIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
break;
case T3F:
if (((TexCoord3f[])refTexCoords[texCoordSet]).length < (initialTexCoordIndex+ validVertexCount) ) {
throw new ArrayIndexOutOfBoundsException(
J3dI18N.getString("GeometryArray113"));
}
break;
}
}
boolean isLive = source!=null && source.isLive();
if(isLive){
geomLock.getLock();
}
dirtyFlag |= TEXTURE_CHANGED;
this.initialTexCoordIndex[texCoordSet] = initialTexCoordIndex;
if(isLive) {
geomLock.unLock();
}
// There is no need to send message for by reference, since we
// use VA
}
int getInitialTexCoordIndex(int texCoordSet) {
return initialTexCoordIndex[texCoordSet];
}
int getTexCoordSetCount() {
return this.texCoordSetCount;
}
int getTexCoordSetMapLength() {
if (this.texCoordSetMap != null)
return this.texCoordSetMap.length;
else
return 0;
}
void getTexCoordSetMap(int [] texCoordSetMap) {
if (this.texCoordSetMap!=null) {
for (int i = 0; i < this.texCoordSetMap.length; i++) {
texCoordSetMap[i] = this.texCoordSetMap[i];
}
}
}
void freeDlistId() {
if (dlistId != -1) {
VirtualUniverse.mc.freeDisplayListId(dlistObj);
dlistId = -1;
}
}
void assignDlistId() {
if (dlistId == -1) {
dlistObj = VirtualUniverse.mc.getDisplayListId();
dlistId = dlistObj.intValue();
}
}
// Add the specified render atom as a user of this geometry array
// (for the specified render bin)
void addDlistUser(RenderBin renderBin, RenderAtomListInfo ra) {
if (dlistUsers == null)
dlistUsers = new HashMap<RenderBin, HashSet<RenderAtomListInfo>>(2, 1.0f);
HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
if (raSet == null) {
raSet = new HashSet<RenderAtomListInfo>();
dlistUsers.put(renderBin, raSet);
}
raSet.add(ra);
}
// Remove the specified render atom from the set of users of this
// geometry array (for the specified render bin)
void removeDlistUser(RenderBin renderBin, RenderAtomListInfo ra) {
if (dlistUsers == null)
return;
HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
if (raSet == null)
return;
raSet.remove(ra);
}
// Returns true if the set of render atoms using this geometry
// array in the specified render bin is empty.
boolean isDlistUserSetEmpty(RenderBin renderBin) {
if (dlistUsers == null)
return true;
HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
if (raSet == null) {
return true;
}
return raSet.isEmpty();
}
// This method is used for debugging only
int numDlistUsers(RenderBin renderBin) {
if (isDlistUserSetEmpty(renderBin))
return 0;
HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
return raSet.size();
}
void setDlistTimeStamp(int rdrBit, long timeStamp) {
int index = getIndex(rdrBit);
if (index >= timeStampPerDlist.length) {
long[] newList = new long[index * 2];
for (int i = 0; i < timeStampPerDlist.length; i++) {
newList[i] = timeStampPerDlist[i];
}
timeStampPerDlist = newList;
}
timeStampPerDlist[index] = timeStamp;
}
long getDlistTimeStamp(int rdrBit) {
int index = getIndex(rdrBit);
// If index is greater than what currently exists, increase
// the array and return zero
if (index >= timeStampPerDlist.length) {
setDlistTimeStamp(rdrBit, 0);
}
return timeStampPerDlist[index];
}
int getIndex(int bit) {
int num = 0;
while (bit > 0) {
num++;
bit >>= 1;
}
return num;
}
boolean isWriteStatic() {
if (source.getCapability(GeometryArray.ALLOW_COORDINATE_WRITE ) ||
source.getCapability(GeometryArray.ALLOW_COLOR_WRITE) ||
source.getCapability(GeometryArray.ALLOW_NORMAL_WRITE) ||
source.getCapability(GeometryArray.ALLOW_TEXCOORD_WRITE) ||
source.getCapability(GeometryArray.ALLOW_VERTEX_ATTR_WRITE) ||
source.getCapability(GeometryArray.ALLOW_COUNT_WRITE) ||
source.getCapability(GeometryArray.ALLOW_REF_DATA_WRITE))
return false;
return true;
}
/**
* The functions below are only used in compile mode
*/
void setCompiled(ArrayList curList) {
int i;
int num = curList.size();
int offset = 0;
geoOffset = new int[num];
compileVcount = new int[num];
int vcount = 0, vformat = 0;
vcount = 0;
isCompiled = true;
if (num > 0)
source = ((SceneGraphObjectRetained)curList.get(0)).source;
for (i = 0; i < num; i++) {
// Build the back mapping
GeometryArrayRetained geo = (GeometryArrayRetained)curList.get(i);
((GeometryArray)geo.source).retained = this;
compileVcount[i] = geo.getValidVertexCount();
vcount += geo.getValidVertexCount();
geoOffset[i] = offset;
offset += geo.stride() * compileVcount[i];
vformat = geo.getVertexFormat();
}
createGeometryArrayData(vcount, vformat);
// Assign the initial and valid fields
validVertexCount = vcount;
initialVertexIndex = 0;
mergeGeometryArrays(curList);
}
/*
// Ununsed
int getVertexCount(int index) {
return compileVcount[index];
}
int getValidVertexCount(int index) {
return compileVcount[index];
}
int getInitialVertexIndex(int index) {
return 0;
}
*/
void mergeGeometryArrays(ArrayList list) {
float[] curVertexData;
int length, srcOffset;
int curOffset = 0;
// We only merge if the texCoordSetCount is 1 and there are no
// vertex attrs
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
texCoordSetCount = 1;
texCoordSetMap = new int[1];
texCoordSetMap[0] = 1;
}
for (int i = 0; i < list.size(); i++) {
GeometryArrayRetained geo = (GeometryArrayRetained)list.get(i);
// Take into account the validVertexCount and initialVertexIndex
curVertexData = geo.vertexData;
length = geo.validVertexCount * stride;
srcOffset = geo.initialVertexIndex * stride;
System.arraycopy(curVertexData, srcOffset, this.vertexData, curOffset,
length);
curOffset += length;
// assign geoBounds
geoBounds.combine(geo.geoBounds);
}
geoBounds.getCenter(this.centroid);
}
boolean isMergeable() {
// For now, turn off by ref geometry
if ((vertexFormat & GeometryArray.BY_REFERENCE) != 0)
return false;
if (!isStatic())
return false;
// If there is more than one set of texture coordinate set defined
// then don't merge geometry (we avoid dealing with texCoordSetMap
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0 &&
(texCoordSetCount > 1 ||
texCoordSetMap != null && texCoordSetMap.length > 1)) {
return false;
}
// We will avoid merging geometry if there are any vertex attributes.
if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
return false;
}
// If intersect is allowed turn off merging
if (source.getCapability(Geometry.ALLOW_INTERSECT))
return false;
return true;
}
@Override
void compile(CompileState compState) {
super.compile(compState);
if ((vertexFormat & GeometryArray.NORMALS) != 0) {
compState.needNormalsTransform = true;
}
}
@Override
void mergeTransform(TransformGroupRetained xform) {
if (geoBounds != null) {
geoBounds.transform(xform.transform);
}
}
// This adds a MorphRetained to the list of users of this geometry
void addMorphUser(MorphRetained m) {
int index;
if(morphUniverseList == null) {
morphUniverseList = new ArrayList<VirtualUniverse>(1);
morphUserLists = new ArrayList<ArrayList<MorphRetained>>(1);
}
synchronized (morphUniverseList) {
if (morphUniverseList.contains(m.universe)) {
index = morphUniverseList.indexOf(m.universe);
morphUserLists.get(index).add(m);
} else {
morphUniverseList.add(m.universe);
ArrayList<MorphRetained> morphList = new ArrayList<MorphRetained>(5);
morphList.add(m);
morphUserLists.add(morphList);
}
}
}
// This adds a MorphRetained to the list of users of this geometry
void removeMorphUser(MorphRetained m) {
int index;
if(morphUniverseList == null)
return;
synchronized (morphUniverseList) {
index = morphUniverseList.indexOf(m.universe);
ArrayList<MorphRetained> morphList = morphUserLists.get(index);
morphList.remove(morphList.indexOf(m));
if (morphList.size() == 0) {
morphUserLists.remove(index);
morphUniverseList.remove(index);
}
}
}
// Initialize mirror object when geometry is first setLived
void initMirrorGeometry() {
geomLock.getLock();
if (this instanceof IndexedGeometryArrayRetained) {
if ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0) {
mirrorGeometry =
((IndexedGeometryArrayRetained)this).cloneNonIndexedGeometry();
}
else {
mirrorGeometry = null;
}
}
geomLock.unLock();
}
// Update Mirror Object in response to change in geometry
void updateMirrorGeometry() {
geomLock.getLock();
if (this instanceof IndexedGeometryArrayRetained) {
if (mirrorGeometry != null) {
mirrorGeometry =
((IndexedGeometryArrayRetained)this).cloneNonIndexedGeometry();
}
}
geomLock.unLock();
}
// Used by the picking intersect routines
void getVertexData(int i, Point3d pnts) {
int offset;
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
offset = stride * i + coordinateOffset;
pnts.x = this.vertexData[offset];
pnts.y = this.vertexData[offset+1];
pnts.z = this.vertexData[offset+2];
return;
}
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0 ) {
if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
offset = stride * i + coordinateOffset;
pnts.x = this.interLeavedVertexData[offset];
pnts.y = this.interLeavedVertexData[offset+1];
pnts.z = this.interLeavedVertexData[offset+2];
}
else {
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case GeometryArrayRetained.PF:
offset = i*3;
pnts.x = this.floatRefCoords[offset];
pnts.y = this.floatRefCoords[offset+1];
pnts.z = this.floatRefCoords[offset+2];
break;
case GeometryArrayRetained.PD:
offset = i*3;
pnts.x = this.doubleRefCoords[offset];
pnts.y = this.doubleRefCoords[offset+1];
pnts.z = this.doubleRefCoords[offset+2];
break;
case GeometryArrayRetained.P3F:
pnts.x = this.p3fRefCoords[i].x;
pnts.y = this.p3fRefCoords[i].y;
pnts.z = this.p3fRefCoords[i].z;
break;
case GeometryArrayRetained.P3D:
pnts.x = this.p3dRefCoords[i].x;
pnts.y = this.p3dRefCoords[i].y;
pnts.z = this.p3dRefCoords[i].z;
break;
}
}
}// end of non nio buffer
else { // NIO BUFFER
if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
offset = stride * i + coordinateOffset;
pnts.x = this.interleavedFloatBufferImpl.get(offset);
pnts.y = this.interleavedFloatBufferImpl.get(offset+1);
pnts.z = this.interleavedFloatBufferImpl.get(offset+2);
}
else {
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case GeometryArrayRetained.PF:
offset = i*3;
pnts.x = this.floatBufferRefCoords.get(offset);
pnts.y = this.floatBufferRefCoords.get(offset+1);
pnts.z = this.floatBufferRefCoords.get(offset+2);
break;
case GeometryArrayRetained.PD:
offset = i*3;
pnts.x = this.doubleBufferRefCoords.get(offset);
pnts.y = this.doubleBufferRefCoords.get(offset+1);
pnts.z = this.doubleBufferRefCoords.get(offset+2);
break;
}
}
} // end of nio buffer
}
void getCrossValue(Point3d p1, Point3d p2, Vector3d value) {
value.x += p1.y*p2.z - p1.z*p2.y;
value.y += p2.x*p1.z - p2.z*p1.x;
value.z += p1.x*p2.y - p1.y*p2.x;
}
@Override
boolean intersect(Transform3D thisLocalToVworld,
Transform3D otherLocalToVworld, GeometryRetained geom) {
Transform3D t3d = new Transform3D();
boolean isIntersect = false;
if (geom instanceof GeometryArrayRetained ) {
GeometryArrayRetained geomArray = (GeometryArrayRetained) geom;
if (geomArray.validVertexCount >= validVertexCount) {
t3d.invert(otherLocalToVworld);
t3d.mul(thisLocalToVworld);
isIntersect = intersect(t3d, geom);
} else {
t3d.invert(thisLocalToVworld);
t3d.mul(otherLocalToVworld);
isIntersect = geomArray.intersect(t3d, this);
}
} else {
t3d.invert(thisLocalToVworld);
t3d.mul(otherLocalToVworld);
isIntersect = geom.intersect(t3d, this);
}
return isIntersect;
}
int getNumCoordCount() {
int count = 0;
if ((vertexFormat & GeometryArray.COORDINATES) != 0){
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
count = vertexCount;
return count;
}
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case PF:
count = floatRefCoords.length/3;
break;
case PD:
count = doubleRefCoords.length/3;
break;
case P3F:
count = p3fRefCoords.length;
break;
case P3D:
count = p3dRefCoords.length;
break;
}
}
else {
count = interLeavedVertexData.length/stride;
}
}
else { // nio buffer
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
case PF:
count = floatBufferRefCoords.limit()/3; // XXXX: limit or capacity?
break;
case PD:
count = doubleBufferRefCoords.limit()/3;
break;
}
}
else {
count = interleavedFloatBufferImpl.limit()/stride;
}
}
}
return count;
}
int getNumColorCount() {
int count = 0;
if ((vertexFormat & GeometryArray.COLOR) != 0){
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
count = vertexCount;
return count;
}
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
switch ((vertexType & GeometryArrayRetained.COLOR_DEFINED)) {
case CF:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
count = floatRefColors.length/3;
}
else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
count = floatRefColors.length/4;
}
break;
case CUB:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
count = byteRefColors.length/3;
}
else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
count = byteRefColors.length/4;
}
break;
case C3F:
count = c3fRefColors.length;
break;
case C4F:
count = c4fRefColors.length;
break;
case C3UB:
count = c3bRefColors.length;
break;
case C4UB:
count = c4bRefColors.length;
break;
}
}
else {
count = interLeavedVertexData.length/stride;
}
} // end of non nio buffer
else {
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
switch ((vertexType & GeometryArrayRetained.COLOR_DEFINED)) {
case CF:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
count = floatBufferRefColors.limit()/3;
}
else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
count = floatBufferRefColors.limit()/4;
}
break;
case CUB:
if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
count = byteBufferRefColors.limit()/3;
}
else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
count = byteBufferRefColors.limit()/4;
}
break;
}
}
else {
count = interleavedFloatBufferImpl.limit()/stride;
}
} // end of nio buffer
}
return count;
}
int getNumNormalCount() {
int count = 0;
if ((vertexFormat & GeometryArray.NORMALS) != 0){
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
count = vertexCount;
return count;
}
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
switch ((vertexType & NORMAL_DEFINED)) {
case NF:
count = floatRefNormals.length/3;
break;
case N3F:
count = v3fRefNormals.length;
break;
}
}
else {
count = interLeavedVertexData.length/stride;
}
} // end of non nio buffer
else {
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
if ((vertexType & NORMAL_DEFINED) == NF ) {
count = floatBufferRefNormals.limit()/3;
}
}
else {
count = interleavedFloatBufferImpl.limit()/stride;
}
}
}
return count;
}
int getNumTexCoordCount(int i) {
int count = 0;
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0){
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
count = vertexCount;
return count;
}
if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
switch ((vertexType & TEXCOORD_DEFINED)) {
case TF:
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
count = ((float[])refTexCoords[i]).length/2;
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
count = ((float[])refTexCoords[i]).length/3;
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
count = ((float[])refTexCoords[i]).length/4;
}
break;
case T2F:
count = ((TexCoord2f[])refTexCoords[i]).length;
break;
case T3F:
count = ((TexCoord3f[])refTexCoords[i]).length;
}
}
else {
count = interLeavedVertexData.length/stride;
}
}
else { // nio buffer
if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
if ((vertexType & TEXCOORD_DEFINED) == TF) {
FloatBuffer texBuffer = (FloatBuffer)refTexCoordsBuffer[i].getROBuffer();
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
count = texBuffer.limit()/2;
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
count = texBuffer.limit()/3;
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
count = texBuffer.limit()/4;
}
}
}
else {
count = interleavedFloatBufferImpl.limit()/stride;
}
}
}
return count;
}
// NOTE: we don't need a getNumVertexAttrCount method, since getNum*Count
// is only called by Morph, which doesn't support vertex attrs
// Found the min distance from center to the point/line/tri/quad
// form by dist[]
void computeMinDistance(Point3d coordinates[], Point3d center,
Vector3d normal,
double dist[], Point3d iPnt) {
double x, y, z;
int i, j;
if (coordinates.length == 1) {
// a point
iPnt.x = coordinates[0].x;
iPnt.y = coordinates[0].y;
iPnt.z = coordinates[0].z;
x = iPnt.x - center.x;
y = iPnt.y - center.y;
z = iPnt.z - center.z;
dist[0] = Math.sqrt(x*x + y*y + z*z);
return;
}
if (coordinates.length == 2) {
// a line
dist[0] = Math.sqrt(Utils.ptToSegSquare(center, coordinates[0], coordinates[1], iPnt));
return;
}
double normalLen = 0;
if (normal == null) {
Vector3d vec0 = new Vector3d();
Vector3d vec1 = new Vector3d();
normal = new Vector3d();
// compute plane normal for coordinates.
for (i=0; i<coordinates.length-1;) {
vec0.x = coordinates[i+1].x - coordinates[i].x;
vec0.y = coordinates[i+1].y - coordinates[i].y;
vec0.z = coordinates[i+1].z - coordinates[i++].z;
if(vec0.length() > 0.0)
break;
}
for (j=i; j<coordinates.length-1; j++) {
vec1.x = coordinates[j+1].x - coordinates[j].x;
vec1.y = coordinates[j+1].y - coordinates[j].y;
vec1.z = coordinates[j+1].z - coordinates[j].z;
if(vec1.length() > 0.0)
break;
}
if (j == (coordinates.length-1)) {
// Degenerate polygon, check with edge only
normal = null;
} else {
normal.cross(vec0,vec1);
}
}
if (normal != null) {
normalLen = normal.length();
if ( normalLen == 0.0) {
// Degenerate polygon, check with edge only
normal = null;
}
}
if (coordinates.length == 3) {
// a triangle
if (normal != null) {
double d = -(normal.x*coordinates[0].x +
normal.y*coordinates[0].y +
normal.z*coordinates[0].z);
dist[0] = (normal.x*center.x + normal.y*center.y +
normal.z*center.z +
d)/normalLen;
iPnt.x = center.x - dist[0]*normal.x/normalLen;
iPnt.y = center.y - dist[0]*normal.y/normalLen;
iPnt.z = center.z - dist[0]*normal.z/normalLen;
if (pointInTri(iPnt, coordinates[0], coordinates[1],
coordinates[2], normal)) {
return;
}
}
// checking point to line distance
double minDist;
Point3d minPnt = new Point3d();
dist[0] = Utils.ptToSegSquare(center, coordinates[0], coordinates[1], iPnt);
minDist = Utils.ptToSegSquare(center, coordinates[1], coordinates[2], minPnt);
if (minDist < dist[0]) {
dist[0] = minDist;
iPnt.x = minPnt.x;
iPnt.y = minPnt.y;
iPnt.z = minPnt.z;
}
minDist = Utils.ptToSegSquare(center, coordinates[2], coordinates[0], minPnt);
if (minDist < dist[0]) {
dist[0] = minDist;
iPnt.x = minPnt.x;
iPnt.y = minPnt.y;
iPnt.z = minPnt.z;
}
dist[0] = Math.sqrt(dist[0]);
return;
}
// a quad
if (normal != null) {
double d = -(normal.x*coordinates[0].x +
normal.y*coordinates[0].y +
normal.z*coordinates[0].z);
dist[0] = (normal.x*center.x + normal.y*center.y +
normal.z*center.z +
d)/normalLen;
iPnt.x = center.x - dist[0]*normal.x/normalLen;
iPnt.y = center.y - dist[0]*normal.y/normalLen;
iPnt.z = center.z - dist[0]*normal.z/normalLen;
if (pointInTri(iPnt, coordinates[0], coordinates[1],
coordinates[2], normal) ||
pointInTri(iPnt, coordinates[1], coordinates[2],
coordinates[3], normal)) {
return;
}
}
// checking point to line distance
double minDist;
Point3d minPnt = new Point3d();
dist[0] = Utils.ptToSegSquare(center, coordinates[0], coordinates[1], iPnt);
minDist = Utils.ptToSegSquare(center, coordinates[1], coordinates[2], minPnt);
if (minDist < dist[0]) {
dist[0] = minDist;
iPnt.x = minPnt.x;
iPnt.y = minPnt.y;
iPnt.z = minPnt.z;
}
minDist = Utils.ptToSegSquare(center, coordinates[2], coordinates[3], minPnt);
if (minDist < dist[0]) {
dist[0] = minDist;
iPnt.x = minPnt.x;
iPnt.y = minPnt.y;
iPnt.z = minPnt.z;
}
minDist = Utils.ptToSegSquare(center, coordinates[3], coordinates[0], minPnt);
if (minDist < dist[0]) {
dist[0] = minDist;
iPnt.x = minPnt.x;
iPnt.y = minPnt.y;
iPnt.z = minPnt.z;
}
dist[0] = Math.sqrt(dist[0]);
}
@Override
void handleFrequencyChange(int bit) {
int mask = 0;
if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
if ((bit == GeometryArray.ALLOW_COORDINATE_WRITE) ||
(((vertexFormat & GeometryArray.COLOR) != 0) &&
bit == GeometryArray.ALLOW_COLOR_WRITE)||
(((vertexFormat & GeometryArray.NORMALS) != 0) &&
bit == GeometryArray.ALLOW_NORMAL_WRITE) ||
(((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) &&
bit == GeometryArray.ALLOW_TEXCOORD_WRITE) ||
(((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
bit == GeometryArray.ALLOW_VERTEX_ATTR_WRITE) ||
(bit == GeometryArray.ALLOW_COUNT_WRITE)) {
mask = 1;
}
}
else {
if (bit == GeometryArray.ALLOW_REF_DATA_WRITE)
mask = 1;
}
if (mask != 0) {
setFrequencyChangeMask(bit, mask);
}
}
int getTexCoordType() {
return texCoordType;
}
int getVertexAttrType() {
return vertexAttrType;
}
}