pointSize contains the rasterized diameter of both aliased and
antialiased points. The initial value is 1. Using a point size other
than 1 has different effects, depending on whether point antialiasing
is enabled (see
pointSmooth) or point sprites are enabled (see
pointSprite). Both are initially disabled.
The specified point size is multiplied with a distance attenuation
factor and clamped to the specified
pointSizeRange, and further
clamped to the implementation-dependent point size range to produce
the derived point size using
derivedSize = clamp (size * sqrt (1 / (a + b * d + c * d^2)))
where
d is the eye-coordinate distance from the eye to the
vertex, and
a,
b, and
c are the distance
attenuation coefficients (see
pointDistanceAttenuation).
If multisampling is disabled, the computed point size is used as the
point's width.
If multisampling is enabled, the point may be faded by modifying the
point alpha value (see
sampleCoverage) instead of allowing the
point width to go below a given
pointFadeThresholdSize. In this
case, the width is further modified in the following manner:
width = if derivedSize >= threshold then derivedSize else threshold
The point alpha value is modified by computing:
alpha = if derivedSize >= threshold then 1 else (derivedSize / threshold)^2
If point antialiasing is disabled, the actual size is determined by
rounding the supplied size to the nearest integer. (If the rounding
results in the value 0, it is as if the point size were 1.) If the
rounded size is odd, then the center point (
x,
y) of the
pixel fragment that represents the point is computed as
(x, y) = (floor xw + 0.5, floor yw + 0.5)
where
xw and
yw indicate window coordinates. All pixels
that lie within the square grid of the rounded size centered at
(
x,
y) make up the fragment. If the size is even, the
center point is
(x, y) = (floor (xw + 0.5), floor (yw + 0.5))
and the rasterized fragment's centers are the half-integer window
coordinates within the square of the rounded size centered at
(
x,
y). All pixel fragments produced in rasterizing a
nonantialiased point are assigned the same associated data, that of
the vertex corresponding to the point.
If antialiasing is enabled, then point rasterization produces a
fragment for each pixel square that intersects the region lying within
the circle having diameter equal to the current point size and
centered at the point's (
xw,
yw). The coverage value for
each fragment is the window coordinate area of the intersection of the
circular region with the corresponding pixel square. This value is
saved and used in the final rasterization step. The data associated
with each fragment is the data associated with the point being
rasterized.
Not all sizes are supported when point antialiasing is enabled. If an
unsupported size is requested, the nearest supported size is used.
Only size 1 is guaranteed to be supported; others depend on the
implementation. To query the range of supported sizes for antialiased
points and the size difference between supported sizes within the
range, query
smoothPointSizeRange and
smoothPointSizeGranularity, respectively. For aliased points,
query the supported range with
aliasedPointSizeRange.
The point size specified when
pointSize is set is always
returned when it is queried. Clamping and rounding for aliased and
antialiased points have no effect on the specified value.
A non-antialiased point size may be clamped to an
implementation-dependent maximum. Although this maximum cannot be
queried, it must be no less than the maximum value for antialiased
points, rounded to the nearest integer value.
An
InvalidValue is generated if
pointSize is set to a
value less than or equal to zero.
An
InvalidOperation is generated if
pointSize is set
during
renderPrimitive.