| /* |
| * 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 jme3tools.converters.model; |
| |
| import com.jme3.bounding.BoundingBox; |
| import com.jme3.math.Transform; |
| import com.jme3.math.Vector2f; |
| import com.jme3.math.Vector3f; |
| import com.jme3.scene.Geometry; |
| import com.jme3.scene.Mesh; |
| import com.jme3.scene.VertexBuffer; |
| import com.jme3.scene.VertexBuffer.Format; |
| import com.jme3.scene.VertexBuffer.Type; |
| import com.jme3.scene.VertexBuffer.Usage; |
| import com.jme3.scene.mesh.IndexBuffer; |
| import com.jme3.util.BufferUtils; |
| import java.nio.*; |
| |
| public class FloatToFixed { |
| |
| private static final float shortSize = Short.MAX_VALUE - Short.MIN_VALUE; |
| private static final float shortOff = (Short.MAX_VALUE + Short.MIN_VALUE) * 0.5f; |
| |
| private static final float byteSize = Byte.MAX_VALUE - Byte.MIN_VALUE; |
| private static final float byteOff = (Byte.MAX_VALUE + Byte.MIN_VALUE) * 0.5f; |
| |
| public static void convertToFixed(Geometry geom, Format posFmt, Format nmFmt, Format tcFmt){ |
| geom.updateModelBound(); |
| BoundingBox bbox = (BoundingBox) geom.getModelBound(); |
| Mesh mesh = geom.getMesh(); |
| |
| VertexBuffer positions = mesh.getBuffer(Type.Position); |
| VertexBuffer normals = mesh.getBuffer(Type.Normal); |
| VertexBuffer texcoords = mesh.getBuffer(Type.TexCoord); |
| VertexBuffer indices = mesh.getBuffer(Type.Index); |
| |
| // positions |
| FloatBuffer fb = (FloatBuffer) positions.getData(); |
| if (posFmt != Format.Float){ |
| Buffer newBuf = VertexBuffer.createBuffer(posFmt, positions.getNumComponents(), |
| mesh.getVertexCount()); |
| Transform t = convertPositions(fb, bbox, newBuf); |
| t.combineWithParent(geom.getLocalTransform()); |
| geom.setLocalTransform(t); |
| |
| VertexBuffer newPosVb = new VertexBuffer(Type.Position); |
| newPosVb.setupData(positions.getUsage(), |
| positions.getNumComponents(), |
| posFmt, |
| newBuf); |
| mesh.clearBuffer(Type.Position); |
| mesh.setBuffer(newPosVb); |
| } |
| |
| // normals, automatically convert to signed byte |
| fb = (FloatBuffer) normals.getData(); |
| |
| ByteBuffer bb = BufferUtils.createByteBuffer(fb.capacity()); |
| convertNormals(fb, bb); |
| |
| normals = new VertexBuffer(Type.Normal); |
| normals.setupData(Usage.Static, 3, Format.Byte, bb); |
| normals.setNormalized(true); |
| mesh.clearBuffer(Type.Normal); |
| mesh.setBuffer(normals); |
| |
| // texcoords |
| fb = (FloatBuffer) texcoords.getData(); |
| if (tcFmt != Format.Float){ |
| Buffer newBuf = VertexBuffer.createBuffer(tcFmt, |
| texcoords.getNumComponents(), |
| mesh.getVertexCount()); |
| convertTexCoords2D(fb, newBuf); |
| |
| VertexBuffer newTcVb = new VertexBuffer(Type.TexCoord); |
| newTcVb.setupData(texcoords.getUsage(), |
| texcoords.getNumComponents(), |
| tcFmt, |
| newBuf); |
| mesh.clearBuffer(Type.TexCoord); |
| mesh.setBuffer(newTcVb); |
| } |
| } |
| |
| public static void compressIndexBuffer(Mesh mesh){ |
| int vertCount = mesh.getVertexCount(); |
| VertexBuffer vb = mesh.getBuffer(Type.Index); |
| Format targetFmt; |
| if (vb.getFormat() == Format.UnsignedInt && vertCount <= 0xffff){ |
| if (vertCount <= 256) |
| targetFmt = Format.UnsignedByte; |
| else |
| targetFmt = Format.UnsignedShort; |
| }else if (vb.getFormat() == Format.UnsignedShort && vertCount <= 0xff){ |
| targetFmt = Format.UnsignedByte; |
| }else{ |
| return; |
| } |
| |
| IndexBuffer src = mesh.getIndexBuffer(); |
| Buffer newBuf = VertexBuffer.createBuffer(targetFmt, vb.getNumComponents(), src.size()); |
| |
| VertexBuffer newVb = new VertexBuffer(Type.Index); |
| newVb.setupData(vb.getUsage(), vb.getNumComponents(), targetFmt, newBuf); |
| mesh.clearBuffer(Type.Index); |
| mesh.setBuffer(newVb); |
| |
| IndexBuffer dst = mesh.getIndexBuffer(); |
| for (int i = 0; i < src.size(); i++){ |
| dst.put(i, src.get(i)); |
| } |
| } |
| |
| private static void convertToFixed(FloatBuffer input, IntBuffer output){ |
| if (output.capacity() < input.capacity()) |
| throw new RuntimeException("Output must be at least as large as input!"); |
| |
| input.clear(); |
| output.clear(); |
| for (int i = 0; i < input.capacity(); i++){ |
| output.put( (int) (input.get() * (float)(1<<16)) ); |
| } |
| output.flip(); |
| } |
| |
| private static void convertToFloat(IntBuffer input, FloatBuffer output){ |
| if (output.capacity() < input.capacity()) |
| throw new RuntimeException("Output must be at least as large as input!"); |
| |
| input.clear(); |
| output.clear(); |
| for (int i = 0; i < input.capacity(); i++){ |
| output.put( ((float)input.get() / (float)(1<<16)) ); |
| } |
| output.flip(); |
| } |
| |
| private static void convertToUByte(FloatBuffer input, ByteBuffer output){ |
| if (output.capacity() < input.capacity()) |
| throw new RuntimeException("Output must be at least as large as input!"); |
| |
| input.clear(); |
| output.clear(); |
| for (int i = 0; i < input.capacity(); i++){ |
| output.put( (byte) (input.get() * 255f) ); |
| } |
| output.flip(); |
| } |
| |
| |
| public static VertexBuffer convertToUByte(VertexBuffer vb){ |
| FloatBuffer fb = (FloatBuffer) vb.getData(); |
| ByteBuffer bb = BufferUtils.createByteBuffer(fb.capacity()); |
| convertToUByte(fb, bb); |
| |
| VertexBuffer newVb = new VertexBuffer(vb.getBufferType()); |
| newVb.setupData(vb.getUsage(), |
| vb.getNumComponents(), |
| Format.UnsignedByte, |
| bb); |
| newVb.setNormalized(true); |
| return newVb; |
| } |
| |
| public static VertexBuffer convertToFixed(VertexBuffer vb){ |
| if (vb.getFormat() == Format.Int) |
| return vb; |
| |
| FloatBuffer fb = (FloatBuffer) vb.getData(); |
| IntBuffer ib = BufferUtils.createIntBuffer(fb.capacity()); |
| convertToFixed(fb, ib); |
| |
| VertexBuffer newVb = new VertexBuffer(vb.getBufferType()); |
| newVb.setupData(vb.getUsage(), |
| vb.getNumComponents(), |
| Format.Int, |
| ib); |
| return newVb; |
| } |
| |
| public static VertexBuffer convertToFloat(VertexBuffer vb){ |
| if (vb.getFormat() == Format.Float) |
| return vb; |
| |
| IntBuffer ib = (IntBuffer) vb.getData(); |
| FloatBuffer fb = BufferUtils.createFloatBuffer(ib.capacity()); |
| convertToFloat(ib, fb); |
| |
| VertexBuffer newVb = new VertexBuffer(vb.getBufferType()); |
| newVb.setupData(vb.getUsage(), |
| vb.getNumComponents(), |
| Format.Float, |
| fb); |
| return newVb; |
| } |
| |
| private static void convertNormals(FloatBuffer input, ByteBuffer output){ |
| if (output.capacity() < input.capacity()) |
| throw new RuntimeException("Output must be at least as large as input!"); |
| |
| input.clear(); |
| output.clear(); |
| Vector3f temp = new Vector3f(); |
| int vertexCount = input.capacity() / 3; |
| for (int i = 0; i < vertexCount; i++){ |
| BufferUtils.populateFromBuffer(temp, input, i); |
| |
| // offset and scale vector into -128 ... 127 |
| temp.multLocal(127).addLocal(0.5f, 0.5f, 0.5f); |
| |
| // quantize |
| byte v1 = (byte) temp.getX(); |
| byte v2 = (byte) temp.getY(); |
| byte v3 = (byte) temp.getZ(); |
| |
| // store |
| output.put(v1).put(v2).put(v3); |
| } |
| } |
| |
| private static void convertTexCoords2D(FloatBuffer input, Buffer output){ |
| if (output.capacity() < input.capacity()) |
| throw new RuntimeException("Output must be at least as large as input!"); |
| |
| input.clear(); |
| output.clear(); |
| Vector2f temp = new Vector2f(); |
| int vertexCount = input.capacity() / 2; |
| |
| ShortBuffer sb = null; |
| IntBuffer ib = null; |
| |
| if (output instanceof ShortBuffer) |
| sb = (ShortBuffer) output; |
| else if (output instanceof IntBuffer) |
| ib = (IntBuffer) output; |
| else |
| throw new UnsupportedOperationException(); |
| |
| for (int i = 0; i < vertexCount; i++){ |
| BufferUtils.populateFromBuffer(temp, input, i); |
| |
| if (sb != null){ |
| sb.put( (short) (temp.getX()*Short.MAX_VALUE) ); |
| sb.put( (short) (temp.getY()*Short.MAX_VALUE) ); |
| }else{ |
| int v1 = (int) (temp.getX() * ((float)(1 << 16))); |
| int v2 = (int) (temp.getY() * ((float)(1 << 16))); |
| ib.put(v1).put(v2); |
| } |
| } |
| } |
| |
| private static Transform convertPositions(FloatBuffer input, BoundingBox bbox, Buffer output){ |
| if (output.capacity() < input.capacity()) |
| throw new RuntimeException("Output must be at least as large as input!"); |
| |
| Vector3f offset = bbox.getCenter().negate(); |
| Vector3f size = new Vector3f(bbox.getXExtent(), bbox.getYExtent(), bbox.getZExtent()); |
| size.multLocal(2); |
| |
| ShortBuffer sb = null; |
| ByteBuffer bb = null; |
| float dataTypeSize; |
| float dataTypeOffset; |
| if (output instanceof ShortBuffer){ |
| sb = (ShortBuffer) output; |
| dataTypeOffset = shortOff; |
| dataTypeSize = shortSize; |
| }else{ |
| bb = (ByteBuffer) output; |
| dataTypeOffset = byteOff; |
| dataTypeSize = byteSize; |
| } |
| Vector3f scale = new Vector3f(); |
| scale.set(dataTypeSize, dataTypeSize, dataTypeSize).divideLocal(size); |
| |
| Vector3f invScale = new Vector3f(); |
| invScale.set(size).divideLocal(dataTypeSize); |
| |
| offset.multLocal(scale); |
| offset.addLocal(dataTypeOffset, dataTypeOffset, dataTypeOffset); |
| |
| // offset = (-modelOffset * shortSize)/modelSize + shortOff |
| // scale = shortSize / modelSize |
| |
| input.clear(); |
| output.clear(); |
| Vector3f temp = new Vector3f(); |
| int vertexCount = input.capacity() / 3; |
| for (int i = 0; i < vertexCount; i++){ |
| BufferUtils.populateFromBuffer(temp, input, i); |
| |
| // offset and scale vector into -32768 ... 32767 |
| // or into -128 ... 127 if using bytes |
| temp.multLocal(scale); |
| temp.addLocal(offset); |
| |
| // quantize and store |
| if (sb != null){ |
| short v1 = (short) temp.getX(); |
| short v2 = (short) temp.getY(); |
| short v3 = (short) temp.getZ(); |
| sb.put(v1).put(v2).put(v3); |
| }else{ |
| byte v1 = (byte) temp.getX(); |
| byte v2 = (byte) temp.getY(); |
| byte v3 = (byte) temp.getZ(); |
| bb.put(v1).put(v2).put(v3); |
| } |
| } |
| |
| Transform transform = new Transform(); |
| transform.setTranslation(offset.negate().multLocal(invScale)); |
| transform.setScale(invScale); |
| return transform; |
| } |
| |
| } |
