2D und 3D Gleichzeitig rendern[LWJGL]!

Werbeanzeige

mineorbit

Frischling

Beiträge: 2

16.01.2014, 19:41

2D und 3D Gleichzeitig rendern[LWJGL]!

Hallo ihr Spieleprogrammierer,
Wie die Frage bereits verrät, habe ich die frage, wie man eine render() funktion in programmieren die meine 3D Welt mit
einem 2D HUD überjegt, eine Antwort wäre spitze.
Mein bisheriger Code sieht so aus:

Quellcode

    public void render()
    {
        while(!Display.isCloseRequested())
        {
        make2D();
        System.out.println("Rendere 2D");
        tl.renderPicture();
        if(graphicstype == true)
        {
        make3D();
        System.out.println("Rendere 3D");

        }
        Display.sync(60);
        Display.update();
        }
    }
    protected static void make2D() {
        //Remove the Z axis
        GL11.glDisable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glPushMatrix();
        GL11.glLoadIdentity();
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        GL11.glOrtho(0, windowdimensions[0], 0,windowdimensions[1] , -1, 1);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glPushMatrix();
        GL11.glLoadIdentity();
        GL11.glEnable(GL11.GL_TEXTURE_2D);  
    }

    protected static void make3D() {
        //Restore the Z axis
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glPopMatrix();
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glPopMatrix();
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glEnable(GL11.GL_LIGHTING);
    }

Nur funktioniert das nicht,
hättet ihr ein Beispiel mit einer Render Engine womit ich dieses Problem lösen kann?
Vielen Dank,
Mineorbit

Zum Seitenanfang

DeKugelschieber

Community-Fossil

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

16.01.2014, 21:16

Hintereinander rendern. Gleichzeitig geht nicht.
Du renderst doch aktuell nichts in 3D, wie willst du das also testen?

Zitat

Nur funktioniert das nicht,

Ist eine ganz schlechte Fehlerbeschreibung... siehst du gar nichts? Ein Screenshot wäre evt. gut.

Außerdem brauchst (und solltest) du nicht für jeden Renderdurchlauf alles neu setzten (glBlendFunc).
Und was macht renderPicture()?

Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Zum Seitenanfang

NachoMan

Community-Fossil

Beiträge: 3 885

Wohnort: Berlin

Beruf: (Nachhilfe)Lehrer (Mathematik, C++, Java, C#)

17.01.2014, 02:59

Zitat von »mineorbit«

hättet ihr ein Beispiel mit einer Render Engine womit ich dieses Problem lösen kann?

Ich glaube du suchst etwas ganz anderes als die LWJGL.
Wenn du bei Java bleiben möchtest würde ich dir empfehlen dir mal die JMonkey Engine anzuschauen. Selbst wenn du deine eigene Engine entwickeln möchtest profitierst du davon erstmal eine zu nutzen. Danach weißt du viel besser was du brauchst und wie du es umsetzen kannst.
Wenn du mit C# Leben kannst, solltest du dir unbedingt Unity anschauen.

Wenn du trotzdem bei der LWJGL bleiben möchtest solltest ist es noch wichtiger zu lernen welche Werkzeuge einem die Objektorientierung bietet und wie man sie effektiv einsetzt.
Deshalb gilt dieses Buch für mich in jedem Fall als Pflichtlektüre, wenn man effizient Spiele und Software entwickeln möchte :vain:

http://openbook.galileocomputing.de/oop/

"Der erste Trunk aus dem Becher der Erkenntnis macht einem zum Atheist, doch auf dem Grund des Bechers wartet Gott." - Werner Heisenberg
Biete Privatunterricht in Berlin und Online.
Kommt jemand mit Nach oMan?

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »NachoMan« (17.01.2014, 03:37)

Zum Seitenanfang

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

17.01.2014, 16:07

Das ganze ist natürlich teilweise von der Engine abhängig. So bieten dir einige Engines schon GUI Funktionen mit welchen du dein HUD schön darstellen kannst. In der Theorie gäbe es aber zum Beispiel folgende Möglichkeiten:
Du renderst deine 3D Welt ganz normal. Für dein HUD nimmst du Planes welche du passend texturierst. Diese renderst du wenn deine gesamte Welt gerendert wurde. Dabei sparst du dir Weltmatrix, Projektionsmatrix und Viewmatrix. du positionierst deine Planes einfach direkt passend auf dem Bildschirm.
Eine weitere Möglichkeit gäbe es je nach Mitteln die du verwendest. Als Beispiel, du benutzt SFML mit OpenGL. SFML kann Texturen und andere 2D Dinge rendern. Jetzt kannst du wieder ganz normal deine Welt rendern und die 2D Objekte nachträglich drüber legen.
Benötigst du ein wirkliches GUI würde ich möglichst nach fertigen Dingen gucken, oder du musst gut was an Zeit investieren. Handelt es sich wirklich nur um einfache HUD Anzeigen reichen ja im Prinzip ein paar Texturen die du auf den Bildschirm zauberst.

„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Zum Seitenanfang

Chromanoid

Alter Hase

Beiträge: 1 410

17.01.2014, 23:00

Du willst doch sicher 2D nach 3D rendern. Ich nehme an, Du hast Deinen Code hier her: http://lwjgl.org/forum/index.php?topic=4431.0

Hier mal ein Beispiel, das funktioniert:

Quellcode

import java.io.PrintWriter;
import java.io.StringWriter;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;

public class App {

    int targetWidth = 640;
    int targetHeight = 480;

    public static void main(String[] args) {
        new App().run();
    }

    public void run() {

        try {
            DisplayMode chosenMode = new DisplayMode(targetWidth, targetHeight);
            Display.setDisplayMode(chosenMode);
            Display.setTitle("Example");
            Display.setFullscreen(false);
            Display.create();
            throw new LWJGLException("test");
        } catch (LWJGLException e) {
            final StringWriter sw = new StringWriter();
            sw.append("Unable to create display:\n");
            e.printStackTrace(new PrintWriter(sw));
            System.out.println(sw.toString());
            Sys.alert("Error", sw.toString());
            System.exit(0);
        }

        GL11.glClearColor(0, 0, 0, 0);

        boolean gameRunning = true;
        int FRAMERATE = 60;

        while (gameRunning) {
            // Bildschirm leeren
            GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

            // Kreiseln
            GL11.glRotatef(0.6f, 0, 0, 1);

            // Dreieck malen
            GL11.glBegin(GL11.GL_TRIANGLES);
            GL11.glColor4f(1f, 1f, 1f, 1f);
            GL11.glVertex3f(-0.5f, -0.5f, 0);
            GL11.glVertex3f(0.5f, -0.5f, 0);
            GL11.glVertex3f(0, 0.5f, 0);
            GL11.glEnd();

            // 2D Matrizen setzen
            begin2D();
            // Dreieck malen nun im 2D Raum (eine Einheit = ein Pixel)
            GL11.glBegin(GL11.GL_TRIANGLES);
            GL11.glColor4f(0f, 0f, 1f, 1f);
            GL11.glVertex3f(0f, 0, 0);
            GL11.glColor4f(0f, 0f, 1f, 0f);
            GL11.glVertex3f(targetWidth, targetHeight, 0);
            GL11.glColor4f(0f, 0f, 1f, 1f);
            GL11.glVertex3f(0, targetHeight, 0);
            GL11.glEnd();
            // 3D Matrizen "wiederherstellen"
            end2D();

            Display.update();
            Display.sync(FRAMERATE);

            if (Display.isCloseRequested()) {
                gameRunning = false;
                Display.destroy();
                System.exit(0);
            }
        }
    }

    protected void begin2D() {
        // Tiefentest deaktivieren
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        // Blending aktivieren
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
        // Projektionsmatrix bearbeiten
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        // Projektionsmatrix auf Matrix-Stack sichern
        GL11.glPushMatrix();
        // Projektionsmatrix zurücksetzen
        GL11.glLoadIdentity();
        // Orthographische Perspektive setzen  
        GL11.glOrtho(0, targetWidth, 0, targetHeight, -1, 1);
        // "Objekttransformationsmatrix" bearbeiten
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        // "Objekttransformationsmatrix" auf Matrix-Stack sichern
        GL11.glPushMatrix();
        // "Objekttransformationsmatrix" zurücksetzen
        GL11.glLoadIdentity();
    }

    protected void end2D() {
        // Tiefentest aktivieren
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        // Blending deaktivieren
        GL11.glDisable(GL11.GL_BLEND);
        // Projektionsmatrix bearbeiten
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        // Alte in begin2D auf den Matrix-Stack gelegte Matrix wiederherstellen
        GL11.glPopMatrix();
        // "Objekttransformationsmatrix" bearbeiten 
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        // Alte in begin2D auf den Matrix-Stack gelegte Matrix wiederherstellen
        GL11.glPopMatrix();
    }
}

So sollte es aussehen (blau = "2D", weiß = "3D"):