如何使用Java在openGL中清除屏幕

Question

I don't understand how I can simply clear the screen in Java while using OpenGL. I have searched all over the internet, there is like no real good resource for OpenGL information. Basically I just want to clear the screen and re-draw a circle. Instead my code decides that it isn't going to clear the screen ever, and it most definitely isn't going to draw anything else.. I want it to clear the screen when I press "e", and then draw a new circle. I have two java files.. I will only post relevant code for the sake of any user's who can help me - but will post more code if needed.

In the beginning of my JOGLEventListener.java file I'm also declaring a global var

// Test GLAutoDrawable test = null;

JOGLEventListener.java

    @Override
    public void display(GLAutoDrawable gLDrawable) 
    {
        // Set a global variable to hold the gLDrawable
        // May not need this?
        test = gLDrawable;

         GL2 gl = gLDrawable.getGL().getGL2();

        gl.glClearColor(backrgb[0], 0, 1, 1);
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

        backrgb[0]+=0.0005;
        if (backrgb[0]> 1) backrgb[0] = 0; 


        // =============================================
        // Draw my circle here
        //
        // =============================================
        // =============================================
        System.out.println("Drawing Circle..");
        drawCircle(5.0f, 5.0f, 10.0f);

    }

    // Draw Circle
    void drawCircle(float x, float y, float radius)
    {
        System.out.println("IN DRAWCIRCLE");
        int i;
        GL2 gl = test.getGL().getGL2();
        int lineAmount = 100; //# of triangles used to draw circle
        final 
        //GLfloat radius = 0.8f; //radius
        float twicePi = (float) (2.0f * Math.PI);

        gl.glBegin(gl.GL_LINE_LOOP);
            for(i = 0; i <= lineAmount;i++) { 
                gl.glVertex2f(
                    x + (radius * (float)Math.cos(i *  twicePi / lineAmount)), 
                    y + (radius* (float)Math.sin(i * twicePi / lineAmount))
                );
            }
        gl.glEnd();
    }

@Override
public void keyTyped(KeyEvent e) 
{
    char key= e.getKeyChar();
    System.out.printf("Key typed: %c\n", key); 
    GL2 gl = test.getGL().getGL2();
    if(key == 'e')
    {
        // WHY ISNT THIS WORKING
        // CLEAR THE SCREEN AND DRAW ME A NEW CIRCLE
        gl.glClear( gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT );     
        gl.glLoadIdentity();                    
        //test
        float x = 100.0f;
        float y = 100.0f;
        float twicePi = (float) (2.0f * Math.PI);
        float radius = 100f;

        System.out.println("Draw Another Circle...");
        gl.glBegin(gl.GL_LINE_LOOP);
        for(int i = 0; i <= 360;i++) 
        { 
            gl.glVertex2f(
                x + (radius * (float)Math.cos(i *  twicePi / 360)), 
                y + (radius* (float)Math.sin(i * twicePi / 360))
            );
        }
        gl.glEnd();
    }

Answer 1

1) That's deprecated OpenGL , don't use it

2) Don't save the gl object to one global value, always get it from the drawable or the GLContext

3) Use a shader program to render and a vertex buffer to hold the vertices position. But first, I'd suggest you to start a tutorial to learn the basic of OpenGL. Or if you want to get something working asap, clone this hello triangle of mine and start experiment on that

Answer 2

The problem is apparently that you don't swap the front and back buffers.

I'm not familiar with the OpenGL bindings for Java, but I guess that the library already does that for you after it calls the display() function. It doesn't do that after keyTyped() .

The way you are supposed to do this is to always draw the scene from scratch inside the display() function based on some internal state. Then in keyTyped() you shall modify that internal state and invalidate the window, which will cause the display() to be called again and redraw the scene properly.

EDIT: Calling display() yourself won't be enough. I can't find how to invalidate the window in Java (in C this would be so much easier). As a dirty hack you can try calling temp.swapBuffers() manually in display , setting setAutoSwapBufferMode(false) and calling display from keyTyped() .