/ - Diff - Distorted Android

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void drawPriv(float halfInputW, float halfInputH, MeshObject grid, DistortedFramebuffer df, long currTime)
       void drawPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedFramebuffer df, long currTime)
+        {
         GLES20.glViewport(0, 0, df.mWidth, df.mHeight);
         float halfZ = halfInputW*grid.zFactor;
         float halfZ = halfInputW*mesh.zFactor;
         mM.compute(currTime);
         mM.send(df,halfInputW,halfInputH,halfZ);
-...
         mF.compute(currTime);
         mF.send(halfInputW,halfInputH);
         grid.draw();
         mesh.draw();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void drawNoEffectsPriv(float halfInputW, float halfInputH, MeshObject grid, DistortedFramebuffer df)
       void drawNoEffectsPriv(float halfInputW, float halfInputH, MeshObject mesh, DistortedFramebuffer df)
+        {
         GLES20.glViewport(0, 0, df.mWidth, df.mHeight);
         mM.sendZero(df,halfInputW,halfInputH,halfInputW*grid.zFactor);
         mM.sendZero(df,halfInputW,halfInputH,halfInputW*mesh.zFactor);
         mV.sendZero();
         mF.sendZero();
         grid.draw();
         mesh.draw();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Draw the (texture,grid,effects) object to the Framebuffer.
      * Draw the (texture,mesh,effects) object to the Framebuffer.
      * <p>
      * Must be called from a thread holding OpenGL Context.
+     *
      * @param tex input Texture to use.
      * @param grid Class descendant from MeshObject
      * @param mesh Class descendant from MeshObject
      * @param effects The DistortedEffects to use when rendering
      * @param time Current time, in milliseconds.
      */
       public void renderTo(DistortedTexture tex, MeshObject grid, DistortedEffects effects, long time)
       public void renderTo(DistortedTexture tex, MeshObject mesh, DistortedEffects effects, long time)
+        {
         tex.createTexture();
         tex.setAsInput();
         createFBO();
         GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fboIds[0]);
         effects.drawPriv(tex.mHalfX, tex.mHalfY, grid, this, time);
         effects.drawPriv(tex.mHalfX, tex.mHalfY, mesh, this, time);
         DistortedFramebuffer.deleteAllMarked();
         DistortedTexture.deleteAllMarked();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Draw the (framebuffer,grid,effects) object to the Framebuffer.
      * Draw the (framebuffer,mesh,effects) object to the Framebuffer.
      * <p>
      * Must be called from a thread holding OpenGL Context.
+     *
      * @param fbo The Framebuffer (previously created with the first constructor, drawing FROM the screen
      *            is unsupported!) whose COLOR attachment 0 will be used as input texture.
      *            Please note that rendering from an FBO to itself is unsupported by OpenGL!
      * @param grid Class descendant from MeshObject
      * @param mesh Class descendant from MeshObject
      * @param effects The DistortedEffects to use when rendering
      * @param time Current time, in milliseconds.
      */
       public void renderTo(DistortedFramebuffer fbo, MeshObject grid, DistortedEffects effects, long time)
       public void renderTo(DistortedFramebuffer fbo, MeshObject mesh, DistortedEffects effects, long time)
+        {
         fbo.createFBO();
-...
           createFBO();
           GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fboIds[0]);
           GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, fbo.texIds[0]);
           effects.drawPriv(fbo.mWidth/2, fbo.mHeight/2, grid, this, time);
           effects.drawPriv(fbo.mWidth/2, fbo.mHeight/2, mesh, this, time);
           DistortedFramebuffer.deleteAllMarked();
           DistortedTexture.deleteAllMarked();
+          }

+          {
           //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_MIN_FILTER, GLES20.GL_LINEAR );
           GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR );
           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( 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_MIN_FILTER, GLES20.GL_LINEAR );
             GLES20.glTexParameteri ( GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR );
             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 );
             GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, flipBitmap(mBmp), 0);
+            }
           else
+            {
             GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataH[0]);
             GLUtils.texSubImage2D(GLES20.GL_TEXTURE_2D, 0,0,0,flipBitmap(mBmp));
+            }
           GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, flipBitmap(mBmp), 0);
           mBmp = null;
+          }
+        }
-...
     /**
      * Returns the depth of the Texture.
      * <p>
      * Admittedly quite a strange method. Why do we need to pass a Grid to it? Because one cannot determine
      * 'depth' of a texture when rendered based only on the texture itself, that depends on the Grid it is
      * Admittedly quite a strange method. Why do we need to pass a Mesh to it? Because one cannot determine
      * 'depth' of a texture 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 grid)
       public int getDepth(MeshObject mesh)
+        {
         return grid==null ? 0 : (int)(mSizeX*grid.zFactor);
         return mesh==null ? 0 : (int)(mSizeX*mesh.zFactor);
+        }
+      }

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Class which represents a Node in a Tree of (Texture,Grid,Effects) objects.
      * Class which represents a Node in a Tree of (Texture,Mesh,Effects) objects.
+     *
      * Having organized such sets into a Tree, we can then render any Node to any Framebuffer.
      * That recursively renders the set held in the Node and all its children.
-...
       private static HashMap<ArrayList<Long>,NodeData> mMapNodeID = new HashMap<>();
       private static long mNextNodeID =0;
       private MeshObject mGrid;
       private MeshObject mMesh;
       private DistortedEffects mEffects;
       private DistortedTexture mTexture;
       private NodeData mData;
-...
             GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
             if( mTexture.setAsInput() )
               mEffects.drawNoEffectsPriv(mTexture.mHalfX, mTexture.mHalfY, mGrid, mData.mDF);
               mEffects.drawNoEffectsPriv(mTexture.mHalfX, mTexture.mHalfY, mMesh, mData.mDF);
             synchronized(this)
+              {
-...
           mData.mDF.setAsInput();
+          }
         mEffects.drawPriv(mTexture.mHalfX, mTexture.mHalfY, mGrid, df, currTime);
         mEffects.drawPriv(mTexture.mHalfX, mTexture.mHalfY, mMesh, df, currTime);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+     *
      * @param texture DistortedTexture to put into the new Node.
      * @param effects DistortedEffects to put into the new Node.
      * @param grid MeshObject to put into the new Node.
      * @param mesh MeshObject to put into the new Node.
      */
       public DistortedTree(DistortedTexture texture, DistortedEffects effects, MeshObject grid)
       public DistortedTree(DistortedTexture texture, DistortedEffects effects, MeshObject mesh)
+        {
         mTexture= texture;
         mEffects= effects;
         mGrid   = grid;
         mMesh   = mesh;
         mParent = null;
         mChildren = null;
         mNumChildren = new int[1];
-...
+        {
         mParent = null;
         mEffects= new DistortedEffects(node.mEffects,flags);
         mGrid   = node.mGrid;
         mMesh = node.mMesh;
         if( (flags & Distorted.CLONE_BITMAP) != 0 )
+          {
-...
+     *
      * @param texture DistortedTexture to initialize our child Node with.
      * @param effects DistortedEffects to initialize our child Node with.
      * @param grid MeshObject to initialize our child Node with.
      * @param mesh MeshObject to initialize our child Node with.
      * @return the newly constructed child Node, or null if we couldn't allocate resources.
      */
       public synchronized DistortedTree attach(DistortedTexture texture, DistortedEffects effects, MeshObject grid)
       public synchronized DistortedTree attach(DistortedTexture texture, DistortedEffects effects, MeshObject mesh)
+        {
         ArrayList<Long> prev = generateIDList();
         if( mChildren==null ) mChildren = new ArrayList<>(2);
         DistortedTree node = new DistortedTree(texture,effects,grid);
         DistortedTree node = new DistortedTree(texture,effects,mesh);
         node.mParent = this;
         mChildren.add(node);
         mNumChildren[0]++;

          if( remainingVert!=0 )
            android.util.Log.d("CUBES", "remainingVert " +remainingVert );
          mGridPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
          mGridPositions.put(positionData).position(0);
          mMeshPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
          mMeshPositions.put(positionData).position(0);
          mGridNormals = ByteBuffer.allocateDirect(NORMAL_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
          mGridNormals.put(normalData).position(0);
          mMeshNormals = ByteBuffer.allocateDirect(NORMAL_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
          mMeshNormals.put(normalData).position(0);
          mGridTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
          mGridTexture.put(textureData).position(0);
          mMeshTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
          mMeshTexture.put(textureData).position(0);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates the underlying grid of vertices, normals, texture coords.
      * Creates the underlying mesh of vertices, normals, texture coords.
+     *
      * @param cols      Integer helping to parse the next parameter.
      * @param desc      String describing the subset of a MxNx1 cuboid that we want to create.
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates a full, hole-less underlying grid of vertices, normals, texture coords and colors.
      * Creates a full, hole-less underlying mesh of vertices, normals, texture coords and colors.
+     *
      * @param cols      Number of columns.
      * @param rows      Number of rows.

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Create a flat, rectangular Grid.
      * Create a flat, rectangular grid.
      * <p>
      * Perfect if you just want to display a flat Texture. If you are not planning to apply any VERTEX
      * effects to it, use MeshFlat(1,1), i.e. a Quad. Otherwise, create more vertices for more realistic effects!
-...
           if( remainingVert!=0 )
             android.util.Log.d("BITMAP", "remainingVert " +remainingVert );
           mGridPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
           mGridPositions.put(positionData).position(0);
           mMeshPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
           mMeshPositions.put(positionData).position(0);
           mGridNormals = ByteBuffer.allocateDirect(NORMAL_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
           mGridNormals.put(normalData).position(0);
           mMeshNormals = ByteBuffer.allocateDirect(NORMAL_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
           mMeshNormals.put(normalData).position(0);
           mGridTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
           mGridTexture.put(textureData).position(0);
           mMeshTexture = ByteBuffer.allocateDirect(TEX_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
           mMeshTexture.put(textureData).position(0);
+          }
+      }

        protected static final int TEX_DATA_SIZE     = 2; // Size of the texture coordinate data in elements.
        protected int dataLength;
        protected FloatBuffer mGridPositions,mGridNormals,mGridTexture;
        protected FloatBuffer mMeshPositions, mMeshNormals, mMeshTexture;
        final float zFactor; // strange workaround for the fact that we need to somehow store the 'depth'
                             // of the Mesh. Used in DistortedEffects. See DistortedTexture.getDepth().
-...
        void draw()
+         {
          GLES20.glVertexAttribPointer(Distorted.mMainProgramAttributes[0], POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mGridPositions);
          GLES20.glVertexAttribPointer(Distorted.mMainProgramAttributes[1], NORMAL_DATA_SIZE  , GLES20.GL_FLOAT, false, 0, mGridNormals  );
          GLES20.glVertexAttribPointer(Distorted.mMainProgramAttributes[2], TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mGridTexture  );
          GLES20.glVertexAttribPointer(Distorted.mMainProgramAttributes[0], POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mMeshPositions);
          GLES20.glVertexAttribPointer(Distorted.mMainProgramAttributes[1], NORMAL_DATA_SIZE  , GLES20.GL_FLOAT, false, 0, mMeshNormals);
          GLES20.glVertexAttribPointer(Distorted.mMainProgramAttributes[2], TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mMeshTexture);
          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, dataLength);
+         }

Project

General

Profile

Distorted Android

Revision 05403bba

Added by Leszek Koltunski over 7 years ago