/*
|
* SmoothSkin.java
|
*
|
*
|
* The Salamander Project - 2D and 3D graphics libraries in Java
|
* Copyright (C) 2004 Mark McKay
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2.1 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
*
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
*
|
* Mark McKay can be contacted at mark@kitfox.com. Salamander and other
|
* projects can be found at http://www.kitfox.com
|
*
|
* Created on March 10, 2004, 5:39 AM
|
*/
|
|
import javax.media.j3d.*;
|
import javax.vecmath.*;
|
|
import java.util.*;
|
|
/**
|
*
|
* @author kitfox
|
*/
|
//public class SmoothSkin extends Shape3D
|
public class SmoothSkin extends TriangleStripArray
|
{
|
// TriangleStripArray targetSkin;
|
Bone skelRoot;
|
|
// int vertexFormat;
|
// int vertexCount;
|
// int[] stripVertexCounts;
|
float[] bindCoordinates;
|
float[] bindNormals;
|
float[] targetCoordinates;
|
float[] targetNormals;
|
float[] texCoords;
|
float[] colors;
|
|
//Array of weights per bone per vertex. Organized first by bones and then
|
// by index of vertex into the targetCoordinates array. Bones are in the
|
// order of a depth first search of the skelRoot skeleton.
|
float[] boneWeights;
|
Transform3D worldToSkin = new Transform3D();
|
|
private SmoothSkin(int vertexCount, int vertexFormat, int[] stripVertexCounts)
|
{
|
super(vertexCount, vertexFormat, stripVertexCounts);
|
}
|
|
private SmoothSkin(int vertexCount, int vertexFormat, int texCoordSetCount, int[] texCoordSetMap, int[] stripVertexCounts)
|
{
|
super(vertexCount, vertexFormat, texCoordSetCount, texCoordSetMap, stripVertexCounts);
|
}
|
|
/**
|
* Create a new instance of SmoothSkin. Special work needs to be done in
|
* creation, so the constructor cannot be called directly.
|
*
|
* @param skelRoot - The root node of the skeleton system that will animate
|
* this mesh
|
* @param weights - A map of HashMaps that represent the distribution of
|
* weights per bone. That is, 'weights' will contain keys of Bone that map
|
* to a hashmap describing weights for that bone. This second hashmap
|
* will contain keys of Point3f representing points in the source mesh to
|
* Float, representing the weight for this point for this bone.
|
* @param geometry - A triangle strip array that is the mesh this skeleton
|
* will deform
|
* @param skinToWorld - A transform that will map the skin mesh into world space,
|
* if it is not already there.
|
*/
|
public static SmoothSkin create(Bone skelRoot, HashMap weights, TriangleStripArray geometry, Transform3D skinToWorld)
|
{
|
//Make two copies of input geometry; one for holding bind information,
|
// and the other being the target object that we render.
|
SmoothSkin targetSkin;
|
|
int vertexFormat = geometry.getVertexFormat();
|
int vertexCount = geometry.getVertexCount();
|
int numStrips = geometry.getNumStrips();
|
int[] stripVertexCounts = new int[numStrips];
|
geometry.getStripVertexCounts(stripVertexCounts);
|
|
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0)
|
{
|
int texCoordSetCount = geometry.getTexCoordSetCount();
|
int[] texCoordSetMap = new int[texCoordSetCount];
|
geometry.getTexCoordSetMap(texCoordSetMap);
|
|
targetSkin = new SmoothSkin(vertexCount, vertexFormat | GeometryArray.BY_REFERENCE, texCoordSetCount, texCoordSetMap, stripVertexCounts);
|
} else
|
{
|
targetSkin = new SmoothSkin(vertexCount, vertexFormat | GeometryArray.BY_REFERENCE, stripVertexCounts);
|
}
|
|
|
targetSkin.prepareGeometry(skelRoot, geometry, weights, skinToWorld);
|
|
return targetSkin;
|
}
|
|
private void prepareGeometry(Bone skelRoot, TriangleStripArray geom, HashMap weights, Transform3D skinToWorld)
|
{
|
int vertexCount = getVertexCount();
|
int vertexFormat = getVertexFormat();
|
|
bindCoordinates = new float[vertexCount * 3];
|
geom.getCoordinates(0, bindCoordinates);
|
targetCoordinates = new float[vertexCount * 3];
|
geom.getCoordinates(0, targetCoordinates);
|
setCoordRefFloat(targetCoordinates);
|
|
setCapability(GeometryArray.ALLOW_REF_DATA_READ);
|
setCapability(GeometryArray.ALLOW_REF_DATA_WRITE);
|
|
if ((vertexFormat & GeometryArray.NORMALS) != 0)
|
{
|
bindNormals = new float[vertexCount * 3];
|
geom.getNormals(0, bindNormals);
|
targetNormals = new float[vertexCount * 3];
|
geom.getNormals(0, targetNormals);
|
setNormalRefFloat(targetNormals);
|
}
|
|
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0)
|
{
|
texCoords = new float[vertexCount * 2];
|
geom.getTextureCoordinates(0, 0, texCoords);
|
setTexCoordRefFloat(0, texCoords);
|
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0)
|
{
|
texCoords = new float[vertexCount * 3];
|
geom.getTextureCoordinates(0, 0, texCoords);
|
setTexCoordRefFloat(0, texCoords);
|
} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0)
|
{
|
texCoords = new float[vertexCount * 4];
|
geom.getTextureCoordinates(0, 0, texCoords);
|
setTexCoordRefFloat(0, texCoords);
|
}
|
|
if ((vertexFormat & GeometryArray.COLOR_4) != 0)
|
{
|
colors = new float[vertexCount * 4];
|
geom.getColors(0, colors);
|
setColorRefFloat(colors);
|
} else if ((vertexFormat & GeometryArray.COLOR_3) != 0)
|
{
|
colors = new float[vertexCount * 3];
|
geom.getColors(0, colors);
|
setColorRefFloat(colors);
|
}
|
|
//Now build skeleton and bone weights array
|
this.skelRoot = skelRoot;
|
|
boneWeights = new float[weights.size() * vertexCount];
|
calcBoneWeights(skelRoot, weights, 0);
|
|
|
//Map all points to world space
|
Point3f mapPoint = new Point3f();
|
for (int i = 0; i < bindCoordinates.length; i += 3)
|
{
|
mapPoint.set(bindCoordinates[i], bindCoordinates[i + 1], bindCoordinates[i + 2]);
|
skinToWorld.transform(mapPoint);
|
bindCoordinates[i] = mapPoint.x;
|
bindCoordinates[i + 1] = mapPoint.y;
|
bindCoordinates[i + 2] = mapPoint.z;
|
}
|
|
worldToSkin.invert(skinToWorld);
|
}
|
|
public NodeComponent cloneNodeComponent(boolean forceDuplicate)
|
{
|
SmoothSkin targetSkin;
|
|
int vertexFormat = getVertexFormat();
|
int vertexCount = getVertexCount();
|
int numStrips = getNumStrips();
|
int[] stripVertexCounts = new int[numStrips];
|
getStripVertexCounts(stripVertexCounts);
|
|
if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0)
|
{
|
int texCoordSetCount = getTexCoordSetCount();
|
int[] texCoordSetMap = new int[texCoordSetCount];
|
getTexCoordSetMap(texCoordSetMap);
|
|
targetSkin = new SmoothSkin(vertexCount, vertexFormat | GeometryArray.BY_REFERENCE, texCoordSetCount, texCoordSetMap, stripVertexCounts);
|
} else
|
{
|
targetSkin = new SmoothSkin(vertexCount, vertexFormat | GeometryArray.BY_REFERENCE, stripVertexCounts);
|
}
|
|
targetSkin.duplicateNodeComponent(this, forceDuplicate);
|
return targetSkin;
|
}
|
|
/**
|
* Copies all information from the original node into this node
|
*/
|
public void duplicateNodeComponent(NodeComponent originalNodeComponent, boolean forceDuplicate)
|
{
|
super.duplicateNodeComponent(originalNodeComponent, forceDuplicate);
|
|
if (!forceDuplicate)
|
{
|
forceDuplicate = getDuplicateOnCloneTree();
|
}
|
|
|
SmoothSkin src = (SmoothSkin) originalNodeComponent;
|
|
bindCoordinates = src.bindCoordinates;
|
bindNormals = src.bindNormals;
|
boneWeights = src.boneWeights;
|
|
targetCoordinates = getCoordRefFloat();
|
targetNormals = getNormalRefFloat();
|
texCoords = getTexCoordRefFloat(0);
|
colors = getColorRefFloat();
|
|
|
if (forceDuplicate)
|
{
|
skelRoot = (Bone) src.skelRoot.cloneTree(true);
|
} else
|
{
|
skelRoot = src.skelRoot;
|
}
|
}
|
|
public Bone getSkeletonRoot()
|
{
|
return skelRoot;
|
}
|
|
/**
|
* Returns number of points weighted
|
*/
|
public int calcBoneWeights(Bone bone, HashMap weights, int offset)
|
{
|
HashMap vtxMap = (HashMap) weights.get(bone);
|
Point3f vertex = new Point3f();
|
|
int vertexCount = getVertexCount();
|
for (int i = 0; i < vertexCount; i++)
|
{
|
vertex.set(bindCoordinates[i * 3], bindCoordinates[i * 3 + 1], bindCoordinates[i * 3 + 2]);
|
Float weight = (Float) vtxMap.get(vertex);
|
|
boneWeights[offset++] = weight.floatValue();
|
}
|
|
for (Iterator it = bone.children.iterator(); it.hasNext();)
|
{
|
Bone nextBone = (Bone) it.next();
|
offset = calcBoneWeights(nextBone, weights, offset);
|
}
|
|
return offset;
|
}
|
|
/**
|
* Causes the target skin to be reevaluated. Call this after making changes
|
* to the bone hierarchy to generate the new mesh.
|
*/
|
public void updateSkin()
|
{
|
updateData(
|
new GeometryUpdater()
|
{
|
|
public void updateData(javax.media.j3d.Geometry geom)
|
{
|
evaluateSkin();
|
}
|
});
|
}
|
|
/**
|
* Recalculates target skin based on current bone animation positions.
|
*/
|
private void evaluateSkin()
|
{
|
for (int i = 0; i < bindCoordinates.length; i++)
|
{
|
targetCoordinates[i] = targetNormals[i] = 0f;
|
}
|
|
//Identity change to root bone
|
final Transform3D rootXform = new Transform3D();
|
evalBoneWeights(skelRoot, 0, rootXform, rootXform);
|
|
//Normal array needs to be converted from normal offsets to normals
|
for (int i = 0; i < bindCoordinates.length; i++)
|
{
|
targetNormals[i] -= targetCoordinates[i];
|
}
|
|
//Map all points to world space
|
Point3f mapPoint = new Point3f();
|
for (int i = 0; i < bindCoordinates.length; i += 3)
|
{
|
mapPoint.set(targetCoordinates[i], targetCoordinates[i + 1], targetCoordinates[i + 2]);
|
worldToSkin.transform(mapPoint);
|
targetCoordinates[i] = mapPoint.x;
|
targetCoordinates[i + 1] = mapPoint.y;
|
targetCoordinates[i + 2] = mapPoint.z;
|
}
|
}
|
|
// Point4f ptN = new Point4f();
|
public int evalBoneWeights(Bone bone, int offset, Transform3D parentWorldToLocal, Transform3D parentLocalToWorld)
|
{
|
Transform3D worldToLocal = new Transform3D();
|
Transform3D localToWorld = new Transform3D();
|
Transform3D sceneXform = new Transform3D();
|
|
worldToLocal.mul(bone.bindInvXform, parentWorldToLocal);
|
localToWorld.mul(parentLocalToWorld, bone.animXform);
|
sceneXform.mul(localToWorld, worldToLocal);
|
|
Point3f pt = new Point3f();
|
Point3f norm = new Point3f();
|
|
for (int i = 0; i < bindCoordinates.length; i += 3)
|
{
|
//boneWeights[offset] = 1f;
|
if (boneWeights[offset] < 0.01)
|
{
|
//Do not process transform if only a tiny amount of bone contribution
|
// is present
|
offset++;
|
continue;
|
}
|
|
//Evaluate coorinate
|
norm.x = pt.x = bindCoordinates[i];
|
norm.y = pt.y = bindCoordinates[i + 1];
|
norm.z = pt.z = bindCoordinates[i + 2];
|
|
sceneXform.transform(pt);
|
float boneWeight = boneWeights[offset];
|
pt.scale(boneWeight);
|
|
targetCoordinates[i] += pt.x;
|
targetCoordinates[i + 1] += pt.y;
|
targetCoordinates[i + 2] += pt.z;
|
|
//Evaluate normal offset
|
norm.x += bindNormals[i];
|
norm.y += bindNormals[i + 1];
|
norm.z += bindNormals[i + 2];
|
|
sceneXform.transform(norm);
|
norm.scale(boneWeights[offset++]);
|
|
targetNormals[i] += norm.x;
|
targetNormals[i + 1] += norm.y;
|
targetNormals[i + 2] += norm.z;
|
}
|
|
for (Iterator it = bone.children.iterator(); it.hasNext();)
|
{
|
Bone nextBone = (Bone) it.next();
|
offset = evalBoneWeights(nextBone, offset, worldToLocal, localToWorld);
|
}
|
|
return offset;
|
}
|
}
|
