unity还原three导出的json——基本模型，位移，旋转，缩放

GameObject.CreatePrimitive(PrimitiveType.Cube);

GameObject.CreatePrimitive(PrimitiveType.Plane);

GameObject.CreatePrimitive(PrimitiveType.Sphere);

GameObject.CreatePrimitive(PrimitiveType.Cylinder);

然后设置transform组件：

using System;
using UnityEngine;
using UnityEditor;

public class MatrixArray
{
    private Vector3 scale;
    private Vector3 angle;
    private Matrix4x4 m_Materix;
    private Quaternion m_Quaternion;

    private double[] init =
    {
        -7.143478,3.521163,-7.232108,,-1.87758,1.747491,2.705387,,2.692082,3.996646,-0.713207,,5.061553,4.274189,5.206913,
    };

    public MatrixArray()
    {
        SetScaleAndAngle();
    }

    public Vector3 GetPosition()
    {
        float[] arr = DoubleToFloat(init);
        Vector3 position = new Vector3(arr[], arr[], arr[]);
        return position;
    }

    public Vector3 GetScale()
    {
        return scale;
    }
    public Vector3 GetAngle()
    {
        return angle;
    }

    private float[] DoubleToFloat(double[] arrs)
    {
        float[] outs = new float[arrs.Length];
        float b = ;
        int index = ;
        foreach (var a in arrs)
        {
            b = (float) a;
            outs[index] = b;
            index++;
        }
        return outs;
    }

    private void SetScaleAndAngle()
    {
        float[] arr = DoubleToFloat(init);
        var te = arr;
        var sx = Length(new Vector3(te[], te[], te[]));
        var sy = Length(new Vector3(te[], te[], te[]));
        var sz = Length(new Vector3(te[], te[], te[]));

        var det = Determinant();
        if (det < )
        {
            sx = -sx;
        }

        scale.x = sx;
        scale.y = sy;
        scale.z = sz;

        var invSX =  / sx;
        var invSY =  / sy;
        var invSZ =  / sz;

        Vector4 v4;
        for (int j = ; j < arr.Length; j++)
        {
            if (j %  == )
            {
                v4 = new Vector4(arr[j - ], arr[j - ], arr[j - ], arr[j]);
                m_Materix.SetColumn((int) (j / ), v4);
            }
        }

        m_Materix[] *= invSX;
        m_Materix[] *= invSX;
        m_Materix[] *= invSX;

        m_Materix[] *= invSY;
        m_Materix[] *= invSY;
        m_Materix[] *= invSY;

        m_Materix[] *= invSZ;
        m_Materix[] *= invSZ;
        m_Materix[] *= invSZ;

        QuaternionSetFromMatrix(m_Materix);
    }

    private void QuaternionSetFromMatrix(Matrix4x4 m)
    {
        var trace = m.m00 + m.m11 + m.m22;
        var s = 0f;
        if (trace > )
        {
            s = 0.5f / Mathf.Sqrt(trace + 1.0f);

            m_Quaternion.w = 0.25f / s;
            m_Quaternion.x = (m.m21 - m.m12) * s;
            m_Quaternion.y = (m.m02 - m.m20) * s;
            m_Quaternion.z = (m.m10 - m.m01) * s;
        }
        else if (m.m00 > m.m11 && m.m00 > m.m22)
        {
            s = 2.0f * Mathf.Sqrt(1.0f + m.m00 - m.m11 - m.m22);

            m_Quaternion.w = (m.m21 - m.m12) / s;
            m_Quaternion.x = 0.25f * s;
            m_Quaternion.y = (m.m10 + m.m01) / s;
            m_Quaternion.z = (m.m20 + m.m02) / s;
        }
        else if (m.m11 > m.m22)
        {
            s = 2.0f * Mathf.Sqrt(1.0f + m.m11 - m.m00 - m.m22);

            m_Quaternion.w = (m.m02 - m.m20) / s;
            m_Quaternion.x = (m.m10 + m.m01) / s;
            m_Quaternion.y = 0.25f * s;
            m_Quaternion.z = (m.m21 + m.m12) / s;
        }
        else
        {
            s = 2.0f * Mathf.Sqrt(1.0f + m.m22 - m.m00 - m.m11);

            m_Quaternion.w = (m.m10 - m.m01) / s;
            m_Quaternion.x = (m.m20 + m.m02) / s;
            m_Quaternion.y = (m.m21 + m.m12) / s;
            m_Quaternion.z = 0.25f * s;
        }

        SetFromRotationMatrix(MakeRotationFromQuaternion(m_Quaternion));
    }

    private float[] MakeRotationFromQuaternion(Quaternion q)
    {
        float[] te = new float[];
        te[] = te[] = te[] = te[] = ;
        var x = q.x;
        var y = q.y;
        var z = q.z;
        var w = q.w;
        var x2 = x + x;
        var y2 = y + y;
        var z2 = z + z;
        var xx = x * x2;
        var xy = x * y2;
        var xz = x * z2;
        var yy = y * y2;
        var yz = y * z2;
        var zz = z * z2;
        var wx = w * x2;
        var wy = w * y2;
        var wz = w * z2;

        te[] =  - (yy + zz);
        te[] = xy - wz;
        te[] = xz + wy;

        te[] = xy + wz;
        te[] =  - (xx + zz);
        te[] = yz - wx;

        te[] = xz - wy;
        te[] = yz + wx;
        te[] =  - (xx + yy);

        // last column
        te[] = ;
        te[] = ;
        te[] = ;

        // bottom row
        te[] = ;
        te[] = ;
        te[] = ;
        te[] = ;

        return te;
    }

    private void SetFromRotationMatrix(float[] m)
    {
        var te = m;
        var m11 = te[];
        var m12 = te[];
        var m13 = te[];
        var m21 = te[];
        var m22 = te[];
        var m23 = te[];
        var m31 = te[];
        var m32 = te[];
        var m33 = te[];

        angle.y = Mathf.Asin(Mathf.Clamp(m13, -, ));

        if (Mathf.Abs(m13) < 0.99999)
        {
            angle.x = Mathf.Atan2(-m23, m33);
            angle.z = Mathf.Atan2(-m12, m11);
        }
        else
        {
            angle.x = Mathf.Atan2(m32, m22);
            angle.z = ;
        }

        angle.x = angle.x * 180f / Mathf.PI;
        angle.y = angle.y * 180f / Mathf.PI;
        angle.z = angle.z * 180f / Mathf.PI;

        m_Quaternion = Quaternion.Euler(angle);
    }

    private float Length(Vector3 vector3)
    {
        return Mathf.Sqrt(vector3.x * vector3.x + vector3.y * vector3.y + vector3.z * vector3.z);
    }

    private float Determinant()
    {
        float[] arr = DoubleToFloat(init);
        var te = arr;

        var n11 = te[];
        var n12 = te[];
        var n13 = te[];
        var n14 = te[];
        var n21 = te[];
        var n22 = te[];
        var n23 = te[];
        var n24 = te[];
        var n31 = te[];
        var n32 = te[];
        var n33 = te[];
        var n34 = te[];
        var n41 = te[];
        var n42 = te[];
        var n43 = te[];
        var n44 = te[];

        return (
            n41 * (
                +n14 * n23 * n32
                - n13 * n24 * n32
                - n14 * n22 * n33
                + n12 * n24 * n33
                + n13 * n22 * n34
                - n12 * n23 * n34
            ) +
            n42 * (
                +n11 * n23 * n34
                - n11 * n24 * n33
                + n14 * n21 * n33
                - n13 * n21 * n34
                + n13 * n24 * n31
                - n14 * n23 * n31
            ) +
            n43 * (
                +n11 * n24 * n32
                - n11 * n22 * n34
                - n14 * n21 * n32
                + n12 * n21 * n34
                + n14 * n22 * n31
                - n12 * n24 * n31
            ) +
            n44 * (
                -n13 * n22 * n31
                - n11 * n23 * n32
                + n11 * n22 * n33
                + n13 * n21 * n32
                - n12 * n21 * n33
                + n12 * n23 * n31
            )
        );
    }
}

MatrixArray类是解析

"matrix": [0.015579,0,0.999879,0,0,1,0,0,-0.999879,0,0.015579,0,-30.749359,4.370426,0,1]用的；

private void SetTransform(GameObject game)
    {
        MatrixArray matrix = new MatrixArray();
        game.transform.position = matrix.GetPosition();
        game.transform.localScale = matrix.GetScale();
        game.transform.Rotate(new Vector3(matrix.GetAngle().x,,),Space.Self);
        game.transform.Rotate(new Vector3(,matrix.GetAngle().y,),Space.Self);
        game.transform.Rotate(new Vector3(,,matrix.GetAngle().z),Space.Self);

        game.transform.parent = gameObject.transform;

        Reverse(game.transform,matrix);
    }

上面代码为unity的对象还原位移旋转缩放。

private void Reverse(Transform form,MatrixArray matrixParse)
    {
        //反转
        Vector3 pos = matrixParse.GetPosition();
        form.position = new Vector3(-pos.x,pos.y,pos.z);

        Vector3 scale = matrixParse.GetScale();
        form.localScale = new Vector3(scale.x,-scale.y,-scale.z);

        form.Rotate(new Vector3(,,),Space.World);
    }

由于three.js是右手坐标系，unity是左手坐标系，摄像机看到的场景会反向，上述代码解决。