Example usage for org.lwjgl.opengl ARBVertexShader GL_VERTEX_SHADER

Introduction

In this page you can find the example usage for org.lwjgl.opengl ARBVertexShader GL_VERTEX_SHADER_ARB.

Prototype

int GL_VERTEX_SHADER_ARB

To view the source code for org.lwjgl.opengl ARBVertexShader GL_VERTEX_SHADER_ARB.

Click Source Link

Document

Accepted by the shaderType argument of CreateShaderObjectARB and returned by the params parameter of GetObjectParameter{if}vARB.

Usage

From source file:akarnokd.opengl.experiment.ShaderProgram.java

License:Apache License

/**
 * Creates a shader program from the vertex and fragment shaders.
 * @param vertex//from  ww  w  .  java 2  s  .  c  o  m
 * @param fragment
 * @return 
 */
public static ShaderProgram create(Supplier<String> vertex, Supplier<String> fragment) {

    ShaderProgram sp = new ShaderProgram();

    sp.vertex = createShader(ARBVertexShader.GL_VERTEX_SHADER_ARB, vertex);
    sp.fragment = createShader(ARBFragmentShader.GL_FRAGMENT_SHADER_ARB, fragment);

    if (sp.vertex != 0 && sp.fragment != 0) {
        sp.program = glCreateProgramObjectARB();
        if (sp.program != 0) {

            glAttachObjectARB(sp.program, sp.vertex);
            glAttachObjectARB(sp.program, sp.fragment);

            glLinkProgramARB(sp.program);
            if (glGetObjectParameteriARB(sp.program, GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
                String err = getLogInfo(sp.program);
                sp.close();
                throw new RuntimeException("Program failed: " + err);
            }
            glValidateProgramARB(sp.program);
            if (glGetObjectParameteriARB(sp.program, GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
                String err = getLogInfo(sp.program);
                sp.close();
                throw new RuntimeException("Program failed: " + err);
            }
        } else {
            sp.close();
            throw new RuntimeException("Unable to create program");
        }
    }

    return sp;
}

From source file:com.a2client.corex.Shader.java

License:Open Source License

public Shader(String name, List<String> defines) {
    String defstr = "";
    for (String s : defines)
        defstr += s;//from  ww  w  .j av  a 2 s  . c  o  m
    this.name = name + Const.EXT_SHADER + "*" + defstr;
    MyInputStream in = FileSys.getStream(name + Const.EXT_SHADER);
    Log.debug("load shader: " + name);
    Log.debug("defines: " + defines.toString());
    String DEFINE = "#define";

    String define_str = DEFINE;
    for (String s : defines) {
        define_str += " " + s + CRLF + DEFINE;
    }

    try {
        shaders.clear();
        String source = readStreamAsString(in);
        // vertex
        String csource = define_str + " VERTEX" + CRLF + source;
        attach(ARBVertexShader.GL_VERTEX_SHADER_ARB, csource);
        // fragment
        csource = define_str + " FRAGMENT" + CRLF + source;
        attach(ARBFragmentShader.GL_FRAGMENT_SHADER_ARB, csource);
        // geometry
        if (source.contains("#ifdef GEOMETRY")) {
            csource = define_str + " GEOMETRY" + CRLF + source;
            attach(ARBGeometryShader4.GL_GEOMETRY_SHADER_ARB, csource);
            // may be need fix
            ARBGetProgramBinary.glProgramParameteri(ID, ARBGeometryShader4.GL_GEOMETRY_VERTICES_OUT_ARB, 3);
            ARBGetProgramBinary.glProgramParameteri(ID, ARBGeometryShader4.GL_GEOMETRY_INPUT_TYPE_ARB,
                    GL11.GL_TRIANGLES);
            ARBGetProgramBinary.glProgramParameteri(ID, ARBGeometryShader4.GL_GEOMETRY_VERTICES_OUT_ARB,
                    GL11.GL_TRIANGLE_STRIP);
        }

        ID = ARBShaderObjects.glCreateProgramObjectARB();
        Log.debug("shader id: " + ID);
        for (int obj : shaders) {
            ARBShaderObjects.glAttachObjectARB(ID, obj);
        }

        ARBShaderObjects.glLinkProgramARB(ID);
        if (ARBShaderObjects.glGetObjectParameteriARB(ID,
                ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
            Log.error(getLogInfo(ID));
            ID = 0;
            return;
        }

        ARBShaderObjects.glValidateProgramARB(ID);
        if (ARBShaderObjects.glGetObjectParameteriARB(ID,
                ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
            Log.error(getLogInfo(ID));
            ID = 0;
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:com.ardor3d.scene.state.lwjgl.LwjglShaderObjectsStateUtil.java

License:Open Source License

protected static void sendToGL(final GLSLShaderObjectsState state, final ContextCapabilities caps) {
    if (state.getVertexShader() == null && state.getFragmentShader() == null) {
        logger.warning("Could not find shader resources!" + "(both inputbuffers are null)");
        state._needSendShader = false;//from ww w . ja  v  a2s.  co m
        return;
    }

    if (state._programID == -1) {
        state._programID = ARBShaderObjects.glCreateProgramObjectARB();
    }

    if (state.getVertexShader() != null) {
        if (state._vertexShaderID != -1) {
            removeVertShader(state);
        }

        state._vertexShaderID = ARBShaderObjects.glCreateShaderObjectARB(ARBVertexShader.GL_VERTEX_SHADER_ARB);

        // Create the sources
        ARBShaderObjects.glShaderSourceARB(state._vertexShaderID, state.getVertexShader());

        // Compile the vertex shader
        final IntBuffer compiled = BufferUtils.createIntBuffer(1);
        ARBShaderObjects.glCompileShaderARB(state._vertexShaderID);
        ARBShaderObjects.glGetObjectParameterARB(state._vertexShaderID,
                ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
        checkProgramError(compiled, state._vertexShaderID, state._vertexShaderName);

        // Attach the program
        ARBShaderObjects.glAttachObjectARB(state._programID, state._vertexShaderID);
    } else if (state._vertexShaderID != -1) {
        removeVertShader(state);
        state._vertexShaderID = -1;
    }

    if (state.getFragmentShader() != null) {
        if (state._fragmentShaderID != -1) {
            removeFragShader(state);
        }

        state._fragmentShaderID = ARBShaderObjects
                .glCreateShaderObjectARB(ARBFragmentShader.GL_FRAGMENT_SHADER_ARB);

        // Create the sources
        ARBShaderObjects.glShaderSourceARB(state._fragmentShaderID, state.getFragmentShader());

        // Compile the fragment shader
        final IntBuffer compiled = BufferUtils.createIntBuffer(1);
        ARBShaderObjects.glCompileShaderARB(state._fragmentShaderID);
        ARBShaderObjects.glGetObjectParameterARB(state._fragmentShaderID,
                ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
        checkProgramError(compiled, state._fragmentShaderID, state._fragmentShaderName);

        // Attach the program
        ARBShaderObjects.glAttachObjectARB(state._programID, state._fragmentShaderID);
    } else if (state._fragmentShaderID != -1) {
        removeFragShader(state);
        state._fragmentShaderID = -1;
    }

    if (caps.isGeometryShader4Supported()) {
        if (state.getGeometryShader() != null) {
            if (state._geometryShaderID != -1) {
                removeGeomShader(state);
            }

            state._geometryShaderID = ARBShaderObjects
                    .glCreateShaderObjectARB(ARBGeometryShader4.GL_GEOMETRY_SHADER_ARB);

            // Create the sources
            ARBShaderObjects.glShaderSourceARB(state._geometryShaderID, state.getGeometryShader());

            // Compile the fragment shader
            final IntBuffer compiled = BufferUtils.createIntBuffer(1);
            ARBShaderObjects.glCompileShaderARB(state._geometryShaderID);
            ARBShaderObjects.glGetObjectParameterARB(state._geometryShaderID,
                    ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
            checkProgramError(compiled, state._geometryShaderID, state._geometryShaderName);

            // Attach the program
            ARBShaderObjects.glAttachObjectARB(state._programID, state._geometryShaderID);
        } else if (state._geometryShaderID != -1) {
            removeGeomShader(state);
            state._geometryShaderID = -1;
        }
    }

    if (caps.isTessellationShadersSupported()) {
        if (state.getTessellationControlShader() != null) {
            if (state._tessellationControlShaderID != -1) {
                removeTessControlShader(state);
            }

            state._tessellationControlShaderID = ARBShaderObjects
                    .glCreateShaderObjectARB(ARBTessellationShader.GL_TESS_CONTROL_SHADER);

            // Create the sources
            ARBShaderObjects.glShaderSourceARB(state._tessellationControlShaderID,
                    state.getTessellationControlShader());

            // Compile the tessellation control shader
            final IntBuffer compiled = BufferUtils.createIntBuffer(1);
            ARBShaderObjects.glCompileShaderARB(state._tessellationControlShaderID);
            ARBShaderObjects.glGetObjectParameterARB(state._tessellationControlShaderID,
                    ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
            checkProgramError(compiled, state._tessellationControlShaderID,
                    state._tessellationControlShaderName);

            // Attach the program
            ARBShaderObjects.glAttachObjectARB(state._programID, state._tessellationControlShaderID);
        } else if (state._tessellationControlShaderID != -1) {
            removeTessControlShader(state);
            state._tessellationControlShaderID = -1;
        }

        if (state.getTessellationEvaluationShader() != null) {
            if (state._tessellationEvaluationShaderID != -1) {
                removeTessEvalShader(state);
            }

            state._tessellationEvaluationShaderID = ARBShaderObjects
                    .glCreateShaderObjectARB(ARBTessellationShader.GL_TESS_CONTROL_SHADER);

            // Create the sources
            ARBShaderObjects.glShaderSourceARB(state._tessellationEvaluationShaderID,
                    state.getTessellationEvaluationShader());

            // Compile the tessellation control shader
            final IntBuffer compiled = BufferUtils.createIntBuffer(1);
            ARBShaderObjects.glCompileShaderARB(state._tessellationEvaluationShaderID);
            ARBShaderObjects.glGetObjectParameterARB(state._tessellationEvaluationShaderID,
                    ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
            checkProgramError(compiled, state._tessellationEvaluationShaderID,
                    state._tessellationEvaluationShaderName);

            // Attach the program
            ARBShaderObjects.glAttachObjectARB(state._programID, state._tessellationEvaluationShaderID);
        } else if (state._tessellationEvaluationShaderID != -1) {
            removeTessEvalShader(state);
            state._tessellationEvaluationShaderID = -1;
        }
    }

    ARBShaderObjects.glLinkProgramARB(state._programID);
    checkLinkError(state._programID);
    state.setNeedsRefresh(true);
    state._needSendShader = false;
}

From source file:com.drazisil.opengl3demo.OpenGL3Demo.java

License:Apache License

private void initShaders() {
    int vertShader = 0;
    int tessShader1 = 0;
    int tessShader2 = 0;
    int geoShader = 0;
    int fragShader = 0;

    try {// w  w w  . j a v a2  s .c  o  m
        vertShader = createShader("resources/shaders/openGlDemo.vert.glsl",
                ARBVertexShader.GL_VERTEX_SHADER_ARB);
        /*
                    tessShader1 = createShader("resources/shaders/openGlDemo.tess-control.glsl", ARBTessellationShader.GL_TESS_CONTROL_SHADER);
                    tessShader2 = createShader("resources/shaders/openGlDemo.tess-eval.glsl", ARBTessellationShader.GL_TESS_EVALUATION_SHADER);
                    geoShader = createShader("resources/shaders/openGlDemo.geo.glsl", ARBGeometryShader4.GL_GEOMETRY_SHADER_ARB);
        */
        fragShader = createShader("resources/shaders/openGlDemo.frag.glsl",
                ARBFragmentShader.GL_FRAGMENT_SHADER_ARB);
    } catch (Exception exc) {
        exc.printStackTrace();
        return;
    } finally {
        if (vertShader == 0 || fragShader == 0) {
            return;
        }
    }

    // Create shaderProgram, attach shaders to it, and link it
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertShader);
    /*
            glAttachShader(shaderProgram, tessShader1);
            glAttachShader(shaderProgram, tessShader2);
            glAttachShader(shaderProgram, geoShader);
    */
    glAttachShader(shaderProgram, fragShader);
    glLinkProgram(shaderProgram);

    // Delete the shaders as the shaderProgram has them now
    glDeleteShader(vertShader);
    /*
            glDeleteShader(tessShader1);
            glDeleteShader(tessShader2);
            glDeleteShader(geoShader);
    */
    glDeleteShader(fragShader);

}

From source file:com.runescape.client.revised.editor.modelviewer.Viewport.java

License:Open Source License

public boolean initShader() {
    int vertShader = 0, fragShader = 0;
    try {//from  www .  ja va2  s .c o  m
        vertShader = this.createShader("./shaders/screen.vert", ARBVertexShader.GL_VERTEX_SHADER_ARB);
        fragShader = this.createShader("./shaders/screen.frag", ARBFragmentShader.GL_FRAGMENT_SHADER_ARB);
    } catch (final Exception exc) {
        exc.printStackTrace();
        return false;
    } finally {
        if ((vertShader == 0) || (fragShader == 0)) {
            return false;
        }
    }
    this.program = ARBShaderObjects.glCreateProgramObjectARB();
    if (this.program == 0) {
        return false;
    }
    ARBShaderObjects.glAttachObjectARB(this.program, vertShader);
    ARBShaderObjects.glAttachObjectARB(this.program, fragShader);
    ARBShaderObjects.glLinkProgramARB(this.program);
    if (ARBShaderObjects.glGetObjectParameteriARB(this.program,
            ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
        System.err.println(this.getLogInfo(this.program));
        return false;
    }
    ARBShaderObjects.glValidateProgramARB(this.program);
    if (ARBShaderObjects.glGetObjectParameteriARB(this.program,
            ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
        System.err.println(this.getLogInfo(this.program));
        return false;
    }
    return true;
}

From source file:flash.display.Shader.java

License:Open Source License

protected void compileShader() {
    System.out.println("Compiling shader ...");
    final String vertexShader = vertexShader();
    final String fragmentShader = fragmentShader();

    System.out.println("Vertex shader:");
    System.out.println(vertexShader);
    System.out.println("Fragment shader:");
    System.out.println(fragmentShader);

    _vertexShaderId = ARBShaderObjects.glCreateShaderObjectARB(ARBVertexShader.GL_VERTEX_SHADER_ARB);
    ARBShaderObjects.glShaderSourceARB(_vertexShaderId, vertexShader);
    ARBShaderObjects.glCompileShaderARB(_vertexShaderId);
    System.out.println("VertexShader Info: " + ARBShaderObjects.glGetInfoLogARB(_vertexShaderId, 8192));

    _fragmentShaderId = ARBShaderObjects.glCreateShaderObjectARB(ARBFragmentShader.GL_FRAGMENT_SHADER_ARB);
    ARBShaderObjects.glShaderSourceARB(_fragmentShaderId, fragmentShader);
    ARBShaderObjects.glCompileShaderARB(_fragmentShaderId);
    System.out.println("FragmentShader Info: " + ARBShaderObjects.glGetInfoLogARB(_fragmentShaderId, 8192));

    _programId = ARBShaderObjects.glCreateProgramObjectARB();
    ARBShaderObjects.glAttachObjectARB(_programId, _vertexShaderId);
    ARBShaderObjects.glAttachObjectARB(_programId, _fragmentShaderId);
    ARBShaderObjects.glLinkProgramARB(_programId);
    System.out.println("Program Info: " + ARBShaderObjects.glGetInfoLogARB(_programId, 8192));
}

From source file:game.map.Shader.java

public Shader() {
    int vertShader = 0, fragShader = 0;

    try {/*w w w  . ja  v a2 s  .com*/
        vertShader = createShader("src/Terrain/shaders/screen.vert", ARBVertexShader.GL_VERTEX_SHADER_ARB);
        fragShader = createShader("src/Terrain/shaders/screen.frag", ARBFragmentShader.GL_FRAGMENT_SHADER_ARB);
    } catch (Exception exc) {
        exc.printStackTrace();
        return;
    } finally {
        if (vertShader == 0 || fragShader == 0)
            return;
    }

    program = ARBShaderObjects.glCreateProgramObjectARB();

    if (program == 0)
        return;

    /*
    * if the vertex and fragment shaders setup sucessfully,
    * attach them to the shader program, link the sahder program
    * (into the GL context I suppose), and validate
    */
    ARBShaderObjects.glAttachObjectARB(program, vertShader);
    ARBShaderObjects.glAttachObjectARB(program, fragShader);

    ARBShaderObjects.glLinkProgramARB(program);
    if (ARBShaderObjects.glGetObjectParameteriARB(program,
            ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
        System.err.println(getLogInfo(program));
        return;
    }

    ARBShaderObjects.glValidateProgramARB(program);
    if (ARBShaderObjects.glGetObjectParameteriARB(program,
            ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
        System.err.println(getLogInfo(program));
        return;
    }

    useShader = true;
}

From source file:lessur.util.shader.ShaderManager.java

License:GNU General Public License

/**
 * Fetches a shader id for a given vertex shader, generating
 * a new id if necessary./*from w  w w.ja  v a  2  s  .c o  m*/
 * @param fragmentFileName The path to the vertex shader
 * @returns shaderID The shader ID of the [new] fragment shader
 */
public int getVertexShaderID(String vertexShaderFilePath) throws Exception {
    Integer id = shaderMap.get(vertexShaderFilePath);
    if (id == null) {
        if (has_opengl2) {
            id = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
            GL20.glShaderSource(id, getProgramCode(vertexShaderFilePath));
            GL20.glCompileShader(id);
            shaderMap.put(vertexShaderFilePath, id);
        } else if (has_arb) {
            id = ARBShaderObjects.glCreateShaderObjectARB(ARBVertexShader.GL_VERTEX_SHADER_ARB);
            ARBShaderObjects.glShaderSourceARB(id, getProgramCode(vertexShaderFilePath));
            ARBShaderObjects.glCompileShaderARB(id);
            shaderMap.put(vertexShaderFilePath, id);
        }
        StringBuilder errorMessage = new StringBuilder();
        //Check for errors with shader
        if (!compiledSuccessfully(id)) {
            errorMessage.append("Vertex Shader ");
            errorMessage.append(vertexShaderFilePath);
            errorMessage.append(" failed to compile.\n");
            errorMessage.append(getShaderInfoLog(id));
            errorMessage.append("\n\n");
            errorMessage.insert(0, "Could not compile shader.\n");
            throw new Exception(errorMessage.toString());
        }
    }
    return id;
}

From source file:name.martingeisse.meltdown.engine.VertexShaderObject.java

License:Open Source License

/**
 * Constructor.
 * @param code the shader code
 */
public VertexShaderObject(String code) {
    super(ARBVertexShader.GL_VERTEX_SHADER_ARB, code);
}

From source file:org.blockartistry.lib.gui.ShaderUtils.java

License:MIT License

public static int createProgram(@Nullable final ResourceLocation vert, @Nullable final ResourceLocation frag) {
    int vertId = 0, fragId = 0, program;
    if (vert != null)
        vertId = createShader(vert, ARBVertexShader.GL_VERTEX_SHADER_ARB);
    if (frag != null)
        fragId = createShader(frag, ARBFragmentShader.GL_FRAGMENT_SHADER_ARB);

    program = OpenGlHelper.glCreateProgram();
    if (program == 0)
        return 0;

    if (vert != null)
        OpenGlHelper.glAttachShader(program, vertId);
    if (frag != null)
        OpenGlHelper.glAttachShader(program, fragId);

    OpenGlHelper.glLinkProgram(program);
    if (OpenGlHelper.glGetProgrami(program, ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
        LibLog.log().error(getLogInfoProgram(program), null);
        return 0;
    }/* ww  w  .  ja  v  a2s  .  c o  m*/

    GL20.glValidateProgram(program);
    if (OpenGlHelper.glGetProgrami(program, ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
        LibLog.log().error(getLogInfoProgram(program), null);
        return 0;
    }

    OpenGlHelper.glDeleteShader(vertId);
    OpenGlHelper.glDeleteShader(fragId);

    OpenGlHelper.glUseProgram(0);

    return program;
}

Example usage for org.lwjgl.opengl ARBVertexShader GL_VERTEX_SHADER_ARB

Introduction

Prototype

Document

Usage