# Render Texture in libGDX



## TreCore (28. Jan 2015)

Hiho Guys 

fang ich direkt mal an ...
also hab ich erstmal folgende Klassen für Entitys und GameScreen
und nutze libGDX

```
class Entity extends Worldobject {
  public void update(float delta) { ... }
  public void render() { ... }
}
```


```
class GameScreen extends Screen {

  private SpriteBatch batch;

  public void create() {
    batch = new SpriteBatch();
  }

  public void render(float delta) {
    batch.begin();
    for(Entity e : entityList) {
      e.render();
    batch.end();
    }
  }
}
```
der rest der Klasse ist erstmal nicht wichtig  (das Entity.rendern kommt auch später in ne GameMatch-Klasse oder so ... habs erstmal vereinfacht darstellen wollen)
soo ich würde gerne das System für das Rendern bis hin zu TextureLoad machen...
nur weiß ich nicht wie ich vom Texturen laden zum Rendern kommen soll
Da ich keine globalen Texturen machen will wie public static Texture etc. hab ich das Problem das ich schlecht von der Entity Klasse aus schlecht an die Texturen komme ...
Ich könnte zwar die Textur private Texture in einem Entity coden und immer neu laden aber ... nä ^^
Gibt es da irgendein Schema das man machen könnte ?
Ich hatte einige Ideen ... aber die greifen jedes mal wieder auf globale Variablen zurück was ich vermeiden möchte ...
Hab auch andere Projekte angeschaut wie die das machen ... aber da hab ich auch nichts interessantes gefunden weil die beispiele meistens die einzelnen Objekte des GameScreens statisch festlegen ...
kann ich vll irgendwie ne ID für ne Texture nehmen und diese dann der Entity zuweisen und somit auch abfragen welche Textur gezeigt werden soll ? dann hätte ich alles Verkapselt und könnte alles locker in einer Texturenliste verwalten ... würde aber auch mehr zeit zum rendern verbrauchen weil er dann durch ne Liste erstmal gehen muss ...

Schon mal danke im vorraus


----------



## Bananabert (29. Jan 2015)

Wenn du schon die Funktion "render" in deiner Entity-Klasse hast, warum lädst du nicht einfach die Textur in deiner Entity-Klasse ? Du brauchst doch nur einmal deine Textur für ein Objekt zu laden, und nicht jedes mal beim Zeichen.
Pseudo Bsp:

```
class Entity extends Worldobject {
	private Texture texture;
	public Entity() {
		texture = TextureUtil.load("MEIN/IMAGE/PFAD.jpg");
	}
	public void update(float delta) { ... }
	public void render() {
		grapics.drawTexture(texture);
	}
}
```


----------



## TreCore (30. Jan 2015)

Das meinte ich mit "jedes mal neu laden" ^^
Ich glaub ich hab mich da ein wenig zu ungenau ausgedrückt
ich möchte nicht im Konstruktor die Texture jedes mal neu laden wenn ich ein Entity generiere 
Die Texture soll insgesamt bei 100 Entities nur 1 mal geladen werden
Dabei sollen die Texturen nicht über globale Variablen verfügbar sein sonder schön alles eingekapselt

PS: Ich frag mich gerade warum ich das nicht so von anfang an erklärt hab


----------



## Bananabert (30. Jan 2015)

Dann erstellst du dir eine Klasse, die dir deine Texturen lädt. Die Texturen könntest du z.B. in einer HashMap speichern mit entweder int/string als Key.
Deinen Entity-Klassen gibst du diese Klasse mit, sodass diese sich ihre Textur von deiner Texturen-Klasse holen können.


----------



## TreCore (31. Jan 2015)

hmmm ... klingt gut !
werde ich gleich mal machen !
danke dir


----------



## InfectedBytes (1. Feb 2015)

Für sowas ist der AssetManager gedacht. Der kümmert sich darum das Assets nicht mehrmals geladen werden müssen. 
In deiner create-Methode erzeugst du deinen AssetManager: 

```
AssetManager assets = new AssetManager();
assets.load("bildXYZ.png", Texture.class);
```
In deiner update-Methode solltest du den AssetManager selbst noch updaten und erst wenn dieser alles geladen hat weitermachen. 

```
if(!assets.update()) {
  //render loading screen
}
```

Den AssetManager kannst du anschließend beim erzeugen deiner Entities dem Konstruktor mitgeben und dort dann die Texturen holen:

```
public Entity(AssetManager assets) {
  Texture tex = assets.get("bildXYZ.png", Texture.class);
}
```

Der AssetManager zählt intern für jedes Asset mit, wie oft es genutzt wird und entlädt es erst, wenn es nicht mehr benötigt wird.


----------

