• Announcements

    • Lars

      Allgemeine Forenregeln   03/13/2017

      Forenregeln Nimm dir bitte einen Moment um die nachfolgenden Regeln durchzulesen. Wenn du diese Regeln akzeptierst und die Registration fortsetzen willst, klick einfach auf den "Mit der Registrierung fortfahren"-Button. Um diese Registration abzubrechen, klick bitte einfach auf den "Zurück" Button deines Browsers. Wir garantieren nicht für die Richtigkeit, Vollständigkeit und Brauchbarkeit der Nachrichten und sind auch nicht dafür verantwortlich. Die Beiträge drücken die Meinung des Autors des Beitrags aus, nicht zwangsläufig das, wofür die Forensoftware steht. Jeder Nutzer, der denkt, dass ein veröffentlichter Beitrag unzulässig bzw. störend ist, ist aufgefordert uns unverzüglich per E-Mail zu kontaktieren. Wir haben das Recht störende Beiträge zu löschen und bemühen uns, das in einem realistischem Zeitraum zu erledigen (sofern wir beschlossen haben, dass die Löschung notwendig ist). Du akzeptierst, durchgehend während der Nutzung dieses Services, dass du dieses Forum nicht dazu missbrauchen wirst, Inhalte zu veröffentlichen, welche bewusst falsch und/oder verleumderisch, ungenau, beleidigend, vulgär, hasserfüllt, belästigend, obszön, sexuell belästigend, bedrohlich, die Privatsphäre einer Person verletzend oder in irgend einer Art und Weise das Gesetz verletzen. Des Weiteren akzeptierst du, dass du keine urheberrechtlich geschützte Inhalte ohne Erlaubnis des Besitzers in diesem Forum veröffentlichst. Mit dem Klick auf den "Mit der Registrierung fortfahren"-Button, akzeptierst du zudem unsere Datenschutzerklärung und stimmst der Speicherung deiner IP-Adresse und personenbezogenen Daten zu, die dafür benötigt werden, um dich im Falle einer rechtswidrigen Tat zurückverfolgen zu können bzw. permanent oder temporär aus dem Forum ausschließen zu können. Es besteht keine Pflicht zur Abgabe der Einwilligung, dies erfolgt alles auf freiwilliger Basis.   Zusatzinformationen Der Forenbetreiber hat das Recht, Nutzer ohne Angabe von Gründen permanent aus dem Forum auszuschließen. Des Weiteren hat er das Recht, Beiträge, Dateianhänge, Umfrage, Blogeinträge, Galleriebilder oder Signaturen ohne Angabe von Gründen zu entfernen. Mit der Registrierung verzichtest du auf alle Rechte an den von dir erstellten Inhalten, bzw. treten diese an das Unity-Insider.de und Unity-Community.de ab. Dies bedeutet im Klartext, dass das Unity-Insider.de und Unity-Community.de frei über deine Texte verfügen kann, sofern diese nicht wiederum die Rechte anderer verletzen. Es besteht weiterhin kein Anspruch von registrierten Nutzern bzw. ehemaligen registrierten Nutzern darauf, dass erstellte Inhalte und/oder die Mitgliedschaft (User) wieder gelöscht werden (Erhaltung der Konsistenz dieses Forums).   Einwilligungserklärung Wenn du mit der Speicherung deiner personenbezogenen Daten sowie den vorstehenden Regeln und Bestimmungen einverstanden bist, kannst du mit einem Klick auf den Mit der Registrierung fortfahren-Button unten fortfahren. Ansonsten drücke bitte Zurück. Stand: 07.03.2011

Leaderboard


Popular Content

Showing most liked content since 02/24/2017 in all areas

  1. 17 likes
    Über unsere Scripting-Tutorials Dies ist die Liste unserer Scripting-Tutorials. Sie ist gedacht für alle, die noch absolut keine Programmiererfahrung haben, aber auch für jene geeignet, die bereits, wenn auch nicht in Unity, programmieren können. Es werden überhaupt keine Vorkenntnisse voraus gesetzt. Eigentlich sind diese Texte auch weniger Tutorials als vielmehr Lehrtexte Scripten in Unity für Einsteiger Erste Grundlagen für das Scripten im Allgemeinen Scripten in Unity für Nicht-mehr-Einsteiger Der zweite Teil, passend zum ersten Nach diesen beiden beherrscht man die Grundlagen und kann sich an seine ersten eigenen Scripts setzen. Wer jetzt auf C# umsteigen möchte: C#-Tutorial für Um- und Einsteiger Umstieg von JavaScript auf C# Scripten in Unity mit Unity Die Schnittstelle der Unity-Engine, deren Klassen beim Scripten benutzt werden, vorgestellt Scripten in Unity für Scripterfahrene (an Objekte kommen) Der vierte Teil, wichtig für sauberes Programmieren und um das Prinzip hinter Unity zu verstehen Die Scripting Reference lesen Damit man eigenständig neue Dinge über Unity lernen kann Noch mehr Scripten in Unity (Wissen für Fortgeschrittene) Noch mehr Scripten in Unity - Teil 1: Arrays und Existenzoperator Erste leicht fortgeschrittene Techniken, aber einfach erklärt Noch mehr Scripten in Unity - Teil 2: Klassen und Überladungen Objektorientierte Programmierung in Unitys JavaScript Für den Anfang nicht benötigt, für Fortgeschrittene interessant Noch mehr Scripten in Unity - Teil 3: Statische Variablen und Funktionen Für die richtige Anwendung statischer Deklarationen und damit für sauberes Programmieren Noch mehr Scripten in Unity - Teil 4: Böse Funktionen beseitigen Die typischen inperformanten Funktionen durch äquivalenten, besseren Code ersetzen Scripten in der Praxis (Komponenten- und Praxisorientiertes Sctipting) Fehler in Scripts finden Konsole benutzen und Fehlermeldungen lesen können Scripten in der Praxis - Der CharacterController Menschen und andere Lebewesen in Unity Scripten in der Praxis - Raycasts Wozu sie gut sind und wie man sie benutzt
  2. 8 likes
    Hallo zusammen, das Forum wird am Sonntag (05.03.) ab ca. 10 Uhr bis voraussichtlich 14 Uhr nicht erreichbar sein. Grund dafür ist das Aktualisieren der Forensoftware. Grüße Dark
  3. 4 likes
    Sodele. Jetzt endlich kann ich mal wieder was zeigen. Mein neuer Flipper ist gut im werden und dieses Mal geht es um das Thema Carnival. Ist nicht viel mehr als ein Ausblick auf das was kommen wird. Schaut:
  4. 4 likes
    Hey Leute, hab mal was neues gebastelt - mal wieder bisschen Gameart, hab die letzten 2 Monate eigentlich nur gecoded Hoffe es gefällt, gibts dann bald im Asset Store. lg, holzi
  5. 4 likes
    Hi, ich habe mich mal spaßeshalber hingesetzt, und veruscht eine "Night / Dark Theme" für das neue Forum zu schreiben. Das ganze Funktioniert über ein Browserplugin namens "Stylish" ( https://chrome.google.com/webstore/detail/stylish-custom-themes-for/fjnbnpbmkenffdnngjfgmeleoegfcffe?hl=de ) Meine komplette Erfahrung im Bereich Webdesign setzt sich so ziemlich aus den letzten 3h try`n error zusammen, also erwartet nicht zu viel ^ Wenn ihr das Plugin herunterladet, könnt ihr ein neues Design erstellen und diesen Code einfügen: https://www.dropbox.com/s/pouzvzf7jrtgy8b/UnityDarkTheme_a1.txt?dl=0 Sieht dann ( hoffentlich ) etwa so aus: Das ganze ist natürlich nicht final.. vtl. hat auch noch jemand ein paar Tipps
  6. 4 likes
    Hi zusammen, wie ihr seht ist das Forum auf der neusten Version. Wichtig: Der alte "Username" zum einloggen wurde durch euren "Displaynamen" ersetzt. Die Umlaufprobleme sollte bei neuen Beiträgen nicht mehr auftreten. Vereinzelt müssen User ihre Profilbilder neu hochladen. Es gibt derzeit keine Emoties und das Syntax Highlightning funktioniert noch nicht Wir werden gucken, das wir das im Laufe der Zeit behoben bekommen. Grüße Dark
  7. 4 likes
    Wie ihr sicherlich gemerkt habt, ist das Forum immer noch auf der alten Version. Als neuen Termin für die Aktualisierung ist das kommende Wochenende angepeilt. Genauer Tag und Zeitfenster wird noch bekannt gegeben.
  8. 3 likes
    Die neue Forensoftware bringt einige Neuerungen mit sich, die ich hier mal auflisten möchte. Darunter können wir gerne über die Features diskutieren Neu & Prima Scripting Reference Button Im Texteditor findet ihr jetzt ein Unity-Icon. Das habe ich eben erstellt. Damit könnt ihr bequem Seiten der Scripting-Reference verlinken. Einfach draufklicken und Seite eingeben, z.B. MonoBehaviour oder GameObject.activeSelf. Beachtet bei Letzterem den Bindestrich statt des Punktes. Vielleicht kann ich das in Zukunft noch einmal hübscher machen, dass da ein Punkt steht. Ich habe eben ein kleines Skript gebastelt, das auf meinem Webspace liegt und auf die richtige Seite weiterleitet. Ich habe einen Skin, der einem nachts nicht die Augen ausbrennt, gebaut. Wenn ihr mit diesem Skin etwas kaputtes feststellt, sagt es mir. Ich habe (musste) über CSS-Hacks jede Menge Kleinigkeiten einzeln fixen - dabei kann mir etwas entgangen sein. Neu & Merkwürdig Die Rangliste Keine Ahnung, warum wir das haben, aber es gibt jetzt eine Rangliste. Da steht drin, wer für den jeweiligen Tag die meisten Likes gesammelt hat. Und wie oft man damit "Tagessieger" war. Es war einfach so da, wir haben das nicht angeschaltet. Wenn es stört, schauen wir mal, ob wir das abgeschaltet kriegen, wenn nicht, dann nicht HTML-Quellcode Wenn man jetzt den Quellcode eines Beitrags ansieht, ist es HTML und kein BBCode mehr. Ist bestimmt nur minimal verwirrend! Den Spoiler-Tag habe ich beim Rumprobieren schon mächtig kaputt gemacht! Noch kaputt Beim Updaten der Datenbank sind unsere schönen Sonderzeichen kaputt gegangen. Immerhin kann man sie unterscheiden, sodass es möglich sein müsste, die Beiträge mit einem kleinen Script fixen zu lassen. Smileys sind völlig im Eimer. Wir schauen mal nach, woran das liegt. Wir haben einen netten Code-Tag, aber C# ist keine der auswählbaren Sprachen. Tipp: C-Sysntax Highlighting sieht fast genauso aus
  9. 3 likes
    Das ging ja fix Ich sitze allerdings gerade daran, ein offizielles, dunkles Theme zu erstellen - dann braucht man keine Browsererweiterungen
  10. 3 likes
    so neue Enemies sind angekommen ..modeliert vom christian ..
  11. 3 likes
    Gute Morgen, anbei, ein paar Screenshots der Ruine: ruine_screenshot_editor.jpg: aus der Unity-View heraus aufgenommen. In den Statistics rechts oben deutlich zu sehen, die Anzahl der berechneten Tris in dieser Scene. 30 Millionen. ruine_screenshot_build.png: das Ganze in voller Auflösung aus dem Build heraus aufgenommen tiled_mesh.jpg Gut zu sehen, wie Unity das aus 6 Millionen Faces bestehende Mesh beim Import aufgeteilt hat in 92 einzelne Objekte Gruß Ultrafox
  12. 3 likes
    So sieht mein Arbeitsplatz im Moment aus. Das linke Dingen ist mein ganzer Stolz! Ein Wacom Cintiq 13HD Monitor/Tablett. Jetzt macht Texturieren richtig Spaß!
  13. 3 likes
    Update Eine neue Demoversion steht zum download bereit. Ihr findet die Downloadlinks auf der ersten Seite dieses Threads. Die begehbare Spielzone wurde erweitert und lootbare Truhen, Kisten und Schränke wurden hinzugefügt. Hovert ihr mit der Maus z.B. über einer Kiste und seid in relativer Reichweite, so verfärbt sie sich leicht und eine Info erscheint, um was es sich bei dem Gegenstand handelt. Viel Spaß beim suchen. Ferner wurden 3 neue zivile NPC hinzugefügt um die Spielatmosphäre lebendiger zu gestalten. ChangeLog 0.162b: Ein Bug wurde behoben, der zu Ladehemmungen führte. Plaza 1 inklusive DNG-Hauptquartier wurde hinzugefügt. Interagierbare Kisten, Schränke und Container wurden hinzugefügt. Drei neue NPC wurden hinzugefügt. Die Grafikqualitätsauswahl wurde etwas angepaßt. Plaza 1 ist ein sicherer Bereich, in dem sich das DNG-Hauptquartier befindet. Später wird hier unter anderem ein weiterer Händler und eine Bar zu finden sein. Ideal um sich zu treffen und um gemeinsame Abenteuer zu beginnen. Qualitätsstufen-Info: Im Launcher des Spiels könnt ihr wie gewohnt die Grafikqualiutätsstufe anpassen. Probiert einfach mal, in welcher Einstellung es bei euch flüssig läuft und auch noch gut aussieht. Ich freu mich auf jede Menge Rückmeldungen von Euch. Nachfolgend ein paar Screenshots, da sich ja nicht gleich jeder eine Demoversion herunterladen mag:
  14. 2 likes
  15. 2 likes
    Ich wusste gar nicht, dass man Transform.forward auch setzen kann
  16. 2 likes
    Problem ist behoben,die Liste sollte sich jetzt wieder leeren.
  17. 2 likes
    Hallo Gemeinde, habe das Projekt mittlerweile fertiggestellt. Das von mir beschriebene Flickern lag daran, dass ich das Mipmapping ausgeschaltet hatte - wegen der Textur-Qualität. Dies hatte allerdings zur Folge, dass sich bei Bewegungen viele unterschiedliche Textur-Pixel, die hinreichend weit von der Kamera entfernt sind, um den gleichen Pixel-Platz im Rasterbild stritten. In einem Frame gewinnt das Eine, im anderen Frame, ein anders Pixel Da meine Texturen sehr sehr hochauflösend sind, war das Flickern extrem. Nochmals die Eckdaten meines Projekts: Ein Mesh, beim Import von Unity in 90 Meshes aufgeteilt. 50 Texturdateien mit jeweils 8192 x 8192 Pixel Auflösung. Fazit: Bei sehr hochauflösenden Texturen sollte man Mipmapping einschalten bzw. eingeschaltet lassen, wenn die Texturen auch aus größeren Entfernungen betrachtet werden sollen - wirkt ziemlich beruhigend auf die Pixel ;) Hier, nochmals zwei Screenshots. RuinePart.jpg zeigt den Ausschnitt, der in RuineAll.jpg mit einem weißen Quadrat gekennzeichnet ist. Keine Texturen werden mehrfach verwendet. Jedes Pixel des Models hat sein eigenes Texturpixel. Übrigens: läuft mit über 70 fps bzw. 90 fps in VR - Unity ist toll!!!! Gruß Ultrafox
  18. 2 likes
    Lost in Nature ist jetzt auf Steam erhältlich und läuft stabil! http://store.steampowered.com/app/601500/ Vielen Dank an alle, die mich während der Entwicklung ermutigt und unterstützt haben! Hier ein sehr gutes deutsches Let's Play:
  19. 2 likes
    Bau die in einem 3d Programm einen kreisrunden Körper und exportiere ihn z.B. als .fbx. In Unity importieren, in die Szene legen und ihm einen "MeshCollider" geben.
  20. 2 likes
    Ist gefixt. Ist ebenfalls gefixt. Da wir jetzt einen Thread im Feedback-Bereich zum dunklen Design haben, neue Anmerkungen dazu gerne dorthin.
  21. 2 likes
    Moin, ich baue im Moment einen einfach anzuwendenen und für Laufzeit fähigen 3D Tile Editor für den Asset Store, weil mir die vorhandenen nicht 100% gefallen. Meiner soll alles, was er kann (außer tile Setup), zur Laufzeit können, sprich als In Game Editor nutzbar sein. Aktueller Stand: Tile Kategorie Editor Kategorie hinzufügen Kategorie entfernen Tile Setup Editor Drag&Drop (auch mehrere gleichzeitig) Prefab in den Editor Erstellt Tile Asset Vorschaubild für den Editor Alternatives Tile Vorschaubild Tile Name Kategorie als Dropdown Typ (Statisch, Dynamisch) Statische Tiles werden beim Laden gemerged, um Batches zu sparen Positions- und Rotationsoffset einstellbar Tile Connection Editor - Tile Connections dienen dazu, dass man z.B. Straßen oder Wände "malen" kann und meine Engine dann die Tiles selbst so auswählt, dass es passt (z.B. Kreuzungen, Wandecken) Neue Tile Connection erstellen aus vorhandenen Tiles kann man nun die diversen Connection Parts auswählen Runtime Editor Layer Manager - man kann Tiles in diverse Layer aufteilen, um diese z.B. auszublenden während des Editierens Layer hinzufügen Layer entfernen Layer aktivieren Stockwerk Es ist möglich, über diverse Stockwerke hinweg zu bauen (Grid Map hoch- und runterbewegen) Tile Auswahl Tile Connection Auswahl Typ des Bauens Tile platzieren pro Klick Tile malen Tile Connection malen Löschen Map speichern [WIP] Map laden [WIP] Maus/Tastatur oder Controller-Stauerung [WIP] Unity UI Redo/Undo System (eigenes System, erweiterbar für eigene Dinge) [WIP] Template für einfaches Speichern/Laden zu und von Remote MySQL Datenbank [WIP] Was für Features würdet ihr euch wünschen? LG
  22. 2 likes
    Wenn du dann aber auf dunkel bist, siehst du nicht mehr wie du zurück kommst, gelle Sascha?
  23. 2 likes
    Das mit dem Unity-Button muss ich gleich mal probieren: Animator Krasse Sache. Das neue Forum macht mir zunehmend Spaß. Vielen Dank für euere Arbeit.
  24. 2 likes
    Eine stinkalte Version derselben Software (IP.Board). Edit: Ich habe mal etwas gebaut - ist aber erstaunlich nervig und ich muss jeden Quark einzeln fixen... hoffentlich sieht alles soweit gut aus.
  25. 2 likes
    Das Forum wird voraussichtlich erst ab 11 Uhr offline und erst gegen 16 Uhr wieder erreichbar sein.
  26. 2 likes
    Steht auch in de Ankündigung. Es gibt noch ein Problemchen, was leider etwas Zeit in Anspruch nimmt und deswegen wird's wahrscheinlich erst nächstes WE soweit sein.
  27. 2 likes
    fehlt vtl. using UnityEngine.UI; ? ^
  28. 2 likes
    Moin Garzec, es gibt hier viele Möglichkeiten dein Problem zu lösen. Dein Problem befasst sich mit der Persitenz von Informationen. Eine Möglichkeit probierst du ja gerade aus. Also du hast ein GameObject mit einer Komponente, welche die thematisierten Listen als Eigenschaft inne hat. Da bei einem Szenenwechsel das GameObject zerstört wird, rufst du DontDestroyOnLoad auf. Das ist komplett in Ordnung, um dann gewisse Dinge im Scope zu halten. Dein Problem wird wohl dort auszumachen sein, wo du Elemente zu deiner Liste hinzufügst. Weil so initialisierst du Listen und hast eben noch keine Elemente hinzugefügt. Ich würde dann eher deinen SceneConnector in einen CoordinatesManager oder so umwandeln, dann gibst du der Klasse noch Methoden um das hinzufügen von Koordinaten zu ermöglichen. Du kannst aber auch auf ein GameObject verzichten, in dem du eine statische Klasse, die nicht von Monobehaviour erbt, erstellst. Dann gibt es noch die Möglichkeit die Koordinaten in einer Datei zu speichern und dann wieder auszulesen, aber das passt jetzt nicht wirklich zu deinem Anwendungsfall. edit: Mr 3d hat einen wichtigen Punkt wegeditiert: Du darfst dann das GameObject mit der "SceneConnector" nicht zweimal haben, sondern nur einmal.
  29. 2 likes
    Nun melde ich mich auch mal. Anders als die Viele hier (gibt allgemein oft nur Leute für die sowas nix ist und wieder Leute die es lieben...), liebe ich Pinballs absolut..ob Echte oder Virtuelle. Deinen Automat jetzt, finde ich echt super! Macht viel Spaß und nach einer Weile, kann man das Teil gut nachvollziehen. Für mich ist es ein Automat der ehr leichten Schwierigkeitsklasse. Wirklich toll geworden. Hätte natürlich viele kleine Wünsche der Optimierung, aber ich werde sie nicht niederschreiben...ich möchte dich nicht beeinflussen. Ich kann nur sagen, dass die Kugel schon ziemlich gute Dienste leistet. Ich werde deinen Automat auf jeden Fall noch weiter zocken...einfach weil er mir Spaß macht. Nur mal, dass du es weißt: ich spiele sehr oft Pinball... zur Zeit sogar täglich ;D Deine neue Version habe ich jetzt (gerade eben) zum ersten Mal gezockt. 11,7M Points. 3 Missionen waren glaub ich noch offen. Erstaunen tut mich aber der Hardwarehunger. Auf meinen i7 mit ner 1080 merkste natürlich nix. Aber meinen kleinen i5 Lappi mit 2,5ghz und ner ATI Radeon 5650, muss ich quali und Auflösung auf 720p runter nehmen, um flüssig zocken zu können. Wenns bissel komisch geschrieben ist, sorry, Geburtstagsfeier.....*higs
  30. 2 likes
    Du vermischt da was. Der Root-Motion-Bone ist für die Bewegung im Raum zuständig. Das bedeutet nur, dass sich dein Character über die Animation selbst im Raum bewegen kann und nicht über die Manipulation seiner Transformkomponente oder seines Rigidbodys (wenn er denn einen hat) bewegt werden muss. Mit dem Collider hat das erstmal gar nichts zu tun, denn der ist jetzt noch gar nicht da. Damit der Char auch kollidieren kann, musst du ihm einen oder auch mehrere Collider geben. Diese Collider kannst du einfach den entsprechenden Bones (was ja in Unity einfach nur simplte Objekte sind) unterordnen. Das ist jetzt erstmal nur das Grundprinzip. Jetzt kommt es darauf an, wie du wirklich steuern willst. Nimmst du die Bewegung der Animationen, weil die auch räumliche Bewegungen mit in der Animation haben, dann brauchst du mindestens einen Collider und nen Rigidbody, damit die Kollisionen überhaupt ausgewertet werden können. Zusätzlich muss der RootMotion Haken natürlich gesetzt sein. Willst du aber den Char selber, z.B. über den CharacterController, steuern, dann brauchst du die Motion ja nicht, denn jetzt bewegst du den Char ja unabhängig von seiner Animation. Der CC hat einen Collider mit an board und ist das Vaterobjekt deines Chars. Bei der Steuerung über Transform oder RB musst du selber noch einen Collider setzen. Aber auch hier wäre ein Vaterobjekt im Spiel. Der Char selber spielt nur die Animationen ab, der Vater bewegt das ganze System. Egal wie, du brauchst immer auch etwas, was kollidiert und mit dem Char mit bewegt wird. Entweder ist der Collider eine Komponente eines Bones bzw. des Meshes oder er ist am Vaterobjekt dran. Der Rootmotion Bone hat mir dem Kollidieren selber nichts zu tun.
  31. 2 likes
    2 Sachen: Ich habe nur in deine Zip rein geschaut aber dabei gesehen, dass du den Cube mit Transform auf die Mausposition setzt. Das ist nicht gut, weil bei solchen Dingen, wo du nicht die Physik nutzt, ganz schnell ein Körper den anderen tunneln kann. Passiert bei dir! Denn es tritt der Fall ein, dass der eine Kollider im anderen drin steckt und dann ist kein Colliderrand mehr da und der Cube fällt. Nutze für solch ein setzen die MovePosition-Funktion in der FixedUpdate: https://docs.unity3d.com/ScriptReference/Rigidbody.MovePosition.html Die andere Sache ist die Reibung von Rigidbodys. In der Grundeinstellung reiben die nicht aneinander. Damit sie Reiben, musst du einen RB auf "Is Kinematic" stellen. Erst jetzt wird kinetische Energie (also Reibung und Mitnahme) berechnet. Das hat erstmal nichts mit dem Physikalischen Material zu tun, denn das ist ohne den Haken bei IsKinematic nur für den sich bewegenden RB wichtig. Es gibt an, ob etwas federt oder durch Reibung abbremst. Ein Kugel würde also wie ein Ball hüpfen können und je nach Reibungswert wie auf Eis immer weiter gleiten oder eben zu Stillstand kommen, wenn der Reibungswert hoch ist. Erst wenn ein RB IsKinematc ist, wird die Reibung auch für die echte mitnahme eines anderen Körpers genutzt. Da diese Berechnungen recht leistungshungrig sind, ist der Haken per default aus. Also: Lernen was die Physikalischen Materialien machen, und wie sich gewisse Parameter auswirken. Dann niemals RB's oder Collider per Transform bewegen oder setzen, sondern über die Force, direkt über die Velocity oder mit besonderen RB Funktion bewegen.
  32. 2 likes
    Sieht sehr vielversprechend aus. Bin gespannt auf die Fortschritte.
  33. 1 like
    Das war schon einmal gemeldet und ist nun gefixt. Da ich den Skin per Hand erstellt habe und alle Dinge einzeln fixen muss, kann das immer mal passieren. Wenn ihr auf Probleme mit dem dunklen Skin stoßen solltet, bitte meldet sie in diesem Thread.
  34. 1 like
    Das dunkle Design ist super. Vielen Dank dafür. = )
  35. 1 like
    Sobald ich es zum laufen kriege! Aber dafür finde ich gerade ein paar andere, nette Features... das wird noch interessant!
  36. 1 like
    Allgemein bin ich pro Dark Theme
  37. 1 like
    So ich habe das Lichtproblem gelöst, war noch einiges an Zusatzarbeit, aber so kann ich den Shader nun auch in meinem Spiel verwenden. Der Shader besteht nun aus 2 Dateien (der Shader selbst und einem Include). Ich gebe diesen Shader für das gesamte Forum frei... Shader "Standard Double Sided.shader": Shader "Standard Double Sided" { // Created by Zer0f0rce (Skype) for Unity Insider Forum // and the Game "Twin Destiny" by Hugin Munin Studios LLC // Version: 5.4.1f1 // Includes UnityStandardCoreDoubleSided.cginc // Only works for the deferred lightning pass Properties { _Color("Color", Color) = (1,1,1,1) _MainTex("Albedo", 2D) = "white" {} _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5 _Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5 _GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0 [Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0 [Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0 _MetallicGlossMap("Metallic", 2D) = "white" {} [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0 [ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0 _BumpScale("Scale", Float) = 1.0 _BumpMap("Normal Map", 2D) = "bump" {} _Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02 _ParallaxMap ("Height Map", 2D) = "black" {} _OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0 _OcclusionMap("Occlusion", 2D) = "white" {} _EmissionColor("Color", Color) = (0,0,0) _EmissionMap("Emission", 2D) = "white" {} _DetailMask("Detail Mask", 2D) = "white" {} _DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {} _DetailNormalMapScale("Scale", Float) = 1.0 _DetailNormalMap("Normal Map", 2D) = "bump" {} [Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0 // Blending state [HideInInspector] _Mode ("__mode", Float) = 0.0 [HideInInspector] _SrcBlend ("__src", Float) = 1.0 [HideInInspector] _DstBlend ("__dst", Float) = 0.0 [HideInInspector] _ZWrite ("__zw", Float) = 1.0 } CGINCLUDE #define UNITY_SETUP_BRDF_INPUT MetallicSetup ENDCG SubShader { Tags { "RenderType"="Opaque" "PerformanceChecks"="False" } LOD 300 // ------------------------------------------------------------------ // Base forward pass (directional light, emission, lightmaps, ...) Pass { Name "FORWARD" Tags { "LightMode" = "ForwardBase" } Blend [_SrcBlend] [_DstBlend] ZWrite [_ZWrite] CGPROGRAM #pragma target 3.0 // ------------------------------------- #pragma shader_feature _NORMALMAP #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma shader_feature _EMISSION #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature ___ _DETAIL_MULX2 #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF #pragma shader_feature _ _GLOSSYREFLECTIONS_OFF #pragma shader_feature _PARALLAXMAP #pragma multi_compile_fwdbase #pragma multi_compile_fog #pragma vertex vertBase #pragma fragment fragBase #include "UnityStandardCoreForward.cginc" ENDCG } // ------------------------------------------------------------------ // Additive forward pass (one light per pass) Pass { Name "FORWARD_DELTA" Tags { "LightMode" = "ForwardAdd" } Blend [_SrcBlend] One Fog { Color (0,0,0,0) } // in additive pass fog should be black ZWrite Off ZTest LEqual Cull off CGPROGRAM #pragma target 3.0 // ------------------------------------- #pragma shader_feature _NORMALMAP #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF #pragma shader_feature ___ _DETAIL_MULX2 #pragma shader_feature _PARALLAXMAP #pragma multi_compile_fwdadd_fullshadows #pragma multi_compile_fog #pragma vertex vertAdd #pragma fragment fragAdd #include "UnityStandardCoreForward.cginc" ENDCG } // ------------------------------------------------------------------ // Shadow rendering pass Pass { Name "ShadowCaster" Tags { "LightMode" = "ShadowCaster" } ZWrite On ZTest LEqual Cull off CGPROGRAM #pragma target 3.0 // ------------------------------------- #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma multi_compile_shadowcaster #pragma vertex vertShadowCaster #pragma fragment fragShadowCaster #include "UnityStandardShadow.cginc" ENDCG } // ------------------------------------------------------------------ // Deferred pass 1 Pass { Name "DEFERRED" Tags { "LightMode" = "Deferred" } Cull Back ZWrite On ZTest LEqual CGPROGRAM #pragma target 3.0 #pragma exclude_renderers nomrt // ------------------------------------- #pragma shader_feature _NORMALMAP #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma shader_feature _EMISSION #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF #pragma shader_feature ___ _DETAIL_MULX2 #pragma shader_feature _PARALLAXMAP #pragma multi_compile ___ UNITY_HDR_ON #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON #pragma multi_compile ___ DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON #pragma vertex vertDeferred #pragma fragment fragDeferred #include "UnityStandardCoreDoubleSided.cginc" ENDCG } // ------------------------------------------------------------------ // Deferred pass 2 Pass { Name "DEFERRED" Tags{ "LightMode" = "Deferred" } Cull Front ZWrite On ZTest LEqual CGPROGRAM #pragma target 3.0 #pragma exclude_renderers nomrt // ------------------------------------- #pragma shader_feature _NORMALMAP #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma shader_feature _EMISSION #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF #pragma shader_feature ___ _DETAIL_MULX2 #pragma shader_feature _PARALLAXMAP #pragma multi_compile ___ UNITY_HDR_ON #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON #pragma multi_compile ___ DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON #pragma vertex vertDeferred #pragma fragment fragDeferredBackSide #include "UnityStandardCoreDoubleSided.cginc" ENDCG } // ------------------------------------------------------------------ // Extracts information for lightmapping, GI (emission, albedo, ...) // This pass it not used during regular rendering. Pass { Name "META" Tags { "LightMode"="Meta" } Cull Off ZWrite On ZTest LEqual CGPROGRAM #pragma vertex vert_meta #pragma fragment frag_meta #pragma shader_feature _EMISSION #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature ___ _DETAIL_MULX2 #include "UnityStandardMeta.cginc" ENDCG } } SubShader { Tags { "RenderType"="Opaque" "PerformanceChecks"="False" } LOD 150 // ------------------------------------------------------------------ // Base forward pass (directional light, emission, lightmaps, ...) Pass { Name "FORWARD" Tags { "LightMode" = "ForwardBase" } Cull off Blend [_SrcBlend] [_DstBlend] ZWrite [_ZWrite] CGPROGRAM #pragma target 2.0 #pragma shader_feature _NORMALMAP #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma shader_feature _EMISSION #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF #pragma shader_feature _ _GLOSSYREFLECTIONS_OFF // SM2.0: NOT SUPPORTED shader_feature ___ _DETAIL_MULX2 // SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP #pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE #pragma multi_compile_fwdbase #pragma multi_compile_fog #pragma vertex vertBase #pragma fragment fragBase #include "UnityStandardCoreForward.cginc" ENDCG } // ------------------------------------------------------------------ // Additive forward pass (one light per pass) Pass { Name "FORWARD_DELTA" Tags { "LightMode" = "ForwardAdd" } Blend [_SrcBlend] One Fog { Color (0,0,0,0) } // in additive pass fog should be black ZWrite Off ZTest LEqual Cull off CGPROGRAM #pragma target 2.0 #pragma shader_feature _NORMALMAP #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF #pragma shader_feature ___ _DETAIL_MULX2 // SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP #pragma skip_variants SHADOWS_SOFT #pragma multi_compile_fwdadd_fullshadows #pragma multi_compile_fog #pragma vertex vertAdd #pragma fragment fragAdd #include "UnityStandardCoreForward.cginc" ENDCG } // ------------------------------------------------------------------ // Shadow rendering pass Pass { Name "ShadowCaster" Tags { "LightMode" = "ShadowCaster" } ZWrite On ZTest LEqual Cull off CGPROGRAM #pragma target 2.0 #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON #pragma skip_variants SHADOWS_SOFT #pragma multi_compile_shadowcaster #pragma vertex vertShadowCaster #pragma fragment fragShadowCaster #include "UnityStandardShadow.cginc" ENDCG } // ------------------------------------------------------------------ // Extracts information for lightmapping, GI (emission, albedo, ...) // This pass it not used during regular rendering. Pass { Name "META" Tags { "LightMode"="Meta" } Cull Off ZWrite On ZTest LEqual CGPROGRAM #pragma vertex vert_meta #pragma fragment frag_meta #pragma shader_feature _EMISSION #pragma shader_feature _METALLICGLOSSMAP #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A #pragma shader_feature ___ _DETAIL_MULX2 #include "UnityStandardMeta.cginc" ENDCG } } FallBack "VertexLit" CustomEditor "StandardShaderGUI" } Include "UnityStandardCoreDoubleSided.cginc": #include "UnityCG.cginc" #include "UnityShaderVariables.cginc" #include "UnityInstancing.cginc" #include "UnityStandardConfig.cginc" #include "UnityStandardInput.cginc" #include "UnityPBSLighting.cginc" #include "UnityStandardUtils.cginc" #include "UnityStandardBRDF.cginc" #include "AutoLight.cginc" //------------------------------------------------------------------------------------- // counterpart for NormalizePerPixelNormal // skips normalization per-vertex and expects normalization to happen per-pixel half3 NormalizePerVertexNormal (float3 n) // takes float to avoid overflow { #if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE return normalize(n); #else return n; // will normalize per-pixel instead #endif } half3 NormalizePerPixelNormal (half3 n) { #if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE return n; #else return normalize(n); #endif } //------------------------------------------------------------------------------------- UnityLight MainLight (half3 normalWorld) { UnityLight l; #ifdef LIGHTMAP_OFF l.color = _LightColor0.rgb; l.dir = _WorldSpaceLightPos0.xyz; l.ndotl = LambertTerm (normalWorld, l.dir); #else // no light specified by the engine // analytical light might be extracted from Lightmap data later on in the shader depending on the Lightmap type l.color = half3(0.f, 0.f, 0.f); l.ndotl = 0.f; l.dir = half3(0.f, 0.f, 0.f); #endif return l; } UnityLight AdditiveLight (half3 normalWorld, half3 lightDir, half atten) { UnityLight l; l.color = _LightColor0.rgb; l.dir = lightDir; #ifndef USING_DIRECTIONAL_LIGHT l.dir = NormalizePerPixelNormal(l.dir); #endif l.ndotl = LambertTerm (normalWorld, l.dir); // shadow the light l.color *= atten; return l; } UnityLight DummyLight (half3 normalWorld) { UnityLight l; l.color = 0; l.dir = half3 (0,1,0); l.ndotl = LambertTerm (normalWorld, l.dir); return l; } UnityIndirect ZeroIndirect () { UnityIndirect ind; ind.diffuse = 0; ind.specular = 0; return ind; } //------------------------------------------------------------------------------------- // Common fragment setup // deprecated half3 WorldNormal(half4 tan2world[3]) { return normalize(tan2world[2].xyz); } // deprecated #ifdef _TANGENT_TO_WORLD half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3]) { half3 t = tan2world[0].xyz; half3 b = tan2world[1].xyz; half3 n = tan2world[2].xyz; #if UNITY_TANGENT_ORTHONORMALIZE n = NormalizePerPixelNormal(n); // ortho-normalize Tangent t = normalize (t - n * dot(t, n)); // recalculate Binormal half3 newB = cross(n, t); b = newB * sign (dot (newB, ); #endif return half3x3(t, b, n); } #else half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3]) { return half3x3(0,0,0,0,0,0,0,0,0); } #endif half3 PerPixelWorldNormal(float4 i_tex, half4 tangentToWorld[3]) { #ifdef _NORMALMAP half3 tangent = tangentToWorld[0].xyz; half3 binormal = tangentToWorld[1].xyz; half3 normal = tangentToWorld[2].xyz; #if UNITY_TANGENT_ORTHONORMALIZE normal = NormalizePerPixelNormal(normal); // ortho-normalize Tangent tangent = normalize (tangent - normal * dot(tangent, normal)); // recalculate Binormal half3 newB = cross(normal, tangent); binormal = newB * sign (dot (newB, binormal)); #endif half3 normalTangent = NormalInTangentSpace(i_tex); half3 normalWorld = NormalizePerPixelNormal(tangent * normalTangent.x + binormal * normalTangent.y + normal * normalTangent.z); // @TODO: see if we can squeeze this normalize on SM2.0 as well #else half3 normalWorld = normalize(tangentToWorld[2].xyz); #endif return normalWorld; } #ifdef _PARALLAXMAP #define IN_VIEWDIR4PARALLAX(i) NormalizePerPixelNormal(half3(i.tangentToWorldAndParallax[0].w,i.tangentToWorldAndParallax[1].w,i.tangentToWorldAndParallax[2].w)) #define IN_VIEWDIR4PARALLAX_FWDADD(i) NormalizePerPixelNormal(i.viewDirForParallax.xyz) #else #define IN_VIEWDIR4PARALLAX(i) half3(0,0,0) #define IN_VIEWDIR4PARALLAX_FWDADD(i) half3(0,0,0) #endif #if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME #define IN_WORLDPOS(i) i.posWorld #else #define IN_WORLDPOS(i) half3(0,0,0) #endif #define IN_LIGHTDIR_FWDADD(i) half3(i.tangentToWorldAndLightDir[0].w, i.tangentToWorldAndLightDir[1].w, i.tangentToWorldAndLightDir[2].w) #define FRAGMENT_SETUP(x) FragmentCommonData x = \ FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX(i), i.tangentToWorldAndParallax, IN_WORLDPOS(i)); #define FRAGMENT_SETUP_FWDADD(x) FragmentCommonData x = \ FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX_FWDADD(i), i.tangentToWorldAndLightDir, half3(0,0,0)); struct FragmentCommonData { half3 diffColor, specColor; // Note: oneMinusRoughness & oneMinusReflectivity for optimization purposes, mostly for DX9 SM2.0 level. // Most of the math is being done on these (1-x) values, and that saves a few precious ALU slots. half oneMinusReflectivity, oneMinusRoughness; half3 normalWorld, eyeVec, posWorld; half alpha; #if UNITY_OPTIMIZE_TEXCUBELOD || UNITY_STANDARD_SIMPLE half3 reflUVW; #endif #if UNITY_STANDARD_SIMPLE half3 tangentSpaceNormal; #endif }; #ifndef UNITY_SETUP_BRDF_INPUT #define UNITY_SETUP_BRDF_INPUT SpecularSetup #endif inline FragmentCommonData SpecularSetup (float4 i_tex) { half4 specGloss = SpecularGloss(i_tex.xy); half3 specColor = specGloss.rgb; half oneMinusRoughness = specGloss.a; half oneMinusReflectivity; half3 diffColor = EnergyConservationBetweenDiffuseAndSpecular (Albedo(i_tex), specColor, /*out*/ oneMinusReflectivity); FragmentCommonData o = (FragmentCommonData)0; o.diffColor = diffColor; o.specColor = specColor; o.oneMinusReflectivity = oneMinusReflectivity; o.oneMinusRoughness = oneMinusRoughness; return o; } inline FragmentCommonData MetallicSetup (float4 i_tex) { half2 metallicGloss = MetallicGloss(i_tex.xy); half metallic = metallicGloss.x; half oneMinusRoughness = metallicGloss.y; // this is 1 minus the square root of real roughness m. half oneMinusReflectivity; half3 specColor; half3 diffColor = DiffuseAndSpecularFromMetallic (Albedo(i_tex), metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity); FragmentCommonData o = (FragmentCommonData)0; o.diffColor = diffColor; o.specColor = specColor; o.oneMinusReflectivity = oneMinusReflectivity; o.oneMinusRoughness = oneMinusRoughness; return o; } inline FragmentCommonData FragmentSetup (float4 i_tex, half3 i_eyeVec, half3 i_viewDirForParallax, half4 tangentToWorld[3], half3 i_posWorld) { i_tex = Parallax(i_tex, i_viewDirForParallax); half alpha = Alpha(i_tex.xy); #if defined(_ALPHATEST_ON) clip (alpha - _Cutoff); #endif FragmentCommonData o = UNITY_SETUP_BRDF_INPUT (i_tex); o.normalWorld = PerPixelWorldNormal(i_tex, tangentToWorld); o.eyeVec = NormalizePerPixelNormal(i_eyeVec); o.posWorld = i_posWorld; // NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha) o.diffColor = PreMultiplyAlpha (o.diffColor, alpha, o.oneMinusReflectivity, /*out*/ o.alpha); return o; } inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light, bool reflections) { UnityGIInput d; d.light = light; d.worldPos = s.posWorld; d.worldViewDir = -s.eyeVec; d.atten = atten; #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON) d.ambient = 0; d.lightmapUV = i_ambientOrLightmapUV; #else d.ambient = i_ambientOrLightmapUV.rgb; d.lightmapUV = 0; #endif d.boxMax[0] = unity_SpecCube0_BoxMax; d.boxMin[0] = unity_SpecCube0_BoxMin; d.probePosition[0] = unity_SpecCube0_ProbePosition; d.probeHDR[0] = unity_SpecCube0_HDR; d.boxMax[1] = unity_SpecCube1_BoxMax; d.boxMin[1] = unity_SpecCube1_BoxMin; d.probePosition[1] = unity_SpecCube1_ProbePosition; d.probeHDR[1] = unity_SpecCube1_HDR; if(reflections) { Unity_GlossyEnvironmentData g; g.roughness = 1 - s.oneMinusRoughness; #if UNITY_OPTIMIZE_TEXCUBELOD || UNITY_STANDARD_SIMPLE g.reflUVW = s.reflUVW; #else g.reflUVW = reflect(s.eyeVec, s.normalWorld); #endif return UnityGlobalIllumination (d, occlusion, s.normalWorld, g); } else { return UnityGlobalIllumination (d, occlusion, s.normalWorld); } } inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light) { return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, true); } //------------------------------------------------------------------------------------- half4 OutputForward (half4 output, half alphaFromSurface) { #if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON) output.a = alphaFromSurface; #else UNITY_OPAQUE_ALPHA(output.a); #endif return output; } inline half4 VertexGIForward(VertexInput v, float3 posWorld, half3 normalWorld) { half4 ambientOrLightmapUV = 0; // Static lightmaps #ifndef LIGHTMAP_OFF ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw; ambientOrLightmapUV.zw = 0; // Sample light probe for Dynamic objects only (no static or dynamic lightmaps) #elif UNITY_SHOULD_SAMPLE_SH #ifdef VERTEXLIGHT_ON // Approximated illumination from non-important point lights ambientOrLightmapUV.rgb = Shade4PointLights ( unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0, unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb, unity_4LightAtten0, posWorld, normalWorld); #endif ambientOrLightmapUV.rgb = ShadeSHPerVertex (normalWorld, ambientOrLightmapUV.rgb); #endif #ifdef DYNAMICLIGHTMAP_ON ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw; #endif return ambientOrLightmapUV; } // ------------------------------------------------------------------ // Base forward pass (directional light, emission, lightmaps, ...) struct VertexOutputForwardBase { float4 pos : SV_POSITION; float4 tex : TEXCOORD0; half3 eyeVec : TEXCOORD1; half4 tangentToWorldAndParallax[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax] half4 ambientOrLightmapUV : TEXCOORD5; // SH or Lightmap UV SHADOW_COORDS(6) UNITY_FOG_COORDS(7) // next ones would not fit into SM2.0 limits, but they are always for SM3.0+ #if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME float3 posWorld : TEXCOORD8; #endif #if UNITY_OPTIMIZE_TEXCUBELOD #if UNITY_SPECCUBE_BOX_PROJECTION half3 reflUVW : TEXCOORD9; #else half3 reflUVW : TEXCOORD8; #endif #endif UNITY_VERTEX_OUTPUT_STEREO }; VertexOutputForwardBase vertForwardBase (VertexInput v) { UNITY_SETUP_INSTANCE_ID(v); VertexOutputForwardBase o; UNITY_INITIALIZE_OUTPUT(VertexOutputForwardBase, o); UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); float4 posWorld = mul(unity_ObjectToWorld, v.vertex); #if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME o.posWorld = posWorld.xyz; #endif o.pos = UnityObjectToClipPos(v.vertex); o.tex = TexCoords(v); o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos); float3 normalWorld = UnityObjectToWorldNormal(v.normal); #ifdef _TANGENT_TO_WORLD float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w); float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w); o.tangentToWorldAndParallax[0].xyz = tangentToWorld[0]; o.tangentToWorldAndParallax[1].xyz = tangentToWorld[1]; o.tangentToWorldAndParallax[2].xyz = tangentToWorld[2]; #else o.tangentToWorldAndParallax[0].xyz = 0; o.tangentToWorldAndParallax[1].xyz = 0; o.tangentToWorldAndParallax[2].xyz = normalWorld; #endif //We need this for shadow receving TRANSFER_SHADOW(o); o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld); #ifdef _PARALLAXMAP TANGENT_SPACE_ROTATION; half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex)); o.tangentToWorldAndParallax[0].w = viewDirForParallax.x; o.tangentToWorldAndParallax[1].w = viewDirForParallax.y; o.tangentToWorldAndParallax[2].w = viewDirForParallax.z; #endif #if UNITY_OPTIMIZE_TEXCUBELOD o.reflUVW = reflect(o.eyeVec, normalWorld); #endif UNITY_TRANSFER_FOG(o,o.pos); return o; } half4 fragForwardBaseInternal (VertexOutputForwardBase i) { FRAGMENT_SETUP(s) #if UNITY_OPTIMIZE_TEXCUBELOD s.reflUVW = i.reflUVW; #endif UnityLight mainLight = MainLight (s.normalWorld); half atten = SHADOW_ATTENUATION(i); half occlusion = Occlusion(i.tex.xy); UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight); half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect); c.rgb += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, occlusion, gi); c.rgb += Emission(i.tex.xy); UNITY_APPLY_FOG(i.fogCoord, c.rgb); return OutputForward (c, s.alpha); } half4 fragForwardBase (VertexOutputForwardBase i) : SV_Target // backward compatibility (this used to be the fragment entry function) { return fragForwardBaseInternal(i); } // ------------------------------------------------------------------ // Additive forward pass (one light per pass) struct VertexOutputForwardAdd { float4 pos : SV_POSITION; float4 tex : TEXCOORD0; half3 eyeVec : TEXCOORD1; half4 tangentToWorldAndLightDir[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:lightDir] LIGHTING_COORDS(5,6) UNITY_FOG_COORDS(7) // next ones would not fit into SM2.0 limits, but they are always for SM3.0+ #if defined(_PARALLAXMAP) half3 viewDirForParallax : TEXCOORD8; #endif UNITY_VERTEX_OUTPUT_STEREO }; VertexOutputForwardAdd vertForwardAdd (VertexInput v) { VertexOutputForwardAdd o; UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAdd, o); UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); float4 posWorld = mul(unity_ObjectToWorld, v.vertex); o.pos = UnityObjectToClipPos(v.vertex); o.tex = TexCoords(v); o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos); float3 normalWorld = UnityObjectToWorldNormal(v.normal); #ifdef _TANGENT_TO_WORLD float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w); float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w); o.tangentToWorldAndLightDir[0].xyz = tangentToWorld[0]; o.tangentToWorldAndLightDir[1].xyz = tangentToWorld[1]; o.tangentToWorldAndLightDir[2].xyz = tangentToWorld[2]; #else o.tangentToWorldAndLightDir[0].xyz = 0; o.tangentToWorldAndLightDir[1].xyz = 0; o.tangentToWorldAndLightDir[2].xyz = normalWorld; #endif //We need this for shadow receiving TRANSFER_VERTEX_TO_FRAGMENT(o); float3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w; #ifndef USING_DIRECTIONAL_LIGHT lightDir = NormalizePerVertexNormal(lightDir); #endif o.tangentToWorldAndLightDir[0].w = lightDir.x; o.tangentToWorldAndLightDir[1].w = lightDir.y; o.tangentToWorldAndLightDir[2].w = lightDir.z; #ifdef _PARALLAXMAP TANGENT_SPACE_ROTATION; o.viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex)); #endif UNITY_TRANSFER_FOG(o,o.pos); return o; } half4 fragForwardAddInternal (VertexOutputForwardAdd i) { FRAGMENT_SETUP_FWDADD(s) UnityLight light = AdditiveLight (s.normalWorld, IN_LIGHTDIR_FWDADD(i), LIGHT_ATTENUATION(i)); UnityIndirect noIndirect = ZeroIndirect (); half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, light, noIndirect); UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass return OutputForward (c, s.alpha); } half4 fragForwardAdd (VertexOutputForwardAdd i) : SV_Target // backward compatibility (this used to be the fragment entry function) { return fragForwardAddInternal(i); } // ------------------------------------------------------------------ // Deferred pass struct VertexOutputDeferred { float4 pos : SV_POSITION; float4 tex : TEXCOORD0; half3 eyeVec : TEXCOORD1; half4 tangentToWorldAndParallax[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax] half4 ambientOrLightmapUV : TEXCOORD5; // SH or Lightmap UVs #if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME float3 posWorld : TEXCOORD6; #endif #if UNITY_OPTIMIZE_TEXCUBELOD #if UNITY_SPECCUBE_BOX_PROJECTION half3 reflUVW : TEXCOORD7; #else half3 reflUVW : TEXCOORD6; #endif #endif UNITY_VERTEX_OUTPUT_STEREO }; VertexOutputDeferred vertDeferred (VertexInput v) { UNITY_SETUP_INSTANCE_ID(v); VertexOutputDeferred o; UNITY_INITIALIZE_OUTPUT(VertexOutputDeferred, o); UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); float4 posWorld = mul(unity_ObjectToWorld, v.vertex); #if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME o.posWorld = posWorld; #endif o.pos = UnityObjectToClipPos(v.vertex); o.tex = TexCoords(v); o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos); float3 normalWorld = UnityObjectToWorldNormal(v.normal); #ifdef _TANGENT_TO_WORLD float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w); float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w); o.tangentToWorldAndParallax[0].xyz = tangentToWorld[0]; o.tangentToWorldAndParallax[1].xyz = tangentToWorld[1]; o.tangentToWorldAndParallax[2].xyz = tangentToWorld[2]; #else o.tangentToWorldAndParallax[0].xyz = 0; o.tangentToWorldAndParallax[1].xyz = 0; o.tangentToWorldAndParallax[2].xyz = normalWorld; #endif o.ambientOrLightmapUV = 0; #ifndef LIGHTMAP_OFF o.ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw; #elif UNITY_SHOULD_SAMPLE_SH o.ambientOrLightmapUV.rgb = ShadeSHPerVertex (normalWorld, o.ambientOrLightmapUV.rgb); #endif #ifdef DYNAMICLIGHTMAP_ON o.ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw; #endif #ifdef _PARALLAXMAP TANGENT_SPACE_ROTATION; half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex)); o.tangentToWorldAndParallax[0].w = viewDirForParallax.x; o.tangentToWorldAndParallax[1].w = viewDirForParallax.y; o.tangentToWorldAndParallax[2].w = viewDirForParallax.z; #endif #if UNITY_OPTIMIZE_TEXCUBELOD o.reflUVW = reflect(o.eyeVec, normalWorld); #endif return o; } void fragDeferred ( VertexOutputDeferred i, out half4 outDiffuse : SV_Target0, // RT0: diffuse color (rgb), occlusion (a) out half4 outSpecSmoothness : SV_Target1, // RT1: spec color (rgb), smoothness (a) out half4 outNormal : SV_Target2, // RT2: normal (rgb), --unused, very low precision-- (a) out half4 outEmission : SV_Target3 // RT3: emission (rgb), --unused-- (a) ) { #if (SHADER_TARGET < 30) outDiffuse = 1; outSpecSmoothness = 1; outNormal = 0; outEmission = 0; return; #endif FRAGMENT_SETUP(s) #if UNITY_OPTIMIZE_TEXCUBELOD s.reflUVW = i.reflUVW; #endif // no analytic lights in this pass UnityLight dummyLight = DummyLight (s.normalWorld); half atten = 1; // only GI half occlusion = Occlusion(i.tex.xy); #if UNITY_ENABLE_REFLECTION_BUFFERS bool sampleReflectionsInDeferred = false; #else bool sampleReflectionsInDeferred = true; #endif UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, dummyLight, sampleReflectionsInDeferred); half3 color = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect).rgb; color += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, occlusion, gi); #ifdef _EMISSION color += Emission (i.tex.xy); #endif #ifndef UNITY_HDR_ON color.rgb = exp2(-color.rgb); #endif outDiffuse = half4(s.diffColor, occlusion); outSpecSmoothness = half4(s.specColor, s.oneMinusRoughness); outNormal = half4(s.normalWorld*0.5+0.5,1); outEmission = half4(color, 1); } // Added by Zer0f0rce (Skype) for the Game "Twin Destiny" by Hugin Munin Studios LLC void fragDeferredBackSide( VertexOutputDeferred i, out half4 outDiffuse : SV_Target0, // RT0: diffuse color (rgb), occlusion (a) out half4 outSpecSmoothness : SV_Target1, // RT1: spec color (rgb), smoothness (a) out half4 outNormal : SV_Target2, // RT2: normal (rgb), --unused, very low precision-- (a) out half4 outEmission : SV_Target3 // RT3: emission (rgb), --unused-- (a) ) { #if (SHADER_TARGET < 30) outDiffuse = 1; outSpecSmoothness = 1; outNormal = 0; outEmission = 0; return; #endif FRAGMENT_SETUP(s) #if UNITY_OPTIMIZE_TEXCUBELOD s.reflUVW = i.reflUVW; #endif s.normalWorld = -s.normalWorld; // no analytic lights in this pass UnityLight dummyLight = DummyLight(s.normalWorld); half atten = 1; // only GI half occlusion = Occlusion(i.tex.xy); #if UNITY_ENABLE_REFLECTION_BUFFERS bool sampleReflectionsInDeferred = false; #else bool sampleReflectionsInDeferred = true; #endif UnityGI gi = FragmentGI(s, occlusion, i.ambientOrLightmapUV, atten, dummyLight, sampleReflectionsInDeferred); half3 color = UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect).rgb; color += UNITY_BRDF_GI(s.diffColor, s.specColor, s.oneMinusReflectivity, s.oneMinusRoughness, s.normalWorld, -s.eyeVec, occlusion, gi); #ifdef _EMISSION color += Emission(i.tex.xy); #endif #ifndef UNITY_HDR_ON color.rgb = exp2(-color.rgb); #endif outDiffuse = half4(s.diffColor, occlusion); outSpecSmoothness = half4(s.specColor, s.oneMinusRoughness); outNormal = half4(s.normalWorld*0.5 + 0.5, 1); outEmission = half4(color, 1); s.normalWorld = -s.normalWorld; } // // Old FragmentGI signature. Kept only for backward compatibility and will be removed soon // inline UnityGI FragmentGI( float3 posWorld, half occlusion, half4 i_ambientOrLightmapUV, half atten, half oneMinusRoughness, half3 normalWorld, half3 eyeVec, UnityLight light, bool reflections) { // we init only fields actually used FragmentCommonData s = (FragmentCommonData)0; s.oneMinusRoughness = oneMinusRoughness; s.normalWorld = normalWorld; s.eyeVec = eyeVec; s.posWorld = posWorld; #if UNITY_OPTIMIZE_TEXCUBELOD s.reflUVW = reflect(eyeVec, normalWorld); #endif return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, reflections); } inline UnityGI FragmentGI ( float3 posWorld, half occlusion, half4 i_ambientOrLightmapUV, half atten, half oneMinusRoughness, half3 normalWorld, half3 eyeVec, UnityLight light) { return FragmentGI (posWorld, occlusion, i_ambientOrLightmapUV, atten, oneMinusRoughness, normalWorld, eyeVec, light, true); }
  38. 1 like
    Oder einfach public Gradient gradient; public void Update() { light.color = gradient.Evaluate(time); }
  39. 1 like
    Hi Sascha, ich hab das schon gelesen, aber es hat bisher nix zum Erfolg geführt. Mittlerweile habe ich zu Testzwecken in fast allen Ordnern ne Datei "Ausschluss.txt". Ich vermute fast, dass das Problem woanders liegt. Vielleicht ist die Datei zu groß (178 kb), vielleicht muss die Endung anders lautet (ne, bei Textdateien nicht) oder oder oder. Ich verstehe es nicht... ### Ich habs rausgekriegt... ### Die Endung ".txt" muss entfernt werden. Das ist alles... Also nur: if (System.IO.File.Exists("Resources/Ausschluss.txt")) LoadTxtFromResource("Ausschluss");
  40. 1 like
    Hallo malzbie, vielen Dank für deine Antwort. Leider bin ich erste heute dazugekommen, zu antworten. Unglaublich - dieses Unity!! Ziel ist es, sogar, ein Mesh mit sechs Millionen Faces zu importieren. Eine manuelle Aufteilung in 64K-Meshes in einem 3D-Programm zu machen wäre sehr aufwändig und mit sehr viel manueller Arbeit verbunden. Zudem auch noch Fehleranfällig. Mittlerweile konnte ich das Problem allerdings lösen. Wie ich schrieb, liegen mir die Daten des Meshes im Obj + mtl vor. Die Texturen erstrecken sich über 16 jeweils 16.384x16.384 Pixel.große Jpg-Files. Problem war, dass Unity beim Import die mtl-Files nicht berücksichtigt. Üblicherweise macht das nichts, da es in der Regel lediglich ein Textur-File pro Mesh (Objekt) gibt. Eine solches einzelnes Textur-File kann man einfach nach dem Import zuweisen. Ich habe jedoch 16 TextureFiles für das eine große Mesh. Die wichtigen Informationen, auf welches File sich die jeweiligen Texturkoordinaten beziehen, stehen allerdings im mtl-File. Und da Unity dieses File nicht berücksichtigt, konnte es kein vernünftiges Mapping der Texturdaten vornehmen. Meine Lösung war, den Autodesk FBX Converter 2013 zur Konvertierung von Obj + mtl nach fbx heranzuziehen. Der berücksichtigt das mtl-File und schreibt diese Infomationen auch korrekt mit in das fbx-File. Unity wiederum berücksichtigt beim Import dir mtl-Daten, wenn sie sich in einem fbx befinden. Vor dem Import der fbx-Daten, die 16 Texturefiles in Unity importiert, dann das fbx - super, klappt alles. Sogar mit 6 Millionen Faces im Mesh. Unity teilte das Mesh in 92 einzelne Objekte, konvertierte die Texturdaten auf jeweils 8192x8192 Pixel und komprimierte diese entsprechend. Eine richtig geile Sache. Läuft absolut flüssig mit > 60 Bps. Unglaublich, was Unity in diesem Bereich kann. Nun kann ich super durch die Ruine laufen, oder drin rumfliegen - auch in VR mit der Occulus. Im Blender konnte ich das Mesh einschl. Texturen überhaupt nicht laden. Nachdem ich lernen durfte, dass die Textur-Koordinaten stets normiert sind, wurde mir klar, dass ich die Texturen eines solchen Mega-Meshes beliebig in der Größe verändern kann - passt trotzdem immer. Somit konnte ich das Projekt mit niedrigerer Auflösung der Texturen in Blender importieren. Nochmals, Danke für die Antwort
  41. 1 like
    Das Finanzamt kommt "nach" der Gewerbeanmeldung! Also ist meine Aussage richtig, gelle? Ich weiß übrigens auch wovon ich rede, denn ich bin seit Januar selbstständig. Die Unstazsteuervoranmeldung macht jeder Einzelunternehmer, der kein Kleingewerbe hat, in den ersten Jahren monatlich. Da ist nix mit jährlich. Nach dieser Zeit brauchst du dass dann nur noch alle 3 Monate machen. Von Jährlich habe ich beim Einzelunternehmen noch nichts gehört. Übrigens muss man nicht warten, bis das Finanzamt sich meldet. Man kann auch gleich nach der Gewerbeanmeldung das Formular ausfüllen und ans Amt schicken, man kann es nämlich auf der Homepage vom Finanzamt runter laden. Das spart Zeit! Dabei dann auch gleich die europäische Umsatzsteuernummer mit beantragen.
  42. 1 like
    Soll sich nur die Maintextur drehen, dann verwende diesen Shader hier: Shader "Legacy Shaders/DecalRotateMaintex" { // Created for Unity Insider Forum by zer0f0rce 2017 Properties{ _Color("Main Color", Color) = (1,1,1,1) _MainTex("Base (RGB)", 2D) = "white" {} _DecalTex("Decal (RGBA)", 2D) = "black" {} _Speed("Speed", Range(0,50)) = 1.0 } SubShader{ Tags{ "RenderType" = "Opaque" } LOD 250 CGPROGRAM #pragma surface surf Lambert sampler2D _MainTex; sampler2D _DecalTex; fixed4 _Color; float _Speed; struct Input { float2 uv_MainTex; float2 uv_DecalTex; }; void surf(Input IN, inout SurfaceOutput o) { fixed2 inuv = IN.uv_DecalTex; float sin_factor = sin(_Time.y / (1.0f / _Speed)); float cos_factor = cos(_Time.y / (1.0f / _Speed)); inuv = mul((inuv - 0.5), float2x2(cos_factor, sin_factor, -sin_factor, cos_factor)); fixed4 c = tex2D(_MainTex, inuv); half4 decal = tex2D(_DecalTex, IN.uv_DecalTex); c.rgb = lerp(c.rgb, decal.rgb, decal.a); c *= _Color; o.Albedo = c.rgb; o.Alpha = c.a; } ENDCG } Fallback "Legacy Shaders/Diffuse" } PS: Beide Skripte als *.shader speichern und im Projektverzeichnis ablegen. Die Shader benötigen keinerlei zusätzliche Skripte mehr, einfach Material erstellen und unter "Legacy/Shader" einen der beiden gewünschten Shader auswählen.
  43. 1 like
    Hab nochmal n bischen weiter gemacht.
  44. 1 like
    Danke für den Tipp, ich habe die Methode mal daraufhin zusammengefasst zu GameObject particleSystem = Instantiate(particles, new Vector3( gameObject.transform.position.x, gameObject.transform.position.y, gameObject.transform.position.z), particles.transform.rotation); Destroy(particleSystem, 5); Die Methode particleSystem.transform.SetParent(gameObject.transform, false); ist sehr hilfreich, leider wird dadurch, dass die Zellen nun auf 1,0.2,1 stehen, das Partikelsystem stark verschoben, von daher lasse ich das mit dem Kindobjekt, da die Partikelsysteme sowieso nach einer gewissen Zeit zerstört werden sollen. Und nein, das Zerstören sollte nicht so sein, sondern auf die korrekte Weise aber durch deine Frage habe ich auch den Fehler entdeckt und das dementsprechend oben in der Methode angepasst. Danke
  45. 1 like
    Haha, danke. Ja, ich denke schon, dass ich Automaten ganz gut einschätzen kann. Irgendwann möchte ich mir auch mal einen echten in die Bude stellen. Weiß noch nicht 100%'ig welchen. Ich kenn aber auch deine Lage als Entwickler eines Automaten. Gerade wenn es darum geht, wie die Kugel am besten zu sein hat, scheiden sich die Meinungen. Das Problem ist aber, dass man in den meisten Fällen die Rampen und halt den ganzen Aufbau, auf die Kugelphysik eingestellt hat. Schraubt man nun zu sehr an den Eigenschaften, verändert man oft auch den Schwierigkeitsgrad unfreiwillig, oder die Positionen der Aufbauten passen nicht mehr richtig. Wenn ich irgendwann mal Bock habe, werde ich mal meinen Automaten mal hier zum Download anbieten. Grad nicht, weil ich keine Lust habe, dazu viel zu schreiben. ;D (und verpassen tut man auch wenig) Geh ich lieber noch auf dich ein... Thema Carnival / Jahrmarkt ist ja der Hammer! Das finde ich richtig nice. Da steh ich voll drauf als Thema. Am liebsten noch schön Funfair im USA Flair der 60/70er Jahre. Wichtig ist mir da ganz klar die Stimmung die erzeugt wird. So richtig schöne Geräusche aus den Buden und Jahrmarkt-Musik. Mal sehen wie du das löst, vor allem, weil du da noch Carnival mit drinnen hast. Einer meiner lieblings Pinballs (wenn nicht sogar der Liebste) ist das alte Pinball Fantasies. Das hat sogar Einen mit so nem Funfairstyle (Partyland). Kennste bestimmt....wenn nicht, unbedingt mal anschauen auf Youtube.
  46. 1 like
    Hehe! Glückwunsch zum Geburtstag! Vielen Dank für deine Antwort! Ja, das Dingen braucht schon einiges an Leistung. Liegt hauptsächlich am SSAA Filter und den Reflektionen/Lichtern. Ich hab zwar vieles Gebacken, darstellen muss die Graka es aber dennoch. Die Prozessorlast ist für heutige Rechner eigentlich nicht sehr hoch. Dürfte bei deinem NB so geschätzt bei 60-70 % liegen. Endlich mal jemand, der Flipper richtig mag und auch einschätzen kann, wie schwer er ist. Ich persönlich finde ihn auch nicht sooo schwer. Er liegt so im Mittelfeld von den Flippern, die ich bis heute gespielt habe. Ich schaffe es eigentlich nach spätestens 5 Spielen auch mal alle Missionen zu spielen. Gut, ich kenne mein Baby natürlich ganz genau. Übrigens bin ich gerade dabei den zweiten Flipper zu bauen. Er wird das Thema Carnival / Jahrmarkt haben. Dieser Flipper ist sehr hoch und wird mit den Rampen dann 4 Ebenen haben. Ich habe schon ein funktionierendes Riesenrad und einen "Hau den Lukas" drin. Viele Dinge muss ich aber noch bauen. Und so wie der dann wird, war noch nie ein Flipper gestaltet! Es wäre technisch möglich gewesen, aber aus Wartungsgründen hätte/hat niemand sowas gebaut. Deswegen baue ich das jetzt!
  47. 1 like
    Wenn du eh einen gefuellten Kreis willst, ist es sogar um einiges leichter.. du durchlaeufst mit deinen 2 for-Schleifen alle Felder und ueberpruefst, ob der Abstand zum Mittelpunkt kleiner als der Radius ist..
  48. 1 like
    Hier noch eine leicht verbesserte Version mit Rotation um 2 Achsen: Wheelcontrol: using UnityEngine; using System.Collections; public class WheelControl : MonoBehaviour { public bool rotating = false; float speed = 45.0f; float maxSteering = 45.0f; public void Rotate(float angle, Vector3 axis) { StartCoroutine(RotateBy(angle, axis, speed)); } IEnumerator RotateBy(float angle, Vector3 axis, float speed) { rotating = true; Quaternion start = transform.localRotation; if ((start.eulerAngles.z + angle) < (90.0f - maxSteering) || (start.eulerAngles.z + angle) > (90.0f + maxSteering)) { rotating = false; yield break; } // Debug.Log("x. " + start.eulerAngles.x + " angle: " + angle + " sum "); if ((start.eulerAngles.x != 0) && (start.eulerAngles.x - angle) < (360f - maxSteering) && ((start.eulerAngles.x - angle) > (maxSteering))) { rotating = false; yield break; } float curAngle = 0.0f; while (Mathf.Abs(curAngle - angle) > 0.0001f) { curAngle = Mathf.MoveTowards(curAngle, angle, Time.deltaTime * speed); transform.localRotation = Quaternion.AngleAxis(curAngle, axis) * start; yield return null; } transform.localRotation = Quaternion.AngleAxis(angle, axis) * start; rotating = false; } } Hovercarcontrol: using UnityEngine; using System.Collections; public class HoverCarControl : MonoBehaviour { Rigidbody body; float deadZone = 0.1f; public float groundedDrag = 3f; public float maxVelocity = 50; public float hoverForce = 1000; public float gravityForce = 1000f; public float hoverHeight = 1.5f; public GameObject[] hoverPoints; public float forwardAcceleration = 8000f; public float reverseAcceleration = 4000f; float thrust = 0f; float acceleration = 0f; public float turnStrength = 1000f; float turnValue = 0f; public ParticleSystem[] dustTrails = new ParticleSystem[2]; public WheelControl[] Wheels; int layerMask; void Start() { body = GetComponent<Rigidbody>(); body.centerOfMass = Vector3.down; layerMask = 1 << LayerMask.NameToLayer("Vehicle"); layerMask = ~layerMask; } // Uncomment this to see a visual indication of the raycast hit points in the editor window // void OnDrawGizmos() // { // // RaycastHit hit; // for (int i = 0; i < hoverPoints.Length; i++) // { // var hoverPoint = hoverPoints [i]; // if (Physics.Raycast(hoverPoint.transform.position, // -Vector3.up, out hit, // hoverHeight, // layerMask)) // { // Gizmos.color = Color.blue; // Gizmos.DrawLine(hoverPoint.transform.position, hit.point); // Gizmos.DrawSphere(hit.point, 0.5f); // } else // { // Gizmos.color = Color.red; // Gizmos.DrawLine(hoverPoint.transform.position, // hoverPoint.transform.position - Vector3.up * hoverHeight); // } // } // } void Update() { // Get thrust input thrust = 0.0f; acceleration = Input.GetAxis("Vertical"); if (acceleration > deadZone) thrust = acceleration * forwardAcceleration; else if (acceleration < -deadZone) thrust = acceleration * reverseAcceleration; // Get turning input turnValue = 0.0f; float turnAxis = Input.GetAxis("Horizontal"); if (Mathf.Abs(turnAxis) > deadZone) turnValue = turnAxis; } void FixedUpdate() { // Do hover/bounce force RaycastHit hit; bool grounded = false; for (int i = 0; i < hoverPoints.Length; i++) { var hoverPoint = hoverPoints [i]; if (Physics.Raycast(hoverPoint.transform.position, -Vector3.up, out hit,hoverHeight, layerMask)) { body.AddForceAtPosition(Vector3.up * hoverForce* (1.0f - (hit.distance / hoverHeight)), hoverPoint.transform.position); grounded = true; } else { // Self levelling - returns the vehicle to horizontal when not grounded and simulates gravity if (transform.position.y > hoverPoint.transform.position.y) { body.AddForceAtPosition(hoverPoint.transform.up * gravityForce, hoverPoint.transform.position); } else { body.AddForceAtPosition(hoverPoint.transform.up * -gravityForce, hoverPoint.transform.position); } } } var emissionRate = 0; if(grounded) { body.drag = groundedDrag; emissionRate = 10; } else { body.drag = 0.1f; thrust /= 100f; turnValue /= 100f; } for(int i = 0; i<dustTrails.Length; i++) { var emission = dustTrails[i].emission; emission.rate = new ParticleSystem.MinMaxCurve(emissionRate); } // Handle Forward and Reverse forces if (Mathf.Abs(thrust) > 0) body.AddForce(transform.forward * thrust); // Handle Turn forces if (turnValue > 0) { body.AddRelativeTorque(Vector3.up * turnValue * turnStrength); } else if (turnValue < 0) { body.AddRelativeTorque(Vector3.up * turnValue * turnStrength); } // Limit max velocity if(body.velocity.sqrMagnitude > (body.velocity.normalized * maxVelocity).sqrMagnitude) { body.velocity = body.velocity.normalized * maxVelocity; } foreach (WheelControl wheel in Wheels) { if (!wheel.rotating) { //Debug.Log("rotateby "+ wheel .gameObject.name + " by: " + turnValue); float maxSteeringAngle = 45.0f; //Debug.Log(maxSteeringAngle * acceleration); float angleh = maxSteeringAngle * turnValue; float anglev = maxSteeringAngle * acceleration; wheel.Rotate(angleh, Vector3.forward); wheel.Rotate(anglev, Vector3.left); } } } } Weitere Verbeserungen wären wie gesagt, die Räder wieder auf ihre 0-Positionen zu bringen und die Rotation in V und H in eine Coroutine zu packen (ist sogar dringend angesagt, da aktuell eigentlich nur um eine Achse zu gleichen Zeit gedreht werden kann, du könntest auch 2 Coroutinen erstellen und müsstet dann den "rotating" bool für 2 Routinen auslegen bspw. "rotatingh" und "rotatetingv"). Die Räder scheinen auch noch bei ihren maximalen Ausschlagswinkeln ab und zu hängen zu bleiben, da muss man noch an der RotateBy()-Routine drehen, an der Stelle wo ich die Coroutine verlasse (yield break), wenn der maximale Ausschlagswinkel erreicht wird (mit Rotation auf 0-Stellung entfällt dieses Problem).
  49. 1 like
    Danke Sascha! Es funktioniert endlich. Das war mir nicht so richtig klar bzw. darauf bin ich auch gar nicht gekommen. Natürlich auch viele Dank an die anderen
  50. 1 like
    Sprite ist halt kein UI Element und deswegen ist es auch hinter dem UI Element, welches ja in der Regel ein Overlay ist. Nimm Image Elemente und gut ist's! Die Animationen lassen sich genauso auf dem Image abspielen wie auf nem Sprite.