static GameObject CreatePrefab()
{
var prefabPath = AssetDatabase.GenerateUniqueAssetPath("Assets/PrefabTest.prefab");
var mesh = ShapeGenerator.CreateShape(ShapeType.Cube);
var prefab = PrefabUtility.SaveAsPrefabAsset(mesh.gameObject, prefabPath);
Assume.That(prefab, Is.Not.Null);
Assume.That(AssetDatabase.GetAssetPath(prefab), Is.EqualTo(prefabPath));
return(prefab);
}
public static void DestroyDeletesMesh()
{
var pb = ShapeGenerator.CreateShape(ShapeType.Cube);
Mesh mesh = pb.GetComponent <MeshFilter>().sharedMesh;
UObject.DestroyImmediate(pb.gameObject);
// IsNull doesn't work due to c#/c++ goofiness
Assert.IsTrue(mesh == null);
}
public void Setup()
{
mesh = ShapeGenerator.CreateShape(ShapeType.Sprite);
face = mesh.faces.First();
verticalEdge = face.edgesInternal[0];
horizontalEdge = face.edgesInternal[1];
// Verify that UVs are actually rotated
Assume.That(face.manualUV, Is.EqualTo(false));
}
public void Setup()
{
CloseWindows <ProBuilderEditor>();
EditorWindow.GetWindow <ProBuilderEditor>();
Assert.That(ProBuilderEditor.instance, Is.Not.Null);
m_PBMesh = ShapeGenerator.CreateShape(ShapeType.Cube);
ProBuilderEditor.selectMode = SelectMode.Vertex;
ProBuilderEditor.SyncEditorToolSelectMode();
Assume.That(ProBuilderEditor.selectMode, Is.EqualTo(SelectMode.Vertex));
Assume.That(typeof(VertexManipulationTool).IsAssignableFrom(ToolManager.activeToolType));
}
public static void DestroyDoesNotDeleteMeshBackByAsset()
{
var pb = ShapeGenerator.CreateShape(ShapeType.Cube);
string path = TestUtility.SaveAssetTemporary <Mesh>(pb.mesh);
Mesh mesh = pb.GetComponent <MeshFilter>().sharedMesh;
UObject.DestroyImmediate(pb.gameObject);
Assert.IsFalse(mesh == null);
AssetDatabase.DeleteAsset(path);
LogAssert.NoUnexpectedReceived();
}
public void Setup()
{
ProBuilderMesh shape1 = ShapeGenerator.CreateShape(ShapeType.Cube);
shape1.transform.position = Vector3.zero - shape1.GetComponent <MeshRenderer>().bounds.center;
selectables = new ProBuilderMesh[]
{
shape1
};
}
public static ProBuilderMesh[] GetBasicShapes()
{
var shapes = Enum.GetValues(typeof(ShapeType)) as ShapeType[];
ProBuilderMesh[] primitives = new ProBuilderMesh[shapes.Length];
for (int i = 0, c = shapes.Length; i < c; i++)
{
primitives[i] = ShapeGenerator.CreateShape(shapes[i]);
primitives[i].GetComponent <MeshFilter>().sharedMesh.name = shapes[i].ToString();
}
return(primitives);
}
public void Setup()
{
// make sure the ProBuilder window is open
if (ProBuilderEditor.instance == null)
{
ProBuilderEditor.MenuOpenWindow();
m_OpenedWindow = true;
}
Assert.That(ProBuilderEditor.instance, Is.Not.Null);
m_PBMesh = ShapeGenerator.CreateShape(ShapeType.Cube);
m_PreviousSelectMode = ProBuilderEditor.selectMode;
ProBuilderEditor.selectMode = SelectMode.Vertex;
}
public void Setup()
{
// make sure the ProBuilder window is open
if (ProBuilderEditor.instance == null)
{
ProBuilderEditor.MenuOpenWindow();
m_OpenedWindow = true;
}
UVEditor.MenuOpenUVEditor();
m_cube = ShapeGenerator.CreateShape(ShapeType.Cube);
UnityEditor.ProBuilder.EditorUtility.InitObject(m_cube);
}
public static void MeshWithTwoMaterials_CreatesTwoSubmeshes()
{
var mesh = ShapeGenerator.CreateShape(ShapeType.Cube);
mesh.renderer.sharedMaterials = new Material[2];
Assert.AreEqual(1, mesh.mesh.subMeshCount);
mesh.faces[0].submeshIndex = 1;
mesh.ToMesh();
Assert.AreEqual(2, mesh.mesh.subMeshCount);
UObject.Destroy(mesh.gameObject);
}
public static void SetFillMode_IsAppliedToMesh([ValueSource("fillModeValues")] AutoUnwrapSettings.Fill fill)
{
var shape = ShapeGenerator.CreateShape(ShapeType.Sprite);
Assume.That(shape, Is.Not.Null);
try
{
var positions = shape.positionsInternal;
// move it off center so that we can be sure fill/scale doesn't change the offset
for (int i = 0; i < shape.vertexCount; i++)
{
var p = positions[i];
p.x *= .7f;
p.z *= .4f;
p.x += 1.5f;
p.z += 1.3f;
positions[i] = p;
}
foreach (var face in shape.faces)
{
AutoUnwrapSettings uv = face.uv;
uv.fill = (AutoUnwrapSettings.Fill)fill;
face.uv = uv;
}
shape.ToMesh();
shape.Refresh();
var name = shape.name + "-Fill(" + fill + ")";
shape.name = name;
#if PB_CREATE_TEST_MESH_TEMPLATES
TestUtility.SaveAssetTemplate(shape.mesh, name);
#endif
Mesh template = TestUtility.GetAssetTemplate <Mesh>(name);
TestUtility.AssertAreEqual(template, shape.mesh, message: name);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
}
finally
{
UnityEngine.Object.DestroyImmediate(shape.gameObject);
}
}
void Setup()
{
camera = new GameObject("Camera", typeof(Camera)).GetComponent <Camera>();
camera.transform.position = new Vector3(.3f, 2.2f, -3f);
ProBuilderMesh shape = ShapeGenerator.CreateShape(ShapeType.Torus);
shape.transform.position = Vector3.zero - shape.GetComponent <MeshRenderer>().bounds.center;
camera.transform.LookAt(shape.transform);
selectables = new ProBuilderMesh[]
{
shape
};
}
public static void CopyReferencesOriginalMesh()
{
var original = ShapeGenerator.CreateShape(ShapeType.Cube);
var copy = UObject.Instantiate(original);
try
{
Assert.AreNotEqual(copy, original, "GameObject references are equal");
Assert.IsTrue(ReferenceEquals(copy.mesh, original.mesh), "Mesh references are equal");
}
finally
{
UObject.DestroyImmediate(original.gameObject);
UObject.DestroyImmediate(copy.gameObject);
}
}
public void Setup()
{
// make sure the ProBuilder window is open
if (ProBuilderEditor.instance == null)
{
ProBuilderEditor.MenuOpenWindow();
}
Assume.That(ProBuilderEditor.instance, Is.Not.Null);
m_PBMesh = ShapeGenerator.CreateShape(ShapeType.Plane);
MeshSelection.SetSelection(m_PBMesh.gameObject);
MeshSelection.OnObjectSelectionChanged();
m_PreviousSelectMode = ProBuilderEditor.selectMode;
ProBuilderEditor.selectMode = SelectMode.Object;
}
public static void CubeSurvivesRoundTrip()
{
var pb = ShapeGenerator.CreateShape(ShapeType.Cube);
try
{
var dup = new GameObject().AddComponent <ProBuilderMesh>();
var importer = new MeshImporter(dup);
importer.Import(pb.gameObject);
dup.ToMesh();
dup.Refresh();
TestUtility.AssertAreEqual(pb.mesh, dup.mesh, message: pb.name);
}
catch
{
UnityEngine.Object.DestroyImmediate(pb.gameObject);
}
}
public static void SubdivideObject_RetainsMaterial()
{
var mesh = ShapeGenerator.CreateShape(ShapeType.Cube);
mesh.facesInternal[0].submeshIndex = 1;
var res = Subdivision.Subdivide(mesh, new[] { mesh.facesInternal[0] });
foreach (var face in res)
{
Assert.AreEqual(1, face.submeshIndex);
}
foreach (var face in mesh.facesInternal.Where(x => !res.Contains(x)))
{
Assert.AreEqual(0, face.submeshIndex);
}
}
public static void Extrude_Face_MultipleTimes_CreatesValidGeometry([ValueSource("shapeTypes")] ShapeType shape)
{
var mesh = ShapeGenerator.CreateShape(shape);
try
{
int initialVertexCount = mesh.vertexCount;
UnityEngine.ProBuilder.Face face = mesh.facesInternal[m_Random.Next(0, mesh.facesInternal.Length)];
mesh.Extrude(new UnityEngine.ProBuilder.Face[] { face }, ExtrudeMethod.FaceNormal, 1f);
mesh.ToMesh();
mesh.Refresh();
LogAssert.NoUnexpectedReceived();
TestUtility.AssertMeshAttributesValid(mesh.mesh);
Assert.AreEqual(initialVertexCount + face.edgesInternal.Length * 4, mesh.vertexCount);
initialVertexCount = mesh.vertexCount;
mesh.Extrude(new UnityEngine.ProBuilder.Face[] { face }, ExtrudeMethod.VertexNormal, 1f);
mesh.ToMesh();
mesh.Refresh();
LogAssert.NoUnexpectedReceived();
TestUtility.AssertMeshAttributesValid(mesh.mesh);
Assert.AreEqual(initialVertexCount + face.edgesInternal.Length * 4, mesh.vertexCount);
initialVertexCount = mesh.vertexCount;
mesh.Extrude(new UnityEngine.ProBuilder.Face[] { face }, ExtrudeMethod.IndividualFaces, 1f);
mesh.ToMesh();
mesh.Refresh();
LogAssert.NoUnexpectedReceived();
TestUtility.AssertMeshAttributesValid(mesh.mesh);
Assert.AreEqual(initialVertexCount + face.edgesInternal.Length * 4, mesh.vertexCount);
}
catch (Exception e)
{
Debug.LogError(e.ToString());
}
finally
{
if (mesh != null)
{
Object.DestroyImmediate(mesh.gameObject);
}
}
}
public static GameObject CreateShape(PBShapeType shapeType)
{
Material defaultMaterial;
//try
//{
// defaultMaterial = BuiltinMaterials.defaultMaterial;
//}
//catch
//{
//}
defaultMaterial = PBBuiltinMaterials.DefaultMaterial;
GameObject shape = ShapeGenerator.CreateShape((ShapeType)shapeType, PivotLocation.Center).gameObject;
Renderer renderer = shape.GetComponent <Renderer>();
renderer.sharedMaterial = defaultMaterial;
return(shape);
}
public static void DestroyWithNoDeleteFlagPreservesMesh()
{
var pb = ShapeGenerator.CreateShape(ShapeType.Cube);
try
{
Mesh mesh = pb.GetComponent <MeshFilter>().sharedMesh;
pb.preserveMeshAssetOnDestroy = true;
UObject.DestroyImmediate(pb.gameObject);
Assert.IsFalse(mesh == null);
}
finally
{
if (pb != null)
{
UObject.DestroyImmediate(pb.gameObject);
}
}
}
public static void FillMode()
{
var fillModes = Enum.GetValues(typeof(AutoUnwrapSettings.Fill));
foreach (var fill in fillModes)
{
var shape = ShapeGenerator.CreateShape(ShapeType.Sprite);
var positions = shape.positionsInternal;
// move it off center so that we can be sure fill/scale doesn't change the offset
for (int i = 0; i < shape.vertexCount; i++)
{
var p = positions[i];
p.x *= .7f;
p.z *= .4f;
p.x += 1.5f;
p.z += 1.3f;
positions[i] = p;
}
foreach (var face in shape.faces)
{
AutoUnwrapSettings uv = face.uv;
uv.fill = (AutoUnwrapSettings.Fill)fill;
face.uv = uv;
}
shape.ToMesh();
shape.Refresh();
var name = shape.name + "-Fill(" + fill + ")";
shape.name = name;
#if PB_CREATE_TEST_MESH_TEMPLATES
TestUtility.SaveAssetTemplate(shape.mesh, name);
#endif
Mesh template = TestUtility.GetAssetTemplate <Mesh>(name);
TestUtility.AssertAreEqual(template, shape.mesh, message: name);
UObject.DestroyImmediate(shape.gameObject);
}
}
// Use this for initialization
protected override void PreStart()
{
if (inputHandler == null)
{
inputHandler = GameObject.FindObjectOfType <InputHandler>();
}
if (inputHandler != null)
{
inputHandler.press += OnStartDraw;
inputHandler.release += OnStopDraw;
inputHandler.move += OnMove;
}
if (this.lineDrawer == null)
{
this.lineDrawer = GameObject.FindObjectOfType <LineDrawer>();
}
ShapeElement prevVertices = GameManager.Instance.GetPreviousShapeVertices();
this.sGen.color = GameManager.Instance._config.Levels[GameManager.Instance.CurrentLevel - 1].shapeColor.Color;
this.sGen.size = GameManager.Instance._config.Levels[GameManager.Instance.CurrentLevel - 1].lineStroke;
this.lineDrawer.color = GameManager.Instance._config.Levels[GameManager.Instance.CurrentLevel - 1].brushColor.Color;
this.lineDrawer.size = GameManager.Instance._config.Levels[GameManager.Instance.CurrentLevel - 1].lineStroke;
this.sGen.drawStartPoint = GameManager.Instance._config.DrawStartPoint;
if (prevVertices == null)
{
shape = sGen.CreateShape(GameManager.Instance.GetCurrentShape());
}
else
{
shape = prevVertices;
}
this.levelNumberText.text = "Poziom " + GameManager.Instance.CurrentLevel + " / " + GameManager.Instance._config.NrOfLevels;
drewThisRound = false;
}
public static void SetOffsetAndRotate_InLocalSpace_IsAppliedToMesh(
[ValueSource("offsetRotationShapes")] ShapeType shape,
[ValueSource("offsetValues")] Vector2 offset,
[ValueSource("rotationValues")] float rotation)
{
var mesh = ShapeGenerator.CreateShape(shape);
Assume.That(mesh, Is.Not.Null);
try
{
foreach (var face in mesh.faces)
{
AutoUnwrapSettings uv = face.uv;
uv.offset += new Vector2(.3f, .5f);
uv.rotation = 35f;
face.uv = uv;
}
mesh.ToMesh();
mesh.Refresh();
TestUtility.AssertMeshAttributesValid(mesh.mesh);
string templateName = shape.ToString() + "offset: " + offset.ToString() + " rotation: " + rotation;
#if PB_CREATE_TEST_MESH_TEMPLATES
TestUtility.SaveAssetTemplate(mesh.mesh, mesh.name);
#endif
Mesh template = TestUtility.GetAssetTemplate <Mesh>(mesh.name);
TestUtility.AssertAreEqual(template, mesh.mesh, message: mesh.name);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
}
finally
{
UnityEngine.Object.DestroyImmediate(mesh.gameObject);
}
}
public static void ImportCube_MatchesDefaultCube()
{
var pb = ShapeGenerator.CreateShape(ShapeType.Cube);
try
{
#pragma warning disable 612
var dup = new GameObject().AddComponent <ProBuilderMesh>();
var importer = new MeshImporter(dup);
importer.Import(pb.gameObject);
#pragma warning restore 612
dup.ToMesh();
dup.Refresh();
TestUtility.AssertAreEqual(pb.mesh, dup.mesh, message: pb.name);
}
catch
{
UnityEngine.Object.DestroyImmediate(pb.gameObject);
}
}
public static void DuplicateMesh_ApplyColor_MatchesTemplate()
{
var cube = ShapeGenerator.CreateShape(ShapeType.Cube);
var dup = UObject.Instantiate(cube.gameObject).GetComponent <ProBuilderMesh>();
dup.SetFaceColor(dup.faces[0], Color.blue);
dup.ToMesh();
dup.Refresh();
#if PB_CREATE_TEST_MESH_TEMPLATES
TestUtility.SaveAssetTemplate(dup.mesh, dup.name);
#endif
var compare = TestUtility.GetAssetTemplate <Mesh>(dup.name);
TestUtility.AssertAreEqual(compare, dup.mesh);
UObject.DestroyImmediate(cube);
UObject.DestroyImmediate(dup);
}
public static GameObject CreateShape(PBShapeType shapeType)
{
Material defaultMaterial;
try
{
//ProBuilder throws exception form Init method line 106 (when trying to initialize preview material)
defaultMaterial = BuiltinMaterials.defaultMaterial;
}
catch
{
}
defaultMaterial = PBBuiltinMaterials.DefaultMaterial;
GameObject shape = ShapeGenerator.CreateShape((ShapeType)shapeType, PivotLocation.Center).gameObject;
Renderer renderer = shape.GetComponent <Renderer>();
renderer.sharedMaterial = defaultMaterial;
return(shape);
}
public static void CollapseToCenter_MatchesTemplate()
{
var cube = ShapeGenerator.CreateShape(ShapeType.Cube);
cube.MergeVertices(new[] { 0, 1 });
cube.ToMesh();
cube.Refresh();
#if PB_CREATE_TEST_MESH_TEMPLATES
TestUtility.SaveAssetTemplate(cube.mesh, cube.name);
#endif
TestUtility.AssertMeshAttributesValid(cube.mesh);
var template = TestUtility.GetAssetTemplate <Mesh>(cube.name);
Assert.IsNotNull(template);
TestUtility.AssertAreEqual(template, cube.mesh);
UnityEngine.Object.DestroyImmediate(cube);
}
public static void FaceMaterialProperty_UpgradesCorrectly()
{
var mesh = ShapeGenerator.CreateShape(ShapeType.Cube);
var meshFormat = typeof(ProBuilderMesh).GetField("m_MeshFormatVersion", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.IsNotNull(meshFormat);
meshFormat.SetValue(mesh, -1);
mesh.renderer.sharedMaterials = new Material[]
{
TestUtility.redMaterial,
TestUtility.greenMaterial,
TestUtility.blueMaterial
};
foreach (var face in mesh.facesInternal)
{
face.submeshIndex = -1;
}
#pragma warning disable 618
mesh.facesInternal[0].material = TestUtility.greenMaterial;
mesh.facesInternal[1].material = TestUtility.blueMaterial;
#pragma warning restore 618
mesh.ToMesh();
Assert.AreEqual(3, mesh.mesh.subMeshCount);
#pragma warning disable 618
foreach (var face in mesh.facesInternal)
{
Assert.IsTrue(face.material == null);
}
#pragma warning restore 618
Assert.AreEqual(1, mesh.facesInternal[0].submeshIndex);
Assert.AreEqual(2, mesh.facesInternal[1].submeshIndex);
UObject.DestroyImmediate(mesh.gameObject);
}
public static void DeleteAllFaces_CreatesValidMesh([ValueSource("shapeTypes")] ShapeType shape)
{
var mesh = ShapeGenerator.CreateShape(shape);
try
{
mesh.DeleteFaces(mesh.facesInternal);
mesh.ToMesh();
mesh.Refresh();
TestUtility.AssertMeshAttributesValid(mesh.mesh);
Assert.AreEqual(mesh.vertexCount, 0);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
}
finally
{
UnityEngine.Object.DestroyImmediate(mesh.gameObject);
}
}
public static void Materials_AreCondensedToSmallestRepresentation()
{
var mesh = ShapeGenerator.CreateShape(ShapeType.Cube);
mesh.renderer.sharedMaterials = new Material[3];
mesh.facesInternal[0].submeshIndex = 0;
mesh.facesInternal[1].submeshIndex = 0;
mesh.facesInternal[2].submeshIndex = 1;
mesh.facesInternal[3].submeshIndex = 1;
mesh.facesInternal[4].submeshIndex = 2;
mesh.facesInternal[5].submeshIndex = 2;
mesh.ToMesh();
Assert.AreEqual(3, mesh.mesh.subMeshCount);
UObject.Destroy(mesh.gameObject);
}
public static void InvalidSubmeshIndex_CreatesValidMesh()
{
var mesh = ShapeGenerator.CreateShape(ShapeType.Cube);
mesh.renderer.sharedMaterials = new Material[2]
{
TestUtility.redMaterial,
TestUtility.blueMaterial
};
// Should map to submesh 0
mesh.facesInternal[0].submeshIndex = -1;
// Should map to submesh 1
mesh.facesInternal[1].submeshIndex = 10;
mesh.ToMesh();
Assert.AreEqual(2, mesh.mesh.subMeshCount);
UObject.Destroy(mesh.gameObject);
}