Datasets:

introvoyz041
/

mujoco

// Copyright 2019 DeepMind Technologies Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Xml;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools.Utils;

namespace Mujoco {

  [TestFixture]
  public class MjEngineToolXmlLoadingTests {

    [Test]
    public unsafe void LoadingSceneFromAProvidedAsset() {
      var modelFile = Resources.Load<TextAsset>("ValidModel");
      var modelPtr = MjEngineTool.LoadModelFromString(modelFile.text);
      var model =
          (MujocoLib.mjModel_)Marshal.PtrToStructure(new IntPtr(modelPtr), typeof(MujocoLib.mjModel_));
      Assert.That(model.nbody, Is.EqualTo(3));
    }
  }

  [TestFixture]
  public class MjEngineToolTransformHelpersTests {
    [TestCase(1, 2, 3)]
    [TestCase(-1, -2, -3)]
    [TestCase(-1, 2, 3)]
    [TestCase(1, -2, 3)]
    [TestCase(1, 2, -3)]
    public unsafe void RoundrobinConversionOfVector3(float x, float y, float z) {
      var vec = new Vector3(x, y, z);
      var MjVec = MjEngineTool.MjVector3(vec);
      var MjVecAsArray = new double[] { 10, 11, 12, MjVec.x, MjVec.y, MjVec.z };
      fixed (double* MjArrPtr = MjVecAsArray) {
        var recreatedVec = MjEngineTool.UnityVector3(
            MjEngineTool.MjVector3AtEntry(MjArrPtr, 1));
        Assert.That(recreatedVec, Is.EqualTo(vec));
      }
    }

    [TestCase(1, 2, 3)]
    [TestCase(-1, -2, -3)]
    [TestCase(-1, 2, 3)]
    [TestCase(1, -2, 3)]
    [TestCase(1, 2, -3)]
    public void RoundrobinConversionOfVector3UsingCoreType(float x, float y, float z) {
      var vec = new Vector3(x, y, z);
      var MjVec = MjEngineTool.MjVector3(vec);
      var unityVec = MjEngineTool.UnityVector3(MjVec);
      Assert.That(unityVec, Is.EqualTo(vec));
    }

    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
    public unsafe void RoundrobinConversionOfQuaternionUsingUnsafeArrays(float x, float y, float z,
                                                                         float w) {
      var quat = new Quaternion(x, y, z, w);
      var MjQuat = MjEngineTool.MjQuaternion(quat);
      var MjQuatAsArray =
          new double[] { 10, 20, 30, 40, MjQuat.w, MjQuat.x, MjQuat.y, MjQuat.z };
      fixed (double* MjArrPtr = MjQuatAsArray) {
        var recreatedQuat = MjEngineTool.UnityQuaternion(
            MjEngineTool.MjQuaternionAtEntry(MjArrPtr, 1));
        var q1 = new Vector4(quat.x, quat.y, quat.z, quat.w);
        var q2 = new Vector4(recreatedQuat.x, recreatedQuat.y, recreatedQuat.z, recreatedQuat.w);
        Assert.That(q1, Is.EqualTo(q2));
      }
    }

    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
    public void RoundrobinConversionOfQuaternionUsingCoreType(float x, float y, float z, float w) {
      var quat = new Quaternion(x, y, z, w);
      var MjQuat = MjEngineTool.MjQuaternion(quat);
      var unityQuat = MjEngineTool.UnityQuaternion(MjQuat);
      Assert.That(unityQuat, Is.EqualTo(quat));
    }

    [TestCase(1, 2, 3)]
    [TestCase(-1, -2, -3)]
    [TestCase(-1, 2, 3)]
    [TestCase(1, -2, 3)]
    [TestCase(1, 2, -3)]
    public void RoundrobinConversionOfExtents(float x, float y, float z) {
      var extents = new Vector3(x, y, z);
      var MjExtents = MjEngineTool.MjExtents(extents);
      var unityExtents = MjEngineTool.UnityExtents(MjExtents);
      Assert.That(MjExtents, Is.Not.EqualTo(extents));
      Assert.That(unityExtents, Is.EqualTo(extents));
    }

    [TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
    [TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
    [TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
    [TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
    [TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
    [TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
    public unsafe void SettingAndRetrievingQuaternions(float x, float y, float z, float w) {
      var quat = new Quaternion(x, y, z, w);
      var result = Quaternion.identity;
      var buffer = new double[4];
      fixed (double* unsafeBuffer = buffer) {
        MjEngineTool.SetMjQuaternion(unsafeBuffer, quat);
        result = MjEngineTool.UnityQuaternion(unsafeBuffer);
      }
      Assert.That(quat, Is.EqualTo(result));
    }

    [TestCase(1, 2, 3)]
    [TestCase(-1, -2, -3)]
    [TestCase(-1, 2, 3)]
    [TestCase(1, -2, 3)]
    [TestCase(1, 2, -3)]
    public unsafe void SettingAndRetrievingVectors(float x, float y, float z) {
      var vec = new Vector3(x, y, z);
      var result = Vector3.zero;
      double[] buffer = new double[3];
      fixed (double* unsafeBuffer = buffer) {
        MjEngineTool.SetMjVector3(unsafeBuffer, vec);
        result = MjEngineTool.UnityVector3(unsafeBuffer);
      }
      Assert.That(vec, Is.EqualTo(result));
    }
  }

  [TestFixture]
  public class MjEngineToolTransformSerializationTests {
    public class FakeMjComponent : MjComponent {
      public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_GEOM;

      protected override void OnParseMjcf(XmlElement mjcf) {}

      protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
        return doc.CreateElement("geom");
      }
    }

    private GameObject _rootObject;
    private GameObject _intermediateObject;
    private FakeMjComponent _component;
    private Vector3EqualityComparer _vectorComparer;
    private Vector4EqualityComparer _quaternionComparer;

    [SetUp]
    public void SetUp() {
      _rootObject = new GameObject("rootObject");
      _intermediateObject = new GameObject("intermediateObject");
      _component = new GameObject("component").AddComponent<FakeMjComponent>();
      var epsilon = 1e-3f;
      _vectorComparer = new Vector3EqualityComparer(epsilon);
      _quaternionComparer = new Vector4EqualityComparer(epsilon);
    }

    [TearDown]
    public void TearDown() {
      UnityEngine.Object.DestroyImmediate(_component.gameObject);
      UnityEngine.Object.DestroyImmediate(_intermediateObject);
      UnityEngine.Object.DestroyImmediate(_rootObject);
      MjSceneImportSettings.AnglesInDegrees = true;
    }

    [Test]
    public void SerializingPositionRotationOfRootComponent() {
      _component.transform.position = new Vector3(1, 2, 3);
      _component.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
      var doc = new XmlDocument();
      var mjcf = doc.CreateElement("element");
      MjEngineTool.PositionRotationToMjcf(mjcf, _component);
      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
      Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
                  Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
                  .Using(_quaternionComparer));
    }

    [Test]
    public void SerializingPositionRotationOfRootComponentParentedToGameObject() {
      _component.transform.parent = _rootObject.transform;
      _rootObject.transform.position = new Vector3(1, 2, 3);
      _rootObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
      var doc = new XmlDocument();
      var mjcf = doc.CreateElement("element");
      MjEngineTool.PositionRotationToMjcf(mjcf, _component);
      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
      Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
                  Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
                  .Using(_quaternionComparer));
    }

    [Test]
    public void SerializingPositionRotationOfChildComponentParentedThroughGameObject() {
      _component.transform.parent = _intermediateObject.transform;
      _intermediateObject.transform.parent = _rootObject.transform;
      _intermediateObject.transform.position = new Vector3(1, 2, 3);
      _intermediateObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
      var doc = new XmlDocument();
      var mjcf = doc.CreateElement("element");
      MjEngineTool.PositionRotationToMjcf(mjcf, _component);
      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
      Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
                  Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
                  .Using(_quaternionComparer));
    }

    [Test]
    public void SerializingPositionAxisOfRootComponent() {
      _component.transform.position = new Vector3(1, 2, 3);
      _component.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
      var doc = new XmlDocument();
      var mjcf = doc.CreateElement("element");
      MjEngineTool.PositionAxisToMjcf(mjcf, _component);
      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
      Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
                  Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
      Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
    }

    [Test]
    public void SerializingPositionAxisOfRootComponentParentedToGameObject() {
      _component.transform.parent = _rootObject.transform;
      _rootObject.transform.position = new Vector3(1, 2, 3);
      _rootObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
      var doc = new XmlDocument();
      var mjcf = doc.CreateElement("element");
      MjEngineTool.PositionAxisToMjcf(mjcf, _component);
      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
      Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
                  Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
      Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
    }

    [Test]
    public void SerializingPositionAxisOfChildComponentParentedThroughGameObject() {
      _component.transform.parent = _intermediateObject.transform;
      _intermediateObject.transform.parent = _rootObject.transform;
      _intermediateObject.transform.position = new Vector3(1, 2, 3);
      _intermediateObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
      var doc = new XmlDocument();
      var mjcf = doc.CreateElement("element");
      MjEngineTool.PositionAxisToMjcf(mjcf, _component);
      Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
      Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
                  Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
      Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
    }

    [Test]
    public void ParsePosition() {
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("pos", "1 3 2");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      Assert.That(_rootObject.transform.position, Is.EqualTo(new Vector3(1, 2, 3)));
    }

    [Test]
    public void ParseRotationFromQuat() {
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("quat", "-0.9238795 0 0 0.3826835");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      var expectedRotation = Quaternion.AngleAxis(45, Vector3.up);
      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
      // Assert.That(
      //     _rootObject.transform.rotation,
      //     Is.EqualTo(Quaternion.AngleAxis(45, Vector3.up))
      //     .Using(_quaternionComparer));
    }

    [Test]
    public void ParseRotationFromZAxis() {
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("zaxis", "0 1 0");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      var expectedRotation = Quaternion.AngleAxis(90, Vector3.right);
      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
      // Assert.That(
      //     _rootObject.transform.rotation,
      //     Is.EqualTo(Quaternion.AngleAxis(90, Vector3.right))
      //     .Using(_quaternionComparer));
    }

    [TestCase(true, 45, 45)]
    [TestCase(false, 0.785398f, 45)]
    [TestCase(true, 90, 90)]
    [TestCase(false, 1.570796f, 90)]
    public void ParseRotationFromAxisAngle(bool useDegrees, float MjAngle,
                                           float expectedAngle) {
      MjSceneImportSettings.AnglesInDegrees = useDegrees;
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("axisangle", $"1 0 0 {MjAngle}");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      var expectedRotation = Quaternion.AngleAxis(expectedAngle, Vector3.right);
      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
      // Assert.That(
      //     _rootObject.transform.rotation,
      //     Is.EqualTo(Quaternion.AngleAxis(expectedAngle, Vector3.right))
      //     .Using(_quaternionComparer));
    }

    [TestCase(true, 0, 45, 0, 0, 0, -45)]
    [TestCase(false, 0, 0.785398f, 0, 0, 0, -45)]
    [TestCase(true, 0, 0, 45, 0, 45, 0)]
    [TestCase(false, 0, 0, 0.785398f, 0, 45, 0)]
    [TestCase(true, 45, 0, 0, 45, 0, 0)]
    [TestCase(false, 0.785398f, 0, 0, 45, 0, 0)]
    public void ParseRotationFromEuler(bool useDegrees, float mx, float my, float mz, float ex,
                                       float ey, float ez) {
      MjSceneImportSettings.AnglesInDegrees = useDegrees;
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("euler", $"{mx} {my} {mz}");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      var expectedRotation = Quaternion.Euler(ex, ey, ez);
      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
      // Assert.That(
      //     _rootObject.transform.rotation,
      //     Is.EqualTo(Quaternion.Euler(ex, ey, ez))
      //     .Using(_quaternionComparer));
    }

    [Test]
    public void ParseRotationFromDirectionVector() {
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("fromto", $"0 0 0 1 1 0");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      var expectedRotation = new Quaternion(0.5f, 0, -0.5f, 0.7071068f);
      Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
      Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
      // Assert.That(
      //     _rootObject.transform.rotation,
      //     Is.EqualTo(new Quaternion(0.5f, 0, -0.5f, 0.7071068f))
      //     .Using(_quaternionComparer));
    }

    [Test]
    public void ParsePositionFromDirectionVector() {
      var mjcf = new XmlDocument().CreateElement("element");
      mjcf.SetAttribute("fromto", $"1 2 3 5 7 9");
      MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
      Assert.That(_rootObject.transform.position, Is.EqualTo(new Vector3(3, 6, 4.5f)));
    }
  }
}

	// Copyright 2019 DeepMind Technologies Limited
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	using System;
	using System.IO;
	using System.Runtime.InteropServices;
	using System.Xml;
	using NUnit.Framework;
	using UnityEngine;
	using UnityEngine.TestTools.Utils;

	namespace Mujoco {

	[TestFixture]
	public class MjEngineToolXmlLoadingTests {

	[Test]
	public unsafe void LoadingSceneFromAProvidedAsset() {
	var modelFile = Resources.Load<TextAsset>("ValidModel");
	var modelPtr = MjEngineTool.LoadModelFromString(modelFile.text);
	var model =
	(MujocoLib.mjModel_)Marshal.PtrToStructure(new IntPtr(modelPtr), typeof(MujocoLib.mjModel_));
	Assert.That(model.nbody, Is.EqualTo(3));
	}
	}

	[TestFixture]
	public class MjEngineToolTransformHelpersTests {
	[TestCase(1, 2, 3)]
	[TestCase(-1, -2, -3)]
	[TestCase(-1, 2, 3)]
	[TestCase(1, -2, 3)]
	[TestCase(1, 2, -3)]
	public unsafe void RoundrobinConversionOfVector3(float x, float y, float z) {
	var vec = new Vector3(x, y, z);
	var MjVec = MjEngineTool.MjVector3(vec);
	var MjVecAsArray = new double[] { 10, 11, 12, MjVec.x, MjVec.y, MjVec.z };
	fixed (double* MjArrPtr = MjVecAsArray) {
	var recreatedVec = MjEngineTool.UnityVector3(
	MjEngineTool.MjVector3AtEntry(MjArrPtr, 1));
	Assert.That(recreatedVec, Is.EqualTo(vec));
	}
	}

	[TestCase(1, 2, 3)]
	[TestCase(-1, -2, -3)]
	[TestCase(-1, 2, 3)]
	[TestCase(1, -2, 3)]
	[TestCase(1, 2, -3)]
	public void RoundrobinConversionOfVector3UsingCoreType(float x, float y, float z) {
	var vec = new Vector3(x, y, z);
	var MjVec = MjEngineTool.MjVector3(vec);
	var unityVec = MjEngineTool.UnityVector3(MjVec);
	Assert.That(unityVec, Is.EqualTo(vec));
	}

	[TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
	[TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
	[TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
	[TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
	[TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
	[TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
	public unsafe void RoundrobinConversionOfQuaternionUsingUnsafeArrays(float x, float y, float z,
	float w) {
	var quat = new Quaternion(x, y, z, w);
	var MjQuat = MjEngineTool.MjQuaternion(quat);
	var MjQuatAsArray =
	new double[] { 10, 20, 30, 40, MjQuat.w, MjQuat.x, MjQuat.y, MjQuat.z };
	fixed (double* MjArrPtr = MjQuatAsArray) {
	var recreatedQuat = MjEngineTool.UnityQuaternion(
	MjEngineTool.MjQuaternionAtEntry(MjArrPtr, 1));
	var q1 = new Vector4(quat.x, quat.y, quat.z, quat.w);
	var q2 = new Vector4(recreatedQuat.x, recreatedQuat.y, recreatedQuat.z, recreatedQuat.w);
	Assert.That(q1, Is.EqualTo(q2));
	}
	}

	[TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
	[TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
	[TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
	[TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
	[TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
	[TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
	public void RoundrobinConversionOfQuaternionUsingCoreType(float x, float y, float z, float w) {
	var quat = new Quaternion(x, y, z, w);
	var MjQuat = MjEngineTool.MjQuaternion(quat);
	var unityQuat = MjEngineTool.UnityQuaternion(MjQuat);
	Assert.That(unityQuat, Is.EqualTo(quat));
	}

	[TestCase(1, 2, 3)]
	[TestCase(-1, -2, -3)]
	[TestCase(-1, 2, 3)]
	[TestCase(1, -2, 3)]
	[TestCase(1, 2, -3)]
	public void RoundrobinConversionOfExtents(float x, float y, float z) {
	var extents = new Vector3(x, y, z);
	var MjExtents = MjEngineTool.MjExtents(extents);
	var unityExtents = MjEngineTool.UnityExtents(MjExtents);
	Assert.That(MjExtents, Is.Not.EqualTo(extents));
	Assert.That(unityExtents, Is.EqualTo(extents));
	}

	[TestCase(0.1f, 0.2f, 0.3f, 0.4f)]
	[TestCase(-0.1f, -0.2f, -0.3f, -0.4f)]
	[TestCase(-0.1f, 0.2f, 0.3f, 0.4f)]
	[TestCase(0.1f, -0.2f, 0.3f, 0.4f)]
	[TestCase(0.1f, 0.2f, -0.3f, 0.4f)]
	[TestCase(0.1f, 0.2f, 0.3f, -0.4f)]
	public unsafe void SettingAndRetrievingQuaternions(float x, float y, float z, float w) {
	var quat = new Quaternion(x, y, z, w);
	var result = Quaternion.identity;
	var buffer = new double[4];
	fixed (double* unsafeBuffer = buffer) {
	MjEngineTool.SetMjQuaternion(unsafeBuffer, quat);
	result = MjEngineTool.UnityQuaternion(unsafeBuffer);
	}
	Assert.That(quat, Is.EqualTo(result));
	}

	[TestCase(1, 2, 3)]
	[TestCase(-1, -2, -3)]
	[TestCase(-1, 2, 3)]
	[TestCase(1, -2, 3)]
	[TestCase(1, 2, -3)]
	public unsafe void SettingAndRetrievingVectors(float x, float y, float z) {
	var vec = new Vector3(x, y, z);
	var result = Vector3.zero;
	double[] buffer = new double[3];
	fixed (double* unsafeBuffer = buffer) {
	MjEngineTool.SetMjVector3(unsafeBuffer, vec);
	result = MjEngineTool.UnityVector3(unsafeBuffer);
	}
	Assert.That(vec, Is.EqualTo(result));
	}
	}

	[TestFixture]
	public class MjEngineToolTransformSerializationTests {
	public class FakeMjComponent : MjComponent {
	public override MujocoLib.mjtObj ObjectType => MujocoLib.mjtObj.mjOBJ_GEOM;

	protected override void OnParseMjcf(XmlElement mjcf) {}

	protected override XmlElement OnGenerateMjcf(XmlDocument doc) {
	return doc.CreateElement("geom");
	}
	}

	private GameObject _rootObject;
	private GameObject _intermediateObject;
	private FakeMjComponent _component;
	private Vector3EqualityComparer _vectorComparer;
	private Vector4EqualityComparer _quaternionComparer;

	[SetUp]
	public void SetUp() {
	_rootObject = new GameObject("rootObject");
	_intermediateObject = new GameObject("intermediateObject");
	_component = new GameObject("component").AddComponent<FakeMjComponent>();
	var epsilon = 1e-3f;
	_vectorComparer = new Vector3EqualityComparer(epsilon);
	_quaternionComparer = new Vector4EqualityComparer(epsilon);
	}

	[TearDown]
	public void TearDown() {
	UnityEngine.Object.DestroyImmediate(_component.gameObject);
	UnityEngine.Object.DestroyImmediate(_intermediateObject);
	UnityEngine.Object.DestroyImmediate(_rootObject);
	MjSceneImportSettings.AnglesInDegrees = true;
	}

	[Test]
	public void SerializingPositionRotationOfRootComponent() {
	_component.transform.position = new Vector3(1, 2, 3);
	_component.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
	var doc = new XmlDocument();
	var mjcf = doc.CreateElement("element");
	MjEngineTool.PositionRotationToMjcf(mjcf, _component);
	Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
	Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
	Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
	.Using(_quaternionComparer));
	}

	[Test]
	public void SerializingPositionRotationOfRootComponentParentedToGameObject() {
	_component.transform.parent = _rootObject.transform;
	_rootObject.transform.position = new Vector3(1, 2, 3);
	_rootObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
	var doc = new XmlDocument();
	var mjcf = doc.CreateElement("element");
	MjEngineTool.PositionRotationToMjcf(mjcf, _component);
	Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
	Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
	Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
	.Using(_quaternionComparer));
	}

	[Test]
	public void SerializingPositionRotationOfChildComponentParentedThroughGameObject() {
	_component.transform.parent = _intermediateObject.transform;
	_intermediateObject.transform.parent = _rootObject.transform;
	_intermediateObject.transform.position = new Vector3(1, 2, 3);
	_intermediateObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
	var doc = new XmlDocument();
	var mjcf = doc.CreateElement("element");
	MjEngineTool.PositionRotationToMjcf(mjcf, _component);
	Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
	Assert.That(mjcf.GetQuaternionAttribute("quat", Quaternion.identity),
	Is.EqualTo(new Quaternion(w:-0.9238795f, x:0, y:0, z:0.3826835f))
	.Using(_quaternionComparer));
	}

	[Test]
	public void SerializingPositionAxisOfRootComponent() {
	_component.transform.position = new Vector3(1, 2, 3);
	_component.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
	var doc = new XmlDocument();
	var mjcf = doc.CreateElement("element");
	MjEngineTool.PositionAxisToMjcf(mjcf, _component);
	Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
	Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
	Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
	Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
	}

	[Test]
	public void SerializingPositionAxisOfRootComponentParentedToGameObject() {
	_component.transform.parent = _rootObject.transform;
	_rootObject.transform.position = new Vector3(1, 2, 3);
	_rootObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
	var doc = new XmlDocument();
	var mjcf = doc.CreateElement("element");
	MjEngineTool.PositionAxisToMjcf(mjcf, _component);
	Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
	Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
	Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
	Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
	}

	[Test]
	public void SerializingPositionAxisOfChildComponentParentedThroughGameObject() {
	_component.transform.parent = _intermediateObject.transform;
	_intermediateObject.transform.parent = _rootObject.transform;
	_intermediateObject.transform.position = new Vector3(1, 2, 3);
	_intermediateObject.transform.rotation = Quaternion.AngleAxis(45, Vector3.up);
	var doc = new XmlDocument();
	var mjcf = doc.CreateElement("element");
	MjEngineTool.PositionAxisToMjcf(mjcf, _component);
	Assert.That(mjcf.GetAttribute("pos"), Is.EqualTo("1 3 2"));
	Assert.That(mjcf.GetVector3Attribute("axis", Vector3.zero),
	Is.EqualTo(new Vector3(0.7071068f, -0.7071069f, 0)).Using(_vectorComparer));
	Assert.That(mjcf.GetAttribute("ref"), Is.EqualTo("0"));
	}

	[Test]
	public void ParsePosition() {
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("pos", "1 3 2");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	Assert.That(_rootObject.transform.position, Is.EqualTo(new Vector3(1, 2, 3)));
	}

	[Test]
	public void ParseRotationFromQuat() {
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("quat", "-0.9238795 0 0 0.3826835");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	var expectedRotation = Quaternion.AngleAxis(45, Vector3.up);
	Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
	// Assert.That(
	// _rootObject.transform.rotation,
	// Is.EqualTo(Quaternion.AngleAxis(45, Vector3.up))
	// .Using(_quaternionComparer));
	}

	[Test]
	public void ParseRotationFromZAxis() {
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("zaxis", "0 1 0");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	var expectedRotation = Quaternion.AngleAxis(90, Vector3.right);
	Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
	// Assert.That(
	// _rootObject.transform.rotation,
	// Is.EqualTo(Quaternion.AngleAxis(90, Vector3.right))
	// .Using(_quaternionComparer));
	}

	[TestCase(true, 45, 45)]
	[TestCase(false, 0.785398f, 45)]
	[TestCase(true, 90, 90)]
	[TestCase(false, 1.570796f, 90)]
	public void ParseRotationFromAxisAngle(bool useDegrees, float MjAngle,
	float expectedAngle) {
	MjSceneImportSettings.AnglesInDegrees = useDegrees;
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("axisangle", $"1 0 0 {MjAngle}");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	var expectedRotation = Quaternion.AngleAxis(expectedAngle, Vector3.right);
	Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
	// Assert.That(
	// _rootObject.transform.rotation,
	// Is.EqualTo(Quaternion.AngleAxis(expectedAngle, Vector3.right))
	// .Using(_quaternionComparer));
	}

	[TestCase(true, 0, 45, 0, 0, 0, -45)]
	[TestCase(false, 0, 0.785398f, 0, 0, 0, -45)]
	[TestCase(true, 0, 0, 45, 0, 45, 0)]
	[TestCase(false, 0, 0, 0.785398f, 0, 45, 0)]
	[TestCase(true, 45, 0, 0, 45, 0, 0)]
	[TestCase(false, 0.785398f, 0, 0, 45, 0, 0)]
	public void ParseRotationFromEuler(bool useDegrees, float mx, float my, float mz, float ex,
	float ey, float ez) {
	MjSceneImportSettings.AnglesInDegrees = useDegrees;
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("euler", $"{mx} {my} {mz}");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	var expectedRotation = Quaternion.Euler(ex, ey, ez);
	Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
	// Assert.That(
	// _rootObject.transform.rotation,
	// Is.EqualTo(Quaternion.Euler(ex, ey, ez))
	// .Using(_quaternionComparer));
	}

	[Test]
	public void ParseRotationFromDirectionVector() {
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("fromto", $"0 0 0 1 1 0");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	var expectedRotation = new Quaternion(0.5f, 0, -0.5f, 0.7071068f);
	Assert.That(_rootObject.transform.rotation.x, Is.EqualTo(expectedRotation.x).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.y, Is.EqualTo(expectedRotation.y).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.z, Is.EqualTo(expectedRotation.z).Within(1e-5f));
	Assert.That(_rootObject.transform.rotation.w, Is.EqualTo(expectedRotation.w).Within(1e-5f));
	// Assert.That(
	// _rootObject.transform.rotation,
	// Is.EqualTo(new Quaternion(0.5f, 0, -0.5f, 0.7071068f))
	// .Using(_quaternionComparer));
	}

	[Test]
	public void ParsePositionFromDirectionVector() {
	var mjcf = new XmlDocument().CreateElement("element");
	mjcf.SetAttribute("fromto", $"1 2 3 5 7 9");
	MjEngineTool.ParseTransformMjcf(mjcf, _rootObject.transform);
	Assert.That(_rootObject.transform.position, Is.EqualTo(new Vector3(3, 6, 4.5f)));
	}
	}
	}