Project

General

Profile

« Previous | Next » 

Revision c638c1b0

Added by Leszek Koltunski over 7 years ago

Further progress with Postprocessing. Now the missing bits are:

- implement Distorted.getFBO()
- implement Distorted.clean()
- improve compilation of DistortedPrograms so that the NUM_POSTPROCESSING and names of POSTPROCESSING effects will be #defined.

View differences:

src/main/java/org/distorted/library/Distorted.java
83 83
  static int mainProgramH, postProgramH;
84 84

  
85 85
///////////////////////////////////////////////////////////////////////////////////////////////////
86
// private: hide this from Javadoc
86 87

  
87 88
  private Distorted()
88 89
    {
89 90
    
90 91
    }
91 92

  
93
///////////////////////////////////////////////////////////////////////////////////////////////////
94

  
95
  static DistortedFramebuffer getFBO(int w, int h)
96
    {
97
    // TODO: a static factory of Framebuffers.
98

  
99
    return null;
100
    }
101

  
92 102
///////////////////////////////////////////////////////////////////////////////////////////////////
93 103

  
94 104
  static boolean isInitialized()
......
96 106
    return (mMainProgramAttributes!=null);
97 107
    }
98 108

  
109
///////////////////////////////////////////////////////////////////////////////////////////////////
110
/**
111
 * Release all internal memory caches (in particular the FBOs used as buffers for postprocessing)
112
 */
113
  public static void clean()
114
    {
115
    // TODO
116
    }
117

  
99 118
///////////////////////////////////////////////////////////////////////////////////////////////////
100 119
/**
101 120
 * When OpenGL context gets created, you need to call this method so that the library can initialise its internal data structures.
src/main/java/org/distorted/library/DistortedEffects.java
29 29
import org.distorted.library.type.Data5D;
30 30
import org.distorted.library.type.Static3D;
31 31

  
32
import java.nio.ByteBuffer;
33
import java.nio.ByteOrder;
34
import java.nio.FloatBuffer;
35

  
32 36
///////////////////////////////////////////////////////////////////////////////////////////////////
33 37
/**
34 38
 * Class containing {@link EffectTypes#LENGTH} queues, each a class derived from EffectQueue.
......
37 41
 */
38 42
public class DistortedEffects
39 43
  {
44
  private static final int BYTES_PER_FLOAT   = 4; //
45
  private static final int POSITION_DATA_SIZE= 2; // Size of the position data in elements
46
  private static final int TEX_DATA_SIZE     = 2; // Size of the texture coordinate data in elements.
47
  private static final FloatBuffer mQuadPositions, mQuadTexture;
48

  
40 49
  private static long mNextID =0;
41 50
  private long mID;
42 51

  
......
47 56

  
48 57
  private boolean matrixCloned, vertexCloned, fragmentCloned, postprocessCloned;
49 58

  
59
  static
60
    {
61
    int dataLength = 4;
62

  
63
    float[] positionData= { -0.5f, -0.5f,  -0.5f, 0.5f,  0.5f,-0.5f,  0.5f, 0.5f };
64
    float[] textureData = {  0.0f,  0.0f,   0.0f, 1.0f,  1.0f, 0.0f,  1.0f, 1.0f };
65

  
66
    mQuadPositions = ByteBuffer.allocateDirect(POSITION_DATA_SIZE*dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
67
    mQuadPositions.put(positionData).position(0);
68
    mQuadTexture   = ByteBuffer.allocateDirect(TEX_DATA_SIZE     *dataLength*BYTES_PER_FLOAT).order(ByteOrder.nativeOrder()).asFloatBuffer();
69
    mQuadTexture.put(textureData).position(0);
70
    }
71

  
50 72
///////////////////////////////////////////////////////////////////////////////////////////////////
51 73
    
52 74
  private void initializeEffectLists(DistortedEffects d, int flags)
......
121 143
      }
122 144
    else
123 145
      {
124
      DistortedFramebuffer fbo = null;
125
      // TODO : set this as output
146
      DistortedFramebuffer buffer = Distorted.getFBO(df.mWidth,df.mHeight);
126 147

  
127
      // render to the FBO just like above
128
      /*
129
      GLES20.glViewport(0, 0, fbo.mWidth, fbo.mHeight);
148
      GLES20.glViewport(0, 0, buffer.mWidth, buffer.mHeight);
149
      buffer.setAsOutput();
130 150

  
131
      mM.send(fbo,halfInputW,halfInputH,halfZ);
151
      mM.send(buffer,halfInputW,halfInputH,halfZ);
132 152
      mV.send(halfInputW,halfInputH,halfZ);
133 153
      mF.send(halfInputW,halfInputH);
134 154

  
135 155
      mesh.draw();
136
      */
137 156

  
138 157
      GLES20.glUseProgram(Distorted.postProgramH);
158
      GLES20.glViewport(0, 0, df.mWidth, df.mHeight);
159
      buffer.setAsInput();
160
      df.setAsOutput();
161
      mP.send(halfInputW,halfInputH);
139 162

  
140
      // apply postprocess effects
141
      mP.postprocess(fbo,df);
163
      GLES20.glVertexAttribPointer(Distorted.mPostProgramAttributes[0], POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mQuadPositions);
164
      GLES20.glVertexAttribPointer(Distorted.mPostProgramAttributes[1], TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mQuadTexture);
165
      GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
142 166
      }
143 167
    }
144 168

  
src/main/java/org/distorted/library/EffectQueuePostprocess.java
98 98
    mTime = currTime;  
99 99
    }  
100 100

  
101
///////////////////////////////////////////////////////////////////////////////////////////////////
102

  
103
  void postprocess(DistortedFramebuffer input, DistortedFramebuffer output)
104
    {
105
    // 1. Set input's COLOR0 as input texture
106
    // 2. Set output as output FBO
107
    // 3. set Vieport
108
    // 4. call send()
109
    // 5. render a quad:
110
    /*
111
    GLES20.glVertexAttribPointer(Distorted.mPostProgramAttributes[0], MeshObject.POSITION_DATA_SIZE, GLES20.GL_FLOAT, false, 0, mMeshPositions);
112
    GLES20.glVertexAttribPointer(Distorted.mPostProgramAttributes[1], MeshObject.TEX_DATA_SIZE     , GLES20.GL_FLOAT, false, 0, mMeshTexture);
113
    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
114
    */
115
    }
116

  
117 101
///////////////////////////////////////////////////////////////////////////////////////////////////
118 102

  
119 103
  protected void moveEffect(int index)
......
125 109

  
126 110
///////////////////////////////////////////////////////////////////////////////////////////////////
127 111

  
128
  synchronized void send(float objX, float objY)
112
  synchronized void send(float halfX, float halfY)
129 113
    {
130 114
    GLES20.glUniform1i( mNumEffectsH, mNumEffects);
131
    GLES20.glUniform2f( mObjDH , objX, objY);
115
    GLES20.glUniform2f( mObjDH , halfX, halfY);
132 116

  
133 117
    if( mNumEffects>0 )
134 118
      {
......
139 123

  
140 124
///////////////////////////////////////////////////////////////////////////////////////////////////
141 125

  
142
  synchronized static void sendZero(float objX, float objY)
126
  synchronized static void sendZero(float halfX, float halfY)
143 127
    {
144 128
    GLES20.glUniform1i( mNumEffectsH, 0);
145
    GLES20.glUniform2f( mObjDH , objX, objY);
129
    GLES20.glUniform2f( mObjDH , halfX, halfY);
146 130
    }
147 131

  
148 132
///////////////////////////////////////////////////////////////////////////////////////////////////
src/main/res/raw/post_vertex_shader.glsl
17 17
// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //
18 18
//////////////////////////////////////////////////////////////////////////////////////////////
19 19

  
20
uniform vec2 u_objD;             // half of object width x half of object height.
21
                                 // point (0,0) is the center of the object
22

  
20 23
attribute vec2 a_Position;       // Per-vertex position information we will pass in.
21 24
attribute vec2 a_TexCoordinate;  // Per-vertex texture coordinate information we will pass in.
22 25
varying   vec2 v_TexCoordinate;  //
......
27 30
void main()
28 31
  {
29 32
  v_TexCoordinate = a_TexCoordinate;
30
  gl_Position = vec4(a_Position, 0.0, 1.0);
33
  gl_Position = vec4( 2.0*u_objD*a_Position, 0.0, 1.0);
31 34
  }

Also available in: Unified diff