求glLineWidth替代方案：面向相机的3D像素宽度线段渲染代码

Great question—this is a standard workaround for glLineWidth's limitations, and getting the camera-facing behavior right is critical to matching the familiar OpenGL line feel. Below is a complete implementation that generates camera-aligned quads (two triangles) for any 3D line, maintaining a fixed pixel width regardless of distance from the camera.

Core Approach #

The idea is to create a quad that:

• Aligns perfectly between your two 3D endpoints
• Faces directly toward the camera at all times
• Uses pixel-based width that doesn't scale with scene depth

To achieve this, we'll:

1. Calculate the line's direction and midpoint
2. Compute a perpendicular vector that lies in the plane perpendicular to the camera's view direction (so the quad always faces the camera)
3. Convert the desired pixel width into world-space units (adjusted for the line's distance from the camera)
4. Offset the original endpoints to generate the four quad vertices

Code Implementation #

Assuming you're using GLM for math (common in OpenGL projects), here's a C++ function to generate the quad vertices:

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <vector>

// Helper struct for camera parameters
struct Camera {
    glm::vec3 position;
    glm::vec3 front;       // Direction the camera is looking
    glm::vec3 up;          // Camera's up vector
    glm::mat4 viewMatrix;  // Precomputed view matrix
    glm::mat4 projMatrix;  // Precomputed projection matrix
    int screenWidth;       // Window width in pixels
    int screenHeight;      // Window height in pixels
};

// Generates 4 vertices for a camera-facing line quad
std::vector<glm::vec3> generateCameraFacingLineQuad(
    glm::vec3 p0,          // Line start point (world space)
    glm::vec3 p1,          // Line end point (world space)
    float pixelWidth,      // Desired line width in screen pixels
    const Camera& cam
) {
    std::vector<glm::vec3> quad(4);

    // Step 1: Calculate line direction and midpoint
    glm::vec3 lineDir = glm::normalize(p1 - p0);
    glm::vec3 midpoint = (p0 + p1) * 0.5f;

    // Step 2: Compute camera-facing perpendicular vector
    glm::vec3 camToMid = glm::normalize(midpoint - cam.position);
    glm::vec3 perpDir = glm::normalize(glm::cross(lineDir, camToMid));

    // Handle edge case: line is parallel to camera view (cross product is zero)
    if (glm::length(perpDir) < 0.001f) {
        perpDir = glm::normalize(glm::cross(lineDir, cam.up));
    }

    // Step 3: Convert pixel width to world-space units
    // Convert midpoint to NDC space
    glm::vec4 clipMid = cam.projMatrix * cam.viewMatrix * glm::vec4(midpoint, 1.0f);
    glm::vec3 ndcMid = glm::vec3(clipMid) / clipMid.w;

    // Calculate NDC size per pixel
    float ndcPixelX = 2.0f / cam.screenWidth;
    float ndcPixelY = 2.0f / cam.screenHeight;
    float ndcPixelSize = (ndcPixelX + ndcPixelY) * 0.5f; // Average for square pixels

    // Convert NDC offset to world space
    glm::mat4 invViewProj = glm::inverse(cam.projMatrix * cam.viewMatrix);
    glm::vec4 ndcOffset = glm::vec4(perpDir * ndcPixelSize * (pixelWidth / 2.0f), 0.0f);
    glm::vec4 worldOffset = invViewProj * (glm::vec4(ndcMid, 1.0f) + ndcOffset) 
                          - invViewProj * glm::vec4(ndcMid, 1.0f);
    float worldWidth = glm::length(glm::vec3(worldOffset));

    // Step 4: Generate quad vertices
    glm::vec3 offset = perpDir * worldWidth;
    quad[0] = p0 + offset;
    quad[1] = p1 + offset;
    quad[2] = p1 - offset;
    quad[3] = p0 - offset;

    return quad;
}

How to Use #

1. Call this function with your line endpoints, desired pixel width, and camera parameters to get the four quad vertices.
2. Render the quad as two triangles using indices 0,1,2 and 0,2,3.
3. In your shader, disable face culling (or set it to GL_BACK if you ensure the quad is oriented correctly) to avoid hidden faces.
4. For solid lines, use a simple color shader—no texture is needed unless you want patterned lines.

Key Notes #

• Orthographic Projection: If using ortho mode, the world-space width calculation simplifies. You can skip the NDC conversion and compute worldWidth directly as (pixelWidth * orthoScale), where orthoScale is the ratio of world units to screen pixels (e.g., orthoRight / screenWidth).
• Smooth Joins: To replicate glLineJoin behavior (round, bevel, or miter joins), you'll need to add logic to generate connecting quads at line intersections. This is more complex but achievable with additional vertex generation.
• Performance: For large numbers of lines, consider batching the quads into a single vertex buffer to minimize draw calls.

内容的提问来源于stack exchange，提问作者Zohar Levi