import com.jme3.texture.Texture;
import com.jme3.util.BufferUtils;
import com.jme3.util.TempVars;
+import com.sun.jmx.remote.util.OrderClassLoaders;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
VertexBuffer skinnb;
VertexBuffer skinnb2;
VertexBuffer skintb;
+ VertexBuffer skinbib;
+ VertexBuffer skinwb;
+ int[] skinIndexArray;
Skin skinArray[];
SkeletonControl skeletonControl;
HashMap<String, Texture> textureMap = new HashMap<String, Texture>();
meshConverter = null;
model.setVertexBuffer(null);
// go.optimize();
+ FloatBuffer fb = (FloatBuffer)skinvb.getData();
+ node.skinPosBuffer = BufferUtils.createFloatBuffer(fb.limit());
+ projectkyoto.jme3.mmd.nativelib.SkinUtil.copy(fb, node.skinPosBuffer, fb.limit() * 4);
node.init();
node.calcOffsetMatrices();
node.update();
skinnb = new VertexBuffer(VertexBuffer.Type.Normal);
FloatBuffer skinnfb = BufferUtils.createFloatBuffer(meshConverter.getSkinMeshData().getVertexList().size() * 3);
- skinnb.setupData(VertexBuffer.Usage.Dynamic, 3, VertexBuffer.Format.Float, skinnfb);
+ skinnb.setupData(VertexBuffer.Usage.Static, 3, VertexBuffer.Format.Float, skinnfb);
skinnb2 = new VertexBuffer(VertexBuffer.Type.Normal);
FloatBuffer skinnfb2 = BufferUtils.createFloatBuffer(meshConverter.getSkinMeshData().getVertexList().size() * 3);
- skinnb2.setupData(VertexBuffer.Usage.Dynamic, 3, VertexBuffer.Format.Float, skinnfb2);
+ skinnb2.setupData(VertexBuffer.Usage.Static, 3, VertexBuffer.Format.Float, skinnfb2);
skintb = new VertexBuffer(VertexBuffer.Type.TexCoord);
FloatBuffer skintfb = BufferUtils.createFloatBuffer(meshConverter.getSkinMeshData().getVertexList().size() * 2);
skintb.setupData(VertexBuffer.Usage.Static, 2, VertexBuffer.Format.Float, skintfb);
+
+ skinbib = new VertexBuffer(VertexBuffer.Type.BoneIndex);
+ ShortBuffer skinbisb = BufferUtils.createShortBuffer(meshConverter.getSkinMeshData().getVertexList().size() * 2);
+ skinbib.setupData(VertexBuffer.Usage.Static, 2, VertexBuffer.Format.UnsignedShort, skinbisb);
+
+ skinwb = new VertexBuffer(VertexBuffer.Type.BoneWeight);
+ FloatBuffer wfb = BufferUtils.createFloatBuffer(meshConverter.getSkinMeshData().getVertexList().size() * 2);
+ skinwb.setupData(VertexBuffer.Usage.Static, 2, VertexBuffer.Format.Float, wfb);
+
for (PMDVertex v : meshConverter.getSkinMeshData().getVertexList()) {
skinvfb.put(v.getPos().x).put(v.getPos().y).put(v.getPos().z);
skinnfb.put(v.getNormal().x).put(v.getNormal().y).put(v.getNormal().z);
skintfb.put(v.getUv().getU()).put(1f - v.getUv().getV());
+ skinbisb.put((short) meshConverter.getSkinMeshData()
+ .getBoneList().indexOf(v.getBoneNum1()))
+ .put((short) meshConverter.getSkinMeshData()
+ .getBoneList().indexOf(v.getBoneNum2()));
+ float weight = (float) v.getBoneWeight() / 100.0f;
+ wfb.put(weight).put(1f - weight);
+ }
+ skinvfb.position(0);
+ skinvfb2.position(0);
+ skinvfb2.put(skinvfb);
+ skinnfb.position(0);
+ skinnfb2.position(0);
+ skinnfb2.put(skinnfb);
+ skinIndexArray = new int[meshConverter.getSkinMeshData().getBoneList().size()];
+ for (int i = 0; i < skinIndexArray.length; i++) {
+ if (i < meshConverter.getSkinMeshData().getBoneList().size()) {
+ skinIndexArray[i] = meshConverter.getSkinMeshData().getBoneList().get(i).shortValue();
+ } else {
+ skinIndexArray[i] = 0;
+ }
}
- skintb.setUpdateNeeded();
}
PMDSkinMesh createSkinMesh(PMDMaterial pmdMaterial) {
+ boolean textureFlag = true;
+ if (pmdMaterial.getTextureFileName().length() == 0) {
+ textureFlag = false;
+ }
PMDSkinMesh mesh = new PMDSkinMesh();
List<Integer> indexList = meshConverter.getSkinMeshData().getIndexMap().get(pmdMaterial);
mesh.setMode(Mesh.Mode.Triangles);
mesh.setSkinvb2(skinvb2);
mesh.setBuffer(skinnb);
mesh.setSkinnb2(skinnb2);
- mesh.setBuffer(skintb);
+ if (textureFlag) {
+ mesh.setBuffer(skintb);
+ }
+ mesh.setBuffer(skinbib);
+ mesh.setBuffer(skinwb);
VertexBuffer ib = new VertexBuffer(VertexBuffer.Type.Index);
ShortBuffer isb = BufferUtils.createShortBuffer(indexList.size());
for (Integer index : indexList) {
}
ib.setupData(VertexBuffer.Usage.Static, 1, VertexBuffer.Format.UnsignedShort, isb);
mesh.setBuffer(ib);
+ mesh.setBoneIndexArray(skinIndexArray);
+ mesh.setBoneMatrixArray(new Matrix4f[skinIndexArray.length]);
+ for (int i = 0; i < mesh.getBoneMatrixArray().length; i++) {
+ mesh.getBoneMatrixArray()[i] = new Matrix4f();
+ mesh.getBoneMatrixArray()[i].loadIdentity();
+ }
return mesh;
}
void setupMaterial(PMDMaterial m, PMDGeometry geom) {
Material mat;
- if (geom.getMesh() instanceof PMDSkinMesh) {
+ if (false /*geom.getMesh() instanceof PMDSkinMesh*/) {
// mat = new Material(assetManager, "Common/MatDefs/Light/Lighting.j3md");
mat = createMaterial(m, false);
geom.setMaterial(mat);
geom.setGlslSkinningMaterial(mat);
geom.setNoSkinningMaterial(mat);
} else {
- PMDMesh mesh = (PMDMesh)geom.getMesh();
+// PMDMesh mesh = (PMDMesh)geom.getMesh();
mat = createMaterial(m, true);
geom.setMaterial(mat);
geom.setGlslSkinningMaterial(mat);
PMDSkinData pmdSkinData = model.getSkinData()[i];
if (pmdSkinData.getSkinType() != 0) {
Skin skin = new Skin(node, pmdSkinData.getSkinName());
- skin.setSkinData(pmdSkinData);
+ skin.setIndexBuf(pmdSkinData.getIndexBuf());
+ skin.setSkinBuf(pmdSkinData.getSkinBuf());
skinList.add(skin);
}
}
PMDGeometry[] pmdGeometryArray;
Map<String, Skin> skinMap = new HashMap<String, Skin>();
Skin[] skinArray = new Skin[0];
- javax.vecmath.Vector3f skinPosArray[];
- javax.vecmath.Vector3f skinNormalArray[];
+// javax.vecmath.Vector3f skinPosArray[];
+// javax.vecmath.Vector3f skinNormalArray[];
javax.vecmath.Vector3f skinPosArrayOrig[];
- javax.vecmath.Vector3f skinNormalArrayOrig[];
- float skinBoneWeightArray[];
- int skinBoneArray[];
+// javax.vecmath.Vector3f skinNormalArrayOrig[];
+ FloatBuffer skinPosBuffer;
+// float skinBoneWeightArray[];
+// int skinBoneArray[];
AssetManager assetManager;
Matrix4f[] offsetMatrices;
boolean updateNeeded = true;
pmdModel = (PMDModel)SavableUtil.read(c, "pmdModel", null);
skeleton = (Skeleton)c.readSavable("skeleton", null);
skinMap = (Map<String, Skin>)c.readStringSavableMap("skinMap", new HashMap<String, Savable>());
- skinBoneWeightArray = c.readFloatArray("skinBoneWeightArray", new float[0]);
- skinBoneArray = c.readIntArray("skinBoneArray", new int[0]);
+// skinBoneWeightArray = c.readFloatArray("skinBoneWeightArray", new float[0]);
+// skinBoneArray = c.readIntArray("skinBoneArray", new int[0]);
edgeSize = c.readFloat("edgeSize", 1.0f);
int pmdGeometryArrayLength = c.readInt("pmdGeometryArrayLength", 0);
pmdGeometryArray = new PMDGeometry[pmdGeometryArrayLength];
l2:
for(int i2=0;i2<pmdModel.getSkinCount();i2++){
if (pmdModel.getSkinData()[i2].getSkinName().equals(skin.getSkinName())) {
- skin.skinData = pmdModel.getSkinData()[i2];
+// skin.skinData = pmdModel.getSkinData()[i2];
break l2;
}
}
skin.setUpdateNeeded(true);
skinMap.put(skin.skinName, skin);
}
- skinPosArray = (javax.vecmath.Vector3f[])SavableUtil.read(c, "skinPosArray", null);
- skinPosArrayOrig = new javax.vecmath.Vector3f[skinPosArray.length];
- for(int i=0;i<skinPosArray.length;i++) {
- skinPosArrayOrig[i] = new javax.vecmath.Vector3f(skinPosArray[i]);
- }
- skinNormalArray = (javax.vecmath.Vector3f[])SavableUtil.read(c, "skinNormalArray", null);
- skinNormalArrayOrig = new javax.vecmath.Vector3f[skinNormalArray.length];
- for(int i=0;i<skinNormalArray.length;i++) {
- skinNormalArrayOrig[i] = new javax.vecmath.Vector3f(skinNormalArray[i]);
- }
- skinBoneArray = c.readIntArray("skinBoneArray", skinBoneArray);
- skinBoneWeightArray = c.readFloatArray("skinBoneWeightArray", skinBoneWeightArray);
+// skinPosArray = (javax.vecmath.Vector3f[])SavableUtil.read(c, "skinPosArray", null);
+// skinPosArrayOrig = new javax.vecmath.Vector3f[skinPosArray.length];
+// for(int i=0;i<skinPosArray.length;i++) {
+// skinPosArrayOrig[i] = new javax.vecmath.Vector3f(skinPosArray[i]);
+// }
+// skinNormalArray = (javax.vecmath.Vector3f[])SavableUtil.read(c, "skinNormalArray", null);
+// skinNormalArrayOrig = new javax.vecmath.Vector3f[skinNormalArray.length];
+// for(int i=0;i<skinNormalArray.length;i++) {
+// skinNormalArrayOrig[i] = new javax.vecmath.Vector3f(skinNormalArray[i]);
+// }
+// skinBoneArray = c.readIntArray("skinBoneArray", skinBoneArray);
+// skinBoneWeightArray = c.readFloatArray("skinBoneWeightArray", skinBoneWeightArray);
}
@Override
SavableUtil.write(c, pmdModel, "pmdModel");
c.write(skeleton, "skeleton", new Skeleton());
c.writeStringSavableMap(skinMap, "skinMap", new HashMap<String, Skin>());
- c.write(skinBoneWeightArray, "skinBoneWeightArray", null);
- c.write(skinBoneArray, "skinBoneArray", null);
+// c.write(skinBoneWeightArray, "skinBoneWeightArray", null);
+// c.write(skinBoneArray, "skinBoneArray", null);
c.write(edgeSize, "edgeSize", 1.0f);
c.write(pmdGeometryArray.length, "pmdGeometryArrayLength",0);
c.write(skinTargets.length, "skinTargetsLength",0);
c.write(mesh.getBuffer(Type.TexCoord),"skintb",null);
}
c.write(skinArray, "skinArray", null);
- SavableUtil.write(c, skinPosArrayOrig,"skinPosArray");
- SavableUtil.write(c, skinNormalArrayOrig, "skinNormalArray");
- c.write(skinBoneArray, "skinBoneArray", null);
- c.write(skinBoneWeightArray, "skinBoneWeightArray", null);
+// SavableUtil.write(c, skinPosArrayOrig,"skinPosArray");
+// SavableUtil.write(c, skinNormalArrayOrig, "skinNormalArray");
+// c.write(skinBoneArray, "skinBoneArray", null);
+// c.write(skinBoneWeightArray, "skinBoneWeightArray", null);
}
skinMap.put(skin.getSkinName(), skin);
}
int skinVertSize = skinVertexList.size();
- skinPosArray = new javax.vecmath.Vector3f[skinVertSize];
- skinNormalArray = new javax.vecmath.Vector3f[skinVertSize];
+// skinPosArray = new javax.vecmath.Vector3f[skinVertSize];
+// skinNormalArray = new javax.vecmath.Vector3f[skinVertSize];
skinPosArrayOrig = new javax.vecmath.Vector3f[skinVertSize];
- skinNormalArrayOrig = new javax.vecmath.Vector3f[skinVertSize];
- skinBoneWeightArray = new float[skinVertSize];
- skinBoneArray = new int[skinVertSize * 2];
+// skinNormalArrayOrig = new javax.vecmath.Vector3f[skinVertSize];
+// skinBoneWeightArray = new float[skinVertSize];
+// skinBoneArray = new int[skinVertSize * 2];
for (int i = 0; i < skinVertSize; i++) {
PMDVertex v = skinVertexList.get(i);
skinPosArrayOrig[i] = v.getPos();
- skinPosArray[i] = new javax.vecmath.Vector3f(v.getPos());
- skinNormalArrayOrig[i] = v.getNormal();
- skinNormalArray[i] = new javax.vecmath.Vector3f(v.getNormal());
- skinBoneWeightArray[i] = (float) v.getBoneWeight() / 100f;
- skinBoneArray[i * 2] = v.getBoneNum1();
- skinBoneArray[i * 2 + 1] = v.getBoneNum2();
+// skinPosArray[i] = new javax.vecmath.Vector3f(v.getPos());
+// skinNormalArrayOrig[i] = v.getNormal();
+// skinNormalArray[i] = new javax.vecmath.Vector3f(v.getNormal());
+// skinBoneWeightArray[i] = (float) v.getBoneWeight() / 100f;
+// skinBoneArray[i * 2] = v.getBoneNum1();
+// skinBoneArray[i * 2 + 1] = v.getBoneNum2();
}
}
}
}
}
-
+ for(int i=getChildren().size()-1;i>=0;i--) {
+ Spatial sp = getChild(i);
+ if (sp instanceof PMDGeometry) {
+ PMDGeometry g = (PMDGeometry) sp;
+ Mesh mesh = g.getMesh();
+ if (mesh instanceof PMDSkinMesh) {
+ PMDSkinMesh skinMesh = (PMDSkinMesh)mesh;
+ Material m = g.getMaterial();
+ int boneIndexArray[] = skinMesh.getBoneIndexArray();
+ Matrix4f[] boneMatrixArray = skinMesh.getBoneMatrixArray();
+ for (int i2 = skinMesh.getBoneIndexArray().length-1; i2 >=0; i2--) {
+ boneMatrixArray[i2] = (offsetMatrices[boneIndexArray[i2]]);
+ }
+ if (glslSkinning) {
+ if (skinMesh.boneMatricesParamIndex < 0) {
+ m.setParam("BoneMatrices", VarType.Matrix4Array, skinMesh.getBoneMatrixArray());
+ skinMesh.boneMatricesParamIndex = g.getMaterial().getParamIndex("BoneMatrices");
+ } else {
+ m.setParam(skinMesh.boneMatricesParamIndex, VarType.Matrix4Array, skinMesh.getBoneMatrixArray());
+ }
+ }
+ }
+ }
+ }
if (!glslSkinning) {
for (PMDMesh mesh : targets) {
softwareSkinUpdate(mesh);
return;
}
VertexBuffer vb = skinTargets[0].getBuffer(VertexBuffer.Type.Position);
- VertexBuffer nb = skinTargets[0].getBuffer(VertexBuffer.Type.Normal);
+// VertexBuffer nb = skinTargets[0].getBuffer(VertexBuffer.Type.Normal);
skinTargets[0].skinvb2.setUpdateNeeded();
- skinTargets[0].skinnb2.setUpdateNeeded();
+// skinTargets[0].skinnb2.setUpdateNeeded();
for(PMDSkinMesh skinMesh : skinTargets) {
// skinMesh.clearBuffer(Type.Position);
// skinMesh.clearBuffer(Type.Normal);
skinMesh.setBuffer(skinTargets[0].getSkinvb2());
- skinMesh.setBuffer(skinTargets[0].getSkinnb2());
+// skinMesh.setBuffer(skinTargets[0].getSkinnb2());
}
skinTargets[0].skinvb2 = vb;
- skinTargets[0].skinnb2 = nb;
+// skinTargets[0].skinnb2 = nb;
vb = skinTargets[0].getBuffer(VertexBuffer.Type.Position);
- nb = skinTargets[0].getBuffer(VertexBuffer.Type.Normal);
+// nb = skinTargets[0].getBuffer(VertexBuffer.Type.Normal);
vb.setUpdateNeeded();
- nb.setUpdateNeeded();
+// nb.setUpdateNeeded();
}
private void softwareSkinUpdate(PMDMesh mesh){
int maxWeightsPerVert = 2;//mesh.getMaxNumWeights();
PMDSkinMesh skinMesh = skinTargets[0];
VertexBuffer vb = skinMesh.getSkinvb2(); //.getBuffer(Type.Position);
FloatBuffer fvb = (FloatBuffer) vb.getData();
- VertexBuffer nb = skinMesh.getSkinnb2(); //skinMesh.getBuffer(Type.Normal);
- FloatBuffer fnb = (FloatBuffer) nb.getData();
-
- for(int i=skinPosArray.length-1;i>=0;i--) {
- skinPosArray[i].set(skinPosArrayOrig[i]);
- }
+ fvb.position(0);
+// float[] floatBuf = skinPosBuffer.array();
+ int length = fvb.capacity();
+// for(int i=0;i<length;i++) {
+// fvb.put(floatBuf[i]);
+// }
+ projectkyoto.jme3.mmd.nativelib.SkinUtil.copy(skinPosBuffer, fvb, fvb.limit() * 4);
for (Skin skin : skinArray) {
if (true || skin.isUpdateNeeded()) {
- if (skin.getWeight() != 0f) {
- for (PMDSkinVertData svd : skin.getSkinData().getSkinVertData()) {
- javax.vecmath.Vector3f dist = skinPosArray[svd.getSkinVertIndex()];
- dist.set(svd.getSkinVertPos());
- dist.scale(skin.getWeight());
- dist.add(skinPosArrayOrig[svd.getSkinVertIndex()]);
- }
+ float weight = skin.getWeight();
+ if (weight != 0f) {
+// for (PMDSkinVertData svd : skin.getSkinData().getSkinVertData()) {
+// javax.vecmath.Vector3f svp = svd.getSkinVertPos();
+// javax.vecmath.Vector3f svop = skinPosArrayOrig[svd.getSkinVertIndex()];
+// fvb.position(svd.getSkinVertIndex() * 3);
+// fvb.put(svp.x*weight+svop.x).put(svp.y*weight+svop.y).put(svp.z*weight+svop.z);
+// }
+ projectkyoto.jme3.mmd.nativelib.SkinUtil.setSkin(fvb, skin.getIndexBuf(), skin.getSkinBuf(), weight);
+
}
skin.setUpdateNeeded(false);
}
}
- fvb.position(0);
- fnb.position(0);
- TempVars vars = TempVars.get();
- for (int i = 0; i < skinPosArray.length; i++) {
- int idxWeights = 0;
-
- float[] posBuf = vars.skinPositions;
- float[] normBuf = vars.skinNormals;
-
- // read next set of positions and normals from native buffer
- int idxPositions = 0;
-
- // iterate vertices and apply skinning transform for each effecting bone
- float nmx = skinNormalArray[i].x;//normBuf[idxPositions];
- float vtx = skinPosArray[i].x;//posBuf[idxPositions++];
- float nmy = skinNormalArray[i].y;//normBuf[idxPositions];
- float vty = skinPosArray[i].y;//posBuf[idxPositions++];
- float nmz = skinNormalArray[i].z;//normBuf[idxPositions];
- float vtz = skinPosArray[i].z;//posBuf[idxPositions++];
-
- float rx = 0, ry = 0, rz = 0, rnx = 0, rny = 0, rnz = 0;
-
- for (int w = 2 - 1; w >= 0; w--) {
- float weight = skinBoneWeightArray[i];//(float) v.getBoneWeight();//weights[idxWeights];
- if (w == 1) {
- weight = 1f - weight;
- }
- //weight = weight / 100f;
-
- Matrix4f mat = offsetMatrices[skinBoneArray[i * 2 + w]];
-
- rx += (mat.m00 * vtx + mat.m01 * vty + mat.m02 * vtz + mat.m03) * weight;
- ry += (mat.m10 * vtx + mat.m11 * vty + mat.m12 * vtz + mat.m13) * weight;
- rz += (mat.m20 * vtx + mat.m21 * vty + mat.m22 * vtz + mat.m23) * weight;
-
- rnx += (nmx * mat.m00 + nmy * mat.m01 + nmz * mat.m02) * weight;
- rny += (nmx * mat.m10 + nmy * mat.m11 + nmz * mat.m12) * weight;
- rnz += (nmx * mat.m20 + nmy * mat.m21 + nmz * mat.m22) * weight;
- }
-
- fnb.put(rnx).put(rny).put(rnz);
- fvb.put(rx).put(ry).put(rz);
- }
- vars.release();
vb.setUpdateNeeded();
- nb.setUpdateNeeded();
+// nb.setUpdateNeeded();
skinUpdateNeeded = false;
}
- void updateSkinMesh(PMDSkinMesh skinMesh) {
- VertexBuffer vb = skinMesh.getBuffer(Type.Position);
- FloatBuffer fvb = (FloatBuffer) vb.getData();
- VertexBuffer nb = skinMesh.getBuffer(Type.Normal);
- FloatBuffer fnb = (FloatBuffer) nb.getData();
-
- for (Skin skin : skinArray) {
- if (skin.isUpdateNeeded()) {
- if (skin.getWeight() != 1f) {
- for (PMDSkinVertData svd : skin.getSkinData().getSkinVertData()) {
- javax.vecmath.Vector3f dist = skinPosArray[svd.getSkinVertIndex()];
- dist.set(svd.getSkinVertPos());
- dist.scale(skin.getWeight());
- dist.add(skinPosArrayOrig[svd.getSkinVertIndex()]);
- }
- }
- skin.setUpdateNeeded(false);
- }
- }
-
- fvb.position(0);
- fnb.position(0);
- TempVars vars = TempVars.get();
- for (int i = 0; i < skinPosArray.length; i++) {
- int idxWeights = 0;
-
- float[] posBuf = vars.skinPositions;
- float[] normBuf = vars.skinNormals;
-
- // read next set of positions and normals from native buffer
- int idxPositions = 0;
-
- // iterate vertices and apply skinning transform for each effecting bone
- float nmx = skinNormalArray[i].x;//normBuf[idxPositions];
- float vtx = skinPosArray[i].x;//posBuf[idxPositions++];
- float nmy = skinNormalArray[i].y;//normBuf[idxPositions];
- float vty = skinPosArray[i].y;//posBuf[idxPositions++];
- float nmz = skinNormalArray[i].z;//normBuf[idxPositions];
- float vtz = skinPosArray[i].z;//posBuf[idxPositions++];
-
- float rx = 0, ry = 0, rz = 0, rnx = 0, rny = 0, rnz = 0;
-
- for (int w = 2 - 1; w >= 0; w--) {
- float weight = skinBoneWeightArray[i];//(float) v.getBoneWeight();//weights[idxWeights];
- if (w == 1) {
- weight = 1f - weight;
- }
- //weight = weight / 100f;
-
- Matrix4f mat = offsetMatrices[skinBoneArray[i * 2 + w]];
-
- rx += (mat.m00 * vtx + mat.m01 * vty + mat.m02 * vtz + mat.m03) * weight;
- ry += (mat.m10 * vtx + mat.m11 * vty + mat.m12 * vtz + mat.m13) * weight;
- rz += (mat.m20 * vtx + mat.m21 * vty + mat.m22 * vtz + mat.m23) * weight;
-
- rnx += (nmx * mat.m00 + nmy * mat.m01 + nmz * mat.m02) * weight;
- rny += (nmx * mat.m10 + nmy * mat.m11 + nmz * mat.m12) * weight;
- rnz += (nmx * mat.m20 + nmy * mat.m21 + nmz * mat.m22) * weight;
- }
-
- fnb.put(rnx).put(rny).put(rnz);
- fvb.put(rx).put(ry).put(rz);
- }
- vars.release();
- vb.setUpdateNeeded();
- nb.setUpdateNeeded();
- }
public void resetToBind() {
for (int i = 0; i < skeleton.getBoneCount(); i++) {
skinMesh.setSkinvb2(skinMesh0.getSkinvb2());
skinMesh.setBuffer(skinMesh0.getBuffer(Type.Normal));
skinMesh.setSkinnb2(skinMesh0.getSkinnb2());
- skinMesh.setBuffer(skinMesh0.getBuffer(Type.TexCoord));
+ if (skinMesh0.getBuffer(Type.TexCoord) != null)
+ skinMesh.setBuffer(skinMesh0.getBuffer(Type.TexCoord));
} else {
PMDSkinMesh skinMesh = (PMDSkinMesh)mesh;
PMDSkinMesh skinMesh0 = skinTargets[0];
skinMesh.setBuffer(skinMesh0.getBuffer(Type.Position).clone());
skinMesh.setSkinvb2(skinMesh0.getSkinvb2().clone());
- skinMesh.setBuffer(skinMesh0.getBuffer(Type.Normal).clone());
- skinMesh.setSkinnb2(skinMesh0.getSkinnb2().clone());
- skinMesh.setBuffer(skinMesh0.getBuffer(Type.TexCoord));
+ skinMesh.setBuffer(skinMesh0.getBuffer(Type.Normal));
+ skinMesh.setSkinnb2(skinMesh0.getSkinnb2());
+ if (skinMesh0.getBuffer(Type.TexCoord) != null)
+ skinMesh.setBuffer(skinMesh0.getBuffer(Type.TexCoord));
}
newPMDNode.skinTargets[skinMeshCount++] = (PMDSkinMesh)mesh;
}
newPMDNode.skinMap.put(skinName, skin);
}
newPMDNode.skinArray = newPMDNode.skinMap.values().toArray(new Skin[newPMDNode.skinMap.size()]);
- newPMDNode.skinPosArray = new javax.vecmath.Vector3f[skinPosArray.length];
- for(int i=0;i<skinPosArray.length;i++) {
- newPMDNode.skinPosArray[i] = new javax.vecmath.Vector3f(skinPosArray[i]);
- }
- newPMDNode.skinNormalArray = new javax.vecmath.Vector3f[skinNormalArray.length];
- for(int i=0;i<skinNormalArray.length;i++) {
- newPMDNode.skinNormalArray[i] = new javax.vecmath.Vector3f(skinNormalArray[i]);
- }
+// newPMDNode.skinPosArray = new javax.vecmath.Vector3f[skinPosArray.length];
+// for(int i=0;i<skinPosArray.length;i++) {
+// newPMDNode.skinPosArray[i] = new javax.vecmath.Vector3f(skinPosArray[i]);
+// }
+// newPMDNode.skinNormalArray = new javax.vecmath.Vector3f[skinNormalArray.length];
+// for(int i=0;i<skinNormalArray.length;i++) {
+// newPMDNode.skinNormalArray[i] = new javax.vecmath.Vector3f(skinNormalArray[i]);
+// }
// newPMDNode.offsetMatrices = new Matrix4f[offsetMatrices.length];
// newPMDNode.setGlslSkinning(newPMDNode.glslSkinning);
newPMDNode.skeleton.updateWorldVectors();