g.glUseProgram(this.program); g.glBindBuffer(GL.GL_ARRAY_BUFFER, this.mesh_lying); g.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, this.indices); position_attrib = g.glGetAttribLocation(this.program, "v_position"); assert position_attrib != -1; g.glEnableVertexAttribArray(position_attrib); g.glVertexAttribPointer( position_attrib, 3, color_attrib = g.glGetAttribLocation(this.program, "v_color"); assert color_attrib != -1; g.glEnableVertexAttribArray(color_attrib); g.glVertexAttribPointer( color_attrib, 3, final int uid = g.glGetUniformLocation(this.program, "m_projection"); assert uid != -1; g.glUniformMatrix4fv( uid, 1, final int uid = g.glGetUniformLocation(this.program, "m_modelview"); assert uid != -1;
/** * @param program * @param shader * @see com.jogamp.opengl.GL2ES2#glAttachShader(int, int) */ public void glAttachShader(int program, int shader) { try{delegate.glAttachShader(program, shader);} catch(GLException e){glException(e); throw e;} } /**
/** * Implementation for {@link #createGlShader(int, String)}. * * @param shaderType The shader type * @param shaderSource The shader source code * @return The GL shader, or <code>null</code> if it cannot be compiled */ private Integer createGlShaderImpl(int shaderType, String shaderSource) { int glShader = gl.glCreateShader(shaderType); gl.glShaderSource( glShader, 1, new String[]{shaderSource}, null); gl.glCompileShader(glShader); int compileStatus[] = { 0 }; gl.glGetShaderiv(glShader, GL_COMPILE_STATUS, compileStatus, 0); if (compileStatus[0] != GL_TRUE) { printShaderLogInfo(glShader); return null; } return glShader; }
@Override public void createVertexAttribute(int glVertexArray, int target, int glBufferView, int attributeLocation, int size, int type, int stride, int offset) { gl.glBindVertexArray(glVertexArray); gl.glBindBuffer(target, glBufferView); gl.glVertexAttribPointer( attributeLocation, size, type, false, stride, offset); gl.glEnableVertexAttribArray(attributeLocation); }
@Override public int createGlBufferView( int target, int byteLength, ByteBuffer bufferViewData) { int bufferViewArray[] = {0}; gl.glGenBuffers(1, bufferViewArray, 0); int glBufferView = bufferViewArray[0]; gl.glBindBuffer(target, glBufferView); gl.glBufferData(target, byteLength, bufferViewData, GL_STATIC_DRAW); return glBufferView; }
@Override public int getAttributeLocation(int glProgram, String attributeName) { gl.glUseProgram(glProgram); return gl.glGetAttribLocation(glProgram, attributeName); }
g.glUseProgram(this.program_uv); g.glBindBuffer(GL.GL_ARRAY_BUFFER, this.mesh_lying); g.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, this.indices); position_attrib = g.glGetAttribLocation(this.program_uv, "v_position"); assert position_attrib != -1; g.glEnableVertexAttribArray(position_attrib); g.glVertexAttribPointer( position_attrib, 3, uv_attrib = g.glGetAttribLocation(this.program_uv, "v_uv"); assert uv_attrib != -1; g.glEnableVertexAttribArray(uv_attrib); g.glVertexAttribPointer( uv_attrib, 2, final int uid = g.glGetUniformLocation(this.program_uv, "m_projection"); assert uid != -1; g.glUniformMatrix4fv( uid, 1, final int uid = g.glGetUniformLocation(this.program_uv, "f_texture"); assert uid != -1;
mGL.getGL3().glUseProgram(mProg.getId()); mGL.getGL3().glGenVertexArrays(1, ui_vao, 0); mGL.getGL3().glBindVertexArray(ui_vao[0]); mGL.getGL3().glGenBuffers(3, ui_vbo, 0); vertices, GL.GL_STATIC_DRAW); mGL.getGL3().glEnableVertexAttribArray(0); mGL.getGL3() .glVertexAttribPointer(0, 3, GL.GL_FLOAT, false, 0, 0); normals, GL.GL_STATIC_DRAW); mGL.getGL3().glEnableVertexAttribArray(1); mGL.getGL3() .glVertexAttribPointer(1, 3, GL.GL_FLOAT, false, 0, 0); texCoords, GL.GL_STATIC_DRAW); mGL.getGL3().glEnableVertexAttribArray(2); mGL.getGL3() .glVertexAttribPointer(2, 2, GL.GL_FLOAT, false, 0, 0); mProg.getUniform("ProjectionMatrix") .setFloatMatrix(ProjectionMatrix.getFloatArray(), false); mGL.getGL3().glUseProgram(mProg.getId()); mGL.getGL3().glDisableVertexAttribArray(0);
)*primsPerBlock; saveWindowViewportState(gl); gl.glEnableVertexAttribArray(0); vps.getVertexNormXYTexture().bindToTextureUnit(4, gl); vps.getVertexNormZTexture().bindToTextureUnit(5, gl); gl.glDisable(GL3.GL_PROGRAM_POINT_SIZE);//Asserts that point size is set only from CPU gl.glPointSize(2*RendererFactory.PRIMITIVE_BUFFER_OVERSAMPLING);//2x2 frags gl.glViewport(0, 0, RendererFactory.PRIMITIVE_BUFFER_WIDTH*RendererFactory.PRIMITIVE_BUFFER_OVERSAMPLING, RendererFactory.PRIMITIVE_BUFFER_HEIGHT*RendererFactory.PRIMITIVE_BUFFER_OVERSAMPLING); gl.glDepthMask(false); gl.glDisable(GL3.GL_BLEND); gl.glDisable(GL3.GL_DEPTH_TEST); gl.glDisable(GL3.GL_CULL_FACE); gl.glDrawArrays(GL3.GL_POINTS, 0, (numTransparentBlocks+numOpaqueBlocks+numOpaqueUnoccludedTBlocks+numTransUnoccludedTBlocks)*primsPerBlock); gl.glEnable(GL3.GL_PROGRAM_POINT_SIZE); gl.glPointSize(1); revertViewportState(gl); gl.glDepthMask(true); gl.glDisable(GL3.GL_BLEND); gl.glDepthFunc(GL3.GL_LESS); gl.glEnable(GL3.GL_DEPTH_TEST); gl.glEnable(GL3.GL_DEPTH_CLAMP);
public void updateNormals(FloatBuffer pNormalBuffer) { if (!isDynamic()) throw new UnsupportedOperationException("Cannot update non dynamic buffers!"); getGL().getGL3().glBindVertexArray(mVertexArrayObject[0]); getGL().glBindBuffer(GL.GL_ARRAY_BUFFER, mVertexBuffers[1]); getGL().getGL3().glEnableVertexAttribArray(1); getGL().glBufferSubData(GL.GL_ARRAY_BUFFER, 0, pNormalBuffer.limit() * (Float.SIZE / Byte.SIZE), pNormalBuffer); getGL().getGL3().glVertexAttribPointer(1, mGeometrySize, GL.GL_FLOAT, false, 0, 0); getGL().getGL3().glBindVertexArray(0); getGL().glBindBuffer(GL.GL_ARRAY_BUFFER, 0); }
@Override public Void call() throws Exception { final GL3 gl = gpu.getGl(); gl.glGenBuffers(1, ib); ib.clear(); dummyBufferID = ib.get(); gl.glBindBuffer(GL3.GL_ARRAY_BUFFER, dummyBufferID); gl.glBufferData(GL3.GL_ARRAY_BUFFER, 1, null, GL3.GL_STATIC_DRAW); gl.glEnableVertexAttribArray(0); gl.glVertexAttribPointer(0, 1, GL3.GL_BYTE, false, 0, 0); gl.glBindBuffer(GL3.GL_ARRAY_BUFFER, 0); return null; } });//end task0
int glProgram = gl.glCreateProgram(); gl.glAttachShader(glProgram, glVertexShader); gl.glDeleteShader(glVertexShader); gl.glAttachShader(glProgram, glFragmentShader); gl.glDeleteShader(glFragmentShader); gl.glLinkProgram(glProgram); gl.glValidateProgram(glProgram); gl.glGetProgramiv(glProgram, GL_VALIDATE_STATUS, validateStatus, 0); if (validateStatus[0] != GL_TRUE)
public void recompile(final GL pGL) { close(); // preprocess shader final String shaderSourceProcessed = preprocessShader(mShaderSource); mShaderId = pGL.getGL3().glCreateShader(glShaderTypeMapping.get(mShaderType)); mGL.getGL3().glShaderSource(mShaderId, 1, new String[]{shaderSourceProcessed}, null); mGL.getGL3().glCompileShader(mShaderId); }
private static int createProgram( final GL3 g, final int vs, final int fs, final IntBuffer status) { final int id = g.glCreateProgram(); if (id == 0) { throw new GLException("glCreateProgram failed"); } g.glAttachShader(id, vs); g.glAttachShader(id, fs); g.glLinkProgram(id); g.glGetProgramiv(id, GL2ES2.GL_LINK_STATUS, status); if (status.get(0) == GL.GL_FALSE) { final ByteBuffer buffer = Buffers.newDirectByteBuffer(8192); final IntBuffer buffer_length = Buffers.newDirectIntBuffer(1); g.glGetProgramInfoLog(id, 8192, buffer_length, buffer); final byte[] raw = new byte[buffer.remaining()]; buffer.get(raw); final String tt = new String(raw); throw new GLException("compile: program: " + tt); } return id; }
@Override public void apply(GL3 gl, Collection<SoundEvent> events, double bufferStartTimeSeconds) { gl.glLineWidth(1); gl.glDisable(GL3.GL_LINE_SMOOTH); gl.glDisable(GL3.GL_CULL_FACE); gl.glEnable(GL3.GL_BLEND); gl.glDepthFunc(GL3.GL_ALWAYS); //gl.glProvokingVertex(GL3.GL_FIRST_VERTEX_CONVENTION); gl.glDepthMask(false); gl.glBlendFunc(GL3.GL_ONE, GL3.GL_ONE); soundProgram.use(); //assert vertexIDAttribLocation != -1:"VertexIDAttribLocation failed to init!"; //gl.glBindBuffer(GL3.GL_ARRAY_BUFFER, vertexBufferID); // gl.glEnableVertexAttribArray(vertexIDAttribLocation); //gl.glVertexAttribPointer(vertexIDAttribLocation, 1, GL3.GL_FLOAT, false, 0, 0); soundTextureU.set((int)0); for(SoundEvent ev:events) ev.apply(gl, bufferStartTimeSeconds); //Cleanup //gl.glDisableVertexAttribArray(vertexIDAttribLocation); gl.glBindBuffer(GL3.GL_ARRAY_BUFFER, 0); gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA); gl.glDisable(GL3.GL_BLEND); gl.glUseProgram(0); }//end apply(...)
@Override public void display(GLAutoDrawable glAutoDrawable) { GL3 gl = glAutoDrawable.getGL().getGL3(); gl.glClear(GL3.GL_DEPTH_BUFFER_BIT | GL3.GL_COLOR_BUFFER_BIT); gl.glUseProgram(program) gl.glBindVertexArray(vertexArray.get(0)); gl.glDrawArrays(GL.GL_TRIANGLES, 0, 6) }
private static String getProgramInfoLog(final GL3 gl, final int programObj) { final int[] infoLogLength = new int[1]; gl.glGetProgramiv(programObj, gl.GL_INFO_LOG_LENGTH, infoLogLength, 0); if (infoLogLength[0] == 0) { return "valid"; } final int[] charsWritten = new int[1]; final byte[] infoLogBytes = new byte[infoLogLength[0]]; gl.glGetProgramInfoLog(programObj, infoLogLength[0], charsWritten, 0, infoLogBytes, 0); return new String(infoLogBytes, 0, charsWritten[0]); } }
/** * Creates a new shader object. * @param gl gl object * @param code shader code * @param type shader type */ private Shader(final GL3 gl, final String code, final Type type) { this.gl = gl; this.shaderHandle = gl.glCreateShader(type.getGlShaderType()); this.code = code; this.type = type; gl.glShaderSource(this.shaderHandle, 1, new String[]{this.code}, (int[]) null, 0); gl.glCompileShader(this.shaderHandle); String info = getShaderInfoLog(gl, this.shaderHandle); if (!isShaderValid(gl, this.shaderHandle)) { gl.glDeleteShader(this.shaderHandle); this.shaderHandle = 0; throw new RuntimeException(info); } }
public void recompileProgram(final GL pGL) { final long start = System.nanoTime(); pGL.getGL3().glDeleteProgram(mProgramId); mProgramId = mGL.getGL3().glCreateProgram(); for (final GLShader shader : mShaders.values()) { shader.setParameters(parameters); shader.recompile(pGL); mGL.getGL3().glAttachShader(mProgramId, shader.getId()); } mGL.getGL3().glLinkProgram(mProgramId); final long diff = System.nanoTime() - start; stale = false; }
public GLProgram(final GL pGL, final HashMap<GLShaderType, GLShader> pipeline) { super(); mGL = pGL; mProgramId = mGL.getGL3().glCreateProgram(); mShaders = pipeline; for (final GLShader shader : pipeline.values()) { mGL.getGL3().glAttachShader(mProgramId, shader.getId()); } mGL.getGL3().glLinkProgram(mProgramId); }