/ - Diff - Distorted Android

     package org.distorted.library.effect;
     import org.distorted.library.main.DistortedFramebuffer;
     import org.distorted.library.main.DistortedMaster;
     import org.distorted.library.program.DistortedProgram;
     import java.nio.ByteBuffer;
-...
     /**
      * Postprocessing Effect - an Effect that works by running a certain Shader Program(s) on a Framebuffer.
      */
     public abstract class PostprocessEffect extends Effect
     public abstract class PostprocessEffect extends Effect implements DistortedMaster.Slave
+      {
       private static final int MIPMAP = 0;
     /**
      * 5: 5 per-effect interpolated values.
      */
-...
+        {
         private String mName, mVertexShader, mFragmentShader;
         public Source(String name, String vertex, String fragment)
         Source(String name, String vertex, String fragment)
+          {
           mName           = name;
           mVertexShader   = vertex;
-...
       private static ArrayList<Source> mSources = new ArrayList<>();
       private static int mNumSources = 0;
       private class Job
+        {
         int type;
         int level;
         Job(int t, int l)
+          {
           type = t;
           level= l;
+          }
+        }
       private ArrayList<Job> mJobs = new ArrayList<>();
       int mQualityLevel;
       float mQualityScale;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static int register(final String name, final String vertexShader, final String fragmentShader)
-...
+     *
      * @y.exclude
      */
       public abstract int apply(float[] uniforms, int index, float qualityScale, DistortedFramebuffer buffer);
       public abstract int apply(float[] uniforms, int index, DistortedFramebuffer[] buffers);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public abstract int getQuality();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedSlave interface, which should really be a class that we extend here instead but
      * Java has no multiple inheritance.
+     *
      * @y.exclude
      */
       public void doWork()
+        {
         int num = mJobs.size();
         Job job;
         for(int i=0; i<num; i++)
+          {
           job = mJobs.remove(0);
           switch(job.type)
+            {
             case MIPMAP: int level = job.level;
                          mQualityLevel = level;
                          mQualityScale = 1.0f;
                          for(int j=0; j<level; j++) mQualityScale*= EffectQuality.MULTIPLIER;
                          break;
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       PostprocessEffect(EffectName name)
+        {
         super(name);
         mQualityLevel = 0;
         mQualityScale = 1.0f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * The higher the quality, the better the effect will look like and the slower it will be.
      * <p>
      * This works by rendering into smaller and smaller intermediate buffers. Each step renders into a
      * buffer that's half the size of the previous one.
      * <p>
      * We cannot this during mid-render - thus, give it to the Master to assign us back this job on the
      * next render.
      */
       public void setQuality(EffectQuality quality)
+        {
         mJobs.add(new Job(MIPMAP,quality.getLevel()));
         DistortedMaster.newSlave(this);
+        }
+      }

+     *
      * @y.exclude
      */
       public int apply(float[] uniforms, int index, float qualityScale, DistortedFramebuffer buffer)
      public int getQuality()
+       {
        return mQualityLevel;
+       }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int apply(float[] uniforms, int index, DistortedFramebuffer[] buffers)
+        {
         if( mProgram1 ==null)
+          {
-...
           mProgram2 = mPrograms.get(mIndex2);
+          }
         DistortedFramebuffer buffer = buffers[mQualityLevel];
         buffer.setAsOutput();
         float w1  = buffer.getWidth();
         float h1  = buffer.getHeight();
         float near= 1.0f - buffer.getNear();
         int radius = (int)(uniforms[index]*qualityScale);
         int radius = (int)(uniforms[index]*mQualityScale);
         if( radius>=MAX_HALO ) radius = MAX_HALO-1;
         computeGaussianKernel(radius);

+     *
      * @y.exclude
      */
       public int apply(float[] uniforms, int index, float qualityScale, DistortedFramebuffer buffer)
      public int getQuality()
+       {
        return 0;
+       }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Only for use by the library itself.
+     *
      * @y.exclude
      */
       public int apply(float[] uniforms, int index, DistortedFramebuffer[] buffers)
+        {
         if( mProgram1 ==null)
+          {
-...
           mProgram2 = mPrograms.get(mIndex2);
+          }
         DistortedFramebuffer buffer = buffers[mQualityLevel];
         buffer.setAsOutput();
         float w1  = buffer.getWidth();
         float h1  = buffer.getHeight();
         float near= 1.0f - buffer.getNear();
         int radius = (int)(uniforms[index]*qualityScale);
         int radius = (int)(uniforms[index]*mQualityScale);
         if( radius>=MAX_HALO ) radius = MAX_HALO-1;
         computeGaussianKernel(radius);

      * <p>
      * The queues hold actual effects to be applied to a given (InputSurface,MeshObject) combo.
      */
     public class DistortedEffects implements DistortedSlave
     public class DistortedEffects
+      {
       private static final int MIPMAP = 0;
       /// MAIN PROGRAM ///
       private static DistortedProgram mMainProgram;
       private static int mMainTextureH;
-...
       private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;
       private class Job
+        {
         int type;
         int level;
         Job(int t, int l)
+          {
           type = t;
           level= l;
+          }
+        }
       private ArrayList<Job> mJobs = new ArrayList<>();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static void createProgram(Resources resources)
-...
       int getQuality()
+        {
         return mP.mQualityLevel;
         return mP.getQuality();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         mP.newNode(node);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * This is not really part of the public API. Has to be public only because it is a part of the
      * DistortedSlave interface, which should really be a class that we extend here instead but
      * Java has no multiple inheritance.
+     *
      * @y.exclude
      */
       public void doWork()
+        {
         int num = mJobs.size();
         Job job;
         for(int i=0; i<num; i++)
+          {
           job = mJobs.remove(0);
           switch(job.type)
+            {
             case MIPMAP: int level = job.level;
                          mP.mQualityLevel = level;
                          mP.mQualityScale = 1.0f;
                          for(int j=0; j<level; j++) mP.mQualityScale*= EffectQuality.MULTIPLIER;
                          break;
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void displayNormals(MeshObject mesh)
-...
         return EffectQueue.setMax(type.ordinal(),max);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * The higher the quality, the better the effect will look like and the slower it will be.
      * <p>
      * This works by rendering into smaller and smaller intermediate buffers. Each step renders into a
      * buffer that's half the size of the previous one.
      * <p>
      * We cannot this during mid-render - thus, give it to the Master to assign us back this job on the
      * next render.
      */
       public void setPostprocessingQuality(EffectQuality quality)
+        {
         mJobs.add(new Job(MIPMAP,quality.getLevel()));
         DistortedMaster.newSlave(this);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Add a new Effect to our queue.

     /**
      * This static class handles assigning jobs to other classes. It does it once, at the beginning of
      * each frame.
      * <p>
      * Not part of public API, do not document (public only because has to be used in PostprocessEffects)
+     *
      * @y.exclude
      */
     class DistortedMaster
     public class DistortedMaster
+      {
       private static ArrayList<DistortedSlave> mSlaves = new ArrayList<>();
       private static ArrayList<Slave> mSlaves = new ArrayList<>();
     /**
      * Not part of public API, do not document (public only because has to be used in PostprocessEffects)
+     *
      * @y.exclude
      */
       public interface Slave
+        {
         /**
          * Not part of public API, do not document
          * @y.exclude
          */
         void doWork();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       static boolean toDo()
+        {
         DistortedSlave slave;
         Slave slave;
         int num = mSlaves.size();
         for(int i=0; i<num; i++)
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       static void newSlave(DistortedSlave s)
     /**
      * Not part of public API, do not document
      * @y.exclude
      */
       public static void newSlave(Slave s)
+        {
         int num = mSlaves.size();
         boolean found = false;
         DistortedSlave tmp;
         Slave tmp;
         for(int i=0; i<num; i++)
+          {

      * to sub-class 'NodeData'. Two identical sub-trees attached at different points of the main tree
      * will point to the same NodeData; only the first of this is rendered (mData.numRender!).
      */
     public class DistortedNode implements DistortedSlave
     public class DistortedNode implements DistortedMaster.Slave
+      {
       private static final int ATTACH = 0;
       private static final int DETACH = 1;

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     abstract class DistortedOutputSurface extends DistortedSurface implements DistortedSlave
     abstract class DistortedOutputSurface extends DistortedSurface implements DistortedMaster.Slave
+    {
     //////////// DEBUG FLAGS /////////////////////////////////////////////
     /**

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Copyright 2016 Leszek Koltunski                                                               //
     //                                                                                               //
     // This file is part of Distorted.                                                               //
     //                                                                                               //
     // Distorted is free software: you can redistribute it and/or modify                             //
     // it under the terms of the GNU General Public License as published by                          //
     // the Free Software Foundation, either version 2 of the License, or                             //
     // (at your option) any later version.                                                           //
     //                                                                                               //
     // Distorted is distributed in the hope that it will be useful,                                  //
     // but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
     // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
     // GNU General Public License for more details.                                                  //
     //                                                                                               //
     // You should have received a copy of the GNU General Public License                             //
     // along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     package org.distorted.library.main;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Package-private interface implemented by all objects which can be assigned work by the DistortedMaster.
      * <p>
      * All the methods below are really meant to be package-local; and this interface should really be a
      * package-local class which other classes would extend (but that's impossible because OutputSurface
      * already extends other class).
      */
     interface DistortedSlave
+      {
       /**
        * Not part of public API, do not document
        * @y.exclude
        */
       void doWork();
+      }

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     abstract class EffectQueue implements DistortedSlave
     abstract class EffectQueue implements DistortedMaster.Slave
+      {
       private static final int ATTACH = 0;
       private static final int DETACH = 1;

       private static final int NUM_UNIFORMS = PostprocessEffect.NUM_UNIFORMS;
       private static final int INDEX = EffectType.POSTPROCESS.ordinal();
       int mQualityLevel;
       float mQualityScale;
       private int mHalo;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       EffectQueuePostprocess(long id)
+        {
         super(id,NUM_UNIFORMS,INDEX );
         mQualityLevel = 0;
         mQualityScale = 1.0f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return mNumEffects>0 ? mHalo : 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int getQuality()
+        {
         return mNumEffects>0 ? ((PostprocessEffect)mEffects[0]).getQuality() : 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int postprocess(DistortedOutputSurface surface)
-...
         for(int i=0; i<mNumEffects; i++)
+          {
           numRenders += ((PostprocessEffect)mEffects[i]).apply(mUniforms,NUM_UNIFORMS*i,mQualityScale,surface.mBuffer[mQualityLevel]);
           numRenders += ((PostprocessEffect)mEffects[i]).apply(mUniforms,NUM_UNIFORMS*i, surface.mBuffer);
+          }
         DistortedRenderState.unuseStencilMark();

Project

General

Profile

Distorted Android

Revision 86d322b5

Added by Leszek Koltunski over 8 years ago