Fixed XML Parser & animation engine

Author: andresoviedo

README.md

@@ -4,15 +4,15 @@ Android 3D Model Viewer
 ![codeship badge](https://codeship.com/projects/52cf9560-deb2-0134-4203-2aaddef843aa/status?branch=master)
 
 This is a demo of OpenGL ES 2.0.
-It is basically an android application with a 3D renderer that can load Wavefront Obj, STL files & Collada files.
+It is basically an android application with a 3D engine that can load Wavefront OBJ, STL & DAE files.
 The purpose of this application is to learn and share how to draw using OpenGL language.
 
-
 * Wafefront format (OBJ): https://en.wikipedia.org/wiki/Wavefront_.obj_file
 * STereoLithography format (STL): https://en.wikipedia.org/wiki/STL_(file_format)
 * Collada format (DAE): https://en.wikipedia.org/wiki/COLLADA
 
-News (08/12/2017)
+
+News (17/12/2017)
 =================
 
 * Support for collada files with skeletal animations :)
@@ -70,8 +70,7 @@ Features
     - rotate with 2 fingers to rotate camera
     - pinch & spread to zoom in/out the camera
   - skeletal animations
-  - moving of objects (not yet!)
-  - primitive collision detection (not yet!)
+
 
 Try it
 ======
@@ -101,6 +100,8 @@ Screenshot
 ![Screenshot5](screenshots/screenshot5.png)
 ![Screenshot6](screenshots/screenshot6.png)
 ![Screenshot7](screenshots/screenshot7.png)
+![cowboy.gif](screenshots/cowboy.gif)
+![stormtrooper.gif](screenshots/stormtrooper.gif)
 
 
 Final Notes
@@ -121,6 +122,11 @@ ChangeLog
 
 (f) fixed, (i) improved, (n) new feature
 
+- 2.0.2 (17/12/2017)
+  - (f) Collada XML parser is now android's XmlPullParser
+  - (f) Animation engine frame times improved
+  - (n) Camera now moves smoothly
+
 - 2.0.1 (08/12/2017)
   - (f) Multiple Collada parser fixes
   - (f) Camera now can look inside objects

app/build/outputs/apk/app-release.apk

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="org.andresoviedo.dddmodel2"
-    android:versionCode="15"
-    android:versionName="2.0.1" >
+    android:versionCode="16"
+    android:versionName="2.0.2" >
 
     <uses-sdk
         android:minSdkVersion="8"

app/src/main/AndroidManifest.xml

@@ -15,6 +15,7 @@ public class Animation {
 
 	private final float length;//in seconds
 	private final KeyFrame[] keyFrames;
+	private boolean initialized;
 
 	/**
 	 * @param lengthInSeconds
@@ -28,6 +29,14 @@ public Animation(float lengthInSeconds, KeyFrame[] frames) {
 		this.length = lengthInSeconds;
 	}
 
+	public void setInitialized(boolean initialized){
+		this.initialized = initialized;
+	}
+
+	public boolean isInitialized(){
+		return initialized;
+	}
+
 	/**
 	 * @return The length of the animation in seconds.
 	 */

app/src/main/java/org/andresoviedo/app/model3D/animation/Animation.java

@@ -1,5 +1,6 @@
 package org.andresoviedo.app.model3D.animation;
 
+import android.animation.Keyframe;
 import android.opengl.Matrix;
 import android.os.SystemClock;
 import android.util.Log;
@@ -57,13 +58,50 @@ public void update(Object3DData obj) {
 		AnimatedModel animatedModel = (AnimatedModel)obj;
 		if (animatedModel.getAnimation() == null) return;
 
+		initAnimation(animatedModel);
+
 		increaseAnimationTime((AnimatedModel)obj);
 		Map<String, float[]> currentPose = calculateCurrentAnimationPose(animatedModel);
 		float parentTransform[] = new float[16];
 		Matrix.setIdentityM(parentTransform,0);
 		applyPoseToJoints(currentPose, (animatedModel).getRootJoint(), parentTransform);
 	}
 
+	private void initAnimation(AnimatedModel animatedModel) {
+		if (animatedModel.getAnimation().isInitialized()) {
+			return;
+		}
+		KeyFrame[] keyFrames = animatedModel.getAnimation().getKeyFrames();
+		Log.i("Animator", "Initializing " + animatedModel.getId() + ". " + keyFrames.length + " key frames...");
+		for (int i = 0; i < keyFrames.length; i++) {
+			int j = (i + 1) % keyFrames.length;
+			KeyFrame keyFramePrevious = keyFrames[i];
+			KeyFrame keyFrameNext = keyFrames[j];
+			Map<String, JointTransform> jointTransforms = keyFramePrevious.getJointKeyFrames();
+			for (Map.Entry<String, JointTransform> transform : jointTransforms.entrySet()) {
+				String jointId = transform.getKey();
+				if (keyFrameNext.getJointKeyFrames().containsKey(jointId)) {
+					continue;
+				}
+				JointTransform keyFramePreviousTransform = keyFramePrevious.getJointKeyFrames().get(jointId);
+				JointTransform keyFrameNextTransform = null;
+				KeyFrame keyFrameNextNext = null;
+				int k = (j + 1) % keyFrames.length;
+				do {
+					keyFrameNextNext = keyFrames[k];
+					keyFrameNextTransform = keyFrameNextNext.getJointKeyFrames().get(jointId);
+					k = (k + 1) % keyFrames.length;
+				} while (keyFrameNextTransform == null);
+				this.animationTime = keyFrameNext.getTimeStamp();
+				float progression = calculateProgression(keyFramePrevious, keyFrameNextNext);
+				JointTransform missingFrameTransform = JointTransform.interpolate(keyFramePreviousTransform, keyFrameNextTransform, progression);
+				keyFrameNext.getJointKeyFrames().put(jointId, missingFrameTransform);
+			}
+		}
+		animatedModel.getAnimation().setInitialized(true);
+		Log.i("Animator", "Initialized " + animatedModel.getId() + ". " + keyFrames.length + " key frames");
+	}
+
 	/**
 	 * Increases the current animation time which allows the animation to
 	 * progress. If the current animation has reached the end then the timer is

app/src/main/java/org/andresoviedo/app/model3D/animation/Animator.java

@@ -45,7 +45,8 @@ public class Camera {
 
 	float[] matrix = new float[16];
 	float[] buffer = new float[12 + 12 + 16 + 16];
-	float[] buffer4x3 = new float[12];
+	private long animationCounter;
+	private Object[] lastAction;
 	private boolean changed = false;
 
 	public Camera() {
@@ -74,6 +75,24 @@ public void setScene(SceneLoader scene) {
 		this.scene = scene;
 	}
 
+	public void animate(){
+		if (lastAction == null || animationCounter == 0){
+			lastAction = null;
+			animationCounter = 100;
+			return;
+		}
+		String method = (String) lastAction[0];
+		if (method.equals("translate")){
+			float dX = (Float) lastAction[1];
+			float dY = (Float) lastAction[2];
+			translateCameraImpl(dX*animationCounter/100, dY*animationCounter/100);
+		} else if (method.equals("rotate")){
+			float rotZ = (Float)lastAction[1];
+			RotateImpl(rotZ/100*animationCounter);
+		}
+		animationCounter--;
+	}
+
 	private void normalize() {
 		float xLook = 0, yLook = 0, zLook = 0;
 		float xRight = 0, yRight = 0, zRight = 0;
@@ -123,7 +142,12 @@ private void normalize() {
 		zUp = zArriba + zPos;
 	}
 
-	public void MoveCameraZ(float direction) {
+	public void MoveCameraZ(float direction){
+		if (direction == 0) return;
+		MoveCameraZImpl(direction);
+		lastAction = new Object[]{"zoom",direction};
+	}
+	public void MoveCameraZImpl(float direction) {
 		// Moving the camera requires a little more then adding 1 to the z or
 		// subracting 1.
 		// First we need to get the direction at which we are looking.
@@ -400,6 +424,13 @@ void RotateByMouse(float mousePosX, float mousePosY, float midX, float midY) {
 	 * @param dY the Y component of the user 2D vector, that is, a value between [-1,1]
 	 */
 	public void translateCamera(float dX, float dY) {
+		Log.d("Camera","translate:"+dX+","+dY);
+		if (dX == 0 && dY == 0) return;
+		translateCameraImpl(dX, dY);
+		lastAction = new Object[]{"translate",dX, dY};
+	}
+
+	public void translateCameraImpl(float dX, float dY) {
 		float vlen;
 
 		// Translating the camera requires a directional vector to rotate
@@ -581,6 +612,12 @@ public String toString() {
 	}
 
 	public void Rotate(float rotViewerZ) {
+		if (rotViewerZ == 0) return;
+		RotateImpl(rotViewerZ);
+		lastAction = new Object[]{"rotate",rotViewerZ};
+	}
+
+	public void RotateImpl(float rotViewerZ) {
 		if (Float.isNaN(rotViewerZ)) {
 			Log.w("Rot", "NaN");
 			return;