From bf72c7975bffcf8cbb6a61bf78154b133af6931f Mon Sep 17 00:00:00 2001 From: "sha..rd" Date: Sun, 10 Jul 2011 20:23:00 +0000 Subject: [PATCH] * Reverted normen's confusion * TGA loader now properly fails on grayscale formats git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@7848 75d07b2b-3a1a-0410-a2c5-0572b91ccdca --- .../shapes/GImpactCollisionShape.java | 337 +++++++++--------- .../shapes/HeightfieldCollisionShape.java | 291 +++++++-------- .../collision/shapes/HullCollisionShape.java | 197 +++++----- .../collision/shapes/MeshCollisionShape.java | 321 ++++++++--------- .../com/jme3/bullet/util/NativeMeshUtil.java | 154 ++++---- .../com/jme3/texture/plugins/TGALoader.java | 6 +- 6 files changed, 656 insertions(+), 650 deletions(-) diff --git a/engine/src/bullet/com/jme3/bullet/collision/shapes/GImpactCollisionShape.java b/engine/src/bullet/com/jme3/bullet/collision/shapes/GImpactCollisionShape.java index 2e253d1e9..912268eeb 100644 --- a/engine/src/bullet/com/jme3/bullet/collision/shapes/GImpactCollisionShape.java +++ b/engine/src/bullet/com/jme3/bullet/collision/shapes/GImpactCollisionShape.java @@ -1,168 +1,169 @@ -/* - * Copyright (c) 2009-2010 jMonkeyEngine - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of 'jMonkeyEngine' nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package com.jme3.bullet.collision.shapes; - -import com.jme3.export.JmeExporter; -import com.jme3.export.JmeImporter; -import com.jme3.scene.Mesh; -import com.jme3.bullet.util.NativeMeshUtil; -import com.jme3.export.InputCapsule; -import com.jme3.export.OutputCapsule; -import com.jme3.scene.VertexBuffer.Type; -import com.jme3.scene.mesh.IndexBuffer; -import java.io.IOException; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.FloatBuffer; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * Basic mesh collision shape - * @author normenhansen - */ -public class GImpactCollisionShape extends CollisionShape { - -// protected Vector3f worldScale; - protected int numVertices, numTriangles, vertexStride, triangleIndexStride; - protected ByteBuffer triangleIndexBase, vertexBase; - protected long meshId = 0; -// protected IndexedMesh bulletMesh; - - public GImpactCollisionShape() { - } - - /** - * creates a collision shape from the given Mesh - * @param mesh the Mesh to use - */ - public GImpactCollisionShape(Mesh mesh) { - createCollisionMesh(mesh); - } - - private void createCollisionMesh(Mesh mesh) { - triangleIndexBase = ByteBuffer.allocateDirect(mesh.getTriangleCount() * 3 * 4).order(ByteOrder.nativeOrder()); - vertexBase = ByteBuffer.allocateDirect(mesh.getVertexCount() * 3 * 4).order(ByteOrder.nativeOrder()); -// triangleIndexBase = ByteBuffer.allocate(mesh.getTriangleCount() * 3 * 4); -// vertexBase = ByteBuffer.allocate(mesh.getVertexCount() * 3 * 4); - numVertices = mesh.getVertexCount(); - vertexStride = 12; //3 verts * 4 bytes per. - numTriangles = mesh.getTriangleCount(); - triangleIndexStride = 12; //3 index entries * 4 bytes each. - - IndexBuffer indices = mesh.getIndexBuffer(); - FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); - vertices.rewind(); - - int verticesLength = mesh.getVertexCount() * 3; - for (int i = 0; i < verticesLength; i++) { - float tempFloat = vertices.get(); - vertexBase.putFloat(tempFloat); - } - - int indicesLength = mesh.getTriangleCount() * 3; - for (int i = 0; i < indicesLength; i++) { - triangleIndexBase.putInt(indices.get(i)); - } - vertices.rewind(); - vertices.clear(); - - createShape(); - } - -// /** -// * creates a jme mesh from the collision shape, only needed for debugging -// */ -// public Mesh createJmeMesh() { -// return Converter.convert(bulletMesh); -// } - public void write(JmeExporter ex) throws IOException { - super.write(ex); - OutputCapsule capsule = ex.getCapsule(this); -// capsule.write(worldScale, "worldScale", new Vector3f(1, 1, 1)); - capsule.write(numVertices, "numVertices", 0); - capsule.write(numTriangles, "numTriangles", 0); - capsule.write(vertexStride, "vertexStride", 0); - capsule.write(triangleIndexStride, "triangleIndexStride", 0); - - capsule.write(triangleIndexBase.array(), "triangleIndexBase", new byte[0]); - capsule.write(vertexBase.array(), "vertexBase", new byte[0]); - } - - public void read(JmeImporter im) throws IOException { - super.read(im); - InputCapsule capsule = im.getCapsule(this); -// worldScale = (Vector3f) capsule.readSavable("worldScale", new Vector3f(1, 1, 1)); - numVertices = capsule.readInt("numVertices", 0); - numTriangles = capsule.readInt("numTriangles", 0); - vertexStride = capsule.readInt("vertexStride", 0); - triangleIndexStride = capsule.readInt("triangleIndexStride", 0); - - triangleIndexBase = ByteBuffer.wrap(capsule.readByteArray("triangleIndexBase", new byte[0])); - vertexBase = ByteBuffer.wrap(capsule.readByteArray("vertexBase", new byte[0])); - createShape(); - } - - protected void createShape() { -// bulletMesh = new IndexedMesh(); -// bulletMesh.numVertices = numVertices; -// bulletMesh.numTriangles = numTriangles; -// bulletMesh.vertexStride = vertexStride; -// bulletMesh.triangleIndexStride = triangleIndexStride; -// bulletMesh.triangleIndexBase = triangleIndexBase; -// bulletMesh.vertexBase = vertexBase; -// bulletMesh.triangleIndexBase = triangleIndexBase; -// TriangleIndexVertexArray tiv = new TriangleIndexVertexArray(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); -// objectId = new GImpactMeshShape(tiv); -// objectId.setLocalScaling(Converter.convert(worldScale)); -// ((GImpactMeshShape)objectId).updateBound(); -// objectId.setLocalScaling(Converter.convert(getScale())); -// objectId.setMargin(margin); - meshId = NativeMeshUtil.createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Mesh {0}", Long.toHexString(meshId)); - objectId = createShape(meshId); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); - setScale(scale); - setMargin(margin); - } - - private native long createShape(long meshId); - - @Override - protected void finalize() throws Throwable { - super.finalize(); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Finalizing Mesh {0}", Long.toHexString(meshId)); - finalizeNative(meshId); - } - - private native void finalizeNative(long objectId); -} +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.bullet.collision.shapes; + +import com.jme3.export.JmeExporter; +import com.jme3.export.JmeImporter; +import com.jme3.scene.Mesh; +import com.jme3.bullet.util.NativeMeshUtil; +import com.jme3.export.InputCapsule; +import com.jme3.export.OutputCapsule; +import com.jme3.scene.VertexBuffer.Type; +import com.jme3.scene.mesh.IndexBuffer; +import com.jme3.util.BufferUtils; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Basic mesh collision shape + * @author normenhansen + */ +public class GImpactCollisionShape extends CollisionShape { + +// protected Vector3f worldScale; + protected int numVertices, numTriangles, vertexStride, triangleIndexStride; + protected ByteBuffer triangleIndexBase, vertexBase; + protected long meshId = 0; +// protected IndexedMesh bulletMesh; + + public GImpactCollisionShape() { + } + + /** + * creates a collision shape from the given Mesh + * @param mesh the Mesh to use + */ + public GImpactCollisionShape(Mesh mesh) { + createCollisionMesh(mesh); + } + + private void createCollisionMesh(Mesh mesh) { + triangleIndexBase = BufferUtils.createByteBuffer(mesh.getTriangleCount() * 3 * 4); + vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4); +// triangleIndexBase = ByteBuffer.allocate(mesh.getTriangleCount() * 3 * 4); +// vertexBase = ByteBuffer.allocate(mesh.getVertexCount() * 3 * 4); + numVertices = mesh.getVertexCount(); + vertexStride = 12; //3 verts * 4 bytes per. + numTriangles = mesh.getTriangleCount(); + triangleIndexStride = 12; //3 index entries * 4 bytes each. + + IndexBuffer indices = mesh.getIndexBuffer(); + FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); + vertices.rewind(); + + int verticesLength = mesh.getVertexCount() * 3; + for (int i = 0; i < verticesLength; i++) { + float tempFloat = vertices.get(); + vertexBase.putFloat(tempFloat); + } + + int indicesLength = mesh.getTriangleCount() * 3; + for (int i = 0; i < indicesLength; i++) { + triangleIndexBase.putInt(indices.get(i)); + } + vertices.rewind(); + vertices.clear(); + + createShape(); + } + +// /** +// * creates a jme mesh from the collision shape, only needed for debugging +// */ +// public Mesh createJmeMesh() { +// return Converter.convert(bulletMesh); +// } + public void write(JmeExporter ex) throws IOException { + super.write(ex); + OutputCapsule capsule = ex.getCapsule(this); +// capsule.write(worldScale, "worldScale", new Vector3f(1, 1, 1)); + capsule.write(numVertices, "numVertices", 0); + capsule.write(numTriangles, "numTriangles", 0); + capsule.write(vertexStride, "vertexStride", 0); + capsule.write(triangleIndexStride, "triangleIndexStride", 0); + + capsule.write(triangleIndexBase.array(), "triangleIndexBase", new byte[0]); + capsule.write(vertexBase.array(), "vertexBase", new byte[0]); + } + + public void read(JmeImporter im) throws IOException { + super.read(im); + InputCapsule capsule = im.getCapsule(this); +// worldScale = (Vector3f) capsule.readSavable("worldScale", new Vector3f(1, 1, 1)); + numVertices = capsule.readInt("numVertices", 0); + numTriangles = capsule.readInt("numTriangles", 0); + vertexStride = capsule.readInt("vertexStride", 0); + triangleIndexStride = capsule.readInt("triangleIndexStride", 0); + + triangleIndexBase = ByteBuffer.wrap(capsule.readByteArray("triangleIndexBase", new byte[0])); + vertexBase = ByteBuffer.wrap(capsule.readByteArray("vertexBase", new byte[0])); + createShape(); + } + + protected void createShape() { +// bulletMesh = new IndexedMesh(); +// bulletMesh.numVertices = numVertices; +// bulletMesh.numTriangles = numTriangles; +// bulletMesh.vertexStride = vertexStride; +// bulletMesh.triangleIndexStride = triangleIndexStride; +// bulletMesh.triangleIndexBase = triangleIndexBase; +// bulletMesh.vertexBase = vertexBase; +// bulletMesh.triangleIndexBase = triangleIndexBase; +// TriangleIndexVertexArray tiv = new TriangleIndexVertexArray(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); +// objectId = new GImpactMeshShape(tiv); +// objectId.setLocalScaling(Converter.convert(worldScale)); +// ((GImpactMeshShape)objectId).updateBound(); +// objectId.setLocalScaling(Converter.convert(getScale())); +// objectId.setMargin(margin); + meshId = NativeMeshUtil.createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Mesh {0}", Long.toHexString(meshId)); + objectId = createShape(meshId); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); + setScale(scale); + setMargin(margin); + } + + private native long createShape(long meshId); + + @Override + protected void finalize() throws Throwable { + super.finalize(); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Finalizing Mesh {0}", Long.toHexString(meshId)); + finalizeNative(meshId); + } + + private native void finalizeNative(long objectId); +} diff --git a/engine/src/bullet/com/jme3/bullet/collision/shapes/HeightfieldCollisionShape.java b/engine/src/bullet/com/jme3/bullet/collision/shapes/HeightfieldCollisionShape.java index 2c2da1323..81c5039dc 100644 --- a/engine/src/bullet/com/jme3/bullet/collision/shapes/HeightfieldCollisionShape.java +++ b/engine/src/bullet/com/jme3/bullet/collision/shapes/HeightfieldCollisionShape.java @@ -1,145 +1,146 @@ -/* - * To change this template, choose Tools | Templates - * and open the template in the editor. - */ -package com.jme3.bullet.collision.shapes; - -import com.jme3.export.InputCapsule; -import com.jme3.export.JmeExporter; -import com.jme3.export.JmeImporter; -import com.jme3.export.OutputCapsule; -import com.jme3.math.FastMath; -import com.jme3.math.Vector3f; -import com.jme3.scene.Mesh; -import java.io.IOException; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * Uses Bullet Physics Heightfield terrain collision system. This is MUCH faster - * than using a regular mesh. - * There are a couple tricks though: - * -No rotation or translation is supported. - * -The collision bbox must be centered around 0,0,0 with the height above and below the y-axis being - * equal on either side. If not, the whole collision box is shifted vertically and things don't collide - * as they should. - * - * @author Brent Owens - */ -public class HeightfieldCollisionShape extends CollisionShape { - - protected int heightStickWidth; - protected int heightStickLength; - protected float[] heightfieldData; - protected float heightScale; - protected float minHeight; - protected float maxHeight; - protected int upAxis; - protected boolean flipQuadEdges; - protected ByteBuffer bbuf; -// protected FloatBuffer fbuf; - - public HeightfieldCollisionShape() { - } - - public HeightfieldCollisionShape(float[] heightmap) { - createCollisionHeightfield(heightmap, Vector3f.UNIT_XYZ); - } - - public HeightfieldCollisionShape(float[] heightmap, Vector3f scale) { - createCollisionHeightfield(heightmap, scale); - } - - protected void createCollisionHeightfield(float[] heightmap, Vector3f worldScale) { - this.scale = worldScale; - this.heightScale = 1;//don't change away from 1, we use worldScale instead to scale - - this.heightfieldData = heightmap; - - float min = heightfieldData[0]; - float max = heightfieldData[0]; - // calculate min and max height - for (int i = 0; i < heightfieldData.length; i++) { - if (heightfieldData[i] < min) { - min = heightfieldData[i]; - } - if (heightfieldData[i] > max) { - max = heightfieldData[i]; - } - } - // we need to center the terrain collision box at 0,0,0 for BulletPhysics. And to do that we need to set the - // min and max height to be equal on either side of the y axis, otherwise it gets shifted and collision is incorrect. - if (max < 0) { - max = -min; - } else { - if (Math.abs(max) > Math.abs(min)) { - min = -max; - } else { - max = -min; - } - } - this.minHeight = min; - this.maxHeight = max; - - this.upAxis = 1; - this.flipQuadEdges = false; - - heightStickWidth = (int) FastMath.sqrt(heightfieldData.length); - heightStickLength = heightStickWidth; - - - createShape(); - } - - protected void createShape() { - bbuf = ByteBuffer.allocateDirect(heightfieldData.length * 4).order(ByteOrder.nativeOrder()); -// fbuf = bbuf.asFloatBuffer();//FloatBuffer.wrap(heightfieldData); -// fbuf.rewind(); -// fbuf.put(heightfieldData); - for (int i = 0; i < heightfieldData.length; i++) { - float f = heightfieldData[i]; - bbuf.putFloat(f); - } -// fbuf.rewind(); - objectId = createShape(heightStickWidth, heightStickLength, bbuf, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); - setScale(scale); - setMargin(margin); - } - - private native long createShape(int heightStickWidth, int heightStickLength, ByteBuffer heightfieldData, float heightScale, float minHeight, float maxHeight, int upAxis, boolean flipQuadEdges); - - public Mesh createJmeMesh() { - //TODO return Converter.convert(bulletMesh); - return null; - } - - public void write(JmeExporter ex) throws IOException { - super.write(ex); - OutputCapsule capsule = ex.getCapsule(this); - capsule.write(heightStickWidth, "heightStickWidth", 0); - capsule.write(heightStickLength, "heightStickLength", 0); - capsule.write(heightScale, "heightScale", 0); - capsule.write(minHeight, "minHeight", 0); - capsule.write(maxHeight, "maxHeight", 0); - capsule.write(upAxis, "upAxis", 1); - capsule.write(heightfieldData, "heightfieldData", new float[0]); - capsule.write(flipQuadEdges, "flipQuadEdges", false); - } - - public void read(JmeImporter im) throws IOException { - super.read(im); - InputCapsule capsule = im.getCapsule(this); - heightStickWidth = capsule.readInt("heightStickWidth", 0); - heightStickLength = capsule.readInt("heightStickLength", 0); - heightScale = capsule.readFloat("heightScale", 0); - minHeight = capsule.readFloat("minHeight", 0); - maxHeight = capsule.readFloat("maxHeight", 0); - upAxis = capsule.readInt("upAxis", 1); - heightfieldData = capsule.readFloatArray("heightfieldData", new float[0]); - flipQuadEdges = capsule.readBoolean("flipQuadEdges", false); - createShape(); - } -} +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package com.jme3.bullet.collision.shapes; + +import com.jme3.export.InputCapsule; +import com.jme3.export.JmeExporter; +import com.jme3.export.JmeImporter; +import com.jme3.export.OutputCapsule; +import com.jme3.math.FastMath; +import com.jme3.math.Vector3f; +import com.jme3.scene.Mesh; +import com.jme3.util.BufferUtils; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Uses Bullet Physics Heightfield terrain collision system. This is MUCH faster + * than using a regular mesh. + * There are a couple tricks though: + * -No rotation or translation is supported. + * -The collision bbox must be centered around 0,0,0 with the height above and below the y-axis being + * equal on either side. If not, the whole collision box is shifted vertically and things don't collide + * as they should. + * + * @author Brent Owens + */ +public class HeightfieldCollisionShape extends CollisionShape { + + protected int heightStickWidth; + protected int heightStickLength; + protected float[] heightfieldData; + protected float heightScale; + protected float minHeight; + protected float maxHeight; + protected int upAxis; + protected boolean flipQuadEdges; + protected ByteBuffer bbuf; +// protected FloatBuffer fbuf; + + public HeightfieldCollisionShape() { + } + + public HeightfieldCollisionShape(float[] heightmap) { + createCollisionHeightfield(heightmap, Vector3f.UNIT_XYZ); + } + + public HeightfieldCollisionShape(float[] heightmap, Vector3f scale) { + createCollisionHeightfield(heightmap, scale); + } + + protected void createCollisionHeightfield(float[] heightmap, Vector3f worldScale) { + this.scale = worldScale; + this.heightScale = 1;//don't change away from 1, we use worldScale instead to scale + + this.heightfieldData = heightmap; + + float min = heightfieldData[0]; + float max = heightfieldData[0]; + // calculate min and max height + for (int i = 0; i < heightfieldData.length; i++) { + if (heightfieldData[i] < min) { + min = heightfieldData[i]; + } + if (heightfieldData[i] > max) { + max = heightfieldData[i]; + } + } + // we need to center the terrain collision box at 0,0,0 for BulletPhysics. And to do that we need to set the + // min and max height to be equal on either side of the y axis, otherwise it gets shifted and collision is incorrect. + if (max < 0) { + max = -min; + } else { + if (Math.abs(max) > Math.abs(min)) { + min = -max; + } else { + max = -min; + } + } + this.minHeight = min; + this.maxHeight = max; + + this.upAxis = 1; + this.flipQuadEdges = false; + + heightStickWidth = (int) FastMath.sqrt(heightfieldData.length); + heightStickLength = heightStickWidth; + + + createShape(); + } + + protected void createShape() { + bbuf = BufferUtils.createByteBuffer(heightfieldData.length * 4); +// fbuf = bbuf.asFloatBuffer();//FloatBuffer.wrap(heightfieldData); +// fbuf.rewind(); +// fbuf.put(heightfieldData); + for (int i = 0; i < heightfieldData.length; i++) { + float f = heightfieldData[i]; + bbuf.putFloat(f); + } +// fbuf.rewind(); + objectId = createShape(heightStickWidth, heightStickLength, bbuf, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); + setScale(scale); + setMargin(margin); + } + + private native long createShape(int heightStickWidth, int heightStickLength, ByteBuffer heightfieldData, float heightScale, float minHeight, float maxHeight, int upAxis, boolean flipQuadEdges); + + public Mesh createJmeMesh() { + //TODO return Converter.convert(bulletMesh); + return null; + } + + public void write(JmeExporter ex) throws IOException { + super.write(ex); + OutputCapsule capsule = ex.getCapsule(this); + capsule.write(heightStickWidth, "heightStickWidth", 0); + capsule.write(heightStickLength, "heightStickLength", 0); + capsule.write(heightScale, "heightScale", 0); + capsule.write(minHeight, "minHeight", 0); + capsule.write(maxHeight, "maxHeight", 0); + capsule.write(upAxis, "upAxis", 1); + capsule.write(heightfieldData, "heightfieldData", new float[0]); + capsule.write(flipQuadEdges, "flipQuadEdges", false); + } + + public void read(JmeImporter im) throws IOException { + super.read(im); + InputCapsule capsule = im.getCapsule(this); + heightStickWidth = capsule.readInt("heightStickWidth", 0); + heightStickLength = capsule.readInt("heightStickLength", 0); + heightScale = capsule.readFloat("heightScale", 0); + minHeight = capsule.readFloat("minHeight", 0); + maxHeight = capsule.readFloat("maxHeight", 0); + upAxis = capsule.readInt("upAxis", 1); + heightfieldData = capsule.readFloatArray("heightfieldData", new float[0]); + flipQuadEdges = capsule.readBoolean("flipQuadEdges", false); + createShape(); + } +} diff --git a/engine/src/bullet/com/jme3/bullet/collision/shapes/HullCollisionShape.java b/engine/src/bullet/com/jme3/bullet/collision/shapes/HullCollisionShape.java index 3f27150ba..44f4b03b6 100644 --- a/engine/src/bullet/com/jme3/bullet/collision/shapes/HullCollisionShape.java +++ b/engine/src/bullet/com/jme3/bullet/collision/shapes/HullCollisionShape.java @@ -1,98 +1,99 @@ -package com.jme3.bullet.collision.shapes; - -import java.nio.FloatBuffer; -import com.jme3.export.InputCapsule; -import com.jme3.export.JmeExporter; -import com.jme3.export.JmeImporter; -import com.jme3.export.OutputCapsule; -import com.jme3.scene.Mesh; -import com.jme3.scene.VertexBuffer.Type; -import java.io.IOException; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.logging.Level; -import java.util.logging.Logger; - -public class HullCollisionShape extends CollisionShape { - - private float[] points; -// protected FloatBuffer fbuf; - - public HullCollisionShape() { - } - - public HullCollisionShape(Mesh mesh) { - this.points = getPoints(mesh); - createShape(); - } - - public HullCollisionShape(float[] points) { - this.points = points; - createShape(); - } - - @Override - public void write(JmeExporter ex) throws IOException { - super.write(ex); - - OutputCapsule capsule = ex.getCapsule(this); - capsule.write(points, "points", null); - } - - @Override - public void read(JmeImporter im) throws IOException { - super.read(im); - InputCapsule capsule = im.getCapsule(this); - - // for backwards compatability - Mesh mesh = (Mesh) capsule.readSavable("hullMesh", null); - if (mesh != null) { - this.points = getPoints(mesh); - } else { - this.points = capsule.readFloatArray("points", null); - - } -// fbuf = ByteBuffer.allocateDirect(points.length * 4).asFloatBuffer(); -// fbuf.put(points); -// fbuf = FloatBuffer.wrap(points).order(ByteOrder.nativeOrder()).asFloatBuffer(); - createShape(); - } - - protected void createShape() { -// ObjectArrayList pointList = new ObjectArrayList(); -// for (int i = 0; i < points.length; i += 3) { -// pointList.add(new Vector3f(points[i], points[i + 1], points[i + 2])); -// } -// objectId = new ConvexHullShape(pointList); -// objectId.setLocalScaling(Converter.convert(getScale())); -// objectId.setMargin(margin); - ByteBuffer bbuf=ByteBuffer.allocateDirect(points.length * 4).order(ByteOrder.nativeOrder()); -// fbuf = bbuf.asFloatBuffer(); -// fbuf.rewind(); -// fbuf.put(points); - for (int i = 0; i < points.length; i++) { - float f = points[i]; - bbuf.putFloat(f); - } - bbuf.rewind(); - objectId = createShape(bbuf); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); - setScale(scale); - setMargin(margin); - } - - private native long createShape(ByteBuffer points); - - protected float[] getPoints(Mesh mesh) { - FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); - vertices.rewind(); - int components = mesh.getVertexCount() * 3; - float[] pointsArray = new float[components]; - for (int i = 0; i < components; i += 3) { - pointsArray[i] = vertices.get(); - pointsArray[i + 1] = vertices.get(); - pointsArray[i + 2] = vertices.get(); - } - return pointsArray; - } -} +package com.jme3.bullet.collision.shapes; + +import java.nio.FloatBuffer; +import com.jme3.export.InputCapsule; +import com.jme3.export.JmeExporter; +import com.jme3.export.JmeImporter; +import com.jme3.export.OutputCapsule; +import com.jme3.scene.Mesh; +import com.jme3.scene.VertexBuffer.Type; +import com.jme3.util.BufferUtils; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class HullCollisionShape extends CollisionShape { + + private float[] points; +// protected FloatBuffer fbuf; + + public HullCollisionShape() { + } + + public HullCollisionShape(Mesh mesh) { + this.points = getPoints(mesh); + createShape(); + } + + public HullCollisionShape(float[] points) { + this.points = points; + createShape(); + } + + @Override + public void write(JmeExporter ex) throws IOException { + super.write(ex); + + OutputCapsule capsule = ex.getCapsule(this); + capsule.write(points, "points", null); + } + + @Override + public void read(JmeImporter im) throws IOException { + super.read(im); + InputCapsule capsule = im.getCapsule(this); + + // for backwards compatability + Mesh mesh = (Mesh) capsule.readSavable("hullMesh", null); + if (mesh != null) { + this.points = getPoints(mesh); + } else { + this.points = capsule.readFloatArray("points", null); + + } +// fbuf = ByteBuffer.allocateDirect(points.length * 4).asFloatBuffer(); +// fbuf.put(points); +// fbuf = FloatBuffer.wrap(points).order(ByteOrder.nativeOrder()).asFloatBuffer(); + createShape(); + } + + protected void createShape() { +// ObjectArrayList pointList = new ObjectArrayList(); +// for (int i = 0; i < points.length; i += 3) { +// pointList.add(new Vector3f(points[i], points[i + 1], points[i + 2])); +// } +// objectId = new ConvexHullShape(pointList); +// objectId.setLocalScaling(Converter.convert(getScale())); +// objectId.setMargin(margin); + ByteBuffer bbuf=BufferUtils.createByteBuffer(points.length * 4); +// fbuf = bbuf.asFloatBuffer(); +// fbuf.rewind(); +// fbuf.put(points); + for (int i = 0; i < points.length; i++) { + float f = points[i]; + bbuf.putFloat(f); + } + bbuf.rewind(); + objectId = createShape(bbuf); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); + setScale(scale); + setMargin(margin); + } + + private native long createShape(ByteBuffer points); + + protected float[] getPoints(Mesh mesh) { + FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); + vertices.rewind(); + int components = mesh.getVertexCount() * 3; + float[] pointsArray = new float[components]; + for (int i = 0; i < components; i += 3) { + pointsArray[i] = vertices.get(); + pointsArray[i + 1] = vertices.get(); + pointsArray[i + 2] = vertices.get(); + } + return pointsArray; + } +} diff --git a/engine/src/bullet/com/jme3/bullet/collision/shapes/MeshCollisionShape.java b/engine/src/bullet/com/jme3/bullet/collision/shapes/MeshCollisionShape.java index b7813a650..cee7c99e3 100644 --- a/engine/src/bullet/com/jme3/bullet/collision/shapes/MeshCollisionShape.java +++ b/engine/src/bullet/com/jme3/bullet/collision/shapes/MeshCollisionShape.java @@ -1,160 +1,161 @@ -/* - * Copyright (c) 2009-2010 jMonkeyEngine - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of 'jMonkeyEngine' nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package com.jme3.bullet.collision.shapes; - -import com.jme3.bullet.util.NativeMeshUtil; -import com.jme3.export.JmeExporter; -import com.jme3.export.JmeImporter; -import com.jme3.scene.Mesh; -import com.jme3.export.InputCapsule; -import com.jme3.export.OutputCapsule; -import com.jme3.scene.VertexBuffer.Type; -import com.jme3.scene.mesh.IndexBuffer; -import java.io.IOException; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.FloatBuffer; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * Basic mesh collision shape - * @author normenhansen - */ -public class MeshCollisionShape extends CollisionShape { - - protected int numVertices, numTriangles, vertexStride, triangleIndexStride; - protected ByteBuffer triangleIndexBase, vertexBase; - protected long meshId = 0; - - public MeshCollisionShape() { - } - - /** - * creates a collision shape from the given TriMesh - * @param mesh the TriMesh to use - */ - public MeshCollisionShape(Mesh mesh) { - createCollisionMesh(mesh); - } - - private void createCollisionMesh(Mesh mesh) { - triangleIndexBase = ByteBuffer.allocateDirect(mesh.getTriangleCount() * 3 * 4).order(ByteOrder.nativeOrder()); - vertexBase = ByteBuffer.allocateDirect(mesh.getVertexCount() * 3 * 4).order(ByteOrder.nativeOrder()); - numVertices = mesh.getVertexCount(); - vertexStride = 12; //3 verts * 4 bytes per. - numTriangles = mesh.getTriangleCount(); - triangleIndexStride = 12; //3 index entries * 4 bytes each. - - IndexBuffer indices = mesh.getIndexBuffer(); - FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); - vertices.rewind(); - - int verticesLength = mesh.getVertexCount() * 3; - for (int i = 0; i < verticesLength; i++) { - float tempFloat = vertices.get(); - vertexBase.putFloat(tempFloat); - } - - int indicesLength = mesh.getTriangleCount() * 3; - for (int i = 0; i < indicesLength; i++) { - triangleIndexBase.putInt(indices.get(i)); - } - vertices.rewind(); - vertices.clear(); - - createShape(); - } - - /** - * creates a jme mesh from the collision shape, only needed for debugging - */ -// public Mesh createJmeMesh(){ -// return Converter.convert(bulletMesh); -// } - public void write(JmeExporter ex) throws IOException { - super.write(ex); - OutputCapsule capsule = ex.getCapsule(this); - capsule.write(numVertices, "numVertices", 0); - capsule.write(numTriangles, "numTriangles", 0); - capsule.write(vertexStride, "vertexStride", 0); - capsule.write(triangleIndexStride, "triangleIndexStride", 0); - - capsule.write(triangleIndexBase.array(), "triangleIndexBase", new byte[0]); - capsule.write(vertexBase.array(), "vertexBase", new byte[0]); - } - - public void read(JmeImporter im) throws IOException { - super.read(im); - InputCapsule capsule = im.getCapsule(this); - numVertices = capsule.readInt("numVertices", 0); - numTriangles = capsule.readInt("numTriangles", 0); - vertexStride = capsule.readInt("vertexStride", 0); - triangleIndexStride = capsule.readInt("triangleIndexStride", 0); - - triangleIndexBase = ByteBuffer.wrap(capsule.readByteArray("triangleIndexBase", new byte[0])); - vertexBase = ByteBuffer.wrap(capsule.readByteArray("vertexBase", new byte[0])).order(ByteOrder.nativeOrder()); - createShape(); - } - - protected void createShape() { -// bulletMesh = new IndexedMesh(); -// bulletMesh.numVertices = numVertices; -// bulletMesh.numTriangles = numTriangles; -// bulletMesh.vertexStride = vertexStride; -// bulletMesh.triangleIndexStride = triangleIndexStride; -// bulletMesh.triangleIndexBase = triangleIndexBase; -// bulletMesh.vertexBase = vertexBase; -// bulletMesh.triangleIndexBase = triangleIndexBase; -// TriangleIndexVertexArray tiv = new TriangleIndexVertexArray(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); -// objectId = new BvhTriangleMeshShape(tiv, true); -// objectId.setLocalScaling(Converter.convert(getScale())); -// objectId.setMargin(margin); - meshId = NativeMeshUtil.createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Mesh {0}", Long.toHexString(meshId)); - objectId = createShape(meshId); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); - setScale(scale); - setMargin(margin); - } - - private native long createShape(long meshId); - - @Override - protected void finalize() throws Throwable { - super.finalize(); - Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Finalizing Mesh {0}", Long.toHexString(meshId)); - finalizeNative(meshId); - } - - private native void finalizeNative(long objectId); -} +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.bullet.collision.shapes; + +import com.jme3.bullet.util.NativeMeshUtil; +import com.jme3.export.JmeExporter; +import com.jme3.export.JmeImporter; +import com.jme3.scene.Mesh; +import com.jme3.export.InputCapsule; +import com.jme3.export.OutputCapsule; +import com.jme3.scene.VertexBuffer.Type; +import com.jme3.scene.mesh.IndexBuffer; +import com.jme3.util.BufferUtils; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Basic mesh collision shape + * @author normenhansen + */ +public class MeshCollisionShape extends CollisionShape { + + protected int numVertices, numTriangles, vertexStride, triangleIndexStride; + protected ByteBuffer triangleIndexBase, vertexBase; + protected long meshId = 0; + + public MeshCollisionShape() { + } + + /** + * creates a collision shape from the given TriMesh + * @param mesh the TriMesh to use + */ + public MeshCollisionShape(Mesh mesh) { + createCollisionMesh(mesh); + } + + private void createCollisionMesh(Mesh mesh) { + triangleIndexBase = BufferUtils.createByteBuffer(mesh.getTriangleCount() * 3 * 4); + vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4); + numVertices = mesh.getVertexCount(); + vertexStride = 12; //3 verts * 4 bytes per. + numTriangles = mesh.getTriangleCount(); + triangleIndexStride = 12; //3 index entries * 4 bytes each. + + IndexBuffer indices = mesh.getIndexBuffer(); + FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); + vertices.rewind(); + + int verticesLength = mesh.getVertexCount() * 3; + for (int i = 0; i < verticesLength; i++) { + float tempFloat = vertices.get(); + vertexBase.putFloat(tempFloat); + } + + int indicesLength = mesh.getTriangleCount() * 3; + for (int i = 0; i < indicesLength; i++) { + triangleIndexBase.putInt(indices.get(i)); + } + vertices.rewind(); + vertices.clear(); + + createShape(); + } + + /** + * creates a jme mesh from the collision shape, only needed for debugging + */ +// public Mesh createJmeMesh(){ +// return Converter.convert(bulletMesh); +// } + public void write(JmeExporter ex) throws IOException { + super.write(ex); + OutputCapsule capsule = ex.getCapsule(this); + capsule.write(numVertices, "numVertices", 0); + capsule.write(numTriangles, "numTriangles", 0); + capsule.write(vertexStride, "vertexStride", 0); + capsule.write(triangleIndexStride, "triangleIndexStride", 0); + + capsule.write(triangleIndexBase.array(), "triangleIndexBase", new byte[0]); + capsule.write(vertexBase.array(), "vertexBase", new byte[0]); + } + + public void read(JmeImporter im) throws IOException { + super.read(im); + InputCapsule capsule = im.getCapsule(this); + numVertices = capsule.readInt("numVertices", 0); + numTriangles = capsule.readInt("numTriangles", 0); + vertexStride = capsule.readInt("vertexStride", 0); + triangleIndexStride = capsule.readInt("triangleIndexStride", 0); + + triangleIndexBase = ByteBuffer.wrap(capsule.readByteArray("triangleIndexBase", new byte[0])); + vertexBase = ByteBuffer.wrap(capsule.readByteArray("vertexBase", new byte[0])).order(ByteOrder.nativeOrder()); + createShape(); + } + + protected void createShape() { +// bulletMesh = new IndexedMesh(); +// bulletMesh.numVertices = numVertices; +// bulletMesh.numTriangles = numTriangles; +// bulletMesh.vertexStride = vertexStride; +// bulletMesh.triangleIndexStride = triangleIndexStride; +// bulletMesh.triangleIndexBase = triangleIndexBase; +// bulletMesh.vertexBase = vertexBase; +// bulletMesh.triangleIndexBase = triangleIndexBase; +// TriangleIndexVertexArray tiv = new TriangleIndexVertexArray(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); +// objectId = new BvhTriangleMeshShape(tiv, true); +// objectId.setLocalScaling(Converter.convert(getScale())); +// objectId.setMargin(margin); + meshId = NativeMeshUtil.createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Mesh {0}", Long.toHexString(meshId)); + objectId = createShape(meshId); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Created Shape {0}", Long.toHexString(objectId)); + setScale(scale); + setMargin(margin); + } + + private native long createShape(long meshId); + + @Override + protected void finalize() throws Throwable { + super.finalize(); + Logger.getLogger(this.getClass().getName()).log(Level.INFO, "Finalizing Mesh {0}", Long.toHexString(meshId)); + finalizeNative(meshId); + } + + private native void finalizeNative(long objectId); +} diff --git a/engine/src/bullet/com/jme3/bullet/util/NativeMeshUtil.java b/engine/src/bullet/com/jme3/bullet/util/NativeMeshUtil.java index 83656d30a..4e14b8e52 100644 --- a/engine/src/bullet/com/jme3/bullet/util/NativeMeshUtil.java +++ b/engine/src/bullet/com/jme3/bullet/util/NativeMeshUtil.java @@ -1,77 +1,77 @@ -/* - * Copyright (c) 2009-2010 jMonkeyEngine - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of 'jMonkeyEngine' nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -package com.jme3.bullet.util; - -import com.jme3.scene.Mesh; -import com.jme3.scene.VertexBuffer.Type; -import com.jme3.scene.mesh.IndexBuffer; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.FloatBuffer; - -/** - * - * @author normenhansen - */ -public class NativeMeshUtil { - - public static long getTriangleIndexVertexArray(Mesh mesh){ - ByteBuffer triangleIndexBase = ByteBuffer.allocateDirect(mesh.getTriangleCount() * 3 * 4).order(ByteOrder.nativeOrder()); - ByteBuffer vertexBase = ByteBuffer.allocateDirect(mesh.getVertexCount() * 3 * 4).order(ByteOrder.nativeOrder()); - int numVertices = mesh.getVertexCount(); - int vertexStride = 12; //3 verts * 4 bytes per. - int numTriangles = mesh.getTriangleCount(); - int triangleIndexStride = 12; //3 index entries * 4 bytes each. - - IndexBuffer indices = mesh.getIndicesAsList(); - FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); - vertices.rewind(); - - int verticesLength = mesh.getVertexCount() * 3; - for (int i = 0; i < verticesLength; i++) { - float tempFloat = vertices.get(); - vertexBase.putFloat(tempFloat); - } - - int indicesLength = mesh.getTriangleCount() * 3; - for (int i = 0; i < indicesLength; i++) { - triangleIndexBase.putInt(indices.get(i)); - } - vertices.rewind(); - vertices.clear(); - - return createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride); - } - - public static native long createTriangleIndexVertexArray(ByteBuffer triangleIndexBase, ByteBuffer vertexBase, int numTraingles, int numVertices, int vertextStride, int triangleIndexStride); - -} +/* + * Copyright (c) 2009-2010 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package com.jme3.bullet.util; + +import com.jme3.scene.Mesh; +import com.jme3.scene.VertexBuffer.Type; +import com.jme3.scene.mesh.IndexBuffer; +import com.jme3.util.BufferUtils; +import java.nio.ByteBuffer; +import java.nio.FloatBuffer; + +/** + * + * @author normenhansen + */ +public class NativeMeshUtil { + + public static long getTriangleIndexVertexArray(Mesh mesh){ + ByteBuffer triangleIndexBase = BufferUtils.createByteBuffer(mesh.getTriangleCount() * 3 * 4); + ByteBuffer vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4); + int numVertices = mesh.getVertexCount(); + int vertexStride = 12; //3 verts * 4 bytes per. + int numTriangles = mesh.getTriangleCount(); + int triangleIndexStride = 12; //3 index entries * 4 bytes each. + + IndexBuffer indices = mesh.getIndicesAsList(); + FloatBuffer vertices = mesh.getFloatBuffer(Type.Position); + vertices.rewind(); + + int verticesLength = mesh.getVertexCount() * 3; + for (int i = 0; i < verticesLength; i++) { + float tempFloat = vertices.get(); + vertexBase.putFloat(tempFloat); + } + + int indicesLength = mesh.getTriangleCount() * 3; + for (int i = 0; i < indicesLength; i++) { + triangleIndexBase.putInt(indices.get(i)); + } + vertices.rewind(); + vertices.clear(); + + return createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride); + } + + public static native long createTriangleIndexVertexArray(ByteBuffer triangleIndexBase, ByteBuffer vertexBase, int numTraingles, int numVertices, int vertextStride, int triangleIndexStride); + +} diff --git a/engine/src/core-plugins/com/jme3/texture/plugins/TGALoader.java b/engine/src/core-plugins/com/jme3/texture/plugins/TGALoader.java index f0f5910d2..b075a4b32 100644 --- a/engine/src/core-plugins/com/jme3/texture/plugins/TGALoader.java +++ b/engine/src/core-plugins/com/jme3/texture/plugins/TGALoader.java @@ -85,7 +85,7 @@ public final class TGALoader implements AssetLoader { boolean flip = ((TextureKey)info.getKey()).isFlipY(); InputStream in = info.openStream(); Image img = load(in, flip); -// in.close(); + in.close(); return img; } @@ -189,7 +189,7 @@ public final class TGALoader implements AssetLoader { // Allocate image data array - Format format = null; + Format format; byte[] rawData = null; int dl; if (pixelDepth == 32) { @@ -442,6 +442,8 @@ public final class TGALoader implements AssetLoader { } format = dl == 4 ? Format.RGBA8 : Format.RGB8; + } else { + throw new IOException("Grayscale TGA not supported"); }