# g.translate(x,y); rückgängig machen



## PixelHD (27. Mrz 2012)

Hallo, 

ich habe mal wieder ein kleines Problem ich lasse ein Bild laden und verschiebe es dann mit 

```
g.translate(x,y);
```
damit sich der Spieler bewegen kann und das Level auch weiter geht. Aber wenn ich jetzt ein Text rendern lassen will wird der mit verschoben sprich wenn ich den an x=10;y=10 rendern lasse und diese Koordinate nicht mehr in meinem Sichtfeld ist sehe ich die auch nicht mehr der Text ist also nicht "fest".
Ich weiß leider nicht wie ich das unterbinden kann :bahnhof:
Ich hoffe aber das einer von euch eine Idee hat 

CODE:


```
public void render(Graphics g) {
		g.translate(-player.x, -player.y);

		for (int x = 0; x < ArtHandler.level.getWidth(); x++) {
			for (int y = 0; y < ArtHandler.level.getHeight(); y++) {
				byte block = blocks[x + y * ArtHandler.level.getWidth()];
				int xImg = 0;
				int yImg = 0;

				if (block == 1)
					xImg = 1;
				g.drawImage(ArtHandler.blocks[xImg][yImg], x * 10, y * 10, null);
			}
		}
	}
```

MFG


----------



## Spacerat (27. Mrz 2012)

Was das für 'ne Frage? Ich würd' translate schlicht erneut mit negierten Parametern aufrufen.


----------



## Marco13 (27. Mrz 2012)

So banal ist die Frage nicht. Es gibt verschiedene Möglichkeiten, die je nach Anwendungsfall unterschiedlich gut oder schlecht geeignet sein können. Pauschal zu sagen "Jede Veränderung kann durch die negierte Veränderung Rückgängig gemacht werden" wäre nicht gut (und nein, ich will nicht andeuten, dass du das andeuten wolltest  )

Das beschriebene wäre ja

```
int dx = ...
int dy = ...
g.translate(dx,dy);
g.draw(shape); // Verschobenes Shape zeichnen
g.translate(-dx,-dy);
g.drawString(text, 0, 0) // Text an Originalposition Zeichnen
```

Man könnte manchmal auch einfach sowas machen wie

```
int dx = ...
int dy = ...
g.translate(dx,dy);
g.draw(shape); // Verschobenes Shape zeichnen
g.drawString(text, -dx, -dy) // Text an Originalposition zeichnen
```

Natürlich würde man, wenn es NUR darum ginge, sowas machen wie

```
int dx = ...
int dy = ...
g.drawString(text, 0, 0) // Text an Originalposition zeichnen
g.translate(dx,dy);
g.draw(shape); // Verschobenes Shape zeichnen
```
falls das mit der Zeichenreihenfolge passt...


Wenn man "viele" Veränderungen an der Transformation macht, kann eine sehr saubere und praktische Möglichkeit auch sein

```
AffineTransform originalAT = g.getTransform();
int dx = ...
int dy = ...

g.translate(dx,dy);
g.draw(shape); // Verschobenes Shape zeichnen

// Viele weitere Veränderungen...
g.rotate(...);
g.transalte(...);

// Originaltransformation wieder herstellen:
g.setTransform(originalAT);
```


Die "aboluteste" Trennung erreicht man durch ein neues Graphics-Objekt

```
// Gegeben: Original-Graphics2D-Objekt 'inputGraphics'
Graphics2D g = (Graphics2D)inputGraphics.create();

int dx = ...
int dy = ...
g.translate(dx,dy);
g.draw(shape); // Verschobenes Shape zeichnen

// Viele weitere Veränderungen...
g.rotate(...);
g.transalte(...);

// Auch das hier kann geändert werden, OHNE dass dadurch
// das ursprüngliche Graphics2D, 'gr' beeinflußt wird
g.setColor(...);
g.setStroke(...);

// Am ende, das temporäre Graphics2D wieder disposen:
g.dispose();
```
Ob und inwieweit das letzte eine nennenswert schlechtere Performance hat, müßte ich auch erst austesten, aber wenn man eine komplexe Zeichenoperation hat, bei der man "viel" am Graphics verändern will (insbesondere auch Dinge wie Farbe und Stroke oder RenderingHints(!)) ist das sehr praktisch, weil der Zustand des original übergebenen Graphics2Ds nicht verändert wird. Ansonsten kann es lästig sein, wenn man eine Zeichenmethode aufruft, und das Graphics2D, das man dort übergeben hat, danach komplett anders "eingestellt" ist als vorher...


----------

