Beiträge von Sleepy

Vorhin wurde die die 5.4 veröffentlicht.

Mehr Informationen gibt es hier:

https://www.unrealengine.com/en-US/blog/unreal-engine-5-4-is-now-available?bt_ee=ZoyWXlbzhFzJzh0sgyF4icFMric6fyAKgN6YKwCpMfnx4CySK29tGc92Dn%2BPY8FZ&bt_ts=1713888565095

Zitat von Exaran

Wie wird die ID Verteilung gemacht so das es im Spiel nicht zu doppelten IDs kommt?

Zitat von Exaran

Das verstehe ich echt nicht.
Das muss dann jemand anderes machen, ich kann das nicht.

ID steht für Identifkationsnummer was im grunde eine xbeliebige nummer sein kann. UID steht für UNIque identifier (Eindeutige Nummer)

Das erreicht man in der Regel in dem Nummern fortlaufenden vergeben vergeben werden.

@Tomarr redet davon dinge in deiner Datenbank zu speichern. Dort gibt keine doppelte vergabe genau so wenig wie du in Exel die Zelle A1 auch nicht mehrmals haben kannst.

Du musst glaube ich mal im klaren werden wie du speichern willst.

In der Softwareentwicklung gibt es zwei begriffe Tomarr hat das hier schon angesprochen:

Zitat

Die UIDs in einer Datenbank haben nichts mit den Objekten in Unreal zu tun.

1. Es gibt den Client (Frontend). Das Frontend ist das, was später in deinem Spiel passiert, nicht in der Unreal Engine, sondern in deinem fertigen Spiel.
2. Das Backend.

Das Backend ist all das, was du als Spieler nicht sehen kannst. Dazu gehören serverseitige Dinge wie Netzwerkfunktionalitäten, Matchmaking, Lobby-Systeme, Speicherverwaltung, Sicherheitsmaßnahmen und natürlich die Datenbankintegration.

Die Speicherung erfolgt natürlich auf dem Client (Frontend), jedoch nicht lokal auf deinem Rechner, sondern auf einem Server. Dann passiert dies im Frontend. Manchmal geschehen Dinge sowohl im Backend als auch im Frontend.

Wichtig ist für das Backend in der Regel, dass Dinge serverseitig stattfinden. Wenn du also über DataTables sprichst, denkst du vielleicht, dass diese zum Backend gehören. DataTables sind jedoch eher zum Lesen als zum Beschreiben gedacht. Wenn du DataTables als Datenbank zum Lesen und Speichern verwenden möchtest, wird das vermutlich nicht gut funktionieren.

Datenbanken, die du für dein Spiel nutzen kannst, sind:

• MySQL
• SQLite
• MongoDB
• Firebase

Ich hoffe du hast jetzt besseres Verständnis dafür.

Du möchtest beispielsweise ein Tor, wie ein Stargate, erstellen, durch das man hindurchgehen kann und verschiedene Dinge passieren.

1. Man reist zu einem anderen Planeten (Levelwechsel).
2. Es wird eine Zahl in einem Zähler angezeigt, die anzeigt, wie oft man bereits durch dieses Tor gegangen ist.

Vielleicht kann man auch verschiedene Optionen wählen, wenn man sich im Bereich des Tores befindet?

Entweder du bestimmst das per Zufall und setzt zum Beispiel einen Boolean auf "True", wenn der Zufallsgenerator entschieden hat (dann ist Reisen möglich).

Oder du setzt andere Booleans auf "True", wenn zum Beispiel im Torraum der richtige Code eingegeben wurde und man jetzt zu einem bestimmten Planeten reisen kann.

Und noch etwas, weil du vom "Level Laden" gesprochen hast: Schau dir mal das Levelstreaming an. Als Spieler versteht man unter "Level Laden" etwas anderes als das, was technisch gesehen passiert.

Vergiss bitte kurz alles, was du über das Level aus Spielen kennst.

In Unreal ist das "persistent Level" so etwas wie der Weltraum - ein leerer Raum ohne irgendetwas. Das persistent Level wird auch als das Hauptlevel bezeichnet.

Das Spiel startet, das Hauptlevel wird geladen. In diesem Level befindet sich nichts, und deshalb wird auch nichts geladen. Es ist also wirklich ein leerer Raum ohne irgend etwas.

Nun gibt es Sublevel. Ein Sublevel könnte zum Beispiel das Menü sein. Du lädst das Menü in das persistent Level.

Als Spieler kannst du dort Dinge tun, zum Beispiel das Spiel starten.

Du wechselst vom Menü weg und lädst zum Beispiel den Torraum.

Wenn du zu einem anderen Planeten reist, wird der Torraum ausgeblendet und der andere Planet eingeblendet.

Du kannst dir die Levels also wie ein ineinanderverschachteltes Universum vorstellen.

Der Vorteil dabei ist, dass du im Hintergrund während des Spielens Levels vorladen und sie dann schlagartig anzeigen kannst. Du kannst sie speichern, nur unsichtbar machen oder sie komplett aus dem Speicher entfernen, um Platz für neue Dinge zu schaffen.

Die Struktur wäre: Du hast ein einziges leeres persistent Level und alles, was in deinem Spiel passiert, ist ein Sublevel.

Das Menü ist ein Sublevel

Der Torraum ist ein Sublevel

Jeder Planetet ist ein eigenes Sublevel usw

Jedes Sublevel wird dann je nach Bedarf ins MainLevel geladen.

Dass nur so als Gedanke. Du musst also nicht immer ein Levelwechsel machen so wie du vielleicht von Fallout4 oder so kennst.

Du hast viel mehr Möglichkeiten weil du dinge Onthefly ein und ausblenden kannst.

Wenn ich so recht überlege brauchst du nicht unbedingt ein Linetrace. Du hast ja gesagt, du hast verschiedene Kacheln oder ?

also zb Linkskurve, Rechtskurve, T Stück1 TStück2 Kreuzung und vielleicht noch ein paar mehr...

Wenn du immer die Kachel auf der sich Pacman gerade findet (berührt) , in das Array lädst, dann kannst du ja daraus auch die Möglichen Richtungen davon ableiten.

Dann könntest du das rein über die Benennung der Kacheln lösen und ohne Linetrace.

Die Mechanik von Pacman funktioniert eigentlich so: Du drückst eine Pfeiltaste und Pacman bewegt sich in die entsprechende Richtung (links, rechts, hoch oder runter). Mit WASD funktioniert das genauso.

Wenn du die Taste loslässt, bleibt Pacman nicht stehen, sondern läuft weiter geradeaus, bis er auf ein Hindernis trifft. Wenn es einen Weg nach oben gibt, drückt man die Pfeiltaste "hoch" oder "W", und Pacman bewegt sich nach oben.

Der entscheidende Unterschied zu einem klassischen RPG ist, dass du bei Pacman nicht einfach eine Richtungstaste gedrückt hältst und Pacman kontinuierlich in diese Richtung läuft, bis du die Taste loslässt.

Es ist natürlich möglich, von der klassischen Pacman-Mechanik abzuweichen. Doch meiner Meinung nach müsste das Spiel ständig prüfen, welche Richtungen aufgrund von Kollisionen möglich sind, und dann Pacman entsprechend in den Achsen XYZ bewegen. Auf diese Weise würden auch diagonale Bewegungen kein Problem darstellen.

Es gibt verschiedene Wege, dies umzusetzen, aber ich stelle es mir folgendermaßen vor:

1. Du drückst die Taste für links, und Pacman bewegt sich in diese Richtung.
2. Pacman hat einen Kollisionsdetektor.
3. Wenn dieser Kollisionsdetektor eine Kachel vor Pacman berührt, wird diese Kachel in ein Array geladen.
4. Du führst einen Linetrace in alle Richtungen durch, in denen sich Kacheln im Array befinden, und prüfst, welche Richtungen möglich sind.
   • Du setzt "hoch" auf "True", "runter" auf "False", "links" auf "True", "rechts" auf "True", usw.
   • In diesem Fall wäre "runter" nicht möglich.

Wenn der Spieler nun die "hoch"-Taste drückt, überprüfst du, ob "hoch" auf "True" ist. Wenn ja, änderst du im Branche die Richtung. Wenn "hoch" auf "False" ist, passiert nichts, und Pacman setzt seine geradeaus Bewegung fort.

Auf diese Weise hat der Spieler ein kleines Zeitfenster, um die Richtung zu ändern, falls möglich.

Die Mechanik von Pacman ist ja so, dass du die Lücke immer treffen musst und zur Richtungen Zeit die Richtung änderst.

Ich habs mal hingetrickst, aber sowas gibts eigentlich nicht bei Pacman, dass man gegen die Wandfährt

Hier auch nochmal ein Screen mit den Richtungen und was True bzw was false ist:

Links wäre in diesem Fall false alle anderen Richtungen True. Ich denke das ist eher die Schwierigkeit dabei.

Ich glaube du brauchst diese ganze RPG Steuern gar nicht.

Es ist manchmal schwierig genau zu sagen, was das Problem ist, da ich deinen Workflow nicht kenne.

Aber das Problem hat vermutlich, wie du bereits festgestellt hast, etwas mit den LOD-Stufen zu tun.

LOD-Stufen bedeuten, dass es für dein Mesh mehrere Versionen gibt: eine Version mit hoher Polygonanzahl, eine Version mit niedriger Polygonanzahl und möglicherweise Zwischenstufen.

So gibt es LOD0, LOD1, LOD2 usw.

Die LOD-Stufe wird in der Regel ab einer bestimmten Kameradistanz gewechselt, und ich glaube, genau das passiert in deinem Fall auch.

Durch LODs können nicht nur Meshes gewechselt werden, sondern auch Texturen.

So kann ein Mesh in 1 km Entfernung eine Polygonanzahl von 300 Tris und eine 128² px Textur haben, und wenn du direkt davorstehst, eine Polygonanzahl von 5000 und eine 2k Textur.

Die Frage ist, warum hast du überhaupt LOD-Stufen? Was willst du damit erreichen?

Hast du das Mesh selber erstellt und dir dabei etwas gedacht oder ist es ein Mesh, das du irgendwo heruntergeladen hast und das jetzt Probleme macht?

Lösungen

1.Du könntest zum Beispiel beim Export der FBX-Datei einfach angeben, dass keine LOD-Stufen mitexportiert werden sollen. Dann sollte das Mesh keine Probleme mehr machen.

2.Du könntest in Unreal die LODs einfach rauskicken so dass dein Mesh oder LODs funktioniert.

3.Du könntest die Distance der LOD anpassen so das der Wechsel der LOD Stufe später einsetzt.

Ich bin mir nicht sicher ob dieses Forum die richtige Plattform für Euch ist ?

Was genau hat den Eurer Projekt mit Unreal zu tun ? Die Projektvorstellung bezieht sich auf Projekte die mit der Unreal realisiert wurden.

Vielleicht könnt ihr dazu noch bisschen mehr erzählen.

Zitat von Lalilu

Sorry, aber was ein vollkommener Blödsinn. Nicht nur, das ich diese Fehlermeldung jetzt aus dem nichts bekomme, die Vorher nie da war. Nein, auch die Tatsache, dass das Problem anscheinend die "IsValid"-Node selbst sein soll. Die ja eigentlich dafür zuständig ist diese Fehlermeldung überhaupt zu beseitigen.

Ich glaube dein Problem ist, dass du eine nicht Initialisierte Variable hast.

Eine leere Variable ist nicht zwangsläufig das selbe wie eine Variable mit 0

Bei vielen Programmiersprachen werden Variablen standardmäßig mit einem bestimmten Wert initialisiert. Der Wert wird häufig als "Null" bezeichnet. Das heißt aber nicht, das der Value = 0 ist

Er wird zwar als 0 Wert bezeichnet ist aber nicht 0 als Value. (Äh ich hoffe verstehst was ich meine)

Es kann sein, dieses Problem nur bei bestimmten Variablentypen auftaucht. (Klassenvariablen, Lokale Variablen, Methoden, oder Funktionen.

Wenn auf die Variable zugegriffen wird oder dass Ihr vorher ein (Gültiger) Wert zugewiesen wurde, dann kommt es zu einem Fehler.

Probiere doch mal folgendes: Beim starten des Levels setze die Variable Manuell auf den Wert der drin sein müsste.

Dann verursachst du einen ISValid und einen ISNOTValid.

Ich hoffe dann ist es klarer.

Zitat von Lalilu

Bitte ignoriere das schlechte deutsch, ich weis dass "nahester" völlig daneben ist

Es ist Klug Umlaute zu vermeiden.

Sicher, dass du nicht irgendwann auf 'Build' geklickt hast? Sind deine Meshes auch auf Moveable gestellt ?

Es ist schwierig zu sagen, woran das liegt, ohne deine Szene gesehen zu haben.

Hast du ein maßstabsgetreues Setup? Du kannst ein Gebäude mit einem Maßstab von 0,0001 oder 1 Million importieren. Das Licht entsprechend anpassen, damit es im Grunde richtig ist. Aber bei der Lichtberechnung können Fehler auftreten.

Überprüfe auch deine Lichter. Auch dort gibt es Einstellungen bezüglich der Qualität deiner Lichtquellen.

Hallo wald4tler und herzlich willkommen im Forum.

Ich bin mir nicht sicher, welche Erfahrungen du bereits mit Unreal Engine und generell mit Rendering hast. Deshalb wäre es vielleicht hilfreich, zunächst etwas Hintergrundwissen zu vermitteln:

Es gibt zwei Arten, wie Objekte beleuchtet werden können: durch direktes Licht und durch indirektes Licht.

Direktes Licht ist eine Lichtquelle, die direkt auf ein Mesh ausgerichtet ist. Indirektes Licht hingegen ist das Licht, das eine Szene realistisch erscheinen lässt.

Technisch gesehen wird ein Lichtstrahl von der Quelle in eine Richtung geschossen, reflektiert ab und trifft auf eine andere Stelle, reflektiert dort wieder ab usw.

Übrigens: Vor allem HDR-Is (High Dynamic Range Images) sind sehr schöne Lichtquellen für indirektes Licht.

Damit möchte ich sagen, dass Licht nicht immer von einer Lichtquelle kommt, sondern durch die Szene "pingpongartig" geschossen wird.

Das, was man auf deinem zweiten Bild sieht, nennt man Lightleaks.

Das ist ein technisches Problem das beim Baken von Licht passiert durch das anti aliasing.

Stell dir vor, du hast einen Schreibblock mit Karos (Die Karos sind Pixel). Du Mahlt Kästchen vertikal aus also von oben nach unten. Wenn es ein gerade Strich ist, dann sind auch die Kästchen gerade.

(Wie Line mit Kästchen.)

Wenn dieser Strich nun aber nur ein bisschen diagonal verläuft, dann hast du bei den Kästchen einen leichten Versatz. Und das ist genau dass was man auf deinem Screenshot sieht.

Das anti aliasing sollte dieses Problem eigentlich minimieren.

Das Hauptproblem ist vermutlich, dass deine Light UV nicht gerade verläuft. Beim Baken muss Unreal das Licht mit einem Versatz (wie eine Treppe) in die LightUV zeichnen. Und dabei entstehen diese Muster auf den Ziegel.

Ich hab die Erfahrung gemacht, dass man ich leichter tut wenn man die UVs immer in Richtung Edge ausrichtet und darauf achtet, das die UVs nicht diagonal verlaufen. Das würde dass Problem vermutlich minimieren oder ausmerzen.

Die Vermutlich einfachere Lösung ist es die Auflösung die Light UV zu vergrößern.

Eine wichtige Sache noch: Ich kenne dein Mesh und deine UVs nicht. Aber wenn dein Mesh zu groß ist also du zb das gesamte Ziegeldach zu einem zusammen gemerged hast, dann hat deine UV auch eine entsprechende Größe wodurch deine Auflösung geringer wird.

Stell dir vor hast eine Fläche die ist 1024m * 1024m (1km) groß und du würdest einer 1k Textur verwenden. 1k = 1024² px. Dann hättest du pro Meter einen Pixel. Das reicht natürlich bei weitem nicht aus.

Die Light UV kannst du zwar mit 4k und mehr baken aber das wäre nicht sinnvoll für die Performance.

Daher prüfe mal ob es nicht sinnmacht das Mesh zu verkleinern und damit den Texturspace bzw deine Auflösung zu vergrößern.

Zuammengefasst: Was man auf deinem Screenshot sieht, ist tatsächlich Licht das von unten kommt. Entweder durch ein Licht von von unten nach oben leuchtet oder durch durch Bounceing der Lichtstrahlen. Das könnte auch von deinem Skylight oder von einem Skydome kommen.

Tipp: Pack dir dir unter dein Level ein Lichtblocker hin. Eine Plane mit der Fläche nach unten. welche das Licht aufhalten tut welchen von unten kommt. Licht dringt immer durch die Rückseite deiner Fläche. Weshalb dein Haus auch Doppelwände haben sollte. Vor allem wenn man das Haus nicht betreten kann und innen Licht brennen soll. Sonst wirst du kein realistisches Licht hinbekommen.

Hmm, ich habe das ausprobiert und würde das gerne anders lösen.

Man bewegt die Maus beispielsweise in einer Linie. Dann sollten mehrere Lichter gesetzt werden.

Nachdem das erste Licht gesetzt wurde, soll dieses kurz heller aufleuchten. Die Intensität sollte erhöht werden, ähnlich wie bei einer Glühbirne, die plötzlich mehr Strom erhält.

Sobald die maximale Helligkeit erreicht ist, soll das Licht sehr schnell abdunkeln und bis auf 0 heruntergedimmt werden, ähnlich wie ein Stern, der erlischt. Erst dann sollte das Licht gelöscht werden.

Bei Avatar, haut der Avatar doch auf Pflanzen dann heller werden und dann direkt wieder dunkel werden. So hab ich mir den Effekt vorgestellt. Es sollten aber auch nicht zuviele Lichter gespawnt werden so dass die Performance stabil bleibt.

Wenn ich das über einen Timer löse, kann nicht einzelne Lichter ansteuern und sie auch nicht manipulieren.

Das ist im grunde der Effekt den ich haben will:

Bewegt man die Maus, gibt ganz viele dieser Lichtpunkte.

Ich probiere am das am Wochenende aus.

Ich brauche etwas Inspiration und eine intelligente und performanten Lösung.

Ich befinde mit der Thirdperson perspektive. Wenn ich die Maus bewege, sollen in in kurzen Abständen pointlights erstellt werden.

Im Prinzip so nur mit Pointlights und Thirdperson.

Die Pointlights sollen entweder ab einer bestimmten Menge an pointlights oder nach einer bestimmten Zeit wieder gekillt werden. Das will ich noch ausprobieren.

Mir fehlt aber die Idee wie ich das Sinnvoll umsetzen kann.

Mein Ansatz ist:

Die haue die Lichter in ein Array rein, muss dann irgend wie Zeit messen wie lange sie schon existieren und Lösche sie dann wieder wenn zb wenn 2 Sekunden vorbei sind.

Jemand ne Idee ?

Irgend wie klingt das vorhaben voll einfach aber ich steh irgend wie auf dem Schlauch

Mir ist klar wie ich viele Pointslight generieren und speichern kann und deren Zeit messen und sie in Reihenfolge wieder löschen kann.

Hey VPro willkommen im Forum.

ich würde das Arbeiten in der Unreal in zwei Arbeitsbereiche aufteilen.

1.Den Programmierpart egal ob per Code oder per Blueprint

2.Den 3D/ 2D part

Beide Bereiche sind sehr umfangreich.

Was macht dir den am meisten Spaß? Willst du eher programmieren oder eher 3D/2D Stuff machen.

Wie ist dein Kenntnissstand ? Hast du Programmiererfahrungen ?

Hilfreich wäre in welche Richtung du gehen willst, was dich interessiert bzw was nicht vielleicht auch nicht so interessiert.

Zitat von Tomarr

Na ganz so kenne ich das nicht. Ich kenne es eher so in die Richtung

Hauptschadensart: Hieb
HauptschadenMax: 10
Nebenschadensart: Feuer

NebenschadenMax: 5

Ja aber Hieb und Feuer ändert sich ja nicht. Wenn ja dann würde ich da zusätzlich ein Integer oder Floatwert dafür nehmen. zb 1 ist Feuerwaffe, 2 ist Eiswaffe. Eben so, dass du das nicht extra in einem String Array speichern musst.

Einfach nur Float Werte für alles und der Text eben aus der Tabelle.

Auch für Mod Stufen zb was das Aussehen der Waffe angeht, könnte man ja einen Floatwert verwenden. (1 Ist Skin1) (2 eben Skin2) usw

Du kannst halt nicht für jede Waffe ein Struct erstelle wo oder alle Datentypen drin hast die du ständig Lesen und bearbeiten musst.

In einem Individuellen Array wo ändere bare Zahlen sind, ist das viel performanter. Als Variablen die theoretisch änderbar sind aber wo die meisten in der Praxis nicht geändert werden.

Zitat von Tomarr

Also wenn ich bei einem Spiel erstmal eine Stunde analysieren müsste, welche Waffe jetzt besser ist und dann auch noch vielleicht unterschiedlich bei jedem Gegner oder so, das wäre bei mir eine 1A Rückerstattung bei Steam.

Oft Leveln sich die Waffen ja von Selbst und damit auch die Werte.

Fallout4 als Beispiel es folgende Werte:

Levelstufe

Damage

Feuerrate

Genauigkeit

Reichweite

Preis.

Magazin Typ zb 45mm

Bei Fallout ist es so gelöst, dass die Waffe einen Default Wert hat und durch bestimmte Mods sich diese Werte entsprechend erhöhen. zb die Genauigkeit um 10, die Reichweite sinkt um 20 usw

Wenn man eine Waffe findet, könnte man der per Zufall Mods verpassen und so ändern sich auch rechnerisch die Werte entsprechend.

In Spielen ist es doch so: Du findest oder bekommst eine Waffe. Dann kannst du diese Waffe verbessern, indem du sie levelst oder modifizierst.

Von der Logik her, wenn man die Waffe findet, erhält die Waffe ein NEUES Array, in das die Werte aus der Tabelle gespeichert werden. Im besten Fall handelt es sich hierbei nur um Floatwerte. Andernfalls würde man für jede Waffe wiederum ein Struct benötigen, das sowohl Strings als auch Floats und Integers usw. enthält.

Also werden alle Informationen (in Form von Floatwerten) aus dem extra für die Waffe angelegten Array bezogen. Informationen wie der Name der Waffe (z.B. Langschwert) werden jedoch weiterhin aus der Tabelle bezogen. Die Werte ändern sich normalerweise auch nicht.

Im Array können diese Werte Überschrieben werden die default Werte in der Tabelle bleiben aber wie sie sind.

Der Feuerschaden ist dann für alle Feuerschaden-Waffen, die keine Modifikation haben, gleich?

Dann wäre diese Tabelle doch die Standardtabelle mit den Standardwerten für alle Waffen. Wenn du hier Werte änderst, kannst du den Standard-Schaden für alle Waffen ändern, die keine Modifikation haben.

Aber warum möchtest du sie in einem Struct speichern? Die Standardwerte sind doch alle vom Typ Float. Ein Struct wird nur benötigt, wenn du unterschiedliche Datentypen hast.

Warum machst du es nicht so:

Eine Tabelle:

• Name der Waffe
• Standardwert des Schadens (Schaden, den die Waffe verursacht)
• Maximale Reichweite (bei Distanzwaffen)
• Lebensdauer (wie viel Schaden die Waffe einstecken kann, bevor sie kaputt geht)

usw.

Eine einzige Tabelle, in der alle Informationen zu allen Waffen und allen Werten gespeichert sind.

Dann kannst du die gesamte Tabelle in ein Struct packen und mit einem Break die verschiedenen Datentypen auslesen.

Ich würde eine Tabelle machen wo alles drin steht.

Waffen, Rüstungen, Schmuck etc kannst du ja auch in verschiedene Tabellen Packen.

Wenn du eine Frage stellst, macht sich sich natürlich jeder Gedanken wie er dir helfen kann und wie er selbst das Problem lösen würde.

Dabei kömmt man oft in diese Situation wo man denkt, wenn das und jenes mein Case ist, dann würde es so und so machen und wenn der Case anderst wäre dann würde das Problem eben anderst lösen.

Wenn du natürlich einfach nur einfach und staighte ne Antwort haben willst, dann fühlt sich dass vielleicht manchmal so an als würde man das Pferd von hinten aufsatteln.

Daher ist eigentlich immer nur von Vorteil für alle, wenn du sagst was du genau vor hast und warum du es so vorhast.

Es es gibt hier im Forum niemanden der nicht zuhören will. Warum sollte jemand nicht zuhören wollen ?

Wenn dann liegt es daran dass diese Leute dein Problem nicht verstehen oder du nicht verstehst warum der Vorschlag die bessere Lösung ist.

Das ist dann eher ein Kommunikationsproblem.

Ich weiß nicht wie du dir das Ergebnis vorstellst. Ein Button wird durch das Licht bestimmt ob er gedrückt oder nicht gedrückt ist.

Bei einem nicht gedrückten Button ist der Rand unten und rechts schwarz (siehe Bild 1) bei einem gedrückten Button ist dieser Effekt einfach invertiert.

Wenn du beim drücken deines Buttons die Grafik also Vertikal und horizontal spiegelst, bekommst du ein gedrücker Button Effekt.

Wenn ich diesen Effekt im Substance Designer erzeugen will, brauch ich Button als Highpoly, ich Bake die Normalmap auf eine Plane und generiere aus der Normal die Curvature. Die Curvature erzeugt genau diesen Effekt.

Eine andere Möglichkeit wäre es diesen Effekt durch eine Normal zu erzeugen und diese Normal einfach zu invertieren. Somit hast du auch dieses rein und raus. Damit käme die Information nicht aus der Diffuse (Textur) sondern NUR aus der Normal heraus.

Du hättest eine Hintergrund Farbe

dein Button hat eine Farbe

und eine Grafik mit Transparenz die du invertierst.

Oder

dein Colorkanal ist leer und du hast nur eine Normal die du inverierst.

Damit musst du Opacity auch gar nicht anfassen.

Zitat von Tomarr

Jetzt habe ich aber folgendes Problem, und zwar, wenn ich diesen Button in das eigentliche HUD einfüge und die Farbeinstellungen für diesen Hintergrund ändern will, bleibt er trotzdem noch immer weiß (Standardeinstellungen). Das ist auch kein Wunder, denn in der Animationstimeline ändere ich zwar nur den Alphawert, aber die Werte für RGB bleiben halt auf 1 stehen.

Wenn die Animation abläuft werden die Werte durch die Animationüberschrieben?

Wenn ich richtig verstehe, änderst du RGBA über ein Blueprint und über eine Animation ? Das funktioniert natürlich nicht.

Macht das den Sinn ? Du kannst ja nicht per Animation die Farbe auf Schwarz stellen und im Blueprint sagen die Farbe soll weiß sein ist ja klar das sich hier dinge überschreiben.

Ich weiß nicht was du vorhast oder warum das tun willst.