public static void AnimationType(SPData SPData, Follower follower)
{
var flipDir = (follower.FlipDirection == Switch.On) ? true : false;
flipDir = (follower._FollowerAnimation == FollowerAnimation.Auto) ? false : flipDir;
follower.DistanceData = DistanceDataClass.DataExtraction(SPData, follower, follower.IsForward, flipDir);
if (follower._FollowerAnimation == FollowerAnimation.Keyboard)
{
KeyboardAnimationType(SPData, follower);
}
else
{
AutoAnimated(follower);
}
//transform assign
TransformFollower(follower);
if (DistanceCheck(SPData, follower))
{
var delta = follower.Distance - SPData.Length;
follower.Distance = delta;
}
}
public void UpdateBaseAlignement(DMBranch dMBranch, Branch branch, float spacing, int tiling, int dMBranchIndex)
{
var prefabMesh = dMBranch.PrefabMeshes[dMBranchIndex];
var temp = (GameObject)Instantiate(prefabMesh.Prefab, transform.position, Quaternion.identity);
var maxtiling = (int)(branch.BranchDistance / spacing);
maxtiling = (prefabMesh.Mirror) ? maxtiling * 2 : maxtiling;
// tiling = Mathf.Clamp(tiling, 0, maxtiling + 1);
prefabMesh.LayerCombineInstances = new CombineInstance[tiling];
float placement = prefabMesh.Placement;
var alignementAxis = new Vector3();
if (prefabMesh._Axis == Axes.X)
{
alignementAxis = Vector3.right;
}
else if (prefabMesh._Axis == Axes.Y)
{
alignementAxis = Vector3.up;
}
else if (prefabMesh._Axis == Axes.Z)
{
alignementAxis = Vector3.forward;
}
for (int i = 0; i < tiling; i++)
{
var rSpacing = (prefabMesh.RandomSpacing) ? Mathf.Lerp(0, spacing, prefabMesh.RandomWeights[i].z) : 0;
int t = (prefabMesh.Mirror) ? i / 2 : i;
var distanceData = DistanceDataClass.DataExtraction(branch, ((spacing * t) + rSpacing + placement));
temp.transform.position = transform.TransformPoint(distanceData.Position);
if (prefabMesh.LockRot)
{
temp.transform.rotation = distanceData.Rotation;
}
else
{
temp.transform.rotation = distanceData.Rotation * Quaternion.LookRotation(alignementAxis);
}
TransformMesh(temp, dMBranch, dMBranchIndex, i);
prefabMesh.LayerCombineInstances[i].mesh = temp.GetComponent <MeshFilter>().sharedMesh;
prefabMesh.LayerCombineInstances[i].transform = transform.worldToLocalMatrix * temp.transform.localToWorldMatrix;
}
var finalMesh = new Mesh();
finalMesh.CombineMeshes(prefabMesh.LayerCombineInstances, true);
MonoBehaviour.DestroyImmediate(temp);
}
Mesh MeshDeformation(Mesh mesh, Branch branch, DMBranch dMBranch, PrefabMesh prefabMesh, int n)
{
var newVertices = new Vector3[mesh.vertices.Length];
float verDistOnAxis = 0;
Vector3 VerPosOnAxis = Vector3.zero;
for (int i = 0; i < newVertices.Length; i++)
{
verDistOnAxis = dMBranch.PrefabMeshes[n].VerticesPosition[i].z;
VerPosOnAxis = dMBranch.PrefabMeshes[n].VerticesPosition[i];
if (prefabMesh._MeshTrim == MeshTrim.Both)
{
VerPosOnAxis.z = 0;
}
else if (prefabMesh._MeshTrim == MeshTrim.Left)
{
if (verDistOnAxis > 0)
{
VerPosOnAxis.z = 0;
}
}
else if (prefabMesh._MeshTrim == MeshTrim.Right)
{
if (verDistOnAxis < branch.BranchDistance)
{
VerPosOnAxis.z = 0;
}
if (verDistOnAxis > branch.BranchDistance)
{
VerPosOnAxis.z -= branch.BranchDistance;
}
}
else
{
if (verDistOnAxis > 0 && verDistOnAxis < branch.BranchDistance)
{
VerPosOnAxis.z = 0;
}
if (verDistOnAxis > branch.BranchDistance)
{
VerPosOnAxis.z -= branch.BranchDistance;
}
}
var distanceData = DistanceDataClass.DataExtraction(branch, verDistOnAxis);
newVertices[i] = (distanceData.Rotation * VerPosOnAxis) + distanceData.Position;
}
mesh.vertices = newVertices;
return(mesh);
}
public static void TransformFollower(SPData SPData, data data)
{
data.wagon.DistanceData = DistanceDataClass.DataExtraction(SPData, data.train, data.wagon);
//transform assign
data.wagon.FollowerGO.transform.position = data.wagon.DistanceData.Position;
if (data.wagon.Trans)
{
data.wagon.FollowerGO.transform.Translate(data.wagon.Position);
}
data.wagon.FollowerGO.transform.rotation = (data.wagon.Rot) ? data.wagon.DistanceData.Rotation : Quaternion.Euler(data.wagon.Rotation);
}
public void TransformFollower(SPData SPData, Follower follower)
{
follower.DistanceData = DistanceDataClass.DataExtraction(SPData, follower);
//transform assign
follower.FollowerGO.transform.position = follower.DistanceData.Position;
if (follower.Trans)
{
follower.FollowerGO.transform.Translate(follower.Position);
}
follower.FollowerGO.transform.rotation = (follower.Rot) ? follower.DistanceData.Rotation : Quaternion.Euler(follower.Rotation);
if (follower.PathFollowingType == PathFollowingType.Projected)
{
FollowerProjection(SPData, follower);
}
}
public void EditingFunctions(SPData SPData)
{
Event e = Event.current;
if (e == null)
{
return;
}
if (Camera.current.transform.eulerAngles == new Vector3(0, 0, 0) || Camera.current.transform.eulerAngles == new Vector3(0, 180, 0))
{
m_Plane = new Plane(Vector3.forward, Vector3.zero);
}
else if (Camera.current.transform.eulerAngles == new Vector3(90, 0, 0) || Camera.current.transform.eulerAngles == new Vector3(270, 0, 0))
{
m_Plane = new Plane(Vector3.up, Vector3.zero);
}
else if (Camera.current.transform.eulerAngles == new Vector3(0, 90, 0) || Camera.current.transform.eulerAngles == new Vector3(0, 270, 0))
{
m_Plane = new Plane(Vector3.right, Vector3.zero);
}
else
{
m_Plane = new Plane(Vector3.up, Vector3.zero);
}
//if (e.type == EventType.keyDown && e.keyCode == KeyCode.X)
if (e.shift)
{
SPData.EditSpline = true;
if (SPData.DictBranches.Count == 0)
{
Branch branch = new Branch();
SPData.DictBranches.Add(SPData.BranchesCount, branch);
SPData.Selections._BranchKey = SPData.BranchesCount;
SPData.Selections._BranchIndex = SPData.DictBranches.Count - 1;
SPData.BranchesCount++;
//rearange followers branches
for (int i = 0; i < SPData.Followers.Count; i++)
{
if (!SPData.DictBranches.ContainsKey(SPData.Followers[i]._BranchKey))
{
SPData.Followers[i]._BranchKey = SPData.DictBranches.Keys.FirstOrDefault();
}
}
}
}
if (e.type == EventType.MouseDown && e.button == 1)
{
SPData.Selections._PathPoint = new Node();
SPData.EditSpline = false;
}
if (!SPData.EditSpline && !SPData.SmoothData.SmoothNode)
{
SelectPoint(SPData);
}
if (SPData.EditSpline)
{
SceneView.currentDrawingSceneView.Repaint();
if (SPData.DictBranches.Count == 0)
{
return;
}
int n = 0;
float distance = 0.0f;
ray = HandleUtility.GUIPointToWorldRay(e.mousePosition);
var branch = SPData.DictBranches[SPData.Selections._BranchKey];
if (e.shift && (branch.Nodes.Count >= 2)) //Adding path points in the midlle
{
if (EditorWindow.focusedWindow == null || EditorWindow.focusedWindow.titleContent.text != "Scene")
{
return;
}
var sceneViewSize = EditorWindow.focusedWindow.position;
var t = Mathf.InverseLerp(sceneViewSize.y * 0.8f, (sceneViewSize.y + sceneViewSize.height) * 0.8f, e.mousePosition.y);
var p = Mathf.Lerp(0, branch.VertexDistance[branch.VertexDistance.Count - 1], t);
var distanceData = DistanceDataClass.DataExtraction(branch, p);
for (int i = 0; i < branch.Nodes.Count; i++)
{
if (Vector3.Distance(distanceData.Position, branch.Nodes[i].Point.position) <= 0.4f)
{
EditorGUIUtility.AddCursorRect(Camera.current.pixelRect, MouseCursor.ArrowMinus);
Handles.color = Color.red;
Handles.SphereHandleCap(0, branch.Nodes[i].Point.position, Quaternion.identity, SPData.SharedSettings.GizmosSize * 2, EventType.Repaint);
if (e.type == EventType.MouseDown && e.button == 0)
{
DeletePoint(SPData, branch.Nodes[i], i);
}
return;
}
}
var v = Mathf.InverseLerp(0, branch.Vertices.Count - 1, distanceData.Index);
n = (int)Mathf.Lerp(0, SPData.IsLooped ? branch.Nodes.Count : branch.Nodes.Count - 1, v);
Handles.color = Color.yellow;
Handles.SphereHandleCap(0, distanceData.Position, Quaternion.identity, SPData.SharedSettings.GizmosSize * 2, EventType.Repaint);
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, distanceData.Position, addPathPointPos.Middle, n + 1);
}
}
else
{
//Welding
foreach (var _branch in SPData.DictBranches)
{
for (int r = 0; r < _branch.Value.Nodes.Count; r++)
{
var dist = Vector2.Distance(HandleUtility.WorldToGUIPoint(_branch.Value.Nodes[r].Point.position), e.mousePosition);
if (dist < 10)
{
if (!branch.Nodes.Exists(x => x.Equals(_branch.Value.Nodes[r])))
{
var wTangent1 = _branch.Value.Nodes[r].Point1.position;
var wTangent2 = _branch.Value.Nodes[r].Point2.position;
EditorGUIUtility.AddCursorRect(Camera.current.pixelRect, MouseCursor.Link);
switch (SPData.Selections._BranchWeldState)
{
case BranchWeldState.First:
n = (branch.Nodes.Count - 1);
Preview(SPData, _branch.Value.Nodes[r].Point.position, branch.Nodes[n].Point2.position, wTangent1, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
WeldBranch(SPData, _branch.Value.Nodes[r], n);
}
break;
case BranchWeldState.Last:
n = 0;
Preview(SPData, _branch.Value.Nodes[r].Point.position, branch.Nodes[n].Point1.position, wTangent2, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
WeldBranch(SPData, _branch.Value.Nodes[r], n);
}
break;
case BranchWeldState.none:
var dist1 = Vector3.Distance(hitPoint, branch.Nodes[0].Point.position);
var dist2 = Vector3.Distance(hitPoint, branch.Nodes[branch.Nodes.Count - 1].Point.position);
if (dist1 <= dist2)
{
n = 0;
Preview(SPData, _branch.Value.Nodes[r].Point.position, branch.Nodes[n].Point1.position, wTangent2, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
WeldBranch(SPData, _branch.Value.Nodes[r], n);
}
}
else
{
n = (branch.Nodes.Count - 1);
Preview(SPData, _branch.Value.Nodes[r].Point.position, branch.Nodes[n].Point2.position, wTangent1, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
WeldBranch(SPData, _branch.Value.Nodes[r], n);
}
}
break;
}
return;
}
}
}
}
EditorGUIUtility.AddCursorRect(Camera.current.pixelRect, MouseCursor.ArrowPlus);
// regular path point adding
if (Physics.Raycast(ray, out Hit))
{
hitPoint = Hit.point;
}
else if (m_Plane.Raycast(ray, out distance))
{
hitPoint = ray.GetPoint(distance);
}
else
{
return;
}
if (branch.Nodes.Count == 0) //first branch path points adding
{
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, hitPoint, addPathPointPos.Beginning, 0);
}
return;
}
else if (branch.Nodes.Count == 1) //first branch path points adding
{
n = (branch.Nodes.Count - 1);
Preview(SPData, hitPoint, branch.Nodes[n].Point2.position, Vector3.zero, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, hitPoint, addPathPointPos.End, n);
}
return;
}
if (SPData.Selections._BranchWeldState == BranchWeldState.none)// add path point to both sides
{
var dist1 = Vector3.Distance(hitPoint, branch.Nodes[0].Point.position);
var dist2 = Vector3.Distance(hitPoint, branch.Nodes[branch.Nodes.Count - 1].Point.position);
if (dist1 <= dist2)
{
n = 0;
if (!SPData.IsLooped)
{
Preview(SPData, hitPoint, branch.Nodes[n].Point1.position, Vector3.zero, n);
}
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, hitPoint, addPathPointPos.Beginning, n);
}
}
else
{
n = (branch.Nodes.Count - 1);
if (!SPData.IsLooped)
{
Preview(SPData, hitPoint, branch.Nodes[n].Point2.position, Vector3.zero, n);
}
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, hitPoint, addPathPointPos.End, n);
}
}
}
else if (SPData.Selections._BranchWeldState == BranchWeldState.First)//add path point to the first side
{
n = (branch.Nodes.Count - 1);
Preview(SPData, hitPoint, branch.Nodes[n].Point2.position, Vector3.zero, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, hitPoint, addPathPointPos.End, n);
}
}
else if (SPData.Selections._BranchWeldState == BranchWeldState.Last)// add path point to the last side
{
n = 0;
Preview(SPData, hitPoint, branch.Nodes[n].Point1.position, Vector3.zero, n);
if (e.type == EventType.MouseDown && e.button == 0)
{
AddNewPoint(SPData, hitPoint, addPathPointPos.Beginning, n);
}
}
}
}
}
