# Vergleich von Java3D und OpenGL



## Infogeil (24. Aug 2010)

Hallo,

wie der Titel schon sagt, würde ich gerne wissen was die Unterschiede bei diesen 3D Grafikschnittstellen Java3D und OpenGL wissen.

1. Für welchen Anwendungsfälle würde man Java3D der OpenGL Schnittstelle vorziehen und anders rum?
2. Welche Vorteile hat Java3D gegenüber OpenGL und anders rum?
3. Wie sind die jeweiligen API's im vergleich (Aktualität)? 
4. Bietet OpenGL die möglichkeit (VRML Grafik) oder andere Grafikdaten zu laden , wie es z.B bei Java3D möglich ist?(VRML Loader)
(VRML ist meines wissen auch eine Very-High-Level-3D Grafikschnittstelle )

Meine bisherigen Erkenntnisse sind:

Java3D baut auf Scenengraphbaum-Struktur auf, womit es schon relativ einfach und schnell möglich ist 3D Scenen zu erstellen.
Java3D "baut" ( ist womöglich das falsche Wort ) auf OpenGL auf bzw verwendet es.
Java3D API ist hervorragend.
Mit Java3D ist es relativ simple eine Animation vom Würfel z.B anzeigen zu lassen ( mit wenig Code ).
uvm.

5. Wie schaut es da bei OpenGL aus? Wieviel mehr Aufwand ist es eine Animation ( Interpolation ) in OpenGL zu erstellen?

Habe ein paar Diplomarbeit im Netz gefunden die sich damit befassen, aber meiner Meinung nach sind die schon etwas veraltet und damit wohl nicht mehr korrekt 

Würde mich freuen über reichlich Input 

Mfg


----------



## maki (24. Aug 2010)

Hatten erst vor ein paar Wochen genau dieses Thema, zu finden über unsere Suchfunktion 
http://www.java-forum.org/spiele-multimedia-programmierung/104180-jogl-java3d.html


----------



## Infogeil (24. Aug 2010)

Ja danke für den Hinweis ,
ich habe mir aber schon diesen Thread durchgelesen und finde das nicht so sehr auf die Unterschiede eingegangen wird.
Vorallem finde ich keine Antworten auf meine Frage  

Mfg


----------



## Guest2 (24. Aug 2010)

Moin,

nuja, wenn Du den anderen Thread gelesen hast, hast Du ja auch das bereits gelesen:


Guest2 hat gesagt.:


> OpenGL (insbesondere die aktuellen Versionen GL > 3.1 bzw. ES 2)  ist praktisch ausschließlich dafür da um einen Satz von Dreiecken über eine "Berechnungsvorschrift" (Fixed-Function oder Shader) auf den Bildschirm zu bringen. Nicht mehr und nicht weniger. Das Ziel ist also etwas vollkommen anderes als das Ziel einer 3D Engine. Und damit nicht vergleichbar.



Damit klären sich einige Deiner Fragen doch bereits von alleine.  Ich gehe nur auf den OpenGL Teil ein - auf den Java3D Teil antwortet vielleicht jemand der das mag:




Infogeil hat gesagt.:


> 1. Für welchen Anwendungsfälle würde man Java3D der OpenGL Schnittstelle vorziehen und anders rum?


OpenGL: Alles wo eine schnelle und individuelle Grafiklösung benötigt wird.




Infogeil hat gesagt.:


> 2. Welche Vorteile hat Java3D gegenüber OpenGL und anders rum?


OpenGL:
 Vorteil: Man kann alles selber machen.
Nachteil: Man muss alles selber machen.




Infogeil hat gesagt.:


> 3. Wie sind die jeweiligen API's im vergleich (Aktualität)?


OpenGL: Aktueller geht nicht. Nichts kann aktueller sein als die Spezifikation selber.




Infogeil hat gesagt.:


> 4. Bietet OpenGL die möglichkeit (VRML Grafik) oder andere Grafikdaten zu laden , wie es z.B bei Java3D möglich ist?(VRML Loader)


1. VRML ist lediglich ein Dateiformat
2. OpenGL schiebt einen Satz von Dreiecken zur Grafikkarte, mehr nicht. Willst Du VRML laden, musst Du das selber machen oder eine Lib dazu einbinden.




Infogeil hat gesagt.:


> Mit Java3D ist es relativ simple eine Animation vom Würfel z.B anzeigen zu lassen ( mit wenig Code ).


Mit OpenGL 2 ist das nicht mehr als mit Java3D. Mit OpenGL > 3.1 ja, deutlich anspruchsvoller und für einen Anfänger nicht zu realisieren.




Infogeil hat gesagt.:


> 5. Wie schaut es da bei OpenGL aus? Wieviel mehr Aufwand ist es eine Animation ( Interpolation ) in OpenGL zu erstellen?


Hangt von der Animation ab. Mit etwas Grundwissen ist es in OpenGL 2 nicht schwer. Mit OpenGL > 3.1 ist es hingegen schon anspruchsvoll. Fortschrittliche Skinning-Methoden gehen aber eh nur noch über OpenGL.

Gruß,
Fancy


----------



## EgonOlsen (24. Aug 2010)

Guest2 hat gesagt.:


> Mit OpenGL > 3.1 ja, deutlich anspruchsvoller und für einen Anfänger nicht zu realisieren.


Jein. Du kannst ja einen kompatiblen Kontext erzeugen, da geht auch alles das mit, was vor 3.0 ging...plus die Dinge in 3.0 und höher. (Unnötig) schwierig wird es nur, wenn du einen "richtigen" 3.0 (oder höher) Kontext verwendest, da gibt es dann in der Tat viele Dinge aus 2.0 und vorher nicht mehr. Aber das muss niemand tun und das ist meiner Ansicht nach auch überhaupt nicht sinnvoll, außer es gäbe wirklich mal Treiber/Hardware, die nur noch 3.0+ unterstützen, aber das ist nicht in Sicht. NVidia hat zum Beispiel gesagt, sie werden die alten Specs immer unterstützen.


----------



## Guest2 (24. Aug 2010)

Genau genommen meinte ich schon das core profile . Imho macht es schon sinn das zu nutzen, weil es mir im fertigen Programm konsequenter erscheint, als wenn da z.B. teilweise noch fixed function Bruchstücke auftauchen würden. Auch beim Blick über den Tellerrand: WebGL ist z.B. OpenGL ES2, da gibt es auch keine fixed function mehr. Auch im Mobilbereich ist ES2 ohne ES1 Unterstützung wohl nicht so ungewöhnlich.

Aber Du hast schon recht, ich würde auch keinem Anfänger empfehlen sich an GL > 3.1 core zu versuchen, weil ich es schlicht für aussichtslos halte. Viele begnügen sich langfristig eh mit den GL 2.1 Funktionen. Und auch die Hersteller, selbst wenn die wollten, die alten GL Specs abzusägen wäre aussichtslos. Außerdem sind z.B. die ganzen Matrix Funktionen eh "nur" Software im Treiber, Hartware steckt da sowieso keine mehr hinter. 

(Allerdings bin ich gespannt wie sich die Tutorial Szene um WebGL entwickelt. Die müssen ja ohne fixed function auskommen, ob die wollen oder nicht. Und ich halte den durchschnittlichen JavaScript Tutorialleser nicht unbedingt für besonders erfahren in der Linearen Algebra. Vielleicht färbt das aber ja auch auf die normale OpenGL Szene ab und GL > 3.1 core verbreitet sich auch im Hobbybereich stärker.)

Gruß,
Fancy


----------



## Infogeil (25. Aug 2010)

Ok , der vergleich von OpenGL und Java3D ist ein wenig schlecht gewählt.
Java3D oder JOGL ist mehr die 3D Engine , korrekt?
Und OpenGL schickt die Objekte zur Grafikkarte um dann letztendlich angezeigt zu werden.

Also würde ich mit Java3D eine Scene erstellen, dann gehe ich so oder so den "umweg" über OpenGL oder Direct3D?
Und wenn man dann eine Scene direkt mit OpenGL erstellt, gibt es diesen Weg nicht?

Für 3D Grafikprogrammieranfänger ist Java3D am geeignetsten oder? 
Weil Java3D schon von Haus aus sehr viele Klassen zur Veränderung an Objekten ( Transformation/Objektattribute(Transparents uvm.)/Interpolation/Picking ) mit sich bringt, oder wie schaut es bei OpenGL aus, bzw JOGL o.a ?

Meine bisherigen Erfahrungen beruhen lediglich auf Java3D.
Ich habe eine Anwendung geschrieben, wo es möglich ist VRML-Dateitypen oder Java3D Objects zu laden und in einer Scene darzustellen.
Dann ist es möglich, Objekteigentschaften ( Position, Materialeigenschaften uvm ) zu ändern und abzuspeichern (VRML Format).
In der Anwendung habe ich dann die möglichkeit, mehrere Objekt in einer Scene zu laden und dann eine eigene Scene daraus zu erstellen. Man hat dann auch die Möglichkeit eine Animation ( Interpolation ) anzeigen zu lassen , z.B ein Arbeitsablauf von einer Maschine oder von einem Motor.
Steuerung der Motor/Maschinenanimation via TCP (externe Software).

Diese Anwendung ist eigentlich mit recht geringen Aufwand in Java3D umgesetzt.

Ich erwähne das weil ich gerne wissen möchte was genau für diesen Anwendungsfall für Java3D spricht und was für OpenGL (oder anderen ) sprechen würde?

Ich z.B habe mich für Java3D entschieden weil:

1. Java3D relativ geeignet ist für Einsteiger in 3D Grafik.
2. Java3D schon von Haus aus sehr viele nützliche Klassen im petto hat 
3. Lib für VRML vorhanden war ( zwingend notwendig )
4. Viele Einsteigertutorials in Netz vorhanden sind.
5. Und OpenGL für mich zum Einstieg ein wenig umständlich war.

Für was hättet ihr euch entschieden und warum ?


----------



## EgonOlsen (25. Aug 2010)

Guest2 hat gesagt.:


> WebGL ist z.B. OpenGL ES2, da gibt es auch keine fixed function mehr. Auch im Mobilbereich ist ES2 ohne ES1 Unterstützung wohl nicht so ungewöhnlich.


OpenGL ES 2.0 ist immer ohne Kompatibilität zu 1.1/1.0. Und das meiner Meinung nach eine extrem dumme Idee. GPUs mit der Füllrate von etwa einem Fünftel einer Voodoo 1 sollen komplett shaderbasiert laufen...na dann Prost Mahlzeit.


----------



## Marco13 (25. Aug 2010)

Infogeil hat gesagt.:


> Ok , der vergleich von OpenGL und Java3D ist ein wenig schlecht gewählt.
> Java3D oder JOGL ist mehr die 3D Engine , korrekt?
> ...
> Für 3D Grafikprogrammieranfänger ist Java3D am geeignetsten oder? ...
> ...



Auch wenn das eine teilweise Wiederholung des schon gesagten ist, und mit Sicherheit eine Widerholung von Bruchstücken aus anderen Threads: Java3D und JOGL (was jetzt mal für "irgendeine" OpenGL-Anbindung steht) kann man schlecht vergleichen. Etwas grob eingeteilt, zur Verdeutlichung: Java3D ist eine API für die Erstellung von Szenen mit Szenegraphen. JOGL ist eine API für reines Rendering von Geometriedaten, ggf. mit ausgefeilten Shadern usw. Was das in der Anwendung bedeutet, hatte ich hier mal sinngemäß zusammengefasst.

Für das, was du beschrieben hast, ist Java3D definitiv die bessere Wahl. Wenn man einen Roboterarm aus VRML lesen und animieren will, sind das mit Java3D vielleicht 1000 Zeilen, und so viel würde mit reinem JOGL schon allein das VRML-Lesen beanspruchen, und die Verwaltung der Shader und Geometrie nochmal genausoviel, und die Animation vielleicht noch mehr. 

Man kann auch schwer sagen, was "für Anfänger" besser geeignet ist. Das kommt auf das Ziel an. Bei Java3D ist es ein Erfolgserlebnis, wenn man auf ein Texturiertes Objekt klicken kann und das Objekt dann animiert wird. Bei JOGL ist es ein Erfolgserlebnis, wenn man ein untexturiertes Dreieck rendern kann.


----------



## Infogeil (25. Aug 2010)

Danke @ Marco13

Gibt es sonst noch erwähnenswerte Unterschiede warum lieber Java3D als JOGL/OpenGL, bis auf die schon erwähnten Punkte von Marco13?

Für meinen fall ist natürlich der Programmieraufwand schon sehr wichtig, da die Zeit für diese Anwendung natürlich sehr beschränkt ist/war.
Ziemlich irrelevant sind dafür Shading.


----------



## Empire Phoenix (26. Aug 2010)

Alos cih würde werder Java3d noch Jogl empfehlen, beides ist techn isch veraltetet und wird nichtmehr weiterentwickelt.

Layer1 Opengl Schnittstelle c/c++ zu grafikkarte
Layer2 LWJGL oder JOGL Java schnittstelle zu layer 1, JOGL veraltet
Layer3 Grafikengine basierend auf Layer2, einige sind in der Lage Layer2 auszuwechseln
Brachbare vertreter der Engines, 
JMonkeyEngine(3)(Opengl3.0,(core soweit ich weiß) bislang einzige ShaderMaterialBasierte Java engine, 
Java3d(einfaches logischen interface, nicht gut für shadermaterialen ohne massiven aufwand
jPCT bietet auch einen softwarrenderer an, wenn keine hardware zur verfügung steht,keine opensource licenz(mehr kenne ich nciht von)


----------



## maki (26. Aug 2010)

> Alos cih würde werder Java3d noch Jogl empfehlen, beides ist techn isch veraltetet und wird nichtmehr weiterentwickelt.


Java3D wird seit einiger Zeit wieder weiterentwicelt, JOGL arbeitet an dem 2.0 Release.


----------



## Empire Phoenix (26. Aug 2010)

Gut dann bin ich da falsch informiert.


----------



## Infogeil (26. Aug 2010)

Der OOP Aspekt spielt in meinem fall auch eine Rolle, und wenn ich nicht falsch Informiert bin ist es in Java3D der fall aber nicht in OpenGL?!?

Gruß


----------



## maki (26. Aug 2010)

Infogeil hat gesagt.:


> Der OOP Aspekt spielt in meinem fall auch eine Rolle, und wenn ich nicht falsch Informiert bin ist es in Java3D der fall aber nicht in OpenGL?!?
> 
> Gruß


OpenGL ist C, JOGL nur ein sehr dünner Wrapper (statische Methoden die genau die OpenGL APi wiedergeben + ein paar Utilities), nix mit OOP.


----------



## Guest2 (26. Aug 2010)

Wenn man es ganz genau nimmt, ist es bei jogl so, dass es schon ein GL Objekt gibt in dem die OpenGL Funktionen leben (die sind bei jogl nicht static). Aber außer das dieses GL Objekt zu einem GL Kontext gehört hat es keinerlei Eigenschaften der OOP. Insofern hat maki vollkommen Recht, nix mit OOP und alles fühlt sich statisch an.

Bei lwjgl ist es sogar tatsächlich so, dass die OpenGL Funktionen als static deklariert sind, mit allen Vor- und Nachteilen.

OOP würde auf der Ebene von OpenGL auch nicht wirklich Sinn ergeben. Auch wenn ich wiederhole, bei OpenGL sieht es üblicherweise so aus:


```
1. hier ein shader
2. hier eine projection matrix
3. hier eine modelview matrix
4. hier eine texture
5. hier eine Folge von triangles
=> darstellen
```

Mehr ist da nicht, alles andere musst Du selber machen! Man kann OpenGL (jogl/lwjgl) einfach nicht mit Java3D / jME oder was anderem vergleichen, das sind zwei vollkommen unterschiedliche Ebenen. 

Eine Maschine / Motor / Roboterarm mit Java3D darzustellen ist einfach, weil es perfekt in das Konzept von Java3D passt. Genau betrachtet sind es eben alles nur statische Geometrien die sich relativ zueinander bewegen. 

Willst Du aber jetzt z.B. die Bewegung einer menschlichen Hand realistisch darstellen, so das eben die unterliegenden kinematischen Strukturen wie Knochen, Muskeln, Sehnen und Blutgefässe Einfluss auf Form und Farbe der Haut haben, dann bist Du mit Java3D gekniffen. Toll das Java3D Shader unterstützt, aber es gibt nun mal "Dinge" die sich nicht so einfach in eine vorgefertigte OOP Struktur wie Java3D pressen lassen. Insbesondere bei multi pass render die teilweise auf- und ineinandergreifen. Spätestens dann musst Du selber in die Tasten greifen.

Ein schönes Beispiel zum Thema Haut(da nur statische) gibt es von Nvidia. Wenn jemand Lust hat, kann er ja mal versuchen das in Java3D zu implementieren. Bin mal gespannt ob die Struktur von Java3D dabei hilfreich oder hinderlich war . 

Gruß,
Fancy


----------



## Marco13 (26. Aug 2010)

Bin mal gespannt in welcher Ausgabe er die Augen mal auf macht


----------



## Guest2 (28. Aug 2010)

lol, ja da bin ich auch gespannt drauf. Der dazugehörige Artikel wird dann bestimmt auch wieder "spannend". 

Gruß,
Fancy


----------

