/// <summary>
/// Create the mesh of legs
/// </summary>
private void BakeLegsMesh()
{
//Reduces the amount of points in LineRenderer
currentLineRenderer.Simplify(0.05f);
//Create the mesh of legs
currentLineRenderer.BakeMesh(wheelRight.mesh, cam, true);
currentLineRenderer.BakeMesh(wheelLeft.mesh, cam, true);
}
public static void SetMeshCollider(GameObject line)
{
LineRenderer lineRenderer = line.GetComponent <LineRenderer>();
MeshCollider meshCollider;
if (line.GetComponentInChildren <MeshCollider>() == null)
{
GameObject child = new GameObject("child");
child.transform.position = line.transform.position;
child.transform.SetParent(line.transform);
meshCollider = child.AddComponent <MeshCollider>();
}
else
{
meshCollider = line.GetComponentInChildren <MeshCollider>();
}
Mesh mesh = new Mesh();
try
{
lineRenderer.BakeMesh(mesh, true);
}
catch (System.Exception)
{
}
finally
{
meshCollider.sharedMesh = mesh;
}
}
public Mesh GetMesh()
{
var mesh = new Mesh();
line.BakeMesh(mesh);
return(mesh);
}
private void DrawMesh()
{
var mesh = new Mesh();
_lineRenderer.BakeMesh(mesh);
_meshCollider.sharedMesh = mesh;
}
public void generateCar()
{
transformPointsToZero();
mesh = new Mesh();
lineRenderer.BakeMesh(mesh, true);
GetComponent <MeshCollider>().sharedMesh = mesh;
GetComponent <MeshFilter>().mesh = mesh;
placeWheels();
RespawnCoordinate = findMidPoint();
newDrawnSpawn();
GetComponent <MeshCollider>().convex = true;
MeshCollider colMesh = gameObject.AddComponent <MeshCollider>();
colMesh.sharedMesh = mesh;
colMesh.convex = true;
colMesh.isTrigger = true;
_gm.setLine(this);
rigidBody.isKinematic = false;
isObjectActivated = true;
}
void CreateLineRendererMesh()
{
Mesh mesh = new Mesh();
lRenderer.BakeMesh(mesh, mainCamera, true);
GetComponent <MeshCollider>().sharedMesh = mesh;
}
private void SetMesh()
{
Mesh trajectoryMesh = new Mesh();
_lineRenderer.BakeMesh(trajectoryMesh);
_meshCollider.sharedMesh = trajectoryMesh;
}
// Funcion para creación de GameObject con LineRenderer para unir figuras erróneas.
void SpawnLineGeneratorWrong()
{
GameObject myLineWrong = new GameObject();
transLr = GetComponent <Transform>();
myLineWrong.tag = "FrameLineWrong";
myLineWrong.name = "FrameLineWrong";
myLineWrong.AddComponent <LineRenderer>();
lr = myLineWrong.GetComponent <LineRenderer>();
lr.useWorldSpace = false;
lr.startWidth = 0.1f;
lr.endWidth = 0.1f;
lr.SetPosition(0, start);
lr.SetPosition(1, finish);
lr.sortingLayerName = "Line";
lr.material = wrongColor;
Mesh lineMesh = new Mesh();
lr.BakeMesh(lineMesh);
MeshCollider meshCollider = myLineWrong.gameObject.AddComponent <MeshCollider>();
meshCollider.sharedMesh = lineMesh;
allLines.Add(myLineWrong);
myLineWrong.transform.position = new Vector3(transform.position.x, transform.position.y, -0.5f);
myLineWrong.transform.position = new Vector3(transform.position.x, transform.position.y, 1);
wrongSound.Play(0);
score = score - 100;
}
public void Bake()
{
_rawLength = Vector3.Distance(_lineRenderer.GetPosition(0), _lineRenderer.GetPosition(1));
_lineRenderer.BakeMesh(_mesh, true);
_meshCollider.sharedMesh = _mesh;
_isDirty = false;
}
// Start is called before the first frame update
void Awake()
{
MeshCollider m = gameObject.AddComponent <MeshCollider>();
Mesh mesh = new Mesh();
l.BakeMesh(mesh, c, true);
m.sharedMesh = mesh;
}
public void update(Vector2 input_pos, Vector2 output_pos, bool is_on_new)
{
update_position(input_pos, output_pos);
update_colour(is_on_new);
temp_mesh = new Mesh();
rend.BakeMesh(temp_mesh, false);
meshColl.sharedMesh = temp_mesh;
}
// Start is called before the first frame update
private void Start()
{
// Заполняем опорное точки
corners = new Vector3[this.transform.childCount];
for (var i = 0; i < corners.Length; i++)
{
GameObject obj = transform.GetChild(i).gameObject;
corners[i] = obj.transform.position;
//отключение отрисовки объекта/
obj.GetComponent <MeshRenderer>().enabled = false;
}
//настраиваем Line Renderer
m_lineRenderer.positionCount = corners.Length;
m_lineRenderer.SetPositions(corners);
//сгенерировать всех соседей в одном сегменте
//проверять только массив соседей
//запекаем меш сетку из Line Renderer
Mesh mesh = new Mesh();
m_lineRenderer.BakeMesh(mesh, true);
//создаем массив сегментов трассы
//(каждый треугольник описан 3-мя точками из массива вершин)
segments = new TrackSegment[mesh.triangles.Length / 3];
//каждую итерацию цикла проходим через каждый треий элемент
for (int i = 0; i < mesh.triangles.Length; i += 3)
{
segments[segmentCounter] = new TrackSegment();
segments[segmentCounter].Points = new Vector3[3];
//в первую точку записываем вершину первого индекса из массива вершин
segments[segmentCounter].Points[0] = mesh.vertices[mesh.triangles[i]];
segments[segmentCounter].Points[1] = mesh.vertices[mesh.triangles[i + 1]];
segments[segmentCounter].Points[2] = mesh.vertices[mesh.triangles[i + 2]];
segmentCounter++;
}
//отдельно можно продебажить сегменты
if (!m_Debug)
{
return;
}
foreach (var segment in segments)
{
foreach (var point in segment.Points)
{
GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.transform.position = point;
sphere.transform.localScale = Vector3.one * 0.1f;
}
}
}
// Start is called before the first frame update
void Start()
{
LineRenderer lineRenderer = transform.GetComponent <LineRenderer>();
MeshCollider meshCollider = transform.gameObject.AddComponent <MeshCollider>();
Mesh mesh = new Mesh();
lineRenderer.BakeMesh(mesh, true);
meshCollider.sharedMesh = mesh;
}
public GameObject CreateLeg(Leg leg, LineRenderer lineRenderer, float zOffset)
{
GameObject legObj = Instantiate(LegPrefab);
lineRenderer.BakeMesh(legObj.GetComponent <MeshFilter>().mesh, true);
MeshCollider meshCollider = legObj.GetComponent <MeshCollider>();
meshCollider.sharedMesh = legObj.GetComponent <MeshFilter>().mesh;
float MaxLineY = 0;
float MinLineY = 1000f;
for (int i = 0; i < lineRenderer.positionCount - 1; i++)
{
MinLineY = Mathf.Min(MinLineY, lineRenderer.GetPosition(i).y);
}
for (int k = 0; k < lineRenderer.positionCount - 1; k++)
{
MaxLineY = Mathf.Max(MaxLineY, lineRenderer.GetPosition(k).y);
}
float lineHeight = MaxLineY - MinLineY;
float playerHeight = this.transform.position.y - FloorOffset.y;
float upCharacterSize = lineHeight - playerHeight;
if (upCharacterSize > 0f)
{
this.transform.SetPositionAndRotation(new Vector3(this.transform.position.x, this.transform.position.y + upCharacterSize, this.transform.position.z), this.transform.rotation);
}
Vector3 legPos = new Vector3();
switch (leg)
{
case Leg.Left:
legPos.x = -lineRenderer.GetPosition(lineRenderer.positionCount - 1).x + transform.position.x;
legPos.y = -lineRenderer.GetPosition(lineRenderer.positionCount - 1).y + transform.position.y;
legPos.z = LeftLegPosition.position.z;
legObj.transform.SetParent(LeftLegPosition);
legPos.z += zOffset;
break;
case Leg.Right:
legPos.x = -lineRenderer.GetPosition(0).x + transform.position.x;
legPos.y = -lineRenderer.GetPosition(0).y + transform.position.y;
legPos.z = RightLegPosition.position.z;
legObj.transform.SetParent(RightLegPosition);
legPos.z += zOffset;
break;
}
legObj.transform.position = legPos;
legObj.GetComponent <MeshRenderer>().material = Mat_Line;
Legs.Add(legObj);
return(legObj);
}
// Start is called before the first frame update
void Start()
{
//заполняем массив опорных точек трассы
corners = new Vector3[transform.childCount];
for (int i = 0; i < corners.Length; i++)
{
GameObject obj = transform.GetChild(i).gameObject;
corners[i] = obj.transform.position;
obj.GetComponent <MeshRenderer>().enabled = false;
}
//задаём значения linerenderer
m_lineRenderer.positionCount = corners.Length;
m_lineRenderer.SetPositions(corners);
//из полученного LineRenderer запекаем mesh
Mesh mesh = new Mesh();
m_lineRenderer.BakeMesh(mesh, true);
//создаём массив сегментов трассы
//каждый треугольник уписываем треугольниками из массива вершин
segments = new TrackSegment[mesh.triangles.Length / 3];
int segmentsCounter = 0;
for (int i = 0; i < mesh.triangles.Length; i += 3)
{
segments[segmentsCounter] = new TrackSegment();
segments[segmentsCounter].points = new Vector3[3];
int nm = mesh.triangles[i];
segments[segmentsCounter].points[0] = mesh.vertices[nm];
nm = mesh.triangles[i + 1];
segments[segmentsCounter].points[1] = mesh.vertices[nm];
nm = mesh.triangles[i + 2];
segments[segmentsCounter].points[2] = mesh.vertices[nm];
segmentsCounter++;
}
if (!m_viewDebug)
{
return;
}
else
{
foreach (var segment in segments)
{
foreach (var point in segment.points)
{
GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.transform.position = point;
sphere.transform.localScale = Vector3.one * 0.1f;
}
}
}
}
public GameObject CreateGenericLineAgent(Agent agent, float lineWidth, string tagName, float zPosition, bool groupBySpecies, bool withMesh)
{
GameObject newObject = new GameObject(agent.AgentName);
var meshFilter = newObject.AddComponent <MeshFilter>();
LineRenderer line = newObject.AddComponent <LineRenderer>();
line.useWorldSpace = true;
line.positionCount = agent.AgentCoordinate.GetVector3Coordinates().Length;
line.SetPositions(agent.AgentCoordinate.GetVector3Coordinates());
//line.positionCount = agent.agentCoordinate.getVector2Coordinates().Length / 2;
line.material = lineMaterial;
line.startWidth = lineWidth;
line.endWidth = lineWidth;
if (withMesh)
{
Mesh mesh = new Mesh();
var meshRenderer = newObject.AddComponent <MeshRenderer>();
meshRenderer.sharedMaterial = lineMaterial;
Material mat = new Material(Shader.Find("Specular"))
{
color = Color.red
};
meshRenderer.sharedMaterial = mat;
//LineRenderer line = (LineRenderer)newObject.GetComponent(typeof(LineRenderer));
line.BakeMesh(mesh);
meshFilter.sharedMesh = mesh;
Destroy(line);
}
RectTransform rt = newObject.AddComponent <RectTransform>(); //(newObject.AddComponent<RectTransform>()).GetComponent<RectTransform>();
rt.SetParent(SceneManager.worldEnveloppeRT);
rt.anchorMin = SceneManager.AnchorMin;
rt.anchorMax = SceneManager.AnchorMax;
rt.pivot = SceneManager.Pivot;
rt.anchoredPosition = new Vector3(0, 0, 0);
Vector3 p = rt.localPosition;
rt.localPosition = new Vector3(p.x, p.y, zPosition);
SetAgentTag(newObject, tagName);
if (groupBySpecies)
{
SetObjectSpecies(newObject, agent.Species);
}
AddAgentToContexte(agent.Species, newObject);
return(newObject);
}
public GameObject CreateLine(GameObject startObject, GameObject endObject) // draws a line betwen the center of 2 game objects
{
Vector2 startPosition = startObject.transform.position;
Vector2 endPosition = endObject.transform.position;
Vector2 offset = (endPosition - startPosition);
GameObject currentLine = Instantiate <GameObject>(linePrefab);
currentLine.transform.position = Vector2.zero;
LineRenderer lr = currentLine.GetComponent <LineRenderer>();
LineType lineProperties = currentLine.GetComponent <LineType>();
lineProperties.lineValue = startObject.GetComponent <ConnectionControl>().lineValue;
lineProperties.startNode = startObject;
lineProperties.endNode = endObject;
//break line into 3 segments if certain conditions are met (Condition currently not active, it auto breaks lines into segments.)
if (startPosition.x < endPosition.x || (startPosition.x > endPosition.x && startObject.tag == "Input Node"))
{
Vector2 tempEnd1 = new Vector2(Random.Range(startPosition.x + offset.x / 6.0f, startPosition.x + offset.x / 2.0f), startPosition.y);
Vector2 tempEnd2 = new Vector2(tempEnd1.x, endPosition.y);
Vector3[] positions = GetPosArray(startPosition, tempEnd1, tempEnd2, endPosition);
lr.positionCount = positions.Length;
lr.SetPositions(positions);
}
else if (startPosition.x > endPosition.x) //first click x position is higher than the second click x position, the line should be broken into 5 segments(6 points)
{
Vector2 tempEnd1 = new Vector2(startPosition.x + Random.Range(0.5f, 1.5f), startPosition.y);
Vector2 tempEnd2 = new Vector2(tempEnd1.x, startPosition.y + (endPosition.y - startPosition.y) / Random.Range(2f, 4f));
Vector2 tempEnd3 = new Vector2(endPosition.x - Random.Range(0.5f, 1.5f), tempEnd2.y);
Vector2 tempEnd4 = new Vector2(tempEnd3.x, endPosition.y);
Vector3[] positions = GetPosArray(startPosition, tempEnd1, tempEnd2, tempEnd3, tempEnd4, endPosition);
lr.positionCount = positions.Length;
lr.SetPositions(positions);
}
//Create a mesh collider to be able to interact with the linerenderer for deletion
MeshCollider mesh = currentLine.AddComponent <MeshCollider>();
Mesh m = new Mesh();
lr.BakeMesh(m, true);
mesh.sharedMesh = m;
return(currentLine.gameObject);
}
private void UpdateMesh(int id)
{
Mesh mesh = new Mesh();
lineRenderer = PhotonView.Find(id).gameObject.GetComponent <LineRenderer>();
lineRenderer.BakeMesh(mesh, Camera.main, true);
meshCollider = PhotonView.Find(id).gameObject.GetComponent <MeshCollider>();
meshCollider.sharedMesh = mesh;
}
// Start is called before the first frame update
private void Start()
{
// fill corners array
corners = new Vector3[transform.childCount];
for (int i = 0; i < corners.Length; i++)
{
GameObject obj = transform.GetChild(i).gameObject;
corners[i] = obj.transform.position;
obj.GetComponent <MeshRenderer>().enabled = false;
}
//Line Renderer settings
m_lineRenderer.positionCount = corners.Length;
m_lineRenderer.SetPositions(corners);
// Line Renderer mesh
Mesh mesh = new Mesh();
m_lineRenderer.BakeMesh(mesh, true);
//array of track segments
segments = new TrackSegment[mesh.triangles.Length / 3];
int segmentCounter = 0;
for (int i = 0; i < mesh.triangles.Length; i += 3)
{
segments[segmentCounter] = new TrackSegment();
segments[segmentCounter].Points = new Vector3[3];
segments[segmentCounter].Points[0] = mesh.vertices[mesh.triangles[i]];
segments[segmentCounter].Points[1] = mesh.vertices[mesh.triangles[i + 1]];
segments[segmentCounter].Points[2] = mesh.vertices[mesh.triangles[i + 2]];
segmentCounter++;
}
CreateNewCheckpoint();
//segments debug
if (!m_debug)
{
return;
}
foreach (var segment in segments)
{
foreach (var point in segment.Points)
{
GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.transform.position = point;
sphere.transform.localScale = Vector3.one * 0.1f;
}
}
}
public void GenerateCurves()
{
List <float> cos = new List <float>();
List <float> sin = new List <float>();
for (float i = 0; i < 2 * Mathf.PI; i += 0.1f)
{
cos.Add(Mathf.Cos(i) * 10);
sin.Add(Mathf.Sin(i) * 10);
}
List <Vector3> curvesX = new List <Vector3>();
List <Vector3> curvesY = new List <Vector3>();
List <Vector3> curvesZ = new List <Vector3>();
for (int j = 0; j < cos.Count; j++)
{
curvesX.Add(new Vector3(0, sin[j], cos[j]));
curvesY.Add(new Vector3(sin[j], 0, cos[j]));
curvesZ.Add(new Vector3(sin[j], cos[j], 0));
}
LineRenderer lineX = xCurve.GetComponent <LineRenderer>();
LineRenderer lineY = yCurve.GetComponent <LineRenderer>();
LineRenderer lineZ = zCurve.GetComponent <LineRenderer>();
lineX.SetPositions(curvesX.ToArray());
lineX.positionCount = curvesX.Count;
lineY.SetPositions(curvesY.ToArray());
lineY.positionCount = curvesY.Count;
lineZ.SetPositions(curvesZ.ToArray());
lineZ.positionCount = curvesZ.Count;
Mesh meshX = new Mesh();
lineX.BakeMesh(meshX);
Mesh meshY = new Mesh();
lineY.BakeMesh(meshY);
Mesh meshZ = new Mesh();
lineZ.BakeMesh(meshZ);
lineX.GetComponent <MeshCollider>().sharedMesh = meshX;
lineY.GetComponent <MeshCollider>().sharedMesh = meshY;
lineZ.GetComponent <MeshCollider>().sharedMesh = meshZ;
}
public void DrawMesh()
{
Init();
Vector3[] vertices = new Vector3[points.Count];
vertices = points.ToArray();
Mesh mesh = new Mesh();
line.BakeMesh(mesh);
mesh.RecalculateNormals();
filter.sharedMesh = mesh;
}
void Start()
{
//GetComponent<LineRenderer>().material.color = new Color(0f, 0f, 0f, 0f);
linerenderer = GetComponent <LineRenderer>();
linerenderer.enabled = false;
meshcollider = GetComponent <MeshCollider>();
Mesh mesh = new Mesh();
linerenderer.BakeMesh(mesh, true);
meshcollider.sharedMesh = mesh;
}
public void CreateLineAgent(Agent agent, Transform parentTransform, Material mat, int speciesId, bool elevate, float lineWidth, string tagName, float zPosition)
{
GameObject newObject = new GameObject(agent.AgentName);
newObject.GetComponent <Transform>().SetParent(parentTransform);
var meshFilter = newObject.AddComponent <MeshFilter>();
LineRenderer line = newObject.AddComponent <LineRenderer>();
Mesh mesh = new Mesh();
var meshRenderer = newObject.AddComponent <MeshRenderer>();
meshRenderer.sharedMaterial = lineMaterial;
meshRenderer.sharedMaterial = mat;
//LineRenderer line = (LineRenderer)newObject.GetComponent(typeof(LineRenderer));
line.useWorldSpace = true;
line.positionCount = agent.AgentCoordinate.GetVector3Coordinates().Length;
line.SetPositions(agent.AgentCoordinate.GetVector3Coordinates());
//line.positionCount = agent.agentCoordinate.getVector2Coordinates().Length / 2;
line.material = lineMaterial;
line.startWidth = lineWidth;
line.endWidth = lineWidth;
line.BakeMesh(mesh);
meshFilter.sharedMesh = mesh;
RectTransform rt = newObject.AddComponent <RectTransform>(); //(newObject.AddComponent<RectTransform>()).GetComponent<RectTransform>();
rt.anchorMin = SceneManager.AnchorMin;
rt.anchorMax = SceneManager.AnchorMax;
rt.pivot = SceneManager.Pivot;
rt.anchoredPosition = new Vector3(0, 0, 0);
Vector3 p = rt.localPosition;
rt.localPosition = new Vector3(p.x, p.y, zPosition);
SetAgentTag(newObject, tagName);
SetObjectSpecies(newObject, agent.Species);
Destroy(line);
}
// Update is called once per frame
void Update()
{
UpdatePosition();
foreach (MeshRenderer mr in gameObject.transform.GetComponentsInChildren <MeshRenderer>())
{
mr.enabled = info.show;
}
line.enabled = info.show;
// create line mesh collider
Mesh mesh = new Mesh();
line.BakeMesh(mesh, true);
line.gameObject.GetComponent <MeshCollider>().sharedMesh = mesh;
// Dead
CheckDeath();
// Kill
CheckKill();
}
private void Update()
{
if (!_drawCam.pixelRect.Contains(Input.mousePosition))
{
return;
}
if (Input.GetMouseButtonDown(0))
{
Reset();
}
if (Input.GetMouseButton(0))
{
var mousePos = _drawCam.ScreenToWorldPoint(Input.mousePosition);
mousePos.z = 0;
if (!points.Contains(mousePos))
{
points.Add(mousePos);
lineRenderer.positionCount = points.Count;
drawLineRenderer.positionCount = points.Count;
var pos = mousePos - _drawCam.transform.position;
pos.z = 0;
lineRenderer.SetPosition(lineRenderer.positionCount - 1, pos);
drawLineRenderer.SetPosition(drawLineRenderer.positionCount - 1, mousePos);
}
}
if (Input.GetMouseButtonUp(0))
{
_meshFilter.transform.parent.rotation = Quaternion.identity;
Mesh _mesh = new Mesh();
lineRenderer.BakeMesh(_mesh);
_meshFilter.sharedMesh = _mesh;
Vector3[] positions = new Vector3[lineRenderer.positionCount];
lineRenderer.GetPositions(positions);
_edgeCollider.points = positions.ToVector2Array();
_movementController.SetHingePositions(GetCorrectPos(points[0]), GetCorrectPos(points[points.Count - 1]));
}
}
/// <summary>
/// Called when hovering over middle buttons
/// </summary>
/// <param name="col"></param>
public void SetNode(Collider col)
{
// change color
col.GetComponent <SpriteRenderer>().color = activeColor;
// disable collider to avoid selecting node twice
col.enabled = false;
// set the position of line renderer vertice
lr.SetPosition(nextPosition, col.transform.position);
// increment position count
lr.positionCount++;
// set next position as previous position - default is Vector3.zero - a white line is seen for a fraction of a second otherwise
lr.SetPosition(nextPosition + 1, lr.GetPosition(nextPosition));
// update mesh collider for line renderer with new line
Mesh mesh = new Mesh();
lr.BakeMesh(mesh, true);
meshCollider.sharedMesh = mesh;
// increment next position
nextPosition++;
}
void Update()
{
_LineRenderer.useWorldSpace = false;
_LineRenderer.loop = GetSpline().SplineLoop();
_LineRenderer.startWidth = _Width;
_LineRenderer.positionCount = 0;
_LineRenderer.colorGradient = _VertexColor;
if (_Spline.GetPointCount() > 0)
{
var P = 0f;
var start = GetSpline().GetNonUniformPoint(0f);
Vector3 _FirstPoint = start;
_FirstPoint = transform.InverseTransformPoint(_FirstPoint);
_LineRenderer.positionCount++;
_LineRenderer.SetPosition(_LineRenderer.positionCount - 1, _FirstPoint);
var step = 1f / resolution;
do
{
_LineRenderer.positionCount++;
P += step;
var here = GetSpline().GetNonUniformPoint(P);
here = transform.InverseTransformPoint(here);
_LineRenderer.SetPosition(_LineRenderer.positionCount - 1, here);
start = here;
} while (P + step <= 1);
}
if (_BakedMesh == null)
{
_BakedMesh = new Mesh();
}
_LineRenderer.BakeMesh(_BakedMesh, false);
}
private void CreateInkCollider(LineRenderer lineRenderer)
{
var colliderInstance = VRCInstantiate(colliderPrefab.gameObject);
colliderInstance.name = "InkCollider";
colliderInstance.transform.SetParent(lineInstance.transform);
colliderInstance.transform.position = Vector3.zero;
colliderInstance.transform.rotation = Quaternion.identity;
colliderInstance.transform.localScale = Vector3.one;
var meshCollider = colliderInstance.GetComponent <MeshCollider>();
var mesh = new Mesh();
var widthMultiplier = lineRenderer.widthMultiplier;
lineRenderer.widthMultiplier = inkWidth;
lineRenderer.BakeMesh(mesh);
lineRenderer.widthMultiplier = widthMultiplier;
meshCollider.sharedMesh = mesh;
colliderInstance.SetActive(true);
}
//Draws new road and turns it in to a mesh
protected virtual void DrawNewRoad(string name, float size, int sortOrder)
{
GameObject newLine = new GameObject(name);
//newLine.AddComponent<BitmapReader>();
//Line renderer
newLine.transform.position = this.transform.position;
LineRenderer nlr = newLine.AddComponent <LineRenderer>();
MeshFilter mf = newLine.AddComponent <MeshFilter>();
MeshRenderer mr = newLine.AddComponent <MeshRenderer>();
nlr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
nlr.material = Mat;
Mat.color = roadColor;
nlr.positionCount = 2;
nlr.SetPosition(0, this.transform.position);
nlr.SetPosition(1, debugPos);
nlr.startWidth = size;
nlr.endWidth = size;
Mesh m = new Mesh();
m.Clear();
nlr.BakeMesh(m, settings.renderCamera, true);
mf.mesh = m;
Bounds carBounds = mf.mesh.bounds;
Vector3 whereYouWantMe = this.transform.position;
Vector3 offset = newLine.transform.position - newLine.transform.TransformPoint(this.transform.position);
newLine.transform.position = whereYouWantMe + offset;
mr.material = Mat;
nlr.sortingOrder = sortOrder;
debugPos = this.transform.position;
newLine.transform.parent = settings.transform;
newLine.tag = "Height";
Destroy(nlr);
}
private void Update()
{
if (refreshTime <= 0)
{
refreshTime = 0.5f; //half second
}
else
{
refreshTime -= Time.deltaTime;
return;
}
float resolution = 0.1f;
int segments = Mathf.FloorToInt(1f / resolution);
//sort points
controlPointsList.Sort((m1, m2) => m1.pointId.CompareTo(m2.pointId));
Vector3 trackUp = Vector3.up;
if (controlPointsList.Count > 0)
{
trackUp = controlPointsList[0].transform.up;
}
//generate points from the markers
positions = new Vector3[controlPointsList.Count * segments];
int elem = 0;
if (controlPointsList.Count >= 4)
{
for (int i = 0; i < controlPointsList.Count; i++)
{
//catmull algorithm: 4 points
Vector3 p0 = controlPointsList[ClampListPos(i - 1)].transform.position;
Vector3 p1 = controlPointsList[i].transform.position;
Vector3 p2 = controlPointsList[ClampListPos(i + 1)].transform.position;
Vector3 p3 = controlPointsList[ClampListPos(i + 2)].transform.position;
int startElem = elem;
for (int j = 1; j <= segments; j++)
{
//Which t position are we at?
float t = j * resolution;
//Find the coordinate between the end points with a Catmull-Rom spline
Vector3 newPos = GetCatmullRomPosition(t, p0, p1, p2, p3);
//align to the first
if (i > 0)
{
newPos = Vector3.ProjectOnPlane(newPos - positions[0], trackUp) + positions[0];
}
positions[elem] = newPos;
elem++;
}
//muovi la barra sul punto della pista
Transform child = controlPointsList[i].transform.GetChild(0);
child.position = positions[startElem];
}
}
//orienta i target intermedi
for (int i = 0; i < controlPointsList.Count; i++)
{
int startElem = i * segments;
Transform child;
if (positions.Length > 1)
{
//ottieni il punto precedente
int idx1 = startElem - 1;
if (idx1 < 0)
{
idx1 = positions.Length - 1;
}
//ottieni il punto successivo
int idx2 = (startElem + 1) % positions.Length;
//orienta usando il punto precedente e il successivo
Quaternion rot = Quaternion.LookRotation((positions[idx2] - positions[idx1]).normalized, trackUp);
child = controlPointsList[i].transform.GetChild(0);
child.rotation = rot;
}
}
if (positions.Length > 2)
{
//sposta la bandiera d'arrivo nel punto corretto e la orienta
goal.position = positions[0];
goal.rotation = Quaternion.LookRotation((positions[positions.Length - 1] - positions[1]).normalized, trackUp);
}
//align the spline direction to the first marker
lr.positionCount = positions.Length;
lr.SetPositions(positions);
if (controlPointsList.Count > 0)
{
transform.forward = -trackUp;
colliderChild.transform.rotation = Quaternion.identity;
//plane.position = controlPointsList[0].transform.position - controlPointsList[0].transform.up * 0.1f;
//plane.rotation = controlPointsList[0].transform.rotation;
}
//bake a collision mesh
lr.BakeMesh(mesh, true);
meshCollider.sharedMesh = mesh;
}
