Rendering - eine Java/OpenGL rendering library

Nachdem ich vor ca. 8(?) Jahren mal damit angefangen hatte, und seit 4 Jahren nicht mehr wirklich daran weitergearbeitet hatte, dachte ich mir, jetzt, wo das ganze durch Vulkan praktisch obsolet geworden ist, könnte ich ja mal eine Version 0.0.0-SNAPSHOT davon veröffentlichen:

(Ja, die Readme wird noch gefüllt. Viel relevante Information steht in der “package-info.java” der “core” library. Mit den daraus generierten JavaDocs sollte man einen ersten Überblick bekommen können. Weitere Doku (mit ein paar Bildchen) habe ich schon erstellt, aber noch nicht finalisiert).

Das Ziel war, eine Rendering-Library zu schaffen, die es sowohl erlaubt, abstrahierend auf verschiedene OpenGL-basierte rendering-Backends zuzugreifen (in diesem Falle JOGL und LWJGL), als auch die Möglichkeit bietet, leicht durch diese Abstraktionsschicht durchzustechen, und nicht-so-abstrakte OpenGL-Funktionen zu verwenden.

Etwas allgemeiner formuliert sollte die Library es erlauben, bequem irgendwelche “Graphischen Objekte” zu verwalten, die als Attribute irgendwelche DataBuffer mit rendering-Daten enthalten. Diese Attribute kann man dann mit den Eingabe-Parametern für ein Shader-Program verdrahten, um zu definieren, wie ein Objekt gerendert werden soll. So ein Objekt kann man dann einfach in die Rendering-Umgebung reinwerfen, die sich dann um die Verwaltung (d.h. die Abbildung des ganzen auf OpenGL) kümmert. Schließlich definiert man am Ende noch Rendering-Kommandos, die der Reihe nach ausgeführt werden.

Das ganze sollte ziemlich straightforward sein. Es gibt also GraphicsObject, die als Attribute irgendwelche DataBuffer enthalten, die in einem RenderedObject mit den Parametern eines Shader-Programs verknüpft werden, das man dann an das RenderingEnvironment übergibt, bevor man die Commands zum rendern absetzt :slight_smile:

Für diejenigen, die sich um Shader keine Gedanken machen wollen, gibt es zusätzlich Default-Shader, die die OpenGL-Fixed-Function-Pipeline emulieren (mit per-Fragment-Lighting)).

Wie das ganze am Ende aussieht, erkennt man vielleicht an den ersten samples, sie auch im GitHub-Repo liegen:

// Create a simple GraphicsObject. This GraphicsObject contains
// DataBuffers for several default Attributes. These are at least
// Attributes.VERTICES, Attributes.TEXCOORDS and Attributes.NORMALS.
GraphicsObject cube = GraphicsObjects.createCube();

// Create a texture from an image file
Texture texture = ImageTextures.createImageTextureFromFileUnchecked(
	"https://forum.byte-welt.net/images/lena512color.png");

// Create a default program that emulates the fixed function pipeline
Program program = Programs.createFixedFunctionProgram();

// Create a rendered object. It will render the GraphicsObject with 
// the loaded Program. The connections between input Parameters of
// the Program and the Attributes of the GraphicsObject are 
// established.
RenderedObject texturedCube = 
    RenderedObjects.create(cube, program)
        .connect(Parameters.VERTEX_POSITION, Attributes.VERTICES)
        .connect(Parameters.VERTEX_NORMAL, Attributes.NORMALS)
        .connect(Parameters.VERTEX_TEXCOORD0, Attributes.TEXCOORDS)
        .connect(Parameters.TEXTURE0, texture)
        .build();

// Pass the RenderedObject to the RenderingEnvironment,
// which will initialize all internal data structures
renderingEnvironment.handleRenderedObject(texturedCube);

// Create a list of Commands that will cause the object to be rendered
CommandList commandList = new CommandList();
commandList.addCommands(

    // Create a command to set the model-, view-, projection- and
    // normal-matrix of the program based on the View that is 
    // provided via the RenderingEnvironment, and set the model 
    // matrix to identity
    Commands.setDefaultMatrices(
        program, MatrixUtils.identity(), 
        renderingEnvironment.getView()),
    
    // Set the number of textures 
    Commands.setNumTextures(program, 1),
        
    // Finally, render the textured cube
    Commands.render(texturedCube)
);
renderingEnvironment.addCommandSupplier(commandList);

Was man daran jetzt noch nicht sieht, sind einige weitere Klassen drumherum, z.B. für Materialien und Lichter. Die sieht man aber in den anderen Samples. Eins der Samples zeigt auch die Verwendung von FrameBuffer-Texturen: Hier werden 9 bunte Kugeln in eine Textur gerendert, die dann (mit einer Lena-Textur kombiniert) auf einen Würfel gelegt wird:

Aber das sollte nur ein Beispiel bzw. ein erster Test sein.

Feedback (bei dem hoffentlich berücksichtigt wird, dass das Version 0.0.0-SNAPSHOT ist ;-)) ist immer willkommen.

*** Edit ***

(Interessant - der Link im Quellcode wurde durch https://forum.byte-welt.net/ ergänzt - das gehört da eigentlich nicht hin ;-))