/ - Diff - Distorted Android

      */
     public class Distorted
+      {
       static final String glslVersion="#version 300 es\n";
       static int GLSL;
       static String GLSL_VERSION;
       /**
        * When creating an instance of a DistortedTexture from another instance, clone the Bitmap that's
        * backing up our DistortedTexture.
-...
       public static void onCreate(final Context context)
       throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException
+        {
         GLSL = 100;
         GLSL_VERSION= (GLSL==100 ? "#version 100\n" : "#version 300 es\n");
         final Resources resources = context.getResources();
         DistortedEffects.createProgram(resources);
         EffectQueuePostprocess.createProgram(resources);

         final InputStream mainVertStream = resources.openRawResource(R.raw.main_vertex_shader);
         final InputStream mainFragStream = resources.openRawResource(R.raw.main_fragment_shader);
         String mainVertHeader= Distorted.glslVersion;
         String mainFragHeader= Distorted.glslVersion;
         String mainVertHeader= Distorted.GLSL_VERSION;
         String mainFragHeader= Distorted.GLSL_VERSION;
         EffectNames name;
         EffectTypes type;
-...
         //android.util.Log.e("Effects", "vertHeader= "+mainVertHeader);
         //android.util.Log.e("Effects", "fragHeader= "+mainFragHeader);
         mMainProgram = new DistortedProgram(mainVertStream,mainFragStream, mainVertHeader, mainFragHeader);
         mMainProgram = new DistortedProgram(mainVertStream,mainFragStream, mainVertHeader, mainFragHeader, Distorted.GLSL);
         int mainProgramH = mMainProgram.getProgramHandle();
         EffectQueueFragment.getUniforms(mainProgramH);
-...
         final InputStream blitVertStream = resources.openRawResource(R.raw.blit_vertex_shader);
         final InputStream blitFragStream = resources.openRawResource(R.raw.blit_fragment_shader);
         String blitVertHeader= (Distorted.glslVersion + "#define NUM_VERTEX 0\n"  );
         String blitFragHeader= (Distorted.glslVersion + "#define NUM_FRAGMENT 0\n");
         String blitVertHeader= (Distorted.GLSL_VERSION + "#define NUM_VERTEX 0\n"  );
         String blitFragHeader= (Distorted.GLSL_VERSION + "#define NUM_FRAGMENT 0\n");
         try
+          {
           mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream,blitVertHeader,blitFragHeader);
           mBlitProgram = new DistortedProgram(blitVertStream,blitFragStream,blitVertHeader,blitFragHeader, Distorted.GLSL);
+          }
         catch(Exception e)
+          {
-...
         try
+          {
           mDebugProgram = new DistortedProgram(debugVertexStream,debugFragmentStream, Distorted.glslVersion, Distorted.glslVersion);
           mDebugProgram = new DistortedProgram(debugVertexStream,debugFragmentStream, Distorted.GLSL_VERSION, Distorted.GLSL_VERSION, Distorted.GLSL);
+          }
         catch(Exception e)
+          {

src/main/java/org/distorted/library/EffectQueuePostprocess.java
123	123	try
124	124	{
125	125	mBlur1Program = new DistortedProgram(blur1VertexStream,blur1FragmentStream,
126		Distorted.glslVersion,
127		Distorted.glslVersion+"#define MAX_BLUR "+MAX_BLUR);
	126	Distorted.GLSL_VERSION,
	127	Distorted.GLSL_VERSION + "#define MAX_BLUR "+MAX_BLUR, Distorted.GLSL);
128	128	}
129	129	catch(Exception e)
130	130	{
...	...
145	145	try
146	146	{
147	147	mBlur2Program = new DistortedProgram(blur2VertexStream,blur2FragmentStream,
148		Distorted.glslVersion,
149		Distorted.glslVersion + "#define MAX_BLUR "+MAX_BLUR);
	148	Distorted.GLSL_VERSION,
	149	Distorted.GLSL_VERSION + "#define MAX_BLUR "+MAX_BLUR, Distorted.GLSL);
150	150	}
151	151	catch(Exception e)
152	152	{
153	153	android.util.Log.e("EFFECTS", "exception trying to compile BLUR2 program: "+e.getMessage());
154		throw new RuntimeException(e.getMessage());
	154	// run anyway as compiling Blur2 WILL fail on OpenGL 2.0 contexts
	155	mBlur2Program = mBlur1Program;
155	156	}
156	157
157	158	int blur2ProgramH = mBlur2Program.getProgramHandle();

      */
     public class DistortedProgram
+      {
       private int mProgramHandle;
       private String mAttributeStr;
       private int mAttributeLen;
       private int mProgramHandle;
       private int mNumAttributes;
       private String[] mAttributeName;
-...
           if( currChar==';') break;
+          }
         if( semicolon<len && semicolon-whiteSpace>=4 )   // "in a;" --> 4
         if( semicolon<len && semicolon-whiteSpace>=mAttributeLen+1 )
+          {
           String subline = line.substring(whiteSpace,semicolon);
           int subLen = semicolon-whiteSpace;
           if( subline.startsWith("in "))
           if( subline.startsWith(mAttributeStr))
+            {
             //android.util.Log.e("program", "GOOD LINE: " +subline+" subLen="+subLen);
             for(nameBegin=subLen-1; nameBegin>1; nameBegin--)
             for(nameBegin=subLen-1; nameBegin>mAttributeLen-2; nameBegin--)
+              {
               currChar=subline.charAt(nameBegin);
-...
        * @throws LinkingException
        */
       public DistortedProgram(final InputStream vertex, final InputStream fragment, final String vertexHeader, final String fragmentHeader)
       public DistortedProgram(final InputStream vertex, final InputStream fragment, final String vertexHeader, final String fragmentHeader, int glslVersion)
       throws FragmentCompilationException,VertexCompilationException,VertexUniformsException,FragmentUniformsException,LinkingException
+        {
         mAttributeStr = (glslVersion == 100 ? "attribute " : "in ");
         mAttributeLen = mAttributeStr.length();
         mNumAttributes = 0;
         final String vertexShader   = readTextFileFromRawResource(vertex  , true );

     precision lowp float;
     in vec2 v_TexCoordinate;      // Interpolated texture coordinate per fragment.
     #if __VERSION__ != 100
     #define TEXTURE texture
     out vec4 fragColor;           // The output color
     in vec2 v_TexCoordinate;      // Interpolated texture coordinate per fragment.
     #else
     #define TEXTURE texture2D
     varying vec2 v_TexCoordinate; // Interpolated texture coordinate per fragment.
     #endif
     uniform sampler2D u_Texture;  // The input texture.
     //////////////////////////////////////////////////////////////////////////////////////////////
     void main()
+      {
       fragColor = texture(u_Texture,v_TexCoordinate);
+      {
     #if __VERSION__ != 100
       fragColor    =
     #else
       gl_FragColor =
     #endif
       TEXTURE(u_Texture,v_TexCoordinate);
+      }

     precision lowp float;
     uniform float u_Depth;    // distance from the near plane to render plane, in clip coords
     in vec2 a_Position;       // Per-vertex position.
     out vec2 v_TexCoordinate; //
     #if __VERSION__ != 100
     in vec2 a_Position;           // Per-vertex position.
     out vec2 v_TexCoordinate;     //
     #else
     attribute vec2 a_Position;    // Per-vertex position.
     varying vec2 v_TexCoordinate; //
     #endif
     uniform float u_Depth;        // distance from the near plane to render plane, in clip coords
     //////////////////////////////////////////////////////////////////////////////////////////////

     precision lowp float;
     #if __VERSION__ != 100
     #define TEXTURE texture
     in vec2 v_TexCoordinate;
     out vec4 fragColor;
     #else
     #define TEXTURE texture2D
     varying vec2 v_TexCoordinate;
     #endif
     uniform sampler2D u_ColorTexture;
     uniform float u_Offsets[MAX_BLUR];
     uniform float u_Weights[MAX_BLUR];
-...
     void main()
+      {
       vec4 pixel= texture(u_ColorTexture,v_TexCoordinate) * u_Weights[0];
       vec4 pixel= TEXTURE(u_ColorTexture,v_TexCoordinate) * u_Weights[0];
       for (int i=1; i<=u_Radius; i+=1)
+        {
         pixel += ( texture(u_ColorTexture,vec2(v_TexCoordinate.x+u_Offsets[i],v_TexCoordinate.y)) +
                    texture(u_ColorTexture,vec2(v_TexCoordinate.x-u_Offsets[i],v_TexCoordinate.y)) ) * u_Weights[i];
         pixel += ( TEXTURE(u_ColorTexture,vec2(v_TexCoordinate.x+u_Offsets[i],v_TexCoordinate.y)) +
                    TEXTURE(u_ColorTexture,vec2(v_TexCoordinate.x-u_Offsets[i],v_TexCoordinate.y)) ) * u_Weights[i];
+        }
       fragColor = pixel;
     #if __VERSION__ != 100
       fragColor    =
     #else
       gl_FragColor =
     #endif
       pixel;
+      }

     precision lowp float;
     #if __VERSION__ != 100
     #define TEXTURE texture
     in vec2 v_TexCoordinate;
     out vec4 fragColor;
     #else
     #define TEXTURE texture2D
     varying vec2 v_TexCoordinate;
     #endif
     uniform sampler2D u_ColorTexture;
     uniform sampler2D u_DepthTexture;
     uniform float u_Offsets[MAX_BLUR];
-...
     void main()
+      {
       gl_FragDepth = 0.0;//texture(u_DepthTexture,v_TexCoordinate);
       gl_FragDepth = TEXTURE(u_DepthTexture,v_TexCoordinate).r;
       vec4 pixel= texture(u_ColorTexture,v_TexCoordinate) * u_Weights[0];
       vec4 pixel= TEXTURE(u_ColorTexture,v_TexCoordinate) * u_Weights[0];
       for (int i=1; i<=u_Radius; i+=1)
+        {
         pixel += ( texture(u_ColorTexture,vec2(v_TexCoordinate.x+u_Offsets[i],v_TexCoordinate.y)) +
                    texture(u_ColorTexture,vec2(v_TexCoordinate.x-u_Offsets[i],v_TexCoordinate.y)) ) * u_Weights[i];
         pixel += ( TEXTURE(u_ColorTexture,vec2(v_TexCoordinate.x+u_Offsets[i],v_TexCoordinate.y)) +
                    TEXTURE(u_ColorTexture,vec2(v_TexCoordinate.x-u_Offsets[i],v_TexCoordinate.y)) ) * u_Weights[i];
+        }
       fragColor = pixel;
     #if __VERSION__ != 100
       fragColor    =
     #else
       gl_FragColor =
     #endif
       pixel;
+      }

     precision lowp float;
     uniform float u_Depth;    // distance from the near plane to render plane, in clip coords
     #if __VERSION__ != 100
     in vec2 a_Position;       // Per-vertex position.
     in vec2 a_TexCoordinate;  // Per-vertex texture coordinate information we will pass in.
     out vec2 v_TexCoordinate; //
     #else
     attribute vec2 a_Position;       // Per-vertex position.
     attribute vec2 a_TexCoordinate;  // Per-vertex texture coordinate information we will pass in.
     varying vec2 v_TexCoordinate;    //
     #endif
     uniform float u_Depth;    // distance from the near plane to render plane, in clip coords
     //////////////////////////////////////////////////////////////////////////////////////////////

     //////////////////////////////////////////////////////////////////////////////////////////////
     precision lowp float;
     uniform sampler2D u_Texture;            // The input texture.
     #if __VERSION__ != 100
     #define TEXTURE texture
     in vec3 v_Position;                     // Interpolated position for this fragment.
     in vec3 v_Normal;                       // Interpolated normal for this fragment.
     in vec2 v_TexCoordinate;                // Interpolated texture coordinate per fragment.
     out vec4 fragColor;                     // The output color
     #else
     #define TEXTURE texture2D
     varying vec3 v_Position;                // Interpolated position for this fragment.
     varying vec3 v_Normal;                  // Interpolated normal for this fragment.
     varying vec2 v_TexCoordinate;           // Interpolated texture coordinate per fragment.
     #endif
     uniform sampler2D u_Texture;            // The input texture.
     #if NUM_FRAGMENT>0
     uniform int fNumEffects;                // total number of fragment effects
-...
     void main()
+      {
       vec4 pixel = texture(u_Texture,v_TexCoordinate);
       vec4 pixel = TEXTURE(u_Texture,v_TexCoordinate);
     #if NUM_FRAGMENT>0
       vec2 diff;
-...
+        }
     #endif
       fragColor = vec4(pixel.rgb * (1.0 + 7.0*v_Normal.z) * 0.125, pixel.a);
     #if __VERSION__ != 100
       fragColor    =
     #else
       gl_FragColor =
     #endif
       vec4(pixel.rgb * (1.0 + 7.0*v_Normal.z) * 0.125, pixel.a);
+      }

     precision lowp float;
     #if __VERSION__ != 100
     in vec3 a_Position;                  // Per-vertex position.
     in vec3 a_Normal;                    // Per-vertex normal vector.
     in vec2 a_TexCoordinate;             // Per-vertex texture coordinate.
     out vec3 v_Position;                 //
     out vec3 v_Normal;                   //
     out vec2 v_TexCoordinate;            //
     #else
     attribute vec3 a_Position;           // Per-vertex position.
     attribute vec3 a_Normal;             // Per-vertex normal vector.
     attribute vec2 a_TexCoordinate;      // Per-vertex texture coordinate.
     varying vec3 v_Position;             //
     varying vec3 v_Normal;               //
     varying vec2 v_TexCoordinate;        //
     #endif
     uniform vec3 u_objD;                 // half of object width x half of object height X half the depth;
                                          // point (0,0,0) is the center of the object
-...
                                          // I read OpenGL ES has a built-in uniform variable gl_DepthRange.near = n,
                                          // .far = f, .diff = f-n so maybe u_Depth is redundant
                                          // Update: this struct is only available in fragment shaders
     uniform mat4 u_MVPMatrix;            // the combined model/view/projection matrix.
     uniform mat4 u_MVMatrix;             // the combined model/view matrix.
     in vec3 a_Position;                  // Per-vertex position.
     in vec3 a_Normal;                    // Per-vertex normal vector.
     in vec2 a_TexCoordinate;             // Per-vertex texture coordinate.
     out vec3 v_Position;                 //
     out vec3 v_Normal;                   //
     out vec2 v_TexCoordinate;            //
     #if NUM_VERTEX>0
     uniform int vNumEffects;             // total number of vertex effects

     precision lowp float;
     #if __VERSION__ != 100
     out vec4 fragColor;
     #endif
     //////////////////////////////////////////////////////////////////////////////////////////////
     void main()
+      {
       fragColor = vec4(1.0,0.0,0.0,0.2);
     #if __VERSION__ != 100
       fragColor    =
     #else
       gl_FragColor =
     #endif
       vec4(1.0,0.0,0.0,0.2);
+      }

     precision lowp float;
     #if __VERSION__ != 100
     in vec2 a_Position;        // Per-vertex position information we will pass in.
     #else
     attribute vec2 a_Position; // Per-vertex position information we will pass in.
     #endif
     uniform vec2 u_objD;       // object width X object height.
     uniform mat4 u_MVPMatrix;  // the combined model/view/projection matrix.
     in vec2 a_Position;        // Per-vertex position information we will pass in.
     //////////////////////////////////////////////////////////////////////////////////////////////

Project

General

Profile

Distorted Android

Revision 94f6d472

Added by Leszek Koltunski about 7 years ago