void UpdateStartExtrudeMesh()
{
MirrorMethod lastMirror = MirrorMethod.None;
if (extrudableMeshes[0] != null)
{
lastMirror = extrudableMeshes[0].mirror;
}
if (_startMesh != null)
{
extrudableMeshes[0] = new ExtrudableMesh(_startMesh, _axis);
}
else if (_middleMeshes.Length > 0)
{
if (_iteration == Iteration.Ordered)
{
extrudableMeshes[0] = new ExtrudableMesh(_middleMeshes[0], _axis);
}
else
{
random = new System.Random(_randomSeed);
extrudableMeshes[0] = new ExtrudableMesh(_middleMeshes[random.Next(_middleMeshes.Length - 1)], _axis);
}
}
if (extrudableMeshes[0] != null)
{
extrudableMeshes[0].mirror = lastMirror;
}
}
void UpdateEndExtrudeMesh()
{
MirrorMethod lastMirror = MirrorMethod.None;
lastMirror = MirrorMethod.None;
if (extrudableMeshes[1] != null)
{
lastMirror = extrudableMeshes[1].mirror;
}
if (_endMesh != null)
{
extrudableMeshes[1] = new ExtrudableMesh(_endMesh, _axis);
}
else if (_middleMeshes.Length > 0)
{
if (_iteration == Iteration.Ordered)
{
extrudableMeshes[1] = new ExtrudableMesh(_middleMeshes[_startMesh != null ? (iterations - 2) % _middleMeshes.Length : (iterations - 1) % _middleMeshes.Length], _axis);
}
else
{
random = new System.Random(_randomSeed);
for (int i = 0; i < iterations - 1; i++)
{
random.Next(_middleMeshes.Length - 1);
}
extrudableMeshes[1] = new ExtrudableMesh(_middleMeshes[random.Next(_middleMeshes.Length - 1)], _axis);
}
}
if (extrudableMeshes[1] != null)
{
extrudableMeshes[1].mirror = lastMirror;
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
ExtrudableMesh ex = target as ExtrudableMesh;
if (GUILayout.Button("Print debug"))
{
var manifold = ex._manifold;
var faceIds = new int[manifold.NumberOfFaces()];
var vertexIds = new int[manifold.NumberOfVertices()];
var halfedgeIds = new int[manifold.NumberOfHalfEdges()];
manifold.GetHMeshIds(vertexIds, halfedgeIds, faceIds);
string res = "";
res += "\nVertexIds: ";
foreach (var vertexId in vertexIds)
{
res += vertexId + ", ";
}
res += "\nFaceids: ";
foreach (var faceId in faceIds)
{
res += faceId + ", ";
}
res += "\nHalfedgeIds: ";
foreach (var halfedgeId in halfedgeIds)
{
res += halfedgeId + ", ";
}
Debug.Log(res);
}
}
public bool RefineMentTest(int halfedge)
{
ExtrudableMesh _extrudableMesh = modellingObject.GetComponentInChildren <ExtrudableMesh>();
Manifold manifold = _extrudableMesh._manifold;
if (manifold.IsHalfedgeInUse(halfedge))
{
int h2 = manifold.GetNextHalfEdge(halfedge);
h2 = manifold.GetNextHalfEdge(h2);
if (manifold.IsHalfedgeInUse(h2))
{
int v1 = _extrudableMesh._manifold.SplitEdge(halfedge);
int v2 = _extrudableMesh._manifold.SplitEdge(h2);
int output = _extrudableMesh._manifold.SplitFaceByEdges(manifold.GetIncidentFace(halfedge), v1, v2);
_extrudableMesh.UpdateMesh();
ControlsManager man = modellingObject.GetComponentInChildren <Controls.ControlsManager>();
man.UpdateControls();
return(true);
}
}
return(false);
}
// Use this for initialization
void Awake()
{
Instance = this;
_extrudableMesh = FindObjectOfType <ExtrudableMesh>();
_controlsManager = FindObjectOfType <ControlsManager>();
undoActions = new List <UndoData>();
_controlsManager.undoReset += OnModelReset;
_controlsManager.undoStartEventHandlers += OnUndoStartAction;
_controlsManager.undoEndEventHandlers += OnUndoEndAction;
UpdateVisuals();
}
private void CreateTSFromExtrudableMesh(ExtrudableMesh source, ref TS_Mesh target)
{
if (target.vertices.Length != source.vertices.Length)
{
target.vertices = new Vector3[source.vertices.Length];
}
if (target.normals.Length != source.normals.Length)
{
target.normals = new Vector3[source.normals.Length];
}
if (target.tangents.Length != source.tangents.Length)
{
target.tangents = new Vector4[source.tangents.Length];
}
if (target.colors.Length != source.colors.Length)
{
target.colors = new Color[source.colors.Length];
}
if (target.uv.Length != source.uv.Length)
{
target.uv = new Vector2[source.uv.Length];
}
source.uv.CopyTo(target.uv, 0);
if (target.uv.Length != target.vertices.Length)
{
Vector2[] newUv = new Vector2[target.vertices.Length];
for (int i = 0; i < target.vertices.Length; i++)
{
if (i < target.uv.Length)
{
newUv[i] = target.uv[i];
}
else
{
newUv[i] = Vector2.zero;
}
}
target.uv = newUv;
}
source.colors.CopyTo(target.colors, 0);
target.subMeshes.Clear();
for (int n = 0; n < source.subMeshes.Count; n++)
{
target.subMeshes.Add(source.subMeshes[n].triangles);
}
}
private void TRS(ExtrudableMesh source, TS_Mesh target, double percent)
{
CreateTSFromExtrudableMesh(source, ref target);
SplineResult splineResult = Evaluate(percent);
Quaternion rhs = Quaternion.identity;
switch (axis)
{
case Axis.X:
rhs = Quaternion.LookRotation(Vector3.right);
break;
case Axis.Y:
rhs = Quaternion.LookRotation(Vector3.up, Vector3.back);
break;
}
ref Matrix4x4 reference = ref vertexMatrix;
public void SetEndMesh(Mesh inputMesh, MirrorMethod mirror = MirrorMethod.None)
{
_endMesh = inputMesh;
if (extrudableMeshes.Count < 2)
{
extrudableMeshes.AddRange(new ExtrudableMesh[2 - extrudableMeshes.Count]);
}
if (_endMesh == null)
{
extrudableMeshes[1] = null;
_hasEndMesh = false;
Rebuild(false);
return;
}
extrudableMeshes[1] = new ExtrudableMesh(_endMesh, _axis);
extrudableMeshes[1].mirror = mirror;
CheckMeshes();
Rebuild(false);
}
public void SetStartMesh(Mesh inputMesh, MirrorMethod mirror = MirrorMethod.None)
{
_startMesh = inputMesh;
if (extrudableMeshes.Count == 0)
{
extrudableMeshes.Add(null);
}
if (_startMesh == null)
{
extrudableMeshes[0] = null;
_hasStartMesh = false;
Rebuild(false);
return;
}
extrudableMeshes[0] = new ExtrudableMesh(_startMesh, _axis);
extrudableMeshes[0].mirror = mirror;
CheckMeshes();
Rebuild(false);
}
/// <summary>
/// Creates the mesh array that will be referenced when extruding the meshes. Elements 0 and 1 are the start and end cap meshes
/// </summary>
void UpdateExtrudableMeshes()
{
iterations = 0;
if (_startMesh != null)
{
iterations++;
}
if (_endMesh != null)
{
iterations++;
}
iterations += (extrudableMeshes.Count - 2) * _repeat;
int targetCount = 2 + _middleMeshes.Length;
if (extrudableMeshes.Count < targetCount)
{
extrudableMeshes.AddRange(new ExtrudableMesh[targetCount - extrudableMeshes.Count]);
}
for (int i = 0; i < _middleMeshes.Length; i++)
{
if (_middleMeshes[i] == null)
{
RemoveMesh(i);
i--;
continue;
}
MirrorMethod lastMirror = MirrorMethod.None;
if (extrudableMeshes[i + 2] != null)
{
lastMirror = extrudableMeshes[i + 2].mirror;
extrudableMeshes[i + 2].Update(_middleMeshes[i], _axis);
}
else
{
extrudableMeshes[i + 2] = new ExtrudableMesh(_middleMeshes[i], _axis);
}
extrudableMeshes[i + 2].mirror = lastMirror;
}
UpdateStartExtrudeMesh();
UpdateEndExtrudeMesh();
}
private void TRS(ExtrudableMesh source, TS_Mesh target, double percent)
{
CreateTSFromExtrudableMesh(source, ref target);
SplineResult result = Evaluate(percent);
Matrix4x4 trsMatrix = new Matrix4x4();
Quaternion axisRotation = Quaternion.identity;
switch (axis)
{
case Axis.X: axisRotation = Quaternion.LookRotation(Vector3.right); break;
case Axis.Y: axisRotation = Quaternion.LookRotation(Vector3.up, Vector3.back); break;
}
trsMatrix.SetTRS(result.position + result.right * offset.x + result.normal * offset.y + result.direction * offset.z, result.rotation * Quaternion.AngleAxis(rotation, Vector3.forward) * axisRotation, new Vector3(_scale.x, _scale.y, 1f) * result.size);
for (int i = 0; i < target.vertexCount; i++)
{
target.vertices[i] = trsMatrix.MultiplyPoint3x4(source.vertices[i]);
target.normals[i] = trsMatrix.MultiplyVector(source.normals[i]);
}
}
private void Stretch(ExtrudableMesh source, TS_Mesh target, double from, double to)
{
CreateTSFromExtrudableMesh(source, ref target);
SplineResult result = new SplineResult();
Vector2 uv = Vector2.zero;
Vector3 trsVector = Vector3.zero;
Matrix4x4 trsMatrix = new Matrix4x4();
Quaternion axisRotation = Quaternion.identity;
switch (axis)
{
case Axis.X: axisRotation = Quaternion.LookRotation(Vector3.left); break;
case Axis.Y: axisRotation = Quaternion.LookRotation(Vector3.up, Vector3.forward); break;
}
for (int i = 0; i < source.vertexGroups.Count; i++)
{
double evalPercent = 0.0;
switch (axis)
{
case Axis.X: evalPercent = DMath.Clamp01(Mathf.InverseLerp(source.bounds.min.x, source.bounds.max.x, source.vertexGroups[i].value)); break;
case Axis.Y: evalPercent = DMath.Clamp01(Mathf.InverseLerp(source.bounds.min.y, source.bounds.max.y, source.vertexGroups[i].value)); break;
case Axis.Z: evalPercent = DMath.Clamp01(Mathf.InverseLerp(source.bounds.min.z, source.bounds.max.z, source.vertexGroups[i].value)); break;
}
if (useLastResult && i == source.vertexGroups.Count)
{
result = lastResult;
}
else
{
Evaluate(result, UnclipPercent(DMath.Lerp(from, to, evalPercent)));
}
trsMatrix.SetTRS(result.position + result.right * offset.x + result.normal * offset.y + result.direction * offset.z, result.rotation * Quaternion.AngleAxis(rotation, Vector3.forward), new Vector3(_scale.x, _scale.y, 1f) * result.size);
if (i == 0)
{
lastResult.CopyFrom(result);
}
for (int n = 0; n < source.vertexGroups[i].ids.Length; n++)
{
int index = source.vertexGroups[i].ids[n];
trsVector = axisRotation * source.vertices[index];
trsVector.z = 0f;
target.vertices[index] = trsMatrix.MultiplyPoint3x4(trsVector);
trsVector = axisRotation * source.normals[index];
target.normals[index] = trsMatrix.MultiplyVector(trsVector);
target.colors[index] = target.colors[index] * result.color;
uv = target.uv[index];
switch (_tileUVs)
{
case TileUVs.U: uv.x = (float)result.percent; break;
case TileUVs.V: uv.y = (float)result.percent; break;
case TileUVs.UniformU: uv.x = CalculateLength(0.0, result.percent); break;
case TileUVs.UniformV: uv.y = CalculateLength(0.0, result.percent); break;
}
target.uv[index] = new Vector2(uv.x * uvScale.x, uv.y * uvScale.y);
target.uv[index] += uvOffset;
}
}
}
/// <summary>
/// Creates the mesh array that will be referenced when extruding the meshes. Elements 0 and 1 are the start and end cap meshes
/// </summary>
void UpdateExtrudableMeshes()
{
iterations = 0;
if (_startMesh != null)
{
iterations++;
}
if (_endMesh != null)
{
iterations++;
}
iterations += (extrudableMeshes.Count - 2) * _repeat;
int targetCount = 2 + _middleMeshes.Length;
if (extrudableMeshes.Count < targetCount)
{
extrudableMeshes.AddRange(new ExtrudableMesh[targetCount - extrudableMeshes.Count]);
}
//If the deprecated sourceMesh is set, then migrate it to the new mesh array
if (_sourceMesh != null)
{
Mesh[] newMeshes = new Mesh[_middleMeshes.Length + 1];
_middleMeshes.CopyTo(newMeshes, 0);
newMeshes[newMeshes.Length - 1] = _sourceMesh;
_middleMeshes = newMeshes;
extrudableMeshes.Add(new ExtrudableMesh(_sourceMesh, _axis));
_sourceMesh = null;
#if UNITY_EDITOR
if (!Application.isPlaying)
{
#if UNITY_5_4_OR_NEWER
UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEngine.SceneManagement.SceneManager.GetActiveScene());
#else
UnityEditor.EditorUtility.SetDirty(gameObject);
#endif
}
#endif
}
for (int i = 0; i < _middleMeshes.Length; i++)
{
if (_middleMeshes[i] == null)
{
RemoveMesh(i);
i--;
continue;
}
MirrorMethod lastMirror = MirrorMethod.None;
if (extrudableMeshes[i + 2] != null)
{
lastMirror = extrudableMeshes[i + 2].mirror;
extrudableMeshes[i + 2].Update(_middleMeshes[i], _axis);
}
else
{
extrudableMeshes[i + 2] = new ExtrudableMesh(_middleMeshes[i], _axis);
}
extrudableMeshes[i + 2].mirror = lastMirror;
}
UpdateStartExtrudeMesh();
UpdateEndExtrudeMesh();
}
public bool RefinementTestLoop(int halfedge1, int halfedge2)
{
if (!ValidateFaceLoop(halfedge1, halfedge2))
{
return(false);
}
ExtrudableMesh _extrudableMesh = modellingObject.GetComponentInChildren <ExtrudableMesh>();
Manifold manifold = _extrudableMesh._manifold;
int h = halfedge1;
int initital_f = manifold.GetIncidentFace(halfedge1);
int f = initital_f;
List <int> faceloop = new List <int>();
List <int> edgeloop = new List <int>();
while (true)
{
if (manifold.IsFaceInUse(f))
{
if (manifold.IsHalfedgeInUse(h))
{
int h2 = manifold.GetNextHalfEdge(h);
h2 = manifold.GetNextHalfEdge(h2);
if (manifold.IsHalfedgeInUse(h2))
{
int w = manifold.SplitEdge(h);
edgeloop.Add(w);
faceloop.Add(f);
h = manifold.GetOppHalfEdge(h2);
f = manifold.GetIncidentFace(h);
if (f == initital_f)
{
int[] farray = faceloop.ToArray();
int[] earray = edgeloop.ToArray();
for (int i = 0; i < farray.Length; i++)
{
if (i == farray.Length - 1)
{
int output = manifold.SplitFaceByEdges(farray[i], earray[i], earray[0]); // earray[1]);
}
else
{
int output = manifold.SplitFaceByEdges(farray[i], earray[i], earray[i + 1]);
}
}
_extrudableMesh.UpdateMesh();
return(true);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
}
