Ankündigung

Einklappen
Keine Ankündigung bisher.

Wie funktioniert Edit Object Track To in Python?

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Wie funktioniert Edit Object Track To in Python?

    Hallo.

    Ich will im Grunde nur dass ObjektA zu ObjektB schaut, und dabei Z nach oben hält.
    Mit
    own.alignAxisToVect(ObjektB, 1, 1.0)
    komm ich nicht weiter, weil dadurch gerät mein ObjektA in Schräglage sobald die Drehung zu stark ausfällt, sprich, Z bleibt nicht oben.

    Theoretisch müsste man doch nur anschließend den local Y Wert auf 0° einstellen ohne dass sich die anderen Achsen verändern.
    Wie geht das?

  • #2
    Dieses Beispiel richtet die X Achse des Objekts zum Ziehlobjekt aus und rotiert dabei das Objekt nur um die Z-Achse.
    Code:
    obj.alignAxisToVect([ObjektB.worldPosition.x, ObjektB.worldPosition.y, 0.0], 0, 1.0)

    Kommentar


    • #3
      Alternativ kannst Du das Objekt zweimal ausrichten. Einmal auf das Ziel schauend (y->Zielvector) und einmal nach oben ausrichten (Z->Z).

      HG1's Methode macht das in einem Schritt.

      Kommentar


      • #4
        Ok jetzt gehts, danke. Will noch kurz anmerken dass der Befehl die Achsen vom Nullpunkt zum Zielobjekt ausrichtet, und nicht von "own" zum Zielobjekt.
        Das hat mich ne Zeit lang beschäftigt lol...

        Noch ne Frage zum Rotieren:
        Wie würde man schreiben "deine (own) jetzige Rotation + 60° in Z"?

        Kommentar


        • #5
          Zitat von Failsafe Beitrag anzeigen
          Noch ne Frage zum Rotieren:
          Wie würde man schreiben "deine (own) jetzige Rotation + 60° in Z"?
          Code:
          own.applyRotation([0, 0, 60], False)
          Das False kannst du auch weglassen, da dieser Parameter automatisch auf False gesetzt wird. Das bedeutet, dass die globalen Achsen für die Drehung genutzt werden. Möchtest du das Objekt um die lokalen Achsen des Objekts drehen, schreibst du True.
          Ehemals M.B (altes BlendPolis)

          Kommentar


          • #6

            ApplyRotation rotiert in Radianten (rad = grad/180*pi).
            https://bgepython.tutorialsforblender.../applyRotation
            https://docs.python.org/3/library/math.html
            Code:
            import math
            own.applyRotation([0.0, 0.0, math.radians(60.0)], False)

            Kommentar


            • Momel
              Momel kommentierte
              Kommentar bearbeiten
              Oh, gut zu wissen. Danke

          • #7
            Noch paar Fragen, sry:
            1. Wie schreibt man das richtig mit Vektorkoordinaten, also zum Beispiel "own.applyRotation( Vektor([10, 10, 0])" ?
            Sollte sich dann 45° nach rechts drehen.

            2. Wie schreibt man dass so ein Vektor gleich in Radians XYZ dargestellt wird, quasi "print(Radians(Vektor[10,10,0]))"
            und es kommt raus 0°, 0°, -45°.

            Ich will damit dann den Rotationsunterschied von 2 Objekten feststellen und ein Objekt in die Richtung zum anderen drehen. Eigentlich genau dasselbe wie oben nur noch mal ohne AlignAxis.
            Für 1/4 Drehungen und sowas zum Beispiel.

            Plan:
            ObjektA.worldPosition - ObjektB.worldPosition = Vektor (Unterschied)

            1:
            own.applyRotation([0, 0, 0], False)
            own.applyRotation(Vektor[X,Y,Z], False)


            bzw 2:
            Vektor in Radians = X° Y° Z°
            eigene Rotation auf 0° 0° 0°
            own.applyRotation([math.radians(X°), math.radians(Y°), math.radians(Z°)]
            bzw Motion Actuator benutzen.

            Bitte korrigieren falls das irgendwie zu umständlich ist.

            Kommentar


            • #8
              Zitat von Failsafe Beitrag anzeigen
              1. Wie schreibt man das richtig mit Vektorkoordinaten, also zum Beispiel "own.applyRotation( Vektor([10, 10, 0])" ?
              Sollte sich dann 45° nach rechts drehen.
              Du kannst applyRotation keine Vectorkoordinaten (punkt im Raum) vorgeben. Diese Funktion benötigt einen Rotaionsvector (Euler Winkel in Radianten), also die drei Rotationen um die XYZ Achse.
              Den mathutils.Vector() benötigst du bei der Funktion nicht.

              Zitat von Failsafe Beitrag anzeigen
              2. Wie schreibt man dass so ein Vektor gleich in Radians XYZ dargestellt wird, quasi "print(Radians(Vektor[10,10,0]))"
              und es kommt raus 0°, 0°, -45°.
              Du kannst keinen Rotaionsvector in Radianten umwandeln. Das ist in der Vector Funktionen nicht vorgesehen.
              Achtung. Würde so nicht funktionieren da Python Groß-/Kleinschreibungsabhängig ist. Radians() --> math.Radians() muss math.radians() heißen.

              Zitat von Failsafe Beitrag anzeigen
              ObjektA.worldPosition - ObjektB.worldPosition = Vektor (Unterschied)
              Soweit richtig nur programmtechnisch falsch herum.
              Code:
              Differenz = ObjektA.worldPosition - ObjektB.worldPosition
              Achtung die Diffrenz zwischen zwei Raumvectoren ergibt wieder einen Raumvector und nicht einen Rotationsvector.

              Zitat von Failsafe Beitrag anzeigen
              own.applyRotation([math.radians(X°), math.radians(Y°), math.radians(Z°)] bzw Motion Actuator benutzen.
              Würde so nicht funktionieren da der zweite Parameter fehlt.
              Code:
              own.applyRotation([math.radians(X), math.radians(Y), math.radians(Z)], False)
              Zitat von Failsafe Beitrag anzeigen
              Ich will damit dann den Rotationsunterschied von 2 Objekten feststellen und ein Objekt in die Richtung zum anderen drehen. Eigentlich genau dasselbe wie oben nur noch mal ohne AlignAxis.
              Für 1/4 Drehungen und sowas zum Beispiel.
              Welchen Rotationsunterschied? Lokale Objektrotation (Eigenrotation) oder die Objektrotation (Position) um das Weltzentrum.
              Wiso ohne AlignAxis?

              Erstelle mal eine Beispieldatei wo man sehen kann was du meint.

              Kommentar


              • #9
                Zitat von HG1 Beitrag anzeigen
                Wiso ohne AlignAxis?
                Naja vlt versteh ich das noch nicht richtig.

                ---------------------------
                alignAxisToVect(vect, axis=2, factor=1.0) Aligns any of the game object’s axis along the given vector.
                • vect (3D vector) – a vector to align the axis.
                • axis (integer) –

                  The axis you want to align
                  • 0: X axis
                  • 1: Y axis
                  • 2: Z axis
                • factor (float) – Only rotate a feaction of the distance to the target vector (0.0 - 1.0)
                -------------------------------

                Bedeutet Faktor
                Geschwindigkeit wie z.b. 13° pro Sekunde oder
                Prozent wie z.b. 50% von 90° also 45°?

                Weil ich würde gern ne konstante Geschwindigkeit haben. Ein Geschütz dass sich mit 10° pro Sekunde zum Ziel drehen soll, darf nicht schneller oder langsamer drehen je nach Winkelgröße.
                Bleibt die Drehung mit dem Faktor immer gleich schnell? Das ist schwer zu erkennen.

                Kommentar


                • #10
                  Zitat von Failsafe Beitrag anzeigen
                  Bedeutet Faktor
                  Geschwindigkeit wie z.b. 13° pro Sekunde oder
                  Prozent wie z.b. 50% von 90° also 45°?
                  Der Faktor entspricht einem Prozentwert (lerp nicht slerp). Also keiner konstanten Geschwindigkeit


                  Kommentar


                  • #11
                    Zitat von Failsafe Beitrag anzeigen

                    Weil ich würde gern ne konstante Geschwindigkeit haben. Ein Geschütz dass sich mit 10° pro Sekunde zum Ziel drehen soll, darf nicht schneller oder langsamer drehen je nach Winkelgröße.
                    Bleibt die Drehung mit dem Faktor immer gleich schnell? Das ist schwer zu erkennen.
                    In dem Fall macht die Vektorfummelei nicht so viel Sinn.
                    Ich empfehle da einen anderen Ansatz:

                    Prüfe in welche Richtung sich das Geschütz drehen soll (also links oder rechts). Dann drehe das Geschütz in diese Richtung (also nach links). Dabei kannst Du konstante Drehung, Beschleunigung, Abbremsen oder was auch immer benutzen. Du hörst auf zu drehen, wenn das Ziel voraus liegt oder auf der anderen Seite. Da es eher unwahrscheinlich ist mit konstanter Schrittweite die genaue Ausrichtung zu treffen, empfehle ich eine "Distanz"-Prüfung. Würde der nächste Schritt zu weit drehen (der notwendige Schritt ist kleiner als der geplante) dann machst Du nur den kleineren Schritt (bzw. richtest das Geschütz sofort aus).
                    Das ganze kannst Du zweidimensional orthogonal machen also einmal die Drehung um die globale Z-Achse und einmal Drehung um die locale X-Achse. Die eine dreht link/rechts, die andere hoch/runter. Die Richtung bestimmst Du per Skalarprodukt (sieh Wikipedia).

                    Kommentar


                    • #12
                      Zitat von Monster Beitrag anzeigen
                      "Distanz"-Prüfung. Würde der nächste Schritt zu weit drehen (der notwendige Schritt ist kleiner als der geplante) dann machst Du nur den kleineren Schritt (bzw. richtest das Geschütz sofort aus).
                      Wie kann man das schreiben mit der Distanzprüfung?
                      Mir fällt jetzt nur Raycast oder RaySensor ein um das Ziel zu erwischen, aber das hat zuviel Spielraum wenn man nah vor dem Geschütz steht.

                      EDIT:
                      Vielleicht mit own.getVectTo(Ziel)[2] irgendwie?
                      Der X-Wert von dem lokalen Vektor ([2]) ändert Vorzeichen sobald das Geschütz über den Zielmittelpunkt hinausgeht (bei Z Drehung).

                      EDIT2:
                      Ok das funktioniert.
                      Hab mit own.getVectTo(Ziel) und X-Wert die Richtung links/rechts bestimmt, applyRotation verwendet und beim Vorzeichenwechsel alignAxis benutzt.
                      Falls es noch andere Möglichkeiten gibt bitte Bescheid geben. Danke für die Antworten.
                      Zuletzt geändert von Failsafe; 17.11.2017, 18:06.

                      Kommentar


                      • #13
                        Ich habe dir in der zwischenzeitlich ein Beispiel gemacht das den Winkel mit atan2 ausgerechnet.
                        Ich habe bewusst auf die Vektorfunktionen verzichtet, da die meisten, wenn sich das zu drehende Objekt im Weltursprung liegt, zu einer Division durch Null kommt (getVectTo funktioniert).
                        Angehängte Dateien

                        Kommentar


                        • #14
                          Nice! Ich glaub das ist genau was ich gesucht hab. Hab nur 2 Probleme grad:

                          1. Bei dem File wird X als Zielachse benutzt. Wie schreibt man das mit Y?

                          2.
                          if ang2 < (ang + 0.01):
                          objA.applyRotation([0.0, 0.0, math.radians(0.5)], False)

                          Kann man diesen Wert vielleicht mit dem math.radians(Wert) abgleichen irgendwie? Ungefähr so:

                          if ang2 < (ang + math.radians(0.5)-Strecke/Schritt):

                          Wenn das ginge wärs optimal.
                          Zuletzt geändert von Failsafe; 18.11.2017, 09:28.

                          Kommentar


                          • #15
                            Zitat von Failsafe Beitrag anzeigen
                            1. Bei dem File wird X als Zielachse benutzt. Wie schreibt man das mit Y?
                            Einfach im Editmodus das Objekt um 90° drehen. Du kannst aber auch die 90° zum Winkel hinzu addieren.
                            Code:
                            ang = math.atan2(dir.y, dir.x) + math.radians(90.)
                            2.
                            Zitat von Failsafe Beitrag anzeigen
                            if ang2 < (ang + 0.01):
                            Das ist ein Positionsfenster. ist der Istwinkel im Fenster wird die Bewegung gestoppt. Ohne dieses Fenster würde der Turm bei zu hohen Geschwindigkeiten über die Sollpostion drehen und danach wieder zurückdrehen.
                            Somit würde er immer hin und her pendeln.
                            Natürlich kannst du auch das Positionsfenster Grad angeben.
                            Code:
                            if ang2 < (ang + math.radians(0.5)):
                            Zitat von Failsafe Beitrag anzeigen
                            Kann man diesen Wert vielleicht mit dem math.radians(Wert) abgleichen irgendwie? Ungefähr so:
                            Was mit was abgleichen?
                            Code:
                            if ang2 < (ang + math.radians(0.5)-Strecke/Schritt):
                            Was macht Strecke und Schritt hier?


                            Kommentar

                            Lädt...
                            X
                            Um unsere Webseite für Sie optimal zu gestalten und fortlaufend verbessern zu können, verwenden wir Cookies. Durch die weitere Nutzung der Webseite stimmen Sie der Verwendung von Cookies zu. Weitere Informationen zu Cookies erhalten Sie in unserer Datenschutzerklärung