JOGL, etwas Grundlegendes

[ArtjomZab]

Ich habe ein kleines Jogl-Projekt. Es gibt ein Spielfeld und Figuren darauf. Sie werden jeweils durch
die Klassen Spielfeld und Spielfigur dargestellt. Das Problem: bisher habe ich nur Jogl-Projekte gesehen,
bei denen alles was gezeichnet werden soll (zb Spielfeld - Figur) in einer Klasse war. Dies war deshalb so, weil man ja zum zeichnen das gl-Objekt benutzt und die gesamte Szene nur duch ein einziges solches Objekt gezeichnet werden kann. Wie kann ich Trotzdem ein solches Klassenmodel realisieren. Ich dachte man könnte eine Methode entwickeln, die das gl-Objekt von Klasse zu Klasse weiterreicht.

 

[Soulfly]

Das wäre der übliche Weg, ja!
Würde man bei einem Szenenmanager, der die einzelnen Spielstati regelt, genauso machen.

MfG

 

[ArtjomZab]

Wenn ich das gl-Objekt von Klasse zu Klasse weitergebe, dann soll ja davon auch keine Kopie erstellt werden.
Das gl-Objekt, das zb das Spielfeld bereits enthält, soll um die Figur ergänzt werden. Technisch muss ich das doch so lösen, dass ich die gl-Erweiterung im Konstruktor vornehme, oder? Aber das is bei JOGL nicht immer möglich, da man
bereits einen Methodenrahmen hat und aus dem Konstruktor keine solche methode aufrufen kann, da sie automatisch ausgeführt werden.

Eine Klasse die etwas zeichnet sieht so aus:

public class Figur implements GLEventListener{
      
      public Figur(){}

      // wird als erstes automatisch ausgeführt, um Grafikkontext zu initialisieren
      public void init(){}

      // zeichnet
      public void display(){
          gl? // wie bekomme ich dieses GL aus der Hauptklasse zb Spielfeld hierher?
          gl.draw....
      }
}

 

[Soulfly]

Dann hast du dich noch nie wirklich mit Java befasst!

Java arbeitet intern mit Zeigern. Du würdest nur einen 32 Bit Integer sozusagen "kopieren".
Da ist keine großer Overhead.

Edit:
Zu der anderen Frage. Denk dir die folgende Struktur:

Renderer
SceneManager
Objekte

Renderer enthält die JOGL-funktionen, bei denen jetzt inner display() ein Aufruf steht scenemanager.display(gl).

Scenemanager ist eine Sammlung von Objekten. In dessen display werden "alle" Objekte durchlaufen álá objekt.display(gl)

Objekt enthält dann nur die tatsächlichen Jogl-Funktionsaufrufen.

Du delegierst hier die Aufgaben an die Objekte und die müssen halt gl kennen.
Mit dieser methode arbeitest du dann immer mit dem gleichen gl-Objekt.
Es existiert eine getGL() (nicht wörtlich) Möglichkeit aber zu der rate ich dir in keinem Fall.

 

[ArtjomZab]

Naja SoulFly, das mit den Referenzen war eigentlich anders gemeint, aber egal. Bin jetzt in der 12ten Klasse und hab
nen Informtik leistungskurs. Da habe ich in einer Gruppe das Projekt einen Bomberman-Klon zu entwickeln. Ich hab aber immer noch nicht deinen Lösungsansatz mt dem Szenenrenderer verstanden. Ah, ein Geistesblitz... DU meinst, im SceneManager wird ein GL-Objekt erzeugt, global sozusagen, ah ja ...danke

 

[ArtjomZab]

Ach ja noch eine Frage. Kann das gl-Objekt überhaupt über GL gl = new GL() erzeugt werden. Geht das nicht über Drawable.getGL()

 

[Soulfly]

Ungefähr genau so, Scenemanager erhält das GL-Objekt vom Renderer und die Objekte können drauf zugreifen.

Zu Zeigern und Referenzen. Sorry lern noch ein bißchen. Soll nicht nach Besserwissen klingen, aber!

Es beruht alles auf dem selben konzept. Was kleines zeigt auf was großes = Speicherersparnis.
Auf jeden Fall sagt das mein Prof. für Compilerbau und OOP und meine Bücher sagen es ebenfalls.
Und 12 Jhg und Leistungskurs ist nicht besonderes, hatte ich auch und jetzt 6. Semester. Unser Lehrer wußte
damals nicht mal das Java objektoriert arbeitet.

Aus Software-Technischer Sicht würde ich zu meiner Methode tendieren, so entstehen viel zu viele weitere Abhängigkeiten. So muss den Objekten der Scenemanager bekannt sein = Ungünstig.

 

[ArtjomZab]

Wo kommt das GL-Objekt her? Vom Renderer sagst du? Der Renderer erzeugt also ein neues GL-Objekt und der Szenemanager ist sozusagen der Vermittler zwischen Renderer und den Objekten(Figuren). In Jogl formuliert könnte
das dann ungefähr so aussehen?

Renderer:

public class Renderer implements GLEventlistener{

    public Renderer(){}

    public void init(GLDrawable arg){
       GL gl = arg.getGL();
        gl....//feste Einstellungen vornehmen
    }

    public void display(GLDrawable arg){
       GL gl = arg.getGL();
       Szenemanager sm = new Szenemanager();
       sm.display(gl);
    }

    ....
}

Szenemanager:

public class Szenemanager{

    public Szenemanager(){}

    public void display(GL gl){

        Figur f = new Figur(gl); // das display der Figur wird ja dann automatisch ausgeführ, jedoch mit dem übergebenen gl
    }
}

Könnte das nach deinen Vorstellungen passen?

 

[Soulfly]

Jep so kann man es verwenden.

Ich kann dir auch mal folgende Quelle empfehlen:

www.javagaming.org/

Der Entwickler an Jogl höchst persönlich ist dort unterwegs und das Forum bietet
viele Tipps und Tricks zu Jogl. Einfach mal reinschauen.

Viel Spaß noch!