ShaderNode.java

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.opengl.GL;



/**
 * A Shader Node
 * @author Andrew
 */
public class ShaderNode extends Node
{
    /** Default value for null shaders */
    private static final int NO_SHADER_ID = -1;

    /** Compiled vertex shader id */
    private int vertexShader = NO_SHADER_ID;
    /** Compiled frag shader id */
    private int fragmentShader = NO_SHADER_ID;

    /** The complete shader program */
    private int shaderProgram = NO_SHADER_ID;

    /** The source code for the vertex shader */
    private String vertexSource;
    /** The source code for the fragment shader */
    private String fragmentSource;

    /** True if shader is ready to use */
    private boolean shaderReady;


    /**
     * Creates a new ShaderNode
     * @param name the name of this node
     */
    public ShaderNode(String name)
    {
        super(name);

        shaderReady = false;
    }


    /**
     * Loads the shaders for this node
     * @param shaderType either GL_VERTEX_SHADER or GL_FRAGMENT_SHADER
     * @param shaderFile the filename to get the source from
     * @return true if shader was successfully loaded
     */
    public boolean loadShaderSource(int shaderType, String shaderFile)
    {
        boolean success = false;
        try
        {
            BufferedReader br = new BufferedReader(new FileReader(shaderFile));
            String data = "";
            String line = null;
            while ((line = br.readLine()) != null)
            {
                data += line + "\n";
            }
            
            if(shaderType == GL.GL_VERTEX_SHADER)
            {
                vertexSource = data;
            }
            else if(shaderType == GL.GL_FRAGMENT_SHADER)
            {
                fragmentSource = data;
            }

            br.close();
            success = true;
        }
        catch (FileNotFoundException ex)
        {
            Logger.getLogger(ShaderNode.class.getName()).log(Level.SEVERE, null, ex);
            success = false;
        }
        catch (IOException ex)
        {
            Logger.getLogger(ShaderNode.class.getName()).log(Level.SEVERE, null, ex);
        }


        return success;
    }

    /**
     * Inits this shader node
     * @param gl
     */
    @Override
    public void init(GL gl)
    {

        //create the shaders on the GPU
        vertexShader = gl.glCreateShader(GL.GL_VERTEX_SHADER);
        fragmentShader = gl.glCreateShader(GL.GL_FRAGMENT_SHADER);

        //send source of vertex and compile
        gl.glShaderSource(vertexShader, 1, new String[]{vertexSource}, null);
        gl.glCompileShader(vertexShader);

        //ensure vertex was compiled
        int[] status = new int[1];
        gl.glGetShaderiv(vertexShader, GL.GL_COMPILE_STATUS, status, 0);
        if(status[0] != GL.GL_TRUE) //then something went wrong
        {
            Logger.getLogger(ShaderNode.class.getName()).log(Level.SEVERE, "Error compiling VERTEX shader");
            return;
        }

        //send source of frag and compile
        gl.glShaderSource(fragmentShader, 1, new String[]{fragmentSource}, null);
        gl.glCompileShader(fragmentShader);

        //ensure frag was compiled
        gl.glGetShaderiv(fragmentShader, GL.GL_COMPILE_STATUS, status, 0);
        if(status[0] != GL.GL_TRUE) //then something went wrong
        {
            Logger.getLogger(ShaderNode.class.getName()).log(Level.SEVERE, "Error compiling FRAGMENT shader");
            return;
        }

        //create the program
        shaderProgram = gl.glCreateProgram();

        //link shaders
        gl.glAttachShader(shaderProgram, vertexShader);
        gl.glAttachShader(shaderProgram, fragmentShader);
        gl.glLinkProgram(shaderProgram);

        //ensure shader was linked
        gl.glGetProgramiv(shaderProgram, GL.GL_LINK_STATUS, status, 0);
        if(status[0] != GL.GL_TRUE) //then something went wrong
        {
            Logger.getLogger(ShaderNode.class.getName()).log(Level.SEVERE, "Error linking shader program");
            return;
        }

        shaderReady = true;
        super.init(gl);
    }

    

    /**
     * Gets the shader program of this node.
     * @return The shader program ID
     */
    @Override
    public int getShaderProgram()
    {
        return shaderProgram;
    }

    /**
     * Turns on this shader
     * @param gl
     */
    public void turnOnShader(GL gl)
    {

        gl.glUseProgram(shaderProgram);
    }

    /**
     * Turns off this shader
     * @param gl
     */
    public void turnOffShader(GL gl)
    {
        if(parentNode != null)
            gl.glUseProgram(parentNode.getShaderProgram());
        else
            gl.glUseProgram(0);
    }



    /**
     * Turns the shader on and draws this (and children) nodes
     * @param gl
     */
    @Override
    public void draw(GL gl)
    {
        turnOnShader(gl);

        super.draw(gl);

        turnOffShader(gl);
    }
}