SpinningCube3D.java

Go to the documentation of this file.

/* Copyright (c) 2013-2017, ARM Limited and Contributors
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

package com.arm.malideveloper.openglessdk.rendertotexturejava;

import java.io.InputStream;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLES20;
import android.opengl.GLUtils;
import android.opengl.Matrix;
import android.content.Context;

public class SpinningCube3D {

    // TODO: Added error checks

    private Context m_Context;

    private int m_RotateX = 0;
    private int m_RotateY = 360;

    private int m_VertexCount = 23;

    private int m_IndexCount = 36;

    private int m_CubeDiffuseTextureId;

    private int m_CubeFBOTextureId;


    private int[] m_RenderToTextureFBO = new int[1];

    private int[] m_VertexAttributeVBO = new int[1];

    private int[] m_VertexAttributeIBO = new int[1];

    private int m_ShaderProgramID;

    private int m_VerticesPositionAttributeId;
    private int m_VerticesTextureAttributeId;

    private int m_ModelViewProjectionId;

    private final String m_VertexShaderSource =
            "uniform mat4 uModelViewProjection;\n" +
            "attribute vec4 aPosition;\n" +
            "attribute vec2 aTextureCoordinate;\n" +
            "varying vec2 vTextureCoordinate;\n" +
            "void main(){\n" +
            "gl_Position = uModelViewProjection * aPosition;\n" +
            "vTextureCoordinate = aTextureCoordinate;\n" +
            "}\n";

    private final String m_FragmentShaderSource =
            "precision mediump float;\n" +
            "varying vec2 vTextureCoordinate;\n" +
            "uniform sampler2D sTextureSampler;\n" +
            "void main(){\n" +
            "gl_FragColor = texture2D(sTextureSampler, vTextureCoordinate);\n" +
            "}\n";

    private float[] m_ModelViewProjectionMatrix = new float[16];
    private float[] m_ModelingMatrix = new float[16];
    private float[] m_ModelViewMatrix = new float[16];
    private float[] m_ProjectionMatrix = new float[16];

    private int m_Width;
    private int m_Height;

    private int m_FBOWidth = 256;
    private int m_FBOHeight = 256;

    public SpinningCube3D() {
        super();
    }

    public SpinningCube3D(Context a_Context) {
        super();

        this.m_Context = a_Context;
    }

    public void createSpinningCube() {

        GLES20.glEnable(GLES20.GL_CULL_FACE);

        GLES20.glEnable(GLES20.GL_DEPTH_TEST);

        createShaderProgram();

        createTexture();

        buildVertexAndIndexBufferObjects();

        Matrix.setLookAtM(this.m_ModelViewMatrix, 0, 0, 0, -2, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
    }

    private void createTexture() {

        int[] textureIds = new int[1];
        GLES20.glGenTextures(1, textureIds, 0);
        this.m_CubeDiffuseTextureId = textureIds[0];

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, this.m_CubeDiffuseTextureId);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);

        InputStream inputStream = this.m_Context.getResources().openRawResource(R.raw.bubbles);
        Bitmap bitmapTexture = BitmapFactory.decodeStream(inputStream);

        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmapTexture, 0);

        bitmapTexture.recycle();
    }

    private void createShaderProgram() {

        int vertexShader = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);

        GLES20.glShaderSource(vertexShader, this.m_VertexShaderSource);
        GLES20.glCompileShader(vertexShader);

        int fragmentShader = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);

        GLES20.glShaderSource(fragmentShader, this.m_FragmentShaderSource);
        GLES20.glCompileShader(fragmentShader);

        this.m_ShaderProgramID = GLES20.glCreateProgram();

        GLES20.glAttachShader(this.m_ShaderProgramID, vertexShader);
        GLES20.glAttachShader(this.m_ShaderProgramID, fragmentShader);

        GLES20.glLinkProgram(this.m_ShaderProgramID);

        this.m_VerticesPositionAttributeId = GLES20.glGetAttribLocation(this.m_ShaderProgramID, "aPosition");
        if (this.m_VerticesPositionAttributeId == -1) {
            throw new RuntimeException("aPosition attribute location invalid");
        }

        this.m_VerticesTextureAttributeId = GLES20.glGetAttribLocation(this.m_ShaderProgramID, "aTextureCoordinate");
        if (this.m_VerticesTextureAttributeId == -1) {
            throw new RuntimeException("aTextureCoordinate attribute location invalid");
        }

        this.m_ModelViewProjectionId = GLES20.glGetUniformLocation(this.m_ShaderProgramID, "uModelViewProjection");
        if (this.m_ModelViewProjectionId == -1) {
            throw new RuntimeException("uModelViewProjection location invalid");
        }
    }

    public void render() {

        int floatSize = Float.SIZE >> 3;

        GLES20.glUseProgram(this.m_ShaderProgramID);

        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, this.m_VertexAttributeVBO[0]);
        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, this.m_VertexAttributeIBO[0]);

        GLES20.glVertexAttribPointer(this.m_VerticesPositionAttributeId, 3, GLES20.GL_FLOAT, false, 0, 0);
        GLES20.glEnableVertexAttribArray(this.m_VerticesPositionAttributeId);

        GLES20.glVertexAttribPointer(this.m_VerticesTextureAttributeId, 2, GLES20.GL_FLOAT, false, 0 , this.m_VertexCount * 3 * floatSize);
        GLES20.glEnableVertexAttribArray(this.m_VerticesTextureAttributeId);

        this.m_RotateX += 2;
        this.m_RotateY -= 2;

        if (this.m_RotateX > 360) {
            this.m_RotateX = 0;
        }
        if (this.m_RotateY < 0) {
            this.m_RotateY = 360;
        }

        float[] m_ModelingMatrix1 = new float[16];
        float[] m_ModelingMatrix2 = new float[16];
        float[] m_ModelingMatrix3 = new float[16];

        Matrix.setRotateM(m_ModelingMatrix1, 0, this.m_RotateX, 1.0f, 0.0f, 0.0f);
        Matrix.setRotateM(m_ModelingMatrix2, 0, this.m_RotateY, 0.0f, 1.0f, 0.0f);

        Matrix.multiplyMM(m_ModelingMatrix3, 0, m_ModelingMatrix1, 0, m_ModelingMatrix2, 0);
        Matrix.multiplyMM(this.m_ModelingMatrix, 0, m_ModelViewMatrix, 0, m_ModelingMatrix3, 0);

        this.setProjection(this.m_FBOWidth, this.m_FBOHeight);

        Matrix.multiplyMM(this.m_ModelViewProjectionMatrix, 0, this.m_ProjectionMatrix, 0, this.m_ModelingMatrix, 0);

        GLES20.glUniformMatrix4fv(this.m_ModelViewProjectionId, 1, false, this.m_ModelViewProjectionMatrix, 0);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, this.m_RenderToTextureFBO[0]);

        GLES20.glClearColor(1.0f, 0.5f, 0.0f, 1.0f);
        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, this.m_CubeDiffuseTextureId);

        GLES20.glDrawElements(GLES20.GL_TRIANGLES, 36, GLES20.GL_UNSIGNED_SHORT, 0);

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

        GLES20.glClearColor(0.0f, 0.2f, 0.3f, 1.0f);
        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        this.setProjection(this.m_Width, this.m_Height);

        Matrix.multiplyMM(this.m_ModelViewProjectionMatrix, 0, this.m_ProjectionMatrix, 0, this.m_ModelingMatrix, 0);

        GLES20.glUniformMatrix4fv(this.m_ModelViewProjectionId, 1, false, this.m_ModelViewProjectionMatrix, 0);

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, this.m_CubeFBOTextureId);

        GLES20.glDrawElements(GLES20.GL_TRIANGLES, 36, GLES20.GL_UNSIGNED_SHORT, 0);
    }

    private void buildVertexAndIndexBufferObjects() {

        int floatSize = Float.SIZE >> 3;
        int shortSize = Short.SIZE >> 3;

        float cubeVerticesAttributes[] = new float[] {
            -0.5f, -0.5f,  0.5f,    /* 0  */
             0.5f, -0.5f,  0.5f,    /* 1  */
            -0.5f,  0.5f,  0.5f,    /* 2  */
             0.5f,  0.5f,  0.5f,    /* 3  */
            -0.5f, -0.5f, -0.5f,    /* 4  */
             0.5f, -0.5f, -0.5f,    /* 5  */
            -0.5f,  0.5f, -0.5f,    /* 6  */
             0.5f,  0.5f, -0.5f,    /* 7  */
             0.5f, -0.5f,  0.5f,    /* 8  */
             0.5f,  0.5f,  0.5f,    /* 9  */
             0.5f, -0.5f, -0.5f,    /* 10 */
            -0.5f, -0.5f, -0.5f,    /* 11 */
             0.5f,  0.5f, -0.5f,    /* 12 */
            -0.5f,  0.5f, -0.5f,    /* 13 */
            -0.5f,  0.5f, -0.5f,    /* 14 */
            -0.5f, -0.5f,  0.5f,    /* 15 */
            -0.5f,  0.5f,  0.5f,    /* 16 */
            -0.5f,  0.5f,  0.5f,    /* 17 */
             0.5f,  0.5f,  0.5f,    /* 18 */
             0.5f,  0.5f, -0.5f,    /* 19 */
            -0.5f, -0.5f,  0.5f,    /* 20 */
            -0.5f, -0.5f, -0.5f,    /* 21 */
             0.5f, -0.5f,  0.5f,    /* 22 */

            0.0f, 0.0f,             /* 0  */
            1.0f, 0.0f,             /* 1  */
            0.0f, 1.0f,             /* 2  */
            1.0f, 1.0f,             /* 3  */
            0.0f, 0.0f,             /* 4  */
            1.0f, 0.0f,             /* 5  */
            0.0f, 1.0f,             /* 6  */
            1.0f, 1.0f,             /* 7  */
            0.0f, 0.0f,             /* 8  */
            0.0f, 1.0f,             /* 9  */
            0.0f, 0.0f,             /* 10 */
            1.0f, 0.0f,             /* 11 */
            0.0f, 1.0f,             /* 12 */
            1.0f, 1.0f,             /* 13 */
            0.0f, 1.0f,             /* 14 */
            1.0f, 0.0f,             /* 15 */
            1.0f, 1.0f,             /* 16 */
            0.0f, 0.0f,             /* 17 */
            1.0f, 0.0f,             /* 18 */
            1.0f, 1.0f,             /* 19 */
            0.0f, 1.0f,             /* 20 */
            0.0f, 0.0f,             /* 21 */
            1.0f, 1.0f,             /* 22 */

        };

        short cubeTriangleIndices[] = new short[] {
            0, 1, 2,                /* 1  */
            2, 1, 3,                /* 2  */

            8, 5, 9,                /* 3  */
            9, 5, 7,                /* 4  */

            10, 11, 12,             /* 5  */
            12, 11, 13,             /* 6  */

            14, 4, 15,              /* 7  */
            14, 15, 16,             /* 8  */

            17, 18, 6,              /* 9  */
            6, 18, 19,              /* 10 */

            20, 21, 5,              /* 11 */
            20, 5, 22               /* 12 */
        };

        FloatBuffer vertexDataBuffer;
        ShortBuffer indexDataBuffer;

        vertexDataBuffer = FloatBuffer.wrap(cubeVerticesAttributes);
        indexDataBuffer = ShortBuffer.wrap(cubeTriangleIndices);

        GLES20.glGenBuffers(1, this.m_VertexAttributeVBO, 0);
        GLES20.glGenBuffers(1, this.m_VertexAttributeIBO, 0);

        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, this.m_VertexAttributeVBO[0]);
        GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, (this.m_VertexCount * 3 * floatSize) + (this.m_VertexCount * 2 * floatSize)  , vertexDataBuffer, GLES20.GL_STATIC_DRAW);

        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, this.m_VertexAttributeIBO[0]);
        GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, this.m_IndexCount * shortSize , indexDataBuffer, GLES20.GL_STATIC_DRAW);

        int[] textureIds = new int[1];
        GLES20.glGenTextures(1, textureIds, 0);
        this.m_CubeFBOTextureId = textureIds[0];

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, this.m_CubeFBOTextureId);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);
        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, this.m_FBOWidth, this.m_FBOHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);

        GLES20.glGenFramebuffers(1, this.m_RenderToTextureFBO, 0);

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, this.m_RenderToTextureFBO[0]);

        GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, this.m_CubeFBOTextureId, 0);

        int iResult = GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER);
        if(iResult != GLES20.GL_FRAMEBUFFER_COMPLETE)
        {
            throw new RuntimeException("Error: Frame Buffer Status is not complete. Terminated.");
        }

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
    }

    public void setWidthHeight(int a_Width, int a_Height){
        this.m_Width = a_Width;
        this.m_Height = a_Height;
    }

    public void setProjection(int a_Width, int a_Height) {

        GLES20.glViewport(0, 0, a_Width, a_Height);

        float aspectRatio = (float) a_Width / (float) a_Height;
        Matrix.frustumM(this.m_ProjectionMatrix, 0, -aspectRatio, aspectRatio, -1, 1, 1, 10);
    }
}