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.opengl.GLES30;

import java.util.LinkedList;

abstract class DistortedRenderable

  {

  static final int FAILED_TO_CREATE = -1;

  static final int NOT_CREATED_YET  = -2;

  static final int DONT_CREATE      = -3;

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

  private boolean mMarked;

  int mSizeX, mSizeY;  // in screen space

  abstract void create();

  abstract void delete();

// must be called form a thread holding OpenGL Context

  static synchronized void deleteAllMarked()

    {

    if( mListMarked )

      {

      DistortedRenderable tmp;

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

      while(iterator.hasNext())

        {

        tmp = iterator.next();

        if( tmp.mMarked )

          {

          tmp.delete();

          tmp.mMarked = false;

          iterator.remove();

          }

        }

      mListMarked = false;

      }

    }

  long getID()

    {

    return mColorH[0];

    }

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

  boolean setAsInput()

    {

    if( mColorH[0]>0 )

      {

      GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mColorH[0]);

      return true;

      }

    return false;

    }

  static synchronized void onDestroy()

    {

    for( DistortedRenderable ren : mList)

      {

      ren.delete();

      ren.mMarked = false;

      }

    mListMarked = false;

    mList.clear();

    }

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

  DistortedRenderable(int width, int height, int color)

    {

    mSizeX    = width ;

    mSizeY    = height;

    mColorH[0]= color;

    mMarked   = false;

    mList.add(this);

    }

// PUBLIC API

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

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

 */

  public void markForDeletion()

    {

    mListMarked = true;

    mMarked     = true;

    }

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

 * Returns the height of the Renderable.

 *

 * @return height of the object, in pixels.

 */

  public int getWidth()

    {

    return mSizeX;

    }

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

/**

 * Returns the width of the Renderable.

 *

 * @return width of the Object, in pixels.

 */

  public int getHeight()

    {

    return mSizeY;

    }

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

/**

 * Returns the depth of the Renderable.

 * <p>

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

 * 'depth' of a Renderable (bitmap really!) 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);

    }

  }