/ - Diff - Distorted Android

« Previous | Next »

Revision 1942537e

Added by Leszek Koltunski about 8 years ago

ID 1942537e5f56b3230ff0087596824d1ce79084eb
Parent 46e25345
Child 6537ba91

Major restructuring with DistortedTexture. One now is able to create Textures anywhere, even from a thread which does not hold the OpenGL context. Same for DistortedFramebuffers.

         GLES20.glEnableVertexAttribArray(mNormalH);
         GLES20.glEnableVertexAttribArray(mTextureCoordH);
         DistortedTexture.reset();
         DistortedObjectTree.reset();
         EffectMessageSender.startSending();
+        }
-...
         DistortedFramebuffer.release();
         DistortedObjectTree.release();
         EffectQueue.release();
         DistortedEffectQueues.release();
         EffectMessageSender.stopSending();
         mInitialized = false;

       void drawPriv(long currTime, DistortedTexture tex, GridObject grid, DistortedFramebuffer df)
+        {
         DistortedFramebuffer.deleteAllMarked();
         GLES20.glViewport(0, 0, df.mWidth, df.mHeight);
         float halfZ = tex.mHalfX*grid.zFactor;
-...
         mF = null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static void release()
+        {
         mNextID = 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public void draw(long currTime, DistortedTexture tex, GridObject grid)
+        {
         tex.createTexture();
         GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, tex.mTextureDataH[0]);
         drawPriv(currTime, tex, grid, Distorted.mFramebuffer);
         DistortedFramebuffer.deleteAllMarked();
         DistortedTexture.deleteAllMarked();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public void draw(long currTime, DistortedTexture tex, GridObject grid, DistortedFramebuffer df)
+        {
         tex.createTexture();
         df.setAsOutput();
         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, tex.mTextureDataH[0]);
         drawPriv(currTime, tex, grid, df);
         DistortedFramebuffer.deleteAllMarked();
         DistortedTexture.deleteAllMarked();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

       private static boolean mListMarked = false;
       private static LinkedList<DistortedFramebuffer> mList = new LinkedList<>();
       private float mX, mY;
       private float mFOV;
       private float mX, mY, mFOV;
       private int[] texIds = new int[1];
       private int[] fboIds = new int[1];
-...
       void reset()
+        {
         texIds[0] = TEXTURE_NOT_CREATED_YET;
         if( texIds[0]!=TEXTURE_DONT_CREATE)
           texIds[0] = TEXTURE_NOT_CREATED_YET;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * @param width Width of the COLOR attachment.
      * @param height Height of the COLOR attachment.
      */
       @SuppressWarnings("unused")
       public DistortedFramebuffer(int width, int height)
+        {
         mProjectionMatrix = new float[16];

       private void drawRecursive(long currTime, DistortedFramebuffer df)
+        {
         mTexture.createTexture();
         if( mNumChildren[0]<=0 )
+          {
           GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexture.mTextureDataH[0]);
-...
+        {
         ArrayList<Long> ret = new ArrayList<>();
         ret.add( mNumChildren[0]>0 ? mTexture.getBitmapID() : mTexture.getID() );
         ret.add( mTexture.getID() );
         DistortedObjectTree node;
         for(int i=0; i<mNumChildren[0]; i++)
-...
         if( otherNodesPoint ) mData.numPointingNodes--;
         else                  mMapNodeID.remove(oldList);
         NodeData newData = mMapNodeID.get(newList);
         if( newData==null )
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Debug - print all the Node IDs
     /*
       void debug(int depth)
+        {
         String tmp="";
         int i;
         for(i=0; i<depth; i++) tmp +="   ";
         tmp += (""+mData.ID);
         tmp += (mData.ID+" (nodes: "+mData.numPointingNodes+")");
         android.util.Log.e("node", tmp);
         android.util.Log.e("NODE", tmp);
         for(i=0; i<mNumChildren[0]; i++)
           mChildren.get(i).debug(depth+1);
-...
           android.util.Log.e("NODE", "key="+key+" NodeID: "+tmp.ID);
+          }
+        }
     */
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mNumChildren[0] = 0;
         ArrayList<Long> list = new ArrayList<>();
         list.add(queues.getID());   // TODO: this should depend on both texture and queues! Maybe even on grid as well
         list.add(mTexture.getID());
         mData = mMapNodeID.get(list);
         if( mData!=null )
-...
         else
+          {
           mData = new NodeData(++mNextNodeID);
           mMapNodeID.put(list, mData);
           mMapNodeID.put(list, mData);
+          }
+        }
-...
         GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
         markRecursive();
         drawRecursive(currTime,Distorted.mFramebuffer);
         DistortedFramebuffer.deleteAllMarked();
         DistortedTexture.deleteAllMarked();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         df.setAsOutput();
         markRecursive();
         drawRecursive(currTime,df);
         DistortedFramebuffer.deleteAllMarked();
         DistortedTexture.deleteAllMarked();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     import android.opengl.GLES20;
     import android.opengl.GLUtils;
     import java.util.Arrays;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.LinkedList;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class DistortedTexture
+      {
       private static long mNextID =0;
       private static HashMap<Long,DistortedTexture> mTextures = new HashMap<>();
       private static boolean mListMarked = false;
       private static LinkedList<DistortedTexture> mList = new LinkedList<>();
       private int mSizeX, mSizeY;  // in screen space
       float mHalfX, mHalfY;        // halves of the above
       private long mID;
       private long mBitmapID=0;
       private boolean mMarked;
       private Bitmap[] mBmp= null; //
       int[] mTextureDataH;         // have to be shared among all the cloned Objects
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // this will be called on startup and every time OpenGL context has been lost
     // also call this from the constructor if the OpenGL context has been created already.
     // must be called from a thread holding OpenGL Context
       private void resetTexture()
       void createTexture()
+        {
         if( mTextureDataH!=null )
         if( mBmp[0]!=null && mTextureDataH!=null )
+          {
           //android.util.Log.e("Texture", "creating "+mID);
           if( mTextureDataH[0]==0 ) GLES20.glGenTextures(1, mTextureDataH, 0);
           GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataH[0]);
-...
           GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE );
           GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE );
           if( mBmp!=null && mBmp[0]!=null)
+            {
             GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, flipBitmap(mBmp[0]), 0);
             mBmp[0] = null;
+            }
           GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, flipBitmap(mBmp[0]), 0);
           mBmp[0] = null;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // must be called from a thread holding OpenGL Context
       private void releasePriv()
       private void deleteTexture()
+        {
         mBmp          = null;
         mTextureDataH = null;
+        }
         if( mTextureDataH!=null && mTextureDataH[0]>0 )
+          {
           //android.util.Log.e("Texture", "deleting "+mID);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
           GLES20.glDeleteTextures(1, mTextureDataH, 0);
       long getBitmapID()
+        {
         if( mBmp!=null && mBitmapID==0 ) mBitmapID = Arrays.hashCode(mBmp);
         return mBitmapID;
           mTextureDataH[0] = 0;
           mBitmapSet[0] = false;
+          }
         mMarked = false;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       long getID()
+          {
           return mID;
+          }
+        {
         return mID;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static synchronized void reset()
       static synchronized void release()
+        {
         for(long id: mTextures.keySet())
+          {
           mTextures.get(id).resetTexture();
+          }
         mListMarked = false;
         mList.clear();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // must be called form a thread holding OpenGL Context
       static synchronized void release()
       static synchronized void deleteAllMarked()
+        {
         for(long id: mTextures.keySet())
         if( mListMarked )
+          {
           mTextures.get(id).releasePriv();
+          }
           DistortedTexture tmp;
           Iterator<DistortedTexture> iterator = mList.iterator();
           while(iterator.hasNext())
+            {
             tmp = iterator.next();
             if( tmp.mMarked )
+              {
               tmp.deleteTexture();
               iterator.remove();
+              }
+            }
         mTextures.clear();
         mNextID = 0;
           mListMarked = false;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public DistortedTexture(int width, int height)
+        {
         mID = mNextID++;
         mTextures.put(mID,this);
         mSizeX= width ; mHalfX = mSizeX/2.0f;
         mSizeY= height; mHalfY = mSizeY/2.0f;
-...
         mBmp[0]         = null;
         mBitmapSet      = new boolean[1];
         mBitmapSet[0]   = false;
         mID             = 0;
         mMarked         = false;
         if( Distorted.isInitialized() ) resetTexture();
         mList.add(this);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public DistortedTexture(DistortedTexture dt, int flags)
+        {
         mID = mNextID++;
         mTextures.put(mID,this);
         mSizeX= dt.mSizeX ; mHalfX = mSizeX/2.0f;
         mSizeY= dt.mSizeY ; mHalfY = mSizeY/2.0f;
-...
           mTextureDataH = dt.mTextureDataH;
           mBmp          = dt.mBmp;
           mBitmapSet    = dt.mBitmapSet;
           mID           = dt.getID();
+          }
         else
+          {
-...
           mBitmapSet[0]   = false;
           mBmp            = new Bitmap[1];
           mBmp[0]         = null;
           if( Distorted.isInitialized() ) resetTexture();
           mID             = 0;
+          }
         mMarked = false;
         mList.add(this);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Releases all resources.
      * Mark the underlying OpenGL object for deletion. Actual deletion will take place on the next render.
      */
       public synchronized void delete()
       public void markForDeletion()
+        {
         releasePriv();
         mTextures.remove(this);
         //android.util.Log.e("Texture", "marking for deletion "+mID);
         mListMarked = true;
         mMarked     = true;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the underlying android.graphics.Bitmap object and uploads it to the GPU.
      * Sets the underlying android.graphics.Bitmap object.
      * <p>
      * You can only recycle() the passed Bitmap once the OpenGL context gets created (i.e. after call
      * to onSurfaceCreated) because only after this point can the Library upload it to the GPU!
-...
       public void setTexture(Bitmap bmp)
+        {
         mBitmapSet[0] = true;
         mBmp[0]       = bmp;
         mID           = bmp.hashCode();
         if( Distorted.isInitialized() )
+          {
           GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
           GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataH[0]);
           GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, flipBitmap(bmp), 0);
+          }
         else
+          {
           mBmp[0] = bmp;
+          }
         //android.util.Log.e("Texture", "setting new bitmap "+mID);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * @return height of the object, in pixels.
      */
       public int getWidth()
+         {
          return mSizeX;
+         }
+        {
         return mSizeX;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
      * @return width of the Object, in pixels.
      */
       public int getHeight()
+          {
           return mSizeY;
+          }
+        {
         return mSizeY;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
-...
      * @return depth of the Object, in pixels.
      */
       public int getDepth(GridObject grid)
+          {
           return grid==null ? 0 : (int)(mSizeX*grid.zFactor);
+          }
+        {
         return grid==null ? 0 : (int)(mSizeX*grid.zFactor);
+        }
+      }

        protected int dataLength;
        protected FloatBuffer mGridPositions,mGridNormals,mGridTexture;
        final float zFactor; // strange workaround the fact that we need to somehow store the 'depth'
        final float zFactor; // strange workaround for the fact that we need to somehow store the 'depth'
                             // of the Grid. Used in DistortedEffectQueues. See DistortedTexture.getDepth().
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 1942537e

Added by Leszek Koltunski about 8 years ago