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 java.util.LinkedList;

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

/**

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

 * Objects 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).

*/

abstract class DistortedSurface

  {

  static final int FAILED_TO_CREATE = 1;

  static final int NOT_CREATED_YET  = 2;

  static final int DONT_CREATE      = 3;

  static final int CREATED          = 4;

  private static boolean mToDo = false;

  private static LinkedList<DistortedSurface> mDoneList = new LinkedList<>();

  private static LinkedList<DistortedSurface> mToDoList = new LinkedList<>();

  private static long mNextClientID = 0;

  private static long mNextSystemID = 0;

  private long mID;

  private boolean mMarked;

  private boolean mSystem;

  int mColorCreated;

  int[] mColorH = new int[1];

  int mSizeX, mSizeY;  // in screen space

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

  abstract void create();

  abstract void delete();

  abstract void recreate();

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

// must be called form a thread holding OpenGL Context

  static synchronized void toDo()

    {

    if( mToDo )

      {

      DistortedSurface surface;

      int num = mToDoList.size();

      for(int i=0; i<num; i++)

        {

        surface = mToDoList.removeFirst();

        if(surface.mMarked)

          {

          surface.delete();

          surface.mMarked = false;

          }

        else

          {

          surface.create();

          mDoneList.add(surface);

          }

        }

      mToDo = false;

      }

    }

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

  static synchronized void onDestroy()

    {

    DistortedSurface surface;

    int num = mDoneList.size();

    for(int i=0; i<num; i++)

      {

      surface = mDoneList.removeFirst();

      if( surface.mSystem )

        {

        mToDoList.add(surface);

        surface.recreate();

        }

      }

    num = mToDoList.size();

    for(int i=0; i<num; i++)

      {

      surface = mToDoList.get(i);

      if( !surface.mSystem )

        {

        mDoneList.remove(i);

        i--;

        num--;

        }

      }

    mToDo = (num>0);

    mNextClientID = 0;

    }

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

  synchronized void moveToToDo()

    {

    if ( mDoneList.remove(this) )

      {

      mToDoList.add(this);

      mToDo = true;

      }

    }

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

  @SuppressWarnings("unused")

  static void debugLists()

    {

    android.util.Log.e("Surface", "Done list:");

    debugList(mDoneList);

    android.util.Log.e("Surface", "ToDo list:");

    debugList(mToDoList);

    }

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

  private static void debugList(LinkedList<DistortedSurface> list)

    {

    DistortedSurface surface;

    String str;

    int num = list.size();

    for(int i=0; i<num; i++)

      {

      surface = list.get(i);

      if( surface instanceof DistortedFramebuffer ) str = (i+": Framebuffer ");

      else if( surface instanceof DistortedTexture) str = (i+": Texture     ");

      else if( surface instanceof DistortedScreen ) str = (i+": Screen      ");

      else                                          str = (i+": UNKNOWN     ");

      str += ("("+surface.getWidth()+","+surface.getHeight()+") surfaceID:"+surface.getID());

      android.util.Log.e("Surface", str);

      }

    }

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

  DistortedSurface(int width, int height, int create, boolean system)

    {

    mSizeX        = width ;

    mSizeY        = height;

    mColorCreated = create;

    mColorH[0]    = 0;

    mMarked       = false;

    mID           = system ? --mNextSystemID : ++mNextClientID;

    mSystem       = system;

    if( create!=DONT_CREATE )

      {

      mToDoList.add(this);

      mToDo = true;

      }

    }

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

// PUBLIC API

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

/**

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

 */

  public void markForDeletion()

    {

    if( !mMarked )

      {

      mToDo   = true;

      mMarked = true;

      mDoneList.remove(this);

      mToDoList.add(this);

      }

    }

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

/**

 * Return unique ID of the Surface.

 */

  public long getID()

    {

    return mID;

    }

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

/**

 * Returns the height of the Surface.

 *

 * @return height of the object, in pixels.

 */

  public int getWidth()

    {

    return mSizeX;

    }

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

/**

 * Returns the width of the Surface.

 *

 * @return width of the Object, in pixels.

 */

  public int getHeight()

    {

    return mSizeY;

    }

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

/**

 * Returns the depth of the Surface.

 * <p>

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

 * 'depth' of a Surface (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);

    }

  }