/ - Diff - Distorted Android

« Previous | Next »

Revision dc8979ba

Added by Leszek Koltunski over 5 years ago

ID dc8979baa4145f60847800174a058d71712d8b94
Parent 7f986357
Child 8fbe9426

RubikApp: simplifications.

           mSize = size;
           mRotationAngleStatic = new Static1D(0);
           mRotAxis= RubikSurfaceView.VECTN;
           mRotAxis= RubikSurfaceView.VECTX;
           mTexture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);
           mCubes          = new MeshCubes[mSize][mSize][mSize];

           float h = mCube.getHeight();
           float d = mCube.getDepth();
           mScaleFactor = CUBE_SCREEN_RATIO*(width>height ? height/h:width/w)/ NUM_CUBES;
           mScaleFactor = CUBE_SCREEN_RATIO*(width>height ? height:width)/mCube.getSizeInModelSpace();
           mMove.set( (width-mScaleFactor*w)/2 , (height-mScaleFactor*h)/2 , -mScaleFactor*d/2 );
           mScale.set(mScaleFactor,mScaleFactor,mScaleFactor);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         float returnCubeSize()
         float returnCubeSizeInScreenSpace()
+          {
           return mScaleFactor*mCube.getSizeInModelSpace();
+          }

         private final static int TOP    = 4;  //
         private final static int BOTTOM = 5;  //
         static final int VECTX = 0;
         static final int VECTY = 1;
         static final int VECTZ = 2;
         static final int VECTN = 3;
         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, mBeginRot;
         private int mX, mY;
-...
         private RubikRenderer mRenderer;
         private RubikCube mCube;
         private float mPoiX, mPoiY, mPoiZ, mCamX, mCamY, mCamZ;
         private float mStartX, mStartY, mStartZ;
         private float[] mPoi, mCam, mTouchedPointCastOntoFace, mDiff; // all in screen space
         private int mLastTouchedFace;
         private int mScreenWidth, mScreenHeight, mScreenMin;
         private float mCameraDistance;
-...
           mDragging = false;
           mBeginRot = false;
           mRotationVect = VECTN;
           mRotationVect = VECT[0];
           mPoi   = new float[3];
           mCam   = new float[3];
           mDiff  = new float[3];
           mTouchedPointCastOntoFace = new float[3];
           mScreenWidth = mScreenHeight = mScreenMin = 0;
-...
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // mTouchedPointCastOntoFace[x] is the x distance between the x-center of the face and the point
     // we just touched cast onto the face. The face is touched iff -cH <= mTouchedPointCastOntoFace[0,1,2] <= +cH
         private void addNewRotation(int x, int y)
         private int faceTouched(int xTouch, int yTouch)
+          {
           fillTouchPoint(x,y);
           float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;
           float A=retA(mLastTouchedFace,cubeHalfSize);
           float cubeHalfSize= mRenderer.returnCubeSizeInScreenSpace()*0.5f;
           float diffX = (mPoiX-mCamX)*A + mCamX - mStartX;
           float diffY = (mPoiY-mCamY)*A + mCamY - mStartY;
           float diffZ = (mPoiZ-mCamZ)*A + mCamZ - mStartZ;
           convertTouchPointToScreenSpace(xTouch,yTouch);
           convertCameraPointToScreenSpace();
           switch(mLastTouchedFace)
           for(int face=FRONT; face<=BOTTOM; face++)
+            {
             case FRONT :
             case BACK  : mRotationVect = (isVertical(diffX, diffY) ? VECTX:VECTY); break;
             case LEFT  :
             case RIGHT : mRotationVect = (isVertical(diffZ, diffY) ? VECTZ:VECTY); break;
             case TOP   :
             case BOTTOM: mRotationVect = (isVertical(diffX, diffZ) ? VECTX:VECTZ); break;
+            }
             if( faceIsVisible(face,cubeHalfSize) )
+              {
               castTouchPointOntoFace(face,cubeHalfSize, mTouchedPointCastOntoFace);
           float offset=0;
               float qX= (mTouchedPointCastOntoFace[0]+cubeHalfSize) / (2*cubeHalfSize);
               float qY= (mTouchedPointCastOntoFace[1]+cubeHalfSize) / (2*cubeHalfSize);
               float qZ= (mTouchedPointCastOntoFace[2]+cubeHalfSize) / (2*cubeHalfSize);
           switch(mRotationVect)
+            {
             case VECTX: offset = (mStartX+cubeHalfSize)/(2*cubeHalfSize); break;
             case VECTY: offset = (mStartY+cubeHalfSize)/(2*cubeHalfSize); break;
             case VECTZ: offset = (mStartZ+cubeHalfSize)/(2*cubeHalfSize); break;
               if( qX<=1 && qX>=0 && qY<=1 && qY>=0 && qZ<=1 && qZ>=0 ) return face;
+              }
+            }
           mStartX = diffX + mStartX;
           mStartY = diffY + mStartY;
           mStartZ = diffZ + mStartZ;
           return NONE;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void addNewRotation(int x, int y)
+          {
           float cubeHalfSize= mRenderer.returnCubeSizeInScreenSpace()*0.5f;
           convertTouchPointToScreenSpace(x,y);
           castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize,mDiff);
           mDiff[0] -= mTouchedPointCastOntoFace[0];
           mDiff[1] -= mTouchedPointCastOntoFace[1];
           mDiff[2] -= mTouchedPointCastOntoFace[2];
           int xAxis = retFaceXaxis(mLastTouchedFace);
           int yAxis = retFaceYaxis(mLastTouchedFace);
           mRotationVect = (isVertical( mDiff[xAxis], mDiff[yAxis]) ? VECT[xAxis]:VECT[yAxis]);
           float offset= (mTouchedPointCastOntoFace[mRotationVect]+cubeHalfSize)/(2*cubeHalfSize);
           mTouchedPointCastOntoFace[0] = mDiff[0] + mTouchedPointCastOntoFace[0];
           mTouchedPointCastOntoFace[1] = mDiff[1] + mTouchedPointCastOntoFace[1];
           mTouchedPointCastOntoFace[2] = mDiff[2] + mTouchedPointCastOntoFace[2];
           mCube.addNewRotation(mRotationVect,offset);
+          }
-...
         private void continueRotation(int x, int y)
+          {
           fillTouchPoint(x,y);
           float cubeHalfSize= mRenderer.returnCubeSizeInScreenSpace()*0.5f;
           float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;
           float A=retA(mLastTouchedFace,cubeHalfSize);
           convertTouchPointToScreenSpace(x,y);
           castTouchPointOntoFace(mLastTouchedFace,cubeHalfSize,mDiff);
           float diffX = (mPoiX-mCamX)*A + mCamX - mStartX;
           float diffY = (mPoiY-mCamY)*A + mCamY - mStartY;
           float diffZ = (mPoiZ-mCamZ)*A + mCamZ - mStartZ;
           mDiff[0] -= mTouchedPointCastOntoFace[0];
           mDiff[1] -= mTouchedPointCastOntoFace[1];
           mDiff[2] -= mTouchedPointCastOntoFace[2];
           float angle=0.0f;
           int xAxis= retFaceXaxis(mLastTouchedFace);
           int yAxis= retFaceYaxis(mLastTouchedFace);
           int sign = retFaceRotationSign(mLastTouchedFace);
           switch(mLastTouchedFace)
+            {
             case FRONT : angle = (mRotationVect==VECTX ? -diffY : diffX); break;
             case BACK  : angle = (mRotationVect==VECTX ?  diffY :-diffX); break;
             case LEFT  : angle = (mRotationVect==VECTY ?  diffZ :-diffY); break;
             case RIGHT : angle = (mRotationVect==VECTY ? -diffZ : diffY); break;
             case TOP   : angle = (mRotationVect==VECTZ ? -diffX : diffZ); break;
             case BOTTOM: angle = (mRotationVect==VECTZ ?  diffX :-diffZ); break;
+            }
           float angle = (mRotationVect==xAxis ? mDiff[yAxis] : -mDiff[xAxis]);
           mCube.continueRotation(200.0f*angle/mScreenMin);
           mCube.continueRotation(200.0f*sign*angle/mScreenMin);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void finishRotation()
+          {
           mRotationVect = VECTN;
           mRenderer.finishRotation();
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private boolean faceIsVisible(int face)
         private boolean faceIsVisible(int face, float cubeHalfSize)
+          {
           float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;
           int sign = retFaceSign(face);
           int zAxis= retFaceZaxis(face);
           Static4D rotated = rotateVectorByInvertedQuat(new Static4D(0,0,mCameraDistance,0), mQuatAccumulated);
           return sign*mCam[zAxis] > cubeHalfSize;
+          }
           switch(face)
+            {
             case FRONT : return rotated.get3() >  cubeHalfSize;
             case BACK  : return rotated.get3() < -cubeHalfSize;
             case LEFT  : return rotated.get1() < -cubeHalfSize;
             case RIGHT : return rotated.get1() >  cubeHalfSize;
             case TOP   : return rotated.get2() >  cubeHalfSize;
             case BOTTOM: return rotated.get2() < -cubeHalfSize;
+            }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
           return false;
         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);
           mPoi[0] = rotatedTouchPoint.get1();
           mPoi[1] = rotatedTouchPoint.get2();
           mPoi[2] = rotatedTouchPoint.get3();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private int faceTouched(int xTouch, int yTouch)
         private void convertCameraPointToScreenSpace()
+          {
           float cubeHalfSize= mRenderer.returnCubeSize()*0.5f;
           fillTouchPoint(xTouch,yTouch);
           fillCamera();
           Static4D cameraPoint = new Static4D(0, 0, mCameraDistance, 0);
           Static4D rotatedCamera= rotateVectorByInvertedQuat(cameraPoint, mQuatAccumulated);
           for(int face=FRONT; face<=BOTTOM; face++)
+            {
             if( faceIsVisible(face) && faceCondition(face) )
+              {
               float A = retA(face,cubeHalfSize);
           mCam[0] = rotatedCamera.get1();
           mCam[1] = rotatedCamera.get2();
           mCam[2] = rotatedCamera.get3();
+          }
               mStartX = (mPoiX-mCamX)*A + mCamX;
               mStartY = (mPoiY-mCamY)*A + mCamY;
               mStartZ = (mPoiZ-mCamZ)*A + mCamZ;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // given precomputed mCam and mPoi, respectively camera and touch point positions in ScreenSpace,
     // cast this touch point onto the 'face' and write the cast coords to 'output'.
     // Center of the 'face' = (0,0)
               float qX= (mStartX+cubeHalfSize) / (2*cubeHalfSize);
               float qY= (mStartY+cubeHalfSize) / (2*cubeHalfSize);
               float qZ= (mStartZ+cubeHalfSize) / (2*cubeHalfSize);
         private void castTouchPointOntoFace(int face, float cubeHalfSize, float[] output)
+          {
           int sign = retFaceSign(face);
           int zAxis= retFaceZaxis(face);
           float diff = mPoi[zAxis]-mCam[zAxis];
               if( qX<=1 && qX>=0 && qY<=1 && qY>=0 && qZ<=1 && qZ>=0 ) return face;
+              }
+            }
           float ratio =  diff!=0.0f ? (sign*cubeHalfSize-mCam[zAxis])/diff : 0.0f;
           return NONE;
           output[0] = (mPoi[0]-mCam[0])*ratio + mCam[0];
           output[1] = (mPoi[1]-mCam[1])*ratio + mCam[1];
           output[2] = (mPoi[2]-mCam[2])*ratio + mCam[2];
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void fillTouchPoint(int x, int y)
         private int retFaceSign(int face)
+          {
           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);
           return (face==FRONT || face==RIGHT || face==TOP) ? 1:-1;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
           mPoiX = rotatedTouchPoint.get1();
           mPoiY = rotatedTouchPoint.get2();
           mPoiZ = rotatedTouchPoint.get3();
         private int retFaceRotationSign(int face)
+          {
           return (face==BACK || face==RIGHT || face==TOP) ? 1:-1;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void fillCamera()
         private int retFaceXaxis(int face)
+          {
           Static4D cameraPoint = new Static4D(0, 0, mCameraDistance, 0);
           Static4D rotatedCamera= rotateVectorByInvertedQuat(cameraPoint, mQuatAccumulated);
           switch(face)
+            {
             case FRONT :
             case BACK  : return VECTX;
             case LEFT  :
             case RIGHT : return VECTZ;
             case TOP   :
             case BOTTOM: return VECTX;
+            }
           mCamX = rotatedCamera.get1();
           mCamY = rotatedCamera.get2();
           mCamZ = rotatedCamera.get3();
           return -1;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private float retA(int face, float cubeHalfSize)
         private int retFaceYaxis(int face)
+          {
           switch(face)
+            {
             case FRONT : return ( mPoiZ!=mCamZ ? ( cubeHalfSize-mCamZ)/(mPoiZ-mCamZ) : 0f);
             case BACK  : return ( mPoiZ!=mCamZ ? (-cubeHalfSize-mCamZ)/(mPoiZ-mCamZ) : 0f);
             case LEFT  : return ( mPoiX!=mCamX ? (-cubeHalfSize-mCamX)/(mPoiX-mCamX) : 0f);
             case RIGHT : return ( mPoiX!=mCamX ? ( cubeHalfSize-mCamX)/(mPoiX-mCamX) : 0f);
             case TOP   : return ( mPoiY!=mCamY ? ( cubeHalfSize-mCamY)/(mPoiY-mCamY) : 0f);
             case BOTTOM: return ( mPoiY!=mCamY ? (-cubeHalfSize-mCamY)/(mPoiY-mCamY) : 0f);
             case FRONT :
             case BACK  : return VECTY;
             case LEFT  :
             case RIGHT : return VECTY;
             case TOP   :
             case BOTTOM: return VECTZ;
+            }
           return 0.0f;
           return -1;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private boolean faceCondition(int face)
         private int retFaceZaxis(int face)
+          {
           switch(face)
+            {
             case FRONT :
             case BACK  : return ( mPoiZ!=mCamZ );
             case BACK  : return VECTZ;
             case LEFT  :
             case RIGHT : return ( mPoiX!=mCamX );
             case RIGHT : return VECTX;
             case TOP   :
             case BOTTOM: return ( mPoiY!=mCamY );
             case BOTTOM: return VECTY;
+            }
           return false;
           return -1;
+          }
+    }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision dc8979ba

Added by Leszek Koltunski over 5 years ago