Beiträge von Sleepy

    Wieso muss ich die Highmap per Hand zeichnen,

    Das war doch deine Idee:

    Meine ursprüngliche Idee war es, eine 4098x4098 große Textur per Hand zu zeichnen, um genau definieren zu können, was an welcher Stelle im Spiel spawnen soll.

    Ich hab nur meine Gedanken dazu geschrieben.

    das eine hat doch mit dem anderen nichts

    Doch, hat es. Weil es einen Unterschied macht, ob du etwas dynamisch in Unreal generierst und diese Informationen direkt verwenden kannst oder ob du etwas von extern importierst was du dann irgend wie umwandeln musst und genau das ist jetzt dein Problem.


    Ich kann dir nur sagen, dass man sich manche Dinge besser vorher überlegen sollte und nicht erst, wenn alles fertig ist. Schade, ich habe mir echt Mühe gegeben und dir viele Informationen gegeben.

    Wenn dir meine Infos nicht gefallen oder du es sowieso besser weißt, kann dir jemand anders besser helfen.


    Ich bin hier jedenfalls raus viel Glück vielleicht kann dir jemand anderst helfen.

    Meine ursprüngliche Idee war es, eine 4098x4098 große Textur per Hand zu zeichnen, um genau definieren zu können, was an welcher Stelle im Spiel spawnen soll. Das hätte mir die Möglichkeit gegeben, sehr präzise zu arbeiten und die Spawn-Punkte genau zu kontrollieren. Allerdings bin ich mittlerweile am Überlegen, ob das wirklich der beste Weg ist. Der Aufwand, so eine große Textur manuell zu erstellen, ist enorm, und ich frage mich, ob es nicht effizientere Methoden gibt.

    Nein, das ist nicht der richtige Weg. Ich denke, du musst erst einmal verstehen, wie eine Map technisch überhaupt funktioniert.

    Wie es nicht funktioniert:

    Angenommen, du erstellst eine Plane in Blender und bearbeitest sie beispielsweise durch Sculpting. Anschließend könntest du das Mesh in Unreal importieren und als Static Mesh verwenden.


    Das Problem dabei und warum es so nicht gemacht wird:


    Die enorme Größe der Map macht diesen Ansatz ineffizient.

    Nehmen wir an, du verwendest eine 4096 × 4096 Pixel große Textur und skalierst das Terrain nicht. Das bedeutet, dass dein Terrain exakt 4096 × 4096 Meter groß ist.

    Das führt zu einem gravierenden Problem: Dein Terrain hätte nur ein Pixel pro Quadratmeter. Selbst Minecraft nutzt mindestens 16 Pixel pro Block.

    Das ist, wie gesagt, das Szenario, wie man es nicht macht.

    Wie man es macht und warum:

    In Unreal Engine erstellt man ein Terrain, das direkt innerhalb der Engine skulptiert und bemalt werden kann. Es sieht so aus, als würde das Terrain physisch verändert – ähnlich wie in Blender oder ZBrush –, doch in Wirklichkeit passiert etwas anderes:

    Höheninformationen werden in einer Heightmap gespeichert, die nur Farben enthält, um Höhenwerte zwischen 0 und 1 zu definieren.

    Das Terrain wird also durch ein Koordinatensystem in Bildform (Heightmap) erzeugt und dabei dynamisch nur dann dargestellt, wenn der Spieler hinsieht.

    Dynamische Detailstufen durch Tessellation:

    Das Terrain kann tesselliert werden, also je nach Blickrichtung dynamisch unterteilt werden:

    • Schaut man weg → Das Terrain bleibt flach und mit niedriger Auflösung.
    • Schaut man hin → Die Auflösung steigt, indem das Terrain feiner unterteilt wird (mehr Dreiecke entstehen).

    Das ist der Sculpting-Part und zeigt, wie das Terrain effizient verwaltet wird.

    Texturierung des Terrains:

    Wie oben bereits erwähnt, kann man auf ein 4K × 4K Terrain nicht einfach eine einzelne 4K-Textur legen – das wäre völlig unzureichend.

    Deshalb werden Terrains in Layern aufgebaut.

    Beispiel:

    Du malst "Wiese" auf dein Terrain. Statt eine einzige Textur aufzulegen, sorgt das Layering dafür, dass die Wiese in einer bestimmten Auflösung dargestellt wird.

    Der Unterschied zu einem Mesh:

    • Bei Meshes werden Pixelinformationen in einer UV-Koordinate von 0 bis 1 gespeichert.
    • Bei Terrains hingegen können Vertex-Informationen direkt in den Vertices gespeichert werden.

    Im Prinzip wird für jeden Punkt des Terrains gespeichert, welches Material an dieser Stelle und in der Umgebung sichtbar sein soll.

    Man kann sich das vorstellen wie ein Karopapier, das mit Buntstiften ausgemalt wird. Anstatt Farben einfach nur aufzutragen, werden einzelne Farbschichten ausgeschnitten und übereinandergelegt, bis ein vollständiges Bild entsteht.

    Das bedeutet:

    Ein Terrain wird nicht wirklich "bemalt", sondern es wird maskiert, welches Material an welcher Stelle sichtbar sein soll – vergleichbar mit einer Material-Maske.


    Eine Heightmap von Hand zu malen wäre, als würde ein Arzt eine Röntgenaufnahme selbst mit einem Stift zeichnen.

    Es gibt spezielle Programme, die zur Erstellung von Heightmaps entwickelt wurden.

    In der Regel funktioniert es genau umgekehrt: Man generiert aus einer vorhandenen Heightmap weitere Daten. Diese Heightmap wird übrigens im RAW-Format gespeichert, das weit über 4K hinausgehen kann.


    Man verwendet auch keine riesigen Heightmaps mit zb 16km am verwendet dann mehre kleine Heigtmaps die nacheinander geladen werden.


    Sorry wen ich auf das Spawnen nicht eingehe aber ich finde es komisch 2 unterschiedliche Themen in einem Thread zu thematisieren. Entweder du erstellt zum Spawnthema einen extra Thread oder ein Thema nach dem anderen. Sonst wird der gesamte Thread super Chaotisch.

    Ich habe DayZ nie gespielt und kenne die Map aus der Bildgenerierung nicht.

    Wenn ich aber ins Blaue raten darf, würde ich eher annehmen, dass es genau umgekehrt ist: Nicht das Level wird aus einem Bild generiert, sondern das Bild wird aus dem Level generiert. Minimaps werden in Spielen häufig auf diese Weise erstellt.

    Falls du jedoch mehr Details zum DayZ-System hast, würde mich interessieren, wie das technisch funktioniert und warum sie es auf diese Weise gelöst haben.


    Houdini ist eigentlich genau das was du bräuchtest. Leider ist die Houdini Version mit Unreal Engine Plugin nicht kostenlos.

    Dafür gibt es viele Lösungen, daher erst einmal ein paar Fragen:

    • Warum gehst du diesen Weg? Warum möchtest du die Zonen aus einer Pixeldatei berechnen?
    • Planst du, verschiedene Bilddateien zu generieren und daraus Levels zu erstellen?
    • Falls ja, warum generierst du die Maps extern? Das erscheint mir etwas umständlich.

    Ich würde das Generieren der Zonen direkt in Unreal vorschlagen. Dadurch hast du viel mehr Möglichkeiten, insbesondere wenn es um das dynamische Erstellen von Levels geht.

    Du könntest beispielsweise auch den umgekehrten Weg gehen:

    • Statt die Zonen aus einer Textur zu berechnen, könntest du zufällige Positionen nehmen und daraus Zonen generieren, die dann eine zufällige Farbe erhalten.
    • Der Spieler würde die farblichen Zonen sehen, während Unreal intern mit festen Zahlen arbeitet, um Berechnungen durchzuführen.

    Vielleicht kannst du dazu noch mehr Informationen geben?

    Einige Überlegungen:

    1. Dynamisches Mesh für Zonen
      • Du könntest ein dynamisches Mesh generieren, das vier farbige Zonen erstellt.
      • Vorteil: Das Generieren geschieht direkt in Unreal und ist zu 100 % dynamisch.
      • Du könntest sogar Seed-Werte verwenden, um bestimmte Zonen erneut zu generieren.
    2. Farbige Bereiche aus der ColorID berechnen
      • Falls du dennoch die Textur-Variante nutzen willst, müsste man sich genau überlegen, wie man die Zonen berechnet.
    3. Zonen anhand der UV-Koordinaten bestimmen
      • Falls die Farbvergabe über die UVs erfolgt, könntest du die Positionen direkt aus den UVs ableiten.
      • Ein UV-Layout ist im Grunde ein Koordinatensystem mit X- und Y-Werten.

    Ein potenzielles Problem: Pixelfehler & Aliasing

    Ich habe allerdings Bedenken:

    • Pixelfehler können auftreten, besonders durch Skalierung und automatische Anpassung.
    • Durch Antialiasing könnten deine 4 klar definierten Zonen in einen "Pixelmatsch" umgerechnet werden.
    • Beispiel: Eine Kante zwischen Rot und Grün kann durch Antialiasing zusätzliche Zwischenfarben erzeugen.
    • Dadurch entstehen mehr als 4 Farben, was die Zonen-Erkennung ungenau machen könnte.

    Das Problem ist abhängig davon, wie die Umrechnung erfolgt.

    Vielleicht wäre eine Mesh-basierte Lösung robuster, anstatt eine Pixelgrafik zur Zonenbestimmung zu nutzen?

    Was hältst du davon? 😊


    Ich will dir das nicht ausreden aber ich muss es erstmal genauer verstehen warum und wieso.


    Bedenken auch: in der Spieleentwicklung wird wie bei einem Zaubertrick sehr viel getrickst. Was man sieht ist oft nicht dass was im Hintergrund passiert ist.


    PS: Was mir noch eingefallen ist dass über Vertex Color zu lösen. Du könntest beispielsweise eine Plane in Blender bemalen und die Vertex Positionen nutzen um Zonen zu Generieren. Der Workflow wäre auch nicht dynamisch aber das Auslesen der Positionen vermutlich einfacher.

    Hallo,

    ich bin gerade dabei, mir einen eigenen Importer über das Editor Widget Tool zu erstellen.

    Was ich vorhabe:

    Der Export:

    1. Ich möchte eine FBX-Datei aus meinem 3D-Programm Maya exportieren. Das gesamte Level besteht in Maya aus Instanzen. Mein Export-Skript erkennt diese Instanzen und exportiert jedes Mesh nur einmal. Gleichzeitig erzeugt mein Python-Skript eine CSV-Datei, in der alle Positionen und Rotationen aller Objekte gespeichert werden – auch von denen, die nicht exportiert werden, weil sie Instanzen sind.

      Beispiel:

      Mein Level besteht aus:

      • 1×10 derselben Wand,
      • 1×5 derselben Decke und
      • 1×5 demselben Boden.

      Mein Skript exportiert nun einmal die Wand, einmal die Decke und einmal den Boden. Zusätzlich speichert es alle Positionen und Transformationsdaten als CSV-Datei, sodass ich das Level in Maya aus den Meshes und den Transform-Daten rekonstruieren kann.

    Der Import:

    2.In Unreal importiere ich die gesamte Szene mit folgendem Skript:


    Nachdem dieses Script über Execute Python Command ausgeführt wurde, kommt direkt die Anzeige im Viewport. Das passiert mit diesem Script:


    Was als nächstes kommt ist die Automatische Material vergabe mit Set Material so weit bin ich aber noch nicht.


    Nur Zur Frage:

    Es gibt noch ein Löschscript:

    Mit diesem Skript werden alle Meshes im Target Folder "Import Mesh" gelöscht.

    Der Import funktioniert, die Platzierung funktioniert, und das Löschen funktioniert ebenfalls.

    Mein Problem:

    Wenn ich die Meshes nach dem Import im Content Browser manuell auswähle und lösche, geht der Vorgang sehr schnell. Zudem wird eine Bestätigungsmeldung angezeigt, in der steht, welche Meshes gelöscht werden. (Das ist der normaler Löschvorgang wie ihn jeder kennt)

    Wenn ich jedoch das Lösch-Skript verwende, dauert der Vorgang sehr lange und es wird keine Fortschrittsanzeige angezeigt.

    Hat jemand eine Idee, warum das so ist? Gibt es möglicherweise einen spezifischen Löschbefehl, der effizienter ist? Vielleicht sieht auch jemand einen Fehler in meinem Skript?


    PS.: Der CSV Import fehlt in diesem Script noch komplett dieser soll später als Datatable erfolgen. Ich möchte auch einen Reimport einbauen wenn sich die Dateigröße des Meshes verändert.

    Mhhh, da fallen mir drei mögliche Gründe ein:

    1. Anti-Aliasing oder Super Sampling ist zu niedrig

    Unreal nutzt TSR (Temporal Super Resolution) als Standard-Anti-Aliasing. In VR kann das jedoch zu Problemen führen.

    • Lösung: Gehe zu Project Settings → Rendering und ändere das Anti-Aliasing von TSR auf MSAA oder FXAA.

    2. Z-Fighting durch Translucent Material

    Da du von einem Widget sprichst, könnte es als Translucent Material gerendert werden, was zu Z-Fighting führt.

    Was ist Z-Fighting?

    Wenn zwei Flächen in der Tiefe genau aufeinander liegen, kann die Grafikkarte nicht entscheiden, welches Pixel zuerst gezeichnet werden soll. Dadurch wechseln die Objekte ständig und es entsteht ein Flackern.

    • Lösung: Ändere das Material von Translucent auf Opaque oder Masked.
    • Falls Transparenz erforderlich ist, verwende Opacity Mask Clip Value.

    3. Pixel Density in VR zu niedrig

    In VR ist die Pixel Density entscheidend. Eine zu geringe Renderauflösung kann zu Flackern führen.

    • Lösung: Erhöhe die Pixel Density unter Project Settings → VR → HMD Scaling Factor auf 1.5 oder 2.0.
    • Falls du eine Nvidia-GPU nutzt, kannst du zusätzlich VRSS (Variable Rate Supersampling) für bessere Qualität aktivieren.

    4. Widget als Screenspace rendern

    Statt das Widget in der Welt zu platzieren, rendere es auf einer Plane als Screenspace Widget (Canvas-UI).

    • Lösung: Stelle sicher, dass die Widget-Komponente auf "World" eingestellt ist.

    5. Problem durch Raytracing oder Lumen

    Falls das Problem durch Raytracing oder Lumen verursacht wird:

    • Lösung: Deaktiviere Lumen testweise und überprüfe, ob das Problem verschwindet.
    • Falls ja, probiere eine andere Reflection-Methode, z. B. SSR (Screen Space Reflection).

    failed to open file. this is most likely because this map was saved with a newer version of unreal engine

    Das bedeutet, dass die Map in einer neueren Version gespeichert wurde als die Version, die du gerade verwendest.

    Hast du die Map selbst erstellt, oder ist sie gekauft bzw. von einer anderen Quelle?


    Du kannst nachschauen, in welcher Version die Map gespeichert wurde. Schau dazu in die Datei:


    DeinProjekt/Config/DefaultEngine.ini

    Dort findest du den Eintrag EngineAssociation, der die verwendete Unreal Engine-Version angibt.

    Alternativ kannst du auch den Saved-Ordner überprüfen. Unter:


    DeinProjekt/Saved/Logs/

    gibt es eine Logdatei, z. B.:


    Projektname.log (Projektname = Name deines Projekts)


    Darin kannst du nach dem Eintrag "Running engine version" suchen.

    So solltest du herausfinden können, welche Engine-Version du benötigst.

    World Partition ist relativ neu und eine bessere Lösung. Mit World Partition kann man Levels auch auf mehrere Benutzer aufteilen, sodass verschiedene Level-Designer gleichzeitig an bestimmten Bereichen der Map arbeiten können –


    das ist ziemlich cool!


    Ich sehe aber gerade, dass World Partition automatisches Level Streaming unterstützt, während das klassische Level Streaming manuell verwaltet werden muss.


    Ich kenne mich mit World Partition noch nicht so gut aus.


    Falls du es testest, prüfe, ob du bestimmte Bereiche der Map separat bearbeiten kannst. Vieleicht kannst du mit einer Riesen Map starten aber erstmal eine kleine Map einrichten.

    Hier gibts ein Video dazu und mehr ist es eigentlich auch nicht.

    Externer Inhalt www.youtube.com
    Inhalte von externen Seiten werden ohne Ihre Zustimmung nicht automatisch geladen und angezeigt.
    Durch die Aktivierung der externen Inhalte erklären Sie sich damit einverstanden, dass personenbezogene Daten an Drittplattformen übermittelt werden. Mehr Informationen dazu haben wir in unserer Datenschutzerklärung zur Verfügung gestellt.

    Vielen lieben Dank für deine ausführliche Erklärung. Ich wollte von Anfang an darauf achten, keine Performance-Probleme direkt schon am Anfang beim Erstellen des Landscapes zu erzeugen. Ich habe gehört, dass eine Overall Resolution von 4033x4033 bereits zu viel sein könnte, während jemand anderes sagt, dass 1009x1009 perfekt ist. Wieder andere empfehlen für eine Open World eine Auflösung von 2017x2017, da diese eine gute Balance zwischen Performance und Details bietet. Zudem wurde mir gesagt, dass die Anzahl der Komponenten (z. B. 8x8 auf 256x256) die Performance ebenso beeinflusst, da höherer Wert = mehr Rechenleistung

    Ich würde sagen, das kann man so pauschal nicht sagen. Es kommt darauf an, was du sonst noch in deinem Spiel hast.

    Grundsätzlich sollten Auflösungen und Größen immer eine Power of Two sein, also durch 2 teilbar.

    Daher kommen auch die typischen Werte: 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048 usw.


    1029 oder 4033 sind hingegen nicht ideal.

    Das liegt daran, dass Informationen in Bits gespeichert werden – also in Nullen und Einsen. Power-of-Two-Werte sind daher die effizienteste Art, Daten zu speichern und zu verarbeiten.

    Mein Plan war, etwa 120 km² zu erreichen, um genug Platz für die Insel zu haben,

    Dann verwende doch einfach mehrere kleinere Maps und kombiniere so viele, dass sie in der Summe auf 120² km kommen. Theoretisch kannst du dann jederzeit weitere Maps hinzufügen.

    Schau dir dazu auch mal das Level Streaming an. Es ermöglicht dir, speichereffizient zu arbeiten und die Performance zu verbessern.

    Du kannst dein Spiel beispielsweise in verschiedene Level unterteilen – vergiss dabei erstmal, was du normalerweise unter einem „Level“ verstehst.

    1. Wenn du dein Spiel startest, wird zunächst ein leeres Level geladen – das sogenannte Persistent Level. Dieses Level enthält anfangs nichts. Sobald es gestartet ist, wird das Menü als Sublevel ins Persistent Level geladen. Sobald das Menü angezeigt wird, beginnt im Hintergrund bereits das Vorladen des Startbereichs.
      Drückst du nun im Menü auf „Spiel starten“, wird das gesamte Startlevel angezeigt. Wenn das Level im Hintergrund geladen wurde, geschieht dies on the fly. Menü wird ausgeblendet und das Startlevel wird eingeblendet.
    2. Während du dich auf der Map bewegst und beispielsweise einen Randbereich erreichst, kannst du weitere Landschaftsabschnitte nachladen und gleichzeitig nicht mehr benötigte Gebiete aus dem Speicher entfernen.
    3. Wenn du Bäume pflanzen möchtest, muss der Wachstumsprozess in der Programmierung gesteuert werden. Das bedeutet, dass die Informationen zum Wachstum des Baumes aus einer Datenbank oder Tabelle abgerufen werden – nicht durch das bloße Abspielen einer Animation oder das Verstreichen einer bestimmten Zeit.

    bei Fortnite wird das zb auch so gemacht. Sie können bestimmte Bereiche im Spiel umbauen während andere Bereiche so bleiben wie sie sind. Jeder Bereich kann man sich als separtes Level vorstellen auch wenn es für den Player natürlich ein riesiges Level ist.

    Vielen Dank für die lehrreiche Erklärung. Nun frage ich mich, was die perfekte Balance zwischen Details und Performance ist. Ich möchte eine 120 km² große Map und weiß nicht, wie und was ich bei den Parametern einstellen soll, ohne am Scale zu drehen, da du sagst, dass es nicht empfehlenswert ist.

    Das ist die große Frage. Performance-Probleme kannst du nicht nur durch das Terrain bzw. die Displacement-Map bekommen, sondern auch durch die Schattenberechnung, die Kollisionsberechnung, die Größe der Texturen, die Anzahl der Polygone, Partikeleffekte usw.


    Es ist unmöglich dass im Vorfeld zu berücksichtigen. Es kommt ja schließlich auch darauf an auf welchem PC dein Spiel später laufen soll.


    1. FPS und Drawcalls

    Ob dein Spiel flüssig läuft, hängt überwiegend von der FPS (Frames per Second) ab – also davon, ob deine Grafikkarte (GPU) schnell genug die Befehle der CPU verarbeiten kann.

    Stell dir vor, die CPU schickt eine Postkarte an deinen Monitor (GPU) mit dem Befehl:

    "Hey, zeichne mir einen Strich von Position XYZ nach XYZ in Farbe XYZ usw."

    Diesen Befehl nennt man Drawcall. Wenn es zu viele Drawcalls gibt, kann der PC nicht mehr schnell genug die Frames zeichnen – das führt zu Lag.

    2. Tiefenpuffer (Z-Puffer) in Unreal Engine

    Die häufigste Rendermethode in Unreal ist der Tiefenpuffer (Z-Puffer). Einfach gesagt bedeutet das:

    Die GPU zeichnet zuerst, was sich im Hintergrund befindet, und übermalt dann die Objekte immer wieder von hinten nach vorne.

    Ein Problem dabei ist das Depth Sorting:

    • Objekte werden nach ihrer Entfernung zur Kamera sortiert, damit Unreal weiß, was zuerst und was zuletzt gezeichnet wird.
    • Beim Berechnen der Entfernung kann es jedoch zu Fehlern kommen, insbesondere bei transparenten Objekten.

    3. FPS-Optimierung & Culling

    Wichtig ist, wie viele FPS du in einem bestimmten Moment im Spiel hast. Frame-Drops können z. B. auftreten, wenn du 100 Rauchgranaten abfeuerst und gleichzeitig 10.000 Objekte gespawnt werden.

    Du musst vermeiden, dass zu viele Drawcalls entstehen und deine GPU überlastet wird.

    Es ist besser, wenn die CPU einen langen Brief an die GPU schickt, anstatt viele kleine Briefe.

    Jeder Brief muss von der GPU geöffnet, gelesen und verarbeitet werden. Große Briefe (z. B. große Meshes) sind oft performanter.

    Aber: Ein einziges riesiges Mesh wäre auch nicht optimal, weil das Laden dann zu lange dauert.

    4. Culling – Das Geheimnis der Performance

    Um die Performance zu verbessern, gibt es Culling-Methoden. Diese sorgen dafür, dass nur das gerendert wird, was wirklich notwendig ist. Hier sind einige wichtige Richtlinien:

    1. Frustum Culling – Es wird nur gerendert, was sichtbar ist

    • Wenn du auf den Boden schaust, muss nur der Boden angezeigt werden.
    • Deshalb gilt: Bist du nah an einem Mesh, kann der Polycount hoch sein, weil weniger Objekte sichtbar sind.
    • Bist du weiter weg, sieht man mehr Objekte – diese sollten dann einen niedrigen Polycount haben.
    • Das Umschalten zwischen verschiedenen Detailstufen nennt man LOD (Level of Detail).

    2. Camera Occlusion Culling – Unsichtbare Objekte ausblenden

    Das blendet Objekte aus, die von anderen Objekten verdeckt werden.

    Beispiel: Du stehst vor einem Haus und kannst durch das Fenster hineinsehen.

    a) Wenn das Haus ein einziges großes Mesh wäre, müsste die Engine entweder alles anzeigen oder gar nichts – das würde zu langen Ladezeiten führen.

    b) Besser: Die Fassade als separates Mesh modellieren.

    • Wenn du draußen stehst, wird nur die Fassade angezeigt.
    • Erst wenn du durchs Fenster schaust, wird z. B. die Küche gerendert – die anderen Räume bleiben ausgeblendet.

    5. Die Balance finden

    Es gibt noch weitere Culling-Methoden, aber das Wichtigste ist:

    Du musst die richtige Balance finden zwischen Polycount, Meshgröße, Anzahl der Materialien und der Anzahl der Meshes.


    Wenn du noch am Anfang stehst, ist es sicherlich gut das zu wissen aber zum experimentieren musst du dass vielleicht noch nicht unbedingt beachten.


    Das ist wie bei der Fahrschulprüfung dort lernt man alles perfekt aber in echt schaut man dann doch nicht immer in den Spiegel.

    Hey, willkommen im Forum!


    1. Scale (Skalierung)

    Bestimmt die Größe des Terrains in Unreal Units (UU). Standardmäßig gilt: 1 UU = 1 cm.

    Theoretisch könntest du einstellen, dass 1 UU = 100 cm ist, aber das würde ich nicht empfehlen.

    2. Section Size (Sektionsgröße)

    Definiert die Anzahl an Segmenten pro Abschnitt. Stell dir das Terrain wie kariertes Papier vor – ein Kästchen entspricht einem Abschnitt, der weiter unterteilt werden kann.

    Für ein Low-Poly-Terrain sollte man hier eher einen niedrigen Wert wählen.

    3. Sections Per Component

    Eine Komponente besteht aus mehreren Sektionen. Hier wird also festgelegt, wie viele Sektionen eine einzelne Komponente enthält.

    4. Number of Components (Anzahl der Komponenten)

    Mehr Komponenten bedeuten ein größeres Terrain. Hier bestimmst du also, wie viele Kästchen dein Terrain haben soll.

    5. Overall Resolution (Gesamtauflösung)

    Legt die Gesamtanzahl der Quads im Terrain fest.

    Es ist das Endergebnis aller vorherigen Einstellungen und bestimmt die finale Detailgenauigkeit der Landschaft.


    Beispiel: 8 km × 8 km Terrain

    Parameter:

    • Overall Size: 127 × 127
    • Sections Per Component: 2 × 2
    • Number of Components: 32 × 32

    Struktur des Terrains:

    • Quads = kleinste Einheit des Terrains
    • Sections = Gruppe von Quads
    • Components = Gruppe von Sections
    • Gesamtes Terrain = Gruppe von Components

    Berechnung der Quads:

    1. Jede Section hat 127 × 127 Quads.
    2. Eine Component besteht aus 2 × 2 Sections, also: 127×2=254127 \times 2 = 254127×2=254 Jede Component hat also 254 × 254 Quads.
    3. Das Terrain besteht aus 32 × 32 Components, also: 254×32=8128254 \times 32 = 8128254×32=8128 Das gilt für die X- und Y-Richtung.
    4. Overall Resolution: Da der Rand noch ein zusätzliches Quad benötigt: 8128+1=81298128 + 1 = 81298128+1=8129 Finale Overall Resolution: 8129 × 8129 Quads.

    Berechnung der Terrain-Größe in km:

    In Unreal gilt:

    • X-Scale = 100 UU = 100 cm = 1 m
    • Y-Scale = 100 UU = 100 cm = 1 m

    Overall Resolution×Scale=8129×100=812,900 cm


    =8.129 km

    Endergebnis:

    Das Terrain ist ca. 8 km × 8 km groß.


    Wichtig: Alle Werte sind relativ zum Terrain.

    1. Nehmen wir an, du importierst einen Charakter.
    2. Du erstellst ein 8 km × 8 km Terrain.
    3. Du skalierst den Charakter um den Faktor 10.000.
    4. Du skalierst das Terrain ebenfalls um den Faktor 10.000.

    Wenn du jetzt den Pinsel einstellst, müsste dieser theoretisch auch einen Wert von 10.000 haben. Falls du stattdessen alles kleiner skalierst, hättest du sehr viele Nachkommastellen – und Unreal kann mit extrem kleinen Werten irgendwann nicht mehr richtig umgehen.

    Dein Pinsel kann nicht 0,0000000001 oder 1000000000000000 groß sein.

    Wenn du mit solchen extremen Skalierungen arbeitest, müsstest du auch die Physik-Werte entsprechend anpassen – z. B., um eine realistische Fallgeschwindigkeit von einer 2-Meter-Leiter zu erhalten.

    Fazit:

    Arbeite IMMER mit dem echten Scale!

    Am besten veränderst du den Scale nicht in Unreal, da dies die Werte beeinflusst und zu Problemen führen kann.

    Falls du die Skalierung anpassen willst, mache das in einem 3D-Programm und setze dort die Transforms auf 0. Dadurch werden nach dem Import in Unreal keine seltsamen Werte wie X = 45, Y = 18, Z = -20 angezeigt, sondern XYZ = 0.

    Eine Warnung vorab: Die Idee hinter Displacement ist genau das Gegenteil – also nicht für Kollisionen genutzt zu werden. Wenn man eine Displacement-Map in ein 3D-Mesh umwandeln würde, entstünde ein extrem komplexes Modell, bei dem die Kollisionsberechnungen sehr aufwendig wären.

    Aus Performance-Gründen ist das keine gute Idee. Das nur mal als Disclaimer.

    Möglichkeiten zur Lösung:

    1. Simple Collision funktioniert nicht mit Displacement.
    2. Tessellation-Kollision aktivieren
      Falls du Tessellation nutzt (was vermutlich der Fall ist), kannst du in den Landscape Settings die Option "Use Tessellation Collision" aktivieren. Das funktioniert jedoch noch nicht mit Nanite – daran wird derzeit gearbeitet.

      Diese Methode ist aber aus Performance-Sicht die schlechteste, da sie extrem rechenintensiv ist. Technisch gesehen wäre es genau das, was du suchst, aber nicht die beste Lösung.

    3. Bessere Lösung: Physik-Proxy verwenden
      Wie bereits erwähnt, ist die Kollision bei Displacement sehr komplex.

      Ein Collider ist im Grunde eine zweite Hülle, die über das eigentliche Objekt gelegt wird – vergleichbar mit einer Jacke oder Hose, die perfekt am Körper sitzt.

      Ein Mesh Collider ist eine 1:1-Kopie des ursprünglichen Meshes und wird als Kollisionsform genutzt. Doch genau das ist nicht gut für die Performance.

      Stell dir einen Türrahmen mit sehr feinen Details vor – mit sichtbaren Nägeln und ausgearbeiteten Holzmaserungen. Würde man für so ein detailliertes Objekt eine exakte Kollision berechnen, wäre das extrem aufwendig. Deshalb nutzt man in solchen Fällen ein Proxy Mesh – also ein vereinfachtes Modell mit weniger Details (ohne Nägel etc.).

      Wenn du also dein Terrain als 3D-Mesh exportierst und dieses stark reduzierst (als grobe Form des Terrains), kannst du es als vereinfachtes Collision Mesh nutzen.

      Dieses Kollisions-Mesh wäre für den Spieler unsichtbar, aber deutlich performanter, da es eine einfache Geometrie hat.

    In der Spieleentwicklung wird viel getrickst – und zwar so, dass der Spieler es nicht merkt. Terrains bestehen oft aus einer Kombination von Heightmaps, Displacement, Vertex Paint und verschiedenen Meshes, z. B. Straßen, Häusern oder Felsen.

    Auf diese Weise lassen sich bestimmte Details oder Übergänge im Terrain geschickt verbergen. Mehrere Terrains können ebenfalls eine Lösung sein, und es gibt verschiedene Blend-Methoden, um sie nahtlos miteinander zu verbinden.


    Das schöne bei einer Terrain Mesh Kombination ist auch, dass das Culling Meshes ausblenden kann die nicht im Sichtbereich des Players liegen.

    Oder anderst gesagt:

    Hast du ein Komplexes Terrain hat dein Rechner viel zu berechnen. Hast du Meshes in deiner Szene die gerade nicht gesehen werden, müssen diese gar nicht berechnet werden.

    Daher kann es manchmal sinnvoll sein das Terrain nicht zu sehr mit Details vollzustopfen und mehr auf das Culling zu vertrauen.


    Zum Thema Performance kannst du dir auch mal das Levelstreaming anschauen.


    Ein Gedanke:

    Du befindest dich auf einem Terrain. In der Mitte dieses Terrains gibt es eine Triggerbox, die etwa 60 % kleiner ist als das Terrain selbst. Das bedeutet, dass es außerhalb der Triggerbox einen Bereich gibt, der nicht abgedeckt ist – eine Art Todeszone, in der das Levelende droht.

    Solange du dich innerhalb der Triggerbox befindest, ist alles in Ordnung. Doch sobald du sie verlässt und Gefahr läufst, in die Endlosigkeit zu stürzen, wird das nächste Terrain eingeblendet. Befindest du dich dort in der Triggerbox, wird das vorherige Terrain ausgeblendet.

    Der Spieler merkt davon nichts, aber du kannst mehrere kleine Terrains statt eines großen verwenden. Dadurch wird die Kollisionsberechnung weniger komplex und die Performance verbessert sich.


    Wenn man von Performance spricht meint man meistens die Frame Darstellung pro Sekunde. zb keine Ruckler und ein flüssiger Spielverlauf.


    Es gibt aber noch einen weiteren Nachteil, insbesondere bei großen Meshes – nicht nur ihre Größe an sich, sondern auch die Dateigröße in Kilobytes oder Megabytes kann sehr hoch sein. Für einen Rechner macht es einen großen Unterschied, ob er ein 4-GB-Mesh einblenden soll oder ein Mesh, das nur wenige Kilobytes groß ist.

    Das gilt besonders dann, wenn die Daten an die Grafikkarte übertragen werden und der Videospeicher (VRAM) nicht ausreicht.

    Bei Android und iOS gibt es daher sogar Beschränkungen, wie groß ein einzelnes Mesh maximal sein darf.

    Okay, versuchen wir mal, analytisch an die Sache heranzugehen:

    1. Tritt das Problem nur bei diesem Material auf?
      • Wenn du ein anderes Material verwendest, sieht es dann genauso aus oder passiert das nur mit diesem spezifischen Material?
    2. Lichtquelle ändern:
      • Was passiert, wenn du eine andere Lichtquelle verwendest? Zum Beispiel statt eines Spotlights ein Pointlight oder umgekehrt?
    3. Roughness-Wert prüfen:
      • Auf welchen Wert ist die Roughness aktuell eingestellt? Falls sie nicht schon auf 1 steht, setze sie testweise auf 1.
    4. Normal Map überprüfen:
      • Verwendet das Material eine Normal Map? Falls sie invertiert ist, könnte sie solche Probleme verursachen. Entferne die Verbindung zur Normal Map, um sicherzustellen, dass sie nicht die Ursache ist.
    5. Material auf ein anderes Objekt anwenden:
      • Erstelle ein einfaches Objekt, z. B. einen Cube, und wende das Material darauf an. Falls das Material dort ebenfalls fehlerhaft aussieht, liegt es vermutlich nicht an den UVs des ursprünglichen Modells.
    6. Rendermethode testen:
      • Wechsle unter Edit → Project Settings → Rendering von Deferred Renderer auf Forward Renderer und prüfe, ob sich das Problem dadurch löst. Der Forward Renderer wird eher für VR verwendet, aber es wäre einen Versuch wert.
      • Unter Edit → Project Settings → Rendering kannst du auch Raytracing aktivieren oder deaktivieren und testen, ob das einen Unterschied macht.
    7. Viewport-Ansicht wechseln:
      • Im Viewport kannst du zwischen Lit, Unlit und Buffer Visualization umschalten. Prüfe, ob dir diese Ansichten Hinweise darauf geben, wo das Problem liegt.

    Mehr fällt mir im Moment nicht ein. Falls du weitere Erkenntnisse hast, lass es mich wissen! :)


    PS.: Es ist echt nicht einfach ohne Informationen zum "Istzustand" zu haben.


    Poste auch einmal Screenshots vom Material.

    Wenn dein Auto kaputt ist, machst du ja auch nicht einfach ein Foto davon und gehst damit in die Werkstatt. 😜 Spaß!


    Das Problem ist, dass ich gar nicht weiß, wie die Materialien aussehen sollen. Ich sehe hier nur ein helles und ein dunkles Material, aber ich habe keine Vorstellung davon, wie es eigentlich aussehen soll.

    Ich habe ja oben schon geschrieben, dass die Reflexion von der Roughness oder dem Metallic-Wert beeinflusst wird. Vielleicht spielst du ein bisschen mit diesen Werten herum?



    Auch wäre es interessant, ein Vorher-Nachher-Bild zu sehen, um zu erkennen, was nicht stimmt oder wie du dir das Ergebnis vorstellst.

    Hey, du gehst falsch an die Sache ran. Du solltest einige Hintergrundinformationen kennen.

    Material

    Früher war es tatsächlich so, dass man sich ein Material mit Farbe etc. erstellt hat und mit den Werten experimentieren musste.

    Zunächst einmal musst du verstehen, dass Material, Licht und Schatten völlig unterschiedliche Dinge sind. Bei jedem dieser Aspekte kann man Fehler machen oder es richtig umsetzen.

    PBR (Physically-Based Rendering – Physikbasiertes Rendering) definiert Materialien anhand von drei wesentlichen Eigenschaften:

    1. Farbe (Diffuse) – Welche Farbe hat das Material oder bestimmte Teile davon?
    2. Rauheit (Roughness) – Wie stark reflektiert das Material oder bestimmte Teile davon?
    3. Metallizität (Metallic) – Wie metallisch ist das Material oder Teile davon?

    Roughness (Rauheit)

    Stell dir ein Gewässer vor:

    • Ist die See ohne Wellen, also glatt (ruhiges Gewässer), dann ist Roughness = 0.
    • Gibt es starken Wellengang, dann ist Roughness = 1.

    Stell dir einen Plattenboden vor:

    • Ist der Boden frisch gewischt oder gebohnert, ist die Oberfläche glatt, also Roughness = 0.
    • Ist der Boden abgenutzt und voller Kratzer, reflektiert er weniger oder gar nicht, also Roughness = 1.

    Holz ist niemals von Natur aus glatt (z. B. ein Baumstamm). Wird es jedoch geschliffen und mit Wachs überzogen, kann es glatt werden.

    Kratzer im Boden sind niemals glatt, daher erscheinen sie in der Roughness-Map als weiße Bereiche, während glatte Flächen schwarz sind.

    Die Roughness-Werte reichen von 0 bis 1:

    • 0 = Glatt, starke Reflexion (Schwarz in der Roughness-Map)
    • 1 = Rau, keine Reflexion (Weiß in der Roughness-Map)
    • Grautöne dazwischen = Halbraue Oberflächen (~0,5)

    Wenn du nach bestimmten Materialien suchst, wie Gold oder Rohöl, kannst du deren Roughness- und Metallic-Werte recherchieren.

    Wichtiger Hinweis: Wenn du es richtig machen willst, dann nutze die realen Werte dieser Materialien anstatt „herumzuprobieren“.

    Metallic (Metallizität)

    Der Metallic-Wert funktioniert ähnlich wie Roughness:

    • 0 (Nichtmetallisch) → Holz, Plastik, Öl oder Glas.
    • 1 (Metallisch) → Gold, Aluminium, Eisen, Kupfer.

    Interessant wird es bei verrostetem Eisen:

    • Rost reflektiert kaum (Metallic = 0, hohe Roughness),
    • Intaktes Eisen reflektiert stark (Metallic = 1, niedrige Roughness).

    Es ist also entscheidend, dass du Materialien gemäß ihren physikalischen Eigenschaften einstellst.

    Licht

    Mir fällt an deinem Screenshot14 auf, dass die Bäume absolut dunkel (schwarz) sind. Das kann in der Realität nicht vorkommen. Dazu musst du verstehen, wie Licht funktioniert.

    Grundlegendes zu Licht

    Ein Lichtstrahl:

    • Wird von der Lichtquelle in eine Richtung ausgesendet.
    • Bei einem Spotlight in eine gezielte Richtung.
    • Bei einem Pointlight in alle Richtungen.
    • Je weiter ein Objekt von der Lichtquelle entfernt ist, desto weniger Lichtstrahlen treffen es.

    Du steuerst die Lichtintensität (Intensity), also wie stark ein Lichtstrahl ein Objekt erhellt.

    • Ein Laser z. B. konzentriert das Licht auf einen kleinen Punkt. Er macht aber nicht großflächig hell, kann aber Licht über große Distanzen transportieren.

    Reflexion und Bouncing

    • Trifft ein Lichtstrahl auf ein Objekt, prallt er ab und erhellt umliegende Flächen.
    • Static Meshes: Berechnen Lichtverhalten offline (vorab gerendert, effizienter).
    • Moveable Lights: Berechnen Lichtverhalten in Echtzeit (leistungsintensiv).
    • Jeder Aufprall eines Lichtstrahls verliert an Intensität (ähnlich wie ein Billardball, der immer langsamer wird).

    Material, Licht und Schatten

    Ein Material braucht Licht, um sichtbar zu sein.

    Warum ist ein Schwarzes Loch schwarz?

    • Weil es kein Licht reflektiert. Wo ein Schwarzes Loch ist, sieht man keine Sterne oder Restlicht.

    Wenn in deinem Rendering einige Bereiche komplett schwarz sind, liegt das daran, dass sie zu wenig oder gar kein Licht erhalten und auch keine Reflexionen haben.

    Displacement

    Eine Displacement-Map verändert die Höhe einer Fläche, ist aber eine Performance-Optimierung:

    • Wenn du direkt darauf schaust, siehst du die 3D-Struktur.
    • Schaust du schräg oder von weitem, bleibt die Oberfläche flach, um Performance zu sparen.
    • Displacement ist also ein Trick und kein echtes physikalisches Verhalten.

    Reflexionen auf Displacement-Maps entstehen hauptsächlich durch die Roughness- oder Normal-Map.

    Normal-Map

    Die Normal-Map definiert die Richtung der Oberflächenstruktur in einer 2D-Informationskarte:

    • Blau (Z-Achse) = Richtung Kamera.
    • Rot (X-Achse) = Links/Rechts.
    • Grün (Y-Achse) = Oben/Unten.

    Diese Werte ermöglichen es dem Computer, zu berechnen, in welchem Winkel Licht reflektiert wird.

    Ohne Licht oder eine fehlerhafte Normal-Map kann all das nicht funktionieren.

    Fazit: Physically-Based Rendering

    PBR basiert auf realen physikalischen Prinzipien. Um realistische Materialien zu erstellen, solltest du:

    1. Richtige Werte für Roughness, Metallic und Diffuse verwenden.
    2. Verstehen, wie Lichtquellen funktionieren und wie sie mit Materialien interagieren.
    3. Displacement, Normal-Maps und Roughness gezielt einsetzen, um Reflexionen realistisch zu gestalten.

    Wenn du diese Grundlagen verstehst und anwendest, werden deine Materialien und Lichtsetzungen realistischer!


    Vermutlich hast du auf eine Oneklick Lösung gehofft aber die gibt es leider nicht. Man muss die Technik verstehen und den richtigen Weg gehen.