LWJGL摆动误差-找不到解决方案



我尝试在我的LWJGL画布上添加一些按钮和一个图像面板

但它不起作用。这是它现在的样子我喜欢在测试图像旁边的灰色方块中渲染。

如果我编译我的代码,我得到以下错误:

Exception in thread "Thread-0" java.lang.RuntimeException: No OpenGL context found in the current thread.
    at org.lwjgl.opengl.GLContext.getCapabilities(GLContext.java:124)
    at org.lwjgl.opengl.GL20.glCreateProgram(GL20.java:253)
    at util.ShaderProgram.createProgram(ShaderProgram.java:53)
    at util.ShaderProgram.<init>(ShaderProgram.java:47)
    at ExampleApplet$5.run(ExampleApplet.java:163)

我有什么需要改变的?

谢谢你。

添加swing到LWJGL让我抓狂

这是我的源代码:

import math.Mat4;
import math.Vec3;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import util.Mesh;
import util.OBJContainer;
import util.OBJGroup;
import util.ShaderProgram;
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.glViewport;
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
public class ExampleApplet {
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ExampleApplet window = new ExampleApplet();
                    window.frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
    private ShaderProgram shaderProgram;
    private ArrayList<Mesh>              meshes;
    private Mat4                         modelMatrix;
    private Mat4                         viewMatrix;
    private volatile float[] vertices;
    private JFrame frame;
    private Canvas canvas;
    private JPanel controlPanel;
    private JPanel canvasPanel;
    private JPanel imagePanel;
    private Thread gameThread;
    private boolean running;
    private int windowWidth;
    private int windowHeight;
    private volatile boolean needValidation;
    private volatile boolean needUpdateViewport;
    public ExampleApplet() {
        frame = new JFrame();
        frame.addWindowListener(new WindowListener() {
            public void windowOpened(WindowEvent arg0) {
            }
            public void windowIconified(WindowEvent arg0) {
            }
            public void windowDeiconified(WindowEvent arg0) {
            }
            public void windowDeactivated(WindowEvent arg0) {
            }
            public void windowClosing(WindowEvent arg0) {
            }
            public void windowClosed(WindowEvent arg0) {
                terminate();
            }
            public void windowActivated(WindowEvent arg0) {
            }
        });
        frame.setTitle("Swing + LWJGL");
        frame.setSize(1500, 700);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(new BorderLayout(0, 0));

        canvasPanel = new JPanel(new BorderLayout(0, 0));
        imagePanel = new JPanel(new BorderLayout(0, 0));
        canvas = new Canvas() {
            private static final long serialVersionUID = -1069002023468669595L;
            public void removeNotify() {
                stopOpenGL();
            }
        };
        canvas.addComponentListener(new ComponentListener() {
            public void componentShown(ComponentEvent e) {
                setNeedValidation();
            }
            public void componentResized(ComponentEvent e) {
                setNeedValidation();
            }
            public void componentMoved(ComponentEvent e) {
                setNeedValidation();
            }
            public void componentHidden(ComponentEvent e) {
                setNeedValidation();
            }
        });
        canvas.setIgnoreRepaint(true);
        canvas.setSize(500,500);
        canvasPanel.setSize(500,500);
        //canvas.setPreferredSize(new Dimension(500, 500));
       // canvas.setMinimumSize(new Dimension(320, 240));
        canvas.setVisible(true);
        canvasPanel.add(canvas, BorderLayout.CENTER);
        try {
            BufferedImage myImg = ImageIO.read((new File("/home/manu/workspaces/LWJGL_swing/resources/itworks-HDTV_720P.png")));
            JLabel picLabel = new JLabel(new ImageIcon(resize(myImg, 1000, 500)));
            imagePanel.add(picLabel);
        } catch (Exception e) {
        }
        controlPanel = new JPanel(new BorderLayout(0, 0));
        frame.add(canvasPanel, BorderLayout.LINE_END);
        frame.add(imagePanel, BorderLayout.LINE_START);
        frame.pack();

        JPanel controls = new JPanel(new GridLayout(2,3));
        controlPanel.add(controls,BorderLayout.EAST);
        JButton openImage = new JButton("Bild öffnen");
        JSlider brigthness = new JSlider(0,100,0);
        controls.add(openImage);
        controls.add(brigthness);
        frame.add(controlPanel, BorderLayout.PAGE_END);
        startOpenGL();
    }
    private void setNeedValidation() {
        needValidation = true;
        needUpdateViewport = true;
    }
    private void startOpenGL() {
        System.out.println("StartOpenGL");

        gameThread = new Thread() {
            public void run() {
                try {
                    shaderProgram = new ShaderProgram( "/home/manu/workspaces/LWJGL_swing/src/GUISample/Color_vs.glsl", "/home/manu/workspaces/LWJGL_swing/src/GUISample/Color_fs.glsl" );
                    modelMatrix   = new Mat4();
                    viewMatrix    = Mat4.translation( 0.0f, 0.0f, -3.0f );
                    meshes        = new ArrayList<Mesh>();
                    windowWidth   = 500;
                    windowHeight  = 500;
                    loadObj("monkey.obj");
                    glEnable( GL_DEPTH_TEST );
                    Display.create();
                    Display.setParent(canvas);
                    running = true;
                } catch (LWJGLException e) {
                    e.printStackTrace();
                }
                int i=0;
                while (running) {
                    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
                    float fov  = 60;
                    float near = 0.01f;
                    float far  = 500.0f;
                    Mat4 projectionMatrix = Mat4.perspective( fov, windowWidth, windowHeight, near, far );
                    glViewport( 0, 0, windowWidth, windowHeight );
                    drawMeshes(viewMatrix, projectionMatrix);
                    GL11.glViewport(0, 0, 500,500);
                    if (i % 2 == 0) {
                        GL11.glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
                        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
                    } else {
                        GL11.glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
                        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
                    }
                    Display.update();
                    try{
                        Thread.sleep(1000);
                    }catch (Exception e){
                    }
                    i++;
                    updateGL();
                }
                if (Display.isCreated()) {
                    Display.destroy();
                }
            }
        };
        gameThread.start();
    }
    public void drawMeshes( Mat4 viewMatrix, Mat4 projMatrix ) {
        shaderProgram.useProgram();
        shaderProgram.setUniform("uModel", modelMatrix);
        shaderProgram.setUniform("uView", viewMatrix);
        shaderProgram.setUniform("uProjection", projMatrix);
        shaderProgram.setUniform("uColor",new Vec3(1.0f,0.0f,0.0f) );
        shaderProgram.setUniform("uEnableShading", 0);
        meshes.get(0).draw();
    }
    private void setupVertices() {
        vertices = new float[4 * 2];
        vertices[0] = 0.1f;
        vertices[1] = 0.3f;
        vertices[2] = 0.2f;
        vertices[3] = 0.8f;
        vertices[4] = 0.9f;
        vertices[5] = 0.6f;
        vertices[6] = 0.7f;
        vertices[7] = 0.05f;
    }
    private void updateGL() {
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
        render();
        Display.update();
        Display.sync(60);
        if (needUpdateViewport) {
            needUpdateViewport = false;
            Rectangle rect = canvas.getBounds();
            int w = (int) rect.getWidth();
            int h = (int) rect.getHeight();
            GL11.glMatrixMode(GL11.GL_PROJECTION);
            GL11.glLoadIdentity();
            GL11.glOrtho(0, w, h, 0, -1, 1);
            GL11.glViewport(0, 0, w, h);
        }
        int error = GL11.glGetError();
        if (error != GL11.GL_NO_ERROR) {
            String msg = "Unknown Error";
            switch (error) {
                case GL11.GL_INVALID_OPERATION:
                    msg = "Invalid Operation";
                    break;
                case GL11.GL_INVALID_VALUE:
                    msg = "Invalid Value";
                    break;
                case GL11.GL_INVALID_ENUM:
                    msg = "Invalid Enum";
                    break;
                case GL11.GL_STACK_OVERFLOW:
                    msg = "Stack Overflow";
                    break;
                case GL11.GL_STACK_UNDERFLOW:
                    msg = "Stack Underflow";
                    break;
                case GL11.GL_OUT_OF_MEMORY:
                    msg = "Out of memory";
                    break;
            }
            throw new RuntimeException(msg);
        }
    }
    private void render() {
        float scale = 100;
        GL11.glBegin(GL11.GL_QUADS);
        GL11.glColor4f(1, 0, 0, 1);
        GL11.glVertex3f(vertices[0] * scale, vertices[1] * scale, 0);
        GL11.glColor4f(1, 0, 0, 1);
        GL11.glVertex3f(vertices[2] * scale, vertices[3] * scale, 0);
        GL11.glColor4f(1, 0, 0, 1);
        GL11.glVertex3f(vertices[4] * scale, vertices[5] * scale, 0);
        GL11.glColor4f(1, 0, 0, 1);
        GL11.glVertex3f(vertices[6] * scale, vertices[7] * scale, 0);
        GL11.glEnd();
    }
    private void stopOpenGL() {
        System.out.println("StopOpenGL");
        running = false;
        try {
            gameThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void terminate() {
        frame.dispose();
        System.exit(0);
    }
    public static BufferedImage resize(BufferedImage img, int newW, int newH) {
        Image tmp = img.getScaledInstance(newW, newH, Image.SCALE_SMOOTH);
        BufferedImage dimg = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = dimg.createGraphics();
        g2d.drawImage(tmp, 0, 0, null);
        g2d.dispose();
        return dimg;
    }
    public void loadObj( String filename )
    {
        if( !filename.toLowerCase().endsWith(".obj") )
        {
            System.err.println( "Error in Sandbox.loadObj(): Invalid file extension, expected ".obj":n" + filename );
            return;
        }
        OBJContainer objContainer = OBJContainer.loadFile( "monkey.obj" );
        ArrayList<OBJGroup> objGroups    = objContainer.getGroups();
        for( OBJGroup group : objGroups )
        {
            float[] positions = group.getPositions();
            float[] normals   = group.getNormals();
            int[]   indices   = group.getIndices();
            Mesh mesh = new Mesh( GL_STATIC_DRAW );
            mesh.setAttribute( 0, positions, 3 );
            mesh.setAttribute( 1, normals, 3 );
            mesh.setIndices( indices );
            meshes.add( mesh );
        }
    }
}

您在不同的线程中创建了OpenGL上下文。你必须在创建它的同一个线程中使用它。

最新更新