Distorted Android

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

// Copyright 2017 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.effect;

import org.distorted.library.effectqueue.EffectQueue;

import org.distorted.library.main.DistortedFramebuffer;

import org.distorted.library.main.InternalMaster;

import org.distorted.library.program.DistortedProgram;

import java.lang.reflect.Method;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.util.ArrayList;

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

/**

 * Abstract class that represents an Effect that works by running a certain Shader Program(s) on a Framebuffer.

 */

public abstract class PostprocessEffect extends Effect implements InternalMaster.Slave

  {

  private static final int MIPMAP = 0;

  /**

   * 5 per-effect interpolated values.

   */

  public static final int NUM_FLOAT_UNIFORMS = 6;

  /**

   * 1: the name of the effect

   */

  public static final int NUM_INT_UNIFORMS = 1;

  static final int POS_DATA_SIZE= 2;

  static final int TEX_DATA_SIZE= 2;

  static final FloatBuffer mQuadPositions, mQuadTexture, mQuadTextureInv;

  static

    {

    int dataLength      = 4;

    int bytes_per_float = 4;

    float[] position  = { -0.5f, -0.5f,  -0.5f, 0.5f,  0.5f,-0.5f,  0.5f, 0.5f };

    float[] textureNor= {  0.0f,  0.0f,   0.0f, 1.0f,  1.0f, 0.0f,  1.0f, 1.0f };

    float[] textureInv= {  0.0f,  0.0f,   1.0f, 0.0f,  0.0f, 1.0f,  1.0f, 1.0f };

    mQuadPositions = ByteBuffer.allocateDirect(POS_DATA_SIZE*dataLength*bytes_per_float).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mQuadPositions.put(position).position(0);

    mQuadTexture   = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*bytes_per_float).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mQuadTexture.put(textureNor).position(0);

    mQuadTextureInv= ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*bytes_per_float).order(ByteOrder.nativeOrder()).asFloatBuffer();

    mQuadTextureInv.put(textureInv).position(0);

    }

  private static class Source

    {

    private final String mName, mVertexShader, mFragmentShader;

    Source(String name, String vertex, String fragment)

      {

      mName           = name;

      mVertexShader   = vertex;

      mFragmentShader = fragment;

      }

    }

  static ArrayList<DistortedProgram> mPrograms = new ArrayList<>();

  private final static ArrayList<Source> mSources = new ArrayList<>();

  private static int mNumSources = 0;

  private static class Job

    {

    int type;

    int level;

    Job(int t, int l)

      {

      type = t;

      level= l;

      }

    }

  private final ArrayList<Job> mJobs = new ArrayList<>();

  private int mQualityLevel;

  private boolean mUseHaloDepth;

  float mQualityScale;

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

  static int register(final String name, final String vertexShader, final String fragmentShader)

    {

    mSources.add(new Source(name,vertexShader,fragmentShader));

    return mNumSources++;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static void createPrograms(int GLSL)

    {

    Source source;

    int len = mSources.size();

    String version = "#version "+GLSL+" es\n";

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

      {

      source = mSources.remove(0);

      try

        {

        mPrograms.add (new DistortedProgram(version+source.mVertexShader,version+source.mFragmentShader));

        }

      catch(Exception e)

        {

        android.util.Log.e("Effects", "exception trying to compile "+source.mName+" program: "+e.getMessage());

        throw new RuntimeException(e.getMessage());

        }

      }

    }

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

/**

 * At this moment the 'buffer' contains a) preprocessed object b) real object rendered 'on top' of

 * the preprocessed one.

 * Postprocess buffer. What this means exactly depends on the effect -

 *

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public abstract int postprocess(float[] uniforms, int index, DistortedFramebuffer buffer);

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

  /**

   * Do we render the object directly to the final surface, and only postprocess and then blit its

   * 'halo', or do we render the object along with its halo to the intermediate framebuffer and

   * postprocess it as well?

   *

   * Only for use by the library itself.

   *

   * @y.exclude

   */

  public abstract boolean getRenderDirectly();

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

  /**

   * Only for use by the library itself.

   *

   * @y.exclude

   */

  public int getQuality()

    {

    return mQualityLevel;

    }

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

  /**

   * Only for use by the library itself.

   *

   * @y.exclude

   */

  public boolean getHaloDepth()

    {

    return mUseHaloDepth;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public void addQueue(EffectQueue queue)

    {

    // NO OP

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public void remQueue(EffectQueue queue)

    {

    // NO OP

    }

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

/**

 * This is not really part of the public API. Has to be public only because it is a part of the

 * DistortedSlave interface, which should really be a class that we extend here instead but

 * Java has no multiple inheritance.

 *

 * @y.exclude

 */

  public void doWork()

    {

    int num = mJobs.size();

    Job job;

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

      {

      job = mJobs.remove(0);

      switch(job.type)

        {

        case MIPMAP: int level = job.level;

                     mQualityLevel = level;

                     mQualityScale = 1.0f;

                     for(int j=0; j<level; j++) mQualityScale*= EffectQuality.MULTIPLIER;

                     break;

        }

      }

    }

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

  static void destroyStatics()

    {

    mPrograms.clear();

    mSources.clear();

    mNumSources = 0;

    Method method;

    for(EffectName name: EffectName.values())

      {

      if( name.getType() == EffectType.POSTPROCESS )

        {

        Class<? extends Effect> cls = name.getEffectClass();

        try

          {

          method = cls.getDeclaredMethod("destroyStatics");  // destroyStatics not public, thus getDeclaredMethod

          }

        catch(NoSuchMethodException ex)

          {

          android.util.Log.e("postprocess", cls.getSimpleName()+": exception getting method: "+ex.getMessage());

          method = null;

          }

        try

          {

          if( method!=null ) method.invoke(null);

          }

        catch(Exception ex)

          {

          android.util.Log.e("postprocess", "exception invoking method: "+ex.getMessage());

          }

        }

      }

    }

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

  PostprocessEffect(EffectName name)

    {

    super(name);

    mQualityLevel = 0;

    mQualityScale = 1.0f;

    mUseHaloDepth = true;

    }

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

// PUBLIC API

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

/**

 * The higher the quality, the better the effect will look like and the slower it will be.

 * <p>

 * This works by rendering into smaller and smaller intermediate buffers. Each step renders into a

 * buffer that's half the size of the previous one.

 * <p>

 * We cannot this during mid-render - thus, give it to the Master to assign us back this job on the

 * next render.

 */

  public void setQuality(EffectQuality quality)

    {

    mJobs.add(new Job(MIPMAP,quality.getLevel()));

    InternalMaster.newSlave(this);

    }

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

/**

 * When preprocessing - so drawning the 'halo' - do we also want to write the depth buffer?

 * If yes, the halo would cover the whole object; if no, it would be just around it (and possibly

 * could be covered by other similarly postprocessed objects nearby)

 *

 * @param depth should the halo around the object cover it or not?

 */

  public void setHaloDepth(boolean depth)

    {

    mUseHaloDepth = depth;

    }

  }