Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

Hi ich arbeite mit unity c#. Kannst du mir einen guten Camera shaker algorithmus geben…

  1. User

    Hi ich arbeite mit unity c#. Kannst du mir einen guten Camera shaker algorithmus geben der performant ist und AAA qualität hat?

  2. Assistant

    Ja sicher! Ein guter Kamerashaker-Algorithmus kann eine Menge zur Immersion und Wirkung in deinem Spiel beitragen. Hier ist ein solider Ansatz für einen effizienten, AAA-qualitätigen Kamerashaker in Unity C#. Dieser Beispielcode verwendet Perlin-Noise, um eine sanfte und nicht-repetitive Bewegung zu erzeugen. Es ist allgemein anerkannt, dass Perlin-Noise für solche Aufgaben sehr gut geeignet ist, da er natürlichen und realistischen Bewegungen entspricht.

    Lass uns ein Kamerashake-Skript erstellen:

    1. Erstelle eine neue C#-Skriptdatei in deinem Unity-Projekt und nenne sie CameraShake.

    2. Öffne die Datei im Code-Editor und füge das folgende hinzu:

    using UnityEngine;
    
    public class CameraShake : MonoBehaviour
    {
        public static CameraShake Instance;
    
        // Dauer des Shakes in Sekunden
        public float shakeDuration = 0.5f;
    
        // Stärke des Shakes
        public float shakeMagnitude = 0.2f;
    
        private float initialShakeDuration;
        private float elapsedTime = 0f;
        private Vector3 originalPosition;
    
        private void Awake()
        {
            // Singleton-Muster, um eine einzige Instanz zu gewährleisten
            if (Instance == null)
            {
                Instance = this;
                DontDestroyOnLoad(gameObject);
            }
            else
            {
                Destroy(gameObject);
            }
        }
    
        private void Start()
        {
            originalPosition = transform.localPosition;
            initialShakeDuration = shakeDuration;
        }
    
        private void Update()
        {
            if (elapsedTime > 0)
            {
                elapsedTime -= Time.deltaTime;
    
                // Erzeuge eine relative Versatzposition mit Perlin-Noise
                float x = (Mathf.PerlinNoise(Time.time * shakeMagnitude, 0) - 0.5f) * 2;
                float y = (Mathf.PerlinNoise(0, Time.time * shakeMagnitude) - 0.5f) * 2;
    
                transform.localPosition = originalPosition + new Vector3(x, y, 0) * shakeMagnitude;
    
                if (elapsedTime <= 0)
                {
                    transform.localPosition = originalPosition;
                }
            }
        }
    
        // Funktion um das Shaken der Kamera zu starten
        public void ShakeCamera(float duration, float magnitude)
        {
            shakeDuration = duration;
            shakeMagnitude = magnitude;
            elapsedTime = duration;
        }
    }
    
    

    Zu verwenden:

    1. Füge das CameraShake Script deinem KameragameObject hinzu.

    2. Um die Kamerabewegung zu aktivieren, rufst du die ShakeCamera Methode von irgendwo in deinem Spielcode auf, z.B.:

    CameraShake.Instance.ShakeCamera(0.2f, 0.1f);
    

    Dies ruft den Shaker mit einer Dauer von 0.2s und einer Stärke von 0.1 auf.

    Hinweis:

    • Dieses Beispiel basiert auf Perlin-Noise für eine glatte und natürliche Kamerabewegung.
    • Passe shakeDuration und shakeMagnitude in der ShakeCamera Methode an, um die Intensität und die Länge des Shakes zu variieren.
    • Stelle sicher, dass deine Kamera standardmäßig auf der Originalposition bleibt, indem sie die originalPosition Variable richtig setzt (z.B. bei Start oder Initialization).

    Der Code sollte sehr performant sein und gut in AAA-Projekten funktionieren. Natürlich könntest du es noch weiter optimieren oder anpassen, um spezielle Anforderungen von deinem Projekt zu erfüllen!

  3. User

    Sollte der Shaker nicht auch rotiern?

  4. Assistant

    Ja, du hast recht, eine wirklich immersive Kamerawackelbewegung sollte nicht nur die Position der Kamera ändern, sondern auch die Rotation einbeziehen. Hier ist eine erweiterte Version des CameraShake-Scripts, die sowohl Translations- als auch Rotationswackeln beinhaltet:

    using UnityEngine;
    
    public class CameraShake : MonoBehaviour
    {
        public static CameraShake Instance;
    
        public float shakeDuration = 0.5f;
        public float shakeMagnitude = 0.2f;
        public float rotationMagnitude = 1.0f; // Magnitude for rotational shake
    
        private float initialShakeDuration;
        private float elapsedTime = 0f;
        private Vector3 originalPosition;
        private Quaternion originalRotation;
    
        private void Awake()
        {
            if (Instance == null)
            {
                Instance = this;
                DontDestroyOnLoad(gameObject);
            }
            else
            {
                Destroy(gameObject);
            }
        }
    
        private void Start()
        {
            originalPosition = transform.localPosition;
            originalRotation = transform.localRotation;
            initialShakeDuration = shakeDuration;
        }
    
        private void Update()
        {
            if (elapsedTime > 0)
            {
                elapsedTime -= Time.deltaTime;
    
                // Generate relative positional offset using Perlin Noise
                float posX = (Mathf.PerlinNoise(Time.time * shakeMagnitude, 0) - 0.5f) * 2;
                float posY = (Mathf.PerlinNoise(0, Time.time * shakeMagnitude) - 0.5f) * 2;
    
                // Generate relative rotational offset using Perlin Noise
                float rotZ = (Mathf.PerlinNoise(Time.time * rotationMagnitude, 1) - 0.5f) * 2;
    
                transform.localPosition = originalPosition + new Vector3(posX, posY, 0) * shakeMagnitude;
                transform.localRotation = originalRotation * Quaternion.Euler(0, 0, rotZ * rotationMagnitude);
    
                if (elapsedTime <= 0)
                {
                    transform.localPosition = originalPosition;
                    transform.localRotation = originalRotation;
                }
            }
        }
    
        public void ShakeCamera(float duration, float posMagnitude, float rotMagnitude)
        {
            shakeDuration = duration;
            shakeMagnitude = posMagnitude;
            rotationMagnitude = rotMagnitude;
            elapsedTime = duration;
        }
    }
    

    Verwendung:

    1. Füge das CameraShake Script deinem Kamera-GameObject hinzu.

    2. Um die Kamera zu wackeln, kannst du die ShakeCamera Methode aufrufen z.B.:

    CameraShake.Instance.ShakeCamera(0.5f, 0.2f, 1.0f);
    

    Dies startet ein Wackeln mit einer Dauer von 0,5 Sekunden, einer Positionsmagnitudenänderung von 0,2 und einer Rotationsmagnitudenänderung von 1,0.

    • Erläuterte Erweiterungen:
      • rotationMagnitude ist ein neuer Parameter, der die Rotationsintensität des Shakes steuerbar macht.
      • Die Rotationen werden entlang der Z-Achse geändert (rotZ), es kann jedoch leicht angepasst werden, um auch entlang andere Achsen zu rotieren falls nötig.

    Dasselbe Konzept wie vorher, aber nun berücksichtigt das Skript auch kleine Rotationsbewegungen, um ein noch realistischeres Kamerashaking zu erzeugen. Stelle bitte sicher, dass die Kamera immer in ihre ursprüngliche Position und Rotation zurückkehrt, damit mögliche nachfolgende Shakes korrekt ausgeführt werden können.

  5. User

    Der shaker spring am ende zurück zum start punkt wäre es nicht besser wenn das smoother wäre?

  6. Assistant

    Ja, eine glattere Rückkehr zur Ausgangsposition und Rotation am Ende des Shakes kann der Gesamtwirkung des Kamerashakes verbessern und professioneller aussehen lassen. Dafür können wir eine Dämpfungsfunktion einführen, um die Bewegung allmählich zu reduzieren, anstatt abrupt zu stoppen.

    Hier ist eine aktualisierte Version des CameraShake-Skripts, das eine glattere Dämpfung verwendet, um die Kamerabewegung und -rotation am Ende des Shakes sanft zu beenden:

    using UnityEngine;
    
    public class CameraShake : MonoBehaviour
    {
        public static CameraShake Instance;
    
        public float shakeDuration = 0.5f;
        public float shakeMagnitude = 0.2f;
        public float rotationMagnitude = 1.0f;
    
        private float initialShakeDuration;
        private float elapsedTime = 0f;
        private Vector3 originalPosition;
        private Quaternion originalRotation;
    
        private void Awake()
        {
            if (Instance == null)
            {
                Instance = this;
                DontDestroyOnLoad(gameObject);
            }
            else
            {
                Destroy(gameObject);
            }
        }
    
        private void Start()
        {
            originalPosition = transform.localPosition;
            originalRotation = transform.localRotation;
            initialShakeDuration = shakeDuration;
        }
    
        private void Update()
        {
            if (elapsedTime > 0)
            {
                elapsedTime -= Time.deltaTime;
    
                // Normalized time (0 to 1) representing how much of the shake duration has passed
                float normalizedTime = 1f - (elapsedTime / shakeDuration);
    
                // Damping factor, decreasing from 1 to 0 over time
                float damping = 1f - normalizedTime;
    
                // Generate relative positional offset using Perlin Noise
                float posX = (Mathf.PerlinNoise(Time.time * shakeMagnitude, 0) - 0.5f) * 2;
                float posY = (Mathf.PerlinNoise(0, Time.time * shakeMagnitude) - 0.5f) * 2;
    
                // Generate relative rotational offset using Perlin Noise
                float rotZ = (Mathf.PerlinNoise(Time.time * rotationMagnitude, 1) - 0.5f) * 2;
    
                transform.localPosition = originalPosition + new Vector3(posX, posY, 0) * shakeMagnitude * damping;
                transform.localRotation = originalRotation * Quaternion.Euler(0, 0, rotZ * rotationMagnitude * damping);
    
                if (elapsedTime <= 0)
                {
                    transform.localPosition = originalPosition;
                    transform.localRotation = originalRotation;
                }
            }
        }
    
        public void ShakeCamera(float duration, float posMagnitude, float rotMagnitude)
        {
            shakeDuration = duration;
            shakeMagnitude = posMagnitude;
            rotationMagnitude = rotMagnitude;
            elapsedTime = duration;
        }
    }
    

    Änderungen und Erklärungen:

    1. Normalized Time: Berechnen der normierten Zeit normalizedTime, die repräsentiert, wie viel Zeit des Shakes vergangen ist (von 0 bis 1).

    2. Damping: Ein Dämpfungsfaktor damping, der von 1 auf 0 abnimmt, wird berechnet. Dies wird verwendet, um die Shake-Intensität allmählich zu reduzieren.

    3. Verwendung von Damping: Der Dämpfungsfaktor wird auf die Positions- und Rotationswerte angewendet, um die Bewegung und Rotation sanft zu reduzieren.

    Dieses Skript sorgt dafür, dass die Kamera am Ende des Shakes glatt zu ihrer ursprünglichen Position und Rotation zurückkehrt, anstatt abrupt zu springen. Dies führt zu einem natürlicheren und hochwertigeren Effekt.

    Du kannst die Shake-Intensität und die Rückkehr zur Normalität weiter anpassen, indem du die Magnituden und Dämpfungsparameter im ShakeCamera-Methodenaufruf justierst.

  7. User

    Mein cam shaker sieht folgendermaßen aus. Ich möchte aber den speed raus bekommen und es mit duration ersetzen: private void FixedUpdate() { if (shakeRot == Vector3.zero) return;

        shakeRot = Vector3.Lerp(shakeRot, Vector3.zero, Time.fixedDeltaTime * speed);
        rotation = Vector3.Lerp(rotation, shakeRot, Time.fixedDeltaTime * speed);
        transform.localRotation = Quaternion.Euler(rotation);
    }
    
    
    public void Shake(float shakeSpeed, float shakeX, float shakeY = 0, float shakeZ = 0)
    {
        speed = shakeSpeed;
        shakeRot += new Vector3(shakeX, Random.Range(-shakeY, shakeY), Random.Range(-shakeZ, shakeZ));
    }
    
  8. Assistant

    Um deinen bisher vorhandenen Code anzupassen, so dass er statt speed nun duration verwendet, müssen wir den zeitbasierten Ansatz implementieren. Wir werden eine Dämpfungsfunktion einführen, um die Sichtbarkeit des Shakes über die Zeit zu bestimmen.

    Hier ist eine überarbeitete Version deines CameraShake-Skripts:

    using UnityEngine;
    
    public class CameraShake : MonoBehaviour
    {
        // Manche Variablen müssen öffentlich sein, um von der Unity-Editor-Schnittstelle zugegriffen werden zu können.
        public float duration = 0.5f;
        public Vector3 shakeRot = Vector3.zero;
    
        private float elapsedTime = 0f;
        private Vector3 originalRotation = Vector3.zero;
        private Vector3 currentShakeRotation = Vector3.zero;
    
        private void FixedUpdate()
        {
            if (elapsedTime > 0)
            {
                // Erhöhe die verstrichene Zeit
                elapsedTime -= Time.fixedDeltaTime;
    
                // Berechne den prozentualen Fortschritt der Dämpfung (zwischen 0 und 1)
                float damping = Mathf.Clamp01(elapsedTime / duration);
    
                // Erzeuge zufällige Drehungen innerhalb des Dämpfungs-Werts
                currentShakeRotation = new Vector3(
                    Random.Range(-shakeRot.x, shakeRot.x) * damping,
                    Random.Range(-shakeRot.y, shakeRot.y) * damping,
                    Random.Range(-shakeRot.z, shakeRot.z) * damping
                );
    
                // Setzte die tatsächliche Rotation auf die Transform-Komponente
                transform.localRotation = Quaternion.Euler(currentShakeRotation);
            }
            else
            {
                // Wenn die verstrichene Zeit zu Ende ist, setze die Rotation wieder auf Null.
                transform.localRotation = Quaternion.Euler(originalRotation);
            }
        }
    
        public void Shake(float shakeDuration, float shakeX, float shakeY = 0f, float shakeZ = 0f)
        {
            duration = shakeDuration;
            elapsedTime = shakeDuration;
            shakeRot = new Vector3(shakeX, shakeY, shakeZ);
            originalRotation = transform.localRotation.eulerAngles;
        }
    }
    
    

    Erklärungen:

    1. duration, elapsedTime, shakeRot, originalRotation, currentShakeRotation:

      • Die Idee ist, dass das duration die gesamte Zeitspanne definiert, in der das Schütteln anhält, und elapsedTime, wie viel Zeit noch übrig ist.
      • shakeRot definiert den Maximalbetrag der Rotation in jede Richtung.
      • originalRotation speichert die Originalrotation der Kamera, damit wir zu ihr zurückkehren können.
      • currentShakeRotation wird verwendet, um die aktuelle Rotation basierend auf dem Betrag des Schüttelns und der Dämpfungsfunktion zu speichern.
    2. FixedUpdate:

      • Diese Methode wird regelmäßig aufgerufen und steuert das Kamera-Schütteln.
      • elapsedTime wird bei jedem Aufruf von FixedUpdate um Time.fixedDeltaTime verringert.
      • Berechnet einen damping Wert, der manuell progressiv abnimmt (zwischen 0 und 1), um das Wackeln allmählich zu dämpfen.
      • Generiert zufällige Rotationen innerhalb der shakeRot Grenzen unter Verwendung des damping Werts.
      • Setzt transform.localRotation basierend auf den berechneten Rotationen.
      • Stellt die Kamera wieder in die Originalrotation zurück, wenn elapsedTime <= 0 ist.
    3. Shake:

      • Diese Methode initialisiert die Shake-Parameter: duration, elapsedTime, und shakeRot.
      • originalRotation speichert die aktuelle Rotation der Kamera zu Beginn des Shakes.

    Das Ergebnis ist eine sanfte Dämpfung des Kamerashakes, und die Kamera kehrt allmählich zurück zur ursprünglichen Rotation, anstatt abrupt zu stoppen.