Hi!

Does anyone know how to solve this problem.

If I create a 3D plane and add a texture of size 512x512 I get an FPS of about 15 fps.
If I minimize the texture size to 256x256 I get around 20 fps.
I have been testing this on my HTC Magic.

Is there any way to somehow speed up the fps, using bigger textures??
The reason why I want a bigger texture is because the quality of the image is much better.

Can you post our code perhaps?
That seems really really slow.

This is practically my draw code.




I removed the top and bottom planes from the cube since I didn't need them for what I'm testing.
I have also tested to call gl11.glBindTexture(GL10.GL_TEXTURE_2D, 0);
on 2 of the planes to speed up performance.

Is it correct to do it like this?

What if I want to be able to change the textures on the planes when it rotates. Like it would be a list?

The problem is not your texture size.. at least not the only problem. You have 4 textures and you bind them in a single frame. This slows down the FPS, and you are showing just a cube. Image if you need to draw other stuff. To solve this you must bind as fewer textures as possible per frame. For the cube the smartest way is to have a single texture for all the faces, and using texture coordinates you can show on each face a different image. Next, for each face you set up all the buffers and call the render. Again, this is not good. You must make the cube a single array and render it in a single pass, not 4 or 6.

Remember:
- state changes are SLOW
- render calls are SLOW
- texture binds are SLOW

So you have to organize your data this way:

- group as many primitives as you can together in the same array, this way you will have fewer glDraw.. calls
- use as few textures as possible and do not call bind if the texture you need is already binded
- order your data to be drawn depending on textures

Also, try to reuse binded data.
For example, if you have to draw 100 cubes in different positions, you don't have to bind your data 100 times:

So for every cube you just call glTranslate and glDrawArrays. This will improve your fps.

Thanks Zorro

But if I want to be able to change the textures as I rotate. As it would be a list.
If I in total have like 20 images that I want to show.

I start with image1 on the front face of the cube. I rotate left and come to image2...rotate..image3 and so on.
How can I do this with the 20 images without getting such slow performance?

Maybe create a huge texture Atlas??

Please help.

You can create a huge texture atlas, but it would be difficult to update the atlas if one picture needs to be changed.

If your app is just the cube and nothing else, you can stick with your first implementation, four planes, each with it's own texture, which let's you add new pictures without affecting the others. You can speed up the rendering by making arrays for a single plane, centered in origin, bind the arrays, then render the cube using for each face a texture bind then translate and rotate. This way the only bottleneck will be the texture bind, which is acceptable i guess.

Hi Zorro!

I'm quite new at this.

Your wrote:

You can speed up the rendering by making arrays for a single plane, centered in origin, bind the arrays, then render the cube using for each face a texture bind then translate and rotate.

How in code do you mean I should do this?

What is the difference between that an my above method?

First, in your code you use GL11 and hardware buffers, but that is not going to help (in your case). That's because buffers help when you have large amounts of data, while your buffers contain only a small number of vertices. You can use plain GL10 arrays and the FPS should not go down.

In your code you have for each face:
- bind texture face
- setup arrays
- draw face

What am i saying is that you can get rid of 'setup arrays' part and just:

do once: setup arrays
do six times:
- bind texture
- transform face
- draw face

Now, how can you modify your code? I see you have PlaneVertBufferIndex1 for the first face. Make that a quad with the vertices in the following positions: (d,d,0) (d,-d,0) (-d,-d,0) (-d,d,0). D is the half of the face width. As you can see the face is in the XoY plane, the Z is always 0. Now you must draw all the faces using this buffer.

First, translate the modelview matrix to the point where the center of the cube will be.

gl.glLoadIdentity(); // reset matrix
gl.glTranslate (cubex, cubey, cubez);

If you want to rotate the cube, here is where you put your main rotation, around Y axis
gl.glRotatef( angle, 0,1,0);

Then bind the arrays once:
gl11.glBindBuffer(GL11.GL_ARRAY_BUFFER, PlaneVertBufferIndex1);
gl11.glVertexPointer(3, GL10.GL_FIXED, 0, 0);
gl11.glBindBuffer(GL11.GL_ARRAY_BUFFER, textureCoordBufferIndex);
gl11.glTexCoordPointer(2, GL11.GL_FIXED, 0, 0);
gl11.glBindBuffer(GL11.GL_ELEMENT_ARRAY_BUFFER, indexBufferIndex);

After that draw each face with these transformations:

// face 1 (right in front of the screen)
gl.glPushMatrix();
gl11.glBindTexture ...
gl.glTranslatef(0,0,d); // translate with 'd' towards the camera (on the Z axis), no rotation
gl11.glDrawElements(GL11.GL_TRIANGLES, 6, GL11.GL_UNSIGNED_SHORT, 0);
gl.glPopMatrix();

// face 2 (on the right)
gl11.glBindTexture ...
gl.glPushMatrix();
gl.glRotatef(90, 0,1,0); // rotate 90 degrees to the right
gl.glTranslatef(0,0,d); // translate 'd' on the same Z axis, which is now rotated
gl11.glDrawElements(GL11.GL_TRIANGLES, 6, GL11.GL_UNSIGNED_SHORT, 0);
gl.glPopMatrix();

// face 3 (on the left)
gl11.glBindTexture ...
gl.glPushMatrix();
gl.glRotatef(-90, 0,1,0); // rotate 90 degrees to the right
gl.glTranslatef(0,0,d); // translate 'd' on the same Z axis, which is now rotated
gl11.glDrawElements(GL11.GL_TRIANGLES, 6, GL11.GL_UNSIGNED_SHORT, 0);
gl.glPopMatrix();

// face 4 (in the back)
gl11.glBindTexture ...
gl.glPushMatrix();
gl.glRotatef(180, 0,1,0); // rotate 180 degrees to the right
gl.glTranslatef(0,0,d); // translate 'd' on the same Z axis, which is now rotated
gl11.glDrawElements(GL11.GL_TRIANGLES, 6, GL11.GL_UNSIGNED_SHORT, 0);
gl.glPopMatrix();

With this you have all the faces drawn with the buffers binded only once, at the beginning.
You can try to implement this, it should speed up the cube. If there are problems, let me know.

Thanks a lot Zorro.
I will send you a mail as soon as I have tried this.