2.7.0 - lighting + bug fixing

Author: andresoviedo

README.md

@@ -13,11 +13,13 @@ The application does not use any third party library.
 * Collada format (DAE): https://en.wikipedia.org/wiki/COLLADA
 
 
-News (06/11/2019)
+News (13/11/2019)
 =================
 
-* Fix: Shader lightning fixed !
-* Fix: Better support for multiple geometries
+* New: version 2.7.0
+* Fix: Shader lighting improved !
+* Fix: Better support for Collada files
+* Fix: Performance issues fixed
 * Fix: Bugs fixed
 
 
@@ -60,10 +62,8 @@ The app comes with some included 3D models that were taken for free from Interne
 Whats next
 ==========
 
-* Blender support
 * 3D without glasses
 * Augmented reality
-* Improve overall performance
 
 
 Features
@@ -179,9 +179,12 @@ ChangeLog
 
 (f) fixed, (i) improved, (n) new feature
 
-- 2.6.1 (06/10/2019)
-  - (f) fixed light rendering issues on shaders #125
+- 2.7.0 (13/11/2019)
+  - (n) new blending force mode to 50% 
+  - (f) fixed light rendering issues on shaders #125 (diffuse + specular)
   - (f) fixed bugs when DAE had multiple geometries #125
+  - (f) fixed textures not being linked issue
+  - (f) fixed performance issues: now rendering below 5% cpu & no ram allocation
 - 2.6.0 (20/10/2019)
   - (n) #81 Support for collada files with multiple geometries
   - (f) #94 fixed setVisible(boolean)

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

@@ -3,7 +3,7 @@
           xmlns:tools="http://schemas.android.com/tools"
     package="org.andresoviedo.dddmodel2"
     android:versionCode="23"
-    android:versionName="2.6.1" >
+    android:versionName="2.7.0" >
 
     <uses-sdk
         android:minSdkVersion="14"

app/src/main/AndroidManifest.xml

@@ -56,6 +56,10 @@ public class SceneLoader implements LoaderTask.Callback {
      * Enable or disable blending (transparency)
      */
     private boolean isBlendingEnabled = true;
+    /**
+     * Force transparency
+     */
+    private boolean isBlendingForced = false;
     /**
      * Whether to draw objects as wireframes
      */
@@ -71,7 +75,7 @@ public class SceneLoader implements LoaderTask.Callback {
     /**
      * Whether to draw face normals. Normally used to debug models
      */
-    // TODO: toggle feature normals + blending
+    // TODO: toggle feature this
     private boolean drawNormals = false;
     /**
      * Whether to draw using textures
@@ -401,14 +405,29 @@ public boolean isAnaglyph() {
     }
 
     public void toggleBlending() {
-        this.isBlendingEnabled = !isBlendingEnabled;
-        makeToastText("Blending "+isBlendingEnabled, Toast.LENGTH_SHORT);
+        if (this.isBlendingEnabled && !this.isBlendingForced){
+            makeToastText("Blending forced", Toast.LENGTH_SHORT);
+            this.isBlendingEnabled = true;
+            this.isBlendingForced = true;
+        } else if (this.isBlendingForced){
+            makeToastText("Blending disabled", Toast.LENGTH_SHORT);
+            this.isBlendingEnabled = false;
+            this.isBlendingForced = false;
+        } else {
+            makeToastText("Blending enabled", Toast.LENGTH_SHORT);
+            this.isBlendingEnabled = true;
+            this.isBlendingForced = false;
+        }
     }
 
     public boolean isBlendingEnabled() {
         return isBlendingEnabled;
     }
 
+    public boolean isBlendingForced() {
+        return isBlendingForced;
+    }
+
     @Override
     public void onStart(){
         ContentUtils.setThreadActivity(parent);

app/src/main/java/org/andresoviedo/app/model3D/demo/SceneLoader.java

@@ -27,6 +27,10 @@
 public class ModelRenderer implements GLSurfaceView.Renderer {
 
 	private final static String TAG = ModelRenderer.class.getName();
+    /**
+     * Add 0.5f to the alpha component to the global shader so we can see through the skin
+     */
+	private static final float[] BLENDING_FORCED_MASK_COLOR = {1.0f, 1.0f, 1.0f, 0.5f};
 	// frustrum - nearest pixel
 	private static final float near = 1f;
 	// frustrum - fartest pixel
@@ -67,7 +71,8 @@ public class ModelRenderer implements GLSurfaceView.Renderer {
 	private final float[] modelViewMatrix = new float[16];
 	private final float[] projectionMatrix = new float[16];
 	private final float[] viewProjectionMatrix = new float[16];
-	private final float[] lightPosInEyeSpace = new float[4];
+	private final float[] lightPosInWorldSpace = new float[4];
+    private final float[] cameraPosInWorldSpace = new float[3];
 
 	// 3D stereoscopic matrix (left & right camera)
     private final float[] viewMatrixLeft = new float[16];
@@ -169,10 +174,14 @@ public void onDrawFrame(GL10 unused) {
 				return;
 			}
 
+			float[] colorMask = null;
 			if (scene.isBlendingEnabled()) {
 				// Enable blending for combining colors when there is transparency
 				GLES20.glEnable(GLES20.GL_BLEND);
 				GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_ALPHA);
+				if (scene.isBlendingForced()){
+					colorMask = BLENDING_FORCED_MASK_COLOR;
+				}
 			} else {
 				GLES20.glDisable(GLES20.GL_BLEND);
 			}
@@ -182,6 +191,9 @@ public void onDrawFrame(GL10 unused) {
 
 			// recalculate mvp matrix according to where we are looking at now
 			Camera camera = scene.getCamera();
+            cameraPosInWorldSpace[0]=camera.xPos;
+            cameraPosInWorldSpace[1]=camera.yPos;
+            cameraPosInWorldSpace[2]=camera.zPos;
 			if (camera.hasChanged()) {
 				// INFO: Set the camera position (View matrix)
 				// The camera has 3 vectors (the position, the vector where we are looking at, and the up position (sky)
@@ -228,19 +240,19 @@ public void onDrawFrame(GL10 unused) {
 
 
 			if (!scene.isStereoscopic()) {
-				this.onDrawFrame(viewMatrix, projectionMatrix, viewProjectionMatrix, lightPosInEyeSpace, null);
+				this.onDrawFrame(viewMatrix, projectionMatrix, viewProjectionMatrix, lightPosInWorldSpace, colorMask, cameraPosInWorldSpace);
 				return;
 			}
 
 
 			if (scene.isAnaglyph()) {
 				// INFO: switch because blending algorithm doesn't mix colors
 				if (anaglyphSwitch) {
-					this.onDrawFrame(viewMatrixLeft, projectionMatrixLeft, viewProjectionMatrixLeft, lightPosInEyeSpace,
-							COLOR_RED);
+					this.onDrawFrame(viewMatrixLeft, projectionMatrixLeft, viewProjectionMatrixLeft, lightPosInWorldSpace,
+							COLOR_RED, cameraPosInWorldSpace);
 				} else {
-					this.onDrawFrame(viewMatrixRight, projectionMatrixRight, viewProjectionMatrixRight, lightPosInEyeSpace,
-							COLOR_BLUE);
+					this.onDrawFrame(viewMatrixRight, projectionMatrixRight, viewProjectionMatrixRight, lightPosInWorldSpace,
+							COLOR_BLUE, cameraPosInWorldSpace);
 				}
 				anaglyphSwitch = !anaglyphSwitch;
 				return;
@@ -251,14 +263,14 @@ public void onDrawFrame(GL10 unused) {
 				// draw left eye image
 				GLES20.glViewport(0, 0, width / 2, height);
 				GLES20.glScissor(0, 0, width / 2, height);
-				this.onDrawFrame(viewMatrixLeft, projectionMatrixLeft, viewProjectionMatrixLeft, lightPosInEyeSpace,
-						null);
+				this.onDrawFrame(viewMatrixLeft, projectionMatrixLeft, viewProjectionMatrixLeft, lightPosInWorldSpace,
+						null, cameraPosInWorldSpace);
 
 				// draw right eye image
 				GLES20.glViewport(width / 2, 0, width / 2, height);
 				GLES20.glScissor(width / 2, 0, width / 2, height);
-				this.onDrawFrame(viewMatrixRight, projectionMatrixRight, viewProjectionMatrixRight, lightPosInEyeSpace,
-						null);
+				this.onDrawFrame(viewMatrixRight, projectionMatrixRight, viewProjectionMatrixRight, lightPosInWorldSpace,
+						null, cameraPosInWorldSpace);
 			}
 		}catch (Exception ex){
 			Log.e("ModelRenderer", "Fatal exception: "+ex.getMessage(), ex);
@@ -267,7 +279,7 @@ public void onDrawFrame(GL10 unused) {
 	}
 
 	private void onDrawFrame(float[] viewMatrix, float[] projectionMatrix, float[] viewProjectionMatrix,
-							float[] lightPosInEyeSpace, float[] colorMask) {
+							float[] lightPosInWorldSpace, float[] colorMask, float[] cameraPosInWorldSpace) {
 
 
 		SceneLoader scene = main.getModelActivity().getScene();
@@ -279,31 +291,32 @@ private void onDrawFrame(float[] viewMatrix, float[] projectionMatrix, float[] v
 
 			// Calculate position of the light in world space to support lighting
 			if (scene.isRotatingLight()) {
-				Matrix.multiplyMV(lightPosInEyeSpace, 0, scene.getLightBulb().getModelMatrix(), 0, scene.getLightPosition(), 0);
+				Matrix.multiplyMV(lightPosInWorldSpace, 0, scene.getLightBulb().getModelMatrix(), 0, scene.getLightPosition(), 0);
 				// Draw a point that represents the light bulb
-				lightBulbDrawer.draw(scene.getLightBulb(), projectionMatrix, viewMatrix, -1, lightPosInEyeSpace,
-						colorMask);
+				lightBulbDrawer.draw(scene.getLightBulb(), projectionMatrix, viewMatrix, -1, lightPosInWorldSpace,
+						colorMask, cameraPosInWorldSpace);
 			} else {
-				// FIXME: memory leak
-				lightPosInEyeSpace = new float[]{scene.getCamera().xPos,	scene.getCamera().yPos,
-						scene.getCamera().zPos, 0f};
+				lightPosInWorldSpace[0] = scene.getCamera().xPos;
+				lightPosInWorldSpace[1] = scene.getCamera().yPos;
+				lightPosInWorldSpace[2] = scene.getCamera().zPos;
+                lightPosInWorldSpace[3] = 0;
 			}
 
 			// FIXME: memory leak
 			if (scene.isDrawNormals()) {
-				lightBulbDrawer.draw(Object3DBuilder.buildLine(new float[]{lightPosInEyeSpace[0],
-								lightPosInEyeSpace[1], lightPosInEyeSpace[2], 0, 0, 0}), projectionMatrix,
+				lightBulbDrawer.draw(Object3DBuilder.buildLine(new float[]{lightPosInWorldSpace[0],
+								lightPosInWorldSpace[1], lightPosInWorldSpace[2], 0, 0, 0}), projectionMatrix,
 						viewMatrix, -1,
-						lightPosInEyeSpace,
-						colorMask);
+                        lightPosInWorldSpace,
+						colorMask, cameraPosInWorldSpace);
 			}
 		}
 
 		// draw axis
         if (scene.isDrawAxis()){
 			Object3D basicDrawer = drawer.getPointDrawer();
 			basicDrawer.draw(axis, projectionMatrix, viewMatrix, axis.getDrawMode(), axis
-					.getDrawSize(),-1, lightPosInEyeSpace, colorMask);
+					.getDrawSize(),-1, lightPosInWorldSpace, colorMask, cameraPosInWorldSpace);
         }
 
 
@@ -337,12 +350,12 @@ private void onDrawFrame(float[] viewMatrix, float[] projectionMatrix, float[] v
 				// load model texture
 				Integer textureId = textures.get(objData.getTextureData());
 				if (textureId == null && objData.getTextureData() != null) {
-					//Log.i("ModelRenderer","Loading texture '"+objData.getTextureFile()+"'...");
+					Log.i("ModelRenderer","Loading texture '"+objData.getTextureFile()+"'...");
 					ByteArrayInputStream textureIs = new ByteArrayInputStream(objData.getTextureData());
 					textureId = GLUtil.loadTexture(textureIs);
 					textureIs.close();
 					textures.put(objData.getTextureData(), textureId);
-					//Log.i("GLUtil", "Loaded texture ok");
+					Log.i("GLUtil", "Loaded texture ok. id: "+textureId);
 				}
 				if (textureId == null){
 					textureId = -1;
@@ -351,7 +364,7 @@ private void onDrawFrame(float[] viewMatrix, float[] projectionMatrix, float[] v
 				// draw points
 				if (objData.getDrawMode() == GLES20.GL_POINTS){
 					Object3D basicDrawer = drawer.getPointDrawer();
-					basicDrawer.draw(objData, projectionMatrix, viewMatrix, GLES20.GL_POINTS,lightPosInEyeSpace);
+					basicDrawer.draw(objData, projectionMatrix, viewMatrix, GLES20.GL_POINTS, lightPosInWorldSpace, cameraPosInWorldSpace);
 				}
 
 				// draw wireframe
@@ -368,8 +381,8 @@ else if (scene.isDrawWireframe() && objData.getDrawMode() != GLES20.GL_POINTS
 							wireframes.put(objData, wireframe);
 						}
 						drawerObject.draw(wireframe, projectionMatrix, viewMatrix, wireframe.getDrawMode(),
-								wireframe.getDrawSize(), textureId, lightPosInEyeSpace,
-								colorMask);
+								wireframe.getDrawSize(), textureId, lightPosInWorldSpace,
+								colorMask, cameraPosInWorldSpace);
 						animator.update(wireframe, scene.isShowBindPose());
 					}catch(Error e){
 						Log.e("ModelRenderer",e.getMessage(),e);
@@ -380,7 +393,7 @@ else if (scene.isDrawWireframe() && objData.getDrawMode() != GLES20.GL_POINTS
 				else if (scene.isDrawPoints() || objData.getFaces() == null || !objData.getFaces().loaded()){
 						drawerObject.draw(objData, projectionMatrix, viewMatrix
 								, GLES20.GL_POINTS, objData.getDrawSize(),
-								textureId, lightPosInEyeSpace, colorMask);
+								textureId, lightPosInWorldSpace, colorMask, cameraPosInWorldSpace);
 				}
 
 				// draw skeleton
@@ -394,13 +407,13 @@ else if (scene.isDrawSkeleton() && objData instanceof AnimatedModel && ((Animate
 					animator.update(skeleton, scene.isShowBindPose());
 					drawerObject = drawer.getDrawer(skeleton, false, scene.isDrawLighting(), scene
                             .isDoAnimation(), scene.isDrawColors());
-					drawerObject.draw(skeleton, projectionMatrix, viewMatrix,-1, lightPosInEyeSpace, colorMask);
+					drawerObject.draw(skeleton, projectionMatrix, viewMatrix,-1, lightPosInWorldSpace, colorMask, cameraPosInWorldSpace);
 				}
 
 				// draw solids
 				else {
 						drawerObject.draw(objData, projectionMatrix, viewMatrix,
-								textureId, lightPosInEyeSpace, colorMask);
+								textureId, lightPosInWorldSpace, colorMask, cameraPosInWorldSpace);
 				}
 
 				// Draw bounding box
@@ -412,7 +425,7 @@ else if (scene.isDrawSkeleton() && objData instanceof AnimatedModel && ((Animate
                     }
                     Object3D boundingBoxDrawer = drawer.getBoundingBoxDrawer();
 					boundingBoxDrawer.draw(boundingBoxData, projectionMatrix, viewMatrix, -1,
-							lightPosInEyeSpace, colorMask);
+                            lightPosInWorldSpace, colorMask, cameraPosInWorldSpace);
 				}
 
 				// Draw normals
@@ -429,7 +442,8 @@ else if (scene.isDrawSkeleton() && objData instanceof AnimatedModel && ((Animate
 						Object3D normalsDrawer = drawer.getDrawer(normalData,false,false,scene.isDoAnimation(),
 								false);
 						animator.update(normalData, scene.isShowBindPose());
-						normalsDrawer.draw(normalData, projectionMatrix, viewMatrix, -1, null);
+						normalsDrawer.draw(normalData, projectionMatrix, viewMatrix, -1, null,
+                                lightPosInWorldSpace, cameraPosInWorldSpace);
 					}
 				}