Draw arbitrary plane from plane equation, OpenGL

Question

I have a plane defined by the standard plane equation a*x + b*y + c*z + d = 0, which I would like to be able to draw using OpenGL. How can I derive the four points needed to draw it as a quadrilateral in 3D space?

My plane type is defined as:

struct Plane {
    float x,y,z; // plane normal
    float d;
};

void DrawPlane(const Plane & p)
{
    ???
}

EDIT:

So, rethinking the question, what I actually wanted was to draw a discreet representation of a plane in 3D space, not an infinite plane. Base on the answer provided by @a.lasram, I have produced this implementation, which doest just that:

void DrawPlane(const Vector3 & center, const Vector3 & planeNormal, float planeScale, float normalVecScale, const fColorRGBA & planeColor, const fColorRGBA & normalVecColor)
{
    Vector3 tangent, bitangent;
    OrthogonalBasis(planeNormal, tangent, bitangent);

    const Vector3 v1(center - (tangent * planeScale) - (bitangent * planeScale));
    const Vector3 v2(center + (tangent * planeScale) - (bitangent * planeScale));
    const Vector3 v3(center + (tangent * planeScale) + (bitangent * planeScale));
    const Vector3 v4(center - (tangent * planeScale) + (bitangent * planeScale));

    // Draw wireframe plane quadrilateral:
    DrawLine(v1, v2, planeColor);
    DrawLine(v2, v3, planeColor);
    DrawLine(v3, v4, planeColor);
    DrawLine(v4, v1, planeColor);

    // And a line depicting the plane normal:
    const Vector3 pvn(
       (center[0] + planeNormal[0] * normalVecScale),
       (center[1] + planeNormal[1] * normalVecScale),
       (center[2] + planeNormal[2] * normalVecScale)
    );
    DrawLine(center, pvn, normalVecColor);
}

Where OrthogonalBasis() computes the tangent and bi-tangent from the plane normal.

Strictly speaking the plane is infinite, so that it doesn't have boundary vertexes. Moreover, the plane as seen in 3D space -> 2D projection either occupies the whole projection plane (general case) or turns into a line (partial case). You need to defined your question better. — valdo
@valdo: If the plane is parallel to the axis of view then it will actually not fill the whole viewport, but recede into a horizon. — datenwolf
@Vallentin I didn't say anything about code! However I admit the empty function was meant to be a hint to any kind soul that would want to implement it ;) Any mathematical definition that helps me write the code is more than good! And about the plane being infinite, yes! My idea was to allow the user to define the size of the plane before drawing. — glampert

a.lasram a.lasram · Accepted Answer · 2013-12-18T22:12:24

To see the plane as if it's infinite you can find 4 quad vertices so that the clipped quad and the clipped infinite plane form the same polygon. Example:

Sample 2 random points P1 and P2 on the plane such as P1 != P2.

Deduce a tangent t and bi-tangent b as

t = normalize(P2-P1); // get a normalized tangent
b = cross(t, n); // the bi-tangent is the cross product of the tangent and the normal

Compute the bounding sphere of the view frustum. The sphere would have a diameter D (if this step seems difficult, just set D to a large enough value such as the corresponding sphere encompasses the frustum).

Get the 4 quad vertices v1 , v2 , v3 and v4 (CCW or CW depending on the choice of P1 and P2):

v1 = P1 - t*D - b*D;
v2 = P1 + t*D - b*D;
v3 = P1 + t*D + b*D;
v4 = P1 - t*D + b*D;

Draw arbitrary plane from plane equation, OpenGL

2 Answers