Added a better skeleton debugger
This commit is contained in:
Rémy Bouquet
Rémy Bouquet
parent
42aec10020
commit
b129d2954f
@ -0,0 +1,417 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
// $Id: Cylinder.java 4131 2009-03-19 20:15:28Z blaine.dev $
|
||||
package com.jme3.scene.debug.custom;
|
||||
|
||||
import com.jme3.export.InputCapsule;
|
||||
import com.jme3.export.JmeExporter;
|
||||
import com.jme3.export.JmeImporter;
|
||||
import com.jme3.export.OutputCapsule;
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.scene.Mesh;
|
||||
import com.jme3.scene.VertexBuffer.Type;
|
||||
import com.jme3.scene.mesh.IndexBuffer;
|
||||
import com.jme3.util.BufferUtils;
|
||||
|
||||
import static com.jme3.util.BufferUtils.*;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
/**
|
||||
* A simple cylinder, defined by it's height and radius.
|
||||
* (Ported to jME3)
|
||||
*
|
||||
* @author Mark Powell
|
||||
* @version $Revision: 4131 $, $Date: 2009-03-19 16:15:28 -0400 (Thu, 19 Mar 2009) $
|
||||
*/
|
||||
public class BoneShape extends Mesh {
|
||||
|
||||
private int axisSamples;
|
||||
|
||||
private int radialSamples;
|
||||
|
||||
private float radius;
|
||||
private float radius2;
|
||||
|
||||
private float height;
|
||||
private boolean closed;
|
||||
private boolean inverted;
|
||||
|
||||
/**
|
||||
* Default constructor for serialization only. Do not use.
|
||||
*/
|
||||
public BoneShape() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Cylinder. By default its center is the origin. Usually, a
|
||||
* higher sample number creates a better looking cylinder, but at the cost
|
||||
* of more vertex information.
|
||||
*
|
||||
* @param axisSamples Number of triangle samples along the axis.
|
||||
* @param radialSamples Number of triangle samples along the radial.
|
||||
* @param radius The radius of the cylinder.
|
||||
* @param height The cylinder's height.
|
||||
*/
|
||||
public BoneShape(int axisSamples, int radialSamples,
|
||||
float radius, float height) {
|
||||
this(axisSamples, radialSamples, radius, height, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Cylinder. By default its center is the origin. Usually, a
|
||||
* higher sample number creates a better looking cylinder, but at the cost
|
||||
* of more vertex information. <br>
|
||||
* If the cylinder is closed the texture is split into axisSamples parts:
|
||||
* top most and bottom most part is used for top and bottom of the cylinder,
|
||||
* rest of the texture for the cylinder wall. The middle of the top is
|
||||
* mapped to texture coordinates (0.5, 1), bottom to (0.5, 0). Thus you need
|
||||
* a suited distorted texture.
|
||||
*
|
||||
* @param axisSamples Number of triangle samples along the axis.
|
||||
* @param radialSamples Number of triangle samples along the radial.
|
||||
* @param radius The radius of the cylinder.
|
||||
* @param height The cylinder's height.
|
||||
* @param closed true to create a cylinder with top and bottom surface
|
||||
*/
|
||||
public BoneShape(int axisSamples, int radialSamples,
|
||||
float radius, float height, boolean closed) {
|
||||
this(axisSamples, radialSamples, radius, height, closed, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Cylinder. By default its center is the origin. Usually, a
|
||||
* higher sample number creates a better looking cylinder, but at the cost
|
||||
* of more vertex information. <br>
|
||||
* If the cylinder is closed the texture is split into axisSamples parts:
|
||||
* top most and bottom most part is used for top and bottom of the cylinder,
|
||||
* rest of the texture for the cylinder wall. The middle of the top is
|
||||
* mapped to texture coordinates (0.5, 1), bottom to (0.5, 0). Thus you need
|
||||
* a suited distorted texture.
|
||||
*
|
||||
* @param axisSamples Number of triangle samples along the axis.
|
||||
* @param radialSamples Number of triangle samples along the radial.
|
||||
* @param radius The radius of the cylinder.
|
||||
* @param height The cylinder's height.
|
||||
* @param closed true to create a cylinder with top and bottom surface
|
||||
* @param inverted true to create a cylinder that is meant to be viewed from the
|
||||
* interior.
|
||||
*/
|
||||
public BoneShape(int axisSamples, int radialSamples,
|
||||
float radius, float height, boolean closed, boolean inverted) {
|
||||
this(axisSamples, radialSamples, radius, radius, height, closed, inverted);
|
||||
}
|
||||
|
||||
public BoneShape(int axisSamples, int radialSamples,
|
||||
float radius, float radius2, float height, boolean closed, boolean inverted) {
|
||||
super();
|
||||
updateGeometry(axisSamples, radialSamples, radius, radius2, height, closed, inverted);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the number of samples along the cylinder axis
|
||||
*/
|
||||
public int getAxisSamples() {
|
||||
return axisSamples;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Returns the height.
|
||||
*/
|
||||
public float getHeight() {
|
||||
return height;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return number of samples around cylinder
|
||||
*/
|
||||
public int getRadialSamples() {
|
||||
return radialSamples;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Returns the radius.
|
||||
*/
|
||||
public float getRadius() {
|
||||
return radius;
|
||||
}
|
||||
|
||||
public float getRadius2() {
|
||||
return radius2;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if end caps are used.
|
||||
*/
|
||||
public boolean isClosed() {
|
||||
return closed;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if normals and uvs are created for interior use
|
||||
*/
|
||||
public boolean isInverted() {
|
||||
return inverted;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rebuilds the cylinder based on a new set of parameters.
|
||||
*
|
||||
* @param axisSamples the number of samples along the axis.
|
||||
* @param radialSamples the number of samples around the radial.
|
||||
* @param radius the radius of the bottom of the cylinder.
|
||||
* @param radius2 the radius of the top of the cylinder.
|
||||
* @param height the cylinder's height.
|
||||
* @param closed should the cylinder have top and bottom surfaces.
|
||||
* @param inverted is the cylinder is meant to be viewed from the inside.
|
||||
*/
|
||||
public void updateGeometry(int axisSamples, int radialSamples,
|
||||
float radius, float radius2, float height, boolean closed, boolean inverted) {
|
||||
this.axisSamples = axisSamples + (closed ? 2 : 0);
|
||||
this.radialSamples = radialSamples;
|
||||
this.radius = radius;
|
||||
this.radius2 = radius2;
|
||||
this.height = height;
|
||||
this.closed = closed;
|
||||
this.inverted = inverted;
|
||||
|
||||
// VertexBuffer pvb = getBuffer(Type.Position);
|
||||
// VertexBuffer nvb = getBuffer(Type.Normal);
|
||||
// VertexBuffer tvb = getBuffer(Type.TexCoord);
|
||||
|
||||
// Vertices
|
||||
int vertCount = axisSamples * (radialSamples + 1) + (closed ? 2 : 0);
|
||||
|
||||
setBuffer(Type.Position, 3, createVector3Buffer(getFloatBuffer(Type.Position), vertCount));
|
||||
|
||||
// Normals
|
||||
setBuffer(Type.Normal, 3, createVector3Buffer(getFloatBuffer(Type.Normal), vertCount));
|
||||
|
||||
// Texture co-ordinates
|
||||
setBuffer(Type.TexCoord, 2, createVector2Buffer(vertCount));
|
||||
|
||||
int triCount = ((closed ? 2 : 0) + 2 * (axisSamples - 1)) * radialSamples;
|
||||
|
||||
setBuffer(Type.Index, 3, createShortBuffer(getShortBuffer(Type.Index), 3 * triCount));
|
||||
|
||||
//Color
|
||||
setBuffer(Type.Color, 4, createFloatBuffer(vertCount * 4));
|
||||
|
||||
// generate geometry
|
||||
float inverseRadial = 1.0f / radialSamples;
|
||||
float inverseAxisLess = 1.0f / (closed ? axisSamples - 3 : axisSamples - 1);
|
||||
float inverseAxisLessTexture = 1.0f / (axisSamples - 1);
|
||||
float halfHeight = 0.5f * height;
|
||||
|
||||
// Generate points on the unit circle to be used in computing the mesh
|
||||
// points on a cylinder slice.
|
||||
float[] sin = new float[radialSamples + 1];
|
||||
float[] cos = new float[radialSamples + 1];
|
||||
|
||||
for (int radialCount = 0; radialCount < radialSamples; radialCount++) {
|
||||
float angle = FastMath.TWO_PI * inverseRadial * radialCount;
|
||||
cos[radialCount] = FastMath.cos(angle);
|
||||
sin[radialCount] = FastMath.sin(angle);
|
||||
}
|
||||
sin[radialSamples] = sin[0];
|
||||
cos[radialSamples] = cos[0];
|
||||
|
||||
// calculate normals
|
||||
Vector3f[] vNormals = null;
|
||||
Vector3f vNormal = Vector3f.UNIT_Z;
|
||||
|
||||
if ((height != 0.0f) && (radius != radius2)) {
|
||||
vNormals = new Vector3f[radialSamples];
|
||||
Vector3f vHeight = Vector3f.UNIT_Z.mult(height);
|
||||
Vector3f vRadial = new Vector3f();
|
||||
|
||||
for (int radialCount = 0; radialCount < radialSamples; radialCount++) {
|
||||
vRadial.set(cos[radialCount], sin[radialCount], 0.0f);
|
||||
Vector3f vRadius = vRadial.mult(radius);
|
||||
Vector3f vRadius2 = vRadial.mult(radius2);
|
||||
Vector3f vMantle = vHeight.subtract(vRadius2.subtract(vRadius));
|
||||
Vector3f vTangent = vRadial.cross(Vector3f.UNIT_Z);
|
||||
vNormals[radialCount] = vMantle.cross(vTangent).normalize();
|
||||
}
|
||||
}
|
||||
|
||||
FloatBuffer nb = getFloatBuffer(Type.Normal);
|
||||
FloatBuffer pb = getFloatBuffer(Type.Position);
|
||||
FloatBuffer tb = getFloatBuffer(Type.TexCoord);
|
||||
FloatBuffer cb = getFloatBuffer(Type.Color);
|
||||
|
||||
cb.rewind();
|
||||
for (int i = 0; i < vertCount; i++) {
|
||||
cb.put(0.05f).put(0.05f).put(0.05f).put(1f);
|
||||
}
|
||||
|
||||
// generate the cylinder itself
|
||||
Vector3f tempNormal = new Vector3f();
|
||||
for (int axisCount = 0, i = 0; axisCount < axisSamples; axisCount++, i++) {
|
||||
float axisFraction;
|
||||
float axisFractionTexture;
|
||||
int topBottom = 0;
|
||||
if (!closed) {
|
||||
axisFraction = axisCount * inverseAxisLess; // in [0,1]
|
||||
axisFractionTexture = axisFraction;
|
||||
} else {
|
||||
if (axisCount == 0) {
|
||||
topBottom = -1; // bottom
|
||||
axisFraction = 0;
|
||||
axisFractionTexture = inverseAxisLessTexture;
|
||||
} else if (axisCount == axisSamples - 1) {
|
||||
topBottom = 1; // top
|
||||
axisFraction = 1;
|
||||
axisFractionTexture = 1 - inverseAxisLessTexture;
|
||||
} else {
|
||||
axisFraction = (axisCount - 1) * inverseAxisLess;
|
||||
axisFractionTexture = axisCount * inverseAxisLessTexture;
|
||||
}
|
||||
}
|
||||
|
||||
// compute center of slice
|
||||
float z = height * axisFraction;
|
||||
Vector3f sliceCenter = new Vector3f(0, 0, z);
|
||||
|
||||
// compute slice vertices with duplication at end point
|
||||
int save = i;
|
||||
for (int radialCount = 0; radialCount < radialSamples; radialCount++, i++) {
|
||||
float radialFraction = radialCount * inverseRadial; // in [0,1)
|
||||
tempNormal.set(cos[radialCount], sin[radialCount], 0.0f);
|
||||
|
||||
if (vNormals != null) {
|
||||
vNormal = vNormals[radialCount];
|
||||
} else if (radius == radius2) {
|
||||
vNormal = tempNormal;
|
||||
}
|
||||
|
||||
if (topBottom == 0) {
|
||||
if (!inverted)
|
||||
nb.put(vNormal.x).put(vNormal.y).put(vNormal.z);
|
||||
else
|
||||
nb.put(-vNormal.x).put(-vNormal.y).put(-vNormal.z);
|
||||
} else {
|
||||
nb.put(0).put(0).put(topBottom * (inverted ? -1 : 1));
|
||||
}
|
||||
|
||||
tempNormal.multLocal((radius - radius2) * axisFraction + radius2)
|
||||
.addLocal(sliceCenter);
|
||||
pb.put(tempNormal.x).put(tempNormal.y).put(tempNormal.z);
|
||||
|
||||
tb.put((inverted ? 1 - radialFraction : radialFraction))
|
||||
.put(axisFractionTexture);
|
||||
}
|
||||
|
||||
BufferUtils.copyInternalVector3(pb, save, i);
|
||||
BufferUtils.copyInternalVector3(nb, save, i);
|
||||
|
||||
tb.put((inverted ? 0.0f : 1.0f))
|
||||
.put(axisFractionTexture);
|
||||
}
|
||||
|
||||
if (closed) {
|
||||
pb.put(0).put(0).put(-halfHeight); // bottom center
|
||||
nb.put(0).put(0).put(-1 * (inverted ? -1 : 1));
|
||||
tb.put(0.5f).put(0);
|
||||
pb.put(0).put(0).put(halfHeight); // top center
|
||||
nb.put(0).put(0).put(1 * (inverted ? -1 : 1));
|
||||
tb.put(0.5f).put(1);
|
||||
}
|
||||
|
||||
IndexBuffer ib = getIndexBuffer();
|
||||
int index = 0;
|
||||
// Connectivity
|
||||
for (int axisCount = 0, axisStart = 0; axisCount < axisSamples - 1; axisCount++) {
|
||||
int i0 = axisStart;
|
||||
int i1 = i0 + 1;
|
||||
axisStart += radialSamples + 1;
|
||||
int i2 = axisStart;
|
||||
int i3 = i2 + 1;
|
||||
for (int i = 0; i < radialSamples; i++) {
|
||||
if (closed && axisCount == 0) {
|
||||
if (!inverted) {
|
||||
ib.put(index++, i0++);
|
||||
ib.put(index++, vertCount - 2);
|
||||
ib.put(index++, i1++);
|
||||
} else {
|
||||
ib.put(index++, i0++);
|
||||
ib.put(index++, i1++);
|
||||
ib.put(index++, vertCount - 2);
|
||||
}
|
||||
} else if (closed && axisCount == axisSamples - 2) {
|
||||
ib.put(index++, i2++);
|
||||
ib.put(index++, inverted ? vertCount - 1 : i3++);
|
||||
ib.put(index++, inverted ? i3++ : vertCount - 1);
|
||||
} else {
|
||||
ib.put(index++, i0++);
|
||||
ib.put(index++, inverted ? i2 : i1);
|
||||
ib.put(index++, inverted ? i1 : i2);
|
||||
ib.put(index++, i1++);
|
||||
ib.put(index++, inverted ? i2++ : i3++);
|
||||
ib.put(index++, inverted ? i3++ : i2++);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
updateBound();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void read(JmeImporter e) throws IOException {
|
||||
super.read(e);
|
||||
InputCapsule capsule = e.getCapsule(this);
|
||||
axisSamples = capsule.readInt("axisSamples", 0);
|
||||
radialSamples = capsule.readInt("radialSamples", 0);
|
||||
radius = capsule.readFloat("radius", 0);
|
||||
radius2 = capsule.readFloat("radius2", 0);
|
||||
height = capsule.readFloat("height", 0);
|
||||
closed = capsule.readBoolean("closed", false);
|
||||
inverted = capsule.readBoolean("inverted", false);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void write(JmeExporter e) throws IOException {
|
||||
super.write(e);
|
||||
OutputCapsule capsule = e.getCapsule(this);
|
||||
capsule.write(axisSamples, "axisSamples", 0);
|
||||
capsule.write(radialSamples, "radialSamples", 0);
|
||||
capsule.write(radius, "radius", 0);
|
||||
capsule.write(radius2, "radius2", 0);
|
||||
capsule.write(height, "height", 0);
|
||||
capsule.write(closed, "closed", false);
|
||||
capsule.write(inverted, "inverted", false);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,216 @@
|
||||
package com.jme3.scene.debug.custom;
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.jme3.animation.Bone;
|
||||
import com.jme3.animation.Skeleton;
|
||||
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.Node;
|
||||
import com.jme3.scene.VertexBuffer;
|
||||
import com.jme3.scene.shape.Sphere;
|
||||
|
||||
import static com.jme3.util.BufferUtils.createFloatBuffer;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.util.HashMap;
|
||||
|
||||
/**
|
||||
* The class that displays either wires between the bones' heads if no length
|
||||
* data is supplied and full bones' shapes otherwise.
|
||||
*/
|
||||
public class SkeletonBone extends Node {
|
||||
|
||||
/**
|
||||
* The skeleton to be displayed.
|
||||
*/
|
||||
private Skeleton skeleton;
|
||||
/**
|
||||
* The map between the bone index and its length.
|
||||
*/
|
||||
private Map<Bone, Node> boneNodes = new HashMap<Bone, Node>();
|
||||
private Map<Node, Bone> nodeBones = new HashMap<Node, Bone>();
|
||||
private Node selectedNode = null;
|
||||
private boolean guessBonesOrientation = false;
|
||||
|
||||
/**
|
||||
* Creates a wire with bone lengths data. If the data is supplied then the
|
||||
* wires will show each full bone (from head to tail).
|
||||
*
|
||||
* @param skeleton the skeleton that will be shown
|
||||
* @param boneLengths a map between the bone's index and the bone's length
|
||||
*/
|
||||
public SkeletonBone(Skeleton skeleton, Map<Integer, Float> boneLengths, boolean guessBonesOrientation) {
|
||||
this.skeleton = skeleton;
|
||||
this.skeleton.reset();
|
||||
this.skeleton.updateWorldVectors();
|
||||
this.guessBonesOrientation = guessBonesOrientation;
|
||||
|
||||
BoneShape boneShape = new BoneShape(5, 12, 0.02f, 0.07f, 1f, false, false);
|
||||
Sphere jointShape = new Sphere(10, 10, 0.1f);
|
||||
jointShape.setBuffer(VertexBuffer.Type.Color, 4, createFloatBuffer(jointShape.getVertexCount() * 4));
|
||||
FloatBuffer cb = jointShape.getFloatBuffer(VertexBuffer.Type.Color);
|
||||
|
||||
cb.rewind();
|
||||
for (int i = 0; i < jointShape.getVertexCount(); i++) {
|
||||
cb.put(0.05f).put(0.05f).put(0.05f).put(1f);
|
||||
}
|
||||
|
||||
for (Bone bone : skeleton.getRoots()) {
|
||||
createSkeletonGeoms(bone, boneShape, jointShape, boneLengths, skeleton, this, guessBonesOrientation);
|
||||
}
|
||||
}
|
||||
|
||||
protected final void createSkeletonGeoms(Bone bone, Mesh boneShape, Mesh jointShape, Map<Integer, Float> boneLengths, Skeleton skeleton, Node parent, boolean guessBonesOrientation) {
|
||||
|
||||
if (guessBonesOrientation && bone.getName().equalsIgnoreCase("Site")) {
|
||||
//BVH skeleton have a useless end point bone named Site
|
||||
return;
|
||||
}
|
||||
Node n = new Node(bone.getName() + "Node");
|
||||
Geometry bGeom = new Geometry(bone.getName(), boneShape);
|
||||
Geometry jGeom = new Geometry(bone.getName() + "Joint", jointShape);
|
||||
n.setLocalTranslation(bone.getLocalPosition());
|
||||
n.setLocalRotation(bone.getLocalRotation());
|
||||
|
||||
float boneLength = boneLengths.get(skeleton.getBoneIndex(bone));
|
||||
n.setLocalScale(bone.getLocalScale());
|
||||
|
||||
bGeom.setLocalRotation(new Quaternion().fromAngleAxis(-FastMath.HALF_PI, Vector3f.UNIT_X).normalizeLocal());
|
||||
|
||||
if (guessBonesOrientation) {
|
||||
//One child only, the bone direction is from the parent joint to the child joint.
|
||||
if (bone.getChildren().size() == 1) {
|
||||
Vector3f v = bone.getChildren().get(0).getLocalPosition();
|
||||
Quaternion q = new Quaternion();
|
||||
q.lookAt(v, Vector3f.UNIT_Z);
|
||||
bGeom.setLocalRotation(q);
|
||||
}
|
||||
//no child, the bone has the same direction as the parent bone.
|
||||
if (bone.getChildren().isEmpty()) {
|
||||
if (parent.getChildren().size() > 0) {
|
||||
bGeom.setLocalRotation(parent.getChild(0).getLocalRotation());
|
||||
} else {
|
||||
//no parent, let's use the bind orientation of the bone
|
||||
bGeom.setLocalRotation(bone.getBindRotation());
|
||||
}
|
||||
}
|
||||
}
|
||||
bGeom.setLocalScale(boneLength);
|
||||
jGeom.setLocalScale(boneLength);
|
||||
|
||||
n.attachChild(bGeom);
|
||||
n.attachChild(jGeom);
|
||||
|
||||
//tip
|
||||
if (bone.getChildren().size() != 1) {
|
||||
Geometry gt = jGeom.clone();
|
||||
gt.scale(0.8f);
|
||||
Vector3f v = new Vector3f(0, boneLength, 0);
|
||||
if (guessBonesOrientation) {
|
||||
if (bone.getChildren().isEmpty()) {
|
||||
if (parent.getChildren().size() > 0) {
|
||||
gt.setLocalTranslation(bGeom.getLocalRotation().mult(parent.getChild(0).getLocalRotation()).mult(v, v));
|
||||
} else {
|
||||
gt.setLocalTranslation(bGeom.getLocalRotation().mult(bone.getBindRotation()).mult(v, v));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
gt.setLocalTranslation(v);
|
||||
}
|
||||
|
||||
n.attachChild(gt);
|
||||
}
|
||||
|
||||
|
||||
boneNodes.put(bone, n);
|
||||
nodeBones.put(n, bone);
|
||||
parent.attachChild(n);
|
||||
for (Bone childBone : bone.getChildren()) {
|
||||
createSkeletonGeoms(childBone, boneShape, jointShape, boneLengths, skeleton, n, guessBonesOrientation);
|
||||
}
|
||||
}
|
||||
|
||||
protected Bone select(Geometry g) {
|
||||
Node parentNode = g.getParent();
|
||||
|
||||
if (parent != null) {
|
||||
Bone b = nodeBones.get(parentNode);
|
||||
if (b != null) {
|
||||
selectedNode = parentNode;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected Node getSelectedNode() {
|
||||
return selectedNode;
|
||||
}
|
||||
|
||||
|
||||
// private Quaternion getRotationBetweenVect(Vector3f v1, Vector3f v2){
|
||||
// Vector3f a =v1.cross(v2);
|
||||
// float w = FastMath.sqrt((v1.length() * v1.length()) * (v2.length() * v2.length())) + v1.dot(v2);
|
||||
// return new Quaternion(a.x, a.y, a.z, w).normalizeLocal() ;
|
||||
// }
|
||||
|
||||
protected final void updateSkeletonGeoms(Bone bone) {
|
||||
if (guessBonesOrientation && bone.getName().equalsIgnoreCase("Site")) {
|
||||
return;
|
||||
}
|
||||
Node n = boneNodes.get(bone);
|
||||
n.setLocalTranslation(bone.getLocalPosition());
|
||||
n.setLocalRotation(bone.getLocalRotation());
|
||||
n.setLocalScale(bone.getLocalScale());
|
||||
|
||||
for (Bone childBone : bone.getChildren()) {
|
||||
updateSkeletonGeoms(childBone);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The method updates the geometry according to the poitions of the bones.
|
||||
*/
|
||||
public void updateGeometry() {
|
||||
|
||||
for (Bone bone : skeleton.getRoots()) {
|
||||
updateSkeletonGeoms(bone);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,150 @@
|
||||
/*
|
||||
* To change this template, choose Tools | Templates
|
||||
* and open the template in the editor.
|
||||
*/
|
||||
package com.jme3.scene.debug.custom;
|
||||
|
||||
import com.jme3.animation.Bone;
|
||||
import com.jme3.animation.Skeleton;
|
||||
import com.jme3.animation.SkeletonControl;
|
||||
import com.jme3.app.Application;
|
||||
import com.jme3.app.state.AbstractAppState;
|
||||
import com.jme3.app.state.AppStateManager;
|
||||
import com.jme3.collision.CollisionResults;
|
||||
import com.jme3.input.MouseInput;
|
||||
import com.jme3.input.controls.ActionListener;
|
||||
import com.jme3.input.controls.MouseButtonTrigger;
|
||||
import com.jme3.math.Ray;
|
||||
import com.jme3.math.Vector2f;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.ViewPort;
|
||||
import com.jme3.scene.Geometry;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* @author Nehon
|
||||
*/
|
||||
public class SkeletonDebugAppState extends AbstractAppState {
|
||||
|
||||
private Node debugNode = new Node("debugNode");
|
||||
private Map<Skeleton, SkeletonDebugger> skeletons = new HashMap<Skeleton, SkeletonDebugger>();
|
||||
private Map<Skeleton, Bone> selectedBones = new HashMap<Skeleton, Bone>();
|
||||
private Application app;
|
||||
|
||||
@Override
|
||||
public void initialize(AppStateManager stateManager, Application app) {
|
||||
ViewPort vp = app.getRenderManager().createMainView("debug", app.getCamera());
|
||||
vp.attachScene(debugNode);
|
||||
vp.setClearDepth(true);
|
||||
this.app = app;
|
||||
for (SkeletonDebugger skeletonDebugger : skeletons.values()) {
|
||||
skeletonDebugger.initialize(app.getAssetManager());
|
||||
}
|
||||
app.getInputManager().addListener(actionListener, "shoot");
|
||||
app.getInputManager().addMapping("shoot", new MouseButtonTrigger(MouseInput.BUTTON_LEFT), new MouseButtonTrigger(MouseInput.BUTTON_RIGHT));
|
||||
super.initialize(stateManager, app);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update(float tpf) {
|
||||
debugNode.updateLogicalState(tpf);
|
||||
debugNode.updateGeometricState();
|
||||
}
|
||||
|
||||
public SkeletonDebugger addSkeleton(SkeletonControl skeletonControl, boolean guessBonesOrientation) {
|
||||
Skeleton skeleton = skeletonControl.getSkeleton();
|
||||
Spatial forSpatial = skeletonControl.getSpatial();
|
||||
SkeletonDebugger sd = new SkeletonDebugger(forSpatial.getName() + "_Skeleton", skeleton, guessBonesOrientation);
|
||||
sd.setLocalTransform(forSpatial.getWorldTransform());
|
||||
if (forSpatial instanceof Node) {
|
||||
List<Geometry> geoms = new ArrayList<>();
|
||||
findGeoms((Node) forSpatial, geoms);
|
||||
if (geoms.size() == 1) {
|
||||
sd.setLocalTransform(geoms.get(0).getWorldTransform());
|
||||
}
|
||||
}
|
||||
skeletons.put(skeleton, sd);
|
||||
debugNode.attachChild(sd);
|
||||
if (isInitialized()) {
|
||||
sd.initialize(app.getAssetManager());
|
||||
}
|
||||
return sd;
|
||||
}
|
||||
|
||||
private void findGeoms(Node node, List<Geometry> geoms) {
|
||||
for (Spatial spatial : node.getChildren()) {
|
||||
if (spatial instanceof Geometry) {
|
||||
geoms.add((Geometry) spatial);
|
||||
} else if (spatial instanceof Node) {
|
||||
findGeoms((Node) spatial, geoms);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Pick a Target Using the Mouse Pointer. <ol><li>Map "pick target" action
|
||||
* to a MouseButtonTrigger. <li>flyCam.setEnabled(false);
|
||||
* <li>inputManager.setCursorVisible(true); <li>Implement action in
|
||||
* AnalogListener (TODO).</ol>
|
||||
*/
|
||||
private ActionListener actionListener = new ActionListener() {
|
||||
public void onAction(String name, boolean isPressed, float tpf) {
|
||||
if (name.equals("shoot") && isPressed) {
|
||||
CollisionResults results = new CollisionResults();
|
||||
Vector2f click2d = app.getInputManager().getCursorPosition();
|
||||
Vector3f click3d = app.getCamera().getWorldCoordinates(new Vector2f(click2d.x, click2d.y), 0f).clone();
|
||||
Vector3f dir = app.getCamera().getWorldCoordinates(new Vector2f(click2d.x, click2d.y), 1f).subtractLocal(click3d);
|
||||
Ray ray = new Ray(click3d, dir);
|
||||
|
||||
debugNode.collideWith(ray, results);
|
||||
|
||||
if (results.size() > 0) {
|
||||
// The closest result is the target that the player picked:
|
||||
Geometry target = results.getClosestCollision().getGeometry();
|
||||
for (SkeletonDebugger skeleton : skeletons.values()) {
|
||||
Bone selectedBone = skeleton.select(target);
|
||||
if (selectedBone != null) {
|
||||
selectedBones.put(skeleton.getSkeleton(), selectedBone);
|
||||
System.err.println("-----------------------");
|
||||
System.err.println("Selected Bone : " + selectedBone.getName() + " in skeleton " + skeleton.getName());
|
||||
System.err.println("-----------------------");
|
||||
System.err.println("Bind translation: " + selectedBone.getBindPosition());
|
||||
System.err.println("Bind rotation: " + selectedBone.getBindRotation());
|
||||
System.err.println("Bind scale: " + selectedBone.getBindScale());
|
||||
System.err.println("---");
|
||||
System.err.println("Local translation: " + selectedBone.getLocalPosition());
|
||||
System.err.println("Local rotation: " + selectedBone.getLocalRotation());
|
||||
System.err.println("Local scale: " + selectedBone.getLocalScale());
|
||||
System.err.println("---");
|
||||
System.err.println("Model translation: " + selectedBone.getModelSpacePosition());
|
||||
System.err.println("Model rotation: " + selectedBone.getModelSpaceRotation());
|
||||
System.err.println("Model scale: " + selectedBone.getModelSpaceScale());
|
||||
System.err.println("---");
|
||||
System.err.println("Bind inverse Transform: ");
|
||||
System.err.println(selectedBone.getBindInverseTransform());
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
public Map<Skeleton, Bone> getSelectedBones() {
|
||||
return selectedBones;
|
||||
}
|
||||
|
||||
public Node getDebugNode() {
|
||||
return debugNode;
|
||||
}
|
||||
|
||||
public void setDebugNode(Node debugNode) {
|
||||
this.debugNode = debugNode;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,218 @@
|
||||
package com.jme3.scene.debug.custom;
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
import com.jme3.animation.Bone;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.jme3.animation.Skeleton;
|
||||
import com.jme3.asset.AssetManager;
|
||||
import com.jme3.material.Material;
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import com.jme3.scene.BatchNode;
|
||||
import com.jme3.scene.Geometry;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.jme3.scene.VertexBuffer;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* The class that creates a mesh to display how bones behave. If it is supplied
|
||||
* with the bones' lengths it will show exactly how the bones look like on the
|
||||
* scene. If not then only connections between each bone heads will be shown.
|
||||
*/
|
||||
public class SkeletonDebugger extends BatchNode {
|
||||
|
||||
/**
|
||||
* The lines of the bones or the wires between their heads.
|
||||
*/
|
||||
private SkeletonBone bones;
|
||||
|
||||
private Skeleton skeleton;
|
||||
/**
|
||||
* The dotted lines between a bone's tail and the had of its children. Not
|
||||
* available if the length data was not provided.
|
||||
*/
|
||||
private SkeletonInterBoneWire interBoneWires;
|
||||
private List<Bone> selectedBones = new ArrayList<Bone>();
|
||||
|
||||
public SkeletonDebugger() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a debugger with no length data. The wires will be a connection
|
||||
* between the bones' heads only. The points will show the bones' heads only
|
||||
* and no dotted line of inter bones connection will be visible.
|
||||
*
|
||||
* @param name the name of the debugger's node
|
||||
* @param skeleton the skeleton that will be shown
|
||||
*/
|
||||
public SkeletonDebugger(String name, Skeleton skeleton, boolean guessBonesOrientation) {
|
||||
super(name);
|
||||
this.skeleton = skeleton;
|
||||
skeleton.reset();
|
||||
skeleton.updateWorldVectors();
|
||||
Map<Integer, Float> boneLengths = new HashMap<Integer, Float>();
|
||||
|
||||
for (Bone bone : skeleton.getRoots()) {
|
||||
computeLength(bone, boneLengths, skeleton);
|
||||
}
|
||||
|
||||
bones = new SkeletonBone(skeleton, boneLengths, guessBonesOrientation);
|
||||
|
||||
this.attachChild(bones);
|
||||
|
||||
interBoneWires = new SkeletonInterBoneWire(skeleton, boneLengths, guessBonesOrientation);
|
||||
Geometry g = new Geometry(name + "_interwires", interBoneWires);
|
||||
g.setBatchHint(BatchHint.Never);
|
||||
this.attachChild(g);
|
||||
}
|
||||
|
||||
protected void initialize(AssetManager assetManager) {
|
||||
Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
|
||||
mat.setColor("Color", new ColorRGBA(0.05f, 0.05f, 0.05f, 1.0f));//new ColorRGBA(0.1f, 0.1f, 0.1f, 1.0f)
|
||||
setMaterial(mat);
|
||||
Material mat2 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
|
||||
mat2.setBoolean("VertexColor", true);
|
||||
bones.setMaterial(mat2);
|
||||
batch();
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public final void setMaterial(Material material) {
|
||||
if (batches.isEmpty()) {
|
||||
for (int i = 0; i < children.size(); i++) {
|
||||
children.get(i).setMaterial(material);
|
||||
}
|
||||
} else {
|
||||
super.setMaterial(material);
|
||||
}
|
||||
}
|
||||
|
||||
public Skeleton getSkeleton() {
|
||||
return skeleton;
|
||||
}
|
||||
|
||||
|
||||
private void computeLength(Bone b, Map<Integer, Float> boneLengths, Skeleton skeleton) {
|
||||
if (b.getChildren().isEmpty()) {
|
||||
if (b.getParent() != null) {
|
||||
boneLengths.put(skeleton.getBoneIndex(b), boneLengths.get(skeleton.getBoneIndex(b.getParent())) * 0.75f);
|
||||
} else {
|
||||
boneLengths.put(skeleton.getBoneIndex(b), 0.1f);
|
||||
}
|
||||
} else {
|
||||
float length = Float.MAX_VALUE;
|
||||
for (Bone bone : b.getChildren()) {
|
||||
float len = b.getModelSpacePosition().subtract(bone.getModelSpacePosition()).length();
|
||||
if (len < length) {
|
||||
length = len;
|
||||
}
|
||||
}
|
||||
boneLengths.put(skeleton.getBoneIndex(b), length);
|
||||
for (Bone bone : b.getChildren()) {
|
||||
computeLength(bone, boneLengths, skeleton);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateLogicalState(float tpf) {
|
||||
super.updateLogicalState(tpf);
|
||||
bones.updateGeometry();
|
||||
if (interBoneWires != null) {
|
||||
interBoneWires.updateGeometry();
|
||||
}
|
||||
}
|
||||
|
||||
ColorRGBA selectedColor = ColorRGBA.Orange;
|
||||
ColorRGBA baseColor = new ColorRGBA(0.05f, 0.05f, 0.05f, 1f);
|
||||
|
||||
protected Bone select(Geometry g) {
|
||||
Node oldNode = bones.getSelectedNode();
|
||||
Bone b = bones.select(g);
|
||||
if (b == null) {
|
||||
return null;
|
||||
}
|
||||
if (oldNode != null) {
|
||||
markSelected(oldNode, false);
|
||||
}
|
||||
markSelected(bones.getSelectedNode(), true);
|
||||
return b;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the skeleton wires
|
||||
*/
|
||||
public SkeletonBone getBoneShapes() {
|
||||
return bones;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the dotted line between bones (can be null)
|
||||
*/
|
||||
public SkeletonInterBoneWire getInterBoneWires() {
|
||||
return interBoneWires;
|
||||
}
|
||||
|
||||
protected void markSelected(Node n, boolean selected) {
|
||||
ColorRGBA c = baseColor;
|
||||
if (selected) {
|
||||
c = selectedColor;
|
||||
}
|
||||
for (Spatial spatial : n.getChildren()) {
|
||||
if (spatial instanceof Geometry) {
|
||||
Geometry geom = (Geometry) spatial;
|
||||
|
||||
Geometry batch = (Geometry) getChild(getName() + "-batch0");
|
||||
VertexBuffer vb = batch.getMesh().getBuffer(VertexBuffer.Type.Color);
|
||||
FloatBuffer color = (FloatBuffer) vb.getData();
|
||||
// System.err.println(getName() + "." + geom.getName() + " index " + getGeometryStartIndex(geom) * 4 + "/" + color.limit());
|
||||
|
||||
color.position(getGeometryStartIndex(geom) * 4);
|
||||
|
||||
for (int i = 0; i < geom.getVertexCount(); i++) {
|
||||
color.put(c.r).put(c.g).put(c.b).put(c.a);
|
||||
}
|
||||
color.rewind();
|
||||
vb.updateData(color);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,141 @@
|
||||
package com.jme3.scene.debug.custom;
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.util.Map;
|
||||
|
||||
import com.jme3.animation.Bone;
|
||||
import com.jme3.animation.Skeleton;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.scene.Mesh;
|
||||
import com.jme3.scene.VertexBuffer;
|
||||
import com.jme3.scene.VertexBuffer.Format;
|
||||
import com.jme3.scene.VertexBuffer.Type;
|
||||
import com.jme3.scene.VertexBuffer.Usage;
|
||||
import com.jme3.util.BufferUtils;
|
||||
|
||||
/**
|
||||
* A class that displays a dotted line between a bone tail and its childrens' heads.
|
||||
*
|
||||
* @author Marcin Roguski (Kaelthas)
|
||||
*/
|
||||
public class SkeletonInterBoneWire extends Mesh {
|
||||
private static final int POINT_AMOUNT = 10;
|
||||
/**
|
||||
* The amount of connections between bones.
|
||||
*/
|
||||
private int connectionsAmount;
|
||||
/**
|
||||
* The skeleton that will be showed.
|
||||
*/
|
||||
private Skeleton skeleton;
|
||||
/**
|
||||
* The map between the bone index and its length.
|
||||
*/
|
||||
private Map<Integer, Float> boneLengths;
|
||||
|
||||
private boolean guessBonesOrientation = false;
|
||||
|
||||
/**
|
||||
* Creates buffers for points. Each line has POINT_AMOUNT of points.
|
||||
*
|
||||
* @param skeleton the skeleton that will be showed
|
||||
* @param boneLengths the lengths of the bones
|
||||
*/
|
||||
public SkeletonInterBoneWire(Skeleton skeleton, Map<Integer, Float> boneLengths, boolean guessBonesOrientation) {
|
||||
this.skeleton = skeleton;
|
||||
|
||||
for (Bone bone : skeleton.getRoots()) {
|
||||
this.countConnections(bone);
|
||||
}
|
||||
|
||||
this.setMode(Mode.Points);
|
||||
this.setPointSize(2);
|
||||
this.boneLengths = boneLengths;
|
||||
|
||||
VertexBuffer pb = new VertexBuffer(Type.Position);
|
||||
FloatBuffer fpb = BufferUtils.createFloatBuffer(POINT_AMOUNT * connectionsAmount * 3);
|
||||
pb.setupData(Usage.Stream, 3, Format.Float, fpb);
|
||||
this.setBuffer(pb);
|
||||
|
||||
this.guessBonesOrientation = guessBonesOrientation;
|
||||
this.updateCounts();
|
||||
}
|
||||
|
||||
/**
|
||||
* The method updates the geometry according to the poitions of the bones.
|
||||
*/
|
||||
public void updateGeometry() {
|
||||
VertexBuffer vb = this.getBuffer(Type.Position);
|
||||
FloatBuffer posBuf = this.getFloatBuffer(Type.Position);
|
||||
posBuf.clear();
|
||||
for (int i = 0; i < skeleton.getBoneCount(); ++i) {
|
||||
Bone bone = skeleton.getBone(i);
|
||||
Vector3f parentTail = bone.getModelSpacePosition().add(bone.getModelSpaceRotation().mult(Vector3f.UNIT_Y.mult(boneLengths.get(i))));
|
||||
|
||||
if (guessBonesOrientation) {
|
||||
parentTail = bone.getModelSpacePosition();
|
||||
}
|
||||
|
||||
for (Bone child : bone.getChildren()) {
|
||||
Vector3f childHead = child.getModelSpacePosition();
|
||||
Vector3f v = childHead.subtract(parentTail);
|
||||
float pointDelta = v.length() / POINT_AMOUNT;
|
||||
v.normalizeLocal().multLocal(pointDelta);
|
||||
Vector3f pointPosition = parentTail.clone();
|
||||
for (int j = 0; j < POINT_AMOUNT; ++j) {
|
||||
posBuf.put(pointPosition.getX()).put(pointPosition.getY()).put(pointPosition.getZ());
|
||||
pointPosition.addLocal(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
posBuf.flip();
|
||||
vb.updateData(posBuf);
|
||||
|
||||
this.updateBound();
|
||||
}
|
||||
|
||||
/**
|
||||
* Th method couns the connections between bones.
|
||||
*
|
||||
* @param bone the bone where counting starts
|
||||
*/
|
||||
private void countConnections(Bone bone) {
|
||||
for (Bone child : bone.getChildren()) {
|
||||
++connectionsAmount;
|
||||
this.countConnections(child);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user