glPushMatrix()
		glTranslated(Self.X, Self.Y, 0)

		glRotated(Self.angle, 0, 0, 1)
		glTranslated(Self.drehpunkt[0], Self.drehpunkt[1], 0)
		
		glBegin(GL_QUADS)
			For Local i:Int = 0 Until Len(Self.koordArr) Step 2
				glVertex2d(Self.koordArr[i], Self.koordArr[i + 1])
			Next
		glEnd()
		glPopMatrix()

		'Versuch 2: Die vertexposis direkt errechnen!
		Local x:Float, y:Float, z:Float, w:Float
		
		glColor3f(1.0, 0.6, 0)
		
		glBegin(GL_QUADS)
		
		For Local i:Int = 0 Until 4
			Local xO:Float = Self.koordArr[i * 2]
			Local yO:Float = Self.koordArr[i * 2 + 1]
			Local zO:Float = 0.0
			Local wO:Float = 1.0
			
			x = (xO * matrix[0]) + (yO * matrix[4]) + (zO * matrix[8]) + (wO * matrix[12])
			y = (xO * matrix[1]) + (yO * matrix[5]) + (zO * matrix[9]) + (wO * matrix[13])
			z = (xO * matrix[2]) + (yO * matrix[6]) + (zO * matrix[10]) + (wO * matrix[14])
			w = (xO * matrix[3]) + (yO * matrix[7]) + (zO * matrix[11]) + (wO * matrix[15])
			
			Print "X: " + x + " Y: " + y + " Z: " + z + " W: " + w
			glVertex2d(x, y)', z)', w)
		Next
		
		glEnd()
		glColor3f(1, 1, 1)

Code: [AUSKLAPPEN] [EINKLAPPEN]

x_neu := x*a[1,1] + y*a[1,2] + z*a[1,3] + w*a[1,4]
          {Koeffizienten aus der ersten Zeile der Matrix}
y_neu := x*a[2,1] + y*a[2,2] + z*a[2,3] + w*a[2,4]
          {Koeffizienten aus der zweiten Zeile der Matrix}
z_neu := x*a[3,1] + y*a[3,2] + z*a[3,3] + w*a[3,4]
          {Koeffizienten aus der dritten Zeile der Matrix}
w_neu := x*a[4,1] + y*a[4,2] + z*a[4,3] + w*a[4,4]
          {Koeffizienten aus der letzten Zeile der Matrix}

glGetDoublev(GL_PROJECTION_MATRIX, Varptr(matrix[0]))

Type TStein
	Field koordArr:Float[] = [- 2.5, -25.0, -2.5, 25.0, 2.5, -25.0, 2.5, 25.0]
	Field drehpunkt:Float[] = [0.0, 0.0] 'der punkt, um den gedreht wird! später evtl ein index für einen der Vertixes.
	
	Field X:Int = 0 'ZentrumX
	Field Y:Int = 0 'ZentrumY
	
	Field angle:Float = 0
	
	Field lastMatrix:Double[] = New Double[16]
	
	Method CheckCollision:Int(With:TStein)

	End Method
	
	Method Draw()
		glPushMatrix()
		glTranslated(Self.X, Self.Y, 0)
		
		glRotated(Self.angle, 0, 0, 1)
		glTranslated(Self.drehpunkt[0], Self.drehpunkt[1], 0)
		
		'alles fertig!
		glGetDoublev(GL_MODELVIEW_MATRIX, Varptr(Self.lastMatrix[0]))
		'matrix sollte nun in Self.lastmatrix[] sein!

		'Zeichnen des steins!
		glBegin(GL_TRIANGLE_STRIP)
			For Local i:Int = 0 Until Len(Self.koordArr) Step 2
				glVertex2d(Self.koordArr[i], Self.koordArr[i + 1])
			Next
		glEnd()
		glPopMatrix()
		'Matrix ist zurückgesetzt!
	End Method
	
	Method DrawCollRect()
		'Da dies die Collision Lines darstellt, rot einfärben!
		glColor3f(1, 0, 0)
		
		'locals, um sinnloses 'öfters erstellen' in der Forschleife zu vermeiden.
		Local xO:Float, yO:Float, zO:Float = 0, wO:Float = 1
		Local x:Float, y:Float

		'Zeichnen!
		glBegin(GL_LINE_LOOP)
			Local i:Int = 0
			For Local cnt:Int = 0 Until 4
				'Temporäres vertauschen, da ich meine koordinatne umgestellt habe. Später entfällt dies:
				i = cnt
				If i = 2 Then
					i = 3
				ElseIf i = 3 Then
					i = 2
				End If
				'/Temp tausch. Grund ist: Vertex 3 und 4 sind im index getauscht worden, LineLoop hat daraus ein haus vom Nikolaus gemacht :)
				
				xO = Self.koordArr[i * 2] 'Holen der X koordinate aus dem eigenen Array!
				yO = Self.koordArr[i * 2 + 1] 'Hole der Y koordinate aus dem eigenen Array!
				
				' Matrix mit dem PositoinsVektor multiplizieren - glaube ich *g*
				x = (xO * Self.lastMatrix[0]) + (yO * Self.lastMatrix[4]) + (zO * Self.lastMatrix[8]) + (wO * Self.lastMatrix[12])
				y = (xO * Self.lastMatrix[1]) + (yO * Self.lastMatrix[5]) + (zO * Self.lastMatrix[9]) + (wO * Self.lastMatrix[13])
				
				'punkt setzen!
				glVertex2d(x, y)
			Next
		glEnd()
		'Feddich, zurücksetzen bitte.
		glColor3f(1, 1, 1)
	End Method
End Type

Function StartOrthoGL(Width:Int, Height:Int, depth:Int = 0, hertz:Int = 60)
	GLGraphics(Width, Height, depth, hertz) 'OpenGL fenster initialisieren - danke blitzmax! :)
	
	glMatrixMode(GL_PROJECTION)  ' Projektionsmatrix auswählen.
	glLoadIdentity() 'Zurücksetzen der Matrix
	
	glOrtho(-ResX / 2, ResX / 2, ResY / 2, -ResY / 2, 0, 128)
	
	glMatrixMode(GL_MODELVIEW) 'Modelview Matrix auswählen. Möge das zeichnen beginnen!
End Function