Project

General

Profile

Download (6.6 KB) Statistics
| Branch: | Revision:

examples / src / main / java / org / distorted / examples / cubes / CubesSurfaceView.java @ 7451c98a

1
///////////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2016 Leszek Koltunski                                                               //
3
//                                                                                               //
4
// This file is part of Distorted.                                                               //
5
//                                                                                               //
6
// Distorted is free software: you can redistribute it and/or modify                             //
7
// it under the terms of the GNU General Public License as published by                          //
8
// the Free Software Foundation, either version 2 of the License, or                             //
9
// (at your option) any later version.                                                           //
10
//                                                                                               //
11
// Distorted is distributed in the hope that it will be useful,                                  //
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
14
// GNU General Public License for more details.                                                  //
15
//                                                                                               //
16
// You should have received a copy of the GNU General Public License                             //
17
// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //
18
///////////////////////////////////////////////////////////////////////////////////////////////////
19

    
20
package org.distorted.examples.cubes;
21

    
22
import org.distorted.examples.R;
23

    
24
import android.content.Context;
25
import android.opengl.GLSurfaceView;
26
import android.os.Build;
27
import android.util.AttributeSet;
28
import android.view.MotionEvent;
29
import android.widget.Toast;
30

    
31
///////////////////////////////////////////////////////////////////////////////////////////////////
32

    
33
class CubesSurfaceView extends GLSurfaceView 
34
{
35
    private int mX, mY;
36
    private CubesRenderer mRenderer;
37
	
38
///////////////////////////////////////////////////////////////////////////////////////////////////
39
   
40
    public CubesSurfaceView(Context c, AttributeSet attrs) 
41
      {
42
      super(c,attrs);
43
    
44
      mX = -1;
45
      mY = -1;
46
      
47
      if(!isInEditMode())
48
        {
49
        setEGLContextClientVersion(2);
50
        mRenderer = new CubesRenderer(this);
51
        setRenderer(mRenderer);
52
        Toast.makeText(c, R.string.example_rotate_toast , Toast.LENGTH_SHORT).show();
53
        }
54
      }
55
    
56
///////////////////////////////////////////////////////////////////////////////////////////////////
57
    
58
    @Override public boolean onTouchEvent(MotionEvent event) 
59
      {
60
      int action = event.getAction();
61
      int x = (int)event.getX();
62
      int y = (int)event.getY();
63
           
64
      switch(action)
65
         {
66
         case MotionEvent.ACTION_DOWN: mX = x;
67
                                       mY = y;
68
                                       break;
69
                                       
70
         case MotionEvent.ACTION_MOVE: if( mX>=0 && mY>= 0 )
71
                                         {
72
                                         float px = mY-y;
73
                                         float py = mX-x;
74
                                         float pz = 0;
75
                                         float plen = (float)Math.sqrt(px*px + py*py + pz*pz);
76
                                         
77
                                         if( plen>0 )
78
                                           {
79
                                           px /= plen;
80
                                           py /= plen;
81
                                           pz /= plen;
82

    
83
                                           float cosA = (float)Math.cos(plen*3.14f/mRenderer.mScreenMin);
84
                                           float sinA = (float)Math.sqrt(1-cosA*cosA);
85
                                         
86
                                           mRenderer.mQuat1.set(px*sinA, py*sinA, pz*sinA, cosA);
87
                                           }
88
                                         }                             
89
                                       break;
90
                                       
91
         case MotionEvent.ACTION_UP  : mX = -1;
92
                                       mY = -1;
93
        	                           
94
                                       float qx = mRenderer.mQuat1.getX();
95
                                       float qy = mRenderer.mQuat1.getY();
96
                                       float qz = mRenderer.mQuat1.getZ();
97
                                       float qw = mRenderer.mQuat1.getW();
98

    
99
                                       float rx = mRenderer.mQuat2.getX();
100
                                       float ry = mRenderer.mQuat2.getY();
101
                                       float rz = mRenderer.mQuat2.getZ();
102
                                       float rw = mRenderer.mQuat2.getW();
103

    
104
                                       // This is quaternion multiplication. (tx.ty.tz.tw)
105
                                       // is now equal to (qx,qy,qz,qw)*(rx,ry,rz,rw)
106
                                       float tx = rw*qx - rz*qy + ry*qz + rx*qw;
107
                                       float ty = rw*qy + rz*qx + ry*qw - rx*qz;
108
                                       float tz = rw*qz + rz*qw - ry*qx + rx*qy;
109
                                       float tw = rw*qw - rz*qz - ry*qy - rx*qx;
110

    
111
                                       // The point of this is so that there are always
112
                                       // exactly 2 quaternions: Quat1 representing the rotation
113
                                       // accumulating only since the last screen touch, and Quat2
114
                                       // which remembers the combined effect of all previous
115
                                       // swipes.
116
                                       // We cannot be accumulating an ever-growing list of quaternions
117
                                       // and add a new one every time user swipes the screen - there
118
                                       // is a limited number of slots in the EffectQueueMatrix!
119
                                       mRenderer.mQuat1.set(0f, 0f, 0f, 1f);
120
                                       mRenderer.mQuat2.set(tx, ty, tz, tw);
121
                                       
122
                                       break;
123
         }
124
             
125
      return true;
126
      }
127
         
128
}
129

    
(3-3/3)