/ - Diff - Distorted Android

« Previous | Next »

Revision a31dbc5c

Added by Leszek Koltunski over 7 years ago

ID a31dbc5cd31c2797104e212c0ae194076dd8ad1e
Parent 3f44e745
Child b28c6c21

Beginnings of support for the GLOW effect.

     import org.distorted.library.message.EffectListener;
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data4D;
     import java.util.ArrayList;
-...
+        {
         return mP.add(EffectNames.BLUR, radius);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Make the object glow with a specific color and a halo of specific radius.
+     *
      * @param radius The 'strength' if the effect, in pixels. 0 = no halo, 10 = halo of roughly 10 pixels
      *               around the whole object.
      * @param color  RGBA of the color with which to draw the glow.
      * @return ID of the effect added, or -1 if we failed to add one.
      */
       public long glow(Data1D radius, Data4D color)
+        {
         return mP.add(EffectNames.GLOW, radius, color);
+        }
+      }

       /////////////////////////////////////////////////////////////////////////////////
       // POSTPROCESSING EFFECTS.
       // Always 4 Uniforms: 4 per-effect interpolated values.
       // Always 5 Uniforms: 5 per-effect interpolated values.
      /**
        * Blur the area around the center.
        * <p>
        * Uniforms: (radius,UNUSED,UNUSED,UNUSED)
        * Uniforms: (radius,UNUSED,UNUSED,UNUSED,UNUSED)
        * <p>
        * Unity: radius = 0
        */
       BLUR             ( EffectTypes.POSTPROCESS,new float[] {0.0f}          , 1, false, false );
       BLUR             ( EffectTypes.POSTPROCESS,new float[] {0.0f}          , 1, false, false ),
     /**
        * Make the object Glow with a certain color and configurable radius of the halo around it.
        * <p>
        * Uniforms: (A,R,G,B,radius)
        * <p>
        * Unity: radius = 0
        */
       GLOW             ( EffectTypes.POSTPROCESS,new float[] {0.0f}          , 5, false, false );
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private static final int MAXDIM = 4;  // maximum supported dimension of an effect
       private static final int MAXDIM = 4;  // maximum supported dimension of the Unity of an Effect
                                             // (not to be confused with dimension of the Effect itself!)
       private final EffectTypes type;
       private final float[] unity;
       private final int dimension;

     import org.distorted.library.program.VertexCompilationException;
     import org.distorted.library.program.VertexUniformsException;
     import org.distorted.library.type.Data1D;
     import org.distorted.library.type.Data4D;
     import org.distorted.library.type.Dynamic1D;
     import org.distorted.library.type.Dynamic4D;
     import org.distorted.library.type.Static1D;
     import org.distorted.library.type.Static4D;
     import java.io.InputStream;
     import java.nio.ByteBuffer;
-...
     class EffectQueuePostprocess extends EffectQueue
+      {
       private static final int MAX_HALO = 50;    // Support effects creating up to MAX_HALO pixels wide 'halo' around the object.
       private static final int POS_DATA_SIZE= 2; // Post Program: size of the position data in elements
       private static final int TEX_DATA_SIZE= 2; // Post Program: size of the texture coordinate data in elements.
       private static final int NUM_UNIFORMS = 4;
       private static final int NUM_UNIFORMS = 5;
       private static final int NUM_CACHE    = 0;
       private static final int INDEX = EffectTypes.POSTPROCESS.ordinal();
-...
         mQuadTextureInv.put(textureInv).position(0);
+        }
       int mQualityLevel;
       float mQualityScale;
       /////////////////////////////////////////////////////////////////////////////////
       // BLUR effect
       private static final float GAUSSIAN[] =   // G(0.00), G(0.03), G(0.06), ..., G(3.00), 0
         {                                       // where G(x)= (1/(sqrt(2*PI))) * e^(-(x^2)/2). The last 0 terminates.
-...
         };
       private static final int NUM_GAUSSIAN = GAUSSIAN.length-2;
       // Support blurs consisting of the present pixel and up to MAX_BLUR pixels in each direction
       static final int MAX_BLUR = 50;
       // The (fixed-function-sampled) Gaussian Blur kernels are of the size k0=1, k1=2, k2=2, k3=3, k4=3, k5=4, k6=4,...
       // i.e. k(i)=floor((i+3)/2).  (the 'i' in k(i) means 'blur taking into account the present pixel and 'i' pixels
       // in all 4 directions)
       // We need room for MAX_BLUR of them, and sum(i=0...N, floor((i+3)/2)) = N + floor(N*N/4)
       private static float[] weightsCache = new float[MAX_BLUR + MAX_BLUR*MAX_BLUR/4];
       private static float[] offsetsCache = new float[MAX_BLUR + MAX_BLUR*MAX_BLUR/4];
       private static float[] weightsCache = new float[MAX_HALO + MAX_HALO*MAX_HALO/4];
       private static float[] offsetsCache = new float[MAX_HALO + MAX_HALO*MAX_HALO/4];
       private static DistortedProgram mBlur1Program, mBlur2Program;
       private static int mRadius1H,mOffsets1H,mWeights1H,mDepth1H, mColorTexture1H;
       private static int mRadius2H,mOffsets2H,mWeights2H,mDepth2H, mColorTexture2H;
       private static float[] mWeights = new float[MAX_BLUR];
       private static float[] mOffsets = new float[MAX_BLUR];
       // another effect ....
       private static float[] mWeights = new float[MAX_HALO];
       private static float[] mOffsets = new float[MAX_HALO];
       /////////////////////////////////////////////////////////////////////////////////
       // GLOW effect
       int mQualityLevel;
       float mQualityScale;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+          {
           mBlur1Program = new DistortedProgram(blur1VertexStream,blur1FragmentStream,
                                               Distorted.GLSL_VERSION,
                                               Distorted.GLSL_VERSION + "#define MAX_BLUR "+MAX_BLUR, Distorted.GLSL);
                                               Distorted.GLSL_VERSION + "#define MAX_BLUR "+MAX_HALO, Distorted.GLSL);
+          }
         catch(Exception e)
+          {
-...
+          {
           mBlur2Program = new DistortedProgram(blur2VertexStream,blur2FragmentStream,
                                               Distorted.GLSL_VERSION,
                                               Distorted.GLSL_VERSION + "#define MAX_BLUR "+MAX_BLUR, Distorted.GLSL);
                                               Distorted.GLSL_VERSION + "#define MAX_BLUR "+MAX_HALO, Distorted.GLSL);
+          }
         catch(Exception e)
+          {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       synchronized boolean compute(long currTime)
       private boolean compute(long currTime)
+        {
         if( currTime==mTime ) return false;
         if( mTime==0 ) mTime = currTime;
-...
+              }
             else mInter[0][i] = null;
+            }
           if( mInter[1][i]!=null ) mInter[1][i].interpolateMain( mUniforms, NUM_UNIFORMS*i+1, mCurrentDuration[i], step);
+          }
         mTime = currTime;
-...
         mUniforms[NUM_UNIFORMS*index+1] = mUniforms[NUM_UNIFORMS*(index+1)+1];
         mUniforms[NUM_UNIFORMS*index+2] = mUniforms[NUM_UNIFORMS*(index+1)+2];
         mUniforms[NUM_UNIFORMS*index+3] = mUniforms[NUM_UNIFORMS*(index+1)+3];
         mUniforms[NUM_UNIFORMS*index+4] = mUniforms[NUM_UNIFORMS*(index+1)+4];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+            {
             if (mName[i] == EffectNames.BLUR.ordinal() )
+              {
               blur(mUniforms[i],surface);
               blur(NUM_UNIFORMS*i,surface);
               numRenders += 2;
+              }
             else if (mName[i] == EffectNames.GLOW.ordinal() )
+              {
               glow(NUM_UNIFORMS*i,surface);
               numRenders += 2;
+              }
+            }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void blur(float degree, DistortedOutputSurface surface)
       private void blur(int index, DistortedOutputSurface surface)
+        {
         DistortedFramebuffer buffer = surface.mBuffer[mQualityLevel];
         GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, buffer.mFBOH[0]);
-...
         float w1 = buffer.mWidth;
         float h1 = buffer.mHeight;
         int radius = (int)(degree*mQualityScale);
         if( radius>=MAX_BLUR ) radius = MAX_BLUR-1;
         int radius = (int)(mUniforms[index]*mQualityScale);
         if( radius>=MAX_HALO ) radius = MAX_HALO-1;
         computeGaussianKernel(radius);
         int offset = radius + radius*radius/4;
-...
         GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void glow(int index, DistortedOutputSurface surface)
+        {
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // blur
-...
         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // glow
       synchronized long add(EffectNames eln, Data1D degree, Data4D color)
+        {
         if( mMax[INDEX]>mNumEffects )
+          {
           if( degree instanceof Dynamic1D)
+            {
             mInter[0][mNumEffects] = (Dynamic1D)degree;
+            }
           else if( degree instanceof Static1D)
+            {
             mInter[0][mNumEffects] = null;
             mUniforms[NUM_UNIFORMS*mNumEffects] = ((Static1D)degree).getX();
+            }
           else return -1;
           if( color instanceof Dynamic4D)
+            {
             mInter[1][mNumEffects] = (Dynamic4D)color;
+            }
           else if( color instanceof Static4D)
+            {
             mInter[1][mNumEffects] = null;
             Static4D tmp = (Static4D)color;
             mUniforms[NUM_UNIFORMS*mNumEffects+1] = tmp.getW();  //
             mUniforms[NUM_UNIFORMS*mNumEffects+2] = tmp.getX();  // Invert: RGBA sent
             mUniforms[NUM_UNIFORMS*mNumEffects+3] = tmp.getY();  // in, ARGB inside
             mUniforms[NUM_UNIFORMS*mNumEffects+4] = tmp.getZ();  //
+            }
           else return -1;
           mInter[2][mNumEffects] = null;
           return addBase(eln);
+          }
         return -1;
+        }
+      }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision a31dbc5c

Added by Leszek Koltunski over 7 years ago