j3dcore: flatten the directory structure a bit

Signed-off-by: Harvey Harrison <[email protected]>

1 files changed, 999 insertions, 0 deletions

diff --git a/src/javax/media/j3d/Text3DRetained.java b/src/javax/media/j3d/Text3DRetained.java
new file mode 100644
index 0000000..ed21941
--- /dev/null
+++ b/src/javax/media/j3d/Text3DRetained.java
@@ -0,0 +1,999 @@
+/*
+ * Copyright 1998-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+package javax.media.j3d;
+
+import java.awt.font.GlyphVector;
+import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
+
+import javax.vecmath.Point3d;
+import javax.vecmath.Point3f;
+import javax.vecmath.Vector3f;
+
+/**
+ * Implements Text3D class.
+ */
+class Text3DRetained extends GeometryRetained {
+    /**
+     * Packaged scope variables needed for implementation
+     */
+    Font3D      font3D = null;
+    String      string = null;
+    Point3f     position = new Point3f(0.0f, 0.0f, 0.0f);
+    int         alignment = Text3D.ALIGN_FIRST, path = Text3D.PATH_RIGHT;
+    float       charSpacing = 0.0f;
+    int         numChars = 0;
+    static final int  targetThreads = (J3dThread.UPDATE_TRANSFORM |
+				       J3dThread.UPDATE_GEOMETRY |
+				       J3dThread.UPDATE_RENDER);
+    /**
+     * The temporary transforms for this Text3D
+     */
+    Transform3D[] charTransforms = new Transform3D[0];
+
+    /**
+     * A cached list of geometry arrays for the current settings
+     */
+    GeometryArrayRetained[] geometryList = new GeometryArrayRetained[0];
+    GlyphVector[] glyphVecs = new GlyphVector[0];
+
+    /**
+     * Bounding box data for this text string.
+     */
+    Point3d lower = new Point3d();
+    Point3d upper = new Point3d();
+
+
+    /**
+     * An Array list used for messages
+     */
+    ArrayList newGeometryAtomList = new ArrayList();
+    ArrayList oldGeometryAtomList = new ArrayList();
+
+
+    /**
+     * temporary model view matrix for immediate mode only
+     */
+    Transform3D vpcToEc;
+    Transform3D drawTransform;
+
+
+    Text3DRetained(){
+       this.geoType = GEO_TYPE_TEXT3D;
+    }
+
+
+    @Override
+    synchronized void computeBoundingBox() {
+	Point3d l = new Point3d();
+	Point3d u = new Point3d();
+        Vector3f location = new Vector3f(this.position);
+        int i, k=0, numTotal=0;
+        double width = 0, height = 0;
+        Rectangle2D bounds;
+
+        //Reset bounds data
+        l.set(location);
+        u.set(location);
+
+	if (numChars != 0) {
+	    // Set loop counters based on path type
+	    if (path == Text3D.PATH_RIGHT || path == Text3D.PATH_UP) {
+		k = 0;
+		numTotal = numChars + 1;
+	    } else if (path == Text3D.PATH_LEFT || path == Text3D.PATH_DOWN) {
+		k = 1;
+		numTotal = numChars;
+		// Reset bounds to bounding box if first character
+		bounds = glyphVecs[0].getVisualBounds();
+		u.x += bounds.getWidth();
+		u.y += bounds.getHeight();
+	    }
+
+	    for (i=1; i<numTotal; i++, k++) {
+		width = glyphVecs[k].getLogicalBounds().getWidth();
+		bounds = glyphVecs[k].getVisualBounds();
+		// 'switch' could be outside loop with little hacking,
+		width += charSpacing;
+		height = bounds.getHeight();
+
+		switch (this.path) {
+		case Text3D.PATH_RIGHT:
+		    u.x    += (width);
+		    if (u.y < (height + location.y)) {
+			u.y = location.y + height;
+		    }
+		    break;
+		case Text3D.PATH_LEFT:
+		    l.x    -= (width);
+		    if (u.y < ( height + location.y)) {
+			u.y = location.y + height;
+		    }
+		    break;
+		case Text3D.PATH_UP:
+		    u.y    += height;
+		    if (u.x < (bounds.getWidth() + location.x)) {
+			u.x = location.x + bounds.getWidth();
+		    }
+		    break;
+		case Text3D.PATH_DOWN:
+		    l.y    -= height;
+		    if (u.x < (bounds.getWidth() + location.x)) {
+			u.x = location.x + bounds.getWidth();
+		    }
+		    break;
+		}
+	    }
+
+	    // Handle string alignment. ALIGN_FIRST is handled by default
+	    if (alignment != Text3D.ALIGN_FIRST) {
+		double cx = (u.x - l.x);
+		double cy = (u.y - l.y);
+
+		if (alignment == Text3D.ALIGN_CENTER) {
+		    cx *= .5;
+		    cy *= .5;
+		}
+		switch (path) {
+		case Text3D.PATH_RIGHT:
+		    l.x -= cx;
+		    u.x -= cx;
+		    break;
+		case Text3D.PATH_LEFT:
+		    l.x += cx;
+		    u.x += cx;
+		    break;
+		case Text3D.PATH_UP:
+		    l.y -= cy;
+		    u.y -= cy;
+		    break;
+		case Text3D.PATH_DOWN:
+		    l.y += cy;
+		    u.y += cy;
+		    break;
+
+		}
+	    }
+	}
+
+        l.z = 0.0f;
+        if ((font3D == null) || (font3D.fontExtrusion == null)) {
+	    u.z = l.z;
+        } else {
+	    u.z = l.z + font3D.fontExtrusion.length;
+	}
+    }
+
+    @Override
+    void update() {}
+
+
+    /**
+     * Returns the Font3D objects used by this Text3D NodeComponent object.
+     *
+     * @return the Font3D object of this Text3D node - null if no Font3D
+     *  has been associated with this node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final Font3D getFont3D() {
+        return this.font3D;
+    }
+
+    /**
+     * Sets the Font3D object used by this Text3D NodeComponent object.
+     *
+     * @param font3d the Font3D object to associate with this Text3D node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final void setFont3D(Font3D font3d) {
+	geomLock.getLock();
+	this.font3D = font3d;
+	updateCharacterData();
+	geomLock.unLock();
+	sendDataChangedMessage();
+    }
+
+    /**
+     * Copies the character string used in the construction of the
+     * Text3D node into the supplied parameter.
+     *
+     * @return a copy of the String object in this Text3D node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final String getString() {
+	return this.string;
+    }
+
+    /**
+     * Copies the character string from the supplied parameter into Tex3D
+     * node.
+     *
+     * @param string the String object to recieve the Text3D node's string.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final void setString(String string) {
+	geomLock.getLock();
+	this.string = string;
+	if (string == null) {
+	    numChars = 0;
+	} else {
+	    numChars = string.length();
+	}
+	updateCharacterData();
+	geomLock.unLock();
+	sendDataChangedMessage();
+    }
+
+    /**
+     * Copies the node's <code>position</code> field into the supplied
+     * parameter.  The <code>position</code> is used to determine the
+     * initial placement of the Text3D string.  The position, combined with
+     * the path and alignment control how the text is displayed.
+     *
+     * @param position the point to position the text.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     *
+     * @see #getAlignment
+     * @see #getPath
+     */
+    final void getPosition(Point3f position) {
+        position.set(this.position);
+    }
+
+    /**
+     * Sets the node's <code>position</code> field to the supplied
+     * parameter.  The <code>position</code> is used to determine the
+     * initial placement of the Text3D string.  The position, combined with
+     * the path and alignment control how the text is displayed.
+     *
+     * @param position the point to position the text.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     *
+     * @see #getAlignment
+     * @see #getPath
+     */
+    final void setPosition(Point3f position) {
+	geomLock.getLock();
+        this.position.set(position);
+        updateTransformData();
+	geomLock.unLock();
+        sendTransformChangedMessage();
+    }
+
+    /**
+     * Retrieves the text alignment policy for this Text3D NodeComponent
+     * object. The <code>alignment</code> is used to specify how
+     * glyphs in the string are placed in relation to the
+     * <code>position</code> field.  Valid values for this field
+     * are:
+     * <UL>
+     * <LI> ALIGN_CENTER - the center of the string is placed on the
+     *  <code>position</code> point.
+     * <LI> ALIGN_FIRST - the first character of the string is placed on
+     *   the <code>position</code> point.
+     * <LI> ALIGN_LAST - the last character of the string is placed on the
+     *   <code>position</code> point.
+     * </UL>
+     * The default value of this field is <code>ALIGN_FIRST</code>.
+     *
+     * @return the current alingment policy for this node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     *
+     * @see #getPosition
+     */
+    final int getAlignment() {
+        return alignment;
+    }
+
+    /**
+     * Sets the text alignment policy for this Text3D NodeComponent
+     * object. The <code>alignment</code> is used to specify how
+     * glyphs in the string are placed in relation to the
+     * <code>position</code> field.  Valid values for this field
+     * are:
+     * <UL>
+     * <LI> ALIGN_CENTER - the center of the string is placed on the
+     *  <code>position</code> point.
+     * <LI> ALIGN_FIRST - the first character of the string is placed on
+     *   the <code>position</code> point.
+     * <LI> ALIGN_LAST - the last character of the string is placed on the
+     *   <code>position</code> point.
+     * </UL>
+     * The default value of this field is <code>ALIGN_FIRST</code>.
+     *
+     * @return the current alingment policy for this node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     *
+     * @see #getPosition
+     */
+    final void setAlignment(int alignment) {
+	geomLock.getLock();
+        this.alignment = alignment;
+        updateTransformData();
+	geomLock.unLock();
+        sendTransformChangedMessage();
+    }
+
+    /**
+     * Retrieves the node's <code>path</code> field.  This field
+     * is used  to specify how succeeding
+     * glyphs in the string are placed in relation to the previous glyph.
+     * Valid values for this field are:
+     * <UL>
+     * <LI> PATH_LEFT: - succeeding glyphs are placed to the left of the
+     *  current glyph.
+     * <LI> PATH_RIGHT: - succeeding glyphs are placed to the right of the
+     *  current glyph.
+     * <LI> PATH_UP: - succeeding glyphs are placed above the current glyph.
+     * <LI> PATH_DOWN: - succeeding glyphs are placed below the current glyph.
+     * </UL>
+     * The default value of this field is <code>PATH_RIGHT</code>.
+     *
+     * @return the current alingment policy for this node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final int getPath() {
+        return this.path;
+    }
+
+    /**
+     * Sets the node's <code>path</code> field.  This field
+     * is used  to specify how succeeding
+     * glyphs in the string are placed in relation to the previous glyph.
+     * Valid values for this field are:
+     * <UL>
+     * <LI> PATH_LEFT - succeeding glyphs are placed to the left of the
+     *  current glyph.
+     * <LI> PATH_RIGHT - succeeding glyphs are placed to the right of the
+     *  current glyph.
+     * <LI> PATH_UP - succeeding glyphs are placed above the current glyph.
+     * <LI> PATH_DOWN - succeeding glyphs are placed below the current glyph.
+     * </UL>
+     * The default value of this field is <code>PATH_RIGHT</code>.
+     *
+     * @param path the value to set the path to.
+     *
+     * @return the current alingment policy for this node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final void setPath(int path) {
+        this.path = path;
+        updateTransformData();
+        sendTransformChangedMessage();
+    }
+
+    /**
+     * Retrieves the 3D bounding box that encloses this Text3D object.
+     *
+     * @param bounds the object to copy the bounding information to.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     *
+     * @see BoundingBox
+     */
+    final void getBoundingBox(BoundingBox bounds) {
+	synchronized (this) {
+            bounds.setLower(lower);
+            bounds.setUpper(upper);
+	}
+    }
+
+    /**
+     * Retrieves the character spacing used to construct the Text3D string.
+     * This spacing is in addition to the regular spacing between glyphs as
+     * defined in the Font object.  1.0 in this space is measured as the
+     * width of the largest glyph in the 2D Font.  The default value is
+     * 0.0.
+     *
+     * @return the current character spacing value
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final float getCharacterSpacing() {
+	return charSpacing;
+    }
+
+    /**
+     * Sets the character spacing used hwne constructing the Text3D string.
+     * This spacing is in addition to the regular spacing between glyphs as
+     * defined in the Font object.  1.0 in this space is measured as the
+     * width of the largest glyph in the 2D Font.  The default value is
+     * 0.0.
+     *
+     * @param characterSpacing the new character spacing value
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     */
+    final void setCharacterSpacing(float characterSpacing) {
+	geomLock.getLock();
+	this.charSpacing = characterSpacing;
+        updateTransformData();
+	geomLock.unLock();
+        sendTransformChangedMessage();
+    }
+
+
+    final void sendDataChangedMessage() {
+	J3dMessage[] m;
+	int i, j, k, kk, numMessages;
+	int gSize;
+	ArrayList gaList;
+	GeometryAtom[] newGeometryAtoms;
+	ArrayList tiArrList = new ArrayList();
+	ArrayList newCtArrArrList = new ArrayList();
+
+	synchronized(liveStateLock) {
+	    if (source.isLive()) {
+		synchronized (universeList) {
+		    numMessages = universeList.size();
+		    m = new J3dMessage[numMessages];
+		    for (i=0; i<numMessages; i++) {
+			m[i] = new J3dMessage();
+			m[i].type = J3dMessage.TEXT3D_DATA_CHANGED;
+			m[i].threads = targetThreads;
+			ArrayList<Shape3DRetained> shapeList = userLists.get(i);
+			newGeometryAtomList.clear();
+			oldGeometryAtomList.clear();
+
+			for (j=0; j<shapeList.size(); j++) {
+				Shape3DRetained s = shapeList.get(j);
+			    if (s.boundsAutoCompute) {
+				// update combine bounds of mirrorShape3Ds. So we need to
+				// use its bounds and not localBounds.
+				// bounds is actually a reference to
+				// mirrorShape3D.source.localBounds.
+				// XXXX : Should only need to update distinct localBounds.
+				s.getCombineBounds((BoundingBox)s.bounds);
+			    }
+
+			    gSize = s.geometryList.size();
+
+			    GeometryAtom oldGA = Shape3DRetained.getGeomAtom(s);
+			    GeometryAtom newGA = new GeometryAtom();
+
+			    int geometryCnt = 0;
+			    for(k = 0; k<gSize; k++) {
+				GeometryRetained geomRetained = s.geometryList.get(k);
+				if(geomRetained != null) {
+				    Text3DRetained tempT3d = (Text3DRetained)geomRetained;
+				    geometryCnt += tempT3d.numChars;
+				}
+				else {
+				    // Slightly wasteful, but not quite worth to optimize yet.
+				    geometryCnt++;
+				}
+			    }
+
+			    newGA.geometryArray = new GeometryRetained[geometryCnt];
+			    newGA.lastLocalTransformArray = new Transform3D[geometryCnt];
+			    // Reset geometryCnt;
+			    geometryCnt = 0;
+
+			    newGA.locale = s.locale;
+			    newGA.visible = s.visible;
+			    newGA.source = s;
+			    int gaCnt=0;
+			    GeometryRetained geometry = null;
+			    for(; gaCnt<gSize; gaCnt++) {
+				geometry = s.geometryList.get(gaCnt);
+				if(geometry != null) {
+				    newGA.geoType = geometry.geoType;
+				    newGA.alphaEditable = s.isAlphaEditable(geometry);
+				    break;
+				}
+			    }
+
+			    for(; gaCnt<gSize; gaCnt++) {
+				geometry = s.geometryList.get(gaCnt);
+				if(geometry == null) {
+				    newGA.geometryArray[gaCnt] = null;
+				}
+				else {
+				    Text3DRetained t = (Text3DRetained)geometry;
+				    GeometryRetained geo;
+				    for (k=0; k<t.numChars; k++, geometryCnt++) {
+					geo = t.geometryList[k];
+					if (geo != null) {
+					    newGA.geometryArray[geometryCnt] = geo;
+					    newGA.lastLocalTransformArray[geometryCnt] =
+						t.charTransforms[k];
+
+					} else {
+					    newGA.geometryArray[geometryCnt] = null;
+					    newGA.lastLocalTransformArray[geometryCnt] = null;
+					}
+
+				    }
+
+				}
+			    }
+
+			    oldGeometryAtomList.add(oldGA);
+			    newGeometryAtomList.add(newGA);
+			    Shape3DRetained.setGeomAtom(s, newGA);
+			}
+
+			Object[] oldGAArray = oldGeometryAtomList.toArray();
+			Object[] newGAArray = newGeometryAtomList.toArray();
+			ArrayList uniqueList = getUniqueSource(shapeList);
+			int numSrc = uniqueList.size();
+			int numMS3D;
+			Shape3DRetained ms, src;
+
+            		for (j=0; j<numSrc; j++) {
+            		    CachedTargets[] newCtArr = null;
+			    src = (Shape3DRetained)uniqueList.get(j);
+			    numMS3D = src.mirrorShape3D.size();
+
+        		    TargetsInterface ti = ((GroupRetained)src.
+				parent).getClosestTargetsInterface(
+                                        TargetsInterface.TRANSFORM_TARGETS);
+
+        		    if (ti != null) {
+            		        CachedTargets ct;
+            		        newCtArr = new CachedTargets[numMS3D];
+
+				for (k=0; k<numMS3D; k++) {
+				    ms = src.mirrorShape3D.get(k);
+
+				    GeometryAtom ga =
+					Shape3DRetained.getGeomAtom(ms);
+				    for(kk=0; kk<newGAArray.length; kk++) {
+					if(ga == newGAArray[kk]) {
+					    break;
+					}
+				    }
+
+				    if(kk==newGAArray.length) {
+					System.err.println("Text3DRetained : Problem !!! Can't find matching geomAtom");
+				    }
+
+				    ct = ti.getCachedTargets(TargetsInterface.
+							     TRANSFORM_TARGETS, k, -1);
+				    if (ct != null) {
+					newCtArr[k] = new CachedTargets();
+					newCtArr[k].copy(ct);
+					newCtArr[k].replace((NnuId)oldGAArray[kk],
+							    (NnuId)newGAArray[kk],
+							    Targets.GEO_TARGETS);
+				    } else {
+					newCtArr[k] = null;
+				    }
+
+				}
+
+            			ti.resetCachedTargets(
+				  TargetsInterface.TRANSFORM_TARGETS, newCtArr, -1);
+
+				tiArrList.add(ti);
+				newCtArrArrList.add(newCtArr);
+
+			    }
+
+			}
+
+			m[i].args[0] = oldGAArray;
+			m[i].args[1] = newGAArray;
+			m[i].universe = universeList.get(i);
+
+			if(tiArrList.size() > 0) {
+			    m[i].args[2] = tiArrList.toArray();
+			    m[i].args[3] = newCtArrArrList.toArray();
+			}
+
+			tiArrList.clear();
+			newCtArrArrList.clear();
+
+		    }
+		    VirtualUniverse.mc.processMessage(m);
+		}
+
+	    }
+	}
+    }
+
+
+    final void sendTransformChangedMessage() {
+	J3dMessage[] m;
+	int i, j, numMessages, sCnt;
+	ArrayList gaList = new ArrayList();
+	GeometryRetained geomR;
+	synchronized(liveStateLock) {
+	    if (source.isLive()) {
+		synchronized (universeList) {
+		    numMessages = universeList.size();
+		    m = new J3dMessage[numMessages];
+		    for (i=0; i<numMessages; i++) {
+			m[i] = new J3dMessage();
+			m[i].type = J3dMessage.TEXT3D_TRANSFORM_CHANGED;
+			m[i].threads = targetThreads;
+			ArrayList<Shape3DRetained> shapeList = userLists.get(i);
+			// gaList = new GeometryAtom[shapeList.size() * numChars];
+			for (j = 0; j < shapeList.size(); j++) {
+				Shape3DRetained s = shapeList.get(j);
+
+			    // Find the right geometry.
+			    for(sCnt=0; sCnt<s.geometryList.size(); sCnt++) {
+				geomR = s.geometryList.get(sCnt);
+				if(geomR == this) {
+				    break;
+				}
+			    }
+
+			    if(sCnt < s.geometryList.size())
+				gaList.add(Shape3DRetained.getGeomAtom(s));
+
+			}
+			m[i].args[0] = gaList.toArray();
+			m[i].args[1] = charTransforms;
+			m[i].universe = universeList.get(i);
+		    }
+		    VirtualUniverse.mc.processMessage(m);
+		}
+	    }
+	}
+    }
+
+    /**
+     * Update internal reprsentation of tranform matrices and geometry.
+     * This method will be called whenever string or font3D change.
+     */
+    final void updateCharacterData() {
+	char c[] = new char[1];
+
+	if (geometryList.length != numChars) {
+	    geometryList = new GeometryArrayRetained[numChars];
+	    glyphVecs = new GlyphVector[numChars];
+	}
+
+	if (font3D != null) {
+            for (int i=0; i<numChars; i++) {
+		c[0] = string.charAt(i);
+		glyphVecs[i] = font3D.font.createGlyphVector(font3D.frc, c);
+	        geometryList[i] = font3D.triangulateGlyphs(glyphVecs[i], c[0]);
+            }
+	}
+
+        updateTransformData();
+    }
+
+    /**
+     * Update per character transform based on Text3D location,
+     * per character size and path.
+     *
+     * WARNING: Caller of this method must make sure SceneGraph is live,
+     * else exceptions may be thrown.
+     */
+    final void updateTransformData(){
+        int i, k=0, numTotal=0;
+        double width = 0, height = 0;
+        Vector3f location = new Vector3f(this.position);
+        Rectangle2D bounds;
+
+        //Reset bounds data
+        lower.set(location);
+        upper.set(location);
+
+	charTransforms = new Transform3D[numChars];
+	for (i=0; i<numChars; i++) {
+	    charTransforms[i] = new Transform3D();
+	}
+
+	if (numChars != 0) {
+	    charTransforms[0].set(location);
+
+	    // Set loop counters based on path type
+	    if (path == Text3D.PATH_RIGHT || path == Text3D.PATH_UP) {
+		k = 0;
+		numTotal = numChars + 1;
+	    } else if (path == Text3D.PATH_LEFT || path == Text3D.PATH_DOWN) {
+		k = 1;
+		numTotal = numChars;
+		// Reset bounds to bounding box if first character
+		bounds = glyphVecs[0].getVisualBounds();
+		upper.x += bounds.getWidth();
+		upper.y += bounds.getHeight();
+	    }
+
+	    for (i=1; i<numTotal; i++, k++) {
+		width = glyphVecs[k].getLogicalBounds().getWidth();
+		bounds = glyphVecs[k].getVisualBounds();
+		// 'switch' could be outside loop with little hacking,
+		width += charSpacing;
+		height = bounds.getHeight();
+
+		switch (this.path) {
+		case Text3D.PATH_RIGHT:
+		    location.x += width;
+		    upper.x    += (width);
+		    if (upper.y < (height + location.y)) {
+			upper.y = location.y + height;
+		    }
+		    break;
+		case Text3D.PATH_LEFT:
+		    location.x -= width;
+		    lower.x    -= (width);
+		    if (upper.y < ( height + location.y)) {
+			upper.y = location.y + height;
+		    }
+		    break;
+		case Text3D.PATH_UP:
+		    location.y += height;
+		    upper.y    += height;
+		    if (upper.x < (bounds.getWidth() + location.x)) {
+			upper.x = location.x + bounds.getWidth();
+		    }
+		    break;
+		case Text3D.PATH_DOWN:
+		    location.y -= height;
+		    lower.y    -= height;
+		    if (upper.x < (bounds.getWidth() + location.x)) {
+			upper.x = location.x + bounds.getWidth();
+		    }
+		    break;
+		}
+		if (i < numChars) {
+		    charTransforms[i].set(location);
+		}
+	    }
+
+	    // Handle string alignment. ALIGN_FIRST is handled by default
+	    if (alignment != Text3D.ALIGN_FIRST) {
+		double cx = (upper.x - lower.x);
+		double cy = (upper.y - lower.y);
+
+		if (alignment == Text3D.ALIGN_CENTER) {
+		    cx *= .5;
+		    cy *= .5;
+		}
+		switch (path) {
+		case Text3D.PATH_RIGHT:
+		    for (i=0;i < numChars;i++) {
+			charTransforms[i].mat[3] -= cx;
+		    }
+		    lower.x -= cx;
+		    upper.x -= cx;
+		    break;
+		case Text3D.PATH_LEFT:
+		    for (i=0;i < numChars;i++) {
+			charTransforms[i].mat[3] += cx;
+		    }
+		    lower.x += cx;
+		    upper.x += cx;
+		    break;
+
+		case Text3D.PATH_UP:
+		    for (i=0;i < numChars;i++) {
+			charTransforms[i].mat[7] -=cy;
+		    }
+		    lower.y -= cy;
+		    upper.y -= cy;
+		    break;
+		case Text3D.PATH_DOWN:
+		    for (i=0;i < numChars;i++) {
+			charTransforms[i].mat[7] +=cy;
+		    }
+		    lower.y += cy;
+		    upper.y += cy;
+		    break;
+
+		}
+	    }
+	}
+
+        lower.z = 0.0f;
+        if ((font3D == null) || (font3D.fontExtrusion == null)) {
+	    upper.z = lower.z;
+        } else {
+	    upper.z = lower.z + font3D.fontExtrusion.length;
+	}
+
+        // update geoBounds
+        getBoundingBox(geoBounds);
+    }
+
+
+    /**
+     * This method is called when the SceneGraph becomes live. All characters
+     * used by this.string are tesselated in this method, to avoid wait during
+     * traversal and rendering.
+     */
+    @Override
+    void setLive(boolean inBackgroundGroup, int refCount) {
+      // Tesselate all character data and update character transforms
+      updateCharacterData();
+      super.doSetLive(inBackgroundGroup, refCount);
+      super.markAsLive();
+    }
+
+    // TODO -- Need to rethink. Might have to consider charTransform[] in returns pickInfo.
+    @Override
+    boolean intersect(PickShape pickShape, PickInfo pickInfo, int flags, Point3d iPnt,
+                      GeometryRetained geom, int geomIndex) {
+	Transform3D tempT3D = new Transform3D();
+	GeometryArrayRetained geo = null;
+	int sIndex = -1;
+	PickShape newPS;
+	double minDist = Double.MAX_VALUE;
+        double distance =0.0;
+        Point3d closestIPnt = new Point3d();
+
+	for (int i=0; i < numChars; i++) {
+	    geo= geometryList[i];
+	    if (geo != null) {
+		tempT3D.invert(charTransforms[i]);
+		newPS = pickShape.transform(tempT3D);
+		if (geo.intersect(newPS, pickInfo, flags, iPnt, geom,  geomIndex)) {
+		    if (flags == 0) {
+			return true;
+		    }
+                    distance = newPS.distance(iPnt);
+		    if (distance < minDist) {
+			sIndex = i;
+			minDist = distance;
+                        closestIPnt.set(iPnt);
+		    }
+		}
+	    }
+	}
+
+	if (sIndex >= 0) {
+	    // We need to transform iPnt to the vworld to compute the actual distance.
+	    // In this method we'll transform iPnt by its char. offset. Shape3D will
+	    // do the localToVworld transform.
+	    iPnt.set(closestIPnt);
+	    charTransforms[sIndex].transform(iPnt);
+	    return true;
+	}
+	return false;
+    }
+
+    @Override
+    boolean intersect(Point3d[] pnts) {
+	Transform3D tempT3D = new Transform3D();
+	GeometryArrayRetained ga;
+	boolean isIntersect = false;
+	Point3d transPnts[] = new Point3d[pnts.length];
+	for (int j=pnts.length-1; j >= 0; j--) {
+	    transPnts[j] = new Point3d();
+	}
+
+	for (int i=numChars-1; i >= 0;  i--) {
+	    ga = geometryList[i];
+	    if ( ga != null) {
+		tempT3D.invert(charTransforms[i]);
+		for (int j=pnts.length-1; j >= 0; j--) {
+		    tempT3D.transform(pnts[j], transPnts[j]);
+		}
+		if (ga.intersect(transPnts)) {
+		    isIntersect = true;
+		    break;
+		}
+	    }
+	}
+	return isIntersect;
+    }
+
+
+    @Override
+    boolean intersect(Transform3D thisToOtherVworld, GeometryRetained geom) {
+	GeometryArrayRetained ga;
+
+	for (int i=numChars-1; i >=0; i--) {
+	    ga = geometryList[i];
+	    if ((ga != null) && ga.intersect(thisToOtherVworld, geom)) {
+		return true;
+	    }
+	}
+
+	return false;
+    }
+
+    @Override
+    boolean intersect(Bounds targetBound) {
+	GeometryArrayRetained ga;
+
+	for (int i=numChars-1; i >=0; i--) {
+	    ga = geometryList[i];
+	    if ((ga != null) && ga.intersect(targetBound)) {
+		return true;
+	    }
+	}
+
+	return false;
+
+    }
+
+    void setModelViewMatrix(Transform3D vpcToEc, Transform3D drawTransform) {
+	this.vpcToEc = vpcToEc;
+	this.drawTransform = drawTransform;
+    }
+
+
+    @Override
+    void execute(Canvas3D cv, RenderAtom ra, boolean isNonUniformScale,
+		 boolean updateAlpha, float alpha,
+		 int screen,
+		 boolean ignoreVertexColors) {
+
+	Transform3D trans = new Transform3D();
+
+	for (int i = 0; i < geometryList.length; i++) {
+	    trans.set(drawTransform);
+	    trans.mul(charTransforms[i]);
+	    cv.setModelViewMatrix(cv.ctx, vpcToEc.mat, trans);
+	    geometryList[i].execute(cv, ra, isNonUniformScale, updateAlpha, alpha,
+				    screen, ignoreVertexColors);
+	}
+    }
+
+    @Override
+    int getClassType() {
+	return TEXT3D_TYPE;
+    }
+
+
+    ArrayList getUniqueSource(ArrayList shapeList) {
+	ArrayList uniqueList = new ArrayList();
+	int size = shapeList.size();
+	Object src;
+	int i, index;
+
+	for (i=0; i<size; i++) {
+	    src = ((Shape3DRetained)shapeList.get(i)).sourceNode;
+            index = uniqueList.indexOf(src);
+            if (index == -1) {
+                uniqueList.add(src);
+            }
+        }
+	return uniqueList;
+    }
+}
+