private void initVertexArray(GL3 gl3) {

    gl3.glGenVertexArrays(1, vertexArrayName);
    gl3.glBindVertexArray(vertexArrayName.get(0));
    {
      gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
      {
        int stride = (2 + 3) * Float.BYTES;
        int offset = 0 * Float.BYTES;

        gl3.glEnableVertexAttribArray(Semantic.Attr.POSITION);
        gl3.glVertexAttribPointer(Semantic.Attr.POSITION, 2, GL_FLOAT, false, stride, offset);

        offset = 2 * Float.BYTES;
        gl3.glEnableVertexAttribArray(Semantic.Attr.COLOR);
        gl3.glVertexAttribPointer(Semantic.Attr.COLOR, 3, GL_FLOAT, false, stride, offset);
      }
      gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

      gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
    }
    gl3.glBindVertexArray(0);

    checkError(gl3, "initVao");
  }
  private boolean initBuffer(GL3 gl3) {

    FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexData);

    gl3.glGenBuffers(1, bufferName);

    gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(0));
    gl3.glBufferData(GL_ARRAY_BUFFER, vertexSize, vertexBuffer, GL_STATIC_DRAW);
    gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

    BufferUtils.destroyDirectBuffer(vertexBuffer);

    return checkError(gl3, "initBuffer");
  }
Exemple #3
0
  @Override
  public void init(GLAutoDrawable glad) {
    GL3 gl3 = glad.getGL().getGL3();

    try {
      shaders.add(
          GLSLHelpers.createShader(gl3, getClass(), GL3.GL_VERTEX_SHADER, "glsl/simple_vs"));
      shaders.add(
          GLSLHelpers.createShader(gl3, getClass(), GL3.GL_FRAGMENT_SHADER, "glsl/simple_fs"));
      program = GLSLHelpers.createProgram(gl3, shaders);

      gl3.glGenVertexArrays(1, VAO, 0);
      gl3.glBindVertexArray(VAO[0]);

      gl3.glGenBuffers(1, VBO, 0);
      gl3.glBindBuffer(GL3.GL_ARRAY_BUFFER, VBO[0]);
      FloatBuffer buffer = GLBuffers.newDirectFloatBuffer(TRIANGLE);
      gl3.glBufferData(GL3.GL_ARRAY_BUFFER, buffer.capacity() * 4, buffer, GL3.GL_STATIC_DRAW);
      gl3.glEnableVertexAttribArray(0);
      gl3.glVertexAttribPointer(0, 2, GL3.GL_FLOAT, false, 0, 0);

      gl3.glBindVertexArray(0);
    } catch (Throwable t) {
      t.printStackTrace();
    }
  }
  private boolean initVertexArray(GL3 gl3) {

    gl3.glGenVertexArrays(1, vertexArrayName);
    gl3.glBindVertexArray(vertexArrayName.get(0));
    {
      gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(0));
      gl3.glVertexAttribPointer(Semantic.Attr.POSITION, 2, GL_FLOAT, false, Vertex_v2fv2f.SIZE, 0);
      gl3.glVertexAttribPointer(
          Semantic.Attr.TEXCOORD, 2, GL_FLOAT, false, Vertex_v2fv2f.SIZE, Vec2.SIZE);
      gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

      gl3.glEnableVertexAttribArray(Semantic.Attr.POSITION);
      gl3.glEnableVertexAttribArray(Semantic.Attr.TEXCOORD);
    }
    gl3.glBindVertexArray(0);

    return checkError(gl3, "initVertexArray");
  }
  private boolean initVertexArray(GL3 gl3) {

    gl3.glGenVertexArrays(1, vertexArrayName);
    gl3.glBindVertexArray(vertexArrayName.get(0));
    {
      gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
      gl3.glVertexAttribPointer(
          Semantic.Attr.POSITION, 2, GL_FLOAT, false, glf.Vertex_v2fv2f.SIZE, 0);
      gl3.glVertexAttribPointer(
          Semantic.Attr.TEXCOORD, 2, GL_FLOAT, false, glf.Vertex_v2fv2f.SIZE, Vec2.SIZE);
      gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

      gl3.glEnableVertexAttribArray(Semantic.Attr.POSITION);
      gl3.glEnableVertexAttribArray(Semantic.Attr.TEXCOORD);

      gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
    }
    gl3.glBindVertexArray(0);

    return true;
  }
  private boolean initBuffer(GL3 gl3) {

    ShortBuffer elementBuffer = GLBuffers.newDirectShortBuffer(elementData);
    FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexData);
    IntBuffer uniformBufferOffset = GLBuffers.newDirectIntBuffer(1);

    gl3.glGenBuffers(Buffer.MAX, bufferName);

    gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
    gl3.glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementSize, elementBuffer, GL_STATIC_DRAW);
    gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
    gl3.glBufferData(GL_ARRAY_BUFFER, vertexSize, vertexBuffer, GL_STATIC_DRAW);
    gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

    gl3.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffset);
    int uniformBlockSize = Math.max(Mat4.SIZE, uniformBufferOffset.get(0));

    gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
    gl3.glBufferData(GL_UNIFORM_BUFFER, uniformBlockSize, null, GL_DYNAMIC_DRAW);
    gl3.glBindBuffer(GL_UNIFORM_BUFFER, 0);

    BufferUtils.destroyDirectBuffer(elementBuffer);
    BufferUtils.destroyDirectBuffer(vertexBuffer);
    BufferUtils.destroyDirectBuffer(uniformBufferOffset);

    return checkError(gl3, "initBuffer");
  }
  private void initBuffers(GL3 gl3) {

    FloatBuffer vertexBuffer = GLBuffers.newDirectFloatBuffer(vertexData);
    ShortBuffer elementBuffer = GLBuffers.newDirectShortBuffer(elementData);

    gl3.glGenBuffers(Buffer.MAX, bufferName);
    gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
    {
      gl3.glBufferData(GL_ARRAY_BUFFER, vertexSize, vertexBuffer, GL_STATIC_DRAW);
    }
    gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

    gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
    {
      gl3.glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementSize, elementBuffer, GL_STATIC_DRAW);
    }
    gl3.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    BufferUtils.destroyDirectBuffer(vertexBuffer);
    BufferUtils.destroyDirectBuffer(elementBuffer);

    checkError(gl3, "initBuffers");
  }
  @Override
  protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;
    {
      gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
      ByteBuffer pointer =
          gl3.glMapBufferRange(
              GL_UNIFORM_BUFFER, 0, Mat4.SIZE, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

      Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
      Mat4 model = new Mat4(1.0f);

      pointer.asFloatBuffer().put(projection.mul(viewMat4()).mul(model).toFa_());

      gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);
    }

    gl3.glDrawBuffer(GL_BACK);

    gl3.glViewport(0, 0, windowSize.x, windowSize.y);
    gl3.glDisable(GL_FRAMEBUFFER_SRGB);
    clearColor.put(new float[] {1.0f, 0.5f, 0.0f, 1.0f}).rewind();
    gl3.glClearBufferfv(GL_COLOR, 0, clearColor);

    gl3.glUseProgram(programName);

    gl3.glDisable(GL_FRAMEBUFFER_SRGB);
    gl3.glActiveTexture(GL_TEXTURE0);
    gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(0));
    gl3.glBindBufferBase(
        GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM));
    gl3.glBindVertexArray(vertexArrayName.get(0));

    gl3.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, elementCount, GL_UNSIGNED_SHORT, 0, 1, 0);

    return true;
  }