Commit: 654ba48c1411cde75816cfb78e800410438e66ac - MikuMikuStudio (git)

Main repository of MikuMikuStudio

Commit MetaInfo

• Revision: 654ba48c1411cde75816cfb78e800410438e66ac (tree)
• Time: 2013-07-07 06:22:17
• Author: kobayasi <kobayasi@pscn...>
• Commiter: kobayasi

Log Message

merge from jme10694

Change Summary

• modified: engine/src/core/com/jme3/scene/BatchNode.java
• modified: engine/src/core/com/jme3/scene/Geometry.java
• modified: engine/src/core/com/jme3/scene/SimpleBatchNode.java
• modified: engine/src/core/com/jme3/scene/Spatial.java
• modified: engine/src/core/com/jme3/scene/VertexBuffer.java

Incremental Difference

--- a/engine/src/core/com/jme3/scene/BatchNode.java
+++ b/engine/src/core/com/jme3/scene/BatchNode.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009-2011 jMonkeyEngine
+ * Copyright (c) 2009-2012 jMonkeyEngine
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,17 +31,13 @@
  */
 package com.jme3.scene;
 
-import com.jme3.export.InputCapsule;
-import com.jme3.export.JmeExporter;
-import com.jme3.export.JmeImporter;
-import com.jme3.export.OutputCapsule;
-import com.jme3.export.Savable;
+import com.jme3.export.*;
 import com.jme3.material.Material;
 import com.jme3.math.Matrix4f;
 import com.jme3.math.Transform;
 import com.jme3.math.Vector3f;
 import com.jme3.scene.mesh.IndexBuffer;
-import com.jme3.util.IntMap.Entry;
+import com.jme3.util.SafeArrayList;
 import com.jme3.util.TempVars;
 import java.io.IOException;
 import java.nio.Buffer;
@@ -54,28 +50,41 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 
 /**
- * BatchNode holds geometrie that are batched version of all geometries that are in its sub scenegraph.
+ * BatchNode holds geometries that are a batched version of all the geometries that are in its sub scenegraph.
  * There is one geometry per different material in the sub tree.
- * this geometries are directly attached to the node in the scene graph.
- * usage is like any other node except you have to call the {@link #batch()} method once all geoms have been attached to the sub scene graph and theire material set
+ * The geometries are directly attached to the node in the scene graph.
+ * Usage is like any other node except you have to call the {@link #batch()} method once all the geometries have been attached to the sub scene graph and their material set
  * (see todo more automagic for further enhancements)
- * all the geometry that have been batched are set to {@link CullHint#Always} to not render them.
- * the sub geometries can be transformed as usual their transforms are used to update the mesh of the geometryBatch.
- * sub geoms can be removed but it may be slower than the normal spatial removing
- * Sub geoms can be added after the batch() method has been called but won't be batched and will be rendered as normal geometries.
+ * All the geometries that have been batched are set to {@link CullHint#Always} to not render them.
+ * The sub geometries can be transformed as usual, their transforms are used to update the mesh of the geometryBatch.
+ * Sub geoms can be removed but it may be slower than the normal spatial removing
+ * Sub geoms can be added after the batch() method has been called but won't be batched and will just be rendered as normal geometries.
  * To integrate them in the batch you have to call the batch() method again on the batchNode.
  * 
  * TODO normal or tangents or both looks a bit weird
- * TODO more automagic (batch when needed in the updateLigicalState)
+ * TODO more automagic (batch when needed in the updateLogicalState)
  * @author Nehon
  */
 public class BatchNode extends Node implements Savable {
 
     private static final Logger logger = Logger.getLogger(BatchNode.class.getName());
     /**
-     * the map of geometry holding the batched meshes
+     * the list of geometry holding the batched meshes
      */
-    protected Map<Material, Batch> batches = new HashMap<Material, Batch>();
+    protected SafeArrayList<Batch> batches = new SafeArrayList<Batch>(Batch.class);
+    /**
+     * a map storing he batches by geometry to quickly acces the batch when updating
+     */
+    protected Map<Geometry, Batch> batchesByGeom = new HashMap<Geometry, Batch>();
+    /**
+     * used to store transformed vectors before proceeding to a bulk put into the FloatBuffer 
+     */
+    private float[] tmpFloat;
+    private float[] tmpFloatN;
+    private float[] tmpFloatT;
+    int maxVertCount = 0;
+    boolean useTangents = false;
+    boolean needsFullRebatch = true;
 
     /**
      * Construct a batchNode
@@ -111,9 +120,9 @@ public class BatchNode extends Node implements Savable {
                 child.updateGeometricState();
             }
 
-            for (Batch batch : batches.values()) {
+            for (Batch batch : batches.getArray()) {
                 if (batch.needMeshUpdate) {
-                    batch.geometry.getMesh().updateBound();
+                    batch.geometry.updateModelBound();
                     batch.geometry.updateWorldBound();
                     batch.needMeshUpdate = false;
 
@@ -129,31 +138,42 @@ public class BatchNode extends Node implements Savable {
 
         assert refreshFlags == 0;
     }
-    
-    protected Transform getTransforms(Geometry geom){
-        return geom.getWorldTransform();
-    }
 
+    protected Matrix4f getTransformMatrix(Geometry g){
+        return g.cachedWorldMat;
+    }
+    
     protected void updateSubBatch(Geometry bg) {
-        Batch batch = batches.get(bg.getMaterial());
+        Batch batch = batchesByGeom.get(bg);
         if (batch != null) {
             Mesh mesh = batch.geometry.getMesh();
-
-            FloatBuffer buf = (FloatBuffer) mesh.getBuffer(VertexBuffer.Type.Position).getData();
-            doTransformVerts(buf, 0, bg.startIndex, bg.startIndex + bg.getVertexCount(), buf, bg.cachedOffsetMat);
-            mesh.getBuffer(VertexBuffer.Type.Position).updateData(buf);
-
-            buf = (FloatBuffer) mesh.getBuffer(VertexBuffer.Type.Normal).getData();
-            doTransformNorm(buf, 0, bg.startIndex, bg.startIndex + bg.getVertexCount(), buf, bg.cachedOffsetMat);
-            mesh.getBuffer(VertexBuffer.Type.Normal).updateData(buf);
-
-
+            Mesh origMesh = bg.getMesh();
+
+            VertexBuffer pvb = mesh.getBuffer(VertexBuffer.Type.Position);
+            FloatBuffer posBuf = (FloatBuffer) pvb.getData();
+            VertexBuffer nvb = mesh.getBuffer(VertexBuffer.Type.Normal);
+            FloatBuffer normBuf = (FloatBuffer) nvb.getData();
+          
+            VertexBuffer opvb = origMesh.getBuffer(VertexBuffer.Type.Position);
+            FloatBuffer oposBuf = (FloatBuffer) opvb.getData();
+            VertexBuffer onvb = origMesh.getBuffer(VertexBuffer.Type.Normal);
+            FloatBuffer onormBuf = (FloatBuffer) onvb.getData();
+            Matrix4f transformMat = getTransformMatrix(bg);
+            
             if (mesh.getBuffer(VertexBuffer.Type.Tangent) != null) {
 
-                buf = (FloatBuffer) mesh.getBuffer(VertexBuffer.Type.Tangent).getData();
-                doTransformNorm(buf, 0, bg.startIndex, bg.startIndex + bg.getVertexCount(), buf, bg.cachedOffsetMat);
-                mesh.getBuffer(VertexBuffer.Type.Tangent).updateData(buf);
+                VertexBuffer tvb = mesh.getBuffer(VertexBuffer.Type.Tangent);
+                FloatBuffer tanBuf = (FloatBuffer) tvb.getData();
+                VertexBuffer otvb = origMesh.getBuffer(VertexBuffer.Type.Tangent);
+                FloatBuffer otanBuf = (FloatBuffer) otvb.getData();
+                doTransformsTangents(oposBuf, onormBuf, otanBuf, posBuf, normBuf, tanBuf, bg.startIndex, bg.startIndex + bg.getVertexCount(), transformMat);
+                tvb.updateData(tanBuf);
+            } else {
+                doTransforms(oposBuf, onormBuf, posBuf, normBuf, bg.startIndex, bg.startIndex + bg.getVertexCount(), transformMat);
             }
+            pvb.updateData(posBuf);
+            nvb.updateData(normBuf);
+
 
             batch.needMeshUpdate = true;
         }
@@ -166,26 +186,55 @@ public class BatchNode extends Node implements Savable {
     public void batch() {
         doBatch();
         //we set the batch geometries to ignore transforms to avoid transforms of parent nodes to be applied twice        
-        for (Batch batch : batches.values()) {
+        for (Batch batch : batches.getArray()) {
             batch.geometry.setIgnoreTransform(true);
+            batch.geometry.setUserData(UserData.JME_PHYSICSIGNORE, true);
         }
+        updateGeometricState();
     }
 
     protected void doBatch() {
-        ///List<Geometry> tmpList = new ArrayList<Geometry>();
-        Map<Material, List<Geometry>> matMap = new HashMap<Material, List<Geometry>>();
-
-        gatherGeomerties(matMap, this);
-        batches.clear();
+        Map<Material, List<Geometry>> matMap = new HashMap<Material, List<Geometry>>();    
         int nbGeoms = 0;
-        for (Material material : matMap.keySet()) {
+
+        gatherGeomerties(matMap, this, needsFullRebatch);
+        if (needsFullRebatch) {
+            for (Batch batch : batches.getArray()) {
+                batch.geometry.removeFromParent();
+            }
+            batches.clear();
+            batchesByGeom.clear();
+        }        
+        //only reset maxVertCount if there is something new to batch
+        if (matMap.size() > 0) {
+            maxVertCount = 0;
+        }
+        
+        for (Map.Entry<Material, List<Geometry>> entry : matMap.entrySet()) {
             Mesh m = new Mesh();
-            List<Geometry> list = matMap.get(material);
+            Material material = entry.getKey();
+            List<Geometry> list = entry.getValue();
             nbGeoms += list.size();
+            String batchName = name + "-batch" + batches.size();
+            Batch batch;
+            if (!needsFullRebatch) {
+                batch = findBatchByMaterial(material);
+                if (batch != null) {
+                    list.add(0, batch.geometry);
+                    batchName = batch.geometry.getName();
+                    batch.geometry.removeFromParent();
+                } else {
+                    batch = new Batch();
+                }
+            } else {
+                batch = new Batch();
+            }
             mergeGeometries(m, list);
-            Batch batch = new Batch();
+            m.setDynamic();
+
+            batch.updateGeomList(list);
 
-            batch.geometry = new Geometry(name + "-batch" + batches.size());
+            batch.geometry = new Geometry(batchName);
             batch.geometry.setMaterial(material);
             this.attachChild(batch.geometry);
 
@@ -193,25 +242,81 @@ public class BatchNode extends Node implements Savable {
             batch.geometry.setMesh(m);
             batch.geometry.getMesh().updateCounts();
             batch.geometry.getMesh().updateBound();
-            batches.put(material, batch);
+            batches.add(batch);
+        }
+        if (batches.size() > 0) {
+            needsFullRebatch = false;
+        }
+
+
+        logger.log(Level.FINE, "Batched {0} geometries in {1} batches.", new Object[]{nbGeoms, batches.size()});
+
+        //init the temp arrays if something has been batched only.
+        if(matMap.size()>0){
+            //TODO these arrays should be allocated by chunk instead to avoid recreating them each time the batch is changed.
+            //init temp float arrays
+            tmpFloat = new float[maxVertCount * 3];
+            tmpFloatN = new float[maxVertCount * 3];
+            if (useTangents) {
+                tmpFloatT = new float[maxVertCount * 4];
+            }
         }
-        logger.log(Level.INFO, "Batched {0} geometries in {1} batches.", new Object[]{nbGeoms, batches.size()});
     }
 
-    private void gatherGeomerties(Map<Material, List<Geometry>> map, Spatial n) {
+    //in case the detached spatial is a node, we unbatch all geometries in its subegraph
+    @Override
+    public Spatial detachChildAt(int index) {
+        Spatial s = super.detachChildAt(index);
+        if (s instanceof Node) {
+            unbatchSubGraph(s);
+        }
+        return s;
+    }
 
-        if (n.getClass() == Geometry.class) {
-            if (!isBatch(n)) {
+    /**
+     * recursively visit the subgraph and unbatch geometries
+     * @param s 
+     */
+    private void unbatchSubGraph(Spatial s) {
+        if (s instanceof Node) {
+            for (Spatial sp : ((Node) s).getChildren()) {
+                unbatchSubGraph(sp);
+            }
+        } else if (s instanceof Geometry) {
+            Geometry g = (Geometry) s;
+            if (g.isBatched()) {
+                g.unBatch();
+            }
+        }
+    }
+    
+    
+    private void gatherGeomerties(Map<Material, List<Geometry>> map, Spatial n, boolean rebatch) {
+
+        if (n instanceof Geometry) {
+
+            if (!isBatch(n) && n.getBatchHint() != BatchHint.Never) {
                 Geometry g = (Geometry) n;
-                if (g.getMaterial() == null) {
-                    throw new IllegalStateException("No material is set for Geometry: " + g.getName() + " please set a material before batching");
-                }
-                List<Geometry> list = map.get(g.getMaterial());
-                if (list == null) {
-                    list = new ArrayList<Geometry>();
-                    map.put(g.getMaterial(), list);
+                if (!g.isBatched() || rebatch) {
+                    if (g.getMaterial() == null) {
+                        throw new IllegalStateException("No material is set for Geometry: " + g.getName() + " please set a material before batching");
+                    }
+                    List<Geometry> list = map.get(g.getMaterial());
+                    if (list == null) {
+                        //trying to compare materials with the isEqual method 
+                        for (Map.Entry<Material, List<Geometry>> mat : map.entrySet()) {
+                            if (g.getMaterial().contentEquals(mat.getKey())) {
+                                list = mat.getValue();
+                            }
+                        }
+                    }
+                    if (list == null) {
+                        list = new ArrayList<Geometry>();
+                        map.put(g.getMaterial(), list);
+                    }
+                    g.setTransformRefresh();
+                    list.add(g);
                 }
-                list.add(g);
             }
 
         } else if (n instanceof Node) {
@@ -219,14 +324,23 @@ public class BatchNode extends Node implements Savable {
                 if (child instanceof BatchNode) {
                     continue;
                 }
-                gatherGeomerties(map, child);
+                gatherGeomerties(map, child, rebatch);
             }
         }
 
     }
 
+    private Batch findBatchByMaterial(Material m) {
+        for (Batch batch : batches.getArray()) {
+            if (batch.geometry.getMaterial().contentEquals(m)) {
+                return batch;
+            }
+        }
+        return null;
+    }
+
     private boolean isBatch(Spatial s) {
-        for (Batch batch : batches.values()) {
+        for (Batch batch : batches.getArray()) {
             if (batch.geometry == s) {
                 return true;
             }
@@ -259,12 +373,12 @@ public class BatchNode extends Node implements Savable {
      */
     public Material getMaterial() {
         if (!batches.isEmpty()) {
-            Batch b = batches.get(batches.keySet().iterator().next());
+            Batch b = batches.iterator().next();
             return b.geometry.getMaterial();
         }
         return null;//material;
     }
-    
+
 //    /**
 //     * Sets the material to the a specific batch of this BatchNode
 //     * 
@@ -294,7 +408,6 @@ public class BatchNode extends Node implements Savable {
 //        }
 //        return null;//material;
 //    }
-
     @Override
     public void write(JmeExporter ex) throws IOException {
         super.write(ex);
@@ -347,13 +460,16 @@ public class BatchNode extends Node implements Savable {
         int totalVerts = 0;
         int totalTris = 0;
         int totalLodLevels = 0;
+        int maxWeights = -1;
 
         Mesh.Mode mode = null;
         for (Geometry geom : geometries) {
             totalVerts += geom.getVertexCount();
             totalTris += geom.getTriangleCount();
             totalLodLevels = Math.min(totalLodLevels, geom.getMesh().getNumLodLevels());
-
+            if (maxVertCount < geom.getVertexCount()) {
+                maxVertCount = geom.getVertexCount();
+            }
             Mesh.Mode listMode;
             int components;
             switch (geom.getMesh().getMode()) {
@@ -377,10 +493,12 @@ public class BatchNode extends Node implements Savable {
                     throw new UnsupportedOperationException();
             }
 
-            for (Entry<VertexBuffer> entry : geom.getMesh().getBuffers()) {
-                compsForBuf[entry.getKey()] = entry.getValue().getNumComponents();
-                formatForBuf[entry.getKey()] = entry.getValue().getFormat();
+            for (VertexBuffer vb : geom.getMesh().getBufferList().getArray()) {
+                compsForBuf[vb.getBufferType().ordinal()] = vb.getNumComponents();
+                formatForBuf[vb.getBufferType().ordinal()] = vb.getFormat();
             }
+            
+            maxWeights = Math.max(maxWeights, geom.getMesh().getMaxNumWeights());
 
             if (mode != null && mode != listMode) {
                 throw new UnsupportedOperationException("Cannot combine different"
@@ -390,6 +508,7 @@ public class BatchNode extends Node implements Savable {
             compsForBuf[VertexBuffer.Type.Index.ordinal()] = components;
         }
 
+        outMesh.setMaxNumWeights(maxWeights);
         outMesh.setMode(mode);
         if (totalVerts >= 65536) {
             // make sure we create an UnsignedInt buffer so
@@ -413,7 +532,7 @@ public class BatchNode extends Node implements Savable {
             }
 
             VertexBuffer vb = new VertexBuffer(VertexBuffer.Type.values()[i]);
-            vb.setupData(VertexBuffer.Usage.Static, compsForBuf[i], formatForBuf[i], data);
+            vb.setupData(VertexBuffer.Usage.Dynamic, compsForBuf[i], formatForBuf[i], data);
             outMesh.setBuffer(vb);
         }
 
@@ -422,13 +541,16 @@ public class BatchNode extends Node implements Savable {
 
         for (Geometry geom : geometries) {
             Mesh inMesh = geom.getMesh();
-            geom.batch(this, globalVertIndex);
+            if (!isBatch(geom)) {
+                geom.batch(this, globalVertIndex);
+            }
 
             int geomVertCount = inMesh.getVertexCount();
             int geomTriCount = inMesh.getTriangleCount();
 
             for (int bufType = 0; bufType < compsForBuf.length; bufType++) {
                 VertexBuffer inBuf = inMesh.getBuffer(VertexBuffer.Type.values()[bufType]);
+
                 VertexBuffer outBuf = outMesh.getBuffer(VertexBuffer.Type.values()[bufType]);
 
                 if (outBuf == null) {
@@ -450,16 +572,20 @@ public class BatchNode extends Node implements Savable {
                 } else if (VertexBuffer.Type.Position.ordinal() == bufType) {
                     FloatBuffer inPos = (FloatBuffer) inBuf.getData();
                     FloatBuffer outPos = (FloatBuffer) outBuf.getData();
-                    doCopyBuffer(inPos, globalVertIndex, outPos);
+                    doCopyBuffer(inPos, globalVertIndex, outPos, 3);
                 } else if (VertexBuffer.Type.Normal.ordinal() == bufType || VertexBuffer.Type.Tangent.ordinal() == bufType) {
                     FloatBuffer inPos = (FloatBuffer) inBuf.getData();
                     FloatBuffer outPos = (FloatBuffer) outBuf.getData();
-                    doCopyBuffer(inPos, globalVertIndex, outPos);
-                } else {
-                    for (int vert = 0; vert < geomVertCount; vert++) {
-                        int curGlobalVertIndex = globalVertIndex + vert;
-                        inBuf.copyElement(vert, outBuf, curGlobalVertIndex);
+                    doCopyBuffer(inPos, globalVertIndex, outPos, compsForBuf[bufType]);
+                    if (VertexBuffer.Type.Tangent.ordinal() == bufType) {
+                        useTangents = true;
                     }
+                } else {
+                    inBuf.copyElements(0, outBuf, globalVertIndex, geomVertCount);
+//                    for (int vert = 0; vert < geomVertCount; vert++) {
+//                        int curGlobalVertIndex = globalVertIndex + vert;
+//                        inBuf.copyElement(vert, outBuf, curGlobalVertIndex);
+//                    }
                 }
             }
 
@@ -468,75 +594,164 @@ public class BatchNode extends Node implements Savable {
         }
     }
 
-    private void doTransformVerts(FloatBuffer inBuf, int offset, int start, int end, FloatBuffer outBuf, Matrix4f transform) {
+    private void doTransforms(FloatBuffer bindBufPos, FloatBuffer bindBufNorm, FloatBuffer bufPos, FloatBuffer bufNorm, int start, int end, Matrix4f transform) {
         TempVars vars = TempVars.get();
         Vector3f pos = vars.vect1;
+        Vector3f norm = vars.vect2;
+
+        int length = (end - start) * 3;
 
         // offset is given in element units
         // convert to be in component units
-        offset *= 3;
-
-        for (int i = start; i < end; i++) {
-            int index = i * 3;
-            pos.x = inBuf.get(index);
-            pos.y = inBuf.get(index + 1);
-            pos.z = inBuf.get(index + 2);
+        int offset = start * 3;
+        bindBufPos.rewind();
+        bindBufNorm.rewind();
+        //bufPos.position(offset);
+        //bufNorm.position(offset);
+        bindBufPos.get(tmpFloat, 0, length);
+        bindBufNorm.get(tmpFloatN, 0, length);
+        int index = 0;
+        while (index < length) {
+            pos.x = tmpFloat[index];
+            norm.x = tmpFloatN[index++];
+            pos.y = tmpFloat[index];
+            norm.y = tmpFloatN[index++];
+            pos.z = tmpFloat[index];
+            norm.z = tmpFloatN[index];
 
             transform.mult(pos, pos);
-            index += offset;
-            outBuf.put(index, pos.x);
-            outBuf.put(index + 1, pos.y);
-            outBuf.put(index + 2, pos.z);
+            transform.multNormal(norm, norm);
+
+            index -= 2;
+            tmpFloat[index] = pos.x;
+            tmpFloatN[index++] = norm.x;
+            tmpFloat[index] = pos.y;
+            tmpFloatN[index++] = norm.y;
+            tmpFloat[index] = pos.z;
+            tmpFloatN[index++] = norm.z;
+
         }
         vars.release();
+        bufPos.position(offset);
+        //using bulk put as it's faster
+        bufPos.put(tmpFloat, 0, length);
+        bufNorm.position(offset);
+        //using bulk put as it's faster
+        bufNorm.put(tmpFloatN, 0, length);
     }
 
-    private void doTransformNorm(FloatBuffer inBuf, int offset, int start, int end, FloatBuffer outBuf, Matrix4f transform) {
+    private void doTransformsTangents(FloatBuffer bindBufPos, FloatBuffer bindBufNorm, FloatBuffer bindBufTangents,FloatBuffer bufPos, FloatBuffer bufNorm, FloatBuffer bufTangents, int start, int end, Matrix4f transform) {
         TempVars vars = TempVars.get();
         Vector3f pos = vars.vect1;
+        Vector3f norm = vars.vect2;
+        Vector3f tan = vars.vect3;
+
+        int length = (end - start) * 3;
+        int tanLength = (end - start) * 4;
 
         // offset is given in element units
         // convert to be in component units
-        offset *= 3;
-
-        for (int i = start; i < end; i++) {
-            int index = i * 3;
-            pos.x = inBuf.get(index);
-            pos.y = inBuf.get(index + 1);
-            pos.z = inBuf.get(index + 2);
-
-            transform.multNormal(pos, pos);
-            index += offset;
-            outBuf.put(index, pos.x);
-            outBuf.put(index + 1, pos.y);
-            outBuf.put(index + 2, pos.z);
+        int offset = start * 3;
+        int tanOffset = start * 4;
+
+        
+        bindBufPos.rewind();
+        bindBufNorm.rewind();
+        bindBufTangents.rewind();
+        bindBufPos.get(tmpFloat, 0, length);
+        bindBufNorm.get(tmpFloatN, 0, length);
+        bindBufTangents.get(tmpFloatT, 0, tanLength);
+
+        int index = 0;
+        int tanIndex = 0;
+        while (index < length) {
+            pos.x = tmpFloat[index];
+            norm.x = tmpFloatN[index++];
+            pos.y = tmpFloat[index];
+            norm.y = tmpFloatN[index++];
+            pos.z = tmpFloat[index];
+            norm.z = tmpFloatN[index];
+
+            tan.x = tmpFloatT[tanIndex++];
+            tan.y = tmpFloatT[tanIndex++];
+            tan.z = tmpFloatT[tanIndex++];
+
+            transform.mult(pos, pos);
+            transform.multNormal(norm, norm);
+            transform.multNormal(tan, tan);
+
+            index -= 2;
+            tanIndex -= 3;
+
+            tmpFloat[index] = pos.x;
+            tmpFloatN[index++] = norm.x;
+            tmpFloat[index] = pos.y;
+            tmpFloatN[index++] = norm.y;
+            tmpFloat[index] = pos.z;
+            tmpFloatN[index++] = norm.z;
+
+            tmpFloatT[tanIndex++] = tan.x;
+            tmpFloatT[tanIndex++] = tan.y;
+            tmpFloatT[tanIndex++] = tan.z;
+
+            //Skipping 4th element of tangent buffer (handedness)
+            tanIndex++;
+
         }
         vars.release();
+        bufPos.position(offset);
+        //using bulk put as it's faster
+        bufPos.put(tmpFloat, 0, length);
+        bufNorm.position(offset);
+        //using bulk put as it's faster
+        bufNorm.put(tmpFloatN, 0, length);
+        bufTangents.position(tanOffset);
+        //using bulk put as it's faster
+        bufTangents.put(tmpFloatT, 0, tanLength);
     }
 
-    private void doCopyBuffer(FloatBuffer inBuf, int offset, FloatBuffer outBuf) {
+    private void doCopyBuffer(FloatBuffer inBuf, int offset, FloatBuffer outBuf, int componentSize) {
         TempVars vars = TempVars.get();
         Vector3f pos = vars.vect1;
 
         // offset is given in element units
         // convert to be in component units
-        offset *= 3;
+        offset *= componentSize;
 
-        for (int i = 0; i < inBuf.capacity() / 3; i++) {
-            pos.x = inBuf.get(i * 3 + 0);
-            pos.y = inBuf.get(i * 3 + 1);
-            pos.z = inBuf.get(i * 3 + 2);
+        for (int i = 0; i < inBuf.limit() / componentSize; i++) {
+            pos.x = inBuf.get(i * componentSize + 0);
+            pos.y = inBuf.get(i * componentSize + 1);
+            pos.z = inBuf.get(i * componentSize + 2);
 
-            outBuf.put(offset + i * 3 + 0, pos.x);
-            outBuf.put(offset + i * 3 + 1, pos.y);
-            outBuf.put(offset + i * 3 + 2, pos.z);
+            outBuf.put(offset + i * componentSize + 0, pos.x);
+            outBuf.put(offset + i * componentSize + 1, pos.y);
+            outBuf.put(offset + i * componentSize + 2, pos.z);
         }
         vars.release();
     }
 
     protected class Batch {
 
+        /**
+         * update the batchesByGeom map for this batch with the given List of geometries
+         * @param list 
+         */
+        void updateGeomList(List<Geometry> list) {
+            for (Geometry geom : list) {
+                if (!isBatch(geom)) {
+                    batchesByGeom.put(geom, this);
+                }
+            }
+        }
         Geometry geometry;
         boolean needMeshUpdate = false;
     }
+
+    protected void setNeedsFullRebatch(boolean needsFullRebatch) {
+        this.needsFullRebatch = needsFullRebatch;
+    }
+
+    public int getOffsetIndex(Geometry batchedGeometry) {
+        return batchedGeometry.startIndex;
+    }
 }

--- a/engine/src/core/com/jme3/scene/Geometry.java
+++ b/engine/src/core/com/jme3/scene/Geometry.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009-2010 jMonkeyEngine
+ * Copyright (c) 2009-2012 jMonkeyEngine
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,9 +35,9 @@ import com.jme3.asset.AssetNotFoundException;
 import com.jme3.bounding.BoundingVolume;
 import com.jme3.collision.Collidable;
 import com.jme3.collision.CollisionResults;
+import com.jme3.export.InputCapsule;
 import com.jme3.export.JmeExporter;
 import com.jme3.export.JmeImporter;
-import com.jme3.export.InputCapsule;
 import com.jme3.export.OutputCapsule;
 import com.jme3.material.Material;
 import com.jme3.math.Matrix4f;
@@ -59,6 +59,9 @@ import java.util.logging.Logger;
  */
 public class Geometry extends Spatial {
 
+    // Version #1: removed shared meshes. 
+    // models loaded with shared mesh will be automatically fixed.
+    public static final int SAVABLE_VERSION = 1;
     private static final Logger logger = Logger.getLogger(Geometry.class.getName());
     protected Mesh mesh;
     protected transient int lodLevel = 0;
@@ -75,16 +78,7 @@ public class Geometry extends Spatial {
     /**
      * the start index of this geom's mesh in the batchNode mesh
      */
-    protected int startIndex;
-    /**
-     * the previous transforms of the geometry used to compute world transforms
-     */
-    protected Transform prevBatchTransforms = null;
-    /**
-     * the cached offset matrix used when the geometry is batched
-     */
-    protected Matrix4f cachedOffsetMat = null;
-
+    protected int startIndex;    
     /**
      * Serialization only. Do not use.
      */
@@ -288,11 +282,8 @@ public class Geometry extends Spatial {
         super.updateWorldTransforms();
         computeWorldMatrix();
 
-        if (isBatched()) {
-            computeOffsetTransform();
-            batchNode.updateSubBatch(this);
-            prevBatchTransforms.set(batchNode.getTransforms(this));
-
+        if (isBatched()) {        
+            batchNode.updateSubBatch(this);     
         }
         // geometry requires lights to be sorted
         worldLights.sort(true);
@@ -305,9 +296,7 @@ public class Geometry extends Spatial {
      */
     protected void batch(BatchNode node, int startIndex) {
         this.batchNode = node;
-        this.startIndex = startIndex;
-        prevBatchTransforms = new Transform();
-        cachedOffsetMat = new Matrix4f();
+        this.startIndex = startIndex;       
         setCullHint(CullHint.Always);
     }
 
@@ -316,65 +305,40 @@ public class Geometry extends Spatial {
      */
     protected void unBatch() {
         this.startIndex = 0;
-        prevBatchTransforms = null;
-        cachedOffsetMat = null;
-        //once the geometry is removed from the screnegraph we call batch on the batchNode before unreferencing it.
-        this.batchNode.batch();
-        this.batchNode = null;
+        //once the geometry is removed from the screnegraph the batchNode needs to be rebatched.
+        if (batchNode != null) {
+            this.batchNode.setNeedsFullRebatch(true);
+            this.batchNode = null;
+        }
         setCullHint(CullHint.Dynamic);
     }
 
     @Override
     public boolean removeFromParent() {
-        boolean removed = super.removeFromParent();
+        return super.removeFromParent();
+    }
+
+    @Override
+    protected void setParent(Node parent) {
+        super.setParent(parent);
         //if the geometry is batched we also have to unbatch it
-        if (isBatched()) {
+        if (parent == null && isBatched()) {
             unBatch();
         }
-        return removed;
     }
 
-    /**
-     * Recomputes the cached offset matrix used when the geometry is batched     * 
-     */
-    public void computeOffsetTransform() {
-        TempVars vars = TempVars.get();
-        Matrix4f tmpMat = vars.tempMat42;
-
-        // Compute the cached world matrix
-        cachedOffsetMat.loadIdentity();
-        cachedOffsetMat.setRotationQuaternion(prevBatchTransforms.getRotation());
-        cachedOffsetMat.setTranslation(prevBatchTransforms.getTranslation());
-
-
-        Matrix4f scaleMat = vars.tempMat4;
-        scaleMat.loadIdentity();
-        scaleMat.scale(prevBatchTransforms.getScale());
-        cachedOffsetMat.multLocal(scaleMat);
-        cachedOffsetMat.invertLocal();
-
-        tmpMat.loadIdentity();
-        tmpMat.setRotationQuaternion(batchNode.getTransforms(this).getRotation());
-        tmpMat.setTranslation(batchNode.getTransforms(this).getTranslation());
-        scaleMat.loadIdentity();
-        scaleMat.scale(batchNode.getTransforms(this).getScale());
-        tmpMat.multLocal(scaleMat);
-
-        tmpMat.mult(cachedOffsetMat, cachedOffsetMat);
-
-        vars.release();
-    }
 
     /**
      * Indicate that the transform of this spatial has changed and that
      * a refresh is required.
      */
-    @Override
-    protected void setTransformRefresh() {
-        refreshFlags |= RF_TRANSFORM;
-        setBoundRefresh();
-    }
-
+    // NOTE: Spatial has an identical implementation of this method,
+    // thus it was commented out.
+//    @Override
+//    protected void setTransformRefresh() {
+//        refreshFlags |= RF_TRANSFORM;
+//        setBoundRefresh();
+//    }
     /**
      * Recomputes the matrix returned by {@link Geometry#getWorldMatrix() }.
      * This will require a localized transform update for this geometry.
@@ -474,6 +438,11 @@ public class Geometry extends Spatial {
     @Override
     public Geometry clone(boolean cloneMaterial) {
         Geometry geomClone = (Geometry) super.clone(cloneMaterial);
+        //this geometry is batched but the clonned one should not be
+        if (isBatched()) {
+            geomClone.batchNode = null;
+            geomClone.unBatch();
+        }
         geomClone.cachedWorldMat = cachedWorldMat.clone();
         if (material != null) {
             if (cloneMaterial) {
@@ -541,8 +510,7 @@ public class Geometry extends Spatial {
                 material = im.getAssetManager().loadMaterial(matName);
             } catch (AssetNotFoundException ex) {
                 // Cannot find J3M file.
-                logger.log(Level.FINE, "Could not load J3M file {0} for Geometry.",
-                        matName);
+                logger.log(Level.FINE, "Cannot locate {0} for geometry {1}", new Object[]{matName, key});
             }
         }
         // If material is NULL, try to load it from the geometry
@@ -550,5 +518,13 @@ public class Geometry extends Spatial {
             material = (Material) ic.readSavable("material", null);
         }
         ignoreTransform = ic.readBoolean("ignoreTransform", false);
+
+        if (ic.getSavableVersion(Geometry.class) == 0) {
+            // Fix shared mesh (if set)
+            Mesh sharedMesh = getUserData(UserData.JME_SHAREDMESH);
+            if (sharedMesh != null) {
+                getMesh().extractVertexData(sharedMesh);
+            }
+        }
     }
 }

--- a/engine/src/core/com/jme3/scene/SimpleBatchNode.java
+++ b/engine/src/core/com/jme3/scene/SimpleBatchNode.java
@@ -1,10 +1,39 @@
 /*
- * To change this template, choose Tools | Templates
- * and open the template in the editor.
+ * Copyright (c) 2009-2012 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.scene;
 
+import com.jme3.math.Matrix4f;
 import com.jme3.math.Transform;
+import com.jme3.util.TempVars;
 
 /**
  * 
@@ -37,17 +66,30 @@ public class SimpleBatchNode extends BatchNode {
 
     @Override
     protected void setTransformRefresh() {
-
         refreshFlags |= RF_TRANSFORM;
         setBoundRefresh();
-        for (Batch batch : batches.values()) {
+        for (Batch batch : batches.getArray()) {
             batch.geometry.setTransformRefresh();
         }
     }
-    
-     protected Transform getTransforms(Geometry geom){
-        return geom.getLocalTransform();
+    private Matrix4f cachedLocalMat = new Matrix4f();
+
+    @Override
+    protected Matrix4f getTransformMatrix(Geometry g){
+        // Compute the Local matrix for the geometry
+        cachedLocalMat.loadIdentity();
+        cachedLocalMat.setRotationQuaternion(g.localTransform.getRotation());
+        cachedLocalMat.setTranslation(g.localTransform.getTranslation());
+
+        TempVars vars = TempVars.get();
+        Matrix4f scaleMat = vars.tempMat4;
+        scaleMat.loadIdentity();
+        scaleMat.scale(g.localTransform.getScale());
+        cachedLocalMat.multLocal(scaleMat);
+        vars.release();
+        return cachedLocalMat;
     }
+    
 
     @Override
     public void batch() {

--- a/engine/src/core/com/jme3/scene/Spatial.java
+++ b/engine/src/core/com/jme3/scene/Spatial.java
@@ -33,6 +33,7 @@ package com.jme3.scene;
 
 import com.jme3.asset.Asset;
 import com.jme3.asset.AssetKey;
+import com.jme3.asset.CloneableSmartAsset;
 import com.jme3.bounding.BoundingVolume;
 import com.jme3.collision.Collidable;
 import com.jme3.export.*;
@@ -50,12 +51,7 @@ import com.jme3.scene.control.Control;
 import com.jme3.util.SafeArrayList;
 import com.jme3.util.TempVars;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.Queue;
+import java.util.*;
 import java.util.logging.Logger;
 
 /**
@@ -68,7 +64,7 @@ import java.util.logging.Logger;
  * @author Joshua Slack
  * @version $Revision: 4075 $, $Data$
  */
-public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
+public abstract class Spatial implements Savable, Cloneable, Collidable, CloneableSmartAsset, Asset {
 
     private static final Logger logger = Logger.getLogger(Spatial.class.getName());
 
@@ -99,31 +95,47 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
          */
         Never;
     }
+
+    /**
+     * Specifies if this spatial should be batched
+     */
+    public enum BatchHint {
+
+        /** 
+         * Do whatever our parent does. If no parent, default to {@link #Always}.
+         */
+        Inherit,
+        /** 
+         * This spatial will always be batched when attached to a BatchNode.
+         */
+        Always,
+        /** 
+         * This spatial will never be batched when attached to a BatchNode.
+         */
+        Never;
+    }
     /**
      * Refresh flag types
      */
     protected static final int RF_TRANSFORM = 0x01, // need light resort + combine transforms
-            RF_BOUND = 0x02,
-            RF_LIGHTLIST = 0x04; // changes in light lists          
+                               RF_BOUND = 0x02,
+                               RF_LIGHTLIST = 0x04; // changes in light lists 
     
     protected CullHint cullHint = CullHint.Inherit;
-    
+    protected BatchHint batchHint = BatchHint.Inherit;
     /** 
      * Spatial's bounding volume relative to the world.
      */
     protected BoundingVolume worldBound;
-    
     /**
      * LightList
      */
     protected LightList localLights;
     protected transient LightList worldLights;
-    
     /** 
      * This spatial's name.
      */
     protected String name;
-    
     // scale values
     protected transient Camera.FrustumIntersect frustrumIntersects = Camera.FrustumIntersect.Intersects;
     protected RenderQueue.Bucket queueBucket = RenderQueue.Bucket.Inherit;
@@ -133,14 +145,12 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
     protected Transform worldTransform;
     protected SafeArrayList<Control> controls = new SafeArrayList<Control>(Control.class);
     protected HashMap<String, Savable> userData = null;
-    
     /**
      * Used for smart asset caching
      * 
      * @see AssetKey#useSmartCache() 
      */
-    protected AssetKey key; 
-    
+    protected AssetKey key;
     /** 
      * Spatial's parent, or null if it has none.
      */
@@ -177,14 +187,14 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
         this.name = name;
     }
 
-    public void setKey(AssetKey key){
+    public void setKey(AssetKey key) {
         this.key = key;
     }
-    
-    public AssetKey getKey(){
+
+    public AssetKey getKey() {
         return key;
     }
-    
+
     /**
      * Indicate that the transform of this spatial has changed and that
      * a refresh is required.
@@ -205,7 +215,6 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
     protected void setBoundRefresh() {
         refreshFlags |= RF_BOUND;
 
-        // XXX: Replace with a recursive call?
         Spatial p = parent;
         while (p != null) {
             if ((p.refreshFlags & RF_BOUND) != 0) {
@@ -216,7 +225,7 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
             p = p.parent;
         }
     }
-
+    
     /**
      * (Internal use only) Forces a refresh of the given types of data.
      * 
@@ -401,11 +410,16 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
 
     /**
      * <code>lookAt</code> is a convenience method for auto-setting the local
-     * rotation based on a position and an up vector. It computes the rotation
+     * rotation based on a position in world space and an up vector. It computes the rotation
      * to transform the z-axis to point onto 'position' and the y-axis to 'up'.
      * Unlike {@link Quaternion#lookAt(com.jme3.math.Vector3f, com.jme3.math.Vector3f) } 
      * this method takes a world position to look at and not a relative direction.
      *
+     * Note : 28/01/2013 this method has been fixed as it was not taking into account the parent rotation.
+     * This was resulting in improper rotation when the spatial had rotated parent nodes.
+     * This method is intended to work in world space, so no matter what parent graph the 
+     * spatial has, it will look at the given position in world space.
+     * 
      * @param position
      *            where to look at in terms of world coordinates
      * @param upVector
@@ -418,11 +432,17 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
         TempVars vars = TempVars.get();
 
         Vector3f compVecA = vars.vect4;
-        vars.release();
-
+      
         compVecA.set(position).subtractLocal(worldTranslation);
-        getLocalRotation().lookAt(compVecA, upVector);
-
+        getLocalRotation().lookAt(compVecA, upVector);        
+        
+        if ( getParent() != null ) {
+            Quaternion rot=vars.quat1;
+            rot =  rot.set(parent.getWorldRotation()).inverseLocal().multLocal(getLocalRotation());
+            rot.normalizeLocal();
+            setLocalRotation(rot);
+        }
+        vars.release();
         setTransformRefresh();
     }
 
@@ -567,7 +587,7 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
             return;
         }
 
-        for (Control c : controls.getArray() ) {
+        for (Control c : controls.getArray()) {
             c.render(rm, vp);
         }
     }
@@ -627,7 +647,7 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
     public <T extends Control> T getControl(Class<T> controlType) {
         for (Control c : controls.getArray()) {
             if (controlType.isAssignableFrom(c.getClass())) {
-                return (T)c;
+                return (T) c;
             }
         }
         return null;
@@ -994,15 +1014,15 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
     }
 
     /**
-     * Rotates the spatial by the yaw, roll and pitch angles (in radians),
-     * in the local coordinate space.
+     * Rotates the spatial by the xAngle, yAngle and zAngle angles (in radians),
+     * (aka pitch, yaw, roll) in the local coordinate space.
      *
      * @return The spatial on which this method is called, e.g <code>this</code>.
      */
-    public Spatial rotate(float yaw, float roll, float pitch) {
+    public Spatial rotate(float xAngle, float yAngle, float zAngle) {
         TempVars vars = TempVars.get();
         Quaternion q = vars.quat1;
-        q.fromAngles(yaw, roll, pitch);
+        q.fromAngles(xAngle, yAngle, zAngle);
         rotate(q);
         vars.release();
 
@@ -1038,6 +1058,16 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
         }
     }
 
+    public BatchHint getBatchHint() {
+        if (batchHint != BatchHint.Inherit) {
+            return batchHint;
+        } else if (parent != null) {
+            return parent.getBatchHint();
+        } else {
+            return BatchHint.Always;
+        }
+    }
+
     /**
      * Returns this spatial's renderqueue bucket. If the mode is set to inherit,
      * then the spatial gets its renderqueue bucket from its parent.
@@ -1153,7 +1183,9 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
 
             clone.controls = new SafeArrayList<Control>(Control.class);
             for (int i = 0; i < controls.size(); i++) {
-                clone.controls.add(controls.get(i).cloneForSpatial(clone));
+                Control newControl = controls.get(i).cloneForSpatial(clone);
+                newControl.setSpatial(clone);
+                clone.controls.add(newControl);
             }
 
             if (userData != null) {
@@ -1197,7 +1229,9 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
             userData = new HashMap<String, Savable>();
         }
 
-        if (data instanceof Savable) {
+        if(data == null){
+            userData.remove(key);            
+        }else if (data instanceof Savable) {
             userData.put(key, (Savable) data);
         } else {
             userData.put(key, new UserData(UserData.getObjectType(data), data));
@@ -1260,13 +1294,14 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
         capsule.write(name, "name", null);
         capsule.write(worldBound, "world_bound", null);
         capsule.write(cullHint, "cull_mode", CullHint.Inherit);
+        capsule.write(batchHint, "batch_hint", BatchHint.Inherit);
         capsule.write(queueBucket, "queue", RenderQueue.Bucket.Inherit);
         capsule.write(shadowMode, "shadow_mode", ShadowMode.Inherit);
         capsule.write(localTransform, "transform", Transform.IDENTITY);
         capsule.write(localLights, "lights", null);
-        
+
         // Shallow clone the controls array to convert its type.
-        capsule.writeSavableArrayList( new ArrayList(controls), "controlsList", null);
+        capsule.writeSavableArrayList(new ArrayList(controls), "controlsList", null);
         capsule.writeStringSavableMap(userData, "user_data", null);
     }
 
@@ -1276,6 +1311,7 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
         name = ic.readString("name", null);
         worldBound = (BoundingVolume) ic.readSavable("world_bound", null);
         cullHint = ic.readEnum("cull_mode", CullHint.class, CullHint.Inherit);
+        batchHint = ic.readEnum("batch_hint", BatchHint.class, BatchHint.Inherit);
         queueBucket = ic.readEnum("queue", RenderQueue.Bucket.class,
                 RenderQueue.Bucket.Inherit);
         shadowMode = ic.readEnum("shadow_mode", ShadowMode.class,
@@ -1321,6 +1357,18 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
     }
 
     /**
+     * <code>setBatchHint</code> sets how batching should work on this
+     * spatial. NOTE: You must set this AFTER attaching to a 
+     * parent or it will be reset with the parent's cullMode value.
+     *
+     * @param hint
+     *            one of BatchHint.Never, BatchHint.Always, BatchHint.Inherit 
+     */
+    public void setBatchHint(BatchHint hint) {
+        batchHint = hint;
+    }
+
+    /**
      * @return the cullmode set on this Spatial
      */
     public CullHint getLocalCullHint() {
@@ -1328,6 +1376,13 @@ public abstract class Spatial implements Savable, Cloneable, Collidable, Asset {
     }
 
     /**
+     * @return the batchHint set on this Spatial
+     */
+    public BatchHint getLocalBatchHint() {
+        return batchHint;
+    }
+
+    /**
      * <code>setQueueBucket</code> determines at what phase of the
      * rendering process this Spatial will rendered. See the
      * {@link Bucket} enum for an explanation of the various 

--- a/engine/src/core/com/jme3/scene/VertexBuffer.java
+++ b/engine/src/core/com/jme3/scene/VertexBuffer.java
@@ -743,6 +743,22 @@ public class VertexBuffer extends NativeObject implements Savable, Cloneable {
      * match.
      */
     public void copyElement(int inIndex, VertexBuffer outVb, int outIndex){
+        copyElements(inIndex, outVb, outIndex, 1);
+    }
+
+    /**
+     * Copies a sequence of elements of data from this <code>VertexBuffer</code>
+     * to the given output VertexBuffer.
+     * 
+     * @param inIndex The input element index
+     * @param outVb The buffer to copy to
+     * @param outIndex The output element index
+     * @param len The number of elements to copy
+     * 
+     * @throws IllegalArgumentException If the formats of the buffers do not
+     * match.
+     */
+    public void copyElements(int inIndex, VertexBuffer outVb, int outIndex, int len){
         if (outVb.format != format || outVb.components != components)
             throw new IllegalArgumentException("Buffer format mismatch. Cannot copy");