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

import android.graphics.Bitmap;

import android.graphics.Matrix;

import android.opengl.GLES20;

import android.opengl.GLUtils;

import java.util.Iterator;

import java.util.LinkedList;

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

/**

 * Class which represents a OpenGL Texture object.

 * <p>

 * Create a Texture of arbitrary size and feed some pixels to it via the setTexture() method.

 * <p>

 * Keep all objects created in a static LinkedList. The point: we need to be able to mark

 * Textures for deletion, and delete all marked objects later at a convenient time (that's

 * because we can only delete from a thread that holds the OpenGL context so here we provide a

 * framework where one is able to mark for deletion at any time and actual deletion takes place

 * on the next render).

 */

public class DistortedTexture

  {

  private static boolean mListMarked = false;

  private static LinkedList<DistortedTexture> mList = new LinkedList<>();

  private static int mTextureH;

  private int mSizeX, mSizeY;  // in screen space

  float mHalfX, mHalfY;        // halves of the above

  private long mID;

  private boolean mMarked;

  private Bitmap mBmp= null;

  private int[] mTextureDataH;

  private boolean mBitmapSet;

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

// We have to flip vertically every single Bitmap that we get fed with.

//

// Reason: textures read from files are the only objects in OpenGL which have their origins at the

// upper-left corner. Everywhere else the origin is in the lower-left corner. Thus we have to flip.

// The alternative solution, namely inverting the y-coordinate of the TexCoord does not really work-

// i.e. it works only in case of rendering directly to the screen, but if we render to an FBO and

// then take the FBO and render to screen, (DistortedTree does so!) things get inverted as textures

// created from FBO have their origins in the lower-left... Mindfuck!

  private static Bitmap flipBitmap(Bitmap src)

    {

    Matrix matrix = new Matrix();

    matrix.preScale(1.0f,-1.0f);

    return Bitmap.createBitmap(src,0,0,src.getWidth(),src.getHeight(), matrix,true);

    }

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

// must be called from a thread holding OpenGL Context

  void createTexture()

    {

    if( mBmp!=null && mTextureDataH!=null )

      {

      //android.util.Log.e("Texture", "creating "+mID);

      if( mTextureDataH[0]==0 )

        {

        GLES20.glGenTextures(1, mTextureDataH, 0);

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataH[0]);

        GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR );

        GLES20.glTexParameteri ( 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_CLAMP_TO_EDGE );

        GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE );

        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, flipBitmap(mBmp), 0);

        }

      else

        {

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataH[0]);

        GLUtils.texSubImage2D(GLES20.GL_TEXTURE_2D, 0,0,0,flipBitmap(mBmp));

        }

      mBmp = null;

      }

    }

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

// must be called from a thread holding OpenGL Context

  private void deleteTexture()

    {

    if( mTextureDataH!=null && mTextureDataH[0]>0 )

      {

      //android.util.Log.e("Texture", "deleting "+mID);

      GLES20.glDeleteTextures(1, mTextureDataH, 0);

      mTextureDataH[0] = 0;

      mBitmapSet= false;

      }

    mMarked = false;

    }

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

  long getID()

    {

    return mID;

    }

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

  boolean setAsInput()

    {

    if( mBitmapSet )

      {

      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataH[0]);

      return true;

      }

    return false;

    }

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

  static void getUniforms(int mProgramH)

    {

    mTextureH= GLES20.glGetUniformLocation( mProgramH, "u_Texture");

    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

    GLES20.glUniform1i(mTextureH, 0);

    }

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

  static synchronized void onDestroy()

    {

    mListMarked = false;

    mList.clear();

    }

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

// must be called form a thread holding OpenGL Context

  static synchronized void deleteAllMarked()

    {

    if( mListMarked )

      {

      DistortedTexture tmp;

      Iterator<DistortedTexture> iterator = mList.iterator();

      while(iterator.hasNext())

        {

        tmp = iterator.next();

        if( tmp.mMarked )

          {

          tmp.deleteTexture();

          iterator.remove();

          }

        }

      mListMarked = false;

      }

    }

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

// PUBLIC API

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

/**

 * Create empty texture of given dimensions.

 */

  public DistortedTexture(int width, int height)

    {

    mSizeX= width ; mHalfX = mSizeX/2.0f;

    mSizeY= height; mHalfY = mSizeY/2.0f;

    mTextureDataH   = new int[1];

    mTextureDataH[0]= 0;

    mBmp            = null;

    mBitmapSet      = false;

    mID             = 0;

    mMarked         = false;

    mList.add(this);

    }

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

/**

 * Mark the underlying OpenGL object for deletion. Actual deletion will take place on the next render.

 */

  public void markForDeletion()

    {

    //android.util.Log.e("Texture", "marking for deletion "+mID);

    mListMarked = true;

    mMarked     = true;

    }

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

/**

 * Sets the underlying android.graphics.Bitmap object.

 * <p>

 * You can only recycle() the passed Bitmap once the OpenGL context gets created (i.e. after call

 * to GLSurfaceView.onSurfaceCreated) because only after this point can the Library upload it to the GPU!

 *

 * @param bmp The android.graphics.Bitmap object to apply effects to and display.

 */

  public void setTexture(Bitmap bmp)

    {

    mBitmapSet = true;

    mBmp       = bmp;

    mID        = bmp.hashCode();

    //android.util.Log.e("Texture", "setting new bitmap "+mID);

    }

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

/**

 * Returns the height of the Texture.

 *

 * @return height of the object, in pixels.

 */

  public int getWidth()

    {

    return mSizeX;

    }

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

/**

 * Returns the width of the Texture.

 *

 * @return width of the Object, in pixels.

 */

  public int getHeight()

    {

    return mSizeY;

    }

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

/**

 * Returns the depth of the Texture.

 * <p>

 * Admittedly quite a strange method. Why do we need to pass a Mesh to it? Because one cannot determine

 * 'depth' of a texture when rendered based only on the texture itself, that depends on the Mesh it is

 * rendered with.

 *

 * @return depth of the Object, in pixels.

 */

  public int getDepth(MeshObject mesh)

    {

    return mesh==null ? 0 : (int)(mSizeX*mesh.zFactor);

    }

  }