Application: gvSIG desktop

<project xmlns="http://maven.apache.org/POM/4.0.0"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<groupId>org.gvsig</groupId>

	<artifactId>libGPE-OSG</artifactId>

	<packaging>jar</packaging>

	<version>1.1-SNAPSHOT</version>

	<name>libGPE-OSG</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>gvsig-library-base-pom</artifactId>

		<version>1.0-SNAPSHOT</version>

	</parent>

	<dependencies>

		<!--dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>gpe</artifactId>

			<version>1.0.0</version>

		</dependency-->

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>libGPE</artifactId>

			<version>1.0-SNAPSHOT</version>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>libGeometries3D</artifactId>

			<version>1.0-SNAPSHOT</version>

		</dependency>

		<dependency>

			<groupId>org.gvsig.osgvp.libosgvp</groupId>

			<artifactId>libosgvp-core</artifactId>

			<version>2.1.6.6</version>

		</dependency>

	</dependencies>

</project>

/* 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.io.FileNotFoundException;

import java.net.URI;

import java.net.URISyntaxException;

import junit.framework.TestCase;

import org.gvsig.driver.OSGDriver;

import org.gvsig.osgvp.util.Util;

public class TestOSGParser extends TestCase {

	public void testParseURI() {

		//fail("Not yet implemented");

	}

	public void testParseStream() {

		// TODO: This is the real work.

		OSGDriver osgDriver = new OSGDriver();

		OSGParser parser = new OSGParser("OSG","OSG File Formats Parser");

		try {

			parser.parse(osgDriver, null, Util.extractResource("/cessna.osg").toURI());

		} catch (FileNotFoundException e) {

			fail("Resource not found");

		}

//		osgDriver.getRootFeature();

	}

	public void testOSGParser() {

		// TODO: This is the constructor, test only for creation

		// or something similar.

//		fail("Not yet implemented");

	}

	public void testAcceptURI() {

		OSGParser parser = new OSGParser("OSG","OSG File Formats Parser");

		URI uri;

		try {

			uri = Util.extractResource("/cessna.osg").toURI();

			assertEquals(parser.accept(uri),true);

			uri = new URI("pepe.com");

			assertEquals(parser.accept(uri),false);

		} catch (FileNotFoundException e) {

			// TODO Auto-generated catch block

			fail();

		} catch (URISyntaxException e) {

			// TODO Auto-generated catch block

			fail();

		}

	}

	public void testGetFormats() {

		String[] formats = new String[4];

		OSGParser parser = new OSGParser("OSG","OSG File Formats Parser");

		formats[0] = "OSG";

		formats[1] = "3DS";

		formats[2] = "OBJ";

		formats[3] = "IVE";

		for(int i=0; i<formats.length; i++){

			assertEquals(formats[i].equals(parser.getFormats()[i]),true);

		}

	}

	public void testGetVersions() {

		String[] versions = new String[1];

		versions[0] = "All";

		OSGParser parser = new OSGParser("OSG","OSG File Formats Parser");

		for(int i=0; i<versions.length; i++){

			assertEquals(versions[i].equals(parser.getVersions()[i]),true);

		}

	}

}

/* 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