Saran Tunyasuvunakool
3577e2cf8b
PiperOrigin-RevId: 434731612 Change-Id: I0cfda3e7a3d1c72036764986efc252ffa1b8c6b0
175 lines
8.2 KiB
C#
175 lines
8.2 KiB
C#
// 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.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using NUnit.Framework;
|
|
using UnityEngine;
|
|
using UnityEngine.TestTools.Utils;
|
|
|
|
namespace Mujoco {
|
|
|
|
[TestFixture]
|
|
public class MeshGeneratorsEditorTests {
|
|
[Test]
|
|
public void FirstAndLastVerticalSlicesContainVerticesLocatedInTheSamePlace() {
|
|
var meshData = MeshGenerators.BuildSphere(scale: Vector3.one, numVerticalSlices: 4,
|
|
numHorizontalSlices: 3);
|
|
var vertices = meshData.Item1;
|
|
Assert.That(vertices[0], Is.EqualTo(vertices[1]));
|
|
Assert.That(vertices[1], Is.EqualTo(vertices[2]));
|
|
Assert.That(vertices[2], Is.EqualTo(vertices[3]));
|
|
Assert.That(vertices[8], Is.EqualTo(vertices[9]));
|
|
Assert.That(vertices[9], Is.EqualTo(vertices[10]));
|
|
Assert.That(vertices[10], Is.EqualTo(vertices[11]));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedSphereWithProperScaling() {
|
|
var scale = new Vector3(0.5f, 2, 3);
|
|
var meshData =
|
|
MeshGenerators.BuildSphere(scale: scale, numVerticalSlices: 4, numHorizontalSlices: 3);
|
|
var vertices = meshData.Item1;
|
|
// One of the vertices of the bottom cap.
|
|
Assert.That(vertices[0], Is.EqualTo(Vector3.down * scale.y).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
// One of the vertices of the top cap.
|
|
Assert.That(vertices[8], Is.EqualTo(Vector3.up * scale.y).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
// The sides.
|
|
Assert.That(vertices[4], Is.EqualTo(Vector3.right * scale.x).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
Assert.That(vertices[5], Is.EqualTo(Vector3.back * scale.z).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
Assert.That(vertices[6], Is.EqualTo(Vector3.left * scale.x).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
Assert.That(vertices[7],
|
|
Is.EqualTo(Vector3.forward * scale.z).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedCylinderHasCorrectHeight() {
|
|
var meshData = MeshGenerators.BuildCylinder(radius: 1.0f, height: 5.0f, numVerticalSlices: 4);
|
|
var bottomVertex =
|
|
meshData.Item1.Aggregate((result, item) => result.y < item.y ? result : item);
|
|
var topVertex = meshData.Item1.Aggregate((result, item) => result.y > item.y ? result : item);
|
|
Assert.That(topVertex.y - bottomVertex.y, Is.EqualTo(5.0f).Within(1e-3f));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedCylinderHasCorrectRadius() {
|
|
var meshData = MeshGenerators.BuildCylinder(radius: 2.0f, height: 1.0f, numVerticalSlices: 4);
|
|
var averageRadius =
|
|
meshData.Item1.Select(v => new Vector3(v.x, 0, v.z).magnitude).Average(radius => radius);
|
|
Assert.That(averageRadius, Is.EqualTo(2.0f).Within(1e-3f));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedCapsuleHasCorrectHeight() {
|
|
var meshData = MeshGenerators.BuildCapsule(radius: 1.0f, height: 5.0f, numVerticalSlices: 4,
|
|
numHorizontalSlices: 3);
|
|
var bottomVertex =
|
|
meshData.Item1.Aggregate((result, item) => result.y < item.y ? result : item);
|
|
var topVertex = meshData.Item1.Aggregate((result, item) => result.y > item.y ? result : item);
|
|
// The height of the capsule is the height of the body plus the diameter of the sphere that
|
|
// forms the bases.
|
|
Assert.That(topVertex.y - bottomVertex.y, Is.EqualTo(5.0f).Within(1e-3f));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedCapsuleHasCorrectRadius() {
|
|
var meshData = MeshGenerators.BuildCapsule(radius: 2.0f, height: 3.0f, numVerticalSlices: 4,
|
|
numHorizontalSlices: 3);
|
|
var averageRadius = meshData.Item1.Where(v => Math.Abs(v.y) <= 0.5f)
|
|
.Select(v => new Vector3(v.x, 0, v.z).magnitude)
|
|
.Average(radius => radius);
|
|
Assert.That(averageRadius, Is.EqualTo(2.0f).Within(1e-3f));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedBoxHasCorrectExtents() {
|
|
var extents = new Vector3(0.5f, 2, 3);
|
|
var meshData = MeshGenerators.BuildBox(extents: extents);
|
|
var minVertex = meshData.Item1.Aggregate(
|
|
(result, item) =>
|
|
(result.x + result.y + result.z) < (item.x + item.y + item.z) ? result : item);
|
|
var maxVertex = meshData.Item1.Aggregate(
|
|
(result, item) =>
|
|
(result.x + result.y + result.z) > (item.x + item.y + item.z) ? result : item);
|
|
Assert.That(minVertex, Is.EqualTo(extents * -1.0f).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
Assert.That(maxVertex, Is.EqualTo(extents).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedBoxTriangleMapIsAListOfConsecutiveIntegers() {
|
|
var meshData = MeshGenerators.BuildBox(extents: Vector3.one);
|
|
Assert.That(meshData.Item2, Has.Length.EqualTo(36));
|
|
for (var i = 0; i < 36; ++i) {
|
|
Assert.That(meshData.Item2[i], Is.EqualTo(i));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GeneratedPlaneHasCorrectExtents() {
|
|
var meshData = MeshGenerators.BuildPlane(width: 2, height: 3);
|
|
var minVertex = meshData.Item1.Aggregate(
|
|
(result, item) => (result.x + result.z) < (item.x + item.z) ? result : item);
|
|
var maxVertex = meshData.Item1.Aggregate(
|
|
(result, item) => (result.x + result.z) > (item.x + item.z) ? result : item);
|
|
Assert.That(minVertex, Is.EqualTo(new Vector3(-1, 0, -1.5f)).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
Assert.That(maxVertex, Is.EqualTo(new Vector3(1, 0, 1.5f)).Using(Vector3ComparerWithEqualsOperator.Instance));
|
|
}
|
|
}
|
|
|
|
[TestFixture]
|
|
public class MeshMergerEditorTests {
|
|
private MeshMerger _meshMerger;
|
|
|
|
[SetUp]
|
|
public void SetUp() {
|
|
_meshMerger = new MeshMerger();
|
|
}
|
|
|
|
[Test]
|
|
public void AddingMeshVerticesAggregatesThem() {
|
|
_meshMerger.Add(vertices: new Vector3[] { Vector3.one }, triangles: new int[] {});
|
|
Assert.That(_meshMerger.Vertices, Has.Length.EqualTo(1));
|
|
_meshMerger.Add(vertices: new Vector3[] { Vector3.forward }, triangles: new int[] {});
|
|
Assert.That(_meshMerger.Vertices, Has.Length.EqualTo(2));
|
|
Assert.That(_meshMerger.Vertices[0], Is.EqualTo(Vector3.one));
|
|
Assert.That(_meshMerger.Vertices[1], Is.EqualTo(Vector3.forward));
|
|
}
|
|
|
|
[Test]
|
|
public void TriangleIndicesAreOffsetToPointAtTheCorrespondingMeshes() {
|
|
_meshMerger.Add(vertices: new Vector3[] { Vector3.right, Vector3.up },
|
|
triangles: new int[] { 0, 1 });
|
|
_meshMerger.Add(vertices: new Vector3[] { Vector3.forward, Vector3.zero },
|
|
triangles: new int[] { 0, 1 });
|
|
Assert.That(_meshMerger.Triangles, Has.Length.EqualTo(4));
|
|
Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[0]], Is.EqualTo(Vector3.right));
|
|
Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[1]], Is.EqualTo(Vector3.up));
|
|
Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[2]], Is.EqualTo(Vector3.forward));
|
|
Assert.That(_meshMerger.Vertices[_meshMerger.Triangles[3]], Is.EqualTo(Vector3.zero));
|
|
}
|
|
|
|
[Test]
|
|
public void TranslatingAddedVertices() {
|
|
_meshMerger.AddAndTranslate(vertices: new Vector3[] { Vector3.zero }, triangles: new int[] {},
|
|
translation: Vector3.right);
|
|
_meshMerger.AddAndTranslate(vertices: new Vector3[] { Vector3.zero }, triangles: new int[] {},
|
|
translation: Vector3.up);
|
|
Assert.That(_meshMerger.Vertices[0], Is.EqualTo(Vector3.right));
|
|
Assert.That(_meshMerger.Vertices[1], Is.EqualTo(Vector3.up));
|
|
}
|
|
}
|
|
}
|