SpinningCube3D.java

Go to the documentation of this file.

/* Copyright (c) 2011-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.spinningcubejava;

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_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];

        public SpinningCube3D() {
                super();
        }

        public SpinningCube3D(Context a_Context) {
                super();
                
                this.m_Context = a_Context;
        }

        public void createSpinningCube() {
                
                GLES20.glEnable(GLES20.GL_CULL_FACE);
                
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        
                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.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        GLES20.glUseProgram(this.m_ShaderProgramID);

        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, this.m_CubeDiffuseTextureId);
        
        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);
        
        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.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);
    }

        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);
        }
}