[ Part II ] - AndroidGL Tutorial - A blank screen

plusminus · by **plusminus** » Fri Dec 07, 2007 9:06 pm

This is Part II of the Android OpenGL-Tutorial powered by brendan.d.burns
:larrow: previous....................................................next :rarrow:

:idea: In this tutorial we are referring to the GLTutorialOne.java from brendans AndroidGL-Tutorial-Package (Download from Google-Code).
The code here is partially altered for a bit easier understanding.
:idea: :idea:

Download that package, to run that specific Tutorial. :idea:

What you will learn: This tutorial will explain how to prepare a OpenGL ES 'View' to allow drawing of primitives later.

Preparing a blank screen

In our constructor, we place a call to glClearColor(...). This is used to specify what color the window should be cleared with. The function takes 4 parameters. These parameters represent the RGBA color values and can range from 0.0f to 1.0f.

The first three parameters indicate your red, green and blue values. The larger the value, the brighter the color. If all values are 0.0f, you get black. If all values are 1, you get white.

The last value is the alpha value. This is used for transparency. 1.0f is completely opaque and 0.0f is completely transparent.

The code below sets the clearing color to black.

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

public class GLTutorialOne extends View {
        protected OpenGLContext myGLContext;
        protected GL10 myGL;
        
        public GLTutorialOne(Context c) {
                super(c);
                /* Create a OpenGLContext
                 * In this case there is no 
                 * need to save it, but in other
                 * cases it will be reused. */
                this.myGLContext = new OpenGLContext(0);
                /* Store the GL interface that will handle  
                 * the actual graphical operations */
                this.myGL = (GL10)this.myGLContext.getGL();
                
                /* Set the color to be uses when clearing
                 * Params: Red, Green, Blue, Alpha
                 * All from (0.0f up to 1.0f) 
                 * Below we use a android-green =) */
                this.myGL.glClearColor(0.0f, 0.8f, 0.0f, 0.0f);
        }
Parsed in 0.032 seconds,  using GeSHi 1.0.8.4

We start off by first clearing the color buffer. This is achieved by using the glClear function. This function accepts one parameter being which buffers you want to clear. Other buffers will be discussed at a later stage. For now, you only need to know about the color buffer. This is specified by using the GL_COLOR_BUFFER_BIT flag. This causes the screen to be cleared to the color (android-green) specified above.

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

        protected void onDraw(Canvas canvas) {          
                /* Associate the glContext with the
                 * canvas it should draw on */
                this.myGLContext.waitNative(canvas, this);
Parsed in 0.030 seconds,  using GeSHi 1.0.8.4

waitNative() makes sure all pending native drawing calls have completed and binds this view's surface to the specified context.

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

                /* waitNative() makes sure all pending 
                 * native drawing calls  have completed 
                 * and binds this passed canvas to 
                 * the specified context(here: this). */
                this.myGL.glClear(GL10.GL_COLOR_BUFFER_BIT);
        }
Parsed in 0.033 seconds,  using GeSHi 1.0.8.4

Thats it, when you run this application it shows a background with the clearColor we defined above.

Full Source:

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

package edu.union;
 
import javax.microedition.khronos.opengles.GL10;
 
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.OpenGLContext;
import android.view.View;
 
public class GLTutorialOne extends View {
        protected OpenGLContext myGLContext;
        protected GL10 myGL;
        
        public GLTutorialOne(Context c) {
                super(c);
                /* Create a OpenGLContext
                 * In this case there is no 
                 * need to save it, but in other
                 * cases it will be reused. */
                this.myGLContext = new OpenGLContext(0);
                /* Store the GL interface that will handle  
                 * the actual graphical operations */
                this.myGL = (GL10)this.myGLContext.getGL();
                
                /* Set the color to be uses when clearing
                 * Params: Red, Green, Blue, Alpha
                 * All from (0.0f up to 1.0f) 
                 * Below we use a android-green =) */
                this.myGL.glClearColor(0.0f, 0.8f, 0.0f, 0.0f);
        }
        
        protected void onDraw(Canvas canvas) {          
                /* waitNative() makes sure all pending 
                 * native drawing calls  have completed 
                 * and binds this passed canvas to 
                 * the specified context(here: this). */
                this.myGLContext.waitNative(canvas, this);
                
                /* This call will finally cause our
                 * canvas to be cleared to the color
                 * we passed in the constructor */
                this.myGL.glClear(GL10.GL_COLOR_BUFFER_BIT);
        }
}
Parsed in 0.038 seconds,  using GeSHi 1.0.8.4

Regards,
plusminus

ufmemo · by **ufmemo** » Wed Dec 12, 2007 6:40 pm

Would be useful for me to see a snippet on how to wire this view to an Activity....

plusminus · by **plusminus** » Wed Dec 12, 2007 6:58 pm

Hello ufmemo,

Look what the first lines of this tutorial tell:

:idea: Download that package, to run that specific Tutorial.

Regards,
plusminus

ufmemo · by **ufmemo** » Thu Dec 13, 2007 12:10 am

i must have just read past that piece...

thanks!!

ps. i think you are doing an excellent job with this site.

Borealis · by **Borealis** » Wed Feb 20, 2008 4:56 pm

Hi,

New to the board, nice site!

Since the m5 update I've found my old opengl test programs and the tutorial examples here do not work.

The package mentioned requires the manifest and several bits of code to be changed - glContext.waitNative

Stepping through with the debugger I find the very first gl call crash.

The new samples provided by the SDK work, but they use SurfaceView and a thread for the main gl drawing.

Does anyone have ideas as to why?

benny! · by **benny!** » Thu Mar 06, 2008 5:27 pm

@Borealis:

I just tested the new examples and also noticed the changes.

Here is what I found on the google groups :

> I see in the new SDK they removed opengl support for drawing on a
> canvas from
> "Canvas canvas = holder.lockCanvas();" by getting rid of
> "glc.waitNative(canvas, null);"
> now waitNative takes no parameters and if you use the lockCanvas
> method to get a canvas to draw on, it causes the opengl images to
> flash in and out for each frame.
> instead they included an example for using overlays with xml code
> only.
> my question is, is it possible to still do the old (simple) style for
> drawing over/behind a SurfaceView that uses opengl?

There is no way with the current SDK to use the canvas normally
associated to the SurfaceView while it is bound to the OpenGLContext.
This feature /may/ come back, but it is generally such a big
performance hit that it's not practical to use. The issue is that in
the case of a H/W accelerated OpenGL context, the overhead of the
necessary synchronization between the main CPU and the GPU is usually
so prohibitive that doing so would nullify using accelerated 3D
graphics.

When a SurfaceView is bound to an OpenGLContext, lockCanvas/
unlockCanvasAndPost are appropriately managed by OpenGLContext and it
is an error to call these APIs manually.

I will look into the possibility of bringing this feature back.

Thank you for your feedback.

Mathias

robisen · by **robisen** » Sun Mar 23, 2008 8:37 pm

OpenGLAUActivity.java

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

//your package 
 
import android.app.Activity;
 
import android.os.Bundle;
 
public class OpenGLAUActivity extends Activity {
 
         private GLSurfaceView mGLSurfaceView;
 
    @Override
 
    public void onCreate(Bundle icicle) {
 
        super.onCreate(icicle);
 
        setContentView(R.layout.main);
 
        mGLSurfaceView = new GLSurfaceView(this);
 
        setContentView(mGLSurfaceView);
 
    }
 
    @Override
 
    protected void onResume() {
 
        super.onResume();
 
    }
 
    @Override
 
    protected void onPause() {
 
        super.onPause();
 
    }
 
}
Parsed in 0.038 seconds,  using GeSHi 1.0.8.4

Now the blank window

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

import android.content.Context;
 
import android.graphics.OpenGLContext;
 
import android.graphics.Canvas;
 
import android.view.View;
 
import javax.microedition.khronos.opengles.GL10;
 
public class GLSurfaceView extends View {
 
        private OpenGLContext glContext;
 
        public GLSurfaceView(Context c) {
 
                super(c);
 
                glContext = new OpenGLContext(0);
 
                GL10 gl = (GL10)glContext.getGL();
 
                // set the color for the window to black
 
                gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
        }
 
        protected void onDraw(Canvas canvas) {
 
                GL10 gl = (GL10)glContext.getGL();
 
                glContext.waitNative();
 
                // clear the color buffer 
 
                gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
 
        }
 
}
 
Parsed in 0.038 seconds,  using GeSHi 1.0.8.4

If I have time I plan to go through the tutorials and update them as separate projects and get them working in M5 as a learning exercise. Hope this helps people.

plusminus · by **plusminus** » Mon Mar 24, 2008 10:07 am

Hello robisen,

robisen wrote:...
If I have time I plan to go through the tutorials and update them as separate projects and get them working in M5 as a learning exercise. Hope this helps people.

That would be fine

Best Regards,
plusminus

robisen · by **robisen** » Tue Mar 25, 2008 5:27 am

So this is somewhat based on tutorial two from android-gl but it works with M5 and the problem with the other code samples is you are now not allowed to manually create or manage surfaces. You have to to do everything asynchronously by requesting a thread, then creating it that holds a reference or handle to your surface, and then get notified if the surface goes away and you stop the thread.

Sorry if the code is ugly but I am just hacking stuff together to make sure I understand whats going on. Obviously you could separate this all out into multiple class. BTW to just draw a blank screen remove the //start drawing comment.

uhh.. i may try to do more of the examples if time permits.

Syntax: [ Download ] [ Hide ]

Using java Syntax Highlighting

 
import java.nio.ByteBuffer;
 
import java.nio.ByteOrder;
 
import java.nio.FloatBuffer;
 
import android.app.Activity;
 
import android.opengl.GLU;
 
import android.os.Bundle;
 
/* imports for creating a SurfaceView */
 
import android.content.Context;
 
import android.graphics.OpenGLContext;
 
import android.view.SurfaceHolder;
 
import android.view.SurfaceView;
 
import javax.microedition.khronos.opengles.GL10;
 
public class SquareActivity extends Activity {
 
        /** Called when the activity is first created. */
 
        @Override
 
        public void onCreate(Bundle icicle) {
 
                super.onCreate(icicle);
 
                setContentView(new DrawingSurfaceView(this));
 
        }
 
        class DrawingSurfaceView extends SurfaceView implements SurfaceHolder.Callback  {
 
                // this handles all the creation, destruction, etc. for getting a surface
 
                // and it does so asynchronously
 
                public SurfaceHolder mHolder;
 
                private OpenGLContext glc;
 
                // this thread will do the actual drawing
 
                public DrawingThread mThread;
 
                public DrawingSurfaceView(Context c) {
 
                        super(c);
 
                        init();
 
                }
 
                public void init() {
 
                        // This is defined in the Android Library
 
                        mHolder = getHolder();
 
                        // by registering as a call back, we receive events from the SurfaceHolder
 
                        // notifying us when a new surface is ready, or if the surface we were using was destroyed
 
                        mHolder.addCallback(this);
 
                }
 
                public void surfaceCreated(SurfaceHolder holder) {
 
                        // We have a new surface, so start a thread that will draw to it
 
                        mThread = new DrawingThread();
 
                        mThread.start();
 
                }
 
                public void surfaceDestroyed(SurfaceHolder holder) {
 
                        // Our surface was destroyed, stop the thread drawing to it
 
                        mThread.waitForExit();
 
                        mThread = null;
 
                }
 
                public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
 
                        // The surface layout has changed
 
                        // So change the size of our output window
 
                        mThread.onWindowResize(w, h);
 
                }
 
                // Define the thread that will run to actually do the drawing on a surface
 
                class DrawingThread extends Thread {
 
                        boolean stop;
 
                        int w;
 
                        int h;
 
                        DrawingThread() {
 
                                super();
 
                                stop = false;
 
                                w = 0;
 
                                h = 0;
 
                        }
 
                        @Override
 
                        public void run() {
 
                                // create a new opengl context
 
                                OpenGLContext glc = new OpenGLContext( OpenGLContext.DEPTH_BUFFER );
 
                                // grab a reference to our parent's surface handle.
 
                                SurfaceHolder holder = mHolder;
 
                                // then assign the context to the parent's surface
 
                                glc.makeCurrent(holder);
 
                                // now grab in interface to opengl
 
                                GL10 gl = (GL10)(glc.getGL());
 
                                // now set any other one-time settings for this context
 
                                gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);
 
                                // now draw forever until asked to stop
 
                                while( ! stop ) {
 
                                        int W, H; // copies of the current width and height
 
                                        synchronized(this) {
 
                                                W = this.w;
 
                                                H = this.h;
 
                                        }
 
                                        drawFrame(gl, W, H);
 
                                        glc.post();
 
                                }
 
                                // if we've been asked to stop
 
                                // remove the reference to the surface
 
                                glc.makeCurrent((SurfaceHolder)null);
 
                        }
 
                        // when a window is resized, adjust the size of the output
 
                        public void onWindowResize(int w, int h) {
 
                                synchronized(this) {
 
                                        this.w = w;
 
                                        this.h = h;
 
                                }
 
                        }
 
                        public void waitForExit() {
 
                                stop = true;
 
                                try {
 
                                        join();
 
                                } catch (InterruptedException ex) {
 
                                }
 
                        }
 
                        private void drawFrame(GL10 gl, int w, int h) {
 
                                // do whatever drawing here.
 
                                gl.glViewport(0, 0, w, h);
 
                                /*
 
                                 * Set our projection matrix. This doesn't have to be done
 
                                 * each time we draw, but usualy a new projection needs to be set
 
                                 * when the viewport is resized.
 
                                 */
 
                                float ratio = (float)w / h;
 
                                gl.glMatrixMode(GL10.GL_PROJECTION);
 
                                gl.glLoadIdentity();
 
                                gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
 
                                /*
 
                                 * By default, OpenGL enables features that improve quality
 
                                 * but reduce performance. One might want to tweak that
 
                                 * especially on software renderer.
 
                                 */
 
                                /*
 
                                 * Usually, the first thing one might want to do is to clear
 
                                 * the screen.
 
                                 */
 
                                gl.glClearColor(1,1,1,1);  // set the backgroudn to white
 
                                gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
 
                                //  start drawing
 
                                float[] square = new float[] {  0.25f, 0.25f, 0.0f,
 
                                                0.75f, 0.25f, 0.0f,
 
                                                0.25f, 0.75f, 0.0f,
 
                                                0.75f, 0.75f, 0.0f };
 
                                FloatBuffer squareBuff;
 
                                ByteBuffer bb = ByteBuffer.allocateDirect(square.length*4);
 
                                bb.order(ByteOrder.nativeOrder());
 
                                squareBuff = bb.asFloatBuffer();
 
                                squareBuff.put(square);
 
                                squareBuff.position(0);
 
                                gl.glMatrixMode(GL10.GL_PROJECTION);
 
                                gl.glLoadIdentity();
 
                                GLU.gluOrtho2D(gl, 0.0f,1.2f,0.0f,1.0f);
 
                                gl.glVertexPointer(3, GL10.GL_FLOAT, 0, squareBuff);
 
                                gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
 
                                gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
 
                                gl.glColor4f(0,1,1,1);
 
                                gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);
 
                         glc.waitGL();
 
                        }
 
                }
 
        }
 
}
 
Parsed in 0.054 seconds,  using GeSHi 1.0.8.4

robisen · by **robisen** » Thu Mar 27, 2008 2:41 am

i just updated several of the examples to work with M5 and then got a email from Brandon saying he updated all of his code so go to android-gl to get the updated tutorial code.

whreckz · by **whreckz** » Wed May 07, 2008 4:05 am

Hi,
I'm really new with android and OpenGL. I tried running the samples here unfortunately I
encountered some errors..
according to eclipse error message.
"The method waitNative() in the type OpenGLContext is not applicable for the arguments..."

What should I do to fix this problem?

takawan · by **takawan** » Sat May 10, 2008 3:01 pm

Hello robisen,

Thank you for m5 code, it's very good example for me too.
But when I copy and pasted this code and ran from my eclipse the emulator said "java.lang.NullPointerException".
What's wrong with me, any suggestion please.

robisen wrote:So this is somewhat based on tutorial two from android-gl but it works with M5 and the problem with the other code samples is you are now not allowed to manually create or manage surfaces. You have to to do everything asynchronously by requesting a thread, then creating it that holds a reference or handle to your surface, and then get notified if the surface goes away and you stop the thread.

[/syntax]

whreckz · by **whreckz** » Tue May 13, 2008 2:54 am

takawan wrote:Hello robisen,

Thank you for m5 code, it's very good example for me too.
But when I copy and pasted this code and ran from my eclipse the emulator said "java.lang.NullPointerException".
What's wrong with me, any suggestion please.

robisen wrote:So this is somewhat based on tutorial two from android-gl but it works with M5 and the problem with the other code samples is you are now not allowed to manually create or manage surfaces. You have to to do everything asynchronously by requesting a thread, then creating it that holds a reference or handle to your surface, and then get notified if the surface goes away and you stop the thread.

[/syntax]

I was able to remove the NullpointExeption Error. I just remove glc.waitGL();
It works but i think this should not be the case

takawan · by **takawan** » Wed May 14, 2008 3:54 am

Hello whreckz,

Thank you whreckz,
I understand from your post.

I changed the code
drawFrame(gl, W, H);
private void drawFrame(GL10 gl, int w, int h) {
to
drawFrame(glc, gl, W, H);
private void drawFrame(OpenGLContext glc, GL10 gl, int w, int h) {
then it works.

Of course,
moving waitGL(); to the line before glc.post(); also works.

It seems scope problem in thread?

whreckz wrote:I was able to remove the NullpointExeption Error. I just remove glc.waitGL();
It works but i think this should not be the case

whreckz · by **whreckz** » Wed May 14, 2008 4:34 am

takawan wrote:Hello whreckz,

Yeah, I could see the light-blue square on the Emulator by removing waitGL().
Thank you!
But why the adb said it has NullpointException?

whreckz wrote:I was able to remove the NullpointExeption Error. I just remove glc.waitGL();
It works but i think this should not be the case

hi Takawan...
the variable glc out of scope. since it was declared in a different method

here's a more appropriate solution for the null exception error.

on the method run(), there is a declaration of variable glc.

OpenGLContext glc = new OpenGLContext( OpenGLContext.DEPTH_BUFFER );

instead of declaring the glc variable in the run() method. make it a member variable of class DrawingThread then initialize this variable in run(),
your code should look something like this..
...
class DrawingThread extends Thread {
boolean stop;
int w;
int h;
OpenGLContext glc;
...
public void run() {
// create a new opengl context
//START_EDIT
// OpenGLContext glc = new OpenGLContext( OpenGLContext.DEPTH_BUFFER );
glc = new OpenGLContext( OpenGLContext.DEPTH_BUFFER );
//END_EDIT
...

[ Part II ] - AndroidGL Tutorial - A blank screen

[ Part II ] - AndroidGL Tutorial - A blank screen

one last piece would be useful

thanks...

Working code for Tutorial One for m5

Re: Working code for Tutorial One for m5

Simple approach to make a square in OpenGL

android-gl code updated to work with m5

Re: Simple approach to make a square in OpenGL

Re: Simple approach to make a square in OpenGL

Re: Simple approach to make a square in OpenGL

Re: Simple approach to make a square in OpenGL

Who is online