/src/main/java/org/distorted/library/DistortedFramebuffer.java - Diff - Distorted Android

« Previous | Next »

Revision c5369f1b

Added by Leszek Koltunski about 7 years ago

ID c5369f1bc82e265b3251e6ec7ac2670a4a58f544
Parent 8ca9f899
Child af4cc5db

Major: change of API.

Split DFramebuffer into Framebuffer and Screen; introduce the 'DistortedInputSurface' and 'DistortedOutputSurface' interfaces.

     package org.distorted.library;
     import android.opengl.GLES30;
     import android.opengl.Matrix;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Class which represents a OpenGL Framebuffer object.
      * <p>
      * User is able to create either Framebuffers from objects already constructed outside
      * of the library (the first constructor; primary use case: the screen) or an offscreen
      * FBOs.
      * <p>
      * Keep all objects created in a static LinkedList. The point: we need to be able to mark
      * Framebuffers for deletion, and delete all marked objects later at a convenient time (that's
      * because we can only delete from a thread that holds the OpenGL context so here we provide a
      * framework where one is able to mark for deletion at any time and actual deletion takes place
      * on the next render).
      * User is able to create offscreen FBOs and both a) render to them b) use their COLOR0 attachment as
      * an input texture.
      */
     public class DistortedFramebuffer extends DistortedRenderable
     public class DistortedFramebuffer extends DistortedRenderable implements DistortedInputSurface, DistortedOutputSurface
+      {
       private int[] mDepthH = new int[1];
       private int[] mFBOH   = new int[1];
       private boolean mDepthEnabled;
       // Projection stuff
       private float mX, mY, mFOV;
       int mWidth,mHeight,mDepth;
       float mDistance;
       float[] mProjectionMatrix;
       private DistortedProjection mProjection;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Must be called from a thread holding OpenGL Context
     // Watch out - this has the side-effect of binding a Texture and a Framebuffer!
       void create()
       public void create()
+        {
         if( mColorH[0]==NOT_CREATED_YET )
+          {
-...
         if( mDepthEnabled           ) mDepthH[0] = NOT_CREATED_YET;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void setAsOutput()
+        {
         GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, mFBOH[0]);
         if( mDepthH[0]!=NOT_CREATED_YET )
+          {
           GLES30.glEnable(GLES30.GL_DEPTH_TEST);
           GLES30.glDepthMask(true);
+          }
         else
+          {
           GLES30.glDisable(GLES30.GL_DEPTH_TEST);
           GLES30.glDepthMask(false);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void createProjection()
+        {
         if( mWidth>0 && mHeight>1 )
+          {
           if( mFOV>0.0f )  // perspective projection
+            {
             float left   = (-mX-mWidth /2.0f)/mHeight;
             float right  = (-mX+mWidth /2.0f)/mHeight;
             float bottom = (-mY-mHeight/2.0f)/mHeight;
             float top    = (-mY+mHeight/2.0f)/mHeight;
             float near   = (top-bottom) / (2.0f*(float)Math.tan(mFOV*Math.PI/360));
             mDistance    = mHeight*near/(top-bottom);
             float far    = 2*mDistance-near;
             mDepth       = (int)((far-near)/2);
             Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
+            }
           else             // parallel projection
+            {
             float left   = -mX-mWidth /2.0f;
             float right  = -mX+mWidth /2.0f;
             float bottom = -mY-mHeight/2.0f;
             float top    = -mY+mHeight/2.0f;
             float near   = (mWidth+mHeight)/2;
             mDistance    = 2*near;
             float far    = 3*near;
             mDepth       = (int)near;
             Matrix.orthoM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // if new size fits into the size of the underlying Texture, just change the projection without
     // reallocating the Texture. Otherwise, we need to reallocate.
-...
       void resizeFast(int width, int height)
+        {
         if( mWidth!=width || mHeight!=height )
         if( mProjection.resize(width,height) )
+          {
           mWidth = width;
           mHeight= height;
           createProjection();
           if( mWidth> mSizeX || mHeight> mSizeY)
           if( width> mSizeX || height> mSizeY)
+            {
             mSizeX = mWidth;
             mSizeY = mHeight;
             mSizeX = width;
             mSizeY = height;
             delete();
+            }
+          }
-...
+        {
         super(width,height,NOT_CREATED_YET);
         mProjectionMatrix = new float[16];
         mHeight      = height;
         mWidth       = width;
         mFOV         = 60.0f;
         mX           = 0.0f;
         mY           = 0.0f;
         mProjection  = new DistortedProjection(width,height);
         mDepthEnabled= depthEnabled;
         mFBOH[0]     = NOT_CREATED_YET;
         mDepthH[0]   = NOT_CREATED_YET;
         createProjection();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        {
         super(width,height,NOT_CREATED_YET);
         mProjectionMatrix = new float[16];
         mHeight      = height;
         mWidth       = width;
         mFOV         = 60.0f;
         mX           = 0.0f;
         mY           = 0.0f;
         mProjection  = new DistortedProjection(width,height);
         mDepthEnabled= false;
         mFBOH[0]     = NOT_CREATED_YET;
         mDepthH[0]   = NOT_CREATED_YET;
         createProjection();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Create a new Framebuffer from an already created OpenGL Framebuffer.
      * <p>
      * Has to be followed by a 'resize()' to set the size.
+     *
      * @param fbo the ID of a OpenGL Framebuffer object. Typically 0 (the screen)
      * Bind the underlying rectangle of pixels as a OpenGL Texture.
      */
       public DistortedFramebuffer(int fbo)
       public boolean setAsInput()
+        {
         super(0,0,DONT_CREATE);
         if( mColorH[0]>0 )
+          {
           GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mColorH[0]);
           return true;
+          }
         return false;
+        }
         mProjectionMatrix = new float[16];
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Bind this Surface as a Framebuffer we can render to.
      */
       public void setAsOutput()
+        {
         GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, mFBOH[0]);
         mFOV         = 60.0f;
         mX           = 0.0f;
         mY           = 0.0f;
         mDepthEnabled= true;
         mFBOH[0]     = fbo;
         mDepthH[0]   = DONT_CREATE;
         if( mDepthH[0]!=NOT_CREATED_YET )
+          {
           GLES30.glEnable(GLES30.GL_DEPTH_TEST);
           GLES30.glDepthMask(true);
+          }
         else
+          {
           GLES30.glDisable(GLES30.GL_DEPTH_TEST);
           GLES30.glDepthMask(false);
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * <p>
      * Must be called from a thread holding OpenGL Context.
+     *
      * @param ren input Renderable to use.
      * @param surface InputSurface to skin our Mesh with.
      * @param mesh Class descendant from MeshObject
      * @param effects The DistortedEffects to use when rendering
      * @param time Current time, in milliseconds.
      */
       public void renderTo(DistortedRenderable ren, MeshObject mesh, DistortedEffects effects, long time)
       public void renderTo(DistortedInputSurface surface, MeshObject mesh, DistortedEffects effects, long time)
+        {
         ren.create();  // Watch out  - this needs to be before
         create();      // the 'setAsInput' because this has side-effects!
         surface.create();  // Watch out  - this needs to be before
         create();          // the 'setAsInput' because this has side-effects!
         if( ren.setAsInput() )
         if( surface.setAsInput() )
+          {
           DistortedRenderable.deleteAllMarked();
           effects.drawPriv(ren.getWidth()/2.0f, ren.getHeight()/2.0f, mesh, this, time);
           effects.drawPriv(surface.getWidth()/2.0f, surface.getHeight()/2.0f, mesh, this, time);
+          }
+        }
-...
      */
       public void setProjection(float fov, float x, float y)
+        {
         mFOV = fov;
         mX   = x;
         mY   = y;
         createProjection();
         mProjection.set(fov,x,y);
         mProjection.createProjection();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Resize the underlying Framebuffer.
+     *
      * As the Framebuffer is not created until the first render, typical usage of this API is actually
      * to set the size of an not-yet-created Framebuffer of an object that has been created with the
      * second constructor.
      * <p>
      * Fully creating an object, rendering to it, then resizing mid-render is also possible. Actual
      * resize takes place on the next render.
+     *
      * @param width The new width.
      * @param height The new height.
      */
       public void resize(int width, int height)
+        {
         if( mWidth!=width || mHeight!=height )
         if( mProjection.resize(width,height) )
+          {
           mWidth = width;
           mHeight= height;
           mSizeX = width;
           mSizeY = height;
           createProjection();
           if( mColorH[0]>0 ) markForDeletion();
+          }
+        }
-...
+        {
         return mDepthEnabled;
+        }
     //////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Return Projection stored in this Framebuffer.
+     *
      * @return DistortedProjection object.
      */
       public DistortedProjection getProjection()
+        {
         return mProjection;
+        }
+      }

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision c5369f1b

Added by Leszek Koltunski about 7 years ago