public static void SaveMeshInPlace(MenuCommand menuCommand)
{
RoadMeshCreator rc = menuCommand.context as RoadMeshCreator;
Mesh m = rc.Mesh;
SaveMesh(m, m.name, false, true);
}
public static void SaveMeshNewInstanceItem(MenuCommand menuCommand)
{
RoadMeshCreator rc = menuCommand.context as RoadMeshCreator;
Mesh m = rc.Mesh;
SaveMesh(m, m.name, true, true);
}
void MeshInitialize()
{
RoadMeshCreator meshCreator = creator.GetComponent <RoadMeshCreator>();
meshCreator.pathCreator = creator.GetComponent <PathCreator>();
meshCreator.roadWidth = this.roadWidth;
meshCreator.ManualPathUpdated();
}
public void createPath()
{
roadPath = new RoadPath(transform.position);
roadSettings = new RoadSettings();
meshCreator = new RoadMeshCreator();
}
// Start is called before the first frame update
void Start()
{
pathcreator = GetComponent <PathCreator>();
meshCreator = GetComponent <RoadMeshCreator>();
pathcreator.bezierPath = new BezierPath(points, false, PathSpace.xy);
pathcreator.bezierPath.ControlPointMode = BezierPath.ControlMode.Automatic;
pathcreator.bezierPath.AutoControlLength = 0.02f;
meshCreator.roadWidth = roadWidth;
meshCreator.CreatePath();
}
public string GenerateCompleteStatus()
{
/* This funciton creates the general status of the map all the players need
* and sends it to them
*
* Mapstatus should contain the following:
*
* 1) The Bezier definition of the track
* 2) The Vertext definition of the walls of the track
* 3) Placement of all the checkpoints
*
*/
MapStatus mapStatus = new MapStatus();
TrackController tc = GameObject.FindObjectOfType <TrackController>();
RoadMeshCreator pst = GameObject.FindObjectOfType <RoadMeshCreator>();
List <Vector3Json> bezierPoints = new List <Vector3Json>();
foreach (Vector3 point in pst.pathCreator.bezierPath.points)
{
bezierPoints.Add(point);
}
mapStatus.bezierPoints = bezierPoints;
mapStatus.roadWidth = pst.roadWidth;
GameObject checkpointHolder = tc.checkpointHolder;
List <Vector3Json> checkPointPos = new List <Vector3Json>();
List <Vector3Json> checkPointRot = new List <Vector3Json>();
Bounds checkPointBound = checkpointHolder.transform.GetChild(0).GetComponent <BoxCollider>().bounds;
for (int i = 0; i < checkpointHolder.transform.childCount; i++)
{
Transform t = checkpointHolder.transform.GetChild(i);
checkPointPos.Add(t.position);
checkPointRot.Add(t.rotation.eulerAngles);
}
mapStatus.checkPointPos = checkPointPos;
mapStatus.checkPointRot = checkPointRot;
mapStatus.checkpointSize = checkPointBound.size;
mapStatus.midpoint = new List <Vector3Json>();
mapStatus.wallLeft = new List <Vector3Json>();
mapStatus.wallRight = new List <Vector3Json>();
mapStatus.roadDirection = new List <Vector3Json>();
VertexPath vertexPath = pst.pathCreator.path;
Vector3[] pathPoints = vertexPath.localPoints;
for (int i = 0; i < vertexPath.localPoints.Length; i++)
{
Vector3 midPoint = pathPoints[i];
Vector3 localRight = Vector3.Cross(Vector3.up, vertexPath.GetTangent(i));
Vector3 vertSideA = vertexPath.GetPoint(i) - localRight * Mathf.Abs(pst.roadWidth);
Vector3 vertSideB = vertexPath.GetPoint(i) + localRight * Mathf.Abs(pst.roadWidth);
mapStatus.midpoint.Add(midPoint);
mapStatus.wallLeft.Add(vertSideA);
mapStatus.wallRight.Add(vertSideB);
mapStatus.roadDirection.Add(vertexPath.GetTangent(i));
}
string mapStatusJson = JsonConvert.SerializeObject(mapStatus);
//Debug.Log(mapStatusJson);
if (debug)
{
for (int i = 1; i < mapStatus.wallLeft.Count; i++)
{
// Left
Vector3 point_l1 = mapStatus.wallRight[i - 1];
Vector3 point_l2 = mapStatus.wallRight[i];
Debug.DrawLine(point_l1, point_l2, Color.red);
// Right
Vector3 point_r1 = mapStatus.wallLeft[i - 1];
Vector3 point_r2 = mapStatus.wallLeft[i];
Debug.DrawLine(point_r1, point_r2, Color.blue);
}
}
return(mapStatusJson);
}
private void drawScene()
{
Handles.color = road.roadSettings.nodeColor;
for (int i = 0; i < road.roadPath.PointsCount; i++)
{
Vector3 updatePos;
if (i % 3 == 0)
{
updatePos = Handles.FreeMoveHandle(road.roadPath[i].Position, Quaternion.identity, road.roadSettings.nodeSize, Vector3.zero, Handles.CylinderHandleCap);
}
else
{
updatePos = Handles.PositionHandle(road.roadPath[i].Position, Quaternion.identity);
}
if (updatePos != road.roadPath[i].Position)
{
Undo.RecordObject(road, "Moved point");
road.roadPath.movePosition(i, updatePos);
}
}
for (int i = 0; i < road.roadPath.SegmentCount; i++)
{
Point[] segment = road.roadPath.getSegment(i);
Handles.color = road.roadSettings.lineColor;
Handles.DrawLine(segment[0].Position, segment[1].Position);
Handles.DrawLine(segment[3].Position, segment[2].Position);
if (road.roadSettings.showCurve)
{
Handles.DrawBezier(segment[0].Position, segment[3].Position, segment[1].Position, segment[2].Position, road.roadSettings.curveColor, null, road.roadSettings.curveWidth);
}
}
if (road.roadSettings.showPoints || road.roadSettings.showPointForwards || road.roadSettings.showPointBinormals ||
road.roadSettings.showPointNormals || road.roadSettings.showVertices || road.roadSettings.showTris ||
road.roadSettings.showMeshNormals || road.roadSettings.showUVs || road.roadSettings.showPathCenter)
{
Point[] roadPoints = road.roadPath.getRoadPathPoints(road.roadSettings.spacing);
Vector3[] forwardDir = road.meshCreator.getPointsForward(roadPoints, road.roadPath.Closed);
Vector3[] binormals = road.meshCreator.getPointsBinormal(forwardDir, Vector3.up);
Vector3[] normals = road.meshCreator.getPointsNormal(forwardDir, binormals, new Vector2(0.0f, 1.0f));
if (road.roadSettings.showPathCenter)
{
Vector3 pathCenter = RoadPath.getCenter(roadPoints);
Handles.Label(pathCenter, "Center:\n" + pathCenter.ToString());
}
if (road.roadSettings.showPoints)
{
Handles.color = road.roadSettings.pathColor;
foreach (Point node in roadPoints)
{
Handles.SphereHandleCap(1, node.Position, Quaternion.identity, road.roadSettings.size, EventType.Repaint);
}
}
if (road.roadSettings.showPathLabels)
{
for (int i = 0; i < roadPoints.Length; i++)
{
Handles.Label(roadPoints[i].Position, i.ToString());
}
}
if (road.roadSettings.showPointForwards)
{
Handles.color = road.roadSettings.nodeForwardColor;
for (int i = 0; i < roadPoints.Length; i++)
{
if (!road.roadPath.Closed && i == roadPoints.Length - 1)
{
break;
}
Handles.ArrowHandleCap(1, roadPoints[i].Position, Quaternion.LookRotation(forwardDir[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
if (road.roadSettings.showPointBinormals)
{
Handles.color = road.roadSettings.nodeBinormalColor;
for (int i = 0; i < roadPoints.Length; i++)
{
if (!road.roadPath.Closed && i == roadPoints.Length - 1)
{
break;
}
Handles.ArrowHandleCap(1, roadPoints[i].Position, Quaternion.LookRotation(binormals[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
if (road.roadSettings.showPointNormals)
{
Handles.color = road.roadSettings.nodeNormalColor;
for (int i = 0; i < roadPoints.Length; i++)
{
if (!road.roadPath.Closed && i == roadPoints.Length - 1)
{
break;
}
Handles.ArrowHandleCap(1, roadPoints[i].Position, Quaternion.LookRotation(normals[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
foreach (DrawableShape shape in road.meshCreator.shapesToRender)
{
Shape renderShape = RoadMeshCreator.enumToShape(shape);
if (road.roadSettings.showVertices || road.roadSettings.showTris || road.roadSettings.showPointNormals || road.roadSettings.showUVs || road.roadSettings.showVertIndices)
{
Vector3[] vertices = road.meshCreator.getMeshVertices(roadPoints, renderShape, shape.offset, Vector3.up, shape.trackCompletion, road.roadPath.Closed);
int[] tris = road.meshCreator.getMeshTris(vertices.Length, renderShape, shape.winding, shape.trackCompletion, road.roadPath.Closed);
if (road.roadSettings.showVertices)
{
Handles.color = road.roadSettings.vertexColor;
foreach (Vector3 vertexPos in vertices)
{
Handles.SphereHandleCap(1, vertexPos, Quaternion.identity, road.roadSettings.size, EventType.Repaint);
}
}
if (road.roadSettings.showVertIndices)
{
for (int i = 0; i < vertices.Length; i++)
{
Handles.Label(vertices[i], i.ToString());
}
}
if (road.roadSettings.showTris)
{
Handles.color = Color.green;
for (int i = 0; i < tris.Length / 3; i++)
{
int index = 3 * i;
Handles.DrawLine(vertices[tris[index]], vertices[tris[index + 1]]);
Handles.DrawLine(vertices[tris[index + 1]], vertices[tris[index + 2]]);
Handles.DrawLine(vertices[tris[index + 2]], vertices[tris[index]]);
}
}
if (road.roadSettings.showMeshNormals)
{
Handles.color = Color.white;
Vector3[] vertexNormals = road.meshCreator.pointToMeshNormals(roadPoints, renderShape, Vector3.up, shape.winding, shape.trackCompletion, road.roadPath.Closed);
for (int i = 0; i < vertexNormals.Length; i++)
{
Handles.ArrowHandleCap(1, vertices[i], Quaternion.LookRotation(vertexNormals[i]), road.roadSettings.nodeArrowSize, EventType.Repaint);
}
}
if (road.roadSettings.showUVs)
{
Vector2[] UVs = road.meshCreator.getMeshUV(vertices.Length, renderShape);
for (int i = 0; i < UVs.Length; i++)
{
Handles.Label(vertices[i], UVs[i].ToString());
}
}
}
}
}
}
// Start is called before the first frame update
void Start()
{
playerPathFollower = player.GetComponent <PathFollower>();
if (create)
{
transforms = new List <Transform>();
pathCreators = new List <PathCreator>();
finalPositions = new List <Vector3>();
roadMeshes = new List <RoadMeshCreator>();
// Get data
string path = "Assets/Data/priceData.csv";
StreamReader reader = new StreamReader(path);
string priceDataRaw = reader.ReadToEnd();
reader.Close();
var priceData = priceDataRaw.Split('\n');
//Transform[] transforms = new Transform[priceData.Length];
float xDistance = 0.0f;
//int curTransform = 0;
foreach (string price in priceData)
{
if (price == "")
{
continue;
}
GameObject tempHusk = GameObject.Instantiate(emptyHusk);
tempHusk.transform.position = new Vector3(xDistance, float.Parse(price) * 3, 0);
transforms.Add(tempHusk.transform);
xDistance += Random.Range(5, 20);
//curTransform++;
}
updateBezier();
// Create bezier paths
// Get 5-10 points and make a path
int last = 0;
int next = 15;
while (last + next < transforms.Count)
{
// Instantiate a PathCreator
GameObject newRoadCreator = GameObject.Instantiate(roadCreator);
PathCreator newPathCreator = newRoadCreator.GetComponent <PathCreator>();
RoadMeshCreator newRoadMeshCreator = newRoadCreator.GetComponent <RoadMeshCreator>();
List <Transform> transformSlice = transforms.GetRange(last, next);
newPathCreator.bezierPath = new BezierPath(transformSlice);
newRoadMeshCreator.updatePath();
finalPositions.Add(transformSlice[transformSlice.Count - 1].position);
pathCreators.Add(newPathCreator);
roadMeshes.Add(newRoadMeshCreator);
last += next;
next = Random.Range(5, 10);
}
}
playerPathFollower.pathCreator = pathCreators[0];
}
private void generatePath()
{
bounds = trackArea.GetComponent <MeshRenderer>().bounds;
List <Vector3> points = new List <Vector3>();
int num_points = Random.Range(Points_min, Points_max);
RoadMeshCreator pst = (RoadMeshCreator)GetComponent <PathSceneTool>();
PathCreator pc = GetComponent <PathCreator>();
for (int i = 0; i < num_points; i++)
{
float size_x = bounds.size.x;
float size_z = bounds.size.z;
float size_y = bounds.size.y;
//print(string.Format("Size X: {0}, Y: {1} Z: {2}", size_x, size_y, size_z));
float x = Random.Range(bounds.center.x - size_x / 2, bounds.center.x + size_x / 2);
float z = Random.Range(bounds.center.z - size_z / 2, bounds.center.z + size_z / 2);
float y = 1;
// I want to use some dumb raycasting so that the Y level always is on top of the terrain
RaycastHit hit;
if (Physics.Raycast(new Vector3(x, 10000, z), Vector3.down, out hit))
{
y = hit.point.y + pst.thickness;
}
//print(string.Format("Point X: {0}, Y: {1} Z: {2}", x, y, z));
Vector3 point = new Vector3(x, y, z);
points.Add(point);
}
trackPath = new BezierPath(points, true, PathSpace.xyz);
trackPath.AutoControlLength = Random.Range(0.1f, 1.0f);
trackPath.IsClosed = true;
/*
* for(int i = 0; i < trackPath.NumPoints; i++)
* {
* Vector3 point = trackPath.GetPoint(i);
* float y = Random.Range(0.0f, 10.0f);
* point.y = y;
* }
*/
trackPath.NotifyPathModified();
pc.bezierPath = trackPath;
pst.TriggerUpdate();
GameObject road = GameObject.Find("Road Mesh Holder");
MeshCollider roadCollider = road.GetComponent <MeshCollider>();
Destroy(roadCollider);
roadCollider = road.AddComponent <MeshCollider>();
MeshFilter roadMesh = road.GetComponent <MeshFilter>();
roadCollider.sharedMesh = roadMesh.mesh;
}
