Jump to content
Unity Insider Forum

Kamera Steuerung


Kojote

Recommended Posts

Huhu! :)

Ich habe heut Nachmittag mal meine Kamerasteuerung umgeschrieben. Funktioniert eigentlich ganz gut, hab nur einen kleinen Bug und wollt ma Fragen ob ihr ihn seht.

Problem ist folgendes, ich lege in der Stadt-Methode den Winkel des Elternelements fest. Das Elternelement regelt die Winkel der Kamera und wie die Kamera halt auf die Fläche zeigt:

Quaternion QT = Quaternion.Euler(25, 45, 0);
kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, 1);

Normalerweise sollte die Kamera von schräg oben auf die Spielfläche schauen, sie schaut aber von der Seite auf die Spielfläche, was wiederrum daran liegt:

// Tatsächliche Kamera-Transformationen Maus
Quaternion QT = Quaternion.Euler(localeRotation.y, localeRotation.x, 0);
this.kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, Time.deltaTime * mausVerzoegerung);

Mir fällt gerade beim besten willen nichts ein, wie ich es umschreiben kann, dass die Kamera in einem bestimmten Winkel auf die Spielfläche schaut. Hat wer eine Idee?

using UnityEngine;
using System.Collections;

public class Kamera : MonoBehaviour {

    private Transform kameraTransform;
    private Transform kameraUrsprungTransform;

    private Vector3 localeRotation;
             
    private Ray ray;
    private RaycastHit hit;

    public float kameraDistanz = 20.0f;
    public float kameraDistanzMin = 5.0f;
    public float kameraDistanzMax = 80.0f;
    public float kameraBewegungsGeschwindigkeit = 10.0f;
    public float mausEmpfindlichkeit = 2.0f;
    public float mausVerzoegerung = 85.0f;
    public float scrollEmpfindlichkeit = 2.0f;
    public float scrollVerzoegerung = 85.0f;
    public float abstandHorizontMin = 25.0f;
    public float abstandHorizontMax = 80.0f;

    public bool kameraDeaktivieren = true;
    private bool kameraUrsprungBewegen = false;


    private void Start() {
        kameraTransform = this.transform;
        kameraUrsprungTransform = this.transform.parent;
        kameraDeaktivieren = true;
        Quaternion QT = Quaternion.Euler(25, 45, 0);
        kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, 1);
    }

    private void FixedUpdate() {
        if (Input.GetMouseButtonDown(1)) {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(ray, out hit)) { 
                if (hit.collider.gameObject.tag == "Ray") { 
                    kameraUrsprungBewegen = true;
                }
            }
        }
    }

    private void Update() {
        if (kameraUrsprungBewegen == true) {
            kameraUrsprungTransform.position = Vector3.MoveTowards(kameraUrsprungTransform.position, hit.point, kameraBewegungsGeschwindigkeit * Time.deltaTime);
            if (kameraUrsprungTransform.position == hit.point) {
                kameraUrsprungBewegen = false;
            } 
        }
    }

    private void LateUpdate() {
        // Steuerung der Mausdrehung und des Zooms
        if (Input.GetButtonDown("Fire3")) {
            kameraDeaktivieren = !kameraDeaktivieren;
        }
            
        if (!kameraDeaktivieren) {
            // Rotation der Kamera basierend auf den Maus-Koordinaten
            if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0) {
                localeRotation.x += Input.GetAxis("Mouse X") * mausEmpfindlichkeit;
                localeRotation.y += Input.GetAxis("Mouse Y") * mausEmpfindlichkeit;

                // Verhindert das Ueberschlagen der Y-Achse bei der Rotation
                if (localeRotation.y < abstandHorizontMin)
                    localeRotation.y = abstandHorizontMin;
                else if (localeRotation.y > abstandHorizontMax)
                    localeRotation.y = abstandHorizontMax;
            }
            // Zoom abhaengig vom Mausrad 
            if (Input.GetAxis("Mouse ScrollWheel") != 0f) {
                float scrollbetrag = Input.GetAxis("Mouse ScrollWheel") * scrollEmpfindlichkeit;
                scrollbetrag *= (this.kameraDistanz * 0.3f);
                this.kameraDistanz += scrollbetrag * -1f;
                this.kameraDistanz = Mathf.Clamp(this.kameraDistanz, kameraDistanzMin, kameraDistanzMax);
            } 
        }

        // Tatsächliche Kamera-Transformationen Maus
        Quaternion QT = Quaternion.Euler(localeRotation.y, localeRotation.x, 0);
        this.kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, Time.deltaTime * mausVerzoegerung);

        // Tatsächliche Kamera-Transformation Zoom
        if (this.kameraTransform.localPosition.z != this.kameraDistanz * -1f) {
            this.kameraTransform.localPosition = new Vector3(0f, 0f, Mathf.Lerp(this.kameraTransform.localPosition.z, this.kameraDistanz * -1f, Time.deltaTime * scrollVerzoegerung));
        }
    }
}

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

  • 3 weeks later...

Ich sitz immer noch dran, ich lass nicht locker! :ph34r:

using UnityEngine;
using System.Collections;

public class Kamera : MonoBehaviour {

    private Transform kameraTransform;
    private Transform kameraUrsprungTransform;

    private Vector3 localeRotation;
             
    private Ray ray;
    private RaycastHit hit;

    public float kameraDistanz = 20.0f;
    public float kameraDistanzMin = 5.0f;
    public float kameraDistanzMax = 80.0f;
    public float kameraBewegungsGeschwindigkeit = 10.0f;
    public float mausEmpfindlichkeit = 2.0f;
    public float mausVerzoegerung = 85.0f;
    public float scrollEmpfindlichkeit = 2.0f;
    public float scrollVerzoegerung = 85.0f;
    public float abstandHorizontMin = 25.0f;
    public float abstandHorizontMax = 80.0f;

    public bool kameraDeaktivieren = true;
    private bool kameraUrsprungBewegen = false;


    private void Start() {
        kameraTransform = this.transform;
        kameraUrsprungTransform = this.transform.parent;
        kameraDeaktivieren = true;
    }

    private void FixedUpdate() {
        if (Time.timeScale == 0)
            return;

        if (!Input.GetMouseButtonDown(0) & Input.GetMouseButtonDown(1)) {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(ray, out hit)) { 
                if (hit.collider.gameObject.tag == "Ray") { 
                    kameraUrsprungBewegen = true;
                }
            }
        }
    }

    private void Update() {
        if (Time.timeScale == 0)
            return;

        if (kameraUrsprungBewegen == true) {
            kameraUrsprungTransform.position = Vector3.MoveTowards(kameraUrsprungTransform.position, hit.point, kameraBewegungsGeschwindigkeit * Time.deltaTime);
            if (kameraUrsprungTransform.position == hit.point) {
                kameraUrsprungBewegen = false;
            } 
        }
    }

    private void LateUpdate() {
        if (Time.timeScale == 0)
            return;

        // ------------------------------------------------------------------------------------
        // AKTIVIERUNG UND DEAKTIVIERUNG DER KAMERADREHUNG
        // ------------------------------------------------------------------------------------
        if (Input.GetButtonDown("Fire3")) {
            kameraDeaktivieren = !kameraDeaktivieren;
        }

        // ------------------------------------------------------------------------------------
        // STEUERUNG DES ZOOMS, ABHAENGIG VOM MAUSRAD 
        // ------------------------------------------------------------------------------------
        if (Input.GetAxis("Mouse ScrollWheel") != 0f) {
            float scrollbetrag = Input.GetAxis("Mouse ScrollWheel") * scrollEmpfindlichkeit;
            scrollbetrag *= (this.kameraDistanz * 0.3f);
            this.kameraDistanz += scrollbetrag * -1f;
            this.kameraDistanz = Mathf.Clamp(this.kameraDistanz, kameraDistanzMin, kameraDistanzMax);
        }
        // Tatsächliche Kamera-Transformation Zoom
        if (this.kameraTransform.localPosition.z != this.kameraDistanz * -1f) {
            this.kameraTransform.localPosition = new Vector3(0f, 0f, Mathf.Lerp(this.kameraTransform.localPosition.z, this.kameraDistanz * -1f, Time.deltaTime * scrollVerzoegerung));
        }

        // ------------------------------------------------------------------------------------
        // STEUERUNG DER KAMERADREHUNG/ ROTATION, BASIEREND AUF DEN MAUS-KOORDINATEN
        // ------------------------------------------------------------------------------------ 
        if (!kameraDeaktivieren) {
            if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0) {
                localeRotation.x += Input.GetAxis("Mouse X") * mausEmpfindlichkeit;
                localeRotation.y += Input.GetAxis("Mouse Y") * mausEmpfindlichkeit;

                // Verhindert das Ueberschlagen der Y-Achse bei der Rotation
                if (localeRotation.y < abstandHorizontMin)
                    localeRotation.y = abstandHorizontMin;
                else if (localeRotation.y > abstandHorizontMax)
                    localeRotation.y = abstandHorizontMax;
            }
        }
        // Tatsächliche Kamera-Transformationen Rotation 
        Quaternion QT = Quaternion.Euler(localeRotation.y, localeRotation.x, 0);
        this.kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, Time.deltaTime * mausVerzoegerung);
    }
}

Hab jetzt die Start-Methode bissl umgebaut, aber Problem bleibt.

Aus irgend einem Grund setzt er nach dem Start die X-Rotation auf 0 und überschreibt mir somit meine Starteinstellung von 25 Grad.

Ich weiß, dass kann nur nen Variablenfehler sein, ich sehs net.

Sieht da jemand was?

Link zu diesem Kommentar
Auf anderen Seiten teilen

Habs doch gewusst, dass es nur nen kleiner Fehler sein kann

        // ------------------------------------------------------------------------------------
        // STEUERUNG DER KAMERADREHUNG/ ROTATION, BASIEREND AUF DEN MAUS-KOORDINATEN
        // ------------------------------------------------------------------------------------ 
        if (!kameraDeaktivieren) {
            if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0) {
                localeRotation.x += Input.GetAxis("Mouse X") * mausEmpfindlichkeit;
                localeRotation.y += Input.GetAxis("Mouse Y") * mausEmpfindlichkeit;

                // Verhindert das Ueberschlagen der Y-Achse bei der Rotation
                if (localeRotation.y < abstandHorizontMin)
                    localeRotation.y = abstandHorizontMin;
                else if (localeRotation.y > abstandHorizontMax)
                    localeRotation.y = abstandHorizontMax;

                Quaternion QT = Quaternion.Euler(localeRotation.y, localeRotation.x, 0f);
                this.kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, Time.deltaTime * mausVerzoegerung);
            }
        }
        // Tatsächliche Kamera-Transformationen Rotation 
        //Quaternion QT = Quaternion.Euler(localeRotation.y, localeRotation.x, 0f);
        //this.kameraUrsprungTransform.rotation = Quaternion.Lerp(this.kameraUrsprungTransform.rotation, QT, Time.deltaTime * mausVerzoegerung);

Hab einfach mal die Kamera Transformation in die if-Abfrage geschoben und schon klappts! 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Deutsche Variablen haben den großen Vorteil, dass sie nicht in Konflikt mit irgendwelchen schon vorhandenen Variablen oder Funktionen kommen. Von daher ist das für jemanden, der für sich entwickelt gar nicht schlecht.
Klar, standard ist es nicht, aber muss ja auch nicht. ;)

Link zu diesem Kommentar
Auf anderen Seiten teilen

  • 3 weeks later...

Bastel gerade an meinem Kamerascript herum, da mir die X und Y Bewegung so nicht mehr gefällt. Wollte die Kamera direkt an die Mausbewegung koppeln, wenn die rechte Maustaste gedrückt wird. Das ganze befindet sich in der LateUpdate Funktion. Die if-Abfrage reagiert, aber es bewegt sich nix. Laut meiner Logik müsste es funktionieren, sehrt ihr hier was:

// ------------------------------------------------------------------------------------
// STEUERUNG DER KAMERAPOSITION X UND Y
// ------------------------------------------------------------------------------------
float horizontalSpeed = 1.0f;
float verticalSpeed = 1.0f;

if (!Input.GetMouseButtonDown(0) & Input.GetMouseButtonDown(1)) {
   Vector3 mouseOriginal = Input.mousePosition;
   Vector3 mousePosition = Camera.main.ScreenToViewportPoint(Input.mousePosition - mouseOriginal);
   Vector3 bewegung = new Vector3(mousePosition.x * horizontalSpeed, mousePosition.y * verticalSpeed, 0);
   transform.Translate(bewegung, Space.Self);
}

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Stimmt, jetzt muss ich mir was neues einfallen lassen. :blink:

Irgendwie werd ich aus der Maussteuerung net schlau, dass funktioniert auch net:

        if (!Input.GetMouseButtonDown(0) && Input.GetMouseButtonDown(1)) {
            Debug.Log("RE " + Input.GetAxis("Mouse X"));
            if (Input.GetAxis("Mouse X") > 0) {
                kameraUrsprungTransform.transform.position += new Vector3(Input.GetAxisRaw("Mouse X") * Time.deltaTime * horizontalSpeed, 0.0f, Input.GetAxisRaw("Mouse Y") * Time.deltaTime * verticalSpeed);
            }
            if (Input.GetAxis("Mouse X") < 0) {
                kameraUrsprungTransform.transform.position += new Vector3(Input.GetAxisRaw("Mouse X") * Time.deltaTime * horizontalSpeed, 0.0f, Input.GetAxisRaw("Mouse Y") * Time.deltaTime * verticalSpeed);
            }
        }

Ganz böser Fehler: 

GetMouseButtonDown

// zu

GetMouseButton

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

  • 2 weeks later...

Leider noch noch einen Fehler gefunden!

So lange die Kamera in Richtung Positiv Z schaut, funktioniert das Scriptstück sehr gut. Problem ist, wenn ich die Kamera drehe. Dann wird die Bewegung der Maus z.B. nach vorn, in eine Bewegung der Kamera schräg Richtung Positiv Z umgesetzt. So richtig kann ich mir dieses Verhalten nicht erklären. Eigentlich sollte doch die Kamera immer in Richtung der Blickachse arbeiten. Wenn ich also die Kamera nach vorn schiebe soll die Kamera nach vorn gehn, zurück das umgekehrte. 

Könnt ihr hier einen Fehler sehn?

        // ------------------------------------------------------------------------------------
        // STEUERUNG DER KAMERAPOSITION X UND Y
        // ------------------------------------------------------------------------------------
        if (!Input.GetMouseButton(0) && Input.GetMouseButton(1) && !Input.GetButton("Fire3")) {
            if (Input.GetAxis("Mouse X") > 0) {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveX = new Vector3(Input.GetAxisRaw("Mouse X") * Time.deltaTime * kameraBewegungsEmpfindlichkeit, 0.0f, 0.0f);
                pruefung += moveX;
                if (pruefung.x < kameraBewegungRandPosition) {
                    kameraUrsprungTransform.transform.position += moveX;
                }
            }
            if (Input.GetAxis("Mouse X") < 0) {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveX = new Vector3(Input.GetAxisRaw("Mouse X") * Time.deltaTime * kameraBewegungsEmpfindlichkeit, 0.0f, 0.0f);
                pruefung += moveX;
                if (pruefung.x > (kameraBewegungRandPosition * -1)) {
                    kameraUrsprungTransform.transform.position += moveX;
                }
            }
            if (Input.GetAxis("Mouse Y") > 0) {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveY = new Vector3(0.0f, 0.0f, Input.GetAxisRaw("Mouse Y") * Time.deltaTime * kameraBewegungsEmpfindlichkeit);
                pruefung += moveY;
                if (pruefung.z < kameraBewegungRandPosition) {
                    kameraUrsprungTransform.transform.position += moveY;
                }
            }
            if (Input.GetAxis("Mouse Y") < 0) {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveY = new Vector3(0.0f, 0.0f, Input.GetAxisRaw("Mouse Y") * Time.deltaTime * kameraBewegungsEmpfindlichkeit);
                pruefung += moveY;
                if (pruefung.z > (kameraBewegungRandPosition * -1)) {
                    kameraUrsprungTransform.transform.position += moveY;
                }
            }
        }

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Kann ja sein, dass ich grade zu müde bin, um grad aus zu denken aber sind deine beiden Mouse X bzw. Mouse Y abfragen nicht einfach if(Input.GetAxis("Mouse X/Y") != 0) ? Da du die kameraBewegungRandPosition einmal positiv (und den Input negativ) hast und auf kleiner (<) prüfst und beim nächsten mal alles negierst und auf größer (>) prüfst dürft das doch dasselbe Ergebnis liefern oder? Wie gesagt, ist schon spät, kann auch sein, dass ich mich grade irre.

Egal, dein Problem hier ist auf jeden Fall, du bewegst die Kamera in globale x und z Richtungen (dementsprechend ist dem Skript vollkommen wurst wohin du schaust), möchtest die Translation aber (soweit ich das jetzt verstanden habe) anhand seines lokalen Koordinatensystems durchführen und auf seine globalen Koordinaten anwenden.
Da kannst du transform.TransformDirection() nehmen.
Also quasi:

	....
	kameraUrsprungTransform.transform.position += transform.TransformDirection(moveX);
	...

Und ich denke das kann man allgemein recht kürzen.. Das hier dürfte doch dasselbe machen oder nicht? 

if (!Input.GetMouseButton(0) && Input.GetMouseButton(1) && !Input.GetButton("Fire3")) {
   Vector3 move = Vector3.zero;
   float mouseXInput = Input.GetAxis("Mouse X") * Time.deltaTime * kameraBewegungsEmpfindlichkeit;
   float mouseYInput = Input.GetAxis("Mouse Y") * Time.deltaTime * kameraBewegungsEmpfindlichkeit;
   if(mouseXInput + kameraUrsprungTransform.transform.position.x < kameraBewegungRandPosition) // Könnte sein, dass das eher ein > sein sollte, ich sollte langsam ins Bett gehen
      move.x = mouseXInput;
   if(mouseYInput + kameraUrsprungTransform.transform.position.z < kameraBewegungRandPosition) // Hier dann dementsprechend auch
      move.z = mouseYInput;
   kameraUrsprungTransform.transform.position += transform.TransformDirection(move);
}

Ich muss aber zugeben ich bin gerade etwas verwirrt was die kameraBewegungRandPosition eigentlich überhaupt sein soll ^^
Im Zweifelsfall könnte es ein Mathf.Abs(mouseXInput) richten.

Link zu diesem Kommentar
Auf anderen Seiten teilen

kameraBewegungRandPosition ist der maximale X und Y Wert den die Kamera überhaupt haben darf. Damit begrenze ich wie weit sich die Kamera von ihrer Ursprungsposition entfernen darf. Da dies auf einem Koordinatensystem stattfindet von -y bis +y und -x bis +x brauche ich die vier if´s.

EDIT: Fehler gefunden. Ich nutze ein Parent Objekt, die Kamera ist Child zur besseren Steuerung. Das Parent Objekt schaut imemr zu Positiv Z, daher kommt das Problem.

EDIT 2: Doch nicht der Fehler.

Link zu diesem Kommentar
Auf anderen Seiten teilen

Denke @Tiwaz hat recht. Aktuell wird die Bewegung immer aufs globale Koordinatensystem übertragen, d.h. wenn du die Maus nach links bewegst, dann bewegst du die Kamera immer in die globale minus X-Richtung. Schaut die Kamera nun beispielsweise aber nach rechts und du bewegst die Maus nach links, dann bewegt sich die Kamera nach hinten anstatt nach links.

Hier wäre dein Code, damit die Bewegung der Kamera vom lokalen Koordinatensystem ins Globale umgerechnet wird:

  // ------------------------------------------------------------------------------------
        // STEUERUNG DER KAMERAPOSITION X UND Y
        // ------------------------------------------------------------------------------------
        if (!Input.GetMouseButton(0) && Input.GetMouseButton(1) && !Input.GetButton("Fire3"))
        {
            if (Input.GetAxis("Mouse X") > 0)
            {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveX = new Vector3(Input.GetAxisRaw("Mouse X") * Time.deltaTime * kameraBewegungsEmpfindlichkeit, 0.0f, 0.0f);
                moveX = kameraUrsprungTransform.TransformDirection(moveX);
                pruefung += moveX;
                if (pruefung.x < kameraBewegungRandPosition)
                {
                    kameraUrsprungTransform.transform.position += moveX;
                }
            }
            if (Input.GetAxis("Mouse X") < 0)
            {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveX = new Vector3(Input.GetAxisRaw("Mouse X") * Time.deltaTime * kameraBewegungsEmpfindlichkeit, 0.0f, 0.0f);
                moveX = kameraUrsprungTransform.TransformDirection(moveX);
                pruefung += moveX;
                if (pruefung.x > (kameraBewegungRandPosition * -1))
                {
                    kameraUrsprungTransform.transform.position += moveX;
                }
            }
            if (Input.GetAxis("Mouse Y") > 0)
            {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveY = new Vector3(0.0f, 0.0f, Input.GetAxisRaw("Mouse Y") * Time.deltaTime * kameraBewegungsEmpfindlichkeit);
                moveY = kameraUrsprungTransform.TransformDirection(moveY);
                pruefung += moveY;
                if (pruefung.z < kameraBewegungRandPosition)
                {
                    kameraUrsprungTransform.transform.position += moveY;
                }
            }
            if (Input.GetAxis("Mouse Y") < 0)
            {
                Vector3 pruefung = kameraUrsprungTransform.transform.position;
                Vector3 moveY = new Vector3(0.0f, 0.0f, Input.GetAxisRaw("Mouse Y") * Time.deltaTime * kameraBewegungsEmpfindlichkeit);
                moveY = kameraUrsprungTransform.TransformDirection(moveY);
                pruefung += moveY;
                if (pruefung.z > (kameraBewegungRandPosition * -1))
                {
                    kameraUrsprungTransform.transform.position += moveY;
                }
            }
        }

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Weil ich grade erwähnt wurde, ich hab gestern mal kurz eine freie Kamera für einen Map Editor geschrieben, damit kann man sich in alle Richtungen bewegen und rumschauen (ohne Kollisionen etc natürlich, wäre für einen Editor ein bisschen dumm) aber vielleicht hilft dir das was:

   void Update () {
      Vector3 movement = cameraTransform.TransformDirection(new Vector3(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical")));
      if (Input.GetKey(KeyCode.Space))
      {
            movement.y = 1;
      }
        else if (Input.GetKey(KeyCode.LeftControl))
        {
            movement.y = -1;
        }
        transform.position += movement * Time.deltaTime * speed;

        if (Input.GetMouseButton(1))
        {
            transform.Rotate(new Vector3(0, Input.GetAxis("Mouse X") * Time.deltaTime * rotationSpeed, 0));
            cameraTransform.Rotate(new Vector3(-Input.GetAxis("Mouse Y") * Time.deltaTime * rotationSpeed, 0, 0));
        }
   }

Bezüglich der kameraBewegungRandPosition könntest du die transform.position auch einfach clampen? Mit Mathf.Clamp könntest du den Wert auf einen Minimal und Maximalwert beschränken, wäre vielleicht angenehmer als die ifs da noch rein zu bauen.

Link zu diesem Kommentar
Auf anderen Seiten teilen

Archiviert

Dieses Thema ist jetzt archiviert und für weitere Antworten gesperrt.

×
×
  • Neu erstellen...