Linkdump

[Krishty]

Wahrscheinlich alles, was man über Physically-Based Rendering wissen kann: A Hitchhiker’s Guide to Multiple Scattering
http://www.eugenedeon.com/project/hitchhikers/

720 pages, 2000+ references

[joggel]

Ich will meinen CSG-Editor neu machen. Hat einige Gründe. Einer ist u.A. das mir das GUI von Qt nicht soooo sehr gefällt.
Also habe ich etwas rumgesucht.
Gefunden habe ich ein paar. Und die werfe ich hier mal ein (hab eher nur nach C++-GUI-Framework gesucht):

LibRocket
https://github.com/libRocket/libRocket
=> https://barotto.github.io/libRocketDoc/index.html


---------------------------------------
XTD
https://github.com/gammasoft71/xtd
=> https://gammasoft71.wixsite.com/xtdpro


---------------------------------------
GacUI
https://github.com/vczh-libraries/GacUI
=> http://gaclib.net/index.html


---------------------------------------
Sciter
https://sciter.com/


---------------------------------------
RmlUI
https://github.com/mikke89/RmlUi
=> https://mikke89.github.io/RmlUiDoc/


---------------------------------------
Nuklear
https://github.com/vurtun/nuklear


---------------------------------------
LiteHTML
http://www.litehtml.com/
=> https://github.com/litehtml/litehtml


---------------------------------------
GWork
https://github.com/billyquith/GWork
=> https://billyquith.github.io/GWork/


---------------------------------------
Ultralight
https://ultralig.ht/
=> https://github.com/ultralight-ux/Ultralight
=> https://github.com/ultralight-ux


---------------------------------------
NeoGFX
https://neogfx.org/
=> https://github.com/i42output/neoGFX


---------------------------------------
FLTK
https://www.fltk.org/


---------------------------------------
NanoGUI
https://github.com/wjakob/nanogui


---------------------------------------
Ultra App Kit
https://www.ultraengine.com/appkit



---------------------------------------
SixtyFPS
https://sixtyfps.io/

--------------------------------------------------------------------
Ist vlt etwas viel, aber wer weiß: Vlt ist das für irgend jemanden nützlich ¯\_(ツ)_/¯

[Jonathan]

Cool wäre es, wenn du die Liste noch evaluierst und schreibst, wofür du dich am Ende entschieden hast.
Wirklich gearbeitet hab ich nur mit einem der Frameworks, FLTK. Im Prinzip hält es zwar, was es verspricht, es ist klein, schnell zu benutzen, nicht so überladen und funktioniert. Ich habs dann aber doch schnell gegen Qt eingetauscht. FLTK war schon vor über 10 Jahren hässlich wie die Nacht und wenn man sich die Seite so anschaut, hat sich daran seit dem auch wenig verändert. Es hat zwar die wichtigsten Features, aber ich glaube damals fehlten ein paar Dinge die nett gewesen wären und es ist halt klein und unbekannt und wenn man eine Frage hat, findet man im Internet wenig dazu. Qt mag total überladen sein, aber das bedeutet eben auch, dass quasi jedes Feature das man sich wünschen kann schon drin ist und es für den Rest vermutlich irgendwo ein Addon gibt. Das man 20 MB dlls braucht ist dumm, aber letztendlich auch egal, wenn man hunderte MB an Grafik-Assets hat. Sprich: Die Vorteile von Qt gegenüber FLTK sind schon Dinge, die wirklich nützlich sind, während die Nachteile eher Dinge sind, die letztendlich eher egal sind.

[joggel]

Uff...um ehrlich zu sein, habe ich schon ne ganze weile nach Alternativen gesucht, und die Links dabei gesammelt.
Für was ich mich entscheide weiß ich absolut nicht.
Ich weiß ja nicht mal ob ich etwas aus der Liste nehme.
Ich wollts einfach mal hier hinschreiben, da es vlt für irgend jemanden interessant sein könnte....dachte ich mir.

Vlt ist die Liste auch ziemlich nutzlos...

[Jonathan]

Ne ach, das war eher als Verbesserungsvorschalg denn als Kritik gemeint. So im Sinne von: Wenn du mit der Liste noch weiter machst, wäre es nützlich die Erfahrungen dann hier auch einzupflegen.

[xq]

Die Liste verdient so schon ihren eigenen Thread imho. Das ist ne Goldgrube, ich kannte zum Beispiel 60FPS noch nicht, sieht aber vom "ersten Draufgucken" echt gut aus

[joggel]

Puuh!! Also doch keine absolute "Spam-Liste" 🤙

[joggel]

Hier kann man sich "Computer Vision - Algorithms and Applications (2nd edition)" runterladen.
Nur E-Mail angeben und man bekommt ein Link für eine PDF.
Hab's mal runtergeladen.
Haben ist besser als brauchen :P

[Krishty]

Raymond Chen erklärt, dass aktivierte C++-Ausnahmebehandlung auch auf x64 die Leistung bremst.

[xq]

Imho sehr lesenswerter Artikel über Projektion:
https://www.gamedeveloper.com/disciplin ... man-vision

[Jonathan]

Raymond Chen erklärt, dass aktivierte C++-Ausnahmebehandlung auch auf x64 die Leistung bremst.

Aber ist das, uhm, schlimm?
Ich bin gerade dabei ein C-Projekt (FreeType) zu debuggen, und wünschte es würde Exceptions benutzen. Es fing damit an, dass ich in der Konsole irgendeine Fehlermeldung habe und das Programm kurz danach abstürzt. Es gab keine Informationen zum Ursprung der Meldung, bloß einen Fehlercode und einen Fehlertext. Also habe ich Volltextsuche im Quellcode verwendet, habe damit aber nur eine errors.h gefunden, in der eben alle möglichen Fehlermeldungen mit Code und übersetzung aufgelistet werden. Ich habe ein paar andere Dinge ausprobiert, konnte aber über die Suchfunktion keine mögliche Quelle finden. Also Musste ich den Debugger anwerfen und immer durchsteppen, bis die Meldung in der Konsole erscheint, dann eine Zeile früher einen Breakpoint setzen, das Programm neu starten und dann in die Funktion reinspringen, anstatt sie zu überspringen. Das ging dann über 4-5 Ebenen so und hat ziemlich viel Zeit gekostet. Ganz am Ende kam ich irgendwo in einer Unterfunktion an in der die Fehlermeldung ganz anders lautete, aber scheinbar gab es eine Kollision mit den Fehlercodes oder so. Die Fehlermeldung die ich also ursprünglich sah war komplett nutzlos, weil sich die Fehlerquelle nicht ausfindig machen lies und der Text absolut nichts mit dem Problem zu tun hatte.
Hätte man jetzt stattdessen Exceptions benutzt und damit vernünftigen, wartbaren Code geschrieben (:P) hätte ich das Programm genau einmal ausgeführt und der Debugger hätte mich auf die Exception hingewiesen und hätte automatisch an genau der richtigen Stelle das Programm angehalten. Selbst ohne Debugger wäre halt zumindest die Fehlermeldung in der Exception korrekt gewesen.
Sorry, aber ich halte von diesem Performance-Argument nichts. Mir ist es schon so oft passiert dass ich mich mit irgendwelchem Code rumärgern musste, dessen Autor dachte irgendwas optimieren zu müssen, es falsch gemacht hat und es am Ende mehr Debug-Zeit gekostet hat als es jemals Laufzeit einsparen könnte. Und die Sache ist halt, so wirklich richtig machen kann man es eben nicht, Flüchtigkeitsfehler passieren halt einfach, das ist ganz unvermeidbar, die einzige Lösung ist so Dinge nicht von Menschen sondern von Computern machen zu lassen. Irgendwelche Fehlercodes über 20 Funktionsaufrufe hindurch durchzuschleifen ist für mich einfach kein vernünftiger Code...

[Krishty]

Wolltest du wirklich eine Frage zu dem Artikelthema stellen oder nur Frust über das Programm ablassen? ;)

Hätte man jetzt stattdessen Exceptions benutzt und damit vernünftigen, wartbaren Code geschrieben (:P)

Genau, der Smiley gehört auch dahin :D Hätte man vernünftigen, wartbaren Code geschrieben, hättest du kein Problem gehabt. Ob jetzt Exceptions oder nicht, das ist Geschmackssache; macht bei vernünftigem, wartbaren Code meiner Erfahrung nach aber auch keinen großen Unterschied.

Aber wenn du das schonmal vom Zaun brechen willst: Ich bevorzuge Code ohne C++-Ausnahmen, weil ich den unsichtbaren Ausführungspfad und die unsichtbaren Nebenwirkungen äußerst hinderlich finde.

In der Case Study „Da taucht ein Fehler auf, aber ich weiß nicht, wo“ hätten Ausnahmen auch nicht geholfen. Dass es mit den meisten Debuggern irre schwer ist, einen unbekannten Fehler beim Auftreten (throw) abzufangen statt beim Verarbeiten (catch), hilft auch nicht gerade. („Irre schwer“ bedeutet hier: Ich konnte noch nie jemandem in fünf Minuten beibringen, a) warum man einen Haltepunkt gerade in __cxa_throw() o.Ä. setzen muss; b) was die Funktion tut; c) was der Unterschied zwischen Programm, C++-Laufzeitbibliothek und Betriebssystem ist.) Ich weiß, dass du eher meintest, C++-Ausnahmen hätten das Programm besser strukturiert, aber da widerspreche ich ja auch (s. o.) …

Das Ganze taugt immerhin ganz gut als Red Flag. Kriege ich ein unbekanntes Projekt und finde darin eine eigene Ausnahmeklasse – die meist auch noch Strings in ihrem Konstruktor zusammenbaut – weiß ich sofort, dass da niemand Ahnung von Fehlerbehandlung hat und ich den Scheiß getrost ersetzen kann ;)

Zu deiner Frage, ob die Performance eine Rolle spielt: In den meisten Fällen nicht. Ich kämpfe ständig mit der Code Generation meiner Compiler; aber auch nur, weil meine Performance-Anforderungen über 99% des Codes da draußen liegen. Wenn man in irgendeiner inneren Schleife Strings zusammenbaut, ist es egal, ob der Compiler jetzt noch ein paar Stores überspringen kann oder nicht. Wenn man hingegen ich ist und die Stores und Bytes des Assemblys literälly zählt, macht es schon einen Unterschied. Und für Raymond Chen wohl auch.

[Jonathan]

Wolltest du wirklich eine Frage zu dem Artikelthema stellen oder nur Frust über das Programm ablassen? ;)

Oh, das waren 90% rumheulen und 10% sachlich diskutieren :D
Wenn ich mich ein paar Stunden mit so einem dummen Problem rumschlagen muss brauche ich einfach jemanden mit dem ich darüber reden kann, und die Vor- und Nachteile verschiedener Fehlerweitergabestrategien in C++ sind halt ein irgendwie spezielles Thema, zu dem nicht jeder was zu sagen hat. Und falls das noch nicht reicht finde ich jeden Post im ZFX nützlich um die Community am leben zu erhalten. Der gehts zwar aktuell ganz ok (klein aber fein), aber das soll ja auch so bleiben.

In der Case Study „Da taucht ein Fehler auf, aber ich weiß nicht, wo“ hätten Ausnahmen auch nicht geholfen.

Hm, in Visual Studio aktiviere ich "Break on Exception" und das funktioniert dann in der Regel auch. Ich hab in diesem Fall ja von allem den Code und mit Debugsymbolen kompiliert, und da sehe ich auch nicht, wo da ein prinzipielles Problem sein sollte. Also, gerade hier ging es ja auch darum, dass im Bibliothekscode eine Abfrage durchgeführt wurde und daraufhin ein Fehlercode gesetzt wurde. Ganz dumm sollte man also sogar einfach in jeder Zeile mit einem throw automatisch einen Breakpoint setzen können, und es sollte das tun, was ich will. Und warum man in einer Debug-Version von Laufzeitumgebungen nicht auch einfach anhalten könnte, versteh ich auch nicht. Also warum sagst du, dass das schwer ist? (Im Sinne von: Was ist deine Perspektive / Erfahrung / tiefergehendes Hintergrundwissen dazu?) Oder redest du davon, Exceptions im optimierten Release-Build automatisch zu erkennen?

Das Ganze taugt immerhin ganz gut als Red Flag. Kriege ich ein unbekanntes Projekt und finde darin eine eigene Ausnahmeklasse – die meist auch noch Strings in ihrem Konstruktor zusammenbaut – weiß ich sofort, dass da niemand Ahnung von Fehlerbehandlung hat und ich den Scheiß getrost ersetzen kann ;)

Naja. Was mich an Software allgemein aufregt, ist, dass es so wenig Leute schaffen, vernünftig Fehlermeldungen durchzureichen. Da arbeitet man irgendwas und ein Pop-Up taucht auf und dann steht da "Der Vorgang konnte nicht abgeschlossen werden" oder ähnliches. Klar, der normale Anwender will sich mit Details vielleicht nicht beschäftigen, aber ich denke mir dann immer, dass es irgendwo in den Tiefen des Programms einen ziemlich konkreten Hinweise darauf gibt, was gerade schief läuft, und ich den nutzen könnte um irgendwie strukturiert eine Lösung für das Problem zu finden, aber nö, all die nützliche Information wurde in irgendeiner Zwischenebene weggeworfen und ich kriege wenig mehr als "geht nicht" raus.
Und in diesem Sinne mag ich die Idee, z.B. in C++ Exceptions über mehrere Ebenen zu fangen, anzureichern und wieder zu schmeißen sehr. Ausnahmen sind ja Ausnahmen, diese Stringoperationen sollten ja, wenn alles gut geht, nie ausgeführt werden, da ist mir dann also egal wie langsam sie sind - im Extremfall würde ich auch gerne eine Sekunde länger warten, wenn dafür meine Fehlermeldung dann vernünftig ist. Und dann weiß ich halt z.B. in welchem Level welches Modell mit welcher Textur geladen werden sollte und dass da irgendein Problem mit dem Format aufgetaucht ist - also quasi eine Art Callstack der mich nicht nur zur Ursache führt sondern mir auch zeit wie es so weit kommen konnte. (weil ein "Width>MAX_WIDTH" ohne Kontext halt auch wertlos ist.)


Mein Problem lag übrigens in FfreeType. Auf einem anderen Rechner lief es, ich habe es parallel durchgesteppt, hab dann irgendwann an der untersten Ebene gemerkt, dass der Code auf beiden Rechnern unterschiedlich ist weil ich auf dem neuen halt die neuste Version installiert hatte und hab dann einfach auch dort die alte Version benutzt. Etwas unbefriedigend, aber von der Aufrufseite her konnte man eigentlich nicht viel falsch machen, also habe ich das mental als Bug in der neuen Version abgestempelt. Einen vernünftigen Bug-Report werd ich aber wohl nicht machen, da müsste man noch viel mehr herausfinden, wie genau der Fehler auftritt und so. Insgesamt also irgendwie eine unbefriedigende Lösung, aber naja.

[Krishty]

In der Case Study „Da taucht ein Fehler auf, aber ich weiß nicht, wo“ hätten Ausnahmen auch nicht geholfen.

Hm, in Visual Studio aktiviere ich "Break on Exception" und das funktioniert dann in der Regel auch.

Das Problem daran ist, dass es bei jeder Ausnahme anhält … Beispiel: Für Windows 10 wurde viel interner Code auf C++-Ausnahmebehandlungen umgestellt (für UWP?). Startest du den Standard-Dialog Datei > Öffnen …, fliegen 30 C++-Exceptions irgendwo in User32.dll und die IDE hält jedes. Mal. an.

Ausnahmen fliegen halt auch gern im normalen Programmverlauf … und mit der IDE-Einstellung setzt man meiner Erfahrung nach einen Haltepunkt bei jedem Fehler.

(Ich weiß nicht, ob Visual Studios Just my Code dem entgegenwirkt, aber das wiederum stört mich ständig, wenn ich mit externen Bibliotheken arbeite.)

Naja. Was mich an Software allgemein aufregt, ist, dass es so wenig Leute schaffen, vernünftig Fehlermeldungen durchzureichen. Da arbeitet man irgendwas und ein Pop-Up taucht auf und dann steht da "Der Vorgang konnte nicht abgeschlossen werden" oder ähnliches. Klar, der normale Anwender will sich mit Details vielleicht nicht beschäftigen, aber ich denke mir dann immer, dass es irgendwo in den Tiefen des Programms einen ziemlich konkreten Hinweise darauf gibt, was gerade schief läuft, und ich den nutzen könnte um irgendwie strukturiert eine Lösung für das Problem zu finden, aber nö, all die nützliche Information wurde in irgendeiner Zwischenebene weggeworfen und ich kriege wenig mehr als "geht nicht" raus.

Absolut richtig

Und in diesem Sinne mag ich die Idee, z.B. in C++ Exceptions über mehrere Ebenen zu fangen, anzureichern und wieder zu schmeißen sehr.

Ist eine Möglichkeit. Nicht meine Lieblingsmöglichkeit (dazu unten mehr), aber an sowas habe ich prinzipiell nichts auszusetzen.

Ausnahmen sind ja Ausnahmen, diese Stringoperationen sollten ja, wenn alles gut geht, nie ausgeführt werden, da ist mir dann also egal wie langsam sie sind - im Extremfall würde ich auch gerne eine Sekunde länger warten, wenn dafür meine Fehlermeldung dann vernünftig ist.

Das ging jetzt gar nicht um die Geschwindigkeit. (Übrigens Hinweis zum Artikel oben: Die Quintessenz ist, C++-Ausnahmen machen alles langsamer, nicht bloß den Fehlerfall!)

Warum ich gegen Strings in Exceptions wettere, sind 1) Lokalisierung und 2) die Trennung von Aufmachung und Inhalt. Wenn der Entwickler Inder war und seine Exception-Klasse Strings zusammenklatscht, bekommst du eben nicht die Meldung Error: Cannot open texture “foo”; file handles exhausted, sondern त्रुटि: 'foo' नहीं मिल रहा है: फ़ाइल समाप्त हो गई है. Uns englischsprachigen Nordhalbkugel-Übermenschen passiert das eher selten, aber wenn deine Programme z. B. nach Südamerika gehen, sind US-Fehlermeldungen für die ähnlich brauchbar wie gar keine Fehlermeldungen. Jetzt kannst du deine Übersetzung in die Exception-Klasse reinziehen, aber das macht außer diesem einen konkreten Problem alles nur schlimmer.

Das Markup-Problem: Ich schreibe Schnittstellen und breche Abhängigkeiten auf, damit man meine Algorithmen in unterschiedlichem Kontext wiederverwenden kann – in einem Konsolenprogramm, in einem GUI-Programm, in einem Spiel, in einem Dedicated Server. Die haben komplett unterschiedliche Anforderungen daran, wie der Fehlertext auszusehen hat – das Konsolenprogramm braucht vielleicht den Code \033[31m um den Fehler rot zu markieren. Das GUI-Programm braucht ein Klicken Sie OK um das Programm zu beenden hinten dran. Du kannst aber in deiner Exception-Klasse nicht wissen, in welchem Kontext du läufst – und wenn du’s tust, hast du nun eine Abhängigkeit mehr in deinem Code.

Wenn du also Ausnahmen hochreichst und anreicherst, muss das komplett auf logischer Ebene passieren, und der String darf frühestens im catch zusammengebaut werden, weil nur der Aufrufer entscheiden kann, was angezeigt werden soll. Also darf String-Formatierung um Himmels Willen nicht in die Ausnahmeklasse; erst recht nicht in den Konstruktor. Markup und Content trennen.

Jetzt nochmal zum oben versprochenen Grund, warum C++-Ausnahmen nicht meine Lieblingsmöglichkeit sind (und Return Values auch nicht): Manchmal möchte man Fehler ignorieren. throw fragt aber den Aufrufer mit dem catch nicht lieb, ob der überhaupt eine Ausnahme wünscht – es schmeißt einfach und zerstört alles zwischen throw und catch.

Ich habe hier viel mit Parsern und Compilern zu tun, und da willst du üblicherweise einen unbarmherzigen (strikten) Modus für deine eigenen Programme haben. Bei Fremdprogrammen oder gewissen Randfällen, die Hacks erfordern, möchtest du ausgewählte nicht-kritische Standard-Verletzungen aber lieber nur als Warnung behandeln, denn als Fehler. (So eine Einstellung hat ja jeder Compiler.) Bei Spielen ähnlich: Die Engine soll im Level-Editor jeden kleinen Fehler melden, aber das tatsächliche Spiel soll um Gottes Willen nicht den Start verweigern, weil irgendwo eine Sound-Datei mono statt stereo ist!

Ich reiche bei sowas grundsätzlich nur ein Interface rein, mit einer Methode pro Fehlertyp, à

  bool onInvalidVariableName(char const * name, enum NameViolation reason);

(aber halt via C realisiert weil Pörfohrmänz). Der Rückgabewert entscheidet ausschließlich: Weiter oder nicht. Kritische Fehler bieten keinen Rückgabewert, weil sie immer abbrechen. Ganz selten wird auch mal ein enum aus mehreren Möglichkeiten zurückgegeben, wie mach weiter aber ignoriere den Wert vs. mach weiter aber überschreibe den bestehenden Wert mit dem fehlerhaften.

Ob der Aufrufer die Fehlermeldung nun via Konsolenausgabe mit Farb-Code realisieren möchte, oder als Message Box, oder an eine in Echtzeit laufende Spiele-Engine weitergibt, oder eine Ausnahme wirft, oder das erst lokalisieren möchte, oder auf ERROR_PERMISSION_DENIED beim Öffnen einer Datei anders reagieren muss als auf ERROR_PATH_NOT_FOUND, oder den User erstmal in der Konsole y oder n eintippen lässt, ist mir dann egal. Kommt true zurück, mache ich weiter. Kommt false zurück, nicht. Und dann gebe ich auch keinen Fehler-Code hoch, weil der Aufrufer seine Fehlerbeschreibung schon bekommen hat, und wenn er die später noch braucht, muss er die selber speichern. Ist alles nicht mehr mein Problem. (Im Beispiel oben ist nicht einmal eine Zeilennummer drin, denn falls der Aufrufer die braucht, kann er sie sich aus dem Zeiger auf den Bezeichner selber berechnen. Schließlich hat er mir die Datei reingereicht – dann weiß er auch, an welcher Adresse sie beginnt, und kann die Newlines dazwischen zählen. Nicht mein Problem.)

Der Nachteil ist Tipperei, weil man nun für jeden Aufruf einmal diese Schnittstelle implementiert haben muss. Die gute Nachricht ist, dass auch diese sich wiederverwenden lässt.

[NytroX]

TLS Connection - every byte explained
https://tls13.ulfheim.net

[Krishty]

Shameless self promotion

Habe aufgeschrieben, wie man ein git-Repository optimiert (mache ich immer für meine Backups): http://krishty.com/articles/how-to-opti ... -repo.html

[Alexander Kornrumpf]

Shameless self promotion

Habe aufgeschrieben, wie man ein git-Repository optimiert (mache ich immer für meine Backups): http://krishty.com/articles/how-to-opti ... -repo.html

Hattest du nicht auch einen nicht-technischen Blog? Wie war da nochmal der Link?

[Krishty]

Hattest du nicht auch einen nicht-technischen Blog? Wie war da nochmal der Link?

http://gegennullkalkuliert.krishty.com
Den lasse ich aber ziemlich schleifen, und durch das weltpolitische Klima ist da auch gerade nicht viel Lustiges drauf.

[Alexander Kornrumpf]

Hattest du nicht auch einen nicht-technischen Blog? Wie war da nochmal der Link?

http://gegennullkalkuliert.krishty.com
Den lasse ich aber ziemlich schleifen, und durch das weltpolitische Klima ist da auch gerade nicht viel Lustiges drauf.

daraus:

Man kennt das ja: Kommt ein Programmierer in eine Bar und bestellt ein Bier. Kommt ein Tester hinterher und bestellt zwei Bier. Und null Bier. Minus acht Bier. Eine Milliarde Bier. Und ein Opossum.

Kommt ein User in die Bar und fragt wo die Toiletten sind. Die Bar explodiert.

[bruebaker]

Der ist echt gut (:

[x1m4]

Als Einstieg zum Thema Lichttransport sehr nützlich:

[Mirror]

https://www.spiegel.de/wissenschaft/men ... 50202.html

[Krishty]

Antoinette Project: tools to create the next generation of flight simulators

The Antoinette Project consists of:

• The Trends and Best Practices for Flight Simulation information paper, which describes guidelines to use Unreal Engine in this context. The paper also includes insights from users who are already using the engine to build solutions for their own needs.
   
• A DIY tutorial that illustrates how simple and fast it is to create a basic flight simulator. The tutorial provides detailed information on how to:
  • Connect input control devices for your pilot interface such as keyboard and mouse, gamepad, joystick, or flight-specific control device
  • Integrate an aircraft model from the Unreal Engine Marketplace
  • Add accurate flight dynamics using the open source JSBSIM plugin for Unreal Engine
  • Simulate flying above world data using the Cesium for Unreal or the ESRI ArcGIS Maps SDK for Unreal Engine
   
• A JSBSim plugin for Unreal Engine, […]
   
• The Antoinette Project demo, a proof-of-concept flight simulator with Unreal Engine at its core and […]

[x1m4]

https://www.spiegel.de/wissenschaft/men ... 50202.html

Hat mich an diesen CCC Vortrag zum Thema Deep Learning Paper, und deren schwierige Reproduzierbarkeit erinnert.

Könnte das Abnehmen der Reproduzierbarkeit evtl. mit der weltweit gestiegenen Anzahl an Studenten zusammenhängen?

Wenn ich an Studiengänge wie Ernährungswissenschaften denke, dann kommt es mir vor, als würde das heutige Studieren oft eher eine Trend Entscheidung, anstatt ein wirkliches Interesse an Wissenschaft zu sein. Mit völlig überlaufene Unis bis zum Punkt, dass man irgendwelche halbgaren Studiengänge wie Ernährungswissenschaften erfindet, nur um die Leute irgendwie zu beschäftigen und später dann als Fließbandware in die Wirtschaft einzuspeisen.

[Krishty]

https://en.wikipedia.org/wiki/Replication_crisis#Causes

[x1m4]

Interessant, danke für den Link

[Krishty]

The Designer’s Republic haben eine nervige Website, aber zumindest ist ein Haufen ihrer Artworks drauf: https://www.thedesignersrepublic.com/

Die wurden ja in den 90ern legendär, nachdem sie das Design für Wip3out usw. ins Leben riefen. Gute Inspiration.

[Alexander Kornrumpf]

https://pedunculate.substack.com/p/microservices

[bruebaker]

https://pedunculate.substack.com/p/microservices

Saugeil... 😀

[xq]

Eine Sammlung von PBR-Eigenschaften diverser Materialien:

https://physicallybased.info/