Usando linhas GL:
Eu recomendaria usar a API GL para desenhar linhas. A espessura da linha sempre será 1px na tela e não há opção para alterá-la. Também não haverá sombras.
As chamadas do método GL são executadas imediatamente, portanto, certifique-se de chamá-las após a câmera já renderizar.
Anexar o script à câmera e usar Camera.OnPostRender () funciona bem para renderização na janela do jogo. Para que eles sejam exibidos no editor, você pode usar o MonoBehaviour.OnDrawGizmos () .
Aqui está o código de barras para desenhar uma linha com a API GL:
public Material lineMat = new Material("Shader \"Lines/Colored Blended\" {" + "SubShader { Pass { " + " Blend SrcAlpha OneMinusSrcAlpha " + " ZWrite Off Cull Off Fog { Mode Off } " + " BindChannels {" + " Bind \"vertex\", vertex Bind \"color\", color }" + "} } }");
void OnPostRender() {
GL.Begin(GL.LINES);
lineMat.SetPass(0);
GL.Color(new Color(0f, 0f, 0f, 1f));
GL.Vertex3(0f, 0f, 0f);
GL.Vertex3(1f, 1f, 1f);
GL.End();
}
Aqui está um script completo que anexa todos os pontos fornecidos ao ponto principal. Existem algumas instruções nos comentários do código para configurá-lo corretamente e sobre o que está acontecendo.
Se estiver com problemas para alterar a cor das linhas de conexão, use um sombreador no material da linha que leve em consideração a cor do vértice, como Unlit/Color.
using UnityEngine;
using System.Collections;
// Put this script on a Camera
public class DrawLines : MonoBehaviour {
// Fill/drag these in from the editor
// Choose the Unlit/Color shader in the Material Settings
// You can change that color, to change the color of the connecting lines
public Material lineMat;
public GameObject mainPoint;
public GameObject[] points;
// Connect all of the `points` to the `mainPoint`
void DrawConnectingLines() {
if(mainPoint && points.Length > 0) {
// Loop through each point to connect to the mainPoint
foreach(GameObject point in points) {
Vector3 mainPointPos = mainPoint.transform.position;
Vector3 pointPos = point.transform.position;
GL.Begin(GL.LINES);
lineMat.SetPass(0);
GL.Color(new Color(lineMat.color.r, lineMat.color.g, lineMat.color.b, lineMat.color.a));
GL.Vertex3(mainPointPos.x, mainPointPos.y, mainPointPos.z);
GL.Vertex3(pointPos.x, pointPos.y, pointPos.z);
GL.End();
}
}
}
// To show the lines in the game window whne it is running
void OnPostRender() {
DrawConnectingLines();
}
// To show the lines in the editor
void OnDrawGizmos() {
DrawConnectingLines();
}
}
Observação adicional sobre sombras: explorei usando um sombreador de geometria para criar sombras, mas como as chamadas GL são executadas imediatamente, elas não estão no pipeline de renderização normal AutoLight.cgince Lighting.cgincnão receberão o ShadowCasterpasse.
Linhas com sombras e raio
Se você precisar alterar a espessura da linha e quiser ter sombras realistas. Basta usar uma malha de cilindro e escalar a altura.
Aqui está um script que fará um cilindro para conectar cada ponto ao ponto principal. Coloque-o em um objeto de jogo vazio e preencha os parâmetros. Ele conterá todos os objetos de conexão extras.
using UnityEngine;
using System.Collections;
public class ConnectPointsWithCylinderMesh : MonoBehaviour {
// Material used for the connecting lines
public Material lineMat;
public float radius = 0.05f;
// Connect all of the `points` to the `mainPoint`
public GameObject mainPoint;
public GameObject[] points;
// Fill in this with the default Unity Cylinder mesh
// We will account for the cylinder pivot/origin being in the middle.
public Mesh cylinderMesh;
GameObject[] ringGameObjects;
// Use this for initialization
void Start () {
this.ringGameObjects = new GameObject[points.Length];
//this.connectingRings = new ProceduralRing[points.Length];
for(int i = 0; i < points.Length; i++) {
// Make a gameobject that we will put the ring on
// And then put it as a child on the gameobject that has this Command and Control script
this.ringGameObjects[i] = new GameObject();
this.ringGameObjects[i].name = "Connecting ring #" + i;
this.ringGameObjects[i].transform.parent = this.gameObject.transform;
// We make a offset gameobject to counteract the default cylindermesh pivot/origin being in the middle
GameObject ringOffsetCylinderMeshObject = new GameObject();
ringOffsetCylinderMeshObject.transform.parent = this.ringGameObjects[i].transform;
// Offset the cylinder so that the pivot/origin is at the bottom in relation to the outer ring gameobject.
ringOffsetCylinderMeshObject.transform.localPosition = new Vector3(0f, 1f, 0f);
// Set the radius
ringOffsetCylinderMeshObject.transform.localScale = new Vector3(radius, 1f, radius);
// Create the the Mesh and renderer to show the connecting ring
MeshFilter ringMesh = ringOffsetCylinderMeshObject.AddComponent<MeshFilter>();
ringMesh.mesh = this.cylinderMesh;
MeshRenderer ringRenderer = ringOffsetCylinderMeshObject.AddComponent<MeshRenderer>();
ringRenderer.material = lineMat;
}
}
// Update is called once per frame
void Update () {
for(int i = 0; i < points.Length; i++) {
// Move the ring to the point
this.ringGameObjects[i].transform.position = this.points[i].transform.position;
// Match the scale to the distance
float cylinderDistance = 0.5f*Vector3.Distance(this.points[i].transform.position, this.mainPoint.transform.position);
this.ringGameObjects[i].transform.localScale = new Vector3(this.ringGameObjects[i].transform.localScale.x, cylinderDistance, this.ringGameObjects[i].transform.localScale.z);
// Make the cylinder look at the main point.
// Since the cylinder is pointing up(y) and the forward is z, we need to offset by 90 degrees.
this.ringGameObjects[i].transform.LookAt(this.mainPoint.transform, Vector3.up);
this.ringGameObjects[i].transform.rotation *= Quaternion.Euler(90, 0, 0);
}
}
}
Linhas com sombras e raio via cubo
Saindo da resposta do @ MadLittleMod , aqui outra versão usando linhas baseadas em cubo ( tris: 12 ) em vez de linhas baseadas em cilindro ( tris: 80 ):
fonte