Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.examples.aroundtheworld;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLES30;

import android.opengl.GLSurfaceView;

import android.opengl.Matrix;

///////////////////////////////////////////////////////////////////////////////////////////////////

class AroundTheWorldRendererPicker implements GLSurfaceView.Renderer

  {

	private static final int BYTES_PER_FLOAT    = 4;

	private static final int STRIDE_BYTES       = 7 * BYTES_PER_FLOAT;

	private static final int POSITION_OFFSET    = 0;

	private static final int POSITION_DATA_SIZE = 3;

	private static final int COLOR_OFFSET       = 3;

	private static final int COLOR_DATA_SIZE    = 4;

  private float[] mModelMatrix      = new float[16];

	private float[] mViewMatrix       = new float[16];

	private float[] mProjectionMatrix = new float[16];

	private float[] mMVPTriangleMatrix= new float[16];

  private float[] mMVPSquareMatrix  = new float[16];

	private final FloatBuffer mTriangleVert, mSquareVert;

  private int mMVPMatrixH;

  private int mPositionH;

	private int mColorH;

  private int mHeight, mWidth;

///////////////////////////////////////////////////////////////////////////////////////////////////

	AroundTheWorldRendererPicker()

	  {

	  Matrix.setIdentityM(mModelMatrix, 0);

		final float[] triangleVertData = {

				      -0.865f, 1.5f, 0.0f,    1.0f, 1.0f, 1.0f, 1.0f,   // x,y,z,  r,g,b,a

	            -0.865f,-1.5f, 0.0f,    0.0f, 0.0f, 0.0f, 1.0f,

	             1.730f, 0.0f, 0.0f,    0.5f, 0.5f, 0.0f, 1.0f };

		mTriangleVert = ByteBuffer.allocateDirect(triangleVertData.length * BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mTriangleVert.put(triangleVertData).position(0);

    final float[] squareVertData = {

				      -0.15f, 0.15f, 0.0f,    1.0f, 0.0f, 0.0f, 1.0f,

	            -0.15f,-0.15f, 0.0f,    1.0f, 0.0f, 0.0f, 1.0f,

	             0.15f, 0.15f, 0.0f,    1.0f, 0.0f, 0.0f, 1.0f,

	             0.15f,-0.15f, 0.0f,    1.0f, 0.0f, 0.0f, 1.0f };

		mSquareVert = ByteBuffer.allocateDirect(squareVertData.length * BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mSquareVert.put(squareVertData).position(0);

	  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void move(float x, float y)

		{

		mModelMatrix[12] = x;

		mModelMatrix[13] = y;

		}

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getHeight()

		{

		return mHeight;

		}

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getWidth()

		{

		return mWidth;

		}

///////////////////////////////////////////////////////////////////////////////////////////////////

	@Override public void onSurfaceCreated(GL10 glUnused, EGLConfig config)

	  {

		GLES30.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);

		final float eyeX = 0.0f;

		final float eyeY = 0.0f;

		final float eyeZ = 1.5f;

		final float lookX = 0.0f;

		final float lookY = 0.0f;

		final float lookZ = 0.0f;

		final float upX = 0.0f;

		final float upY = 1.0f;

		final float upZ = 0.0f;

		Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);

		final String vertexShader =

			  "uniform mat4 u_MVPMatrix;                \n"

		  + "attribute vec4 a_Position;               \n"

		  + "attribute vec4 a_Color;                  \n"

		  + "varying vec4 v_Color;                    \n"

		  + "void main()                              \n"

		  + "  {                                      \n"

		  + "  v_Color = a_Color;                     \n"

		  + "  gl_Position = u_MVPMatrix* a_Position; \n"

		  + "  }                                      \n";

		final String fragmentShader =

			  "precision mediump float;     \n"

		  + "varying vec4 v_Color;        \n"

		  + "void main()                  \n"

		  + "  {                          \n"

		  + "  gl_FragColor = v_Color;    \n"

		  + "  }                          \n";

		int vertexShaderHandle = GLES30.glCreateShader(GLES30.GL_VERTEX_SHADER);

		if (vertexShaderHandle != 0)

		  {

			GLES30.glShaderSource(vertexShaderHandle, vertexShader);

      GLES30.glCompileShader(vertexShaderHandle);

      final int[] compileStatus = new int[1];

			GLES30.glGetShaderiv(vertexShaderHandle, GLES30.GL_COMPILE_STATUS, compileStatus, 0);

			if (compileStatus[0] == 0)

  			{

				GLES30.glDeleteShader(vertexShaderHandle);

				vertexShaderHandle = 0;

	  		}

		  }

		if (vertexShaderHandle == 0)

		  {

			throw new RuntimeException("Error creating vertex shader.");

		  }

		int fragmentShaderHandle = GLES30.glCreateShader(GLES30.GL_FRAGMENT_SHADER);

		if (fragmentShaderHandle != 0)

		  {

			GLES30.glShaderSource(fragmentShaderHandle, fragmentShader);

      GLES30.glCompileShader(fragmentShaderHandle);

			final int[] compileStatus = new int[1];

			GLES30.glGetShaderiv(fragmentShaderHandle, GLES30.GL_COMPILE_STATUS, compileStatus, 0);

			if (compileStatus[0] == 0)

			  {

				GLES30.glDeleteShader(fragmentShaderHandle);

				fragmentShaderHandle = 0;

			  }

		  }

		if (fragmentShaderHandle == 0)

		  {

			throw new RuntimeException("Error creating fragment shader.");

		  }

		int programHandle = GLES30.glCreateProgram();

		if (programHandle != 0)

		  {

			GLES30.glAttachShader(programHandle, vertexShaderHandle);

      GLES30.glAttachShader(programHandle, fragmentShaderHandle);

			GLES30.glBindAttribLocation(programHandle, 0, "a_Position");

			GLES30.glBindAttribLocation(programHandle, 1, "a_Color");

			GLES30.glLinkProgram(programHandle);

			final int[] linkStatus = new int[1];

			GLES30.glGetProgramiv(programHandle, GLES30.GL_LINK_STATUS, linkStatus, 0);

			if (linkStatus[0] == 0)

			  {

				GLES30.glDeleteProgram(programHandle);

				programHandle = 0;

			  }

		  }

		if (programHandle == 0)

		  {

			throw new RuntimeException("Error creating program.");

		  }

    mMVPMatrixH = GLES30.glGetUniformLocation(programHandle, "u_MVPMatrix");

    mPositionH  = GLES30.glGetAttribLocation(programHandle, "a_Position");

    mColorH     = GLES30.glGetAttribLocation(programHandle, "a_Color");

    GLES30.glUseProgram(programHandle);

	  }

///////////////////////////////////////////////////////////////////////////////////////////////////

	@Override public void onSurfaceChanged(GL10 glUnused, int width, int height)

	  {

	  mHeight = height;

	  mWidth  = width;

		GLES30.glViewport(0, 0, width, height);

		final float ratio  = (float) width / height;

		final float left   =-ratio;

		final float right  = ratio;

		final float bottom =-1.0f;

		final float top    = 1.0f;

		final float near   = 1.0f;

		final float far    = 2.0f;

		Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);

		Matrix.multiplyMM(mMVPTriangleMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);

	  }

///////////////////////////////////////////////////////////////////////////////////////////////////

	@Override public void onDrawFrame(GL10 glUnused)

	  {

		GLES30.glClear(GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);

    GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPTriangleMatrix, 0);

    ///////// 'white-black-yellow' triangle //////

    mTriangleVert.position(POSITION_OFFSET);

    GLES30.glVertexAttribPointer(mPositionH, POSITION_DATA_SIZE, GLES30.GL_FLOAT, false, STRIDE_BYTES, mTriangleVert);

    GLES30.glEnableVertexAttribArray(mPositionH);

    mTriangleVert.position(COLOR_OFFSET);

    GLES30.glVertexAttribPointer(mColorH, COLOR_DATA_SIZE, GLES30.GL_FLOAT, false, STRIDE_BYTES, mTriangleVert);

    GLES30.glEnableVertexAttribArray(mColorH);

		GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPTriangleMatrix, 0);

		GLES30.glDrawArrays(GLES30.GL_TRIANGLES, 0, 3);

    //////// 'current position' square ///////////

    mSquareVert.position(POSITION_OFFSET);

    GLES30.glVertexAttribPointer(mPositionH, POSITION_DATA_SIZE, GLES30.GL_FLOAT, false, STRIDE_BYTES, mSquareVert);

    GLES30.glEnableVertexAttribArray(mPositionH);

    mSquareVert.position(COLOR_OFFSET);

    GLES30.glVertexAttribPointer(mColorH, COLOR_DATA_SIZE, GLES30.GL_FLOAT, false, STRIDE_BYTES, mSquareVert);

    GLES30.glEnableVertexAttribArray(mColorH);

    Matrix.multiplyMM(mMVPSquareMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);

    Matrix.multiplyMM(mMVPSquareMatrix, 0, mProjectionMatrix, 0, mMVPSquareMatrix, 0);

    GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPSquareMatrix, 0);

		GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0,4);

	  }

  }