Distorted Android

  private static int mCountIndexH;

    android.util.Log.e("Effects", "creating main program");

    mCountIndexH = GLES31.glGetUniformLocation( mainProgramH, "u_currentIndex");

    android.util.Log.e("Effects", "creating blit program");

    android.util.Log.e("Effects", "creating blit depth program");

    android.util.Log.e("Effects", "creating blit depth render program");

    android.util.Log.e("Effects", "creating normal program");

    GLES31.glUniform1i(mCountIndexH, surface.getNewCounter() );

    //android.util.Log.e("effects", "width="+surface.mWidth+" height="+surface.mHeight+

    //    " bufferSize: "+mBufferSize+" numRecords: "+((mBufferSize-surface.mWidth*surface.mHeight)/3) );

  void createSurface()

  void deleteSurface()

  void recreateSurface()

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

// 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.main;

import java.util.ArrayList;

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

/**

 * Return unique IDs of objects in a lazy way. When we create a new Object, return the lowest unused

 * integer. When an objects gets deleted, its ID then gets marked unused. We do not try to 'collapse'

 * unused holes.

 */

class DistortedObjectCounter

  {

  private ArrayList<Integer> mUsed;

  private int mFirstUnused;

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

  DistortedObjectCounter()

    {

    mUsed        = new ArrayList<>();

    mFirstUnused = 0;

    }

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

  int returnNext()

    {

    int size = mUsed.size();

    if( mFirstUnused<size )

      {

      int ret = mFirstUnused;

      mUsed.set(mFirstUnused,1);

      int found=-1;

      for(int i=mFirstUnused+1; i<size; i++ )

        {

        if( mUsed.get(i)==0 )

          {

          found = i;

          break;

          }

        }

      mFirstUnused = found<0 ? size : found;

      return ret;

      }

    mUsed.add(1);

    mFirstUnused++;

    return size;

    }

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

  void release(int objID)

    {

    int size = mUsed.size();

    if( objID<size && objID>=0 && mUsed.get(objID)==1 )

      {

      mUsed.set(objID,0);

      if( objID<mFirstUnused ) mFirstUnused = objID;

      }

    }

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

  void releaseAll()

    {

    mUsed.clear();

    mFirstUnused = 0;

    }

  }

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.IntBuffer;

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

  // section dealing with Shader Storage Buffer Object (for counting transparency)

  private static final int FRAME_DELAY = 3;

  private static int mBufferSize       =10;

  private static DistortedObjectCounter mSurfaceCounter = new DistortedObjectCounter();

  private static int[] mSSBO = new int[1];

  private static IntBuffer mIntBuffer;

  static

    {

    mSSBO[0]= -1;

    }

  private int mSurfaceID;

  private int mLastIndex;

  private int[] mLastValue = new int[FRAME_DELAY];

  private int mLastDiff = -1;

  private static final int RUNNING_AVERAGE = 10;

  private int[] mRunningAvg = new int[RUNNING_AVERAGE];

  private int mAvgIndex;

  private int mAvgSum;

  // end section

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

  abstract void createSurface();

  abstract void deleteSurface();

  abstract void recreateSurface();

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

// Must be called from a thread holding OpenGL Context

  void create()

    {

    if( mSSBO[0]<0 )

      {

      GLES31.glGenBuffers(1,mSSBO,0);

      // here bind the new SSBO and map it

      GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mSSBO[0]);

      GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, FRAME_DELAY *mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ);

      ByteBuffer buf = (ByteBuffer) GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, FRAME_DELAY *mBufferSize*4, GLES31.GL_MAP_READ_BIT );

      mIntBuffer = buf.order(ByteOrder.nativeOrder()).asIntBuffer();

      GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER,0, mSSBO[0]);

      }

    mSurfaceID = mSurfaceCounter.returnNext();

    if( mSurfaceID>=mBufferSize )

      {

      // increase size of the Buffer, copy over old values, remap.

      int[] tmp = new int[FRAME_DELAY *mBufferSize];

      for(int i = 0; i< FRAME_DELAY *mBufferSize; i++) tmp[i] = mIntBuffer.get(i);

      mBufferSize*= 2;

      GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER, 0, 0);

      GLES31.glUnmapBuffer(GLES31.GL_SHADER_STORAGE_BUFFER);

      GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER,0);

      GLES31.glBindBuffer(GLES31.GL_SHADER_STORAGE_BUFFER, mSSBO[0]);

      GLES31.glBufferData(GLES31.GL_SHADER_STORAGE_BUFFER, FRAME_DELAY *mBufferSize*4 , null, GLES31.GL_DYNAMIC_READ);

      ByteBuffer buf = (ByteBuffer) GLES31.glMapBufferRange(GLES31.GL_SHADER_STORAGE_BUFFER, 0, FRAME_DELAY *mBufferSize*4, GLES31.GL_MAP_READ_BIT );

      mIntBuffer = buf.order(ByteOrder.nativeOrder()).asIntBuffer();

      GLES31.glBindBufferBase(GLES31.GL_SHADER_STORAGE_BUFFER,0, mSSBO[0]);

      for(int i=0;i<tmp.length;i++) mIntBuffer.put(i,tmp[i]);

      }

    createSurface();

    }

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

// Must be called from a thread holding OpenGL Context

  void delete()

    {

    mSurfaceCounter.release(mSurfaceID);

    deleteSurface();

    }

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

  void recreate()

    {

    mSSBO[0]  = -1;

    mLastDiff = -1;

    for(int i = 0; i< FRAME_DELAY; i++) mLastValue[i] = 0;

    mSurfaceCounter.releaseAll();

    recreateSurface();

    }

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

  int getNewCounter()

    {

    return FRAME_DELAY*mSurfaceID + mLastIndex;

    }

          surface.recreateSurface();

          surface.createSurface();

/*

      if( mSSBO[0]>=0 )

        {

        // yes, this DOES keep on working when 'value' overflows into negative territory.

        int value = mIntBuffer.get(FRAME_DELAY*mSurfaceID+mLastIndex);

        if( value-mLastValue[mLastIndex]!=mLastDiff )

          {

          android.util.Log.d("surface", "id " + mSurfaceID +

                             (mType == TYPE_USER ? " USER" : (mType == TYPE_SYST ? " SYST" : " TREE")) +

                             " viewport: (" + mWidth + "x" + mHeight + ") last frame: " + (value - mLastValue[mLastIndex])

                             + " avg: " + (mAvgSum/RUNNING_AVERAGE)

                            );

          }

        mLastDiff = value-mLastValue[mLastIndex];

        mLastValue[mLastIndex] = value;

        mAvgSum += (mLastDiff-mRunningAvg[mAvgIndex]);

        mRunningAvg[mAvgIndex] = mLastDiff;

        if( ++mAvgIndex>=RUNNING_AVERAGE ) mAvgIndex =0;

        }

      if( ++mLastIndex >= FRAME_DELAY ) mLastIndex=0;

*/

  void createSurface()   {}

  void deleteSurface()   {}

  void recreateSurface() {}

precision lowp float;

layout (std430,binding=0) buffer SSBO   // PER-SURFACE count of transparent fragments.

  {                                     // Can be buffered, i.e. if we are for example

  int ssbocount[];                      // triple-buffered, then surfaceID=N uses 3

  };                                    // consecutive counts (N,N+1,N+2) during 3

                                        // consecutive frames.

                                        // Cannot be an 'uint' because the Java application that's

                                        // reading this does not have unsigned types so it's reading

                                        // this into a signed int... Doesn't matter as things keep on

                                        // working even when this overflows into negative territory :)

uniform int u_currentIndex;             // Index into the count[] array we are supposed to be using

                                        // during this very invocation.

  if( color.a < 1.0 && color.a > 0.0 ) atomicAdd(ssbocount[u_currentIndex],1);

precision lowp float;