Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *  osgVP. OSG Virtual Planets.

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 Instituto de Automática e Informática Industrial, UPV.

 */

/**

 * 

 */

package org.gvsig.driver;

import java.awt.Color;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.util.Vector;

import java.util.logging.Level;

import org.gvsig.GeometryFactory3D;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.primitive.AbstractPrimitive;

import org.gvsig.geometries3D.Material;

import org.gvsig.geometries3D.MultiGeometry;

import org.gvsig.geometries3D.MultiSolid;

import org.gvsig.geometries3D.Point3D;

import org.gvsig.geometries3D.PrimitiveSet;

import org.gvsig.geometries3D.Solid;

import org.gvsig.gpe.IGPEContentHandler3D;

import org.gvsig.gpe.parser.GPEContentHandler;

import org.gvsig.osgvp.util.Util;

/**

 * @author rgaitan

 * 

 */

public class OSGDriver extends GPEContentHandler implements

		IGPEContentHandler3D {

	private MultiGeometry _root;

	@Override

	public Object startMultiGeometry(String id, String srs) {

		Util.logger.log(Level.FINEST, "Starting MultiGeometry");

		MultiGeometry feature = (MultiGeometry) ((GeometryFactory3D) GeometryManager

				.getInstance().getGeometryFactory()).createMultiGeometry(id);

		if (_root == null)

			_root = feature;

		return feature;

	}

	public Object startMultiSolid(String id, String srs) {

		Util.logger.log(Level.FINEST, "Starting MultiSolid");

		return (MultiSolid) ((GeometryFactory3D) GeometryManager.getInstance()

				.getGeometryFactory()).createMultiSolid(id);

	}

	public void endMultiSolid(Object solid) {

	}

	public Object startSolid(String id, String srs) {

		// Util.logger.log(Level.FINEST,"Starting Geometry");

		Solid geometry = (Solid) ((GeometryFactory3D) GeometryManager

				.getInstance().getGeometryFactory()).createSolid(id);

		return geometry;

	}

	public void endSolid(Object geometry) {

		// Util.logger.log(Level.FINEST,"Ending Geometry");

	}

	@Override

	public void addGeometryToMultiGeometry(Object geometry, Object multiGeometry) {

		// Util.logger.log(Level.FINEST,"Adding Feature to Feature");

		((MultiGeometry) multiGeometry)

				.addGeometry((AbstractPrimitive) geometry);

	}

	public void addSolidToMultiSolid(Object solid, Object multiSolid) {

		// Util.logger.log(Level.FINEST,"Adding Geometry to Feature");

		((MultiSolid) multiSolid).addSolid((Solid) solid);

	}

	public void startSolidVertexArray(Object geometry) {

	}

	public void endSolidVertexArray() {

	}

	public void startSolidNormalArray(Object geometry) {

	}

	public void endSolidNormalArray() {

	}

	public void startSolidColorArray(Object geometry) {

	}

	public void endSolidColorArray() {

	}

	public void startSolidTexCoordArray(Object geometry, int nTexCoords,

			int stage) {

	}

	public void endSolidTexCoordArray() {

	}

	public void addVertexToSolid(Object geometry, double x, double y, double z) {

		Point3D point = (Point3D) ((GeometryFactory3D) GeometryManager

				.getInstance().getGeometryFactory()).createPoint3D("");

		point.setX(x);

		point.setY(y);

		point.setZ(z);

		((Solid) geometry).getVertices().add(point);

		// Util.logger.log(Level.FINEST,"Adding Vertex");

	}

	public void addNormalToSolid(Object geometry, double x, double y, double z) {

		Point3D point = (Point3D) ((GeometryFactory3D) GeometryManager

				.getInstance().getGeometryFactory()).createPoint3D("");

		point.setX(x);

		point.setY(y);

		point.setZ(z);

		((Solid) geometry).getNormals().add(point);

		Util.logger.log(Level.FINEST, "Adding Normal" + point.getX());

	}

	public void addTextureToSolid(Object geometry, int stage,

			BufferedImage image) {

		((Solid) geometry).getTextures().add(stage, image);

	}

	public void setNormalBindingToSolid(Object geometry, int mode) {

		((Solid) geometry).setNormalBinding(mode);

	}

	public void setColorBindingToSolid(Object geometry, int mode) {

		((Solid) geometry).setColorBinding(mode);

	}

	public void addColorToSolid(Object geometry, float r, float g, float b,

			float a) {

		((Solid) geometry).getColors().add(convertColor(r, g, b, a));

	}

	public void addTextureCoordinateToSolid(Object geometry, double x,

			double y, int stage) {

		try {

			((Solid) geometry).getTexcoord().get(stage);

		} catch (ArrayIndexOutOfBoundsException ex) {

			((Solid) geometry).getTexcoord().add(stage, new Vector<Point2D>());

		}

		Point2D point = new Point2D.Double();

		point.setLocation(x, y);

		((Solid) geometry).getTexcoord().get(stage).add(point);

	}

	public MultiGeometry getRootFeature() {

		return _root;

	}

	public void addPrimitiveSetToSolid(Object geometry, Object primitiveSet) {

		((Solid) geometry).getPrimitiveSets().add((PrimitiveSet) primitiveSet);

	}

	public void addIndexToPrimitiveSet(Object primitiveSet, int i) {

		((PrimitiveSet) primitiveSet).getIndices().add(i);

	}

	public void endPrimitiveSet(Object primitiveSet) {

	}

	public void endPrimitiveSetIndexArray() {

	}

	public Object startPrimitiveSet(int mode, int type) {

		return new PrimitiveSet(mode, type);

	}

	public void startPrimitiveSetIndexArray(Object primitiveSet, int indices) {

		((PrimitiveSet) primitiveSet).setIndices(new Vector<Integer>());

	}

	public void addMaterialToSolid(Object solid, Object material) {

		((Solid) solid).setMaterial((Material) material);

	}

	public void endMaterial(Object material) {

	}

	public Object startMaterial() {

		Material material = new Material();

		return material;

	}

	public void addAmbientToMaterial(Object material, float r, float g,

			float b, float a) {

		((Material) material).setAmbient(convertColor(r, g, b, a));

	}

	public void addDiffuseToMaterial(Object material, float r, float g,

			float b, float a) {

		((Material) material).setDiffuse(convertColor(r, g, b, a));

	}

	public void addEmissionToMaterial(Object material, float r, float g,

			float b, float a) {

		((Material) material).setEmission(convertColor(r, g, b, a));

	}

	public void addShininessToMaterial(Object material, float s) {

		((Material) material).setShininess(s);

	}

	public void addSpecularToMaterial(Object material, float r, float g,

			float b, float a) {

		((Material) material).setSpecular(convertColor(r, g, b, a));

	}

	protected Color convertColor(float r, float g, float b, float a) {

		int _r, _g, _b, _a;

		_r = Math.min((int) (r * 255), 255);

		_g = Math.min((int) (g * 255), 255);

		_b = Math.min((int) (b * 255), 255);

		_a = Math.min((int) (a * 255), 255);

		Color color = new Color(_r, _g, _b, _a);

		return color;

	}

	public void addBlendingToSolid(Object solid, boolean blending) {

		((Solid) solid).setBlending(blending);

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*  osgVP. OSG Virtual Planets.

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2008 Instituto de Automática e Informática Industrial, UPV.

*/

package org.gvsig.gpe;

import java.awt.image.BufferedImage;

import org.gvsig.gpe.parser.IGPEContentHandler;

public interface IGPEContentHandler3D extends IGPEContentHandler {

	public Object startSolid(String id, String srs);

	public void endSolid(Object solid);

	public Object startMultiSolid(String id, String srs);

	public void endMultiSolid(Object solid);

	public void addSolidToMultiSolid(Object solid, Object feature);

	public void startSolidVertexArray(Object solid);

	public void endSolidVertexArray();

	public void startSolidNormalArray(Object solid);

	public void endSolidNormalArray();

	public void startSolidColorArray(Object solid);

	public void endSolidColorArray();

	public void startSolidTexCoordArray(Object solid, int nTexCoords, int stage);

	public void endSolidTexCoordArray();

	public void addVertexToSolid(Object solid, double x, double y, double z);

	public void addNormalToSolid(Object solid, double x, double y, double z);

	public void addTextureToSolid(Object geometry, int stage, BufferedImage image);

	public void setNormalBindingToSolid(Object solid, int mode );

	public void setColorBindingToSolid(Object solid, int mode );

	public void addColorToSolid(Object solid, float r, float g, float b, float a);

	public void addTextureCoordinateToSolid(Object solid, double x, double y, int stage);

	public Object startPrimitiveSet(int mode, int type);

	public void endPrimitiveSet(Object primitiveSet);

	public void addPrimitiveSetToSolid(Object solid, Object primitiveSet);

	public void startPrimitiveSetIndexArray(Object primitiveSet, int nIndices);

	public void endPrimitiveSetIndexArray();

	public void addIndexToPrimitiveSet(Object primitiveSet, int i);

	public Object startMaterial();

	public void addMaterialToSolid(Object solid, Object material);

	public void endMaterial(Object material);

	public void addAmbientToMaterial(Object material, float r, float g, float b, float a);

	public void addDiffuseToMaterial(Object material, float r, float g, float b, float a);

	public void addSpecularToMaterial(Object material, float r, float g, float b, float a);

	public void addEmissionToMaterial(Object material, float r, float g, float b, float a);

	public void addShininessToMaterial(Object material, float s);

	public void addBlendingToSolid(Object solid, boolean blending);

}

/* gvSIG. Geographic Information System of the Valencian Government

 *  osgVP. OSG Virtual Planets.

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2008 Instituto de Automática e Informática Industrial, UPV.

 */

package org.gvsig.gpe.osg;

import java.awt.Color;

import java.awt.image.BufferedImage;

import java.io.FileNotFoundException;

import java.lang.reflect.Constructor;

import java.net.URI;

import java.util.NoSuchElementException;

import java.util.Stack;

import java.util.Vector;

import java.util.logging.Level;

import org.gvsig.gpe.IGPEContentHandler3D;

import org.gvsig.gpe.parser.GPEParser;

import org.gvsig.osgvp.AutoTransform;

import org.gvsig.osgvp.DrawArrayLengths;

import org.gvsig.osgvp.Drawable;

import org.gvsig.osgvp.Geode;

import org.gvsig.osgvp.Geometry;

import org.gvsig.osgvp.Group;

import org.gvsig.osgvp.Material;

import org.gvsig.osgvp.Matrix;

import org.gvsig.osgvp.MatrixTransform;

import org.gvsig.osgvp.Node;

import org.gvsig.osgvp.PositionAttitudeTransform;

import org.gvsig.osgvp.PrimitiveSet;

import org.gvsig.osgvp.Quat;

import org.gvsig.osgvp.Texture2D;

import org.gvsig.osgvp.Vec2;

import org.gvsig.osgvp.Vec3;

import org.gvsig.osgvp.Vec4;

import org.gvsig.osgvp.osgDB;

import org.gvsig.osgvp.exceptions.node.ChildIndexOutOfBoundsExceptions;

import org.gvsig.osgvp.exceptions.node.LoadNodeException;

import org.gvsig.osgvp.exceptions.node.NodeException;

import org.gvsig.osgvp.exceptions.texture.TextureStageException;

import org.gvsig.osgvp.util.Util;

public class OSGParser extends GPEParser {

	Stack<Matrix> _transforms = new Stack<Matrix>();

	Vector<Stack<Texture2D>> _textures = new Vector<Stack<Texture2D>>();

	Stack<Material> _materials = new Stack<Material>();

	Stack<Boolean> _blendings = new Stack<Boolean>();

	private IGPEContentHandler3D _content;

	private String description;

	private String name;

	public OSGParser(String name, String description) {

		// super(name, description);

		this.name = name;

		this.description = description;

	}

	@Override

	public String getDescription() {

		// TODO Auto-generated method stub

		return this.description;

	}

	@Override

	public String getName() {

		// TODO Auto-generated method stub

		return this.name;

	}

	@Override

	public boolean accept(URI uri) {

		if ((uri.getPath().toUpperCase().endsWith("OSG"))

				|| (uri.getPath().toUpperCase().endsWith("3DS"))

				|| (uri.getPath().toUpperCase().endsWith("IVE"))

				|| (uri.getPath().toUpperCase().endsWith("OBJ"))) {

			return true;

		}

		return false;

	}

	public String[] getFormats() {

		String[] formats = new String[4];

		formats[0] = "OSG";

		formats[1] = "3DS";

		formats[2] = "OBJ";

		formats[3] = "IVE";

		return formats;

	}

	public String[] getVersions() {

		String[] versions = new String[1];

		versions[0] = "All";

		return versions;

	}

	@Override

	protected void parseStream() {

	}

	@Override

	protected void parseURI() {

		// This is a very bad hack to avoid testing hangs in Mac OS Lepard

		Color color = new Color(0, 0, 0, 255);

		// TODO remove this hack

		Vector<Integer> addedTextures = new Vector<Integer>();

		boolean addedMaterial = false;

		_content = (IGPEContentHandler3D) getContentHandler();

//		Util.logger.log(Level.FINEST, getMainFile().getPath());

		Node root=null;

		try {

			String os = System.getProperty("os.name");

			String path;

			if (os.toLowerCase().startsWith("windows")) {

				path = getMainFile().getPath().substring(1,

						getMainFile().getPath().length());

			} else {

				path = getMainFile().getPath();

			}

			root = osgDB.readNodeFile(path);

//			root = osgDB.readNodeFile(getMainFile().getPath().substring(1, getMainFile().getPath().length()));

		} catch (LoadNodeException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			return;

		} catch (FileNotFoundException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			return;

		}

		if (root == null)

//			Util.logger.log(Level.FINEST, "Cannot open"

//					+ getMainFile().getPath());

		System.out.println("error");

		else {

			Object multiGeometry;

			multiGeometry = _content.startMultiGeometry("", "");

			if (root.className().equals("Geode")) {

				Geode rootGeode = new Geode(root.getCPtr());

				Object multiSolid;

				multiSolid = _content.startMultiSolid("", "");

				_content.addGeometryToMultiGeometry(multiSolid, multiGeometry);

				try {

					addedTextures = pushTextures(rootGeode);

				} catch (NodeException e) {

				}

				try {

					addedMaterial = pushMaterial(rootGeode);

				} catch (NodeException e) {

				}

				_blendings.push(rootGeode.getOrCreateStateSet().getEnabledBlending());

				for (int i = 0; i < rootGeode.getNumDrawables(); i++) {

					try {

						parseDrawable(rootGeode.getDrawable(i), multiSolid);

					} catch (ChildIndexOutOfBoundsExceptions e) {

						e.printStackTrace();

						return;

					} catch (NodeException e) {

					}

				}

				_blendings.pop();

				_content.endMultiSolid(multiSolid);

			}

			else if (root.className().equals("Group")) {

				Group rootGroup;

				try {

					rootGroup = new Group(root.getCPtr());

				} catch (NodeException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

					return;

				}

				try {

					addedTextures = pushTextures(rootGroup);

				} catch (NodeException e) {

				}

				try {

					addedMaterial = pushMaterial(rootGroup);

				} catch (NodeException e) {

				}

				_blendings.push(rootGroup.getOrCreateStateSet().getEnabledBlending());

				//System.out.println("CHILDREN: " + rootGroup.getNumChildren());

				for (int i = 0; i < rootGroup.getNumChildren(); i++) {

					try {

						parseNode(rootGroup.getChild(i), multiGeometry);

					} catch (ChildIndexOutOfBoundsExceptions e) {

						e.printStackTrace();

						return;

					}

//					Util.logger.log(Level.FINEST, "Node parsed");

				}

				_blendings.pop();

			}

			else {

//				Util.logger.log(Level.FINEST,

//						"First parsed object must be Group or Geode");

			}

			popTextures(addedTextures);

			if (addedMaterial)

				_materials.pop();

			_content.endMultiGeometry(multiGeometry);

		}

	}

	protected void parseNode(Node node, Object parent) {

		// Util.logger.log(Level.FINEST, "node init");

		Node instance;

		boolean isTransform = false;

		boolean addedMaterial = false;

		Vector<Integer> addedTextures = new Vector<Integer>();

		try {

			Class<?> reflect = Class.forName("org.gvsig.osgvp."

					+ node.className());

			Constructor<?> builder = reflect

					.getConstructor(new Class[] { long.class });

			instance = (Node) builder

					.newInstance(new Object[] { node.getCPtr() });

		}

		catch (Exception e) {

			instance = new Node(node.getCPtr());

		}

		if (instance instanceof Group) {

			Object multiGeometry;

			multiGeometry = _content.startMultiGeometry("", "");

			_content.addGeometryToMultiGeometry(multiGeometry, parent);

			isTransform = pushTransform((Group) instance);

			try {

				addedTextures = pushTextures(instance);

			} catch (NodeException e) {

			}

			try {

				addedMaterial = pushMaterial(instance);

			} catch (NodeException e) {

			}

			if (_blendings.lastElement())

				_blendings.push(true);

			else

				_blendings.push(instance.getOrCreateStateSet()

						.getEnabledBlending());

			for (int i = 0; i < ((Group) instance).getNumChildren(); i++) {

				try {

					parseNode(((Group) instance).getChild(i), multiGeometry);

				} catch (ChildIndexOutOfBoundsExceptions e) {

					e.printStackTrace();

					return;

				}

			}

			if (isTransform)

				_transforms.pop();

			if (addedMaterial)

				_materials.pop();

			_blendings.pop();

			popTextures(addedTextures);

			_content.endMultiGeometry(multiGeometry);

		}

		else if (instance instanceof Geode) {

			Object multiSolid;

			multiSolid = _content.startMultiSolid("", "");

			_content.addGeometryToMultiGeometry(multiSolid, parent);

			try {

				addedTextures = pushTextures(instance);

			} catch (NodeException e) {

			}

			try {

				addedMaterial = pushMaterial(instance);

			} catch (NodeException e) {

			}

			if (_blendings.lastElement())

				_blendings.push(true);

			else

				_blendings.push(instance.getOrCreateStateSet()

						.getEnabledBlending());

			for (int i = 0; i < ((Geode) instance).getNumDrawables(); i++) {

				try {

					parseDrawable(((Geode) instance).getDrawable(i), multiSolid);

				} catch (ChildIndexOutOfBoundsExceptions e) {

					e.printStackTrace();

					return;

				} catch (NodeException e) {

				}

			}

			if (addedMaterial)

				_materials.pop();

			_blendings.pop();

			popTextures(addedTextures);

			_content.endMultiSolid(multiSolid);

		}

		// Util.logger.log(Level.FINEST, "Node parsed-0");

		// else Util.logger.log(Level.FINEST,instance.className() + " is not

		// instanceof

		// Group or Geode");

	}

	protected void parseDrawable(Drawable drawable, Object feature)

			throws NodeException {

		Util.logger.log(Level.FINEST, "drawable init");

		int t = 0;

		if (drawable instanceof Geometry) {

			int j;

			Object solid;

			solid = _content.startSolid("", "");

			_content.addSolidToMultiSolid(solid, feature);

			Matrix matrix = new Matrix();

			for (int i = 0; i < _transforms.size(); i++) {

				matrix.mult(_transforms.get(i), matrix);

			}

			// Util.logger.log(Level.FINEST, "transforms");

			Vector<Vec3> vertices = ((Geometry) drawable).getVertexArray();

			if (vertices == null)

				vertices = new Vector<Vec3>();

			Vec3 vertex;

			int i;

			// Util.logger.log(Level.FINEST, "vertex starts");

			_content.startSolidVertexArray(solid);

			for (i = 0; i < vertices.size(); i++) {

				vertex = vertices.get(i);

				// Util.logger.log(Level.FINEST,"Vertice sin

				// transformar"+vertex.x()+";"+vertex.y()+";"+vertex.z()+";");

				vertex = matrix.prod(vertex, matrix);

				// Util.logger.log(Level.FINEST,"Vertice

				// transformado"+vertex.x()+";"+vertex.y()+";"+vertex.z()+";");

				_content.addVertexToSolid(solid, vertex.x(), vertex.y(), vertex

						.z());

			}

			_content.endSolidVertexArray();

			Vector<Vec3> normals = ((Geometry) drawable).getNormalArray();

			// Util.logger.log(Level.FINEST, "talla normals" + normals.size());

			if (normals == null)

				normals = new Vector<Vec3>();

			Vec3 normal;

			_content.startSolidNormalArray(solid);

			for (i = 0; i < normals.size(); i++) {

				normal = normals.get(i);

				// Util.logger.log(Level.FINEST, " normal bucleee" + normal);

				normal = matrix.prod(normal, matrix);

				normal.normalize();

				_content.addNormalToSolid(solid, normal.x(), normal.y(), normal

						.z());

			}

			_content.endSolidNormalArray();

			_content.setNormalBindingToSolid(solid, ((Geometry) drawable)

					.getNormalBinding());

			try {

				Vector<Vec4> colors = ((Geometry) drawable).getColorArray();

				if (colors == null)

					colors = new Vector<Vec4>();

				Vec4 color;

				// Util.logger.log(Level.FINEST, "color starts" +

				// colors.size());

				_content.startSolidColorArray(solid);

				for (i = 0; i < colors.size(); i++) {

					// Util.logger.log(Level.FINEST, "bucleeeeee 0");

					color = colors.get(i);

					_content.addColorToSolid(solid, (float) color.x(),

							(float) color.y(), (float) color.z(), (float) color

									.w());

					// Util.logger.log(Level.FINEST, "bucleeeeee");

				}

				_content.endSolidColorArray();

			} catch (NullPointerException e) {

			}

			// Util.logger.log(Level.FINEST, "primitiveSets: "

			// + ((Geometry) drawable).getNumPrimitiveSets());

			for (int k = 0; k < ((Geometry) drawable).getNumPrimitiveSets(); k++) {

				int mode = ((Geometry) drawable).getPrimitiveSet(k).getMode();

				int type = ((Geometry) drawable).getPrimitiveSet(k).getType();

				if (type == PrimitiveSet.Type.DrawArrayLengthsPrimitiveType) {

					int offset = 0;

					int accum = 0;

					DrawArrayLengths lengths = new DrawArrayLengths(

							((PrimitiveSet) ((Geometry) drawable)

									.getPrimitiveSet(k)).getCPtr());

					Vector<Integer> arrayLengths = lengths

							.getElementLengthsVector();

					if (arrayLengths == null)

						arrayLengths = new Vector<Integer>();

					for (int h = 0; h < arrayLengths.size(); h++) {

						Object primitiveSet = _content.startPrimitiveSet(mode,

								PrimitiveSet.Type.DrawArraysPrimitiveType);

						_content.addPrimitiveSetToSolid(solid, primitiveSet);

						accum = arrayLengths.get(h);

						for (int l = 0; l < accum; l++) {

							_content.addIndexToPrimitiveSet(primitiveSet,

									((Geometry) drawable).getPrimitiveSet(k)

											.index(offset + l));

						}

						offset = offset + accum;

						_content.endPrimitiveSetIndexArray();

						_content.endPrimitiveSet(primitiveSet);

					}

				} else {

					Object primitiveSet = _content

							.startPrimitiveSet(mode, type);

					_content.addPrimitiveSetToSolid(solid, primitiveSet);

					_content.startPrimitiveSetIndexArray(primitiveSet,

							((Geometry) drawable).getPrimitiveSet(k)

									.getNumIndices());

					// Util.logger.log(Level.FINEST, "Num Indices: "

					// + String.valueOf(((Geometry) drawable)

					// .getPrimitiveSet(k).getNumIndices()));

					for (int ps = 0; ps < ((Geometry) drawable)

							.getPrimitiveSet(k).getNumIndices(); ps++) {

						// Util.logger.log(Level.FINEST, "adding index");

						_content.addIndexToPrimitiveSet(primitiveSet,

								((Geometry) drawable).getPrimitiveSet(k).index(

										ps));

						// Util.logger.log(Level.FINEST, String.valueOf(t));

						// t++;

					}

					_content.endPrimitiveSetIndexArray();

					_content.endPrimitiveSet(primitiveSet);

				}

			}

			Vector<Integer> addedTextures = new Vector<Integer>();

			boolean addedMaterial = false;

			addedTextures = pushTexturesDrawable(drawable);

			// Util.logger.log(Level.FINEST, "Added textures: " +

			// addedTextures);

			try {

				addTexturesToGeometry(solid);

			} catch (Exception e) {

				e.printStackTrace();

			}

			// Util.logger.log(Level.FINEST, "getNumTextures"

			// + drawable.getOrCreateStateSet().getNumTextureStages());

			for (j = 0; j < drawable.getOrCreateStateSet()

					.getNumTextureStages(); j++) {

				try {

					if (drawable.getOrCreateStateSet().getTextureAttribute(j) != null) {

						Vector<Vec2> texCoords = ((Geometry) drawable)

								.getTexCoordArray(j);

						if (texCoords == null)

							texCoords = new Vector<Vec2>();

						Vec2 texCoord;

						_content.startSolidTexCoordArray(solid, texCoords

								.size(), j);

						for (i = 0; i < texCoords.size(); i++) {

							texCoord = texCoords.get(i);

							_content.addTextureCoordinateToSolid(solid,

									texCoord.x(), texCoord.y(), j);

						}

						_content.endSolidTexCoordArray();

					}

				} catch (TextureStageException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

			addedMaterial = pushMaterialDrawable(drawable);

			try {

				Material osgMaterial = _materials.lastElement();

				float x, y, z, w;

				Vec4 vectorAmb = new Vec4();

				Vec4 vectorDif = new Vec4();

				Vec4 vectorEmi = new Vec4();

				Vec4 vectorSpe = new Vec4();

				vectorAmb = osgMaterial.getAmbient(Material.Face.FRONT);

				vectorDif = osgMaterial.getDiffuse(Material.Face.FRONT);

				vectorEmi = osgMaterial.getEmission(Material.Face.FRONT);

				vectorSpe = osgMaterial.getSpecular(Material.Face.FRONT);

				Object material = _content.startMaterial();

				x = (float) vectorAmb.x();

				y = (float) vectorAmb.y();

				z = (float) vectorAmb.z();

				w = (float) vectorAmb.w();

				_content.addAmbientToMaterial(material, x, y, z, w);

				x = (float) vectorDif.x();

				y = (float) vectorDif.y();

				z = (float) vectorDif.z();

				w = (float) vectorDif.w();

				_content.addDiffuseToMaterial(material, x, y, z, w);

				x = (float) vectorSpe.x();

				y = (float) vectorSpe.y();

				z = (float) vectorSpe.z();

				w = (float) vectorSpe.w();

				_content.addSpecularToMaterial(material, x, y, z, w);

				x = (float) vectorEmi.x();

				y = (float) vectorEmi.y();

				z = (float) vectorEmi.z();

				w = (float) vectorEmi.w();

				_content.addEmissionToMaterial(material, x, y, z, w);

				_content.addShininessToMaterial(material, osgMaterial

						.getShininess(Material.Face.FRONT));

				_content.addMaterialToSolid(solid, material);

				_content.endMaterial(material);

			} catch (ArrayIndexOutOfBoundsException ex) {

			}

			if (_blendings.lastElement())

				_content.addBlendingToSolid(solid, true);

			else

				_content.addBlendingToSolid(solid, drawable

						.getOrCreateStateSet().getEnabledBlending());

			popTextures(addedTextures);

			_content.endSolid(solid);

		}

		// Util.logger.log(Level.FINEST, "drawable parsed");

	}

	protected boolean pushTransform(Group group) {

		if (group instanceof MatrixTransform) {

			// Util.logger.log(Level.FINEST,"Push a MatrixTransform");

			_transforms.push(((MatrixTransform) group).getMatrix());

			return true;

		}

		if (group instanceof PositionAttitudeTransform) {

			// Util.logger.log(Level.FINEST,"Push a PAT");

			Matrix scaleMatrix = Matrix

					.scale(((PositionAttitudeTransform) group).getScale());

			Quat quat = new Quat((((PositionAttitudeTransform) group)

					.getAttitudeAngle()), (((PositionAttitudeTransform) group)

					.getAttitudeAxis()));

			Matrix rotateMatrix = Matrix.rotate(quat);

			Matrix transMatrix = Matrix

					.translate(((PositionAttitudeTransform) group)

							.getPosition());

			// rotateMatrix.postMult(scaleMatrix);

			// transMatrix.postMult(rotateMatrix);

			rotateMatrix.preMult(scaleMatrix);

			transMatrix.preMult(rotateMatrix);

			_transforms.push(transMatrix);

			return true;

		}

		if (group instanceof AutoTransform) {

			// Util.logger.log(Level.FINEST,"Push a AutoTransform");

			Matrix scaleMatrix = Matrix.scale(((AutoTransform) group)

					.getScale());

			Quat quat = new Quat((((AutoTransform) group).getRotationAngle()),

					(((AutoTransform) group).getRotationAxis()));

			Matrix rotateMatrix = Matrix.rotate(quat);

			Matrix transMatrix = Matrix.translate(((AutoTransform) group)

					.getPosition());

			// rotateMatrix.postMult(scaleMatrix);

			// transMatrix.postMult(rotateMatrix);

			rotateMatrix.preMult(scaleMatrix);

			transMatrix.preMult(rotateMatrix);

			_transforms.push(transMatrix);

			return true;

		}

		return false;

	}

	protected Vector<Integer> pushTextures(Node node) throws NodeException {

		int numTextures;

		numTextures = node.getOrCreateStateSet().getNumTextureStages();

		Vector<Texture2D> vector = node.getOrCreateStateSet()

				.getTextureAttributeVector();

		Vector<Integer> stages = new Vector<Integer>();

		for (int i = 0; i < numTextures; i++) {

			_textures.get(i);

			_textures.add(i, new Stack<Texture2D>());

			_textures.get(i).push(vector.get(i));

			// Util.logger.log(Level.FINEST,"PUSH");

			stages.add(i);

		}

		return stages;

	}

	protected boolean pushMaterial(Node node) throws NodeException {

		boolean hasMaterial = false;

		Material material;

		material = node.getOrCreateStateSet().getMaterial();

		_materials.push(material);

		hasMaterial = true;

		return hasMaterial;

	}

	protected Vector<Integer> pushTexturesDrawable(Drawable drawable)

			throws NodeException {

		int numTextures;

		numTextures = drawable.getOrCreateStateSet().getNumTextureStages();

		Vector<Texture2D> vector = drawable.getOrCreateStateSet()

				.getTextureAttributeVector();

		Vector<Integer> stages = new Vector<Integer>();

		// Util.logger.log(Level.FINEST, "NumTextures: " + numTextures);

		for (int i = 0; i < numTextures; i++) {

			try {

				_textures.get(i);

			} catch (ArrayIndexOutOfBoundsException ex) {

				_textures.add(i, new Stack<Texture2D>());

			}

			try {

				_textures.get(i).push(vector.get(i));

				// Util.logger.log(Level.FINEST,"PUSH");

				stages.add(i);

				Util.logger.log(Level.FINEST, "Added textures: " + stages);

			} catch (ArrayIndexOutOfBoundsException ex) {

			}

		}

		return stages;

	}

	protected boolean pushMaterialDrawable(Drawable draw) throws NodeException {

		boolean hasMaterial = false;

		try {

			Material material;

			material = draw.getOrCreateStateSet().getMaterial();

			_materials.push(material);

			hasMaterial = true;

		} catch (ArrayIndexOutOfBoundsException ex) {

			hasMaterial = false;

		} catch (NullPointerException e) {

		}

		return hasMaterial;

	}

	protected void popTextures(Vector<Integer> stages) {

		for (int i = 0; i < stages.size(); i++) {

			// Util.logger.log(Level.FINEST,"POP");

			_textures.get(stages.get(i)).pop();

		}

	}

	protected void addTexturesToGeometry(Object solid) throws Exception {

		BufferedImage image;

		for (int i = 0; i < _textures.size(); i++) {

			try {

				// Util.logger.log(Level.FINEST, "Num textures in stack: "

				// + _textures.get(i).size());

				_textures.get(i).lastElement();

				try {

					// Util.logger.log(Level.FINEST, "TRYING STAGE: " + i);

					image = _textures.get(i).lastElement().getImage()

							.getBufferedImage();

					_content.addTextureToSolid(solid, i, image);

				} catch (ArrayIndexOutOfBoundsException ex) {

				}

			}

			catch (NoSuchElementException ex) {

			}

		}

	}

	@Override

	public String getFormat() {

		// TODO Auto-generated method stub

		return null;

	}

}

Group {

  UniqueID Group_0

  DataVariance STATIC

  cullingActive TRUE

  num_children 1

  Geode {

    DataVariance DYNAMIC

    name "dumptruck.osg"

    cullingActive TRUE

    num_drawables 3

    Geometry {

      DataVariance DYNAMIC

      StateSet {

        UniqueID StateSet_1

        DataVariance STATIC

        rendering_hint OPAQUE_BIN

        renderBinMode INHERIT

        GL_CULL_FACE OFF

        GL_LIGHTING ON

        Material {

          DataVariance STATIC

          ColorMode OFF

          ambientColor 0.2 0.2 0.2 1

          diffuseColor 0.8 0.8 0.8 1

          specularColor 0 0 0 1

          emissionColor 0 0 0 1

          shininess 0

        }

      }

      useDisplayList TRUE

      Primitives 1

      {

        DrawArrayLengths TRIANGLE_STRIP 0 907

        {

          3 3 3 3 3 3 3 3

          3 3 3 3 3 3 3 3

          3 3 3 3 3 3 3 3

          3 3 3 3 3 3 3 3

          3 3 3 3 3 3 3 3

          3 3 3 3 3 3 3 3

          3 3 3 3 3 3 3 3

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 4 4

          4 4 4 4 4 4 62 62

          62 62 62 62 30 62 62 62

          62 62 62 62 62 62 62 62

          62 62 62 42 42 42 42 42

          42 42 42 82 42 42 42 42

          42 42 42 42 42 42 42 42

          82 42 42 42 42 20 42 42

          42 42 42 42 42 42 42 42

          42 42 42 42 42 42 22 22

          22 22 22 22 22 22 22 22

          22 22 22 22 22 22 22 22

          22 22 22 22 22 22 22 22

          22 22 22 22 22 22 22 22

          22 22 22 22 22 22 22 22

          10 22 22 22 22 10 22 22

          22 22 22 22 22 22 22 22

          22 10 22 22 22 22 10 22

          22 22 22 22 22 22 62 62

          62 62 30 62 62 62 62 30

          62 62 62 62 62 62 62 62

          62 62 62 30 62 62 62 62

          30 62 62 62 62 62 62 62

          36 26 9 10 10 9 15 34

          10 12 26 26 11 12 26 12

          24 5 10 11 42 6 14 14

          6 6 8 9 5 9 5 6

          10 6 5 6 5 6 8 8

          11 6 5 12 6 14 14 6

          14 14 8 5 8 5 5 6

          7 6 8 5 9 6 9 5

          5 5 21 8 19 6 6 6

          10 7 7 9 8 14 6 14

          12 10 30 6 6 6 6 5

          6 6 5 13 8 6 7 5

          6 10 8 8 8 8 6 10

          8 8 8 8 6 10 8 7

          6 6 5 8 6 6 6 5

          6 6 11 14 6 11 14 6

          8 12 6 12 6 14 11 7

          5 7 8 7 5 15 9 8

          8 11 27 7 5 8 5 90

          5 14 5 5 17 8 6 9

          11 18 16 5 8 8 8 8

          8 8 8 6 10 8 8 8

          8 6 10 8 6 6 7 6

          6 8 7 8 8 8 8 6

          19 5 8 8 8 10 5 7

          9 12 12 7 12 11 6 9

          10 5 8 5 7 20 7 5

          7 15 14 7 9 24 11 11

          12 6 19 17 19 5 7 48

          38 6 6 55 12 7 6 6

          13 11 9 8 11 8 7 12

          8 8 5 12 6 6 6 28

          8 24 28 28 20 8 24 5

          6 6 5 10 5 6 9 7

          6 6 6 6 5 6 6 6

          6 6 6 6 5 6 6 6

          38 20 20 6 6 14 14 14

          14 14 14 14 14 10 10 10

          10 5 6 5 6 9 9 10

          10 10 10 16 16 16 16 16

          16 16 16 6 5 6 9 6

          13 5 8 6 12 12 10 10

          10 10 16 16 16 16 16 16

          16 16 6 6 5 8 9 7

          6 12 12 

        }

      }

      VertexArray 11813

      {

        0.912526 5.25919 2.51182

        0.983379 5.26351 2.53055

        0.911395 5.16927 2.56377

        0.980369 5.26365 2.88188

        1.03139 5.33888 2.81326

        0.98109 5.35779 2.88185

        0.909998 5.36319 2.89936

        0.98109 5.35779 2.88185

        0.911127 5.45311 2.84741

        1.40123 -0.66679 0.82615

        0.81107 -0.72166 0.68056

        1.24693 -0.68022 0.67832

        8.00494 4.90679 -2.17661

        8.05065 4.75217 -2.01154

        8.00487 4.70141 -2.17659

        8.07061 5.41762 -1.58063

        8.01113 5.13042 -1.7139

        8.06831 5.41759 -1.75462

        2.6651 2.36112 0.54797

        2.50071 2.35788 0.65041

        2.66463 1.5618 0.54797

        -0.72413 -0.92084 -2.02524

        1.24014 -0.8774 -2.04662

        -0.709098 -0.92715 -1.96685

        1.85515 3.8041 2.93252

        1.94398 3.84689 2.88252

        1.84478 3.84695 2.88252

        1.97795 2.937 2.93252

        2.06678 2.97982 2.88906

        1.96758 2.97988 2.88906

        -0.741482 4.82057 -2.12957

        1.2435 4.80199 -2.04662

        1.23732 4.79579 -2.15336

        2.66611 4.75493 -2.20671

        3.50519 4.9885 -2.35739

        3.49545 4.92738 -2.42669

        -1.07378 4.79543 0.24847

        1.6295 4.73294 0.24847

        -1.03116 4.87393 -1.27463

        3.93119 -0.86987 -0.989677

        4.49223 -0.65996 -0.92682

        3.18164 -0.92128 -1.02674

        6.56315 -1.9181 -1.31203

        4.82088 -1.76135 -1.14517

        4.84026 -1.89248 -1.30202

        7.81534 -1.86797 -1.36381

        7.88025 -1.84835 -1.32664

        7.82223 -1.86455 -1.32178

        7.88408 0.33768 -2.8309

        7.82644 0.20219 -2.91162

        7.82662 0.50406 -2.91162

        8.05658 3.62542 -2.59138

        7.82852 3.71461 -2.91162

        7.82428 5.71737 -2.917

        7.90816 1.95835 -2.0004

        7.90741 0.84053 -2.00175

        7.90873 3.07616 -2.00175

        7.55832 5.75263 -2.8734

        7.58808 5.72242 -2.877

        7.55826 5.65943 -2.8734

        7.69997 5.85163 -2.91162

        7.69997 5.85163 -2.71922

        7.70006 5.99986 -2.71922

        1.65149 4.39695 2.51895

        1.50263 4.47952 2.37171

        1.16645 4.58601 2.4733

        1.99869 2.85124 2.88839

        1.64938 2.88416 2.93252

        1.65289 2.83951 2.91265

        1.87589 3.7184 2.88252

        1.57515 3.76203 2.93252

        1.57865 3.71745 2.89648

        -1.13143 -0.79911 0.37352

        -1.03971 -0.65804 2.18329

        -1.52619 -0.73697 0.37353

        -1.07714 -0.86809 0.24847

        -1.07176 -0.80297 0.37352

        -1.13681 -0.86438 0.24847

        1.68982 4.43889 2.10838

        1.79855 4.49407 0.91837

        1.60973 4.45854 2.11338

        7.69535 -1.93468 -3.42082

        7.69535 -1.93468 -3.84602

        7.69526 -2.08291 -3.84602

        7.99905 4.24552 -1.06405

        7.94566 3.79099 0.1857

        8.03058 4.21573 -1.10895

        8.03189 5.43741 -1.20559

        8.03378 5.51106 -1.24934

        8.00097 5.45279 -1.15911

        8.01254 4.56692 -1.58371

        8.05508 4.75218 -1.67282

        8.01362 4.70143 -1.50661