Java 如何使用GLSURFACHEVIEW创建和理解拖放和缩放事件

我制作了一个测试应用程序，它使用标准顶点、颜色和点缓冲区显示3D对象

我能

• 使用触摸事件旋转对象
• 使用GL10使用openGL ES 1.0渲染对象
• 一切都很好

现在，我想能够放大和缩小使用两个手指的“捏”动作。我找到了一些很好的教程和示例代码，但主要是针对ImageView的。我对Android还是半新手，我不完全了解如何让这个缩放功能在GLSurfaceView上工作

下面是我到目前为止为Activity类编写的代码。第一个触摸处理程序用于我通过为ImageView设计的教程找到的缩放事件（我使用它是因为我认为这将是一个简单的转换）。第二个处理程序用于旋转事件，它工作正常

提前谢谢你，我希望这篇文章能帮助其他人解决同样的问题。 我将随时准备进行任何必要的编辑或添加

 // Activity for rendering 3D object openGL ES 1.0
 public class GL_ExampleActivity extends Activity
 {
      private GLSurfaceView surface;

      @Override
      public void onCreate(Bundle savedInstanceState)
      {
           super.onCreate(savedInstanceState);

           surface = new GL_ExampleSurfaceView(this);
           setContentView(surface);
      }

      @Override
      protected void onPause()
      {
           // TODO Auto-generated method stub
           super.onPause();
           surface.onPause();
      }

      @Override
      protected void onResume()
      {
           // TODO Auto-generated method stub
           super.onResume();
           surface.onResume();
      }
 }

 class GL_ExampleSurfaceView extends GLSurfaceView
 {
      private static final String TAG = "Touch";

      Matrix matrix_new = new Matrix();
      Matrix last_matrix = new Matrix();

      static final int NONE = 0;
      static final int DRAG = 1;
      static final int ZOOM = 2;
      int mode = NONE;

      PointF start = new PointF();
      PointF mid = new PointF();
      float oldDist = 1f;


      private final float SCALE_FACTOR = 180.0f / 320;
      private GLRenderer renderer;
      private float previous_x;
      private float previous_y;

      public GL_ExampleSurfaceView(Context context)
      {
           super(context);

           renderer = new GLRenderer();
           setRenderer(renderer);

           setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
      }

      @Override
      public boolean onTouchEvent(MotionEvent e)
      {
           // handler for drag and zoom events
           switch (e.getAction() & MotionEvent.ACTION_MASK)
           {
                case MotionEvent.ACTION_DOWN:
                     last_matrix.set(matrix_new);
                     start.set(e.getX(), e.getY());
                     Log.d(TAG, "mode=DRAG");
                     mode = DRAG;
                     //requestRender();
                     break;
                case MotionEvent.ACTION_POINTER_DOWN:
                     oldDist = finger_distance(e);
                     Log.d(TAG, "oldDist=" + oldDist);
                     if (oldDist > 10f)
                     {
                         last_matrix.set(matrix_new);
                         finger_distance_midpoint(mid, e);
                         mode = ZOOM;
                         Log.d(TAG, "mode=ZOOM");
                     }
                     //requestRender();
                     break;
                case MotionEvent.ACTION_UP:
                case MotionEvent.ACTION_POINTER_UP:
                     mode = NONE;
                     Log.d(TAG, "mode=NONE");
                     //requestRender();
                     break;
                case MotionEvent.ACTION_MOVE:
                     if (mode == DRAG)
                     {
                          matrix_new.set(last_matrix);
                          matrix_new.postTranslate(e.getX() - start.x, e.getY() - start.y);
                     }
                     else if (mode == ZOOM)
                     {
                          float newDist = finger_distance(e);
                          Log.d(TAG, "newDist=" + newDist);
                          if (newDist > 10f)
                          {
                               matrix_new.set(last_matrix);
                               float scale = newDist / oldDist;
                               matrix_new.postScale(scale, scale, mid.x, mid.y);
                          }
                     }
                    //requestRender();
                    break;
            }
           //view.setImageMatrix(matrix_new);



           // handler for rotation event, y and x axis
           float x = e.getX();
           float y = e.getY();

           switch (e.getAction())
           {
                case MotionEvent.ACTION_MOVE:

                float dx = x - previous_x;
                float dy = y - previous_y;

                if (y > getHeight() / 2)
                {
                     dx = dx * -1 ;
                }

                if (x < getWidth() / 2)
                {
                     dy = dy * -1 ;
                }
                renderer.angle_x += dx * SCALE_FACTOR;
                renderer.angle_y += dy * SCALE_FACTOR;
                requestRender();
           }
           previous_x = x;
           previous_y = y;
           return true;
      }


      private float finger_distance(MotionEvent e)
      {
           float x = e.getX(0) - e.getX(1);
           float y = e.getY(0) - e.getY(1);
           return FloatMath.sqrt(x * x + y * y);
      }

      private void finger_distance_midpoint(PointF point, MotionEvent e)
      {
           float x = e.getX(0) + e.getX(1);
           float y = e.getY(0) + e.getY(1);
           point.set(x / 2, y / 2);
      }

 }

//用于渲染三维对象的活动openGL ES 1.0
公共类GL_示例活动扩展活动
{
私人GLSURFACHEVIEW表面；
@凌驾
创建时的公共void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
表面=新的GL_示例表面视图（此）；
setContentView（表面）；
}
@凌驾
受保护的void onPause（）
{
//TODO自动生成的方法存根
super.onPause（）；
surface.onPause（）；
}
@凌驾
受保护的void onResume（）
{
//TODO自动生成的方法存根
super.onResume（）；
surface.onResume（）；
}
}
类GL_示例surfaceview扩展了GLSurfaceView
{
私有静态最终字符串TAG=“Touch”；
矩阵矩阵_new=新矩阵（）；
矩阵last_矩阵=新矩阵（）；
静态最终int NONE=0；
静态最终整数阻力=1；
静态最终整数缩放=2；
int模式=无；
PointF start=新的PointF（）；
PointF mid=新的PointF（）；
浮动oldDist=1f；
私人最终浮动比例系数=180.0f/320；
私营部门；
私有浮动前_x；
私人浮动；
公共GL_示例SurfaceView（上下文）
{
超级（上下文）；
renderer=新的GLRenderer（）；
设置渲染器（渲染器）；
setRenderMode（GLSurfaceView.RENDERMODE_脏时）；
}
@凌驾
公共事件（运动事件e）
{
//拖动和缩放事件的处理程序
开关（如getAction（）&MotionEvent.ACTION\u掩码）
{
case MotionEvent.ACTION\u DOWN：
最后一个矩阵集合（矩阵新）；
set（e.getX（），e.getY（））；
Log.d（标记“mode=DRAG”）；
模式=拖动；
//requestRender（）；
打破
case MotionEvent.ACTION\u指针\u向下：
oldDist=手指距离（e）；
Log.d（标记“oldDist=“+oldDist”）；
如果（旧区>10f）
{
最后一个矩阵集合（矩阵新）；
手指距离中点（中点，e）；
模式=缩放；
Log.d（标记“mode=ZOOM”）；
}
//requestRender（）；
打破
case MotionEvent.ACTION\u UP：
case MotionEvent.ACTION\u指针\u向上：
模式=无；
Log.d（标记“mode=NONE”）；
//requestRender（）；
打破
case MotionEvent.ACTION\u移动：
如果（模式==拖动）
{
矩阵新集合（最后一个矩阵）；
矩阵_new.postTranslate（e.getX（）-start.x，e.getY（）-start.y）；
}
else if（模式==缩放）
{
float newDist=指距（e）；
Log.d（标记“newDist=“+newDist”）；
如果（新距离>10f）
{
矩阵新集合（最后一个矩阵）；
浮动比例=新距离/旧距离；
矩阵_新的后标度（标度、标度、中x、中y）；
}
}
//requestRender（）；
打破
}
//视图.setImageMatrix（新矩阵）；
//旋转事件的处理程序，y轴和x轴
float x=e.getX（）；
float y=e.getY（）；
开关（如getAction（））
{
case MotionEvent.ACTION\u移动：
浮点数dx=x——上一个_x；
float dy=y-上一个y；
如果（y>getHeight（）/2）
{
dx=dx*-1；
}
if（x

---

再次感谢……

有两种明显的方法