예제 #1
0
  public void init(GLAutoDrawable drawable) {
    drawable.setAutoSwapBufferMode(false);

    GL2ES2 gl = drawable.getGL().getGL2ES2();
    System.err.println("Entering initialization");
    System.err.println("GL_VERSION=" + gl.glGetString(gl.GL_VERSION));
    System.err.println("GL_EXTENSIONS:");
    System.err.println("  " + gl.glGetString(gl.GL_EXTENSIONS));

    pmvMatrix = new PMVMatrix();

    pmod.initShaderState(gl);
    st = ShaderState.getCurrent();

    // Push the 1st uniform down the path
    st.glUseProgram(gl, true);

    pmvMatrix.glMatrixMode(pmvMatrix.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glMatrixMode(pmvMatrix.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();

    if (!st.glUniform(gl, new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf()))) {
      throw new GLException("Error setting PMVMatrix in shader: " + st);
    }

    // OpenGL Render Settings
    gl.glClearColor(0, 0, 0, 1);
    gl.glEnable(GL2ES2.GL_DEPTH_TEST);

    st.glUseProgram(gl, false);

    // Let's show the completed shader state ..
    System.out.println(st);
  }
예제 #2
0
  public RenderStateImpl(ShaderState st, Vertex.Factory<? extends Vertex> pointFactory) {
    this(st, pointFactory, new PMVMatrix());

    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
  }
예제 #3
0
  // Unused routines
  public void reshape(GLAutoDrawable glad, int x, int y, int width, int height) {
    System.err.println("reshape ..");
    final GL2ES2 gl = glad.getGL().getGL2ES2();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    // pmvMatrix.glOrthof(-1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f);
    pmvMatrix.glOrthof(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 10.0f);
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();

    st.useProgram(gl, true);
    st.uniform(gl, pmvMatrixUniform);
    st.useProgram(gl, false);
  }
예제 #4
0
 public void orthof(float left, float right, float bottom, float top, float zNear, float zFar) {
   orthoproj[0] = left;
   orthoproj[1] = right;
   orthoproj[2] = bottom;
   orthoproj[3] = top;
   pvmat.glMatrixMode(GL2.GL_PROJECTION);
   pvmat.glLoadIdentity();
   pvmat.glOrthof(left, right, bottom, top, zNear, zFar);
   pvmat.update();
 }
예제 #5
0
  @Override
  public void reshape(
      final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) {
    final GL2ES2 gl = drawable.getGL().getGL2ES2();

    // Clear background to white
    gl.glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
    if (null != st) {
      pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
      pmvMatrix.glLoadIdentity();
      pmvMatrix.glOrthof(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 10.0f);

      pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
      pmvMatrix.glLoadIdentity();

      st.useProgram(gl, true);
      st.uniform(gl, pmvMatrixUniform);
      st.useProgram(gl, false);
    }
  }
예제 #6
0
  public void display(GLAutoDrawable drawable) {
    final GL2 gl = drawable.getGL().getGL2();
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    mats.glMatrixMode(GL2.GL_MODELVIEW);
    mats.glLoadIdentity();
    mats.glTranslatef(0f, 0f, -2.0f);
    // t = t+0.5f;
    t = 40f;
    mats.glRotatef(t, 0f, 1f, 0f);
    mats.glMatrixMode(GL2.GL_PROJECTION);
    mats.glLoadIdentity();
    mats.glFrustumf(-1f, 1f, -1f, 1f, 1f, 100f);
    mats.update();
    gl.glUseProgram(shader.getID());
    gl.glUniformMatrix4fv(uniformMat, 3, false, mats.glGetPMvMviMatrixf());

    obj.display(gl, mats);
    gl.glFlush();
    gl.glUseProgram(0);
  }
예제 #7
0
  public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
    GL2ES2 gl = drawable.getGL().getGL2ES2();

    st.glUseProgram(gl, true);

    // Set location in front of camera
    pmvMatrix.glMatrixMode(pmvMatrix.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glOrthof(0f, 1.0f, 0.0f, 1.0f, 1.0f, 100.0f);

    pmvMatrix.glMatrixMode(pmvMatrix.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glTranslatef(0, 0, -10);

    GLUniformData ud = st.getUniform("mgl_PMVMatrix");
    if (null != ud) {
      // same data object
      st.glUniform(gl, ud);
    }

    st.glUseProgram(gl, false);
  }
예제 #8
0
  public void display(final GLAutoDrawable drawable) {
    final GL2ES2 gl = drawable.getGL().getGL2ES2();

    gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

    final RegionRenderer regionRenderer = getRenderer();
    final PMVMatrix pmv = regionRenderer.getMatrix();
    pmv.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    pmv.glLoadIdentity();
    pmv.glTranslatef(getXTran(), getYTran(), getZTran());
    pmv.glRotatef(getAngle(), 0, 1, 0);
    if (weight != regionRenderer.getRenderState().getWeight()) {
      regionRenderer.getRenderState().setWeight(weight);
    }
    region.draw(gl, regionRenderer, getSampleCount());
  }
예제 #9
0
  @Override
  public void display(final GLAutoDrawable glad) {
    final long t1 = System.currentTimeMillis();

    final GL2ES2 gl = glad.getGL().getGL2ES2();
    if (clearBuffers) {
      if (null != tileRendererInUse) {
        gl.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
      } else {
        gl.glClearColor(0, 0, 0, 0);
      }
      gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    }
    if (!gl.hasGLSL()) {
      return;
    }
    st.useProgram(gl, true);
    // One rotation every four seconds
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glTranslatef(0, 0, -10);
    if (doRotate) {
      final float ang = ((t1 - t0) * 360.0F) / 4000.0F;
      pmvMatrix.glRotatef(ang, 0, 0, 1);
      pmvMatrix.glRotatef(ang, 0, 1, 0);
    }
    st.uniform(gl, pmvMatrixUniform);

    // Draw a square
    vertices.enableBuffer(gl, true);
    colors.enableBuffer(gl, true);
    gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, 4);
    vertices.enableBuffer(gl, false);
    colors.enableBuffer(gl, false);
    st.useProgram(gl, false);
  }
  @Test
  public void testShaderState01Validation() throws InterruptedException {
    // preset ..
    final NEWTGLContext.WindowContext winctx =
        NEWTGLContext.createOnscreenWindow(GLProfile.getGL2ES2(), 480, 480, true);
    final GLDrawable drawable = winctx.context.getGLDrawable();
    final GL2ES2 gl = winctx.context.getGL().getGL2ES2();
    System.err.println(winctx.context);

    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());

    // test code ..
    final ShaderState st = new ShaderState();

    final ShaderCode rsVp =
        ShaderCode.create(
            gl,
            GL2ES2.GL_VERTEX_SHADER,
            1,
            RedSquare0.class,
            "shader",
            "shader/bin",
            "RedSquareShader");
    final ShaderCode rsFp =
        ShaderCode.create(
            gl,
            GL2ES2.GL_FRAGMENT_SHADER,
            1,
            RedSquare0.class,
            "shader",
            "shader/bin",
            "RedSquareShader");

    final ShaderProgram sp = new ShaderProgram();
    Assert.assertTrue(0 > sp.program());

    sp.add(gl, rsVp, System.err);
    sp.add(gl, rsFp, System.err);

    Assert.assertTrue(0 <= sp.program());
    Assert.assertTrue(!sp.inUse());
    Assert.assertTrue(!sp.linked());
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());

    st.attachShaderProgram(gl, sp);

    // Allocate Vertex Array0
    final GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, vertices0_loc);
    System.err.println("vertices0: " + vertices0);
    vertices0.enableBuffer(gl, false);
    Assert.assertEquals(vertices0_loc, vertices0.getLocation());
    st.ownAttribute(vertices0, true);

    // Allocate Color Array0
    final GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, colors0_loc);
    System.err.println("colors0: " + colors0);
    colors0.enableBuffer(gl, false);
    Assert.assertEquals(colors0_loc, colors0.getLocation());
    st.ownAttribute(colors0, true);

    Assert.assertTrue(sp.link(gl, System.err));
    Assert.assertTrue(sp.linked());
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());

    Assert.assertEquals(vertices0_loc, vertices0.getLocation());
    GLSLMiscHelper.validateGLArrayDataServerState(gl, st, vertices0);

    Assert.assertEquals(colors0_loc, colors0.getLocation());
    GLSLMiscHelper.validateGLArrayDataServerState(gl, st, colors0);

    Assert.assertEquals(null, ShaderState.getShaderState(gl));
    st.useProgram(gl, true);
    Assert.assertTrue(sp.inUse());
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
    Assert.assertEquals(st, ShaderState.getShaderState(gl));

    // setup mgl_PMVMatrix
    final PMVMatrix pmvMatrix = new PMVMatrix();
    final GLUniformData pmvMatrixUniform =
        new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
    st.ownUniform(pmvMatrixUniform);

    st.uniform(gl, pmvMatrixUniform);
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
    Assert.assertEquals(pmvMatrixUniform, st.getUniform("mgl_PMVMatrix"));

    // Allocate Vertex Array1
    final GLArrayDataServer vertices1 = GLSLMiscHelper.createRSVertices1(gl, st);
    System.err.println("vertices1: " + vertices1);
    vertices1.enableBuffer(gl, false);
    GLSLMiscHelper.validateGLArrayDataServerState(gl, st, vertices1);
    st.ownAttribute(vertices1, true);

    // Allocate Color Array1
    final GLArrayDataServer colors1 = GLSLMiscHelper.createRSColors1(gl, st);
    System.err.println("colors1: " + colors1);
    colors1.enableBuffer(gl, false);
    GLSLMiscHelper.validateGLArrayDataServerState(gl, st, colors1);
    st.ownAttribute(colors0, true);

    // misc GL setup
    gl.glClearColor(0, 0, 0, 1);
    gl.glEnable(GL2ES2.GL_DEPTH_TEST);
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());

    // reshape
    pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.gluPerspective(
        45.0F, (float) drawable.getWidth() / (float) drawable.getHeight(), 1.0F, 100.0F);
    pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glTranslatef(0, 0, -10);
    st.uniform(gl, pmvMatrixUniform);
    gl.glViewport(0, 0, drawable.getWidth(), drawable.getHeight());
    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());

    // display #1 vertices0 / colors0 (post-disable)
    GLSLMiscHelper.displayVCArrays(
        drawable, gl, st, true, vertices0, colors0, true, 1, durationPerTest);

    // display #2 #1 vertices1 / colors1 (post-disable)
    GLSLMiscHelper.displayVCArrays(
        drawable, gl, st, true, vertices1, colors1, true, 2, durationPerTest);

    // display #3 vertices0 / colors0 (post-disable)
    GLSLMiscHelper.displayVCArrays(
        drawable, gl, st, true, vertices0, colors0, true, 3, durationPerTest);

    // cleanup
    st.destroy(gl);

    NEWTGLContext.destroyWindow(winctx);
  }
  @Test(timeout = 120000)
  public void testShaderState01PerformanceDouble() throws InterruptedException {
    // preset ..
    final NEWTGLContext.WindowContext winctx =
        NEWTGLContext.createOnscreenWindow(GLProfile.getGL2ES2(), 480, 480, false);
    final GLDrawable drawable = winctx.context.getGLDrawable();
    final GL2ES2 gl = winctx.context.getGL().getGL2ES2();
    System.err.println(winctx.context);
    gl.setSwapInterval(0);

    Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());

    // test code ..
    final ShaderState st = new ShaderState();

    final ShaderCode rsVp =
        ShaderCode.create(
            gl,
            GL2ES2.GL_VERTEX_SHADER,
            1,
            RedSquare0.class,
            "shader",
            "shader/bin",
            "RedSquareShader");
    final ShaderCode rsFp =
        ShaderCode.create(
            gl,
            GL2ES2.GL_FRAGMENT_SHADER,
            1,
            RedSquare0.class,
            "shader",
            "shader/bin",
            "RedSquareShader");

    final ShaderProgram sp = new ShaderProgram();
    sp.add(rsVp);
    sp.add(rsFp);

    sp.init(gl);
    Assert.assertTrue(sp.link(gl, System.err));

    st.attachShaderProgram(gl, sp);
    st.useProgram(gl, true);

    // setup mgl_PMVMatrix
    final PMVMatrix pmvMatrix = new PMVMatrix();
    final GLUniformData pmvMatrixUniform =
        new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());
    st.ownUniform(pmvMatrixUniform);
    st.uniform(gl, pmvMatrixUniform);

    // Allocate Vertex Array0
    final GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, -1);
    st.ownAttribute(vertices0, true);
    vertices0.enableBuffer(gl, false);

    // Allocate Vertex Array1
    final GLArrayDataServer vertices1 = GLSLMiscHelper.createRSVertices1(gl, st);
    st.ownAttribute(vertices1, true);
    vertices1.enableBuffer(gl, false);

    // Allocate Color Array0
    final GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, -1);
    st.ownAttribute(colors0, true);
    colors0.enableBuffer(gl, false);

    // Allocate Color Array1
    final GLArrayDataServer colors1 = GLSLMiscHelper.createRSColors1(gl, st);
    st.ownAttribute(colors1, true);
    colors1.enableBuffer(gl, false);

    // misc GL setup
    gl.glClearColor(0, 0, 0, 1);
    gl.glEnable(GL2ES2.GL_DEPTH_TEST);

    // reshape
    pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.gluPerspective(
        45.0F, (float) drawable.getWidth() / (float) drawable.getHeight(), 1.0F, 100.0F);
    pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glTranslatef(0, 0, -10);
    st.uniform(gl, pmvMatrixUniform);
    gl.glViewport(0, 0, drawable.getWidth(), drawable.getHeight());

    gl.setSwapInterval(0);

    // validation ..
    GLSLMiscHelper.displayVCArrays(drawable, gl, st, true, vertices0, colors0, true, 1, 0);
    GLSLMiscHelper.displayVCArrays(drawable, gl, st, true, vertices1, colors1, true, 2, 0);

    // warmup ..
    for (int frames = 0; frames < GLSLMiscHelper.frames_warmup; frames += 2) {
      GLSLMiscHelper.displayVCArraysNoChecks(drawable, gl, true, vertices0, colors0, true);
      GLSLMiscHelper.displayVCArraysNoChecks(drawable, gl, true, vertices1, colors1, true);
    }

    // measure ..
    long t0 = System.currentTimeMillis();
    int frames;

    for (frames = 0; frames < GLSLMiscHelper.frames_perftest; frames += 2) {
      GLSLMiscHelper.displayVCArraysNoChecks(drawable, gl, true, vertices0, colors0, true);
      GLSLMiscHelper.displayVCArraysNoChecks(drawable, gl, true, vertices1, colors1, true);
    }
    final long t1 = System.currentTimeMillis();
    final long dt = t1 - t0;
    final double fps = (frames * 1000.0) / (double) dt;
    final String fpsS = String.valueOf(fps);
    final int fpsSp = fpsS.indexOf('.');
    System.err.println(
        "testShaderState01PerformanceDouble: "
            + dt / 1000.0
            + "s: "
            + frames
            + "f, "
            + fpsS.substring(0, fpsSp + 2)
            + " fps, "
            + dt / frames
            + " ms/f");

    // cleanup
    st.destroy(gl);

    NEWTGLContext.destroyWindow(winctx);
  }
예제 #12
0
파일: PMVMatrix.java 프로젝트: hanjoyo/jogl
  /**
   * Creates an instance of PMVMatrix.
   *
   * @param useBackingArray <code>true</code> for non direct NIO Buffers with guaranteed backing
   *     array, which allows faster access in Java computation.
   *     <p><code>false</code> for direct NIO buffers w/o a guaranteed backing array. In most Java
   *     implementations, direct NIO buffers have no backing array and hence the Java computation
   *     will be throttled down by direct IO get/put operations.
   *     <p>Depending on the application, ie. whether the Java computation or JNI invocation and
   *     hence native data transfer part is heavier, this flag shall be set to <code>true</code> or
   *     <code>false</code>.
   */
  public PMVMatrix(boolean useBackingArray) {
    this.usesBackingArray = useBackingArray;

    // I    Identity
    // T    Texture
    // P    Projection
    // Mv   ModelView
    // Mvi  Modelview-Inverse
    // Mvit Modelview-Inverse-Transpose
    if (useBackingArray) {
      matrixBufferArray = new float[6 * 16 + ProjectFloat.getRequiredFloatBufferSize()];
      matrixBuffer = null;
    } else {
      matrixBufferArray = null;
      matrixBuffer =
          Buffers.newDirectByteBuffer(
              (6 * 16 + ProjectFloat.getRequiredFloatBufferSize()) * Buffers.SIZEOF_FLOAT);
      matrixBuffer.mark();
    }

    matrixIdent = Buffers.slice2Float(matrixBuffer, matrixBufferArray, 0 * 16, 1 * 16); //  I
    matrixTex = Buffers.slice2Float(matrixBuffer, matrixBufferArray, 1 * 16, 1 * 16); //      T
    matrixPMvMvit =
        Buffers.slice2Float(
            matrixBuffer,
            matrixBufferArray,
            2 * 16,
            4 * 16); //          P  + Mv + Mvi + Mvit
    matrixPMvMvi =
        Buffers.slice2Float(
            matrixBuffer, matrixBufferArray, 2 * 16, 3 * 16); //          P  + Mv + Mvi
    matrixPMv =
        Buffers.slice2Float(matrixBuffer, matrixBufferArray, 2 * 16, 2 * 16); //          P  + Mv
    matrixP = Buffers.slice2Float(matrixBuffer, matrixBufferArray, 2 * 16, 1 * 16); //          P
    matrixMv =
        Buffers.slice2Float(matrixBuffer, matrixBufferArray, 3 * 16, 1 * 16); //               Mv
    matrixMvi =
        Buffers.slice2Float(
            matrixBuffer, matrixBufferArray, 4 * 16, 1 * 16); //                    Mvi
    matrixMvit =
        Buffers.slice2Float(
            matrixBuffer, matrixBufferArray, 5 * 16, 1 * 16); //                          Mvit

    projectFloat = new ProjectFloat(matrixBuffer, matrixBufferArray, 6 * 16);

    if (null != matrixBuffer) {
      matrixBuffer.reset();
    }
    FloatUtil.makeIdentityf(matrixIdent);

    vec3f = new float[3];
    matrixMult = new float[16];
    matrixTrans = new float[16];
    matrixRot = new float[16];
    matrixScale = new float[16];
    matrixOrtho = new float[16];
    matrixFrustum = new float[16];
    FloatUtil.makeIdentityf(matrixTrans, 0);
    FloatUtil.makeIdentityf(matrixRot, 0);
    FloatUtil.makeIdentityf(matrixScale, 0);
    FloatUtil.makeIdentityf(matrixOrtho, 0);
    FloatUtil.makeZero(matrixFrustum, 0);

    matrixPStack = new ArrayList<float[]>();
    matrixMvStack = new ArrayList<float[]>();

    // default values and mode
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glMatrixMode(GL.GL_TEXTURE);
    glLoadIdentity();
    setDirty();
    update();
  }
예제 #13
0
  @Override
  public void init(final GLAutoDrawable glad) {
    if (null != textureData) {
      texture = TextureIO.newTexture(glad.getGL(), textureData);
    }
    final GL2ES2 gl = glad.getGL().getGL2ES2();

    initShader(gl, true);

    // setup mgl_PMVMatrix
    pmvMatrix = new PMVMatrix();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrixUniform =
        new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf()); // P, Mv

    st.ownUniform(pmvMatrixUniform);
    if (!st.uniform(gl, pmvMatrixUniform)) {
      throw new GLException("Error setting PMVMatrix in shader: " + st);
    }
    if (!st.uniform(gl, new GLUniformData("mgl_ActiveTexture", textureUnit))) {
      throw new GLException("Error setting mgl_ActiveTexture in shader: " + st);
    }

    if (null != texture) {
      // fetch the flipped texture coordinates
      texture.getImageTexCoords().getST_LB_RB_LT_RT(s_quadTexCoords, 0, 1f, 1f);
    }

    interleavedVBO =
        GLArrayDataServer.createGLSLInterleaved(
            3 + 4 + 2, GL.GL_FLOAT, false, 3 * 4, GL.GL_STATIC_DRAW);
    {
      interleavedVBO.addGLSLSubArray("mgl_Vertex", 3, GL.GL_ARRAY_BUFFER);
      interleavedVBO.addGLSLSubArray("mgl_Color", 4, GL.GL_ARRAY_BUFFER);
      // interleavedVBO.addGLSLSubArray("mgl_Normal",        3, GL.GL_ARRAY_BUFFER);
      interleavedVBO.addGLSLSubArray("mgl_MultiTexCoord", 2, GL.GL_ARRAY_BUFFER);

      final FloatBuffer ib = (FloatBuffer) interleavedVBO.getBuffer();

      for (int i = 0; i < 4; i++) {
        ib.put(s_quadVertices, i * 3, 3);
        ib.put(s_quadColors, i * 4, 4);
        // ib.put(s_cubeNormals,   i*3, 3);
        ib.put(s_quadTexCoords, i * 2, 2);
      }
    }
    interleavedVBO.seal(gl, true);
    interleavedVBO.enableBuffer(gl, false);
    st.ownAttribute(interleavedVBO, true);

    // OpenGL Render Settings
    gl.glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
    gl.glEnable(GL.GL_DEPTH_TEST);

    if (keepTextureBound && null != texture) {
      gl.glActiveTexture(GL.GL_TEXTURE0 + textureUnit);
      texture.enable(gl);
      texture.bind(gl);
    }
    st.useProgram(gl, false);
  }
예제 #14
0
 public void perspectivef(float fovy, float aspect, float zNear, float zFar) {
   pvmat.glMatrixMode(GL2.GL_PROJECTION);
   pvmat.glLoadIdentity();
   pvmat.gluPerspective(fovy, aspect, zNear, zFar);
 }
예제 #15
0
  void reshapeImpl(
      final GL2ES2 gl,
      final int tileX,
      final int tileY,
      final int tileWidth,
      final int tileHeight,
      final int imageWidth,
      final int imageHeight) {
    System.err.println(
        Thread.currentThread()
            + " RedSquareES2.reshape "
            + tileX
            + "/"
            + tileY
            + " "
            + tileWidth
            + "x"
            + tileHeight
            + " of "
            + imageWidth
            + "x"
            + imageHeight
            + ", swapInterval "
            + swapInterval
            + ", drawable 0x"
            + Long.toHexString(gl.getContext().getGLDrawable().getHandle())
            + ", tileRendererInUse "
            + tileRendererInUse);
    // Thread.dumpStack();
    if (!gl.hasGLSL()) {
      return;
    }

    st.useProgram(gl, true);
    // Set location in front of camera
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();

    // compute projection parameters 'normal' perspective
    final float fovy = 45f;
    final float aspect2 = ((float) imageWidth / (float) imageHeight) / aspect;
    final float zNear = 1f;
    final float zFar = 100f;

    // compute projection parameters 'normal' frustum
    final float top = (float) Math.tan(fovy * ((float) Math.PI) / 360.0f) * zNear;
    final float bottom = -1.0f * top;
    final float left = aspect2 * bottom;
    final float right = aspect2 * top;
    final float w = right - left;
    final float h = top - bottom;

    // compute projection parameters 'tiled'
    final float l = left + tileX * w / imageWidth;
    final float r = l + tileWidth * w / imageWidth;
    final float b = bottom + tileY * h / imageHeight;
    final float t = b + tileHeight * h / imageHeight;

    pmvMatrix.glFrustumf(l, r, b, t, zNear, zFar);
    // pmvMatrix.glOrthof(-4.0f, 4.0f, -4.0f, 4.0f, 1.0f, 100.0f);
    st.uniform(gl, pmvMatrixUniform);
    st.useProgram(gl, false);

    System.err.println(Thread.currentThread() + " RedSquareES2.reshape FIN");
  }
예제 #16
0
  @Override
  public void init(final GLAutoDrawable glad) {
    System.err.println(
        Thread.currentThread() + " RedSquareES2.init: tileRendererInUse " + tileRendererInUse);
    final GL2ES2 gl = glad.getGL().getGL2ES2();

    System.err.println("RedSquareES2 init on " + Thread.currentThread());
    System.err.println("Chosen GLCapabilities: " + glad.getChosenGLCapabilities());
    System.err.println("INIT GL IS: " + gl.getClass().getName());
    System.err.println(JoglVersion.getGLStrings(gl, null, false).toString());
    if (!gl.hasGLSL()) {
      System.err.println("No GLSL available, no rendering.");
      return;
    }
    st = new ShaderState();
    st.setVerbose(true);
    final ShaderCode vp0 =
        ShaderCode.create(
            gl,
            GL2ES2.GL_VERTEX_SHADER,
            this.getClass(),
            "shader",
            "shader/bin",
            "RedSquareShader",
            true);
    final ShaderCode fp0 =
        ShaderCode.create(
            gl,
            GL2ES2.GL_FRAGMENT_SHADER,
            this.getClass(),
            "shader",
            "shader/bin",
            "RedSquareShader",
            true);
    vp0.defaultShaderCustomization(gl, true, true);
    fp0.defaultShaderCustomization(gl, true, true);
    final ShaderProgram sp0 = new ShaderProgram();
    sp0.add(gl, vp0, System.err);
    sp0.add(gl, fp0, System.err);
    st.attachShaderProgram(gl, sp0, true);

    // setup mgl_PMVMatrix
    pmvMatrix = new PMVMatrix();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();
    pmvMatrixUniform =
        new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf()); // P, Mv
    st.ownUniform(pmvMatrixUniform);
    st.uniform(gl, pmvMatrixUniform);

    // Allocate Vertex Array
    vertices =
        GLArrayDataServer.createGLSL("mgl_Vertex", 3, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
    vertices.putf(-2);
    vertices.putf(2);
    vertices.putf(0);
    vertices.putf(2);
    vertices.putf(2);
    vertices.putf(0);
    vertices.putf(-2);
    vertices.putf(-2);
    vertices.putf(0);
    vertices.putf(2);
    vertices.putf(-2);
    vertices.putf(0);
    vertices.seal(gl, true);
    st.ownAttribute(vertices, true);
    vertices.enableBuffer(gl, false);

    // Allocate Color Array
    colors = GLArrayDataServer.createGLSL("mgl_Color", 4, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
    colors.putf(1);
    colors.putf(0);
    colors.putf(0);
    colors.putf(1);
    colors.putf(0);
    colors.putf(0);
    colors.putf(1);
    colors.putf(1);
    colors.putf(1);
    colors.putf(0);
    colors.putf(0);
    colors.putf(1);
    colors.putf(1);
    colors.putf(0);
    colors.putf(0);
    colors.putf(1);
    colors.seal(gl, true);
    st.ownAttribute(colors, true);
    colors.enableBuffer(gl, false);

    // OpenGL Render Settings
    gl.glEnable(GL.GL_DEPTH_TEST);
    st.useProgram(gl, false);

    t0 = System.currentTimeMillis();
    System.err.println(Thread.currentThread() + " RedSquareES2.init FIN");
  }