# OpenGL ES - gl.glOrthof



## Tschulz (8. Jul 2012)

Hallo!

Ich möchte eine Form darstellen, die aus verschiedenen Vierecken aufgebaut ist und habe begonnen einen ganz einfachen Code dafür zu schreiben. Jedoch wird das Objekt nicht angezeigt und ich kann den Fehler einfach nicht finden. Hat von euch jemand eine Idee?




```
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLSurfaceView;
import android.opengl.GLU;

import java.lang.Math;

public class CubeRenderer implements GLSurfaceView.Renderer {

	public CubeRenderer() {

		building = new Faces();
	}

	public void onDrawFrame(GL10 gl) {
		gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
		gl.glClearColor(0.0f, 0.5f, 0.5f, 1.0f);

		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
		gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
		
//		gl.glRotatef(mAngle, 1.0f, 0.0f, 0.0f);

		building.draw(gl);
		
//		mAngle += .4;

	}

	public void onSurfaceChanged(GL10 gl, int width, int height) {

		gl.glViewport(0, 0, width, height);
		gl.glMatrixMode(GL10.GL_PROJECTION);
		gl.glOrthof(9035f, 9078f, -22.63f, 45.63f, 2013f, 1970f);

	}

	public void onSurfaceCreated(GL10 gl, EGLConfig config) {

	}

	private Faces building;
	private float mAngle;

}
```

Wenn ich die auskommentierten Lines mit einbaue, dann wird dann taucht das Objekt immer wieder für einen Bruchteil einer Sekunde an verschiedenen Stellen auf und verschwindet wieder. 
Kann mir irgendjemand sagen, was ich hier falsch mache?? Vielen Dank.

Ach ja, der Vollständigkeit halber, hier ist die Klasse mit den Vertices. Wobei ich nicht glaube, dass das Problem dort liegt, da das Objekt ja wie gesagt, manchmal kurz aufflackert.


```
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;

import javax.microedition.khronos.opengles.GL10;
import javax.microedition.khronos.opengles.GL11;

public class Faces {

	public Faces()
	{
		float vertices[] = 
			{
				9055.85f, 	0f, 	2012.54f, 
				9055.85f, 	22.5f, 	2012.54f, 
				9067.8f, 	22.5f, 	1973.41f, 
				9067.8f, 	0f, 	1973.41f, 
				9045.29f, 	0f, 	2009.32f, 
				9045.29f, 	22.5f, 	2009.32f, 
				9055.85f, 	22.5f, 	2012.54f, 
				9055.85f, 	0f, 	2012.54f, 
				9046.3f, 	0f, 	2005.49f, 
				9046.3f, 	22.5f, 	2005.49f, 
				9045.29f, 	22.5f, 	2009.32f, 
				9045.29f, 	0f, 	2009.32f, 
				9053.84f, 	0f, 	2007.79f, 
				9053.84f, 	22.5f, 	2007.79f, 
				9046.3f, 	22.5f, 	2005.49f, 
				9046.3f, 	0f, 	2005.49f, 
				9056.19f, 	0f, 	2000.08f, 
				9056.19f, 	22.5f, 	2000.08f, 
				9053.84f, 	22.5f, 	2007.79f, 
				9053.84f, 	0f, 	2007.79f, 
				9048.65f, 	0f, 	1997.78f, 
				9048.65f, 	22.5f, 	1997.78f, 
				9056.19f, 	22.5f, 	2000.08f, 
				9056.19f, 	0f, 	2000.08f, 
				9057.06f, 	0f, 	1970.24f, 
				9057.06f, 	22.5f, 	1970.24f, 
				9048.65f, 	22.5f, 	1997.78f, 
				9048.65f, 	0f, 	1997.78f, 
				9067.8f, 	0f, 	1973.41f, 
				9067.8f, 	22.5f, 	1973.41f, 
				9057.06f, 	22.5f, 	1970.24f, 
				9057.06f, 	0f, 	1970.24f



			};
		
		byte maxColor=(byte)255;
		
		byte colors[]=
			{
				maxColor, maxColor, 0, maxColor,
				0, maxColor, maxColor, maxColor,
				0, 0, 0, maxColor,
				maxColor, 0, maxColor, maxColor,
				
				maxColor, 0, 0, maxColor,
				0, maxColor, 0, maxColor,
				0, 0, maxColor, maxColor,
				0, 0, 0, maxColor,
				
				maxColor, maxColor, 0, maxColor,
				0, maxColor, maxColor, maxColor,
				0, 0, 0, maxColor,
				maxColor, 0, maxColor, maxColor,
				
				maxColor, 0, 0, maxColor,
				0, maxColor, 0, maxColor,
				0, 0, maxColor, maxColor,
				0, 0, 0, maxColor,
				
				maxColor, maxColor, 0, maxColor,
				0, maxColor, maxColor, maxColor,
				0, 0, 0, maxColor,
				maxColor, 0, maxColor, maxColor,
				
				maxColor, 0, 0, maxColor,
				0, maxColor, 0, maxColor,
				0, 0, maxColor, maxColor,
				0, 0, 0, maxColor,
				
				maxColor, maxColor, 0, maxColor,
				0, maxColor, maxColor, maxColor,
				0, 0, 0, maxColor,
				maxColor, 0, maxColor, maxColor,
				
				maxColor, 0, 0, maxColor,
				0, maxColor, 0, maxColor,
				0, 0, maxColor, maxColor,
				0, 0, 0, maxColor
				
			};
		

		
		byte tfan1[] =
			{
				0,1,2,
				0,2,3
			};
		
		byte tfan2[] =
			{
				4,5,6,
				4,6,7
			};
		
		byte tfan3[] =
			{
				8,9,10,
				8,10,11
			};
		
		byte tfan4[] =
			{
				12,13,14,
				12,14,15
			};
		
		byte tfan5[] =
			{
				16,17,18,
				16,18,19
			};
		
		byte tfan6[] =
			{
				20,21,22,
				20,22,23
			};
		
		byte tfan7[] =
			{
				24,25,26,
				24,26,27
			};
		
		byte tfan8[] =
			{
				28,29,30,
				28,30,31
			};
		

		
	
		
		ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
		vbb.order(ByteOrder.nativeOrder());
		mFVertexBuffer = vbb.asFloatBuffer();
		mFVertexBuffer.put(vertices);
		mFVertexBuffer.position(0);
		
		mColorBuffer = ByteBuffer.allocateDirect(colors.length);
		mColorBuffer.put(colors);
		mColorBuffer.position(0);
		
		mTfan1 = ByteBuffer.allocateDirect(tfan1.length);
		mTfan1.put(tfan1);
		mTfan1.position(0);		
		
		mTfan2 = ByteBuffer.allocateDirect(tfan2.length);
		mTfan2.put(tfan2);
		mTfan2.position(0);	
		
		mTfan3 = ByteBuffer.allocateDirect(tfan3.length);
		mTfan3.put(tfan3);
		mTfan3.position(0);		
		
		mTfan4 = ByteBuffer.allocateDirect(tfan4.length);
		mTfan4.put(tfan4);
		mTfan4.position(0);	
		
		mTfan5 = ByteBuffer.allocateDirect(tfan5.length);
		mTfan5.put(tfan5);
		mTfan5.position(0);		
		
		mTfan6 = ByteBuffer.allocateDirect(tfan6.length);
		mTfan6.put(tfan6);
		mTfan6.position(0);			
		
		mTfan7 = ByteBuffer.allocateDirect(tfan7.length);
		mTfan7.put(tfan7);
		mTfan7.position(0);		
		
		mTfan8 = ByteBuffer.allocateDirect(tfan8.length);
		mTfan8.put(tfan8);
		mTfan8.position(0);	
			
	}
	
	public void draw(GL10 gl){
		
		gl.glVertexPointer(3, GL11.GL_FLOAT, 0, mFVertexBuffer);
		gl.glColorPointer(4, GL11.GL_UNSIGNED_BYTE, 0, mColorBuffer);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan1);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan2);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan3);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan4);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan5);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan6);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan7);
		gl.glDrawElements(GL11.GL_TRIANGLES, 3*2, GL11.GL_UNSIGNED_BYTE, mTfan8);
		

	}
	
	private FloatBuffer mFVertexBuffer;
	private ByteBuffer mColorBuffer;
	private ByteBuffer mTfan1;
	private ByteBuffer mTfan2;
	private ByteBuffer mTfan3;
	private ByteBuffer mTfan4;
	private ByteBuffer mTfan5;
	private ByteBuffer mTfan6;
	private ByteBuffer mTfan7;
	private ByteBuffer mTfan8;

}
```

VIELEN DANK FÜR EURE HILFE !!!


----------



## Marco13 (8. Jul 2012)

Am Ende von onSurfaceChanged solltest du in den MODELVIEW matrix mode wechseln. 
Und in der onDrawFrame-Methode wird auch immer weiter gedreht. OpenGL ist eine "State Machine": Wenn man etwas ändert, BLEIBT das geändert, bis man es wieder rückgängig macht. Eine Möglichkeit in diesem Fall wäre, in der onDrawFrame:

```
glPushMatrix();
glLoadIdentity();
glRotatef(...);
draw();
glPopMatrix();
```
Ob man das LoadIdentity braucht oder will muss man sich dann noch genauer überlegen.


----------



## Tschulz (9. Jul 2012)

Hey, vielen Dank für die Hinweise. Ich habe den Code dementsprechend verändert. Jedoch bleibt das Problem bestehen, dass mein Objekt nicht angezeigt wird, bzw. manchmal super schnell durch den Bildschirm flitzt.


----------



## Marco13 (12. Jul 2012)

Äh... das Objekt ist ja auch absurd weit rechts... Wenn es gedreht werden soll, dann doch vermutlich um SEIN Zentrum? glRotatef dreht erstmal um 0,0,0...


----------

