spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

java.lang.NullPointerException
    at org.lwjgl.opengl.GL20.glCreateProgram(GL20.java:254)
    at Adworld.init(Adworld.java:30)
    at sun.applet.AppletPanel.run(Unknown Source)
    at java.lang.Thread.run(Unknown Source)

C-/C++-Quelltext

import java.nio.FloatBuffer;
import java.util.Map;
import org.lwjgl.BufferUtils;
import java.io.*;
import javax.swing.JOptionPane;
import static org.lwjgl.opengl.GL20.*;

public class GLSLProgram{
    protected GLSLShader m_vertexShader;
    protected GLSLShader m_fragmentShader;
    protected int m_programID;
    protected Map<String, Integer> m_uniformMap;
    protected Map<String, Integer> m_attribMap;
    
    GLSLProgram(String vertexShader, String fragmentShader){
        m_vertexShader = new GLSLShader();
        m_fragmentShader = new GLSLShader();
        
        m_vertexShader.filename = vertexShader;
        m_fragmentShader.filename = fragmentShader;
        m_programID = 0;
    }
        
    protected String readFile(String filename){
        try{
            String source = new FileReader(filename).toString();
            
            return source;
        }
        catch(Exception e){
            return new String();
        }
    }
    
    protected boolean compileShader(GLSLShader shader){
        glCompileShader(shader.id);

        int result = glGetShader(shader.id, GL_COMPILE_STATUS);
    
        if(result == 0){
            return false;
        }
    
        return true;
    }
    
    protected void outputShaderLog(int shaderID){
        String infoLog;
        int infoLen;

        infoLen = glGetShader(shaderID, GL_INFO_LOG_LENGTH);
        infoLog = glGetShaderInfoLog(shaderID, infoLen);

        JOptionPane.showMessageDialog(null, infoLog, "GLSL Shader Error", 0);
    }
    
    protected void outputProgramLog(int programID){
        String infoLog;
        int infoLen;
        int result;
    
        result = glGetProgram(programID, GL_LINK_STATUS);
    
        if(result == 1){
            return;
        }
    
        infoLen = glGetProgram(programID, GL_INFO_LOG_LENGTH);
        infoLog = glGetProgramInfoLog(programID, infoLen);
    
        JOptionPane.showMessageDialog(null, infoLog, "GLSL Shader Error", 0);
    }
    
    public boolean initialize(){
        m_programID = glCreateProgram(); // Erzeugt Shaderprogramm
        m_vertexShader.id = glCreateShader(GL_VERTEX_SHADER); // Erzeugt Vertex Shader
        m_fragmentShader.id = glCreateShader(GL_FRAGMENT_SHADER); // Erzeugt Fragment Shader
    
        // Daten einlesen
        m_vertexShader.source = readFile(m_vertexShader.filename);
        m_fragmentShader.source = readFile(m_fragmentShader.filename);
                
        if(m_vertexShader.source.length() == 0 || m_fragmentShader.source.length() == 0){
            return false;
        }
    
        glShaderSource(m_vertexShader.id, m_vertexShader.source);
        glShaderSource(m_fragmentShader.id, m_fragmentShader.source);
    
        if(!compileShader(m_vertexShader) || !compileShader(m_fragmentShader)){ // Shader compilieren
            outputShaderLog(m_vertexShader.id);
            outputShaderLog(m_fragmentShader.id);
            
            return false;
        }
    
        // Hinzufuegen, Linken
        glAttachShader(m_programID, m_vertexShader.id);
        glAttachShader(m_programID, m_fragmentShader.id);
        glLinkProgram(m_programID); // Programm linken
    
        return true;
    }
    
    public void linkProgram(){
        glLinkProgram(m_programID);

        int result = glGetProgram(m_programID, GL_LINK_STATUS);

        if(result == 0){
            outputProgramLog(m_programID); // Fehlerlog erstellen
        }
    }
    
    public void bindShader(){
        glUseProgram(m_programID);
    }
    
    public void unbindShader(){
        glUseProgram(0);
    }
    
    public int getUniformLocation(String name){
        if(!m_uniformMap.containsKey(name)){
            int location = glGetUniformLocation(m_programID, name);
            m_uniformMap.put(name, location);
            
            return location;
        }
        
        return m_uniformMap.get(name);
    }
    
    public int getAttribLocation(String name){
        if(!m_attribMap.containsKey(name)){
            int location = glGetAttribLocation(m_programID, name);
            m_attribMap.put(name, location);
            
            return location;
        }
        
        return m_attribMap.get(name);
    }
    
    public void sendUniform(String name, int id){
        int location = getUniformLocation(name);
        glUniform1i(location, id);
    }
    
    public void sendUniform(String name, float r, float g, float b, float a){ // red green blue alpha
        FloatBuffer v = BufferUtils.createFloatBuffer(4);
        v.put(r);
        v.put(g);
        v.put(b);
        v.put(a);
        
        int location = getUniformLocation(name);
        glUniform4(location, v);
    }
    
    public void sendUniform(String name, float x, float y, float z){
        FloatBuffer v = BufferUtils.createFloatBuffer(3);
        v.put(x);
        v.put(y);
        v.put(z);
        
        int location = getUniformLocation(name);
        glUniform3(location, v);
    }
    
    public void sendUniform(String name, float scalar){
        FloatBuffer f = BufferUtils.createFloatBuffer(1);
        f.put(scalar);
        
        int location = getUniformLocation(name);
        glUniform1(location, f);
    }
    
    public void sendUniform4x4(String name, float matrix[]){
        FloatBuffer m = BufferUtils.createFloatBuffer(16);
        m.put(matrix);
        
        int location = getUniformLocation(name);
        glUniformMatrix4(location, false, m);
    }
    
    public void sendUniform3x3(String name, float matrix[]){
        FloatBuffer m = BufferUtils.createFloatBuffer(16);
        m.put(matrix);
        
        int location = getUniformLocation(name);
        glUniformMatrix3(location, false, m);
    }
    
    public void sendUniform4x4(String name, float matrix[], boolean transpose){
        FloatBuffer m = BufferUtils.createFloatBuffer(16);
        m.put(matrix);
        
        int location = getUniformLocation(name);
        glUniformMatrix4(location, transpose, m);
    }
    
    public void sendUniform3x3(String name, float matrix[], boolean transpose){
        FloatBuffer m = BufferUtils.createFloatBuffer(16);
        m.put(matrix);
        
        int location = getUniformLocation(name);
        glUniformMatrix3(location, transpose, m);
    }
    
    public void bindAttrib(int index, String name){
        glBindAttribLocation(m_programID, index, name);
    }
}

C-/C++-Quelltext

public void init(){
        // Zeichenflaeche
        m_display = new Canvas();
        m_display.setSize(getWidth(), getHeight());
        add(m_display);
        m_display.setFocusable(true);
        m_display.requestFocus();
        m_display.setIgnoreRepaint(true);
        setVisible(true);
                
        // Variablen
        m_shader = new Shader("shader/default.vert", "shader/default.frag"); // <--- DA
        m_rotation = 0;
        
        glCreateProgram();
        
        // main thread
        Thread mainThread = new Thread(){
            public void run(){
                try{
                    Display.setParent(m_display);
                    Display.create();
                }catch(Exception e){
                    System.exit(0);
                }
                
                loop();
            }
        };
        
        mainThread.start();
    }

C-/C++-Quelltext

 m_programID = glCreateProgram(); // Erzeugt Shaderprogramm
// und
 m_shader = new Shader("shader/default.vert", "shader/default.frag");
// und
if(!initialize()){