Kirill Vainer
7 years ago
commit
5108f52ebf
@ -0,0 +1,41 @@ |
|||||||
|
package com.jme3.export.binary; |
||||||
|
|
||||||
|
import com.jme3.asset.AssetInfo; |
||||||
|
import com.jme3.asset.AssetLoader; |
||||||
|
|
||||||
|
import java.io.IOException; |
||||||
|
import java.util.ArrayDeque; |
||||||
|
import java.util.Deque; |
||||||
|
|
||||||
|
/** |
||||||
|
* The default loader to load binaries files. |
||||||
|
* |
||||||
|
* @author JavaSaBr |
||||||
|
*/ |
||||||
|
public class BinaryLoader implements AssetLoader { |
||||||
|
|
||||||
|
/** |
||||||
|
* The importers queue. |
||||||
|
*/ |
||||||
|
private final Deque<BinaryImporter> importers; |
||||||
|
|
||||||
|
public BinaryLoader() { |
||||||
|
importers = new ArrayDeque<>(); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public Object load(final AssetInfo assetInfo) throws IOException { |
||||||
|
|
||||||
|
BinaryImporter importer = importers.pollLast(); |
||||||
|
|
||||||
|
if (importer == null) { |
||||||
|
importer = new BinaryImporter(); |
||||||
|
} |
||||||
|
|
||||||
|
try { |
||||||
|
return importer.load(assetInfo); |
||||||
|
} finally { |
||||||
|
importers.addLast(importer); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,296 @@ |
|||||||
|
package com.jme3.scene.plugins.gltf; |
||||||
|
|
||||||
|
import com.jme3.math.*; |
||||||
|
|
||||||
|
import java.util.*; |
||||||
|
|
||||||
|
public class AnimData { |
||||||
|
|
||||||
|
public enum Type { |
||||||
|
Translation, |
||||||
|
Rotation, |
||||||
|
Scale |
||||||
|
} |
||||||
|
|
||||||
|
Float length; |
||||||
|
float[] times; |
||||||
|
List<TimeData> timeArrays = new ArrayList<>(); |
||||||
|
|
||||||
|
|
||||||
|
Vector3f[] translations; |
||||||
|
Quaternion[] rotations; |
||||||
|
Vector3f[] scales; |
||||||
|
//not used for now
|
||||||
|
float[] weights; |
||||||
|
|
||||||
|
public void update() { |
||||||
|
|
||||||
|
if (equalTimes(timeArrays)) { |
||||||
|
times = timeArrays.get(0).times; |
||||||
|
ensureArraysInit(); |
||||||
|
} else { |
||||||
|
//Times array are different and contains different sampling times.
|
||||||
|
//We have to merge them because JME needs the 3 types of transforms for each keyFrame.
|
||||||
|
|
||||||
|
//extracting keyframes information
|
||||||
|
List<KeyFrame> keyFrames = new ArrayList<>(); |
||||||
|
TimeData timeData = timeArrays.get(0); |
||||||
|
Type type = timeData.type; |
||||||
|
for (int i = 0; i < timeData.times.length; i++) { |
||||||
|
float time = timeData.times[i]; |
||||||
|
KeyFrame keyFrame = new KeyFrame(); |
||||||
|
keyFrame.time = time; |
||||||
|
setKeyFrameTransforms(type, keyFrame, timeData.times); |
||||||
|
keyFrames.add(keyFrame); |
||||||
|
} |
||||||
|
|
||||||
|
for (int i = 1; i < timeArrays.size(); i++) { |
||||||
|
timeData = timeArrays.get(i); |
||||||
|
type = timeData.type; |
||||||
|
for (float time : timeData.times) { |
||||||
|
for (int j = 0; j < keyFrames.size(); j++) { |
||||||
|
KeyFrame kf = keyFrames.get(j); |
||||||
|
if (Float.floatToIntBits(kf.time) != Float.floatToIntBits(time)) { |
||||||
|
if (time > kf.time) { |
||||||
|
continue; |
||||||
|
} else { |
||||||
|
kf = new KeyFrame(); |
||||||
|
kf.time = time; |
||||||
|
keyFrames.add(j, kf); |
||||||
|
//we inserted a keyframe let's shift the counter.
|
||||||
|
j++; |
||||||
|
} |
||||||
|
} |
||||||
|
setKeyFrameTransforms(type, kf, timeData.times); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
// populating transforms array from the keyframes, interpolating
|
||||||
|
times = new float[keyFrames.size()]; |
||||||
|
|
||||||
|
ensureArraysInit(); |
||||||
|
|
||||||
|
TransformIndices translationIndices = new TransformIndices(); |
||||||
|
TransformIndices rotationIndices = new TransformIndices(); |
||||||
|
TransformIndices scaleIndices = new TransformIndices(); |
||||||
|
|
||||||
|
for (int i = 0; i < keyFrames.size(); i++) { |
||||||
|
KeyFrame kf = keyFrames.get(i); |
||||||
|
//we need Interpolate between keyframes when transforms are sparse.
|
||||||
|
times[i] = kf.time; |
||||||
|
populateTransform(Type.Translation, i, keyFrames, kf, translationIndices); |
||||||
|
populateTransform(Type.Rotation, i, keyFrames, kf, rotationIndices); |
||||||
|
populateTransform(Type.Scale, i, keyFrames, kf, scaleIndices); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
ensureArraysInit(); |
||||||
|
|
||||||
|
if (times[0] > 0) { |
||||||
|
//Anim doesn't start at 0, JME can't handle that and will interpolate transforms linearly from 0 to the first frame of the anim.
|
||||||
|
//we need to add a frame at 0 that copies the first real frame
|
||||||
|
|
||||||
|
float[] newTimes = new float[times.length + 1]; |
||||||
|
newTimes[0] = 0f; |
||||||
|
System.arraycopy(times, 0, newTimes, 1, times.length); |
||||||
|
times = newTimes; |
||||||
|
|
||||||
|
if (translations != null) { |
||||||
|
Vector3f[] newTranslations = new Vector3f[translations.length + 1]; |
||||||
|
newTranslations[0] = translations[0]; |
||||||
|
System.arraycopy(translations, 0, newTranslations, 1, translations.length); |
||||||
|
translations = newTranslations; |
||||||
|
} |
||||||
|
if (rotations != null) { |
||||||
|
Quaternion[] newRotations = new Quaternion[rotations.length + 1]; |
||||||
|
newRotations[0] = rotations[0]; |
||||||
|
System.arraycopy(rotations, 0, newRotations, 1, rotations.length); |
||||||
|
rotations = newRotations; |
||||||
|
} |
||||||
|
if (scales != null) { |
||||||
|
Vector3f[] newScales = new Vector3f[scales.length + 1]; |
||||||
|
newScales[0] = scales[0]; |
||||||
|
System.arraycopy(scales, 0, newScales, 1, scales.length); |
||||||
|
scales = newScales; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
length = times[times.length - 1]; |
||||||
|
} |
||||||
|
|
||||||
|
private void populateTransform(Type type, int index, List<KeyFrame> keyFrames, KeyFrame currentKeyFrame, TransformIndices transformIndices) { |
||||||
|
Object transform = getTransform(type, currentKeyFrame); |
||||||
|
if (transform != null) { |
||||||
|
getArray(type)[index] = transform; |
||||||
|
transformIndices.last = index; |
||||||
|
} else { |
||||||
|
transformIndices.next = findNext(keyFrames, type, index); |
||||||
|
if (transformIndices.next == -1) { |
||||||
|
//no next let's use prev value.
|
||||||
|
if (transformIndices.last == -1) { |
||||||
|
//last Transform Index = -1 it means there are no transforms. nothing more to do
|
||||||
|
return; |
||||||
|
} |
||||||
|
KeyFrame lastKeyFrame = keyFrames.get(transformIndices.last); |
||||||
|
getArray(type)[index] = getTransform(type, lastKeyFrame); |
||||||
|
return; |
||||||
|
} |
||||||
|
KeyFrame nextKeyFrame = keyFrames.get(transformIndices.next); |
||||||
|
if (transformIndices.last == -1) { |
||||||
|
//no previous transforms let's use the new one.
|
||||||
|
translations[index] = nextKeyFrame.translation; |
||||||
|
} else { |
||||||
|
//interpolation between the previous transform and the next one.
|
||||||
|
KeyFrame lastKeyFrame = keyFrames.get(transformIndices.last); |
||||||
|
float ratio = currentKeyFrame.time / (nextKeyFrame.time - lastKeyFrame.time); |
||||||
|
interpolate(type, ratio, lastKeyFrame, nextKeyFrame, index); |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private int findNext(List<KeyFrame> keyFrames, Type type, int fromIndex) { |
||||||
|
for (int i = fromIndex + 1; i < keyFrames.size(); i++) { |
||||||
|
KeyFrame kf = keyFrames.get(i); |
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
if (kf.translation != null) { |
||||||
|
return i; |
||||||
|
} |
||||||
|
break; |
||||||
|
case Rotation: |
||||||
|
if (kf.rotation != null) { |
||||||
|
return i; |
||||||
|
} |
||||||
|
break; |
||||||
|
case Scale: |
||||||
|
if (kf.scale != null) { |
||||||
|
return i; |
||||||
|
} |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
private void interpolate(Type type, float ratio, KeyFrame lastKeyFrame, KeyFrame nextKeyFrame, int currentIndex) { |
||||||
|
//TODO here we should interpolate differently according to the interpolation given in the gltf file.
|
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
translations[currentIndex] = FastMath.interpolateLinear(ratio, lastKeyFrame.translation, nextKeyFrame.translation); |
||||||
|
break; |
||||||
|
case Rotation: |
||||||
|
Quaternion rot = new Quaternion().set(lastKeyFrame.rotation); |
||||||
|
rot.nlerp(nextKeyFrame.rotation, ratio); |
||||||
|
rotations[currentIndex] = rot; |
||||||
|
break; |
||||||
|
case Scale: |
||||||
|
scales[currentIndex] = FastMath.interpolateLinear(ratio, lastKeyFrame.scale, nextKeyFrame.scale); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private Object[] getArray(Type type) { |
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
return translations; |
||||||
|
case Rotation: |
||||||
|
return rotations; |
||||||
|
case Scale: |
||||||
|
return scales; |
||||||
|
default: |
||||||
|
return translations; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private Object getTransform(Type type, KeyFrame kf) { |
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
return kf.translation; |
||||||
|
case Rotation: |
||||||
|
return kf.rotation; |
||||||
|
case Scale: |
||||||
|
return kf.scale; |
||||||
|
default: |
||||||
|
return kf.translation; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private void ensureArraysInit() { |
||||||
|
if (translations == null || translations.length < times.length) { |
||||||
|
translations = new Vector3f[times.length]; |
||||||
|
for (int i = 0; i < translations.length; i++) { |
||||||
|
translations[i] = new Vector3f(); |
||||||
|
} |
||||||
|
} |
||||||
|
if (rotations == null || rotations.length < times.length) { |
||||||
|
rotations = new Quaternion[times.length]; |
||||||
|
for (int i = 0; i < rotations.length; i++) { |
||||||
|
rotations[i] = new Quaternion(); |
||||||
|
} |
||||||
|
} |
||||||
|
if (scales == null || scales.length < times.length) { |
||||||
|
scales = new Vector3f[times.length]; |
||||||
|
for (int i = 0; i < scales.length; i++) { |
||||||
|
scales[i] = new Vector3f().set(Vector3f.UNIT_XYZ); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private void setKeyFrameTransforms(Type type, KeyFrame keyFrame, float[] transformTimes) { |
||||||
|
int index = 0; |
||||||
|
while (Float.floatToIntBits(transformTimes[index]) != Float.floatToIntBits(keyFrame.time)) { |
||||||
|
index++; |
||||||
|
} |
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
keyFrame.translation = translations[index]; |
||||||
|
break; |
||||||
|
case Rotation: |
||||||
|
keyFrame.rotation = rotations[index]; |
||||||
|
break; |
||||||
|
case Scale: |
||||||
|
keyFrame.scale = scales[index]; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private boolean equalTimes(List<TimeData> timeData) { |
||||||
|
if (timeData.size() == 1) { |
||||||
|
return true; |
||||||
|
} |
||||||
|
float[] times0 = timeData.get(0).times; |
||||||
|
for (int i = 1; i < timeData.size(); i++) { |
||||||
|
float[] timesI = timeData.get(i).times; |
||||||
|
if (!Arrays.equals(times0, timesI)) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
static class TimeData { |
||||||
|
|
||||||
|
float[] times; |
||||||
|
Type type; |
||||||
|
|
||||||
|
public TimeData(float[] times, Type type) { |
||||||
|
this.times = times; |
||||||
|
this.type = type; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private class TransformIndices { |
||||||
|
int last = -1; |
||||||
|
int next = -1; |
||||||
|
} |
||||||
|
|
||||||
|
private class KeyFrame { |
||||||
|
float time; |
||||||
|
Vector3f translation; |
||||||
|
Quaternion rotation; |
||||||
|
Vector3f scale; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
Loading…
Reference in new issue