Project

General

Profile

« Previous | Next » 

Revision 95c441a2

Added by Leszek Koltunski almost 8 years ago

Progress with Multiblur.

This introduces some regressions with transparency (see: 'Different Bitmaps' and 'Around the world' )

View differences:

src/main/java/org/distorted/library/DistortedEffects.java
230 230
// DEBUG ONLY
231 231

  
232 232
  @SuppressWarnings("unused")
233
  private void displayBoundingRect(float halfX, float halfY, float halfZ, DistortedOutputSurface surface, float[] mvp, float[] vertices)
233
  private void displayBoundingRect(float halfX, float halfY, float halfZ, DistortedOutputSurface surface, float[] mvp, float[] vertices, long currTime)
234 234
    {
235 235
    int len  = vertices.length/3;
236 236
    int minx = Integer.MAX_VALUE;
......
264 264
      }
265 265

  
266 266
    mDebugProgram.useProgram();
267
    surface.setAsOutput();
267
    surface.setAsOutput(currTime);
268 268

  
269 269
    Matrix.setIdentityM( mTmpMatrix, 0);
270 270
    Matrix.translateM  ( mTmpMatrix, 0, minx-surface.mWidth/2, maxy-surface.mHeight/2, -surface.mDistance);
......
286 286
    return mP.mNumEffects==0 ? null : mP.mMainBuffer;
287 287
    }
288 288

  
289
///////////////////////////////////////////////////////////////////////////////////////////////////
290

  
291
  int postprocessPriv(long currTime, DistortedOutputSurface surface)
292
    {
293
    return mP.postprocess(currTime,surface);
294
    }
295

  
289 296
///////////////////////////////////////////////////////////////////////////////////////////////////
290 297

  
291 298
  void drawPriv(float halfW, float halfH, MeshObject mesh, DistortedOutputSurface surface, long currTime)
......
293 300
    mM.compute(currTime);
294 301
    mV.compute(currTime);
295 302
    mF.compute(currTime);
296
    mP.compute(currTime);
297 303

  
298 304
    float halfZ = halfW*mesh.zFactor;
299 305
    GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight);
300 306

  
301 307
    mMainProgram.useProgram();
302 308
    GLES30.glUniform1i(mMainTextureH, 0);
303
    surface.setAsOutput();
309
    surface.setAsOutput(currTime);
304 310
    mM.send(surface,halfW,halfH,halfZ);
305 311
    mV.send(halfW,halfH,halfZ);
306 312
    mF.send(halfW,halfH);
src/main/java/org/distorted/library/DistortedNode.java
211 211
    return 0;
212 212
    }
213 213

  
214
///////////////////////////////////////////////////////////////////////////////////////////////////
215

  
216
  int postprocess(long currTime, DistortedOutputSurface surface)
217
    {
218
    return mEffects.postprocessPriv(currTime,surface);
219
    }
220

  
214 221
///////////////////////////////////////////////////////////////////////////////////////////////////
215 222

  
216 223
  DistortedFramebuffer getPostprocessingBuffer()
......
234 241
        numRenders += mChildren.get(i).renderRecursive(currTime);
235 242
        }
236 243

  
237
      mData.mFBO.setAsOutput();
238

  
239
      DistortedRenderState.colorDepthOn();
240

  
241
      GLES30.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
242
      GLES30.glClear( GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);
244
      mData.mFBO.setAsOutput(currTime);
243 245

  
244 246
      if( mSurface.setAsInput() )
245 247
        {
src/main/java/org/distorted/library/DistortedOutputSurface.java
30 30
  private ArrayList<DistortedNode> mChildren;
31 31
  private int mNumChildren;   // ==mChildren.length(), but we only create mChildren if the first one gets added
32 32

  
33
  private long mTime;
33 34
  private float mFOV;
34 35
  int mWidth,mHeight,mDepth;
35 36
  float mDistance, mNear;
......
61 62
    mFBOH[0]     = fbo;
62 63
    mDepthH[0]   = 0;
63 64

  
65
    mTime = 0;
66

  
64 67
    createProjection();
65 68
    }
66 69

  
......
111 114
    int numRenders = 0;
112 115
    DistortedNode child;
113 116
    DistortedFramebuffer fbo;
114
    DistortedOutputSurface buffer;
117
    DistortedOutputSurface surface;
115 118

  
116 119
    // 1. Render all children that have postprocessing effects to their own buffer FBOs
117 120

  
......
130 133
    // 2. If we have rendered anything so far, and we are a Screen, then render to an
131 134
    //    intermediate FBO instead.
132 135

  
133
    buffer = numRenders>0 ? getBuffer() : this;
136
    surface = this;//numRenders>0 ? getBuffer() : this;
134 137

  
135 138
    // 3. Render all children without postprocessing effects to buffer
136 139

  
......
141 144

  
142 145
      if( fbo==null )
143 146
        {
144
        numRenders += child.draw(time,buffer);
147
        numRenders += child.draw(time,surface);
145 148
        }
146 149
      }
147 150

  
......
149 152
    //       postprocess fbo
150 153
    //       merge to buffer
151 154

  
152
    // TODO
155
    for(int i=0; i<num; i++)
156
      {
157
      numRenders += children.get(i).postprocess(time,surface);
158
      }
153 159

  
154 160
    // 5. finally blit to this if we have to
155 161

  
156
    if( buffer!=this && ((DistortedFramebuffer)buffer).setAsInput() )
162
    if( surface!=this && ((DistortedFramebuffer)surface).setAsInput() )
157 163
      {
158 164
      numRenders++;
159 165
      DistortedEffects.blitPriv(this);
......
215 221
      numRenders += mChildren.get(i).renderRecursive(time);
216 222
      }
217 223

  
218
    setAsOutput();
224
    setAsOutput(time);
219 225
    numRenders += renderChildren(time,mNumChildren,mChildren);
220 226

  
221 227
    return numRenders;
......
225 231
/**
226 232
 * Bind this Surface as a Framebuffer we can render to.
227 233
 */
228
  public void setAsOutput()
234
  public void setAsOutput(long time)
229 235
    {
230 236
    GLES30.glBindFramebuffer(GLES30.GL_FRAMEBUFFER, mFBOH[0]);
237

  
238
    if( mTime!=time )
239
      {
240
      mTime = time;
241
      DistortedRenderState.colorDepthOn();
242
      GLES30.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
243
      GLES30.glClear( GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);
244
      }
231 245
    }
232 246

  
233 247
///////////////////////////////////////////////////////////////////////////////////////////////////
src/main/java/org/distorted/library/EffectQueuePostprocess.java
137 137

  
138 138
///////////////////////////////////////////////////////////////////////////////////////////////////
139 139
  
140
  synchronized void compute(long currTime) 
140
  synchronized boolean compute(long currTime)
141 141
    {
142
    if( currTime==mTime ) return;
142
    if( currTime==mTime ) return false;
143 143
    if( mTime==0 ) mTime = currTime;
144 144
    long step = (currTime-mTime);
145 145
   
......
166 166
        }
167 167
      }
168 168
     
169
    mTime = currTime;  
169
    mTime = currTime;
170

  
171
    return true;
170 172
    }  
171 173

  
172 174
///////////////////////////////////////////////////////////////////////////////////////////////////
......
227 229
    }
228 230

  
229 231
///////////////////////////////////////////////////////////////////////////////////////////////////
230
// w,h - width and height of the input texture. MVP - Model-View-Projection matrix to apply to the
231
// texture; df - output FBO.
232 232

  
233
  synchronized void render(float w, float h, float[] mvp, DistortedOutputSurface surface)
233
  int postprocess(long time, DistortedOutputSurface surface)
234 234
    {
235
    mBlurProgram.useProgram();
236

  
237
    int radius = (int)mUniforms[0];
238
    if( radius>=MAX_BLUR ) radius = MAX_BLUR-1;
239
    computeGaussianKernel(radius);
235
    if( mNumEffects>0 && compute(time) )
236
      {
237
      mMainBuffer.setAsInput();
238

  
239
      Matrix.setIdentityM(mTmpMatrix, 0);
240
      Matrix.translateM(mTmpMatrix, 0, 0, 0, -surface.mDistance);
241
      Matrix.multiplyMM(mMVPMatrix, 0, surface.mProjectionMatrix, 0, mTmpMatrix, 0);
242

  
243
      float w = surface.mWidth;
244
      float h = surface.mHeight;
245

  
246
      mBlurProgram.useProgram();
247

  
248
      int radius = (int)mUniforms[0];
249
      if( radius>=MAX_BLUR ) radius = MAX_BLUR-1;
250
      computeGaussianKernel(radius);
251

  
252
      int offset = radius + radius*radius/4;
253
      radius = (radius+1)/2;
254
      for(int i=0; i<=radius; i++) mOffsets[i] = offsetsCache[offset+i]/h;
255

  
256
      GLES30.glUniform1fv( mWeightsH, radius+1, weightsCache,offset);
257
      GLES30.glUniform1i( mRadiusH, radius);
258
      GLES30.glUniform2f( mObjDH , w, h );
259

  
260
      mPostBuffer.resizeFast( (int)w, (int)h);
261
      mPostBuffer.setAsOutput(time);
262
      GLES30.glViewport(0, 0, (int)w, (int)h);
263

  
264
      Matrix.setIdentityM(mTmpMatrix, 0);
265
      Matrix.translateM(mTmpMatrix, 0, 0, 0, -mPostBuffer.mDistance);
266
      Matrix.multiplyMM(mMVPMatrix, 0, mPostBuffer.mProjectionMatrix, 0, mTmpMatrix, 0);
267

  
268
      // horizontal blur
269
      GLES30.glUniform1fv( mOffsetsH ,radius+1, mOffsets,0);
270
      GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix , 0);
271
      GLES30.glVertexAttribPointer(mBlurProgram.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadPositions);
272
      GLES30.glVertexAttribPointer(mBlurProgram.mAttribute[1], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadTextureInv);
273
      GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
274

  
275
      // vertical blur
276
      mPostBuffer.setAsInput();
277
      surface.setAsOutput(time);
278
      for(int i=0; i<=radius; i++) mOffsets[i] = offsetsCache[offset+i]/w;
279
      GLES30.glUniform1fv( mOffsetsH ,radius+1, mOffsets,0);
280
      GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
281
      }
240 282

  
241
    int offset = radius + radius*radius/4;
242
    radius = (radius+1)/2;
243
    for(int i=0; i<=radius; i++) mOffsets[i] = offsetsCache[offset+i]/h;
244

  
245
    GLES30.glUniform1fv( mWeightsH, radius+1, weightsCache,offset);
246
    GLES30.glUniform1i( mRadiusH, radius);
247
    GLES30.glUniform2f( mObjDH , w, h );
248

  
249
    mPostBuffer.resizeFast( (int)w, (int)h);
250
    mPostBuffer.setAsOutput();
251
    GLES30.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
252
    GLES30.glClear( GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);
253
    GLES30.glViewport(0, 0, (int)w, (int)h);
254

  
255
    Matrix.setIdentityM(mTmpMatrix, 0);
256
    Matrix.translateM(mTmpMatrix, 0, 0, 0, -mPostBuffer.mDistance);
257
    Matrix.multiplyMM(mMVPMatrix, 0, mPostBuffer.mProjectionMatrix, 0, mTmpMatrix, 0);
258

  
259
    // horizontal blur
260
    GLES30.glUniform1fv( mOffsetsH ,radius+1, mOffsets,0);
261
    GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mMVPMatrix , 0);
262
    GLES30.glVertexAttribPointer(mBlurProgram.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadPositions);
263
    GLES30.glVertexAttribPointer(mBlurProgram.mAttribute[1], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadTextureInv);
264
    GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
265

  
266
    mPostBuffer.setAsInput();
267
    surface.setAsOutput();
268

  
269
    GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight);
270

  
271
    for(int i=0; i<=radius; i++) mOffsets[i] = offsetsCache[offset+i]/w;
272

  
273
    // vertical blur
274
    GLES30.glUniform1fv( mOffsetsH ,radius+1, mOffsets,0);
275
    GLES30.glUniformMatrix4fv(mMVPMatrixH, 1, false, mvp , 0);
276
    GLES30.glVertexAttribPointer(mBlurProgram.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadPositions);
277
    GLES30.glVertexAttribPointer(mBlurProgram.mAttribute[1], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, 0, mQuadTextureInv);
278
    GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
283
    return mNumEffects;
279 284
    }
280 285

  
281 286
///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff