* Added InstancedNode: easy to use instancing with similar API to BatchNode. The underlying scene graph will be automatically optimized so instancing is used as much as possible, thus reducing number of draw calls and improving performance. Unlike BatchNode, it does not copy the geometry's mesh around, but only its transform. In order for it to work, it requires the Renderer to support the GeometryInstancing capability.

* Replaced existing instancing test with TestInstanceNode, which demostrates how to use the new InstancedNode by changing the transform, mesh, and material of every instance periodically.
 * The lower-level InstancedGeometry API rewritten: Users don't need to manage the number of instances they have and their indices. Instead, they can use addInstance() and removeInstance() to add and remove instances as desired. Unlike InstancedNode, InstancedGeometry requires all Geometries to have the same mesh and material, but they can have different transforms.
 * Instancing.glsllib now requires the InstanceData to have world transforms instead of world view transforms. As a consequence, users of instancing must specify in the material the world parameters ViewProjectionMatrix and ViewMatrix instead of ProjectionMatrix.
experimental
shadowislord 11 years ago
parent 52b93ba933
commit eee43b470e
  1. 6
      jme3-core/src/main/java/com/jme3/material/Material.java
  2. 501
      jme3-core/src/main/java/com/jme3/scene/instancing/InstancedGeometry.java
  3. 259
      jme3-core/src/main/java/com/jme3/scene/instancing/InstancedNode.java
  4. 2
      jme3-core/src/main/resources/Common/MatDefs/Misc/ShowNormals.j3md
  5. 3
      jme3-core/src/main/resources/Common/MatDefs/Misc/Unshaded.j3md
  6. 18
      jme3-core/src/main/resources/Common/ShaderLib/Instancing.glsllib
  7. 186
      jme3-examples/src/main/java/jme3test/scene/instancing/TestInstanceNode.java
  8. 146
      jme3-examples/src/main/java/jme3test/scene/instancing/TestInstancing.java

@ -702,7 +702,11 @@ public class Material implements CloneableSmartAsset, Cloneable, Savable {
int lodLevel = geom.getLodLevel(); int lodLevel = geom.getLodLevel();
if (geom instanceof InstancedGeometry) { if (geom instanceof InstancedGeometry) {
InstancedGeometry instGeom = (InstancedGeometry) geom; InstancedGeometry instGeom = (InstancedGeometry) geom;
renderer.renderMesh(mesh, lodLevel, instGeom.getCurrentNumInstances(), instGeom.getAllInstanceData()); int numInstances = instGeom.getActualNumInstances();
if (numInstances == 0) {
return;
}
renderer.renderMesh(mesh, lodLevel, numInstances, instGeom.getAllInstanceData());
} else { } else {
renderer.renderMesh(mesh, lodLevel, 1, null); renderer.renderMesh(mesh, lodLevel, 1, null);
} }

@ -39,136 +39,28 @@ import com.jme3.export.Savable;
import com.jme3.math.Matrix3f; import com.jme3.math.Matrix3f;
import com.jme3.math.Matrix4f; import com.jme3.math.Matrix4f;
import com.jme3.math.Quaternion; import com.jme3.math.Quaternion;
import com.jme3.math.Transform;
import com.jme3.renderer.Camera;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.Geometry; import com.jme3.scene.Geometry;
import com.jme3.scene.Mesh;
import com.jme3.scene.Spatial; import com.jme3.scene.Spatial;
import com.jme3.scene.VertexBuffer; import com.jme3.scene.VertexBuffer;
import com.jme3.scene.VertexBuffer.Format; import com.jme3.scene.VertexBuffer.Format;
import com.jme3.scene.VertexBuffer.Type; import com.jme3.scene.VertexBuffer.Type;
import com.jme3.scene.VertexBuffer.Usage; import com.jme3.scene.VertexBuffer.Usage;
import com.jme3.scene.control.AbstractControl;
import com.jme3.util.BufferUtils; import com.jme3.util.BufferUtils;
import com.jme3.util.TempVars;
import java.io.IOException; import java.io.IOException;
import java.nio.FloatBuffer; import java.nio.FloatBuffer;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* <code>InstancedGeometry</code> allows rendering many similar
* geometries efficiently through a feature called geometry
* instancing.
*
* <p>
* All rendered geometries share material, mesh, and lod level
* but have different world transforms or possibly other parameters.
* The settings for all instances are inherited from this geometry's
* {@link #setMesh(com.jme3.scene.Mesh) mesh},
* {@link #setMaterial(com.jme3.material.Material) material} and
* {@link #setLodLevel(int) lod level} and cannot be changed per-instance.
* </p>
*
* <p>
* In order to receive any per-instance parameters, the material's shader
* must be changed to retrieve per-instance data via
* {@link VertexBuffer#setInstanced(boolean) instanced vertex attributes}
* or uniform arrays indexed with the GLSL built-in uniform
* <code>gl_InstanceID</code>. At the very least, they should use the
* functions specified in <code>Instancing.glsllib</code> shader library
* to transform vertex positions and normals instead of multiplying by the
* built-in matrix uniforms.
* </p>
*
* <p>
* This class can operate in two modes, {@link InstancedGeometry.Mode#Auto}
* and {@link InstancedGeometry.Mode#Manual}. See the respective enums
* for more information</p>
*
* <p>
* Prior to usage, the maximum number of instances must be set via
* {@link #setMaxNumInstances(int) } and the current number of instances set
* via {@link #setCurrentNumInstances(int) }. The user is then
* expected to provide transforms for all instances up to the number
* of current instances.
* </p>
*
* @author Kirill Vainer
*/
public class InstancedGeometry extends Geometry {
/**
* Indicates how the per-instance data is to be specified.
*/
public static enum Mode {
/**
* The user must specify all per-instance transforms and
* parameters manually via
* {@link InstancedGeometry#setGlobalUserInstanceData(com.jme3.scene.VertexBuffer[]) }
* or
* {@link InstancedGeometry#setCameraUserInstanceData(com.jme3.renderer.Camera, com.jme3.scene.VertexBuffer) }.
*/
Manual,
/**
* The user
* {@link InstancedGeometry#setInstanceTransform(int, com.jme3.math.Transform) provides world transforms}
* and then uses the <code>Instancing.glsllib</code> transform functions in the
* shader to transform vertex attributes to the respective spaces.
* Additional per-instance data can be specified via
* {@link InstancedGeometry#setManualGlobalInstanceData(com.jme3.scene.VertexBuffer[]) }.
* {@link #setManualCameraInstanceData(com.jme3.renderer.Camera, com.jme3.scene.VertexBuffer) }
* cannot be used at this mode since it is computed automatically.
*/
Auto
}
private static class InstancedGeometryControl extends AbstractControl {
private InstancedGeometry geom;
public InstancedGeometryControl() {
}
public InstancedGeometryControl(InstancedGeometry geom) {
this.geom = geom;
}
@Override public class InstancedGeometry extends Geometry {
protected void controlUpdate(float tpf) {
}
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
geom.renderFromControl(vp.getCamera());
}
}
private static final int INSTANCE_SIZE = 16; private static final int INSTANCE_SIZE = 16;
private InstancedGeometry.Mode mode;
private InstancedGeometryControl control;
private int currentNumInstances = 1;
private Camera lastCamera = null;
private Matrix4f[] worldMatrices = new Matrix4f[1];
private VertexBuffer[] globalInstanceData; private VertexBuffer[] globalInstanceData;
private VertexBuffer transformInstanceData;
private Geometry[] geometries = new Geometry[1];
private final HashMap<Camera, VertexBuffer> instanceDataPerCam private int firstUnusedIndex = 0;
= new HashMap<Camera, VertexBuffer>();
// TODO: determine if perhaps its better to use TempVars here.
private final Matrix4f tempMat4 = new Matrix4f();
private final Matrix4f tempMat4_2 = new Matrix4f();
private final Matrix3f tempMat3 = new Matrix3f();
private final Quaternion tempQuat = new Quaternion();
private final float[] tempFloatArray = new float[16];
/** /**
* Serialization only. Do not use. * Serialization only. Do not use.
@ -176,35 +68,20 @@ public class InstancedGeometry extends Geometry {
public InstancedGeometry() { public InstancedGeometry() {
super(); super();
setIgnoreTransform(true); setIgnoreTransform(true);
setMaxNumInstances(1);
} }
/** /**
* Creates instanced geometry with the specified mode and name. * Creates instanced geometry with the specified mode and name.
* *
* @param mode The {@link Mode} at which the instanced geometry operates at.
* @param name The name of the spatial. * @param name The name of the spatial.
* *
* @see Mode
* @see Spatial#Spatial(java.lang.String) * @see Spatial#Spatial(java.lang.String)
*/ */
public InstancedGeometry(InstancedGeometry.Mode mode, String name) { public InstancedGeometry(String name) {
super(name); super(name);
this.mode = mode;
setIgnoreTransform(true); setIgnoreTransform(true);
if (mode == InstancedGeometry.Mode.Auto) { setMaxNumInstances(1);
control = new InstancedGeometryControl(this);
addControl(control);
}
}
/**
* The mode with which this instanced geometry was initialized
* with. Cannot be changed after initialization.
*
* @return instanced geometry mode.
*/
public InstancedGeometry.Mode getMode() {
return mode;
} }
/** /**
@ -238,85 +115,27 @@ public class InstancedGeometry extends Geometry {
/** /**
* Specify camera specific user per-instance data. * Specify camera specific user per-instance data.
* *
* Only applies when operating in {@link Mode#Manual}. * @param transformInstanceData The transforms for each instance.
* When operating in {@link Mode#Auto}, this data is computed automatically,
* and using this method is not allowed.
*
* @param camera The camera for which per-instance data is to be set.
* @param cameraInstanceData The camera's per-instance data.
*
* @throws IllegalArgumentException If camera is null.
* @throws IllegalStateException If {@link #getMode() mode} is set to
* {@link Mode#Auto}.
*
* @see Mode
* @see #getCameraUserInstanceData(com.jme3.renderer.Camera)
*/
public void setCameraUserInstanceData(Camera camera, VertexBuffer cameraInstanceData) {
if (mode == Mode.Auto) {
throw new IllegalStateException("Not allowed in auto mode");
}
if (camera == null) {
throw new IllegalArgumentException("camera cannot be null");
}
instanceDataPerCam.put(camera, cameraInstanceData);
}
/**
* Return camera specific user per-instance data.
*
* Only applies when operating in {@link Mode#Manual}.
* When operating in {@link Mode#Auto}, this data is computed automatically,
* and using this method is not allowed.
*
* @param camera The camera to look up the per-instance data for.
* @return The per-instance data, or <code>null</code> if none was specified
* for the given camera.
*
* @throws IllegalArgumentException If camera is null.
* @throws IllegalStateException If {@link #getMode() mode} is set to
* {@link Mode#Auto}.
*
* @see Mode
* @see #setCameraUserInstanceData(com.jme3.renderer.Camera, com.jme3.scene.VertexBuffer)
*/ */
public VertexBuffer getCameraUserInstanceData(Camera camera) { public void setTransformUserInstanceData(VertexBuffer transformInstanceData) {
if (mode == Mode.Auto) { this.transformInstanceData = transformInstanceData;
throw new IllegalStateException("Not allowed in auto mode");
}
if (camera == null) {
throw new IllegalArgumentException("camera cannot be null");
}
return instanceDataPerCam.get(camera);
} }
/** /**
* Return a read only map with the mappings between cameras and camera * Return user per-instance transform data.
* specific per-instance data.
* *
* Only applies when operating in {@link Mode#Manual}. * @return The per-instance transform data.
* When operating in {@link Mode#Auto}, this data is computed automatically,
* and using this method is not allowed.
* *
* @return read only map with the mappings between cameras and camera * @see #setTransformUserInstanceData(com.jme3.scene.VertexBuffer)
* specific per-instance data.
*
* @throws IllegalStateException If {@link #getMode() mode} is set to
* {@link Mode#Auto}.
*
* @see Mode
* @see #setCameraUserInstanceData(com.jme3.renderer.Camera, com.jme3.scene.VertexBuffer)
*/ */
public Map<Camera, VertexBuffer> getAllCameraUserInstanceData() { public VertexBuffer getTransformUserInstanceData() {
if (mode == Mode.Auto) { return transformInstanceData;
throw new IllegalStateException("Not allowed in auto mode");
}
return Collections.unmodifiableMap(instanceDataPerCam);
} }
private void updateInstance(Matrix4f viewMatrix, Matrix4f worldMatrix, float[] store, int offset) { private void updateInstance(Matrix4f worldMatrix, float[] store,
viewMatrix.mult(worldMatrix, tempMat4); int offset, Matrix3f tempMat3,
tempMat4.toRotationMatrix(tempMat3); Quaternion tempQuat) {
worldMatrix.toRotationMatrix(tempMat3);
tempMat3.invertLocal(); tempMat3.invertLocal();
// NOTE: No need to take the transpose in order to encode // NOTE: No need to take the transpose in order to encode
@ -326,82 +145,24 @@ public class InstancedGeometry extends Geometry {
// Column-major encoding. The "W" field in each of the encoded // Column-major encoding. The "W" field in each of the encoded
// vectors represents the quaternion. // vectors represents the quaternion.
store[offset + 0] = tempMat4.m00; store[offset + 0] = worldMatrix.m00;
store[offset + 1] = tempMat4.m10; store[offset + 1] = worldMatrix.m10;
store[offset + 2] = tempMat4.m20; store[offset + 2] = worldMatrix.m20;
store[offset + 3] = tempQuat.getX(); store[offset + 3] = tempQuat.getX();
store[offset + 4] = tempMat4.m01; store[offset + 4] = worldMatrix.m01;
store[offset + 5] = tempMat4.m11; store[offset + 5] = worldMatrix.m11;
store[offset + 6] = tempMat4.m21; store[offset + 6] = worldMatrix.m21;
store[offset + 7] = tempQuat.getY(); store[offset + 7] = tempQuat.getY();
store[offset + 8] = tempMat4.m02; store[offset + 8] = worldMatrix.m02;
store[offset + 9] = tempMat4.m12; store[offset + 9] = worldMatrix.m12;
store[offset + 10] = tempMat4.m22; store[offset + 10] = worldMatrix.m22;
store[offset + 11] = tempQuat.getZ(); store[offset + 11] = tempQuat.getZ();
store[offset + 12] = tempMat4.m03; store[offset + 12] = worldMatrix.m03;
store[offset + 13] = tempMat4.m13; store[offset + 13] = worldMatrix.m13;
store[offset + 14] = tempMat4.m23; store[offset + 14] = worldMatrix.m23;
store[offset + 15] = tempQuat.getW(); store[offset + 15] = tempQuat.getW();
} }
private void renderFromControl(Camera cam) {
if (mode != Mode.Auto) {
return;
}
// Get the instance data VBO for this camera.
VertexBuffer instanceDataVB = instanceDataPerCam.get(cam);
FloatBuffer instanceData;
if (instanceDataVB == null) {
// This is a new camera, create instance data VBO for it.
instanceData = BufferUtils.createFloatBuffer(worldMatrices.length * INSTANCE_SIZE);
instanceDataVB = new VertexBuffer(Type.InstanceData);
instanceDataVB.setInstanced(true);
instanceDataVB.setupData(Usage.Stream, INSTANCE_SIZE, Format.Float, instanceData);
instanceDataPerCam.put(cam, instanceDataVB);
} else {
// Retrieve the current instance data buffer.
instanceData = (FloatBuffer) instanceDataVB.getData();
}
Matrix4f viewMatrix = cam.getViewMatrix();
instanceData.limit(instanceData.capacity());
instanceData.position(0);
assert currentNumInstances <= worldMatrices.length;
for (int i = 0; i < currentNumInstances; i++) {
Matrix4f worldMatrix = worldMatrices[i];
if (worldMatrix == null) {
worldMatrix = Matrix4f.IDENTITY;
}
updateInstance(viewMatrix, worldMatrix, tempFloatArray, 0);
instanceData.put(tempFloatArray);
}
instanceData.flip();
this.lastCamera = cam;
instanceDataVB.updateData(instanceDataVB.getData());
}
/**
* Set the current number of instances to be rendered.
*
* @param currentNumInstances the current number of instances to be rendered.
*
* @throws IllegalArgumentException If current number of instances is
* greater than the maximum number of instances.
*/
public void setCurrentNumInstances(int currentNumInstances) {
if (currentNumInstances > worldMatrices.length) {
throw new IllegalArgumentException("currentNumInstances cannot be larger than maxNumInstances");
}
this.currentNumInstances = currentNumInstances;
}
/** /**
* Set the maximum amount of instances that can be rendered by this * Set the maximum amount of instances that can be rendered by this
* instanced geometry when mode is set to auto. * instanced geometry when mode is set to auto.
@ -415,88 +176,164 @@ public class InstancedGeometry extends Geometry {
* @throws IllegalStateException If mode is set to manual. * @throws IllegalStateException If mode is set to manual.
* @throws IllegalArgumentException If maxNumInstances is zero or negative * @throws IllegalArgumentException If maxNumInstances is zero or negative
*/ */
public void setMaxNumInstances(int maxNumInstances) { public final void setMaxNumInstances(int maxNumInstances) {
if (mode == Mode.Manual) {
throw new IllegalStateException("Not allowed in manual mode");
}
if (maxNumInstances < 1) { if (maxNumInstances < 1) {
throw new IllegalArgumentException("maxNumInstances must be 1 or higher"); throw new IllegalArgumentException("maxNumInstances must be 1 or higher");
} }
this.worldMatrices = new Matrix4f[maxNumInstances]; Geometry[] originalGeometries = geometries;
this.geometries = new Geometry[maxNumInstances];
if (currentNumInstances > maxNumInstances) { if (originalGeometries != null) {
currentNumInstances = maxNumInstances; System.arraycopy(originalGeometries, 0, geometries, 0, originalGeometries.length);
} }
// Resize instance data for each of the cameras. // Resize instance data.
for (VertexBuffer instanceDataVB : instanceDataPerCam.values()) { if (transformInstanceData != null) {
FloatBuffer instanceData = (FloatBuffer) instanceDataVB.getData(); BufferUtils.destroyDirectBuffer(transformInstanceData.getData());
if (instanceData.capacity() / INSTANCE_SIZE != worldMatrices.length) { transformInstanceData.updateData(BufferUtils.createFloatBuffer(geometries.length * INSTANCE_SIZE));
// Delete old data. } else if (transformInstanceData == null) {
BufferUtils.destroyDirectBuffer(instanceData); transformInstanceData = new VertexBuffer(Type.InstanceData);
transformInstanceData.setInstanced(true);
transformInstanceData.setupData(Usage.Stream,
INSTANCE_SIZE,
Format.Float,
BufferUtils.createFloatBuffer(geometries.length * INSTANCE_SIZE));
}
}
// Resize instance data for this camera. public int getMaxNumInstances() {
// Create new data with new length. return geometries.length;
instanceData = BufferUtils.createFloatBuffer(worldMatrices.length * INSTANCE_SIZE);
instanceDataVB.updateData(instanceData);
} }
public int getActualNumInstances() {
return firstUnusedIndex;
}
private void swap(int idx1, int idx2) {
Geometry g = geometries[idx1];
geometries[idx1] = geometries[idx2];
geometries[idx2] = g;
if (geometries[idx1] != null) {
InstancedNode.setGeometryStartIndex2(geometries[idx1], idx1);
}
if (geometries[idx2] != null) {
InstancedNode.setGeometryStartIndex2(geometries[idx2], idx2);
} }
} }
public int getMaxNumInstances() { private void sanitize(boolean insideEntriesNonNull) {
return worldMatrices.length; if (firstUnusedIndex >= geometries.length) {
throw new AssertionError();
}
for (int i = 0; i < geometries.length; i++) {
if (i < firstUnusedIndex) {
if (geometries[i] == null) {
if (insideEntriesNonNull) {
throw new AssertionError();
}
} else if (InstancedNode.getGeometryStartIndex2(geometries[i]) != i) {
throw new AssertionError();
}
} else {
if (geometries[i] != null) {
throw new AssertionError();
}
}
}
}
public void updateInstances() {
FloatBuffer fb = (FloatBuffer) transformInstanceData.getData();
fb.limit(fb.capacity());
fb.position(0);
TempVars vars = TempVars.get();
{
float[] temp = vars.matrixWrite;
for (int i = 0; i < firstUnusedIndex; i++) {
Geometry geom = geometries[i];
if (geom == null) {
geom = geometries[firstUnusedIndex - 1];
if (geom == null) {
throw new AssertionError();
}
swap(i, firstUnusedIndex - 1);
while (geometries[firstUnusedIndex -1] == null) {
firstUnusedIndex--;
}
} }
public int getCurrentNumInstances() { Matrix4f worldMatrix = geom.getWorldMatrix();
return currentNumInstances; updateInstance(worldMatrix, temp, 0, vars.tempMat3, vars.quat1);
fb.put(temp);
}
}
vars.release();
fb.flip();
if (fb.limit() / INSTANCE_SIZE != firstUnusedIndex) {
throw new AssertionError();
} }
public void setInstanceTransform(int instanceIndex, Matrix4f worldTransform) { transformInstanceData.updateData(fb);
if (mode == Mode.Manual) {
throw new IllegalStateException("Not allowed in manual mode");
} }
if (worldTransform == null) {
throw new IllegalArgumentException("worldTransform cannot be null"); public void deleteInstance(Geometry geom) {
int idx = InstancedNode.getGeometryStartIndex2(geom);
InstancedNode.setGeometryStartIndex2(geom, -1);
geometries[idx] = null;
if (idx == firstUnusedIndex - 1) {
// Deleting the last element.
// Move index back.
firstUnusedIndex--;
while (geometries[firstUnusedIndex] == null) {
firstUnusedIndex--;
if (firstUnusedIndex < 0) {
break;
} }
if (instanceIndex < 0) {
throw new IllegalArgumentException("instanceIndex cannot be smaller than zero");
} }
if (instanceIndex >= currentNumInstances) { firstUnusedIndex++;
throw new IllegalArgumentException("instanceIndex cannot be larger than currentNumInstances"); } else {
// Deleting element in the middle
} }
// TODO: Determine if need to make a copy of matrix or just doing this
// is fine.
worldMatrices[instanceIndex] = worldTransform;
} }
public void setInstanceTransform(int instanceIndex, Transform worldTransform) { public void addInstance(Geometry geometry) {
if (worldTransform == null) { if (geometry == null) {
throw new IllegalArgumentException("worldTransform cannot be null"); throw new IllegalArgumentException("geometry cannot be null");
} }
// Compute the world transform matrix. // Take an index from the end.
tempMat4.loadIdentity(); if (firstUnusedIndex + 1 >= geometries.length) {
tempMat4.setRotationQuaternion(worldTransform.getRotation()); // No more room.
tempMat4.setTranslation(worldTransform.getTranslation()); setMaxNumInstances(getMaxNumInstances() * 2);
tempMat4_2.loadIdentity(); }
tempMat4_2.scale(worldTransform.getScale());
tempMat4.multLocal(tempMat4_2); int freeIndex = firstUnusedIndex;
firstUnusedIndex++;
setInstanceTransform(instanceIndex, tempMat4.clone()); geometries[freeIndex] = geometry;
InstancedNode.setGeometryStartIndex2(geometry, freeIndex);
} }
public VertexBuffer[] getAllInstanceData() { public VertexBuffer[] getAllInstanceData() {
VertexBuffer instanceDataForCam = instanceDataPerCam.get(lastCamera);
ArrayList<VertexBuffer> allData = new ArrayList(); ArrayList<VertexBuffer> allData = new ArrayList();
if (transformInstanceData != null) {
if (instanceDataForCam != null) { allData.add(transformInstanceData);
allData.add(instanceDataForCam);
} }
if (globalInstanceData != null) { if (globalInstanceData != null) {
allData.addAll(Arrays.asList(globalInstanceData)); allData.addAll(Arrays.asList(globalInstanceData));
} }
return allData.toArray(new VertexBuffer[allData.size()]); return allData.toArray(new VertexBuffer[allData.size()]);
} }
@ -504,30 +341,20 @@ public class InstancedGeometry extends Geometry {
public void write(JmeExporter exporter) throws IOException { public void write(JmeExporter exporter) throws IOException {
super.write(exporter); super.write(exporter);
OutputCapsule capsule = exporter.getCapsule(this); OutputCapsule capsule = exporter.getCapsule(this);
capsule.write(currentNumInstances, "cur_num_instances", 1); //capsule.write(currentNumInstances, "cur_num_instances", 1);
capsule.write(mode, "instancing_mode", InstancedGeometry.Mode.Auto); capsule.write(geometries, "geometries", null);
if (mode == Mode.Auto) {
capsule.write(worldMatrices, "world_matrices", null);
}
} }
@Override @Override
public void read(JmeImporter importer) throws IOException { public void read(JmeImporter importer) throws IOException {
super.read(importer); super.read(importer);
InputCapsule capsule = importer.getCapsule(this); InputCapsule capsule = importer.getCapsule(this);
currentNumInstances = capsule.readInt("cur_num_instances", 1); //currentNumInstances = capsule.readInt("cur_num_instances", 1);
mode = capsule.readEnum("instancing_mode", InstancedGeometry.Mode.class,
InstancedGeometry.Mode.Auto);
if (mode == Mode.Auto) {
Savable[] matrixSavables = capsule.readSavableArray("world_matrices", null);
worldMatrices = new Matrix4f[matrixSavables.length];
for (int i = 0; i < worldMatrices.length; i++) {
worldMatrices[i] = (Matrix4f) matrixSavables[i];
}
control = getControl(InstancedGeometryControl.class); Savable[] geometrySavables = capsule.readSavableArray("geometries", null);
control.geom = this; geometries = new Geometry[geometrySavables.length];
for (int i = 0; i < geometrySavables.length; i++) {
geometries[i] = (Geometry) geometrySavables[i];
} }
} }
} }

@ -0,0 +1,259 @@
package com.jme3.scene.instancing;
import com.jme3.material.Material;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.BatchNode;
import com.jme3.scene.Geometry;
import com.jme3.scene.GeometryGroupNode;
import com.jme3.scene.Mesh;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.UserData;
import com.jme3.scene.control.AbstractControl;
import com.jme3.scene.control.Control;
import java.util.HashMap;
public class InstancedNode extends GeometryGroupNode {
static int getGeometryStartIndex2(Geometry geom) {
return getGeometryStartIndex(geom);
}
static void setGeometryStartIndex2(Geometry geom, int startIndex) {
setGeometryStartIndex(geom, startIndex);
}
private static class InstanceTypeKey implements Cloneable {
Mesh mesh;
Material material;
int lodLevel;
public InstanceTypeKey(Mesh mesh, Material material, int lodLevel) {
this.mesh = mesh;
this.material = material;
this.lodLevel = lodLevel;
}
public InstanceTypeKey(){
}
@Override
public int hashCode() {
int hash = 3;
hash = 41 * hash + this.mesh.hashCode();
hash = 41 * hash + this.material.hashCode();
hash = 41 * hash + this.lodLevel;
return hash;
}
@Override
public boolean equals(Object obj) {
final InstanceTypeKey other = (InstanceTypeKey) obj;
if (this.mesh != other.mesh) {
return false;
}
if (this.material != other.material) {
return false;
}
if (this.lodLevel != other.lodLevel) {
return false;
}
return true;
}
@Override
public InstanceTypeKey clone() {
try {
return (InstanceTypeKey) super.clone();
} catch (CloneNotSupportedException ex) {
throw new AssertionError();
}
}
}
private static class InstancedNodeControl extends AbstractControl {
private InstancedNode node;
public InstancedNodeControl() {
}
public InstancedNodeControl(InstancedNode node) {
this.node = node;
}
@Override
public Control cloneForSpatial(Spatial spatial) {
return this;
// WARNING: Sets wrong control on spatial. Will be
// fixed automatically by InstancedNode.clone() method.
}
@Override
protected void controlUpdate(float tpf) {
}
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
node.renderFromControl();
}
}
protected final HashMap<Geometry, InstancedGeometry> igByGeom
= new HashMap<Geometry, InstancedGeometry>();
private final InstanceTypeKey lookUp = new InstanceTypeKey();
private final HashMap<InstanceTypeKey, InstancedGeometry> instancesMap =
new HashMap<InstanceTypeKey, InstancedGeometry>();
public InstancedNode() {
super();
// NOTE: since we are deserializing,
// the control is going to be added automatically here.
}
public InstancedNode(String name) {
super(name);
addControl(new InstancedNodeControl(this));
}
private void renderFromControl() {
for (InstancedGeometry ig : instancesMap.values()) {
ig.updateInstances();
}
}
private static boolean isInstancedGeometry(Geometry geom) {
return geom instanceof InstancedGeometry;
}
private InstancedGeometry lookUpByGeometry(Geometry geom) {
lookUp.mesh = geom.getMesh();
lookUp.material = geom.getMaterial();
lookUp.lodLevel = geom.getLodLevel();
InstancedGeometry ig = instancesMap.get(lookUp);
if (ig == null) {
ig = new InstancedGeometry(
"material-" + lookUp.material.getMaterialDef().getName() + ","
+ "lod-" + lookUp.lodLevel);
ig.setMaterial(lookUp.material);
ig.setMesh(lookUp.mesh);
ig.setUserData(UserData.JME_PHYSICSIGNORE, true);
ig.setCullHint(CullHint.Never);
instancesMap.put(lookUp.clone(), ig);
attachChild(ig);
}
return ig;
}
private void removeFromInstancedGeometry(Geometry geom) {
InstancedGeometry ig = igByGeom.remove(geom);
if (ig != null) {
ig.deleteInstance(geom);
}
}
private void ungroupSceneGraph(Spatial s) {
if (s instanceof Node) {
for (Spatial sp : ((Node) s).getChildren()) {
ungroupSceneGraph(sp);
}
} else if (s instanceof Geometry) {
Geometry g = (Geometry) s;
if (g.isGrouped()) {
// Will invoke onGeometryUnassociated automatically.
g.unassociateFromGroupNode();
if (InstancedNode.getGeometryStartIndex(g) != -1) {
throw new AssertionError();
}
}
}
}
@Override
public Spatial detachChildAt(int index) {
Spatial s = super.detachChildAt(index);
if (s instanceof Node) {
ungroupSceneGraph(s);
}
return s;
}
private void instance(Spatial n) {
if (n instanceof Geometry) {
Geometry g = (Geometry) n;
if (!g.isGrouped() && g.getBatchHint() != BatchHint.Never) {
InstancedGeometry ig = lookUpByGeometry(g);
igByGeom.put(g, ig);
g.associateWithGroupNode(this, 0);
ig.addInstance(g);
}
} else if (n instanceof Node) {
for (Spatial child : ((Node) n).getChildren()) {
if (child instanceof GeometryGroupNode) {
continue;
}
instance(child);
}
}
}
public void instance() {
instance(this);
}
@Override
public Node clone(boolean cloneMaterials) {
InstancedNode clone = (InstancedNode)super.clone(cloneMaterials);
if (instancesMap.size() > 0) {
// Remove all instanced geometries from the clone
for (int i = 0; i < clone.children.size(); i++) {
if (clone.children.get(i) instanceof InstancedGeometry) {
clone.children.remove(i);
}
}
// Clear state (which is incorrect)
clone.igByGeom.clear();
clone.instancesMap.clear();
clone.instance();
}
return clone;
}
private void majorChange(Geometry geom) {
InstancedGeometry oldIG = igByGeom.get(geom);
InstancedGeometry newIG = lookUpByGeometry(geom);
if (oldIG != newIG) {
oldIG.deleteInstance(geom);
newIG.addInstance(geom);
igByGeom.put(geom, newIG);
}
}
@Override
public void onTransformChange(Geometry geom) {
// Handled automatically
}
@Override
public void onMaterialChange(Geometry geom) {
majorChange(geom);
}
@Override
public void onMeshChange(Geometry geom) {
majorChange(geom);
}
@Override
public void onGeoemtryUnassociated(Geometry geom) {
removeFromInstancedGeometry(geom);
}
}

@ -10,6 +10,8 @@ MaterialDef Debug Normals {
WorldParameters { WorldParameters {
WorldViewProjectionMatrix WorldViewProjectionMatrix
ViewProjectionMatrix
ViewMatrix
ProjectionMatrix ProjectionMatrix
} }

@ -59,7 +59,8 @@ MaterialDef Unshaded {
WorldParameters { WorldParameters {
WorldViewProjectionMatrix WorldViewProjectionMatrix
ProjectionMatrix ViewProjectionMatrix
ViewMatrix
} }
Defines { Defines {

@ -23,6 +23,7 @@ uniform mat4 g_ViewMatrix;
uniform mat4 g_ProjectionMatrix; uniform mat4 g_ProjectionMatrix;
uniform mat4 g_WorldViewMatrix; uniform mat4 g_WorldViewMatrix;
uniform mat4 g_WorldViewProjectionMatrix; uniform mat4 g_WorldViewProjectionMatrix;
uniform mat4 g_ViewProjectionMatrix;
uniform mat3 g_NormalMatrix; uniform mat3 g_NormalMatrix;
#if defined INSTANCING #if defined INSTANCING
@ -37,29 +38,36 @@ uniform mat3 g_NormalMatrix;
// 2 vertex attributes which now can be used for additional per-vertex data. // 2 vertex attributes which now can be used for additional per-vertex data.
attribute mat4 inInstanceData; attribute mat4 inInstanceData;
// Extract the world view matrix out of the instance data, leaving out the // Extract the world matrix out of the instance data, leaving out the
// quaternion at the end. // quaternion at the end.
mat4 worldViewMatrix = mat4(vec4(inInstanceData[0].xyz, 0.0), mat4 worldMatrix = mat4(vec4(inInstanceData[0].xyz, 0.0),
vec4(inInstanceData[1].xyz, 0.0), vec4(inInstanceData[1].xyz, 0.0),
vec4(inInstanceData[2].xyz, 0.0), vec4(inInstanceData[2].xyz, 0.0),
vec4(inInstanceData[3].xyz, 1.0)); vec4(inInstanceData[3].xyz, 1.0));
vec4 TransformWorld(vec4 position)
{
return (worldMatrix * position);
}
vec4 TransformWorldView(vec4 position) vec4 TransformWorldView(vec4 position)
{ {
return worldViewMatrix * position; return g_ViewMatrix * TransformWorld(position);
} }
vec4 TransformWorldViewProjection(vec4 position) vec4 TransformWorldViewProjection(vec4 position)
{ {
return g_ProjectionMatrix * TransformWorldView(position); return g_ViewProjectionMatrix * TransformWorld(position);
} }
vec3 TransformNormal(vec3 vec) vec3 TransformNormal(vec3 vec)
{ {
vec4 quat = vec4(inInstanceData[0].w, inInstanceData[1].w, vec4 quat = vec4(inInstanceData[0].w, inInstanceData[1].w,
inInstanceData[2].w, inInstanceData[3].w); inInstanceData[2].w, inInstanceData[3].w);
return vec + vec3(2.0) * cross(cross(vec, quat.xyz) + vec3(quat.w) * vec, quat.xyz);
vec3 worldNormal = vec + vec3(2.0) * cross(cross(vec, quat.xyz) + vec3(quat.w) * vec, quat.xyz);
return (g_ViewMatrix * vec4(worldNormal, 0.0)).xyz;
} }
// Prevent user from using g_** matrices which will have invalid data in this case. // Prevent user from using g_** matrices which will have invalid data in this case.

@ -0,0 +1,186 @@
/*
* 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 jme3test.scene.instancing;
import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.FastMath;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.Mesh;
import com.jme3.scene.Spatial;
import com.jme3.scene.Spatial.CullHint;
import com.jme3.scene.instancing.InstancedGeometry;
import com.jme3.scene.instancing.InstancedNode;
import com.jme3.scene.shape.Box;
import com.jme3.scene.shape.Sphere;
import com.jme3.system.AppSettings;
public class TestInstanceNode extends SimpleApplication {
private Mesh mesh1;
private Mesh mesh2;
private final Material[] materials = new Material[6];
private InstancedNode instancedNode;
private float time = 0;
public static void main(String[] args){
TestInstanceNode app = new TestInstanceNode();
AppSettings settings = new AppSettings(true);
settings.setVSync(false);
app.setSettings(settings);
app.start();
}
private Geometry createInstance(float x, float z) {
Mesh mesh;
if (FastMath.nextRandomInt(0, 1) == 1) mesh = mesh2;
else mesh = mesh1;
Geometry geometry = new Geometry("randomGeom", mesh);
geometry.setMaterial(materials[FastMath.nextRandomInt(0, materials.length - 1)]);
geometry.setLocalTranslation(x, 0, z);
return geometry;
}
@Override
public void simpleInitApp() {
mesh1 = new Sphere(13, 13, 0.4f, true, false);
mesh2 = new Box(0.4f, 0.4f, 0.4f);
materials[0] = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
materials[0].setBoolean("UseInstancing", true);
materials[0].setColor("Color", ColorRGBA.Red);
materials[1] = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
materials[1].setBoolean("UseInstancing", true);
materials[1].setColor("Color", ColorRGBA.Green);
materials[2] = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
materials[2].setBoolean("UseInstancing", true);
materials[2].setColor("Color", ColorRGBA.Blue);
materials[3] = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
materials[3].setBoolean("UseInstancing", true);
materials[3].setColor("Color", ColorRGBA.Cyan);
materials[4] = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
materials[4].setBoolean("UseInstancing", true);
materials[4].setColor("Color", ColorRGBA.Magenta);
materials[5] = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
materials[5].setBoolean("UseInstancing", true);
materials[5].setColor("Color", ColorRGBA.Yellow);
instancedNode = new InstancedNode("instanced_node");
instancedNode.setCullHint(CullHint.Never);
rootNode.attachChild(instancedNode);
int extent = 30;
for (int y = -extent; y < extent; y++) {
for (int x = -extent; x < extent; x++) {
Geometry instance = createInstance(x, y);
float height = (smoothstep(0, 1, FastMath.nextRandomFloat()) * 2.5f) - 1.25f;
instance.setUserData("height", height);
instance.setUserData("dir", 1f);
instancedNode.attachChild(instance);
}
}
instancedNode.instance();
cam.setLocation(new Vector3f(38.373516f, 6.689055f, 38.482082f));
cam.setRotation(new Quaternion(-0.04004206f, 0.918326f, -0.096310444f, -0.38183528f));
flyCam.setMoveSpeed(15);
//flyCam.setEnabled(false);
}
private float smoothstep(float edge0, float edge1, float x) {
// Scale, bias and saturate x to 0..1 range
x = FastMath.clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
// Evaluate polynomial
return x * x * (3 - 2 * x);
}
@Override
public void simpleUpdate(float tpf) {
time += tpf;
if (time > 1f) {
time = 0f;
for (Spatial instance : instancedNode.getChildren()) {
if (!(instance instanceof InstancedGeometry)) {
Geometry geom = (Geometry) instance;
geom.setMaterial(materials[FastMath.nextRandomInt(0, materials.length - 1)]);
Mesh mesh;
if (FastMath.nextRandomInt(0, 1) == 1) mesh = mesh2;
else mesh = mesh1;
geom.setMesh(mesh);
}
}
}
for (Spatial child : instancedNode.getChildren()) {
if (!(child instanceof InstancedGeometry)) {
float val = child.getUserData("height");
float dir = child.getUserData("dir");
val += (dir + ((FastMath.nextRandomFloat() * 0.5f) - 0.25f)) * tpf;
if (val > 1f) {
val = 1f;
dir = -dir;
} else if (val < 0f) {
val = 0f;
dir = -dir;
}
Vector3f translation = child.getLocalTranslation();
translation.y = (smoothstep(0, 1, val) * 2.5f) - 1.25f;
child.setUserData("height", val);
child.setUserData("dir", dir);
child.setLocalTranslation(translation);
}
}
}
}

@ -1,146 +0,0 @@
/*
* 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 jme3test.scene.instancing;
import com.jme3.app.SimpleApplication;
import com.jme3.input.KeyInput;
import com.jme3.input.controls.ActionListener;
import com.jme3.input.controls.AnalogListener;
import com.jme3.input.controls.KeyTrigger;
import com.jme3.material.Material;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.Spatial.CullHint;
import com.jme3.scene.instancing.InstancedGeometry;
import com.jme3.scene.shape.Sphere;
public class TestInstancing extends SimpleApplication {
private InstancedGeometry instancedGeometry;
private Node instancedGeoms;
private Material material;
private boolean enabled = true;
public static void main(String[] args){
TestInstancing app = new TestInstancing();
//app.setShowSettings(false);
//app.setDisplayFps(false);
//app.setDisplayStatView(false);
app.start();
}
private Geometry createInstance(float x, float z) {
// Note: it doesn't matter what mesh or material we set here.
Geometry geometry = new Geometry("randomGeom", instancedGeometry.getMesh());
geometry.setMaterial(instancedGeometry.getMaterial());
geometry.setLocalTranslation(x, 0, z);
return geometry;
}
@Override
public void simpleInitApp() {
initInputs();
Sphere sphere = new Sphere(10, 10, 0.5f, true, false);
material = new Material(assetManager, "Common/MatDefs/Misc/ShowNormals.j3md");
material.setBoolean("UseInstancing", true);
instancedGeometry = new InstancedGeometry(InstancedGeometry.Mode.Auto, "instanced_geom");
instancedGeometry.setMaxNumInstances(60 * 60);
instancedGeometry.setCurrentNumInstances(60 * 60);
instancedGeometry.setCullHint(CullHint.Never);
instancedGeometry.setMesh(sphere);
instancedGeometry.setMaterial(material);
rootNode.attachChild(instancedGeometry);
instancedGeoms = new Node("instances_node");
// Important: Do not render these geometries, only
// use their world transforms to instance them via
// InstancedGeometry.
instancedGeoms.setCullHint(CullHint.Always);
for (int y = -30; y < 30; y++) {
for (int x = -30; x < 30; x++) {
Geometry instance = createInstance(x, y);
instancedGeoms.attachChild(instance);
}
}
rootNode.attachChild(instancedGeoms);
rootNode.setCullHint(CullHint.Never);
int instanceIndex = 0;
for (Spatial child : instancedGeoms.getChildren()) {
if (instanceIndex < instancedGeometry.getMaxNumInstances()) {
instancedGeometry.setInstanceTransform(instanceIndex++, child.getWorldTransform());
}
}
instancedGeometry.setCurrentNumInstances(instanceIndex);
cam.setLocation(new Vector3f(38.373516f, 6.689055f, 38.482082f));
cam.setRotation(new Quaternion(-0.04004206f, 0.918326f, -0.096310444f, -0.38183528f));
flyCam.setMoveSpeed(15);
}
private void initInputs() {
inputManager.addMapping("toggle", new KeyTrigger(KeyInput.KEY_SPACE));
ActionListener acl = new ActionListener() {
public void onAction(String name, boolean keyPressed, float tpf) {
if (name.equals("toggle") && keyPressed) {
if (enabled) {
enabled = false;
instancedGeoms.setCullHint(CullHint.Dynamic);
instancedGeometry.setCullHint(CullHint.Always);
material.setBoolean("UseInstancing", false);
System.out.println("Instancing OFF");
} else {
enabled = true;
instancedGeoms.setCullHint(CullHint.Always);
instancedGeometry.setCullHint(CullHint.Never);
material.setBoolean("UseInstancing", true);
System.out.println("Instancing ON");
}
}
}
};
inputManager.addListener(acl, "toggle");
}
}
Loading…
Cancel
Save