2D-Grafik Punkte um Mittelpunkt drehen

[felixpk]

Schönen guten Abend zusammen,
als aller erstes werde ich mein Problem mal mit folgenden Bild verdeutlichen:

Mein Problem ist, dass ich nicht weiß wie ich die Punkte(A,B,C,D) um den Mittelpunkt des Autos drehen kann.

Nebenbei: Die 4 Punkte die ich erstellt habe, dienen als Start- und Endpunkt für Linien.
Ich mache das so, weil die Line-Klasse eine intersection-Methode hat.
Das funktioniert auch 1A! Nur eben an der falschen Stelle.

Ich habe mich mal an AffineTransform gewagt, das hat aber leider nur Komische sachen gemacht 🙁

Ich hoffe Ihr versteht das Problem, und habt eine Lösung für mich! :rtfm::toll:

Achja hier noch einen Ausschnitt aus dem Code, was das ganze nochmal verdeutlichen sollte.

        A.move((int)position.x-width/2, (int)position.y-height/2);
		B.move((int)position.x+width/2, (int)position.y-height/2);
		C.move((int)position.x+width/2, (int)position.y+height/2);
		D.move((int)position.x-width/2, (int)position.y+height/2);

		lineAB.setLine(A, B);

		lineBC.setLine(B, C);

		lineCD.setLine(C, D);

		lineDA.setLine(D, A);

Und hier das was ich mit Affinetransform versucht habe:

        AffineTransform at = new AffineTransform();
		at.translate(position.x, position.y);
		at.rotate(Math.toRadians(carHeading));
		at.translate(-position.x, -position.y);
		at.transform(A, A);

MfG, Felix

 

[Marco13]

So ganz hab' ich's nicht kapiert - das weiße (d.h. das Auto) drehst du ja auch schon?! (BTW: Bei AffineTransform gibt's auch diese Methode AffineTransform (Java Platform SE 6) die die geposteten Schritte in einem macht)

 

[felixpk]

Erstmal vielen Dank für deine Antwort,

ja diese Methode habe ich auch schon ausprobiert!
Da das auch nicht geklappt hat, wollte ich einfach "ein bisschen mehr Kontrolle" über die Sache haben, und habe es manuell gemacht.

Das Problem ist nur, das dass weiße Quadrat die openGL interne rotationsmethode benutzt.
Die kann ich ja nur leider nicht auf die Vertexes der Boundingbox anwenden, da diese ja nur die Verbildlichung der Punkte + Lines ist. Die Vertexes an sich haben ja keine intersection-Methode, die Lines, die aus den Punkten entstehen aber schon.

Ich hoffe jetzt ist es ein wenig klarer?

EDIT:

Ich habe mir gerade etwas überlegt, wenn du dich mit lwjgl auskennst, kannst du mir vielleicht helfen.
Wenn ich die Koordinaten des Autos habe ( Weißes Quadrat ), hätte ich ja absolut kein Problem mehr.
Dann könnte ich die Koordinaten der "GL11.glVertex2f();" auf die der Boundingbox übertragen.

Kennt jemand eine Möglichkeit die Koodinaten aus einem openGL vertex zu bekommen? :rtfm:

MfG Felix

 

[pappawinni]

at.rotate(Math.toRadians(carHeading));

"carHeading" hört sich so an, als würde das die Richtung des Autos absolut anzeigen.
D.h. meinetwegen, immer wenn Auto nach unten fährt ist carHeading sagen wir 90°.. keine Ahnung, immer der gleiche Wert halt.
Ein rotate macht aber eine relative Drehung. Jedesmal wenn du das neu rechnest,
würdest du damit also dein Kästchen um weitere 90° drehen. Das hätte dann wenig Sinn.
Wäre das so, müsstest entweder nur die Richtungsänderung erfassen und nur die anwenden, oder aus der aktuellen Ausrichtung die erforderliche Rotation berechnen, um die entsprechende Ausrichtung zu erhalten.
[EDIT]Vielleicht kannst du die Transformation auch einfach auf die "Nulllage" des Kästchens anwenden, statt auf der aktuellen Transformation.[/EDIT]

 

[felixpk]

Puh, das ist in der Tat ziemlich schwer zu erklären, aber das hat nichts mit dem Problem zutun.
Ich würde sagen ich Mache mal ein Video von dem was passiert und werde dann auch mal den Code hochladen.

(ich weiß das carHeading absolut ist, und das falsch ist, hatte bissher nur keine lust mich mit der Berechnung zu beschäftigen)

import java.awt.Point;
import java.awt.geom.AffineTransform;
import java.util.Vector;

import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector2f;
public class Car {

	private Vector2f position;
	private int width, height;
	private float acceleration, deceleration;
	private float maxVelocity;
	private float drag;
	private float carHeading;
	private float carVelocity;
	private float steerVelocity;
	private float steerAngle;
	private float maxSteeringAngle;
	private float wheelBase;

	private boolean frontDirection = true;

	Line lineAB,lineBC,lineCD,lineDA;
	Point A,B,C,D;

	private Vector<Line> lines = new Vector<Line>();

	public Car(int x, int y, int width, int height, float wheelBase, float carHeading, float acceleration, float deceleration, float maxVelocity, float drag, float steerVelocity, float maxSteeringAngle) {
		this.position = new Vector2f(x+width/2, y+height/2);
		this.width = width;
		this.height = height;
		this.wheelBase = wheelBase;
		this.carHeading = carHeading;
		this.acceleration = acceleration;
		this.deceleration = deceleration;
		this.maxVelocity = maxVelocity;
		this.drag = drag;
		this.steerVelocity = steerVelocity;
		this.maxSteeringAngle = maxSteeringAngle;
		this.steerAngle = 0;

		setBoundingBox();
	}

	public void setBoundingBox(){

		A = new Point((int)position.x-width/2,(int)position.y-height/2);
		B = new Point((int)position.x+width/2,(int)position.y-height/2);
		C = new Point((int)position.x+width/2,(int)position.y+height/2);
		D = new Point((int)position.x-width/2,(int)position.y+height/2);

		lineAB = new Line();
		lineAB.setLine(A, B);
		lines.addElement(lineAB);

		lineBC = new Line();
		lineBC.setLine(B, C);
		lines.addElement(lineBC);

		lineCD = new Line();
		lineCD.setLine(C, D);
		lines.addElement(lineCD);

		lineDA = new Line();
		lineDA.setLine(D, A);
		lines.addElement(lineDA);
	}

	public boolean intersects(Vector<Line> objLines){
		for (int i = 0; i < objLines.size(); i++) {
			for (int j = 0; j < lines.size(); j++) {
				if(objLines.get(i).intersectsLine(lines.get(j))){
					return true;
				}
			}
		}
		return false;
	}

	public Vector<Line> getLines(){
		return lines;
	}

	public Vector2f getPosition() {
		return position;
	}

	public int getWidth() {
		return width;
	}

	public int getHeight() {
		return height;
	}

	public float getAcceleration() {
		return acceleration;
	}

	public float getDeceleration() {
		return deceleration;
	}

	public float getWheelBase() {
		return wheelBase;
	}

	public float getCarHeading() {
		return carHeading;
	}

	public void setCarHeading(float carHeading) {
		this.carHeading = carHeading;
	}

	public float getCarVelocity() {
		return carVelocity;
	}

	public void setCarVelocity(float carVelocity) {
		this.carVelocity = carVelocity;
	}

	public float getSteerVelocity() {
		return steerVelocity;
	}

	public float getMaxSteeringAngle() {
		return maxSteeringAngle;
	}

	public float getSteerAngle() {
		return steerAngle;
	}

	public void setSteerAngle(float steerAngle) {
		this.steerAngle = steerAngle;
	}

	public boolean isFrontDirection() {
		return frontDirection;
	}

	public void setFrontDirection(boolean frontDirection) {
		this.frontDirection = frontDirection;
	}

	public void setPosition(Vector2f position) {
		this.position = position;
	}

	public float getDrag() {
		return drag;
	}

	public float getMaxVelocity() {
		return maxVelocity;
	}

	public String toString() {
		return "Acc: " + acceleration + " Vel: " + carVelocity + " MaxVel:" + maxVelocity; 
	}

	public void show(){
		
		
		AffineTransform at = new AffineTransform();
		at.translate(position.x, position.y);
		at.rotate(Math.toRadians(carHeading));
		at.translate(-position.x, -position.y);
		at.transform(A, A);
		at.transform(B, B);
		at.transform(C, C);
		at.transform(D, D);
		
//		A.move((int)position.x-width/2, (int)position.y-height/2);
//		B.move((int)position.x+width/2, (int)position.y-height/2);
//		C.move((int)position.x+width/2, (int)position.y+height/2);
//		D.move((int)position.x-width/2, (int)position.y+height/2);

		lineAB.setLine(A, B);

		lineBC.setLine(B, C);

		lineCD.setLine(C, D);

		lineDA.setLine(D, A);
		
		
		// Wheel matrix
		GL11.glColor3f(0f, 255f, 255f);

		GL11.glPushMatrix();

		GL11.glTranslatef(getPosition().x, getPosition().y, 0);
		GL11.glRotatef((float)Math.toDegrees(getCarHeading()), 0f, 0f, 1f);
		GL11.glTranslatef(-getPosition().x, -getPosition().y, 0);

		GL11.glTranslatef(getPosition().x + (getWheelBase()/2), getPosition().y - (getHeight()/2) + 7, 0);
		GL11.glRotatef((float)Math.toDegrees(getSteerAngle()), 0f, 0f, 1f);
		GL11.glTranslatef(-(getPosition().x + (getWheelBase()/2)), -(getPosition().y - (getHeight()/2) + 7), 0);

		GL11.glBegin(GL11.GL_QUADS);
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) - 10, getPosition().y - (getHeight()/2));
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) + 10 , getPosition().y - (getHeight()/2));
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) + 10 , getPosition().y - (getHeight()/2) + 10);
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) - 10, getPosition().y - (getHeight()/2) + 10);
		GL11.glEnd();

		GL11.glPopMatrix();

		GL11.glColor3f(0f, 255f, 255f);

		GL11.glPushMatrix();

		GL11.glTranslatef(getPosition().x, getPosition().y, 0);
		GL11.glRotatef((float)Math.toDegrees(getCarHeading()), 0f, 0f, 1f);
		GL11.glTranslatef(-getPosition().x, -getPosition().y, 0);

		GL11.glTranslatef(getPosition().x + (getWheelBase()/2), getPosition().y + (getHeight()/2) - 7, 0);
		GL11.glRotatef((float)Math.toDegrees(getSteerAngle()), 0f, 0f, 1f);
		GL11.glTranslatef(-(getPosition().x + (getWheelBase()/2)), -(getPosition().y + (getHeight()/2) - 7), 0);

		GL11.glBegin(GL11.GL_QUADS);
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) - 10, getPosition().y + (getHeight()/2));
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) + 10 , getPosition().y + (getHeight()/2));
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) + 10 , getPosition().y + (getHeight()/2) - 10);
		GL11.glVertex2f(getPosition().x + (getWheelBase()/2) - 10, getPosition().y + (getHeight()/2) - 10);
		GL11.glEnd();

		GL11.glPopMatrix();

		// Wheel matrix end
		// Car matrix

		GL11.glColor3f(255f, 255f, 255f);
		GL11.glPushMatrix();
		GL11.glTranslatef(getPosition().x, getPosition().y, 0);
		GL11.glRotatef((float)Math.toDegrees(getCarHeading()), 0f, 0f, 1f);
		GL11.glTranslatef(-getPosition().x, -getPosition().y, 0);

		GL11.glBegin(GL11.GL_QUADS);
		GL11.glVertex2f(getPosition().x - getWidth()/2, getPosition().y - getHeight()/2);
		GL11.glVertex2f(getPosition().x + getWidth()/2, getPosition().y - getHeight()/2);
		GL11.glVertex2f(getPosition().x + getWidth()/2, getPosition().y + getHeight()/2);
		GL11.glVertex2f(getPosition().x - getWidth()/2, getPosition().y + getHeight()/2);
		GL11.glEnd();
		GL11.glPopMatrix();
		
		// BOUND

		GL11.glColor3f(0f, 255f, 255f);
		GL11.glBegin(GL11.GL_QUADS);
		GL11.glVertex2f(A.x,A.y);
		GL11.glVertex2f(B.x,B.y);
		GL11.glVertex2f(C.x,C.y);
		GL11.glVertex2f(D.x,D.y);
		GL11.glEnd();
		GL11.glPopMatrix();

		// Car matrix end

		// Refresh Bounds
		
		

		// Refresh Bounds end
	}
}

package de.felix.pk.opengl;

import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
import static org.lwjgl.opengl.GL11.glDisable;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glMatrixMode;
import static org.lwjgl.opengl.GL11.glOrtho;
import static org.lwjgl.opengl.GL11.glViewport;

import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector2f;

public class GameTest {

	private final int WIDTH = 800;
	private final int HEIGHT = 600;
	
	private long lastFrame;


	Obstacle obs = new Obstacle(50, 50, 300, 500,0f,100f,100f);
	Obstacle obs2 = new Obstacle(50, 50, 500, 500,0f,255f,255f);
	Car car = new Car(0, 0, 100, 50, 80, 0, 0.001f, 0.0015f, 0.2f, 0.0001f, 0.01f, (float)Math.toRadians(50));
	
	public GameTest(){
		start();
	}

	public void start(){
		try{
			Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
			Display.create();
		}catch(LWJGLException e){
			e.printStackTrace();
		}

		initGl();
		getDelta();

		while(!Display.isCloseRequested()){
			int delta = getDelta();
			update(delta);
			renderGl();
			Display.update();
			Display.sync(100);
		}

		Display.destroy();
	}

	private void renderGl() {
		GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

		// Obstacles
		obs.show();
		obs2.show();

		//car
		car.show();
	}

	private void update(int delta) {

		if(car.getCarVelocity() - car.getDrag() > 0){
			car.setCarVelocity(car.getCarVelocity() - car.getDrag());
		}

		// Shift

		if(Keyboard.isKeyDown(Keyboard.KEY_LCONTROL)){
			car.setFrontDirection(false);
		}

		if(Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)){
			car.setFrontDirection(true);
		}

		// Shift end

		if(Keyboard.isKeyDown(Keyboard.KEY_UP)){
			if(car.isFrontDirection()){
				if(car.getCarVelocity() + car.getAcceleration() < car.getMaxVelocity()){
					car.setCarVelocity(car.getCarVelocity() + car.getAcceleration());
				}
			}else{
				car.setCarVelocity(car.getCarVelocity() - car.getAcceleration());
			}
		}

		if(Keyboard.isKeyDown(Keyboard.KEY_DOWN)){
			if(car.isFrontDirection()){
				if(car.getCarVelocity() - car.getDeceleration() > 0){
					car.setCarVelocity(car.getCarVelocity() - car.getDeceleration());
				}else{
					car.setCarVelocity(0);
				}
			}else{
				if(car.getCarVelocity() + car.getDeceleration() < 0){
					car.setCarVelocity(car.getCarVelocity() + car.getDeceleration());
				}else{
					car.setCarVelocity(0);
				}
			}
		}

		if(Keyboard.isKeyDown(Keyboard.KEY_LEFT)){
			if(car.getSteerAngle() - car.getSteerVelocity() > -car.getMaxSteeringAngle()){
				car.setSteerAngle(car.getSteerAngle() - car.getSteerVelocity());
			}
		}

		if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)){
			if(car.getSteerAngle() + car.getSteerVelocity() < car.getMaxSteeringAngle()){
				car.setSteerAngle(car.getSteerAngle() + car.getSteerVelocity());
			}
		}

		// Car update


		float frontWheelX = (float) (car.getPosition().x + car.getWheelBase() / 2 * Math.cos(car.getCarHeading()));
		float frontWheelY = (float) (car.getPosition().y + car.getWheelBase() / 2 * Math.sin(car.getCarHeading()));

		float backWheelX = (float) (car.getPosition().x - car.getWheelBase() / 2 * Math.cos(car.getCarHeading()));
		float backWheelY = (float) (car.getPosition().y - car.getWheelBase() / 2 * Math.sin(car.getCarHeading()));


		backWheelX += car.getCarVelocity() * delta * Math.cos(car.getCarHeading());
		backWheelY += car.getCarVelocity() * delta * Math.sin(car.getCarHeading());

		frontWheelX += car.getCarVelocity() * delta * Math.cos(car.getCarHeading() + car.getSteerAngle());
		frontWheelY += car.getCarVelocity() * delta * Math.sin(car.getCarHeading() + car.getSteerAngle());

		car.setPosition(new Vector2f((frontWheelX + backWheelX) / 2, (frontWheelY + backWheelY) / 2));

		car.setCarHeading((float) Math.atan2( frontWheelY - backWheelY , frontWheelX - backWheelX));
		// Car update end
		
		if(car.intersects(obs.getLines())){
			System.out.println("INTERSECTION");
		}
	}

	private void initGl() {
		glDisable(GL_DEPTH_TEST);

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();

		glOrtho(0, 800, 600, 0, -1, 1);
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glViewport(0, 0, 800, 600);
	}

	public int getDelta(){
		long time = getTime();
		int delta = (int)(time - lastFrame);
		lastFrame = time;
		return delta;
	}

	public long getTime(){
		return (Sys.getTime() * 1000) / Sys.getTimerResolution();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new GameTest();
	}
}

Hier mal die 2 Klassen

MfG Felix

 

[Marco13]

Ich kapier's immer noch nicht ... du wendest die GL-Matrizen an ("Car matrix"), machst dann ein Pop und malst die Bounds - praktisch untransformiert. Wenn du auf die Bounds die gleiche Matrix anwenden würdest (rotate(angle,x,y)), sollten auch die gleichen Punkte rauskommen. Kann man da ein KSKB basteln?

 

[felixpk]

Wenn du lwjgl hast, dann ja.

Das Problem ist das die Boundingbox rein garnichts mit openGl zutun hat 🙁
Die Boundingbox besteht ja aus 4 Line's die aus 4 Punkten gebildet werden (java.awt)
Okay egal: ich werde jetzt das Szenarion mal komplett "durchspielen":

1) Auto wird in der Hauptklasse erzeugt:

Car car = new Car(0, 0, 100, 50, 80, 0, 0.001f, 0.0015f, 0.2f, 0.0001f, 0.01f, (float)Math.toRadians(50));

Die Parameter sind größtenteils Fahrverhaltensparameter und sowas wie Größe und Reifenabstand ( Hier eigentlich nicht wichtig )

2) Die Klasse Car hat eine Methode: setBoundingBox() die im konstruktor aufgerufen wird:

public void setBoundingBox(){

		A = new Point((int)position.x-width/2,(int)position.y-height/2);
		B = new Point((int)position.x+width/2,(int)position.y-height/2);
		C = new Point((int)position.x+width/2,(int)position.y+height/2);
		D = new Point((int)position.x-width/2,(int)position.y+height/2);
		

		lineAB = new Line();
		lineAB.setLine(A, B);
		lines.addElement(lineAB);

		lineBC = new Line();
		lineBC.setLine(B, C);
		lines.addElement(lineBC);

		lineCD = new Line();
		lineCD.setLine(C, D);
		lines.addElement(lineCD);

		lineDA = new Line();
		lineDA.setLine(D, A);
		lines.addElement(lineDA);
	}

3) Jetzt wird in der Methode show() der openGL aufruf gemacht:

GL11.glColor3f(255f, 255f, 255f);
		GL11.glPushMatrix();
		GL11.glTranslatef(getPosition().x, getPosition().y, 0);
		GL11.glRotatef((float)Math.toDegrees(getCarHeading()), 0f, 0f, 1f);
		GL11.glTranslatef(-getPosition().x, -getPosition().y, 0);

		GL11.glBegin(GL11.GL_QUADS);
		GL11.glVertex2f(getPosition().x - getWidth()/2, getPosition().y - getHeight()/2);
		GL11.glVertex2f(getPosition().x + getWidth()/2, getPosition().y - getHeight()/2);
		GL11.glVertex2f(getPosition().x + getWidth()/2, getPosition().y + getHeight()/2);
		GL11.glVertex2f(getPosition().x - getWidth()/2, getPosition().y + getHeight()/2);
		GL11.glEnd();
		GL11.glPopMatrix();

das ist nur ein kleiner Teil des ogl-Teils.

4) Hier wird jetzt die BoundingBox aus den oben erzeugten Punkten(Point2D) gerendert:

// BOUND

		GL11.glColor3f(0f, 255f, 255f);
		GL11.glBegin(GL11.GL_QUADS);
		GL11.glVertex2f(A.x,A.y);
		GL11.glVertex2f(B.x,B.y);
		GL11.glVertex2f(C.x,C.y);
		GL11.glVertex2f(D.x,D.y);
		GL11.glEnd();
		GL11.glPopMatrix();

Jetzt brauche ich nur noch eine Methode die diese Punkte, genauso wie es GL11 mit den vertices macht, dreht.

Ich habe mir also eben die Point2D Schnitstellenbeschreibung durchgelesen und bin zufälligerweise auf math.geom2d.Point2D gestoßen(!)
Dort gibt es die Methode Rotate (+ rotate um einen Mittelpunkt :toll::applaus🙂
Wenn ich versuche das zu importen, bzw mit Point2D auf eine Rotate-Methode zuzugreifen klappt das einfach nicht. Und ich kann mir nicht erklären warum.

Ich hoffe ihr versteht jetzt mein Problem und oder könnt mir mit dieser math.geom2d.Point2D klasse helfen ... ?

MfG Felix!

 

[JohannisderKaeufer]

Zum Drehen eignen sich meiner Meinung nach Polarkoordinten hervorragend.

Polarkoordinaten ? Wikipedia

Polarkoordinate ist ausgehend von einem Nullpunkt eine Entfernung mit einem Winkel.

Um eine Drehung hinzubekommen muß nur der Winkel verändert werden.

Als Beispiel:
Der Punkt (4;3) soll um den Punkt (1;1) um 10 Grad gedreht werden.

(1;1) ist der Nullpunkt, somit ist ein Vektor der davon ausgeht und zu (4;3) führt
(3;2).

(3;2) wird in Polarkoordinaten umgerechnet.

Theta = Math.arctan(2;3);
Länge = Math.sqrt(3*3+2*2);

Drehung
Theta += 10 Grad

Und nun wieder zurückrechnen in Kartesische Koordinaten

x = Länge * cos Theta
y = Länge * sin Theta


Da die Drehung um den Punkt 1;1 stattfindet muß dieser nun dazuaddiert werden
(x+1; y+1)

 

[Marco13]

Polarkoordinaten...? ???:L Jedenfalls sollte man die Abfolge

        GL11.glTranslatef(getPosition().x, getPosition().y, 0);
        GL11.glRotatef((float)Math.toDegrees(getCarHeading()), 0f, 0f, 1f);
        GL11.glTranslatef(-getPosition().x, -getPosition().y, 0);

eben genau durch

        at.translate(position.x, position.y);
        at.rotate(Math.toRadians(carHeading));
        at.translate(-position.x, -position.y);

nachbauen können, d.h. wenn man dort die gleichen Punkte übergibt, sollten auch die gleichen Ergebnisse rauskommen. Ansonsten wäre ein KSKB nicht schlecht.

 

[felixpk]

Great news!! Ich habe es geshafft!
Ich habe mir eine neue API heruntergeladen mit der mehr oder weniger einfach war das zu realisieren!
Ich muss jetzt zur arbeit, werde das heute nacht aber näher erläutern!

Vielen Dank an ALLE die mir geholfen haben!! 🙂

MfG felix

 

[JohannisderKaeufer]

Polarkoordinaten...? ???:L

Vielleicht sagt dir Drehmatrix mehr.

Drehmatrix ? Wikipedia

 

[Marco13]

Es ging nicht um den Begriff an sich, sondern eher darum, was er mit der eigentlichen Frage zu tun hatte. Aber das hat sich ja erledigt.