Umrechnung von Matrizen zu Keyframes

DH-106 · 20. Juni 2024

Transformationsmatrizen haben natürlich eine gewisse Eleganz, aber sobald ich versuchen möchte, eine solche nachzuvollziehen, bin ich mit meinem Latein ziemlich bald am Ende.

In so einer Zahlenkolonne wie { 0.995, 0, 0.096, 0, 0, 1, 0, 0, -0.096, 0, 0.995, 0, -0.274, 0, 0.152, 1, }, sind an den vier letzten Stellen die Koordinaten des Ursprungs und die globale Skalierung enthalten, aber die Rotation und Skalierung um die drei Achsen sind hinter diversen aufmultiplizierten Sinussen und Kosinussen versteckt. Xanos hatte einmal ein schönes Werkzeug gebaut, mit dem man (trotz gewisser Einschränkungen) schnell aus einem Keyframe eine Matrix bauen kann.

Gibt es aber auch eine Möglichkeit, den umgekehrten Weg zu gehen und eine Transformationsmatrix in einen Keyframe plus Skalierung je Achse umrechnen zu lassen?

**MaikC** · 20. Juni 2024

Warum nutzt du nicht einfach eine andere transf und sparst dir die ganze Umrechnerei indem du die Skalierung und die Winkel direkt eingibst?

Code

local vec3 = require "vec3"
local transf = require "transf"
function data()
return {
    times = { 0, 1500, },
    transfs = {
        transf.scaleRotZYXTransl(vec3.new( 1.0, 1.0, 1.0), transf.degToRad ( 0, 0, 0), vec3.new(0.0, 0.0, 0.0)),
        transf.scaleRotZYXTransl(vec3.new( 1.0, 1.0, 1.0), transf.degToRad ( 0, 0, -87), vec3.new(0.0, 0.0, 0.0))
    },
}
end

Alles anzeigen

DH-106 · 20. Juni 2024

Es geht mir darum, eine existierende Matrix nachzuvollziehen.

Ich habe gerade den Lachs im Blender und seine .mdl dazu im Editor; das Ziel ist, daß ich die Animation über Bones verstehen lerne. Daß die nicht im .msh, sondern in der .mdl und weiter über .anis definiert ist, habe ich bereits herausgefunden - nur die Struktur, die dahinter steht, ist leider in den Matrizen versteckt.

Und deswegen hätte ich gerne die Matrizen in intuitiv verständliche Keyframes zurückgerechnet.

**MaikC** · 20. Juni 2024

Zitat von DH-106

den umgekehrten Weg zu gehen und eine Transformationsmatrix in einen Keyframe plus Skalierung je Achse umrechnen zu lassen?

Was meinst du mit Keyframe? Meinst du von TPF2 nach Blender?

Edit: Also ja sorry dann hatte ich deine Intention missverstanden.

DH-106 · 20. Juni 2024

Prinzipiell ja. Ich suche nach dem Schritt von {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1} zu transf.scaleRotZYXTransl(vec3.new( 1, 1, 1), transf.degToRad ( 0, 0, 0), vec3.new(0, 0, 0)), . Der umgekehrte, wesentlich häufiger gebrauchte geht ja über Xanos´ Lexikoneintrag, aber der hilft mir nicht weiter.

**MaikC** · 20. Juni 2024

EAT1963 hatte sich damit für den TPF->TPF2 Converter intensiver damit beschäftigt. Eventuell hat er ja Zeit und Lust da zu helfen.

DH-106 · 20. Juni 2024

...oder ich gehe einfach mal im Konverter spicken. Guter Punkt, danke

**MaikC** · 20. Juni 2024

So als Tip dazu da das nicht offensichtlich ist. Der Eintrag "oldSeatsStyle = false,/true" (in der mod.lua) bewirkt das es er zwischen den beiden Transf formen "wechselt" da irgendwo ist also der Code oder eine Formel versteckt.

**eis_os** · 20. Juni 2024

Ich hab das hier noch rumliegen (keine Gewähr auf Funktion und Richtigkeit) , ich hab das vor keine Ahnung mehr zusammengeklöppelt:

Code

function transf.decompositeParts(m)
--   m[1]  m[2]  m[3]  m[4]
--   m[5]  m[6]  m[7]  m[8]
--   m[9] m[10] m[11] m[12]
--  m[13] m[14] m[15] m[16]

    local scaleing = {}
    local transl = { m[13], m[14], m[15] }
    local rotatingMatrix = {}

    scaleing[1] = m[16] * math.sqrt(m[1]^2 + m[2]^2 + m[3]^2)
    scaleing[2] = m[16] * math.sqrt(m[5]^2 + m[6]^2 + m[7]^2)
    scaleing[3] = m[16] * math.sqrt(m[9]^2 + m[10]^2 + m[11]^2)
    

    rotatingMatrix = {
        m[1] / scaleing[1], m[2]/scaleing[2], m[3] / scaleing[3], 0,
        m[5] / scaleing[1], m[6]/scaleing[2], m[7] / scaleing[3], 0,
        m[9] / scaleing[1], m[10]/scaleing[2], m[11] / scaleing[3], 0,
        0, 0, 0, 1
    }
    
    local rotParts =  {
        math.atan2( rotatingMatrix[7], rotatingMatrix[11]);
        math.atan2(-rotatingMatrix[9], rotatingMatrix[11]);
        math.atan2(rotatingMatrix[5], rotatingMatrix[1]);
    }

    local theta1 = math.atan2(m[7], m[11])
    local c2 = math.sqrt(m[1]^2 + m[2]^2)
    local theta2 = math.atan2(-m[3], c2)
    local s1 = math.sin(theta1)
    local c1 = math.cos(theta1)
    local theta3 = math.atan2(s1*m[9] - c1*m[5], c1*m[6] - s1*m[10])
    local rotParts = { -theta1, -theta2, -theta3 }

    local rotPartsDeg = {
        math.deg(rotParts[1]),
        math.deg(rotParts[2]),
        math.deg(rotParts[3]),
    }

    local data = {
        transl = transl,
        scaleing = scaleing,
        rotatingMatrix = rotatingMatrix,
        rotationAngles = rotParts,
        rotPartsDeg = rotPartsDeg,
    }
    return data
end

Alles anzeigen

DH-106 · 20. Juni 2024

Das sieht nach der Lösung aus. Wenn du es mir erlaubst, werde ich diese Zeilen einmal räubern und schauen, ob ich damit einen Konverter von Matrix zu Keyframe basteln kann. Mir fehlt zwar außerhalb des Spiels eine .lua-Umgebung, aber man kann dafür bestimmt auch eine .con zweckentfremden, die nebenher noch was zum Rechnen bekommt und es dann in der Konsole zum Rauskopieren hinschreibt...

VacuumTube · 20. Juni 2024

Ich kann für sowas

https://www.tutorialspoint.com/execute_lua_online.php

empfehlen

Umrechnung von Matrizen zu Keyframes

Willkommen in der Transport Fever Community

Teilen