commit 0c52af30407546044c46ad8524ee9e2b5ea0193c Author: Leszek Koltunski Date: Tue Apr 9 21:27:18 2019 +0100 New module: Rubik App. Initial commit. diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..796b96d1 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/build diff --git a/build.gradle b/build.gradle new file mode 100644 index 00000000..c821d62c --- /dev/null +++ b/build.gradle @@ -0,0 +1,28 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion 27 + + defaultConfig { + applicationId "org.distorted.magic" + minSdkVersion 24 + targetSdkVersion 27 + versionCode 1 + versionName "1.0" + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + +} + +dependencies { + implementation fileTree(dir: 'libs', include: ['*.jar']) + + api project(':distorted-library') + implementation 'com.android.support:appcompat-v7:27.1.1' +} diff --git a/distorted-cube.iml b/distorted-cube.iml new file mode 100644 index 00000000..2154dce2 --- /dev/null +++ b/distorted-cube.iml @@ -0,0 +1,145 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/proguard-rules.pro b/proguard-rules.pro new file mode 100644 index 00000000..f1b42451 --- /dev/null +++ b/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile diff --git a/src/main/AndroidManifest.xml b/src/main/AndroidManifest.xml new file mode 100644 index 00000000..cedda6db --- /dev/null +++ b/src/main/AndroidManifest.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + diff --git a/src/main/java/org/distorted/magic/RubikActivity.java b/src/main/java/org/distorted/magic/RubikActivity.java new file mode 100644 index 00000000..3d8c05c2 --- /dev/null +++ b/src/main/java/org/distorted/magic/RubikActivity.java @@ -0,0 +1,133 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 Leszek Koltunski // +// // +// This file is part of Distorted. // +// // +// Distorted is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Distorted 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 General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Distorted. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.magic; + +import android.app.Activity; +import android.graphics.PorterDuff; +import android.graphics.drawable.Drawable; +import android.opengl.GLSurfaceView; +import android.os.Bundle; +import android.support.v4.content.ContextCompat; +import android.view.View; + +import org.distorted.library.main.Distorted; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class RubikActivity extends Activity +{ + static final int DEFAULT_SIZE = 3; + private static final int STARTING_SIZE = 2; + private static final int[] button_ids = {R.id.rubikSize2, R.id.rubikSize3, R.id.rubikSize4}; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void onCreate(Bundle icicle) + { + super.onCreate(icicle); + setContentView(R.layout.layout); + + markButton(DEFAULT_SIZE); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void onPause() + { + GLSurfaceView view = findViewById(R.id.rubikSurfaceView); + view.onPause(); + Distorted.onPause(); + super.onPause(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void onResume() + { + super.onResume(); + GLSurfaceView view = findViewById(R.id.rubikSurfaceView); + view.onResume(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + @Override + protected void onDestroy() + { + Distorted.onDestroy(); + super.onDestroy(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void Scramble(View v) + { + RubikSurfaceView view = findViewById(R.id.rubikSurfaceView); + view.scrambleCube(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void Credits(View v) + { + android.util.Log.e("rubik", "credits..."); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void setSize(View v) + { + int size=0, id = v.getId(); + + for(int b=0; b. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.magic; + +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Paint; + +import org.distorted.library.effect.MatrixEffectMove; +import org.distorted.library.effect.MatrixEffectQuaternion; +import org.distorted.library.effect.MatrixEffectRotate; +import org.distorted.library.effect.MatrixEffectScale; +import org.distorted.library.effect.VertexEffectSink; +import org.distorted.library.main.DistortedEffects; +import org.distorted.library.main.DistortedScreen; +import org.distorted.library.main.DistortedTexture; +import org.distorted.library.mesh.MeshCubes; +import org.distorted.library.message.EffectListener; +import org.distorted.library.type.Dynamic1D; +import org.distorted.library.type.Static1D; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class RubikCube +{ + private static final int POST_ROTATION_MILLISEC = 500; + private static final int TEXTURE_SIZE = 100; + + private static final Static3D VectX = new Static3D(1,0,0); + private static final Static3D VectY = new Static3D(0,1,0); + private static final Static3D VectZ = new Static3D(0,0,1); + + private MeshCubes[][][] mCubes; + private DistortedEffects[][][] mEffects; + private Static4D[][][] mQuatScramble; + private Static3D[][][] mRotationAxis; + private Dynamic1D[][][] mRotationAngle; + private Static3D[][][] mCurrentPosition; + private Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal; + private DistortedTexture mTexture; + private DistortedEffects mEffectsListeningForNow; + + private int mRotAxis, mRotRow; + private int mSize; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + RubikCube(int size, Static3D move, Static3D scale, Static4D quatC, Static4D quatA) + { + mSize = size; + + mRotationAngleStatic = new Static1D(0); + mRotationAngleMiddle = new Static1D(0); + mRotationAngleFinal = new Static1D(0); + + mRotAxis= RubikSurfaceView.VECTX; + mTexture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE); + + mCubes = new MeshCubes[mSize][mSize][mSize]; + mEffects = new DistortedEffects[mSize][mSize][mSize]; + mQuatScramble = new Static4D[mSize][mSize][mSize]; + mRotationAxis = new Static3D[mSize][mSize][mSize]; + mRotationAngle = new Dynamic1D[mSize][mSize][mSize]; + mCurrentPosition= new Static3D[mSize][mSize][mSize]; + + Static3D[][][] cubeVectors = new Static3D[mSize][mSize][mSize]; + + Static3D center = new Static3D(TEXTURE_SIZE*0.5f, TEXTURE_SIZE*0.5f, TEXTURE_SIZE*0.5f); + Static4D region = new Static4D(0,0,0, TEXTURE_SIZE*0.72f); + + VertexEffectSink sinkEffect = new VertexEffectSink( new Static1D(getSinkStrength()), center, region ); + MatrixEffectMove moveEffect = new MatrixEffectMove(move); + MatrixEffectScale scaleEffect = new MatrixEffectScale(scale); + MatrixEffectQuaternion quatCEffect = new MatrixEffectQuaternion(quatC, center); + MatrixEffectQuaternion quatAEffect = new MatrixEffectQuaternion(quatA, center); + + // 3x2 bitmap = 6 squares: + // + // RED GREEN BLUE + // YELLOW WHITE BROWN + + final float ze = 0.0f; + final float ot = 1.0f/3.0f; + final float tt = 2.0f/3.0f; + final float oh = 1.0f/2.0f; + final float of = 1.0f/40.0f; + + final Static4D mapFront = new Static4D(ze,oh, ze+ot,oh+oh); + final Static4D mapBack = new Static4D(tt,ze, tt+ot,ze+oh); + final Static4D mapLeft = new Static4D(ot,ze, ot+ot,ze+oh); + final Static4D mapRight = new Static4D(ze,ze, ze+ot,ze+oh); + final Static4D mapTop = new Static4D(tt,oh, tt+ot,oh+oh); + final Static4D mapBottom= new Static4D(ot,oh, ot+ot,oh+oh); + + final Static4D mapBlack = new Static4D(ze,ze, ze+of,ze+of); + + Static4D tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom; + float nc = 0.5f*(mSize-1); + int vertices = (int)(24.0f/mSize + 2.0f); + + for(int x = 0; x< mSize; x++) + for(int y = 0; y< mSize; y++) + for(int z = 0; z< mSize; z++) + { + if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 ) // only the external walls + { + tmpLeft = (x== 0 ? mapLeft :mapBlack); + tmpRight = (x== mSize-1 ? mapRight :mapBlack); + tmpFront = (z== mSize-1 ? mapFront :mapBlack); + tmpBack = (z== 0 ? mapBack :mapBlack); + tmpTop = (y== mSize-1 ? mapTop :mapBlack); + tmpBottom= (y== 0 ? mapBottom:mapBlack); + + mCubes[x][y][z] = new MeshCubes(vertices,vertices,vertices, tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom); + cubeVectors[x][y][z] = new Static3D( TEXTURE_SIZE*(x-nc), TEXTURE_SIZE*(y-nc), TEXTURE_SIZE*(z-nc) ); + mQuatScramble[x][y][z] = new Static4D(0,0,0,1); + mRotationAngle[x][y][z] = new Dynamic1D(); + mRotationAxis[x][y][z] = new Static3D(1,0,0); + mCurrentPosition[x][y][z] = new Static3D(x,y,z); + + mEffects[x][y][z] = new DistortedEffects(); + mEffects[x][y][z].apply(sinkEffect); + mEffects[x][y][z].apply(moveEffect); + mEffects[x][y][z].apply(scaleEffect); + mEffects[x][y][z].apply(quatCEffect); + mEffects[x][y][z].apply(quatAEffect); + mEffects[x][y][z].apply( new MatrixEffectRotate( mRotationAngle[x][y][z], mRotationAxis[x][y][z], center)); + mEffects[x][y][z].apply( new MatrixEffectQuaternion(mQuatScramble[x][y][z], center)); + mEffects[x][y][z].apply( new MatrixEffectMove(cubeVectors[x][y][z]) ); + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void attachToScreen(DistortedScreen screen) + { + for(int x=0; x. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.magic; + +import android.opengl.GLSurfaceView; + +import org.distorted.library.effect.VertexEffectSink; +import org.distorted.library.main.Distorted; +import org.distorted.library.main.DistortedScreen; +import org.distorted.library.message.EffectListener; +import org.distorted.library.message.EffectMessage; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; + +import javax.microedition.khronos.egl.EGLConfig; +import javax.microedition.khronos.opengles.GL10; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class RubikRenderer implements GLSurfaceView.Renderer, EffectListener +{ + private static final float CUBE_SCREEN_RATIO = 0.5f; + private static final float CAMERA_DISTANCE = 0.6f; // 0.6 of the length of max(scrHeight,scrWidth) + + private RubikSurfaceView mView; + private DistortedScreen mScreen; + private Static3D mMove, mScale; + private Static4D mQuatCurrent, mQuatAccumulated; + private Static4D mTempCurrent, mTempAccumulated; + private float mCubeSizeInScreenSpace; + private boolean mFinishRotation, mRemoveRotation, mFinishDragCurrent, mFinishDragAccumulated; + private boolean mCanRotate; + private RubikCube mCube; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + RubikRenderer(RubikSurfaceView v) + { + mView = v; + + mScreen = new DistortedScreen(); + + mTempCurrent = new Static4D(0,0,0,1); + mTempAccumulated = initializeQuat(); + mQuatCurrent = new Static4D(0,0,0,1); + mQuatAccumulated = initializeQuat(); + + mMove = new Static3D(0,0,0); + mScale = new Static3D(1,1,1); + + mFinishRotation = false; + mRemoveRotation = false; + mFinishDragCurrent = false; + mFinishDragAccumulated = false; + + mCanRotate = true; + + mCube = new RubikCube( RubikActivity.DEFAULT_SIZE, mMove, mScale, mQuatCurrent, mQuatAccumulated); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// various things are done here delayed, 'after the next render' as not to be done mid-render and +// cause artifacts. + + public void onDrawFrame(GL10 glUnused) + { + mScreen.render( System.currentTimeMillis() ); + + if( mFinishDragCurrent ) + { + mFinishDragCurrent = false; + mQuatCurrent.set(mTempCurrent); + } + + if( mFinishDragAccumulated ) + { + mFinishDragAccumulated = false; + mQuatAccumulated.set(mTempAccumulated); + } + + if( mFinishRotation ) + { + mCanRotate = false; + mFinishRotation=false; + mCube.finishRotationCalledOnNextRender(this); + } + + if( mRemoveRotation ) + { + mRemoveRotation=false; + mCube.removeRotationCalledOnNextRender(this); + mCanRotate = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// EffectListener. The library sends a message to us when it's time to call 'removeRotation' + + public void effectMessage(final EffectMessage em, final long effectID, final long objectID) + { + switch(em) + { + case EFFECT_FINISHED: mRemoveRotation = true; break; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void onSurfaceChanged(GL10 glUnused, int width, int height) + { + float cameraDistance = CAMERA_DISTANCE*(width>height ? width:height); + float fovInDegrees = computeFOV(cameraDistance,height); + + mScreen.setProjection( fovInDegrees, 0.1f); + mView.setScreenSize(width,height); + mView.setCameraDist(cameraDistance); + + mCubeSizeInScreenSpace = CUBE_SCREEN_RATIO*(width>height ? height:width); + float texSize = mCube.getTextureSize(); + float scaleFactor = mCubeSizeInScreenSpace/(texSize*mCube.getSize()); + + mMove.set( (width-scaleFactor*texSize)/2 , (height-scaleFactor*texSize)/2 , -scaleFactor*texSize/2 ); + mScale.set(scaleFactor,scaleFactor,scaleFactor); + + mScreen.resize(width, height); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void onSurfaceCreated(GL10 glUnused, EGLConfig config) + { + mCube.createTexture(); + mScreen.detachAll(); + mCube.attachToScreen(mScreen); + + VertexEffectSink.enable(); + + try + { + Distorted.onCreate(mView.getContext()); + } + catch(Exception ex) + { + android.util.Log.e("Rubik", ex.getMessage() ); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float computeFOV(float cameraDistance, int screenHeight) + { + double halfFOVInRadians = Math.atan( screenHeight/(2*cameraDistance) ); + return (float)(2*halfFOVInRadians*(180/Math.PI)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// no this will not race with onDrawFrame + + void finishRotation() + { + mFinishRotation = true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + float returnCubeSizeInScreenSpace() + { + return mCubeSizeInScreenSpace; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean canRotate() + { + return mCanRotate; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + RubikCube getCube() + { + return mCube; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Initial rotation of the cube. Something semi-random that looks good. + + Static4D initializeQuat() + { + return new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void setQuatCurrent(Static4D current) + { + mTempCurrent.set(current); + mFinishDragCurrent = true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void setQuatAccumulated(Static4D accumulated) + { + mTempAccumulated.set(accumulated); + mFinishDragAccumulated = true; + } +} diff --git a/src/main/java/org/distorted/magic/RubikSurfaceView.java b/src/main/java/org/distorted/magic/RubikSurfaceView.java new file mode 100644 index 00000000..ca446443 --- /dev/null +++ b/src/main/java/org/distorted/magic/RubikSurfaceView.java @@ -0,0 +1,484 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2019 Leszek Koltunski // +// // +// This file is part of Distorted. // +// // +// Distorted is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Distorted 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 General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Distorted. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.magic; + +import android.app.ActivityManager; +import android.content.Context; +import android.content.pm.ConfigurationInfo; +import android.opengl.GLSurfaceView; +import android.util.AttributeSet; +import android.view.MotionEvent; + +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class RubikSurfaceView extends GLSurfaceView +{ + private final static int NONE =-1; + private final static int FRONT = 0; // has to be 6 consecutive ints + private final static int BACK = 1; // FRONT ... BOTTOM + private final static int LEFT = 2; // + private final static int RIGHT = 3; // + private final static int TOP = 4; // + private final static int BOTTOM = 5; // + + static final int VECTX = 0; // + static final int VECTY = 1; // dont change this + static final int VECTZ = 2; // + + private static final int[] VECT = {VECTX,VECTY,VECTZ}; + + private boolean mDragging, mBeginningRotation, mContinuingRotation; + private int mX, mY; + private Static4D mQuatCurrent, mQuatAccumulated; + private int mRotationVect; + private RubikRenderer mRenderer; + private RubikCube mCube; + + private float[] mPoint, mCamera, mTouchPointCastOntoFace, mDiff, mTouchPoint; // all in screen space + private int mLastTouchedFace; + private int mScreenWidth, mScreenHeight, mScreenMin; + private float mCameraDistance; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public RubikSurfaceView(Context context, AttributeSet attrs) + { + super(context,attrs); + + if(!isInEditMode()) + { + mRotationVect = VECT[0]; + + mPoint = new float[3]; + mCamera= new float[3]; + mDiff = new float[3]; + mTouchPoint = new float[3]; + mTouchPointCastOntoFace = new float[3]; + + mScreenWidth = mScreenHeight = mScreenMin = 0; + + mRenderer = new RubikRenderer(this); + mCube = mRenderer.getCube(); + + mQuatCurrent = new Static4D(0,0,0,1); + mQuatAccumulated = mRenderer.initializeQuat(); + + final ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); + final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo(); + setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 ); + setRenderer(mRenderer); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public RubikRenderer getRenderer() + { + return mRenderer; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + @Override + public boolean onTouchEvent(MotionEvent event) + { + int action = event.getAction(); + int x = (int)event.getX(); + int y = (int)event.getY(); + + switch(action) + { + case MotionEvent.ACTION_DOWN: mX = x; + mY = y; + mLastTouchedFace = faceTouched(x,y); + + if( mLastTouchedFace != NONE ) + { + mDragging = false; + mBeginningRotation = mRenderer.canRotate(); + mContinuingRotation = false; + } + else + { + mDragging = true; + mBeginningRotation = false; + mContinuingRotation = false; + } + break; + case MotionEvent.ACTION_MOVE: if( mDragging ) + { + mQuatCurrent.set(quatFromDrag(mX-x,mY-y)); + mRenderer.setQuatCurrent(mQuatCurrent); + } + if( mBeginningRotation ) + { + int minimumDistToStartRotating = (mScreenMin*mScreenMin)/100; + + if( (mX-x)*(mX-x)+(mY-y)*(mY-y) > minimumDistToStartRotating ) + { + addNewRotation(x,y); + mBeginningRotation = false; + mContinuingRotation= true; + } + } + else if( mContinuingRotation ) + { + continueRotation(x,y); + } + break; + case MotionEvent.ACTION_UP : if( mDragging ) + { + mQuatAccumulated.set(quatMultiply(mQuatCurrent, mQuatAccumulated)); + mQuatCurrent.set(0f, 0f, 0f, 1f); + mRenderer.setQuatCurrent(mQuatCurrent); + mRenderer.setQuatAccumulated(mQuatAccumulated); + } + + if( mContinuingRotation ) + { + finishRotation(); + } + + break; + } + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void setNewCubeSize(int newCubeSize) + { + android.util.Log.e("view", "new size="+newCubeSize); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void scrambleCube() + { + android.util.Log.e("view", "scrambling..."); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void setScreenSize(int width, int height) + { + mScreenWidth = width; + mScreenHeight= height; + + mScreenMin = width=0 && qY<=1 && qY>=0 && qZ<=1 && qZ>=0 ) return face; + } + } + + return NONE; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void addNewRotation(int x, int y) + { + float cubeHalfSize= mRenderer.returnCubeSizeInScreenSpace()*0.5f; + + convertTouchPointToScreenSpace(x,y); + castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize,mDiff); + + mDiff[0] -= mTouchPointCastOntoFace[0]; + mDiff[1] -= mTouchPointCastOntoFace[1]; + mDiff[2] -= mTouchPointCastOntoFace[2]; + + int xAxis = retFaceXaxis(mLastTouchedFace); + int yAxis = retFaceYaxis(mLastTouchedFace); + mRotationVect = (isVertical( mDiff[xAxis], mDiff[yAxis]) ? VECT[xAxis]:VECT[yAxis]); + float offset= (mTouchPointCastOntoFace[mRotationVect]+cubeHalfSize)/(2*cubeHalfSize); + + mTouchPoint[0] = mPoint[0]; + mTouchPoint[1] = mPoint[1]; + mTouchPoint[2] = mPoint[2]; + + mCube.addNewRotation(mRotationVect,offset); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean isVertical(float x, float y) + { + return (y>x) ? (y>=-x) : (y< -x); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// 240 --> moving finger from the middle of the vertical screen to the right edge will rotate a +// given face by 240/2 = 120 degrees. + + private void continueRotation(int x, int y) + { + convertTouchPointToScreenSpace(x,y); + + mDiff[0] = mPoint[0]-mTouchPoint[0]; + mDiff[1] = mPoint[1]-mTouchPoint[1]; + mDiff[2] = mPoint[2]-mTouchPoint[2]; + + int xAxis= retFaceXaxis(mLastTouchedFace); + int yAxis= retFaceYaxis(mLastTouchedFace); + int sign = retFaceRotationSign(mLastTouchedFace); + float angle = (mRotationVect==xAxis ? mDiff[yAxis] : -mDiff[xAxis]); + + mCube.continueRotation(240.0f*sign*angle/mScreenMin); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void finishRotation() + { + mRenderer.finishRotation(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// return quat1*quat2 + + static Static4D quatMultiply( Static4D quat1, Static4D quat2 ) + { + float qx = quat1.get1(); + float qy = quat1.get2(); + float qz = quat1.get3(); + float qw = quat1.get4(); + + float rx = quat2.get1(); + float ry = quat2.get2(); + float rz = quat2.get3(); + float rw = quat2.get4(); + + float tx = rw*qx - rz*qy + ry*qz + rx*qw; + float ty = rw*qy + rz*qx + ry*qw - rx*qz; + float tz = rw*qz + rz*qw - ry*qx + rx*qy; + float tw = rw*qw - rz*qz - ry*qy - rx*qx; + + return new Static4D(tx,ty,tz,tw); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// rotate 'vector' by quat^(-1) ( i.e. return (quat^-1)*vector*quat ) + + static Static4D rotateVectorByInvertedQuat(Static4D vector, Static4D quat) + { + float qx = quat.get1(); + float qy = quat.get2(); + float qz = quat.get3(); + float qw = quat.get4(); + + Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw); + Static4D tmp = quatMultiply(quatInverted,vector); + + return quatMultiply(tmp,quat); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// rotate 'vector' by quat ( i.e. return quat*vector*(quat^-1) ) + + static Static4D rotateVectorByQuat(Static4D vector, Static4D quat) + { + float qx = quat.get1(); + float qy = quat.get2(); + float qz = quat.get3(); + float qw = quat.get4(); + + Static4D quatInverted= new Static4D(-qx,-qy,-qz,qw); + Static4D tmp = quatMultiply(quat,vector); + + return quatMultiply(tmp,quatInverted); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private Static4D quatFromDrag(float dragX, float dragY) + { + float axisX = dragY; // inverted X and Y - rotation axis is + float axisY = dragX; // perpendicular to (dragX,dragY) Why not (-dragY, dragX) ? because Y axis is also inverted! + float axisZ = 0; + float axisL = (float)Math.sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ); + + if( axisL>0 ) + { + axisX /= axisL; + axisY /= axisL; + axisZ /= axisL; + + float cosA = (float)Math.cos(axisL*Math.PI/mScreenMin); + float sinA = (float)Math.sqrt(1-cosA*cosA); + + return new Static4D(axisX*sinA, axisY*sinA, axisZ*sinA, cosA); + } + + return new Static4D(0f, 0f, 0f, 1f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private boolean faceIsVisible(int face, float cubeHalfSize) + { + int sign = retFaceSign(face); + int zAxis= retFaceZaxis(face); + + return sign*mCamera[zAxis] > cubeHalfSize; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void convertTouchPointToScreenSpace(int x, int y) + { + float halfScrWidth = mScreenWidth *0.5f; + float halfScrHeight = mScreenHeight*0.5f; + Static4D touchPoint = new Static4D(x-halfScrWidth, halfScrHeight-y, 0, 0); + Static4D rotatedTouchPoint= rotateVectorByInvertedQuat(touchPoint, mQuatAccumulated); + + mPoint[0] = rotatedTouchPoint.get1(); + mPoint[1] = rotatedTouchPoint.get2(); + mPoint[2] = rotatedTouchPoint.get3(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void convertCameraPointToScreenSpace() + { + Static4D cameraPoint = new Static4D(0, 0, mCameraDistance, 0); + Static4D rotatedCamera= rotateVectorByInvertedQuat(cameraPoint, mQuatAccumulated); + + mCamera[0] = rotatedCamera.get1(); + mCamera[1] = rotatedCamera.get2(); + mCamera[2] = rotatedCamera.get3(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace, +// cast this touch point onto the surface defined by the 'face' and write the cast coords to 'output'. +// Center of the 'face' = (0,0), third coord always +- cubeHalfSize. + + private void castTouchPointOntoFace(int face, float cubeHalfSize, float[] output) + { + int sign = retFaceSign(face); + int zAxis= retFaceZaxis(face); + float diff = mPoint[zAxis]-mCamera[zAxis]; + + float ratio = diff!=0.0f ? (sign*cubeHalfSize-mCamera[zAxis])/diff : 0.0f; + + output[0] = (mPoint[0]-mCamera[0])*ratio + mCamera[0]; + output[1] = (mPoint[1]-mCamera[1])*ratio + mCamera[1]; + output[2] = (mPoint[2]-mCamera[2])*ratio + mCamera[2]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int retFaceSign(int face) + { + return (face==FRONT || face==RIGHT || face==TOP) ? 1:-1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int retFaceRotationSign(int face) + { + return (face==BACK || face==RIGHT || face==TOP) ? 1:-1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// retFace{X,Y,Z}axis: 3 functions which return which real AXIS gets mapped to which when we look +// directly at a given face. For example, when we look at the RIGHT face of the cube (with TOP still +// in the top) then the 'real' X axis becomes the 'Z' axis, thus retFaceZaxis(RIGHT) = VECTX. + + private int retFaceXaxis(int face) + { + switch(face) + { + case FRONT : + case BACK : return VECTX; + case LEFT : + case RIGHT : return VECTZ; + case TOP : + case BOTTOM: return VECTX; + } + + return -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int retFaceYaxis(int face) + { + switch(face) + { + case FRONT : + case BACK : return VECTY; + case LEFT : + case RIGHT : return VECTY; + case TOP : + case BOTTOM: return VECTZ; + } + + return -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int retFaceZaxis(int face) + { + switch(face) + { + case FRONT : + case BACK : return VECTZ; + case LEFT : + case RIGHT : return VECTX; + case TOP : + case BOTTOM: return VECTY; + } + + return -1; + } +} + diff --git a/src/main/res/drawable/button2.png b/src/main/res/drawable/button2.png new file mode 100644 index 00000000..eb781e64 Binary files /dev/null and b/src/main/res/drawable/button2.png differ diff --git a/src/main/res/drawable/button3.png b/src/main/res/drawable/button3.png new file mode 100644 index 00000000..dae0f164 Binary files /dev/null and b/src/main/res/drawable/button3.png differ diff --git a/src/main/res/drawable/button4.png b/src/main/res/drawable/button4.png new file mode 100644 index 00000000..c37a2e75 Binary files /dev/null and b/src/main/res/drawable/button4.png differ diff --git a/src/main/res/layout/layout.xml b/src/main/res/layout/layout.xml new file mode 100644 index 00000000..1cdfa896 --- /dev/null +++ b/src/main/res/layout/layout.xml @@ -0,0 +1,68 @@ + + + + + +