Android开放式Gl对象选择

在OpenGL中，有一个术语称为拾取。用于确定选择了屏幕上的哪个对象。有人能给我解释一下在对象的每个实例（比如立方体类）中使用拾取和放置基于触摸的侦听器之间的区别吗

假设地；我想做的是在屏幕上随机演示多个立方体。我想如果我给多维数据集类一个监听器，在触摸多维数据集时，监听器应该为每个按下的多维数据集相应地触发

这是我要添加侦听器的代码。 这是可能的还是必要的

public class Cube extends Shapes {
private FloatBuffer mVertexBuffer;
private FloatBuffer mColorBuffer;
private ByteBuffer mIndexBuffer;
private Triangle[] normTris = new Triangle[12];
private Triangle[] transTris = new Triangle[12];

// every 3 entries represent the position of one vertex
private float[] vertices =
        {
                -1.0f, -1.0f, -1.0f,
                1.0f, -1.0f, -1.0f,
                1.0f, 1.0f, -1.0f,
                -1.0f, 1.0f, -1.0f,
                -1.0f, -1.0f, 1.0f,
                1.0f, -1.0f, 1.0f,
                1.0f, 1.0f, 1.0f,
                -1.0f, 1.0f, 1.0f
        };

// every 4 entries represent the color (r,g,b,a) of the corresponding vertex in      vertices
 private float[] colors =
        {
                1.0f, 0.0f, 0.0f, 1.0f,
                0.0f, 1.0f, 0.0f, 1.0f,
                0.0f, 0.0f, 1.0f, 1.0f,
                1.0f, 0.0f, 0.0f, 1.0f,
                0.0f, 1.0f, 0.0f, 1.0f,
                0.0f, 0.0f, 1.0f, 1.0f,
                0.0f, 0.0f, 0.0f, 1.0f,
                1.0f, 1.0f, 1.0f, 1.0f
        };
// every 3 entries make up a triangle, every 6 entries make up a side
private byte[] indices =
        {
                0, 4, 5, 0, 5, 1,
                1, 5, 6, 1, 6, 2,
                2, 6, 7, 2, 7, 3,
                3, 7, 4, 3, 4, 0,
                4, 7, 6, 4, 6, 5,
                3, 0, 1, 3, 1, 2
        };
private float[] createVertex(int Index)
{
   float[] vertex = new float[3];
   int properIndex = Index * 3;
   vertex[0] = vertices[properIndex];
   vertex[1] = vertices[properIndex + 1];
   vertex[2] = vertices[properIndex + 2];
   return vertex;
}

public Triangle getTriangle(int index){
    Triangle tri = null;
   //if(index >= 0 && index < indices.length){
       float[] v1 = createVertex(indices[(index * 3) + 0]);
       float[] v2 = createVertex(indices[(index * 3) + 1]);
       float[] v3 = createVertex(indices[(index * 3) + 2]);
       tri = new Triangle(v1, v2, v3);
  // }
       return tri;

}

public int getNumberOfTriangles(){
    return indices.length / 3;
}

public boolean checkCollision(Ray r, OpenGLRenderer renderer){

    boolean isCollide = false;

    int i = 0; 
    while(i < getNumberOfTriangles() && !isCollide){
        float[] I = new float[3];
        if(Shapes.intersectRayAndTriangle(r, transTris[i], I) > 0){
            isCollide = true;
        }

        i++;
    }


    return isCollide;
}

public void translate(float[] trans){
    for(int i = 0; i < getNumberOfTriangles(); i++){
        transTris[i].setV1(Vector.addition(transTris[i].getV1(), trans));
        transTris[i].setV2(Vector.addition(transTris[i].getV2(), trans));
        transTris[i].setV3(Vector.addition(transTris[i].getV3(), trans));
    }
}

public void scale(float[] scale){
    for(int i = 0; i < getNumberOfTriangles(); i++){
        transTris[i].setV1(Vector.scalePoint(transTris[i].getV1(), scale));
        transTris[i].setV2(Vector.scalePoint(transTris[i].getV2(), scale));
        transTris[i].setV3(Vector.scalePoint(transTris[i].getV3(), scale));
    }
}

public void resetTransfomations(){
    for(int i = 0; i < getNumberOfTriangles(); i++){
        transTris[i].setV1(normTris[i].getV1().clone());
        transTris[i].setV2(normTris[i].getV2().clone());
        transTris[i].setV3(normTris[i].getV3().clone());
    }
}

public Cube()
{
    Buffer[] buffers = super.getBuffers(vertices, colors, indices);
    mVertexBuffer = (FloatBuffer) buffers[0];
    mColorBuffer = (FloatBuffer) buffers[1];
    mIndexBuffer = (ByteBuffer) buffers[2];
}

public Cube(float[] vertices, float[] colors, byte[] indices)
{
    if(vertices != null) {
        this.vertices = vertices;
    }
    if(colors != null) {
        this.colors = colors;
    }
    if(indices != null) {
        this.indices = indices;
    }
    Buffer[] buffers = getBuffers(this.vertices, this.colors, this.indices);
    mVertexBuffer = (FloatBuffer) buffers[0];
    mColorBuffer = (FloatBuffer) buffers[1];
    mIndexBuffer = (ByteBuffer) buffers[2];

    for(int i = 0; i < getNumberOfTriangles(); i++){
        normTris[i] = getTriangle(i);
        transTris[i] = getTriangle(i);
    }
}

public void draw(GL10 gl)
{
    gl.glFrontFace(GL10.GL_CW);

    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);
    gl.glColorPointer(4, GL10.GL_FLOAT, 0, mColorBuffer);

    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

    // draw all 36 triangles
    gl.glDrawElements(GL10.GL_TRIANGLES, 36, GL10.GL_UNSIGNED_BYTE, mIndexBuffer);

    gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
}
}

公共类多维数据集扩展形状{
私有FloatBuffer mVertexBuffer；
私人浮动缓冲区mColorBuffer；
私人ByteBuffer mIndexBuffer；
私有三角形[]normTris=新三角形[12]；
私有三角形[]transTris=新三角形[12]；
//每3个条目代表一个顶点的位置
私有浮点[]顶点=
{
-1.0f，-1.0f，-1.0f，
1.0f，-1.0f，-1.0f，
1.0f，1.0f，-1.0f，
-1.0f，1.0f，-1.0f，
-1.0f，-1.0f，1.0f，
1.0f，-1.0f，1.0f，
1.0f，1.0f，1.0f，
-1.0f，1.0f，1.0f
};
//每4个条目表示顶点中对应顶点的颜色（r、g、b、a）
私人浮动[]颜色=
{
1.0f，0.0f，0.0f，1.0f，
0.0f，1.0f，0.0f，1.0f，
0.0f，0.0f，1.0f，1.0f，
1.0f，0.0f，0.0f，1.0f，
0.0f，1.0f，0.0f，1.0f，
0.0f，0.0f，1.0f，1.0f，
0.0f，0.0f，0.0f，1.0f，
1.0f，1.0f，1.0f，1.0f
};
//每3个条目组成一个三角形，每6个条目组成一条边
专用字节[]索引=
{
0, 4, 5, 0, 5, 1,
1, 5, 6, 1, 6, 2,
2, 6, 7, 2, 7, 3,
3, 7, 4, 3, 4, 0,
4, 7, 6, 4, 6, 5,
3, 0, 1, 3, 1, 2
};
私有浮点[]createVertex（整数索引）
{
浮点[]顶点=新浮点[3]；
int properIndex=索引*3；
顶点[0]=顶点[PropertyIndex]；
顶点[1]=顶点[PropertyIndex+1]；
顶点[2]=顶点[PropertyIndex+2]；
返回顶点；
}
公共三角形getTriangle（整数索引）{
三角形三=零；
//如果（索引>=0&&index0）{
isCollide=true；
}
i++；
}
回归方程；
}
公共无效转换（浮动[]转换）{
对于（int i=0；i

在这种情况下，使用侦听器不起作用

如果你举个例子，看看这个。这基本上是一个只提供一个onTouch（）方法的接口。现在，当android处理触摸输入时，目标视图被触摸，它知道可以通过调用监听器的onTouch（）通知监听器触摸

当使用OpenGL时，您会遇到一个问题，即没有人处理OpenGL曲面内部的触摸输入。你必须自己做。所以没有人会给你的听众打电话

为什么?？在gl曲面中渲染什么取决于您。你只知道实际的几何体是什么，因此你是唯一能决定哪一个的人