private void Start()
{
outCurve = new SplineCurve();
inCurve = new SplineCurve();
centerCurve = new SplineCurve();
positions = new List <Vector3>();
}
public CurveSegement(Node _startNode, Node _endNode, SplineCurve _rootCurve)
{
startNode = _startNode;
endNode = _endNode;
rootCurve = _rootCurve;
c = -5f;
}
public void Start()
{
if (Path.IsCurved)
{
_splineCurve = new SplineCurve();
UpdateCurvePoints();
}
}
private Vector2[] GetDivededPoints(int ind)
{
var points = new Vector2[11];
var pointInd = 0;
var indexes = GetSplinePointIndexes(ind, true);
Vector2 a = paths[indexes[0]].transform.position;
Vector2 b = paths[indexes[1]].transform.position;
Vector2 c = paths[indexes[2]].transform.position;
Vector2 d = paths[indexes[3]].transform.position;
for (float t = 0; t <= 1.001f; t += 0.1f)
{
points[pointInd++] = SplineCurve.GetPoint(a, b, c, d, t);
}
return(points);
}
public override void Init()
{
outCurve = new SplineCurve();
inCurve = new SplineCurve();
centerCurve = new SplineCurve();
positions = new List <Vector3>();
GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cube);
meshFilter = obj.GetComponent <MeshFilter>();
obj.GetComponent <MeshRenderer>().material.color = Color.cyan;
GameObject.CreatePrimitive(PrimitiveType.Plane).transform.localScale = new Vector3(50, 1, 50);
Camera.main.transform.position = new Vector3(-118, 179, -115);
Camera.main.transform.localEulerAngles = new Vector3(60, 45, 0);
}
public void CreateNode(SplineComponent splineComponent)
{
GameObject controlPoint = new GameObject("ControlPoint");
// Add the splineComponent component
controlPoint.AddComponent <ControlPointComponent>();
SplineCurve splineCurve = splineComponent.GetSplineObject();
Vector3 targetPosition = Vector3.one;
Vector3[] controlPoints = splineCurve.controlPoints;
int cpLength = controlPoints.Length;
int controlPointsPerSegment = splineComponent.GetControlPointsPerSegment();
if (cpLength >= controlPointsPerSegment)
{
// extrapolate the position from the last two points
targetPosition = controlPoints[cpLength - 1] + (controlPoints[cpLength - 1] - controlPoints[cpLength - controlPointsPerSegment]);
}
controlPoint.transform.position = targetPosition;
controlPoint.transform.parent = splineComponent.transform;
}
private void CalculateNewBeam(ref Transform endPointBeam)
{
//sets the collider to the new pos on the z axis, and obtains its x pos to be used later.
Vector3 newPos = endPointBeam.localPosition;
newPos.z = newBeamEndPoint + Vector3.Dot(this.transform.GetChild(this.transform.childCount - 1).position, -this.transform.forward);
newPos.y = 0;
endPointBeam.position = newPos;
//for this spline implementation last two are always end point, first two are always start point, sub all in the middle for average values between the two
SplineCurve lightCurve = this.transform.GetChild(this.transform.childCount - 1).GetComponent <SplineCurve>();
int totalControlPoints = lightCurve.controlPoints.Count;
Vector3 startPoint = lightCurve.controlPoints[0];
List <Vector3> midPoints = new List <Vector3>();
Vector3 endPoint = endPointBeam.position;
//only the difference in the z axis is required, zeroing out the x axis is, therfore, important to keep things consistant, no matter where this object is placed, spawned.
endPoint.x = 0;
//new middle points cal, finds the amount required, based on the amount of control points that exist on that lightbeam
float middlePoints = (totalControlPoints - 4);
//finds the average number based on the amount of control points needed
Vector3 difference = endPoint - startPoint;
difference = (difference / middlePoints) / 2.0f;
for (int i = 2; i < middlePoints + 2; i++)
{
midPoints.Add(difference * (i - 1));
}
//destroys old default lightbeam, and creates a new one, with custom points
lineBeam.ToggleBeam();
lineBeam.ToggleCustomBeam(startPoint, midPoints, endPoint);
}
public void DoUpdateSpline()
{
List <Vector3> controlPoints = new List <Vector3>();
List <Vector3> tangents = new List <Vector3>();
List <float> time = new List <float>();
float lastTime = 0;
for (int i = 0; i < transform.childCount; i++)
{
ControlPointComponent controlPointComp = transform.GetChild(i).gameObject.GetComponent <ControlPointComponent>();
if (controlPointComp != null)
{
controlPoints.Add(controlPointComp.position);
tangents.Add(controlPointComp.tangent);
// if illegal time detected, then autoadjust
if (lastTime >= controlPointComp.time)
{
controlPointComp.time += lastTime + 1;
}
lastTime = controlPointComp.time;
time.Add(controlPointComp.time);
}
}
switch (splineType)
{
case SplineType.LinearSpline: {
LinearSplineCurve lSpline = new LinearSplineCurve();
spline = lSpline;
spline.lengthPrecision = lengthPrecision;
lSpline.Init(controlPoints.ToArray(), time.ToArray());
}
break;
case SplineType.CatmullRom: {
HermiteSplineCurve hSpline = new HermiteSplineCurve();
spline = hSpline;
spline.lengthPrecision = lengthPrecision;
hSpline.InitCatmullRom(controlPoints.ToArray());
}
break;
case SplineType.BezierSpline:
case SplineType.BezierSmoothSpline:
BezierSplineCurve bSpline = new BezierSplineCurve();
spline = bSpline;
spline.lengthPrecision = lengthPrecision;
switch (splineType)
{
case SplineType.BezierSpline:
bSpline.Init(controlPoints.ToArray());
break;
case SplineType.BezierSmoothSpline:
bSpline.InitSmoothTangents(controlPoints.ToArray());
break;
}
break;
}
// hack to make the editor update the obejct
Vector3 p = transform.position;
transform.position = Vector3.zero;
if (p.sqrMagnitude > 0)
{
transform.position = p;
}
updated = true;
}
public override void OnUpdate()
{
MouseLeft();
// 路面创建测试
if (Input.GetKeyDown(KeyCode.K))
{
List <Vector3> points_out = new List <Vector3>();
List <Vector3> points_in = new List <Vector3>();
Vector3 dirr;
dirr = PhysicsMath.GetHorizontalDir(positions[1] - positions[0]);
points_in.Add(positions[0] + dirr * 4);
points_out.Add(positions[0] - dirr * 4);
for (int i = 1; i < positions.Count - 1; i++)
{
dirr = PhysicsMath.GetHorizontalDir(positions[i + 1] - positions[i - 1]);
points_in.Add(positions[i] + dirr * 4);
points_out.Add(positions[i] - dirr * 4);
}
dirr = PhysicsMath.GetHorizontalDir(positions[positions.Count - 1] - positions[positions.Count - 2]);
points_in.Add(positions[positions.Count - 1] + dirr * 4);
points_out.Add(positions[positions.Count - 1] - dirr * 4);
for (int i = 0; i < positions.Count; i++)
{
outCurve.AddNode(points_out[i], c);
inCurve.AddNode(points_in[i], c);
centerCurve.AddNode(positions[i], c);
}
outCurve.AddCatmull_RomControl();
inCurve.AddCatmull_RomControl();
centerCurve.AddCatmull_RomControl();
for (int i = 0; i < outCurve.segmentList.Count; i++)
{
float add = 1f / 20;
for (float j = 0; j < 1; j += add)
{
Vector3 point = centerCurve.segmentList[i].GetPoint(j);
path.Add(point);
objs.Add(Utility.CreatPrimitiveType(PrimitiveType.Sphere, Color.red, point, 1));
//point = outCurve.segmentList[i].GetPoint(j);
//path.Add(point);
//objs.Add(Utility.CreatPrimitiveType(PrimitiveType.Sphere, point, 1, Color.red));
//point = inCurve.segmentList[i].GetPoint(j);
//path.Add(point);
//objs.Add(Utility.CreatPrimitiveType(PrimitiveType.Sphere, point, 1, Color.red));
}
}
CreateRoads(Terrain.activeTerrain, meshFilter, path, 6);
}
if (Input.GetKeyDown(KeyCode.C))
{
meshFilter.mesh.Clear();
objs.ForEach((a) => { Object.Destroy(a); });
objs.Clear();
outCurve = new SplineCurve();
inCurve = new SplineCurve();
centerCurve = new SplineCurve();
positions.Clear();
path.Clear();
}
if (Input.GetKeyDown(KeyCode.J))
{
hit = Utility.SendRay(LayerMask.GetMask("Terrain"));
}
// 刷新地图
if (Input.GetKeyDown(KeyCode.L))
{
//TerrainUtility.Refresh();
}
}
