/ - Diff - Distorted Android

         mF.compute(currTime);
         float halfZ = halfW*mesh.zFactor;
         GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight);
         float mipmap = 1.0f;//surface.mMipmap;
         GLES30.glViewport(0, 0, (int)(mipmap*surface.mWidth), (int)(mipmap*surface.mHeight) );
         //GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight);
         mMainProgram.useProgram();
         GLES30.glUniform1i(mMainTextureH, 0);
         surface.setAsOutput(currTime);
         mM.send(surface,halfW,halfH,halfZ);
         mM.send(surface,halfW,halfH,halfZ);
         mV.send(halfW,halfH,halfZ);
         mF.send(halfW,halfH);
         GLES30.glVertexAttribPointer(mMainProgram.mAttribute[0], POSITION_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mesh.mMeshPositions);
-...
+        {
         mBlitProgram.useProgram();
         GLES30.glViewport(0, 0, projection.mWidth, projection.mHeight);
         float mipmap = 1.0f;//projection.mMipmap;
         GLES30.glViewport(0, 0, (int)(mipmap*projection.mWidth), (int)(mipmap*projection.mHeight) );
         GLES30.glUniform1i(mBlitTextureH, 0);
         GLES30.glUniform1f( mBlitDepthH , 1.0f-projection.mNear);
         GLES30.glVertexAttribPointer(mBlitProgram.mAttribute[0], 2, GLES30.GL_FLOAT, false, 0, mQuadPositions);

+        {
         return mColorH[0];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Set mipmap level.
      * <p>
      * Trick for speeding up your renders - one can create a pyramid of DistortedFramebuffer objects,
      * each next one some constant FACTOR smaller than the previous (0.5 is the common value), then set
      * the Mipmap Level of the i-th object to be FACTOR^i (we start counting from 0). When rendering any
      * scene into such prepared Framebuffer, the library will make sure to scale any Effects used so that
      * the end scene will end up looking identical no matter which object we render to. Identical, that
      * is, except for the loss of quality and gain in speed associated with rendering to a smaller surface.
+     *
      * @param mipmap The mipmap level. Acceptable range: 0&lt;mipmap&lt;infinity, although mipmap&gt;1
      *               does not make any sense (that would result in loss of speed and no gain in quality)
      */
       public void setMipmap(float mipmap)
+        {
         mMipmap = mipmap;
+        }
+      }

     abstract class DistortedOutputSurface extends DistortedSurface implements DistortedSlave
+    {
       private static final int NUM_MIPMAP = 4;
               static final int CUR_MIPMAP = 0;
               static final int CUR_MIPMAP = 1;
       private static final int ATTACH = 0;
       private static final int DETACH = 1;
-...
         mBuffer1 = new DistortedFramebuffer[NUM_MIPMAP];
         mBuffer2 = new DistortedFramebuffer[NUM_MIPMAP];
         mMipmap = 1.0f;
         mMipmap = (this instanceof DistortedScreen ? 0.5f : 1.0f);
         createProjection();
+        }
-...
+        {
         if( mWidth>0 && mHeight>1 )
+          {
           float mw = mWidth;//mMipmap*mWidth;
           float mh = mHeight;//mMipmap*mHeight;
           if( mFOV>0.0f )  // perspective projection
+            {
             float a = 2.0f*(float)Math.tan(mFOV*Math.PI/360);
             float q = mWidth*mNear;
             float c = mHeight*mNear;
             float q = mw*mNear;
             float c = mh*mNear;
             float left   = -q/2;
             float right  = +q/2;
-...
             float top    = +c/2;
             float near   =  c/a;
             mDistance    = mHeight/a;
             mDistance    = mh/a;
             float far    = 2*mDistance-near;
             Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
+            }
           else             // parallel projection
+            {
             float left   = -mWidth /2.0f;
             float right  = +mWidth /2.0f;
             float bottom = -mHeight/2.0f;
             float top    = +mHeight/2.0f;
             float near   = mWidth+mHeight-mHeight*(1.0f-mNear);
             mDistance    = mWidth+mHeight;
             float far    = mWidth+mHeight+mHeight*(1.0f-mNear);
             float left   = -mw/2.0f;
             float right  = +mw/2.0f;
             float bottom = -mh/2.0f;
             float top    = +mh/2.0f;
             float near   = mw+mh-mh*(1.0f-mNear);
             mDistance    = mw+mh;
             float far    = mw+mh+mh*(1.0f-mNear);
             Matrix.orthoM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
+            }
-...
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Set mipmap level.
      * <p>
      * Trick for speeding up your renders - one can create a pyramid of OutputSurface objects, each next
      * one some constant FACTOR smaller than the previous (0.5 is the common value), then set the Mipmap
      * Level of the i-th object to be FACTOR^i (we start counting from 0). When rendering any scene into
      * such prepared OutputSurface, the library will make sure to scale any Effects used so that the end
      * scene will end up looking identical no matter which object we render to. Identical, that is, except
      * for the loss of quality and gain in speed associated with rendering to a smaller Surface.
+     *
      * @param mipmap The mipmap level. Acceptable range: 0&lt;mipmap&lt;infinity, although mipmap&gt;1
      *               does not make any sense (that would result in loss of speed and no gain in quality)
      */
       public void setMipmap(float mipmap)
+        {
         mMipmap = mipmap;
         createProjection();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Set the (R,G,B,A) values of GLES30.glClearColor() to set up color with which to clear

         float x,y,z, sx,sy,sz;
         float mipmap = projection.mMipmap;
         if( mipmap!=1 ) Matrix.scaleM(mViewMatrix, 0, mipmap, mipmap, mipmap);
         for(int i=0; i<mNumEffects; i++)
+          {
           if (mName[i] == EffectNames.ROTATE.ordinal() )
+            {
             x = mUniforms[NUM_UNIFORMS*i+4]*mipmap;
             y = mUniforms[NUM_UNIFORMS*i+5]*mipmap;
             z = mUniforms[NUM_UNIFORMS*i+6]*mipmap;
             x = mUniforms[NUM_UNIFORMS*i+4];
             y = mUniforms[NUM_UNIFORMS*i+5];
             z = mUniforms[NUM_UNIFORMS*i+6];
             Matrix.translateM(mViewMatrix, 0, x,-y, z);
             Matrix.rotateM( mViewMatrix, 0, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
-...
+            }
           else if(mName[i] == EffectNames.QUATERNION.ordinal() )
+            {
             x = mUniforms[NUM_UNIFORMS*i+4]*mipmap;
             y = mUniforms[NUM_UNIFORMS*i+5]*mipmap;
             z = mUniforms[NUM_UNIFORMS*i+6]*mipmap;
             x = mUniforms[NUM_UNIFORMS*i+4];
             y = mUniforms[NUM_UNIFORMS*i+5];
             z = mUniforms[NUM_UNIFORMS*i+6];
             Matrix.translateM(mViewMatrix, 0, x,-y, z);
             multiplyByQuat(mViewMatrix, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
-...
+            }
           else if(mName[i] == EffectNames.MOVE.ordinal() )
+            {
             sx = mUniforms[NUM_UNIFORMS*i  ]*mipmap;
             sy = mUniforms[NUM_UNIFORMS*i+1]*mipmap;
             sz = mUniforms[NUM_UNIFORMS*i+2]*mipmap;
             sx = mUniforms[NUM_UNIFORMS*i  ];
             sy = mUniforms[NUM_UNIFORMS*i+1];
             sz = mUniforms[NUM_UNIFORMS*i+2];
             Matrix.translateM(mViewMatrix, 0, sx,-sy, sz);
+            }
           else if(mName[i] == EffectNames.SCALE.ordinal() )
+            {
             sx = mUniforms[NUM_UNIFORMS*i  ]*mipmap;
             sy = mUniforms[NUM_UNIFORMS*i+1]*mipmap;
             sz = mUniforms[NUM_UNIFORMS*i+2]*mipmap;
             sx = mUniforms[NUM_UNIFORMS*i  ];
             sy = mUniforms[NUM_UNIFORMS*i+1];
             sz = mUniforms[NUM_UNIFORMS*i+2];
             Matrix.scaleM(mViewMatrix, 0, sx, sy, sz);
+            }
-...
             sy = mUniforms[NUM_UNIFORMS*i+1];
             sz = mUniforms[NUM_UNIFORMS*i+2];
             x  = mUniforms[NUM_UNIFORMS*i+4]*mipmap;
             y  = mUniforms[NUM_UNIFORMS*i+5]*mipmap;
             z  = mUniforms[NUM_UNIFORMS*i+6]*mipmap;
             x  = mUniforms[NUM_UNIFORMS*i+4];
             y  = mUniforms[NUM_UNIFORMS*i+5];
             z  = mUniforms[NUM_UNIFORMS*i+6];
             Matrix.translateM(mViewMatrix, 0, x,-y, z);

Project

General

Profile

Distorted Android

Revision 638b5b5c

Added by Leszek Koltunski over 8 years ago