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

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

public class DistortedTexture

  {

  private static long mNextID =0;

  private static HashMap<Long,DistortedTexture> mTextures = new HashMap<>();

  private int mSizeX, mSizeY, mSizeZ;   // in screen space

  float mHalfX, mHalfY, mHalfZ;         // halves of the above

  private long mID;

  private Bitmap[] mBmp= null; //

  int[] mTextureDataH;         // have to be shared among all the cloned Objects

  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, (DistortedObjectTree 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);

    }

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

// this will be called on startup and every time OpenGL context has been lost

// also call this from the constructor if the OpenGL context has been created already.

  private void resetTexture()

    {

    if( mTextureDataH!=null )

      {

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

      if( mBmp!=null && mBmp[0]!=null)

        {

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

        mBmp[0] = null;

        }

      }

    }

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

  private void releasePriv()

    {

    mBmp          = null;

    mTextureDataH = null;

    }

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

  long getBitmapID()

    {

    return mBmp==null ? 0 : mBmp.hashCode();

    }

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

  static synchronized void reset()

    {

    for(long id: mTextures.keySet())

      {

      mTextures.get(id).resetTexture();

      }

    }

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

  static synchronized void release()

    {

    for(long id: mTextures.keySet())

      {

      mTextures.get(id).releasePriv();

      }

    mTextures.clear();

    mNextID = 0;

    }

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

// PUBLIC API

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

/**

 * Create empty texture of given dimensions.

 */

  public DistortedTexture(int width, int height, int depth)

    {

    mSizeX= width ; mHalfX = mSizeX/2.0f;

    mSizeY= height; mHalfY = mSizeY/2.0f;

    mSizeZ= depth ; mHalfZ = mSizeZ/2.0f;

    mID = mNextID++;

    mTextures.put(mID,this);

    mTextureDataH   = new int[1];

    mTextureDataH[0]= 0;

    mBmp            = new Bitmap[1];

    mBmp[0]         = null;

    mBitmapSet      = new boolean[1];

    mBitmapSet[0]   = false;

    if( Distorted.isInitialized() ) resetTexture();

    }

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

/**

 * Copy constructor.

 * <p>

 * Whatever we do not clone gets created just like in the default constructor.

 *

 * @param dt    Source object to create our object from

 * @param flags A bitmask of values specifying what to copy.

 *              For example, CLONE_BITMAP.

 */

  public DistortedTexture(DistortedTexture dt, int flags)

    {

    mID = mNextID++;

    mTextures.put(mID,this);

    mSizeX = dt.mSizeX;

    mSizeY = dt.mSizeY;

    mSizeZ = dt.mSizeZ;

    mHalfX = dt.mHalfX;

    mHalfY = dt.mHalfY;

    mHalfZ = dt.mHalfZ;

    if( (flags & Distorted.CLONE_BITMAP) != 0 )

      {

      mTextureDataH = dt.mTextureDataH;

      mBmp          = dt.mBmp;

      mBitmapSet    = dt.mBitmapSet;

      }

    else

      {

      mTextureDataH   = new int[1];

      mTextureDataH[0]= 0;

      mBitmapSet      = new boolean[1];

      mBitmapSet[0]   = false;

      mBmp            = new Bitmap[1];

      mBmp[0]         = null;

      if( Distorted.isInitialized() ) resetTexture();

      }

    }

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

/**

 * Releases all resources.

 */

  public synchronized void delete()

    {

    releasePriv();

    mTextures.remove(this);

    }

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

/**

 * Sets the underlying android.graphics.Bitmap object and uploads it to the GPU.

 * <p>

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

 * to 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[0] = true;

    if( Distorted.isInitialized() )

      {

      GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

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

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

      }

    else

      {

      mBmp[0] = bmp;

      }

    }

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

/**

 * Returns the height of the DistortedObject.

 *

 * @return height of the object, in pixels.

 */

  public int getWidth()

     {

     return mSizeX;

     }

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

/**

 * Returns the width of the DistortedObject.

 *

 * @return width of the Object, in pixels.

 */

  public int getHeight()

      {

      return mSizeY;

      }

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

/**

 * Returns the depth of the DistortedObject.

 *

 * @return depth of the Object, in pixels.

 */

  public int getDepth()

      {

      return mSizeZ;

      }

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

/**

 * Returns unique ID of this instance.

 *

 * @return ID of the object.

 */

  public long getID()

      {

      return mID;

      }

  }