I think you need to change your view port in your draw method.

On Aug 22, 11:42 pm, souza <[email protected]> wrote:
> Hi,
>
> I'm trying to get two viewports setup on the screen of the Android
> Emulator (I have no real Android device as my University only gave me
> a tablet pc with Windows 7 for development).
> The FIRST VIEWPORT (orthographic projection) fills the emulators
> screen and displays a white, screen filling polygon. The SECOND
> VIEWPORT (perspective projection) is only a square inside the screen
> and should appear above the other viewport showing a cube. Now, when i
> have both viewports active I cannot see the white polygon but the
> smaller viewport with the cube. In case I have the second viewports
> code in block comments it again apears. I don't get where I have to
> modify the code that both viewports appear correctly on the emulator.
> Here are some code snippets:
>
> --CODE--------------
>
> public void onSurfaceCreated(GL10 gl, EGLConfig config) {
>                 // Set the background color to red ( rgba ).
>                 gl.glClearColor(1.0f, 0.0f, 0.0f, 0.5f);
>                 // Enable Smooth Shading, default not really needed.
>                 gl.glShadeModel(GL10.GL_SMOOTH);
>                 // Depth buffer setup.
>                 gl.glClearDepthf(1.0f);
>                 // Enables depth testing.
>                 gl.glEnable(GL10.GL_DEPTH_TEST);
>                 // The type of depth testing to do.
>                 gl.glDepthFunc(GL10.GL_LEQUAL);
>                 // Really nice perspective calculations.
>                 gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,
> GL10.GL_NICEST);
>
> }
>
> public void onDrawFrame(GL10 gl) {
>
>                 // Clears the screen and depth buffer.
>                 gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
>                 // Modelview Matrix selektieren
>                 gl.glMatrixMode(GL10.GL_MODELVIEW);
>                 // Replace the current Matrix with the identity matrix
>                 gl.glLoadIdentity();
>                 // Translates 6 units into the screen
>                 gl.glTranslatef(0, 0, -10);
>
>                 // Draw RECTANGLE
>                 square.draw(gl);
>
>                 // CUBE
>                 // Save the current matrix
>                 gl.glPushMatrix();
>                         gl.glTranslatef(0, 0, -5);
>                         // Draw the cube
>                         root.draw(gl);
>                 // Restore the last matrix
>                 gl.glPopMatrix();
>
> }
>
> public void onSurfaceChanged(GL10 gl, int width, int height) {
>
>                 for(int i = 0; i < 2; i++) {
>
>                         if(i==0) {
>                                 // Main Viewport
>                                 gl.glViewport(0, 0, width, height);
>                                 // Select the projection matrix
>                                 gl.glMatrixMode(GL10.GL_PROJECTION);
>                                 // Reset the projection matrix
>                                 gl.glLoadIdentity();
>                                 // Setup orthographic projection.
> Consider aspect ratio to avoid distortion.
>                                 if(width < height) {
>                                         gl.glOrthof(-1.0f, 1.0f, -1.0f
> * height / width, 1.0f * height / width, -2.0f, 10.0f);
>                                 } else {
>                                         gl.glOrthof(-1.0f * width /
> height, 1.0f * width / height, -1.0f, 1.0f, -2.0f, 10.0f);
>                                 }
>
>                                 GLU.gluLookAt(gl, 0.0f, 0.0f, 0.0f,
> 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f);
>                         }
>
>                         if(i==1) {
>                                 // Sets the cube's viewport.
>                                 gl.glViewport(width/2, height/3, width/
> 2, height/3);
>                                 // Select the projection matrix
>                                 gl.glMatrixMode(GL10.GL_PROJECTION);
>                                 // Reset the projection matrix
>                                 gl.glLoadIdentity();
>                                 // Calculate the aspect ratio of the
> window
>                                 GLU.gluPerspective(gl, 45.0f, (float)
> width / (float) height, -2.0f, 10.0f);
>
>                                 GLU.gluLookAt(gl, 0.0f, 0.0f, 0.0f,
> 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f);
>                         }
>                         // Select the modelview matrix
>                         gl.glMatrixMode(GL10.GL_MODELVIEW);
>                         // Reset the modelview matrix
>                         gl.glLoadIdentity();
>                         // Clear Depth Buffer
>                         gl.glClear(GL10.GL_DEPTH_BUFFER_BIT);
>                 }
>
> }
>
> --CODE--------------
>
> Here is a screenshot how it looks in the emulator when I have both
> viewports active:
>
> http://userpages.uni-koblenz.de/~saditanis/picture.jpg
>
> Maybe somebody can tell me if I have an errror in reasoning!

-- 
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