/ - Diff - Distorted Android

           mEffects.apply(new MatrixEffectScale(mScale));
           mManager.apply(mEffects);
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
+          }

     package org.distorted.examples.aroundtheworld;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new AroundTheWorldRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

           mEffects.apply( new MatrixEffectMove(mMove) );
           mEffects.apply( new MatrixEffectScale(mScale) );
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.bean;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public BeanSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new BeanRenderer(this));
+          }
+    }

           mEffects.apply(new MatrixEffectScale(mScale));
           mEffects.apply(new FragmentEffectChroma(chromaDyn, new Static3D(0,0,1)));
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.bitmaptree;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new BitmapTreeRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

+          {
           mView   = v;
           mMesh   = new MeshFlat(1,1);
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mRadiusSta = new Static1D(5);
           Dynamic1D radiusDyn = new Dynamic1D();

     package org.distorted.examples.blur;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new BlurRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

           mEffects.apply( new MatrixEffectScale(diScale));
           mEffects.apply( new MatrixEffectRotate( diRotate, new Static3D(0,0,1), mRotate) );
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.catanddog;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public CatAndDogSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new CatAndDogRenderer(this));
+          }
+    }

src/main/java/org/distorted/examples/check/CheckRenderer.java
131	131	Log.e("Check", "Failed to add Chroma effect!");
132	132	}
133	133
134		mScreen = new DistortedScreen(mView);
	134	mScreen = new DistortedScreen();
135	135	}
136	136
137	137	///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.check;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
         public CheckSurfaceView(Context context, AttributeSet attrs)
+          {
           super(context, attrs);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           if(!isInEditMode()) setRenderer(new CheckRenderer(this));
+          }
+    }

           mEffects.apply( new MatrixEffectQuaternion(quatInt1, mCenter) );
           mEffects.apply( new MatrixEffectQuaternion(quatInt2, mCenter) );
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     import org.distorted.examples.R;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
     import android.view.MotionEvent;
-...
           if(!isInEditMode())
+            {
             mRenderer = new CubesRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
             Toast.makeText(context, R.string.example_rotate_toast , Toast.LENGTH_SHORT).show();
+            }

           movingShearDynamic.add(vShear[0]);
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.setDebug(DistortedScreen.DEBUG_FPS);
           mMovingDistort   = new VertexEffectDistort(movingDistortDynamic, mTouchPoint, mRegion);

     package org.distorted.examples.deform;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
     import android.view.MotionEvent;
-...
           if(!isInEditMode())
+            {
             mRenderer = new DeformRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

             mEffects[i].apply(scaleEffect);
+            }
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void onDrawFrame(GL10 glUnused)
        public void onDrawFrame(GL10 glUnused)
+          {
           mScreen.render( System.currentTimeMillis() );
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void onSurfaceChanged(GL10 glUnused, int width, int height)
+          {
           if( (float)bmpHeight/(NUM*bmpWidth) > (float)height/width )
+            {
             int w = (height*bmpWidth)/bmpHeight;
             float factor = (float)height/bmpHeight;
             mScale.set(factor,factor,factor);
             for(int i=NUM-1; i>=0; i--)
+              {
               mMove[i].set((width-NUM*w)/2 +i*w ,0,0);
+              }
+            }
           else
+            {
             int w = width/NUM;
             int h = (width*bmpHeight)/(bmpWidth*NUM);
             float factor = (float)width/(bmpWidth*NUM);
             mScale.set(factor,factor,factor);
             for(int i=NUM-1; i>=0; i--)
+              {
               mMove[i].set(i*w,(height-h)/2,0);
+              }
+            }
        public void onSurfaceChanged(GL10 glUnused, int width, int height)
+         {
          if( (float)bmpHeight/(NUM*bmpWidth) > (float)height/width )
+           {
            int w = (height*bmpWidth)/bmpHeight;
            float factor = (float)height/bmpHeight;
            mScale.set(factor,factor,factor);
            for(int i=NUM-1; i>=0; i--)
+             {
              mMove[i].set((width-NUM*w)/2 +i*w ,0,0);
+             }
+           }
          else
+           {
            int w = width/NUM;
            int h = (width*bmpHeight)/(bmpWidth*NUM);
            float factor = (float)width/(bmpWidth*NUM);
            mScale.set(factor,factor,factor);
            for(int i=NUM-1; i>=0; i--)
+             {
              mMove[i].set(i*w,(height-h)/2,0);
+             }
+           }
           mScreen.resize(width, height);
+          }
          mScreen.resize(width, height);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
+          {
           Bitmap bitmap0= readBitmap(R.raw.dog);
           Bitmap bitmap1= readBitmap(R.raw.face);
           Bitmap bitmap2= readBitmap(R.raw.cat);
        public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
+         {
          Bitmap bitmap0= readBitmap(R.raw.dog);
          Bitmap bitmap1= readBitmap(R.raw.face);
          Bitmap bitmap2= readBitmap(R.raw.cat);
           bmpHeight = bitmap0.getHeight();
           bmpWidth  = bitmap0.getWidth();
          bmpHeight = bitmap0.getHeight();
          bmpWidth  = bitmap0.getWidth();
           if( mTexture==null )
+            {
             mTexture = new DistortedTexture[NUM];
          if( mTexture==null )
+           {
            mTexture = new DistortedTexture[NUM];
             for(int i=0; i<NUM; i++)
               mTexture[i] = new DistortedTexture(bmpWidth,bmpHeight);
+            }
            for(int i=0; i<NUM; i++)
              mTexture[i] = new DistortedTexture(bmpWidth,bmpHeight);
+           }
           mTexture[0].setTexture(bitmap0);
           mTexture[1].setTexture(bitmap1);
           mTexture[2].setTexture(bitmap2);
          mTexture[0].setTexture(bitmap0);
          mTexture[1].setTexture(bitmap1);
          mTexture[2].setTexture(bitmap2);
           if( mMesh==null ) mMesh = new MeshFlat(30,30*bmpHeight/bmpWidth);
          if( mMesh==null ) mMesh = new MeshFlat(30,30*bmpHeight/bmpWidth);
           mScreen.detachAll();
           for(int i=NUM-1; i>=0; i--) mScreen.attach(mTexture[i], mEffects[i], mMesh);
          mScreen.detachAll();
          for(int i=NUM-1; i>=0; i--) mScreen.attach(mTexture[i], mEffects[i], mMesh);
           DistortedEffects.enableEffect(EffectName.SINK);
           DistortedEffects.enableEffect(EffectName.DISTORT);
          DistortedEffects.enableEffect(EffectName.SINK);
          DistortedEffects.enableEffect(EffectName.DISTORT);
           try
+            {
             Distorted.onCreate(mView.getContext());
+            }
           catch(Exception ex)
+            {
             android.util.Log.e("Renderer", ex.getMessage() );
+            }
+          }
          try
+           {
            Distorted.onCreate(mView.getContext());
+           }
          catch(Exception ex)
+           {
            android.util.Log.e("Renderer", ex.getMessage() );
+           }
+         }
+    }

     package org.distorted.examples.differentbitmaps;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public DifferentBitmapsSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new DifferentBitmapsRenderer(this));
+          }
+    }

src/main/java/org/distorted/examples/differenteffects/DifferentEffectsRenderer.java
118	118	mEffects[i].apply(scaleEffect);
119	119	}
120	120
121		mScreen = new DistortedScreen(mView);
	121	mScreen = new DistortedScreen();
122	122	}
123	123
124	124	///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.differenteffects;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public DifferentEffectsSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new DifferentEffectsRenderer(this));
+          }
+    }

          mView    = v;
          mMesh    = new MeshFlat(1,1);
          mEffects = new DistortedEffects();
          mScreen  = new DistortedScreen(mView);
          mScreen  = new DistortedScreen();
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.dynamic;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.view.MotionEvent;
     import android.util.AttributeSet;
-...
             setFocusable(true);
             setFocusableInTouchMode(true);
             DynamicRenderer mRenderer = new DynamicRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

         mEffects.apply(scaleEffect);
         mEffects.registerForMessages(this);
         mScreen = new DistortedScreen(mView);
         mScreen = new DistortedScreen();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.effectqueue;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.view.MotionEvent;
     import android.util.AttributeSet;
-...
           setFocusable(true);
           setFocusableInTouchMode(true);
           mRenderer = new EffectQueueRenderer(this);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(mRenderer);
           mRegionV= new Static4D(0,0,RADIUS,RADIUS);
           setEffect(0);

           mCenterNode = new DistortedNode(mCenterTexture, centerEffects, quad);
           mRegionNode = new DistortedNode(mRegionTexture, regionEffects, quad);
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.setProjection(FOV, NEAR);
           mScreen.attach(mBackgroundTexture, backgroundEffects, quad );
           mScreen.attach(mObjectTexture    , objectEffects    , meshO);

     package org.distorted.examples.effects3d;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
     import android.view.MotionEvent;
-...
         if(!isInEditMode())
+          {
           mRenderer = new Effects3DRenderer(this);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(mRenderer);
+          }
+        }

           mEffects.apply( new MatrixEffectQuaternion(mQuat1, mCenter) );
           mEffects.apply( new MatrixEffectQuaternion(mQuat2, mCenter) );
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.attach(mTexture,mEffects, new MeshCubes(50,30,1) );
+          }

     package org.distorted.examples.flag;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
     import android.view.MotionEvent;
-...
           if(!isInEditMode())
+            {
             mRenderer = new FlagRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

           mEffects.apply(new MatrixEffectMove(mMove));
           mEffects.apply(new MatrixEffectScale(mScale));
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void onSurfaceChanged(GL10 glUnused, int width, int height)
+          {
           if( (float)bmpHeight/bmpWidth > (float)height/width )
+            {
             int w = (height*bmpWidth)/bmpHeight;
             float factor = (float)height/bmpHeight;
             mMove.set((width-w)/2,0,0);
             mScale.set(factor,factor,factor);
+            }
           else
+            {
             int h = (width*bmpHeight)/bmpWidth;
             float factor = (float)width/bmpWidth;
             mMove.set(0,(height-h)/2,0);
             mScale.set(factor,factor,factor);
+            }
        public void onSurfaceChanged(GL10 glUnused, int width, int height)
+         {
          if( (float)bmpHeight/bmpWidth > (float)height/width )
+           {
            int w = (height*bmpWidth)/bmpHeight;
            float factor = (float)height/bmpHeight;
            mMove.set((width-w)/2,0,0);
            mScale.set(factor,factor,factor);
+           }
          else
+           {
            int h = (width*bmpHeight)/bmpWidth;
            float factor = (float)width/bmpWidth;
            mMove.set(0,(height-h)/2,0);
            mScale.set(factor,factor,factor);
+           }
           mScreen.resize(width, height);
+          }
          mScreen.resize(width, height);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
+          {
           InputStream is = mView.getContext().getResources().openRawResource(R.raw.girl);
           Bitmap bitmap;
        public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
+         {
          InputStream is = mView.getContext().getResources().openRawResource(R.raw.girl);
          Bitmap bitmap;
           try
+            {
             bitmap = BitmapFactory.decodeStream(is);
+            }
           finally
+            {
             try
+              {
               is.close();
+              }
             catch(IOException e) { }
+            }
          try
+           {
            bitmap = BitmapFactory.decodeStream(is);
+           }
          finally
+           {
            try
+             {
              is.close();
+             }
            catch(IOException e) { }
+           }
           bmpHeight = bitmap.getHeight();
           bmpWidth  = bitmap.getWidth();
          bmpHeight = bitmap.getHeight();
          bmpWidth  = bitmap.getWidth();
           if( mTexture==null ) mTexture = new DistortedTexture(bmpWidth,bmpHeight);
           mTexture.setTexture(bitmap);
          if( mTexture==null ) mTexture = new DistortedTexture(bmpWidth,bmpHeight);
          mTexture.setTexture(bitmap);
           if( mMesh==null ) mMesh = new MeshFlat(30,30*bmpHeight/bmpWidth);
          if( mMesh==null ) mMesh = new MeshFlat(30,30*bmpHeight/bmpWidth);
           mScreen.detachAll();
           mScreen.attach(mTexture,mEffects,mMesh);
          mScreen.detachAll();
          mScreen.attach(mTexture,mEffects,mMesh);
           DistortedEffects.enableEffect(EffectName.DISTORT);
           DistortedEffects.enableEffect(EffectName.SINK);
           DistortedEffects.enableEffect(EffectName.SWIRL);
          DistortedEffects.enableEffect(EffectName.DISTORT);
          DistortedEffects.enableEffect(EffectName.SINK);
          DistortedEffects.enableEffect(EffectName.SWIRL);
           try
+            {
             Distorted.onCreate(mView.getContext());
+            }
           catch(Exception ex)
+            {
             android.util.Log.e("Renderer", ex.getMessage() );
+            }
+          }
          try
+           {
            Distorted.onCreate(mView.getContext());
+           }
          catch(Exception ex)
+           {
            android.util.Log.e("Renderer", ex.getMessage() );
+           }
+         }
+    }

     package org.distorted.examples.girl;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new GirlRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

           makeGlow(0);
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.attach(root);
+          }

     package org.distorted.examples.glow;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public GlowSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new GlowRenderer(this));
+          }
+    }

           mView = v;
           mEffects = new DistortedEffects();
           mEffects.registerForMessages(this);
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mRnd = new Random(0);
           mMove = new Static3D(0,0,0);

     package org.distorted.examples.listener;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public ListenerSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new ListenerRenderer(this));
+          }
+    }

           mView = v;
           Matrix3DActivity act = (Matrix3DActivity)v.getContext();
           mTexture= act.getTexture();
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.attach(mTexture,act.getEffects(),act.getMesh());
           mScreen.setProjection(60.0f,0.1f);
+          }

     package org.distorted.examples.matrix3d;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
         if(!isInEditMode())
+          {
           mRenderer = new Matrix3DRenderer(this);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(mRenderer);
+          }
+        }

+          {
           mView    = view;
           mQuad    = new MeshFlat(1,1);
           mScreen  = new DistortedScreen(mView);
           mScreen  = new DistortedScreen();
           mEffectsMirror    = new DistortedEffects();
           mEffectsHead      = new DistortedEffects();

     package org.distorted.examples.mirror;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new MirrorRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

           mEffects.apply(new MatrixEffectMove(mMove));
           mEffects.apply(new MatrixEffectScale(mScale));
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.monalisa;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         public MonaLisaSurfaceView(Context context)
+          {
           super(context);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(new MonaLisaRenderer(this));
+          }
+    }

          mView   = v;
          mEffects= new DistortedEffects();
          mScreen = new DistortedScreen(mView);
          mScreen = new DistortedScreen();
          mRefresh= true;
+         }

     package org.distorted.examples.movingeffects;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.graphics.Canvas;
     import android.graphics.Paint;
     import android.graphics.Paint.Style;
-...
           mRegionVertex   = new Static4D(0,0,0,0);
           mDistort        = new Static3D(0,0,0);
           mRenderer = new MovingEffectsRenderer(this);
           if(!isInEditMode())
+            {
             mRenderer = new MovingEffectsRenderer(this);
             setFocusable(true);
             setFocusableInTouchMode(true);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
           mEffectDistort = new VertexEffectDistort( mDistort , mCenterVertex, mRegionVertex);
           mEffectSink    = new VertexEffectSink(new Static1D(10), mCenterVertex, mRegionVertex);
           mEffectSwirl   = new VertexEffectSwirl( new Static1D(30), mCenterVertex, mRegionVertex);
           mEffectAlpha   = new FragmentEffectAlpha(new Static1D(0.5f), mRegionFragment, true);
           mEffectChroma  = new FragmentEffectChroma(new Static1D(0.5f), new Static3D(1,0,0), mRegionFragment, true);
             mEffectDistort = new VertexEffectDistort( mDistort , mCenterVertex, mRegionVertex);
             mEffectSink    = new VertexEffectSink(new Static1D(10), mCenterVertex, mRegionVertex);
             mEffectSwirl   = new VertexEffectSwirl( new Static1D(30), mCenterVertex, mRegionVertex);
             mEffectAlpha   = new FragmentEffectAlpha(new Static1D(0.5f), mRegionFragment, true);
             mEffectChroma  = new FragmentEffectChroma(new Static1D(0.5f), new Static3D(1,0,0), mRegionFragment, true);
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

           mQuat1 = new Static4D(0,0,0,1);  // unity
           mQuat2 = new Static4D(0,0,0,1);  // quaternions
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.setDebug(DistortedScreen.DEBUG_FPS);
           for(int i=0; i<NUM_OBJECTS; i++)

     package org.distorted.examples.multiblur;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
     import android.view.MotionEvent;
-...
           if(!isInEditMode())
+            {
             mRenderer = new MultiblurRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
             Toast.makeText(context, R.string.example_rotate_toast , Toast.LENGTH_SHORT).show();
+            }

src/main/java/org/distorted/examples/olimpic/OlimpicRenderer.java
140	140	for(int j=0; j<NUM_LEAVES; j++) mCircleNode[i].attach(mLeaf, mEffects[j], mMesh);
141	141	}
142	142
143		mScreen = new DistortedScreen(mView);
	143	mScreen = new DistortedScreen();
144	144	mScreen.attach(mRoot);
145	145	}
146	146

     package org.distorted.examples.olimpic;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new OlimpicRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

         mEffects.apply(new MatrixEffectMove(mMove));
         mEffects.apply(new MatrixEffectScale(mScale));
         mScreen = new DistortedScreen(null);
         mScreen = new DistortedScreen();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

+          {
           mView   = view;
           mEffects= new DistortedEffects();
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mVector = new Static3D(0,0,0);
           mPoint1 = new Static3D(0,0,0);

     package org.distorted.examples.projection;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new ProjectionRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

         effects.apply(new MatrixEffectScale(mScale));
         effects.apply( new MatrixEffectQuaternion(rot,mCenter) );
         mScreen = new DistortedScreen(mView);
         mScreen = new DistortedScreen();
         mScreen.attach(mTexture,effects,mMesh);
+        }

     package org.distorted.examples.quaternion;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public QuaternionSurfaceView(Context context)
+        {
         super(context);
         final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
         final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
         setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
         setRenderer(new QuaternionRenderer(this));
+        }
+      }

         mEffects.apply( new MatrixEffectScale(mScaleMain));
         mEffects.apply( new MatrixEffectScale(mScaleFactor));
         mScreen = new DistortedScreen(mView);
         mScreen = new DistortedScreen();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.save;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
         if(!isInEditMode())
+          {
           mRenderer = new SaveRenderer(this);
           final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
           final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
           setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
           setRenderer(mRenderer);
+          }
+        }

         mEffects.apply(new MatrixEffectMove(mMove));
         mEffects.apply(new MatrixEffectScale(mScale));
         mScreen = new DistortedScreen(mView);
         mScreen = new DistortedScreen();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.sink;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public SinkSurfaceView(Context context)
+        {
         super(context);
         final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
         final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
         setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
         setRenderer(new SinkRenderer(this));
+        }
+      }

src/main/java/org/distorted/examples/starwars/StarWarsRenderer.java
141	141	mStarEffects[i] = new DistortedEffects(mStarEffects[0], Distorted.CLONE_VERTEX);
142	142	}
143	143
144		mScreen = new DistortedScreen(mView);
	144	mScreen = new DistortedScreen();
145	145	mScreen.setProjection(FOV_ANGLE, 0.02f);
146	146	}
147	147

     package org.distorted.examples.starwars;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         super(context);
         mRenderer = new StarWarsRenderer(this);
         final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
         final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
         setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
         setRenderer(mRenderer);
+        }

           mCube2Node.glDepthMask(true);                                              // Write to depth buffer
           /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
           mScreen = new DistortedScreen(mView);
           mScreen = new DistortedScreen();
           mScreen.glClearColor(1.0f,1.0f,1.0f,1.0f);
           mView.setEGLConfigChooser(5,6,5,0,16,8);       // Screen: 16 bit depth, 8 bit STENCIL

     package org.distorted.examples.stencil;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
          if(!isInEditMode())
+           {
            mRenderer = new StencilRenderer(this);
            final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
            setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
            setRenderer(mRenderer);
+           }
+         }

     class WindRenderer implements GLSurfaceView.Renderer
+    {
        private GLSurfaceView mView;
        private DistortedEffects mEffects;
        private DistortedTexture mTexture;
        private DistortedScreen mScreen;
        private WindEffectsManager mManager;
-...
+          {
           mView = view;
           mEffects = new DistortedEffects();
           mTexture = new DistortedTexture(50,30);
           mManager = new WindEffectsManager(mTexture);
           mScreen  = new DistortedScreen(mView);
           mScreen  = new DistortedScreen();
           mScreen.attach(mTexture,mEffects,new MeshCubes(50,30,1));
           DistortedEffects effects = new DistortedEffects();
           mScreen.attach(mTexture,effects,new MeshCubes(50,30,1));
           mObjWidth = mTexture.getWidth();
           mObjHeight= mTexture.getHeight();
           mMove = new Static3D(0,0,0);
           mScale= new Static3D(1,1,1);
           mEffects.apply( new MatrixEffectMove(mMove));
           mEffects.apply( new MatrixEffectScale(mScale));
           effects.apply( new MatrixEffectMove(mMove));
           effects.apply( new MatrixEffectScale(mScale));
           Static1D angle = new Static1D(-45);
           Static3D axis  = new Static3D(0,0,1);
           Static3D center= new Static3D(0,mObjHeight/2,0);
           mEffects.apply( new MatrixEffectRotate(angle, axis, center) );
           mManager.apply(mEffects,mWind);
           effects.apply( new MatrixEffectRotate(angle, axis, center) );
           mManager.apply(effects,mWind);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     package org.distorted.examples.wind;
     import android.app.ActivityManager;
     import android.content.Context;
     import android.content.pm.ConfigurationInfo;
     import android.opengl.GLSurfaceView;
     import android.util.AttributeSet;
-...
           if(!isInEditMode())
+            {
             mRenderer = new WindRenderer(this);
             final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
             setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );
             setRenderer(mRenderer);
+            }
+          }

Project

General

Profile

Distorted Android

Revision e4330c89

Added by Leszek Koltunski over 7 years ago