Distorted Android

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

// Copyright 2017 Leszek Koltunski                                                               //

//                                                                                               //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// 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                             //

package org.distorted.library.effect;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

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

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

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

    }

    {

      mName           = name;

      mVertexShader   = vertex;

      mFragmentShader = fragment;

      }

    }

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

    int type;

    int level;

    Job(int t, int l)

      {

      type = t;

      level= l;

      }

    }

  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

 */

    Source source;

    int len = mSources.size();

      {

      source = mSources.remove(0);

      try

        {

      catch(Exception e)

        {

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

        throw new RuntimeException(e.getMessage());

        }

      }

    }

 * the preprocessed one.

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

 *

 *

 * @y.exclude

 */

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

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

   * postprocess it as well?

   *

   *

   * @y.exclude

   */

  /**

   * Only for use by the library itself.

   *

   * @y.exclude

   */

  /**

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

    for(EffectName name: EffectName.values())

      {

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

        {

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

        try

          {

        catch(NoSuchMethodException ex)

          {

          method = null;

        try

          {

        catch(Exception ex)

          {

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

          }

        }

      }

    }

    mQualityLevel = 0;

    mQualityScale = 1.0f;

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

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

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

/**

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

    }