Hi,

Try to add a Log statement to your constructor, to see if you have
more than one SurfaceView created.

Hardy Henneberg
http://www.maxikeys.com


On Nov 7, 12:11 pm, saex <[email protected]> wrote:
> First of all, this is not a duplicate of other questions with similar
> error, because in these questions, the solution of the error is that
> there are various threads and there is a problem with various threads,
> but i'm not using various threads, my problem is not the same.
>
> I have a simple Square with openGL es 1 and Android 1.5. The square is
> painted on the center of the screen.
>
> I want that when the user press on the screen, or moves the finger on
> the screen, the square get's moved to that position. For do this i
> tryed with GLuUnProject, i tryed to obtain the opengl coordinate that
> matches with the window XY coordinate touched with the finger (to
> translate the polygon to that coordinate in the future), and i'm
> writting the coordinates on the LogCat.
>
> The coordinate's i'm receiving are not true cordinates, are wrong
> coordinates, also i'm getting the error of the tittle of the question.
> `ERROR/libEGL(206): call to OpenGL ES API with no current context`
>
> The LogCat:
>
>     11-07 09:43:40.012: DEBUG/XXXXXXXXX(203): X: -1.2918732
>     11-07 09:43:40.023: DEBUG/XXXXXXXXX(203): Y: 0.050911963
>     11-07 09:43:40.042: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.042: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.042: DEBUG/XXXXXXXXX(203): X: -1.2943747
>     11-07 09:43:40.052: DEBUG/XXXXXXXXX(203): Y: 0.04674524
>     11-07 09:43:40.152: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.152: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.172: DEBUG/XXXXXXXXX(203): X: 0.77298313
>     11-07 09:43:40.182: DEBUG/XXXXXXXXX(203): Y: -0.5083332
>     11-07 09:43:40.223: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.223: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.223: DEBUG/XXXXXXXXX(203): X: 0.77298313
>     11-07 09:43:40.223: DEBUG/XXXXXXXXX(203): Y: -0.5083332
>     11-07 09:43:40.402: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.402: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:40.402: DEBUG/XXXXXXXXX(203): X: -1.2943747
>     11-07 09:43:40.402: DEBUG/XXXXXXXXX(203): Y: 0.04674524
>     11-07 09:43:41.952: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:41.952: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:41.952: DEBUG/XXXXXXXXX(203): X: 0.77298313
>     11-07 09:43:41.952: DEBUG/XXXXXXXXX(203): Y: -0.5083332
>     11-07 09:43:42.042: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>     11-07 09:43:42.042: ERROR/libEGL(203): call to OpenGL ES API with
> no current context
>
> My code:
>
>     public class MySurfaceView extends GLSurfaceView implements
> Renderer {
>         private float INITIAL_Z = -35.0f;
>         private Context context;
>         private Square square;
>         private float xrot;                                     //X Rotation
>         private float yrot;                                     //Y Rotation
>         private float zrot;                                     //Z Rotation
>         private float z = INITIAL_Z;                    //Profundidad en el 
> eje Z
>         private float x = 0.0f;                         //eje X
>         private float y = 0.0f;                         //eje Y
>
>     private MatrixGrabber mg = new MatrixGrabber(); //create the
> matrix grabber object in your initialization code
>     private GL10 MyGl; //To make gl variable accesible on all the
> methods of the class
>         byte horizontal=-1; //0: LEFT  1:CENTER  2:RIGHT
>         byte vertical=-1; //0: TOP  1:CENTER  2:BOTTOM
>         float startX=-1;
>         float startY=-1;
>         float xMovement=0.0f;
>         float yMovement=0.0f;
>         private boolean movement_mode=false;
>
>         public MySurfaceView(Context context, Bitmap image, int width, byte
> horizontal, byte vertical) {
>                 super(context);
>                 this.context = context;
>                 setEGLConfigChooser(8, 8, 8, 8, 16, 0); //fondo transparente
>                 getHolder().setFormat(PixelFormat.TRANSLUCENT); //fondo 
> transparente
>                 //Transformamos esta clase en renderizadora
>                 this.setRenderer(this);
>                 //Request focus, para que los botones reaccionen
>                 this.requestFocus();
>                 this.setFocusableInTouchMode(true);
>                 square = new Square(image);
>                 this.horizontal=horizontal;
>                 this.vertical=vertical;
>         }
>
>         public void onSurfaceCreated(GL10 gl, EGLConfig config) {
>                 MyGl=gl;
>                 gl.glDisable(GL10.GL_DITHER);                           
> //dithering OFF
>                 gl.glEnable(GL10.GL_TEXTURE_2D);                        
> //Texture Mapping ON
>                 gl.glShadeModel(GL10.GL_SMOOTH);                        
> //Smooth Shading
>                 gl.glClearDepthf(1.0f);                                       
>   //Depth Buffer Setup
>                 gl.glEnable(GL10.GL_DEPTH_TEST);                        
> //Depth Testing ON
>                 gl.glDepthFunc(GL10.GL_LEQUAL);
>                 gl.glClearColor(0,0,0,0); //fondo transparente
>                 gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, 
> GL10.GL_NICEST);
>                 //Cargamos la textura del cubo.
>                 square.loadGLTexture(gl, this.context);
>         }
>
>         public void onDrawFrame(GL10 gl) {
>                 //Limpiamos pantalla y Depth Buffer
>                 gl.glClear(GL10.GL_COLOR_BUFFER_BIT | 
> GL10.GL_DEPTH_BUFFER_BIT);
>                 gl.glLoadIdentity();
>                 //Dibujado
>                 gl.glTranslatef(x, y, z);                       //Move z 
> units into the screen
>                 //gl.glScalef(0.8f, 0.8f, 0.8f);                        
> //Escalamos para que quepa en la
> pantalla
>                 //Rotamos sobre los ejes.
>                 gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f);   //X
>                 gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);   //Y
>                 gl.glRotatef(zrot, 0.0f, 0.0f, 1.0f);   //Z
>                 //Dibujamos el cuadrado
>                 square.draw(gl);
>         }
>
>         //si el surface cambia, resetea la vista, imagino que esto pasa
> cuando cambias de modo portrait/landscape o sacas el teclado físico en
> móviles tipo Droid.
>         public void onSurfaceChanged(GL10 gl, int width, int height) {
>                 if(height == 0) {
>                         height = 1;
>                 }
>                 gl.glViewport(0, 0, width, height);     //Reset Viewport
>                 gl.glMatrixMode(GL10.GL_PROJECTION);    //Select Projection 
> Matrix
>                 gl.glLoadIdentity();                                    
> //Reset Projection Matrix
>                 //Aspect Ratio de la ventana
>                 GLU.gluPerspective(gl, 45.0f, (float)width / (float)height, 
> 0.1f,
> 100.0f);
>                 gl.glMatrixMode(GL10.GL_MODELVIEW);     //Select Modelview 
> Matrix
>                 gl.glLoadIdentity();                                    
> //Reset Modelview Matrix
>         }
>
>         public boolean onTouchEvent(MotionEvent event) {
>                 float [] outputCoords=getOpenGLCoords(event.getX(), 
> event.getY(),
> 0);
>                 x=(outputCoords[0]/outputCoords[3]);
>                 y=(outputCoords[1]/outputCoords[3]);
>                 //z=outputCoords[2]/outputCoords[3];
>                 Log.d("XXXXXXXXX", "X: "+x);
>                 Log.d("XXXXXXXXX", "Y: "+y);
>         return true; //El evento ha sido manejado
>         }
>
>         public float[] getOpenGLCoords(float xWin,float yWin,float zWin)
>         {
>                 int screenW=SectionManager.instance.getDisplayWidth();
>                 int screenH=SectionManager.instance.getDisplayHeight();
>                 //CODE FOR TRANSLATING FROM SCREEN COORDINATES TO OPENGL 
> COORDINATES
>                 mg.getCurrentProjection(MyGl);
>                 mg.getCurrentModelView(MyGl);
>             float [] modelMatrix = new float[16];
>             float [] projMatrix = new float[16];
>             modelMatrix=mg.mModelView;
>             projMatrix=mg.mProjection;
>             int [] mView = new int[4];
>             mView[0] = 0;
>             mView[1] = 0;
>             mView[2] = screenW; //width
>             mView[3] = screenH; //height
>             float [] outputCoords = new float[4];
>             GLU.gluUnProject(xWin, ((float)screenH)-yWin, zWin, modelMatrix,
> 0, projMatrix, 0, mView, 0, outputCoords, 0);
>             return outputCoords;
>         }
>     }

-- 
You received this message because you are subscribed to the Google
Groups "Android Developers" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/android-developers?hl=en

Reply via email to