UE4 C++绘制非调试线条求助：新手需实现带线条边框的透明3D物体

Hey there! As a fellow UE4 developer, I get your frustration with DrawDebugLine being only for debugging and not handling your point array needs. Let's go through two solid approaches to draw persistent, non-debug lines for your transparent 3D object's borders:

Option 1: Use a Procedural Mesh Component (For Static/Styled Lines) #

Since you already know how to work with procedural meshes, this is a natural next step. We'll simulate lines by creating extremely thin quadrilaterals (made of two triangles) between each pair of points in your array. This method lets you use custom materials (with transparency, lighting, etc.) just like any other mesh.

Step-by-Step Implementation: #

1. Set up your base variables (assuming you have your point array ready):

   TArray<FVector> LinePoints; // Your existing array of border points
   float LineThickness = 4.0f; // Adjust based on your desired line width
   UProceduralMeshComponent* ProcMesh = GetComponentByClass<UProceduralMeshComponent>();
   

2. Prepare vertex and index data for line segments:

   TArray<FVector> Vertices;
   TArray<int32> Triangles;
   TArray<FVector> Normals;
   TArray<FVector2D> UVs;
   TArray<FColor> VertexColors;
   TArray<FProcMeshTangent> Tangents;
   
   // Loop through each consecutive point pair to create line segments
   for (int32 i = 0; i < LinePoints.Num() - 1; ++i)
   {
       FVector P0 = LinePoints[i];
       FVector P1 = LinePoints[i + 1];
       FVector SegmentDir = (P1 - P0).GetSafeNormal();
   
       // Calculate a perpendicular vector to add thickness to the line
       FVector PerpVector = FVector::UpVector;
       // Fallback if the segment is almost vertical
       if (FMath::Abs(SegmentDir.Dot(PerpVector)) > 0.9f)
       {
           PerpVector = FVector::RightVector;
       }
       PerpVector = SegmentDir.Cross(PerpVector).GetSafeNormal() * (LineThickness * 0.5f);
   
       // Create 4 vertices for the thin quad representing the line segment
       Vertices.Add(P0 - PerpVector);
       Vertices.Add(P0 + PerpVector);
       Vertices.Add(P1 + PerpVector);
       Vertices.Add(P1 - PerpVector);
   
       // Add triangle indices to form the quad (two triangles per quad)
       int32 BaseIndex = Vertices.Num() - 4;
       Triangles.Add(BaseIndex);
       Triangles.Add(BaseIndex + 1);
       Triangles.Add(BaseIndex + 2);
   
       Triangles.Add(BaseIndex);
       Triangles.Add(BaseIndex + 2);
       Triangles.Add(BaseIndex + 3);
   }
   

3. Update the procedural mesh with your line data:

   ProcMesh->CreateMeshSection_LinearColor(
       0,
       Vertices,
       Triangles,
       Normals,
       UVs,
       VertexColors,
       Tangents,
       true // Set to true if you want collision for the lines (optional)
   );
   

4. Assign a transparent material:
   Create a material tailored for your lines:

   • Set Blend Mode to Translucent
   • Choose a Shading Model (Unlit works great for simple, consistent lines)
   • Disable Depth Write if you want lines to appear behind other transparent objects

Option 2: Use ULineBatchComponent (For Quick, Dynamic Lines) #

If you don't need complex materials and just want to draw persistent lines quickly, ULineBatchComponent is perfect. It's designed for non-debug line rendering and supports batch drawing directly from your point array.

Step-by-Step Implementation: #

1. Add the component to your Actor:
   First, declare the component in your Actor's header:

   UPROPERTY(VisibleAnywhere)
   ULineBatchComponent* LineBatchComp;
   

   Then initialize it in your Actor's constructor:

   LineBatchComp = CreateDefaultSubobject<ULineBatchComponent>(TEXT("LineBatchComponent"));
   LineBatchComp->SetupAttachment(RootComponent);
   LineBatchComp->SetPersistent(true); // Keep lines visible permanently
   

2. Draw lines from your point array:
   Call this in BeginPlay() (or whenever your point array is finalized):

   TArray<FVector> LinePoints; // Your existing point array
   FColor LineColor = FColor::Blue; // Customize your line color
   float LineThickness = 3.0f;
   
   for (int32 i = 0; i < LinePoints.Num() - 1; ++i)
   {
       // Add a permanent line segment between consecutive points
       // 0.f = no auto-expiry (line stays until flushed)
       LineBatchComp->AddLine(
           LinePoints[i],
           LinePoints[i + 1],
           LineColor,
           0.f,
           LineThickness
       );
   }
   

3. For dynamic updates:
   If your point array changes over time, clear existing lines before re-drawing:

   LineBatchComp->Flush(); // Remove all existing lines
   // Re-run the loop above to draw updated lines
   

Which Option Should You Choose? #

• Use Procedural Mesh if you need:
  • Custom materials (transparency, textures, lighting integration)
  • Collision for the lines
  • Static lines that don't change often
• Use LineBatchComponent if you need:
  • Fast, minimal-code line rendering
  • Dynamic lines that update frequently
  • Basic color/thickness control without material setup

内容的提问来源于stack exchange，提问作者Иван Пупкин