3 ways to draw 3d lines in unity3d_dynamic lines unity3d-CSDN博客

本文链接：https://blog.csdn.net/cubesky/article/details/38754845

本文介绍了在Unity3D中绘制3D线条的三种不同解决方案：使用LineRenderer组件，通过Graphics类创建网格，以及直接使用GL进行绘制。LineRenderer适合静态线，而GL方法在性能上更优但控制度较低。对于动态和大规模线的绘制，Graphics方案在Unity3D Pro中是更好的选择。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Just as I was thinking about an interesting demo to play withdrawing functions in Unity3D,Mrdoob publishedhis Harmony drawingtool made with HTML5/Canvas. It looks really cool, so I though howabout doing this in 3D? I only had to figure out how to drawlines.

I did some research and below Ipresent 3 different solutions. Youcan grab the source of the examples discussedbelow here.

Drawing lines with LineRenderer [demo]

When it comes to lines, the first thing you'll bump into in theUnity3D API is the LineRenderercomponent. As the name suggests, it is used to drawlines so it seems the right tool for the job. Lines in this caseare defined by 2 or more points (segments), a material and awidth.

It has an important limitation: the line must be continuous.So if you need two lines, you need two renderers. The other problemis that the Line Renderer acts very strangely when new points areadded dynamically. The width of the line does not seem to rendercorrectly. It's either buggy or just wasn't designed for suchuse. Because of these limitations I had to create aseparate Line Renderer for each tiny bit of line I'm drawing.

It was easy to implement, but not very fast since I end up spawninglots of GameObjects each with a LineRenderer attached. It seems tobe the only option if you don't have Unity3DProthough.

Drawing lines as a meshusing Graphics [demo]

The Graphics classallows to draw a mesh directly without the overhead of creatinggame objects and components to hold it.It runsmuch faster than Line Renderer, but you need to create thelines yourself. This is a bit more difficult but also gives youtotal control of the lines - their color, material, width andorientation.

Since meshes are composed of surfaces rather than lines or points,in 3D space a line is best rendered as a very thin quad. A quad isdescribed with 4 vertices, and usually you'll only have the startand end points and a width. Based on this data you can compute aline like this:

PLAIN TEXT

C#: 
    
        Vector3 normal = Vector3. 
       Cross 
       (start,end 
       ); 
      
        Vector3 side = Vector3. 
       Cross 
       (normal,end-start 
       ); 
      
        side. 
       Normalize 
       ( 
       ); 
      
        Vector3 a = start + side *  
        
       (lineWidth/  
        
       2 
       ); 
      
        Vector3 b = start + side *  
        
       (lineWidth/ - 
       2 
       ); 
      
        Vector3 c = end + side *  
        
       (lineWidth/  
        
       2 
       ); 
      
        Vector3 d = end + side *  
        
       (lineWidth/ - 
       2 
       );

First, you get the normal of the plane on which both start and endvectors lie. This will be the plane on which the line-quad willlocated. The cross product of the normal and of the differencebetween end and start vectors gives you the side vector (the "thin"side of the quad). You need to normalize it to make it a unitvector. Finally calculate all 4 points of the rectangle by addingthe side vector multiplied by half width to both start and endpoints in both directions. In the sourcecode all this happensin MakeQuad and AddLine methods,so take a look in there.

It wasn't easy to implement, but once I was there it runs prettyfast.

Direct drawing withGL [demo]

No fast is fastenough! Instead of leaving this topic andlive happily with the Graphics solution, I kept searching forsomething even better. And I found the GLclass. GL is used to "issue rendering commands similar toOpenGL's immediate mode". This sounds like fast, doesn't it? Itis!

Being much easier to implement that the Graphics solution it isa clearwinner for me, the only drawback beingthat you don't have much control over theappearance of the lines. You can't set a width andperspective does not apply (i.e. lines that are far behind lookexactly the same as those that are close to the camera).

Conclusion

For massive & dynamic line drawing LineRenderer is not the bestsolution, but it is the only one available in Unity free version.It can surely be useful to draw limited amounts of static lines andthis is probably what it was made for. If you do have Unity3D Pro,the solution with Graphics is reasonable and very flexible but ifit is performance you're after choose GL.

注：

1、linerender:

using UnityEngine;
using System.Collections;
public class Script1 : MonoBehaviour {
//LineRenderer
private LineRenderer lineRenderer;
//定义一个Vector3,用来存储鼠标点击的位置
private Vector3 position;
//用来索引端点
private int index = 0;
//端点数
private int LengthOfLineRenderer=0;
void Start()
{
//添加LineRenderer组件
lineRenderer = gameObject.AddComponent();
//设置材质
lineRenderer.material = new Material(Shader.Find("Particles/Additive"));
//设置颜色
lineRenderer.SetColors(Color.red, Color.yellow);
//设置宽度
lineRenderer.SetWidth(0.02f, 0.02f);
}
void Update()
{
//获取LineRenderer组件
lineRenderer = GetComponent();
//鼠标左击
if (Input.GetMouseButtonDown(0))
{
//将鼠标点击的屏幕坐标转换为世界坐标，然后存储到position中
position = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x,Input.mousePosition.y,1.0f));
//端点数+1
LengthOfLineRenderer++;
//设置线段的端点数
lineRenderer.SetVertexCount(LengthOfLineRenderer);
}
//连续绘制线段
while (index < LengthOfLineRenderer)
{
//两点确定一条直线，所以我们依次绘制点就可以形成线段了
lineRenderer.SetPosition(index, position);
index++;
}
}
void OnGUI()
{
GUILayout.Label("当前鼠标X轴位置：" + Input.mousePosition.x);
GUILayout.Label("当前鼠标Y轴位置：" + Input.mousePosition.y);
}
}

2、GL

There are two things:

1. GL immediate drawing functions use whatever is the "currentmaterial" set up right now. The material controls how the renderingis done (blending, textures, etc.) So unless you explicitly set itto something before using GL draw functions, the material canhappen to be anything. Also, if you call any other drawing commandsfrom inside GL drawing code, they can set material to somethingelse, so it's not good to mix them.

2. GL drawing commands execute immediately. That means if you callthem in Start(), they will be executed just once. If you call themin Update(), they will be executed before camera is rendered (andthe camera will most likely clear the screen, making the GL drawingnot visible). So the usual place to call GL drawing is most oftenin OnPostRender from a script that is attached to acamera.

Here's a small example, attach it to a camera:

Code: