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.Matrix;

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

class AroundTheWorldRendererPicker implements GLSurfaceView.Renderer

  {

	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[] mProjectionMatrix = new float[16];

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

  private int mPositionH;

	private int mColorH;

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

	AroundTheWorldRendererPicker()

	  {

				      -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.put(triangleVertData).position(0);

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

	  {

		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 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 =

		  + "attribute vec4 a_Position;               \n"

		  + "attribute vec4 a_Color;                  \n"

		  + "varying vec4 v_Color;                    \n"

		  + "  {                                      \n"

		  + "  v_Color = a_Color;                     \n"

		  + "  gl_Position = u_MVPMatrix* a_Position; \n"

		  + "  }                                      \n";

		final String fragmentShader =

		  + "varying vec4 v_Color;        \n"

		  + "  {                          \n"

		  + "  gl_FragColor = v_Color;    \n"

		  + "  }                          \n";

		if (vertexShaderHandle != 0)

		  {

      GLES30.glCompileShader(vertexShaderHandle);

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

			if (compileStatus[0] == 0)

  			{

	  		}

		  }

		if (vertexShaderHandle == 0)

		  {

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

		  }

		if (fragmentShaderHandle != 0)

		  {

      GLES30.glCompileShader(fragmentShaderHandle);

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

			if (compileStatus[0] == 0)

			  {

			  }

		  }

		if (fragmentShaderHandle == 0)

		  {

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

		  }

		if (programHandle != 0)

		  {

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

			if (linkStatus[0] == 0)

			  {

			  }

		  }

		if (programHandle == 0)

		  {

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

		  }

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

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

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

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

	  {

	  mWidth  = width;

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

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

	@Override public void onDrawFrame(GL10 glUnused)

	  {

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

    mTriangleVert.position(POSITION_OFFSET);

    GLES30.glEnableVertexAttribArray(mPositionH);

    GLES30.glEnableVertexAttribArray(mColorH);

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

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

    mSquareVert.position(POSITION_OFFSET);

    GLES30.glEnableVertexAttribArray(mPositionH);

    GLES30.glEnableVertexAttribArray(mColorH);

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

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

  }