With the same object3D and the same lookAt-vector, If i move camera out by Camera.moveCamera(CAMERA_MOVEOUT, distance); some abnormal things will happen:

1, the aliasing between boundaries will be rather obvious.

2, some transparency issues(I'm not very sure, but the appearance seems like that), i.e, some parts of an opacity object3D will be transparent and the object3D behind it will be visible.

3, when rotating object3D/camera, the aliasing between boundaries is rather obvious.

Some images:

1, With the near camra,  the aliasing is not obvious:



2, With the far camera, the aliasing is obvious:



3, With the rotating, the aliasing is obvious:

 

I want to make the special effect like that:





What i do:
1,  Render skeleton animation, assume the frame sequences are  1\2\3\4\5\6...
2,  When rendering frame-1, first render to frameBuffer, then change the transparency  of obj3d, render frame-1 to a texture.
3,  When rendering frame-2, first render to frameBuffer, then blit the last render-target-texture(frame-1). So there are 2 obj3ds in frameBuffer now, one is frame-1 with  transparency, one is frame-2. then change the transparency  of obj3d, render frame-2 to a texture.
4, Goto step 3.

Problem:
When blitting, i got an black-screen. OpenglES 2.0, Code:

//onDrawFrame

frameBuffer.clear();
world.renderScene(frameBuffer);
world.draw(frameBuffer);

if(mTexture == null){
      mTexture = new Texture(frameBuffer.getWidth(), frameBuffer.getHeight(), 100);
      Log.d(D.TAG, "texture width: " + mTexture.getWidth());
      Log.d(D.TAG, "texture height: " + mTexture.getHeight());
}
else {
      frameBuffer.blit(mTexture, 0, 0, 0, 0, frameBuffer.getWidth(), frameBuffer.getHeight(), FrameBuffer.TRANSPARENT_BLITTING);
}

obj.setTransparency(100);  // Adjust Config, so transparency value is between 0 - 255;
frameBuffer.setRenderTarget(mTexture);
world.draw(frameBuffer);

frameBuffer.removeRenderTarget();
obj.setTransparency(-1);
 

What does the 4bpp mean? 4 bits per pixel? If so, what's the pixel format? 1111?

Or it means 4 bits per pixel-component?  i.e 4444.

Texture.defaultTo4bpp defined the pixel format of textures in GPU, right? 

The java-doc of jPCT-AE doesn't say that, but a run time exception was thrown when running:

01-28 17:33:43.910: E/AndroidRuntime(2477): java.lang.RuntimeException: Wireframe rendering isn't supported ATM!

I want to use this method to do some special effects, could you add it? Thanks.

Another question: what's the "ATM" mean? At the moment?

I want to decrease the memory usage and the disk-space of .bones file.

What should i do to get the best result?

1, decrease the total frames of animation.

2, decrease the vertexes of the model.

3, decrease the joints of the model.

My obj has 1818 frames, 4947 vertexes, 18 joints.

The FrameBuffer.resize() method is just what i needed! Thanks!

 And when will you add this to an new version jar?

I am not clear when will the OpenGL context  lose and what the system do when the context lose. Please give me some advice.

What i want to do is that:
When window size changed, the world will auto-scale to the right size but without unloading the textures from gpu because i don't want to the delay.

If i change code to an empty implement:

// in class which implements Renderer
  public void onSurfaceChanged(GL10 gl, int width, int height)  {
    Log.d("jPCT-AE", "3d Renderer Surface Changed: " + width + ", " + height);
    Log.d("jPCT-AE", "3d Renderer Surface Changed: update frameBuffer");
   
  }
When the window size changed(64*64 to 128*128), the world didn't scale to 128*128, but all are rendering fine.

WindowSize: 64*64 -> 128*128

1, Before change code: the world will scale to larger after a delay

2, After change code: the world won't scale, but rendering fine, and there is almost little delay.

I am not clear if the OpenGL context will lose when the window(surface) size changed?  Or only when the surface destroyed, the context  lost.

I tried this: GLSurfaceView.setVisiable(GONE); 

Then the view will gone and the surface will destroy(GLSurfaceView.onDestroyed()), the OpenGL context seems to be destroyed,  but when i "GLSurfaceView.setVisiable(VISABLE)", things happened like this:

GLSurfaceView.surfaceCreate() -> GLSurfaceView.surfaceChanged() -> Renderer.onSurfaceCreate()(the method has an empty implement) -> Renderer.onSurfaceChanged()(the method has an empty implement)  -> onDrawFrame()

And this situation looks like the one of "window size changed": the world didn't scale, but render fine. 

Full codes:

// in class which implements Renderer

public void onSurfaceCreated(GL10 gl, EGLConfig config)
{
    Log.d("jPCT-AE", "3d Renderer Surface Created");
}

 public void onSurfaceChanged(GL10 gl, int width, int height)
{
    Log.d("jPCT-AE", "3d Renderer Surface Changed: " + width + ", " + height);

    if(mFirstEntry)  // mFirstEntry wiil change to false in onDrawFrame
    {
      initFrameBuffer(gl, width, height);
      getGameContext().setFrameBuffer(mFrameBuffer);
      initFpsShown(); // rely on initFramebuffer
      mGameLogic.onCreate();
    }
//  else if(getGameContext().getGameConfig().canWindowScale())
//  {
//    Log.d("jPCT-AE", "3d Renderer Surface Changed: update frameBuffer");
//    mFrameBuffer.dispose();
//    initFrameBuffer(gl, width, height);
//    getGameContext().setFrameBuffer(mFrameBuffer);
//    initFpsShown();
//  }

    mGameLogic.onResize(mFrameBuffer.getWidth(), mFrameBuffer.getHeight());
}