skia / external / github.com / KhronosGroup / OpenGL-Registry / refs/heads/11723-workgroup / . / extensions / NV / NV_blend_equation_advanced.txt

Name | |

NV_blend_equation_advanced | |

Name Strings | |

GL_NV_blend_equation_advanced | |

GL_NV_blend_equation_advanced_coherent | |

Contact | |

Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com) | |

Contributors | |

Jeff Bolz, NVIDIA Corporation | |

Mathias Heyer, NVIDIA Corporation | |

Mark Kilgard, NVIDIA Corporation | |

Daniel Koch, NVIDIA Corporation | |

Rik Cabanier, Adobe | |

Status | |

NV_blend_equation_advanced is released in NVIDIA Driver Release | |

326.xx (June 2013). | |

Version | |

Last Modified Date: February 14, 2018 | |

NVIDIA Revision: 10 | |

Number | |

OpenGL Extension #433 | |

OpenGL ES Extension #163 | |

Dependencies | |

This extension is written against the OpenGL 4.1 Specification | |

(Compatibility Profile). | |

OpenGL 2.0 is required (for Desktop). | |

OpenGL ES 2.0 is required (for mobile). | |

EXT_blend_minmax is required (for mobile). | |

This extension interacts with OpenGL 4.0. | |

This extension interacts with OpenGL 4.1 (Core Profile). | |

This extension interacts with OpenGL 4.3 or later. | |

This extension interacts with OpenGL ES 2.0. | |

This extension interacts with OpenGL ES 3.0. | |

This extension interacts with NV_path_rendering. | |

Overview | |

This extension adds a number of "advanced" blending equations that can be | |

used to perform new color blending operations, many of which are more | |

complex than the standard blend modes provided by unextended OpenGL. This | |

extension provides two different extension string entries: | |

- NV_blend_equation_advanced: Provides the new blending equations, but | |

guarantees defined results only if each sample is touched no more than | |

once in any single rendering pass. The command BlendBarrierNV() is | |

provided to indicate a boundary between passes. | |

- NV_blend_equation_advanced_coherent: Provides the new blending | |

equations, and guarantees that blending is done coherently and in API | |

primitive ordering. An enable is provided to allow implementations to | |

opt out of fully coherent blending and instead behave as though only | |

NV_blend_equation_advanced were supported. | |

Some implementations may support NV_blend_equation_advanced without | |

supporting NV_blend_equation_advanced_coherent. | |

In unextended OpenGL, the set of blending equations is limited, and can be | |

expressed very simply. The MIN and MAX blend equations simply compute | |

component-wise minimums or maximums of source and destination color | |

components. The FUNC_ADD, FUNC_SUBTRACT, and FUNC_REVERSE_SUBTRACT | |

multiply the source and destination colors by source and destination | |

factors and either add the two products together or subtract one from the | |

other. This limited set of operations supports many common blending | |

operations but precludes the use of more sophisticated transparency and | |

blending operations commonly available in many dedicated imaging APIs. | |

This extension provides a number of new "advanced" blending equations. | |

Unlike traditional blending operations using the FUNC_ADD equation, these | |

blending equations do not use source and destination factors specified by | |

BlendFunc. Instead, each blend equation specifies a complete equation | |

based on the source and destination colors. These new blend equations are | |

used for both RGB and alpha components; they may not be used to perform | |

separate RGB and alpha blending (via functions like | |

BlendEquationSeparate). | |

These blending operations are performed using premultiplied colors, where | |

RGB colors stored in the framebuffer are considered to be multiplied by | |

alpha (coverage). The fragment color may be considered premultiplied or | |

non-premultiplied, according the BLEND_PREMULTIPLIED_SRC_NV blending | |

parameter (as specified by the new BlendParameteriNV function). If | |

fragment color is considered non-premultiplied, the (R,G,B) color | |

components are multiplied by the alpha component prior to blending. For | |

non-premultiplied color components in the range [0,1], the corresponding | |

premultiplied color component would have values in the range [0*A,1*A]. | |

Many of these advanced blending equations are formulated where the result | |

of blending source and destination colors with partial coverage have three | |

separate contributions: from the portions covered by both the source and | |

the destination, from the portion covered only by the source, and from the | |

portion covered only by the destination. The blend parameter | |

BLEND_OVERLAP_NV can be used to specify a correlation between source and | |

destination pixel coverage. If set to CONJOINT_NV, the source and | |

destination are considered to have maximal overlap, as would be the case | |

if drawing two objects on top of each other. If set to DISJOINT_NV, the | |

source and destination are considered to have minimal overlap, as would be | |

the case when rendering a complex polygon tessellated into individual | |

non-intersecting triangles. If set to UNCORRELATED_NV (default), the | |

source and destination coverage are assumed to have no spatial correlation | |

within the pixel. | |

In addition to the coherency issues on implementations not supporting | |

NV_blend_equation_advanced_coherent, this extension has several | |

limitations worth noting. First, the new blend equations are not | |

supported while rendering to more than one color buffer at once; an | |

INVALID_OPERATION will be generated if an application attempts to render | |

any primitives in this unsupported configuration. Additionally, blending | |

precision may be limited to 16-bit floating-point, which could result in a | |

loss of precision and dynamic range for framebuffer formats with 32-bit | |

floating-point components, and in a loss of precision for formats with 12- | |

and 16-bit signed or unsigned normalized integer components. | |

New Procedures and Functions | |

void BlendParameteriNV(enum pname, int value); | |

void BlendBarrierNV(void); | |

New Tokens | |

Accepted by the <cap> parameter of Disable, Enable, and IsEnabled, and by | |

the <pname> parameter of GetIntegerv, GetBooleanv, GetFloatv, GetDoublev | |

and GetInteger64v: | |

BLEND_ADVANCED_COHERENT_NV 0x9285 | |

Note: The BLEND_ADVANCED_COHERENT_NV enable is provided if and only if | |

the NV_blend_equation_advanced_coherent extension is supported. On | |

implementations supporting only NV_blend_equation_advanced, this enable is | |

considered not to exist. | |

Accepted by the <pname> parameter of BlendParameteriNV, GetBooleanv, | |

GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev: | |

BLEND_PREMULTIPLIED_SRC_NV 0x9280 | |

BLEND_OVERLAP_NV 0x9281 | |

Accepted by the <value> parameter of BlendParameteriNV when <pname> is | |

BLEND_PREMULTIPLIED_SRC_NV: | |

TRUE | |

FALSE | |

Accepted by the <value> parameter of BlendParameteriNV when <pname> is | |

BLEND_OVERLAP_NV: | |

UNCORRELATED_NV 0x9282 | |

DISJOINT_NV 0x9283 | |

CONJOINT_NV 0x9284 | |

Accepted by the <mode> parameter of BlendEquation and BlendEquationi: | |

ZERO // reused from core | |

SRC_NV 0x9286 | |

DST_NV 0x9287 | |

SRC_OVER_NV 0x9288 | |

DST_OVER_NV 0x9289 | |

SRC_IN_NV 0x928A | |

DST_IN_NV 0x928B | |

SRC_OUT_NV 0x928C | |

DST_OUT_NV 0x928D | |

SRC_ATOP_NV 0x928E | |

DST_ATOP_NV 0x928F | |

XOR_NV 0x1506 | |

MULTIPLY_NV 0x9294 | |

SCREEN_NV 0x9295 | |

OVERLAY_NV 0x9296 | |

DARKEN_NV 0x9297 | |

LIGHTEN_NV 0x9298 | |

COLORDODGE_NV 0x9299 | |

COLORBURN_NV 0x929A | |

HARDLIGHT_NV 0x929B | |

SOFTLIGHT_NV 0x929C | |

DIFFERENCE_NV 0x929E | |

EXCLUSION_NV 0x92A0 | |

INVERT // reused from core | |

INVERT_RGB_NV 0x92A3 | |

LINEARDODGE_NV 0x92A4 | |

LINEARBURN_NV 0x92A5 | |

VIVIDLIGHT_NV 0x92A6 | |

LINEARLIGHT_NV 0x92A7 | |

PINLIGHT_NV 0x92A8 | |

HARDMIX_NV 0x92A9 | |

HSL_HUE_NV 0x92AD | |

HSL_SATURATION_NV 0x92AE | |

HSL_COLOR_NV 0x92AF | |

HSL_LUMINOSITY_NV 0x92B0 | |

PLUS_NV 0x9291 | |

PLUS_CLAMPED_NV 0x92B1 | |

PLUS_CLAMPED_ALPHA_NV 0x92B2 | |

PLUS_DARKER_NV 0x9292 | |

MINUS_NV 0x929F | |

MINUS_CLAMPED_NV 0x92B3 | |

CONTRAST_NV 0x92A1 | |

INVERT_OVG_NV 0x92B4 | |

RED_NV 0x1903 | |

GREEN_NV 0x1904 | |

BLUE_NV 0x1905 | |

NOTE: These enums are not accepted by the <modeRGB> or <modeAlpha> | |

parameters of BlendEquationSeparate or BlendEquationSeparatei. | |

NOTE: The tokens XOR_NV, RED_NV, GREEN_NV, and BLUE_NV have the same | |

values as core OpenGL API enumerants with names without the "_NV" | |

suffixes. Either #define can be used, but the non-suffixed #defines are | |

not available in OpenGL ES 2.0 and XOR is not available in OpenGL ES 3.0. | |

Additions to Chapter 2 of the OpenGL 4.1 Specification (OpenGL Operation) | |

None. | |

Additions to Chapter 3 of the OpenGL 4.1 Specification (Rasterization) | |

None. | |

Additions to Chapter 4 of the OpenGL 4.1 Specification (Per-Fragment | |

Operations and the Frame Buffer) | |

Modify Section 4.1.8, Blending (p. 359). | |

(modify the first paragraph, p. 361, allowing for new values in the | |

<mode> parameter) ... <modeRGB> and <modeAlpha> must be one of | |

FUNC_ADD, FUNC_SUBTRACT, FUNC_REVERSE_SUBTRACT, MIN, or MAX as listed | |

in Table 4.1. <mode> must be one of the values in Table 4.1, | |

or one of the blend equations listed in tables X.2, X.3, and X.4. ... | |

(modify the third paragraph, p. 361, specifying minimum precision and | |

dynamic range for blend operations) ... Blending computations are treated | |

as if carried out in floating-point. For the equations in table 4.1, | |

blending computations will be performed with a precision and dynamic range | |

no lower than that used to represent destination components. For the | |

equations in table X.2, X.3, and X.4, blending computations will be | |

performed with a precision and dynamic range no lower than the smaller of | |

that used to represent destination components or that used to represent | |

16-bit floating-point values as described in section 2.1.1. | |

(add unnumbered subsection prior to "Dual Source Blending and Multiple | |

Draw Buffers", p. 363) | |

Advanced Blend Equations | |

The advanced blend equations are those listed in tables X.2, X.3, and X.4. | |

Parameters related to the advanced blend equations can be set by calling | |

void BlendParameteriNV(enum pname, int param); | |

with <pname> set to BLEND_PREMULTIPLIED_SRC_NV or BLEND_OVERLAP_NV. When | |

<pname> is BLEND_PREMULTIPLIED_SRC_NV, the valid values for <param> are | |

TRUE or FALSE. When <pname> is BLEND_OVERLAP_NV, the valid values for | |

<param> are UNCORRELATED_NV, CONJOINT_NV, and DISJOINT_NV. An | |

INVALID_ENUM error is generated if <pname> is not | |

BLEND_PREMULTIPLIED_SRC_NV or BLEND_OVERLAP_NV, or if <param> is not a | |

legal value for <pname>. | |

When using one of the equations in table X.2 or X.3, blending is performed | |

according to the following equations: | |

R = f(Rs',Rd')*p0(As,Ad) + Y*Rs'*p1(As,Ad) + Z*Rd'*p2(As,Ad) | |

G = f(Gs',Gd')*p0(As,Ad) + Y*Gs'*p1(As,Ad) + Z*Gd'*p2(As,Ad) | |

B = f(Bs',Bd')*p0(As,Ad) + Y*Bs'*p1(As,Ad) + Z*Bd'*p2(As,Ad) | |

A = X*p0(As,Ad) + Y*p1(As,Ad) + Z*p2(As,Ad) | |

where the function f and terms X, Y, and Z are specified in the table. | |

The R, G, and B components of the source color used for blending are | |

derived according to the premultiplied source color blending parameter, | |

which is set by calling BlendParameteriNV with <pname> set to | |

BLEND_PREMULTIPLIED_SRC_NV, and <param> set to TRUE or FALSE. | |

If the parameter is set to TRUE, the fragment color components are | |

considered to have been premultiplied by the A component prior to | |

blending. The base source color (Rs',Gs',Bs') is obtained by dividing | |

through by the A component: | |

(Rs', Gs', Bs') = | |

(0, 0, 0), if As == 0 | |

(Rs/As, Gs/As, Bs/As), otherwise | |

If the premultiplied source color parameter is FALSE, the fragment color | |

components are used as the base color: | |

(Rs', Gs', Bs') = (Rs, Gs, Bs) | |

The destination color components are always considered to have been | |

premultiplied by the destination A component and the base destination | |

color (Rd', Gd', Bd') is obtained by dividing through by the A component: | |

(Rd', Gd', Bd') = | |

(0, 0, 0), if Ad == 0 | |

(Rd/Ad, Gd/Ad, Bd/Ad), otherwise | |

When blending using advanced blend equations, we expect that the R, G, and | |

B components of premultiplied source and destination color inputs be | |

stored as the product of non-premultiplied R, G, and B component values | |

and the A component of the color. If any R, G, or B component of a | |

premultiplied input color is non-zero and the A component is zero, the | |

color is considered ill-formed, and the corresponding component of the | |

blend result will be undefined. | |

The weighting functions p0, p1, and p2 are defined in table X.1. In these | |

functions, the A components of the source and destination colors are taken | |

to indicate the portion of the pixel covered by the fragment (source) and | |

the fragments previously accumulated in the pixel (destination). The | |

functions p0, p1, and p2 approximate the relative portion of the pixel | |

covered by the intersection of the source and destination, covered only by | |

the source, and covered only by the destination, respectively. These | |

functions are specified by the blend overlap parameter, which can be set | |

by calling BlendParameteriNV with <pname> set to BLEND_OVERLAP_NV. <param> | |

can be one of UNCORRELATED_NV (default), CONJOINT_NV, and DISJOINT_NV. | |

UNCORRELATED_NV indicates that there is no correlation between the source | |

and destination coverage. CONJOINT_NV and DISJOINT_NV indicate that the | |

source and destination coverage are considered to have maximal or minimal | |

overlap, respectively. | |

Overlap Mode Weighting Equations | |

--------------- -------------------------- | |

UNCORRELATED_NV p0(As,Ad) = As*Ad | |

p1(As,Ad) = As*(1-Ad) | |

p2(As,Ad) = Ad*(1-As) | |

CONJOINT_NV p0(As,Ad) = min(As,Ad) | |

p1(As,Ad) = max(As-Ad,0) | |

p2(As,Ad) = max(Ad-As,0) | |

DISJOINT_NV p0(As,Ad) = max(As+Ad-1,0) | |

p1(As,Ad) = min(As,1-Ad) | |

p2(As,Ad) = min(Ad,1-As) | |

Table X.1, Advanced Blend Overlap Modes | |

Mode Blend Coefficients | |

-------------------- ----------------------------------- | |

ZERO (X,Y,Z) = (0,0,0) | |

f(Cs,Cd) = 0 | |

SRC_NV (X,Y,Z) = (1,1,0) | |

f(Cs,Cd) = Cs | |

DST_NV (X,Y,Z) = (1,0,1) | |

f(Cs,Cd) = Cd | |

SRC_OVER_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = Cs | |

DST_OVER_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = Cd | |

SRC_IN_NV (X,Y,Z) = (1,0,0) | |

f(Cs,Cd) = Cs | |

DST_IN_NV (X,Y,Z) = (1,0,0) | |

f(Cs,Cd) = Cd | |

SRC_OUT_NV (X,Y,Z) = (0,1,0) | |

f(Cs,Cd) = 0 | |

DST_OUT_NV (X,Y,Z) = (0,0,1) | |

f(Cs,Cd) = 0 | |

SRC_ATOP_NV (X,Y,Z) = (1,0,1) | |

f(Cs,Cd) = Cs | |

DST_ATOP_NV (X,Y,Z) = (1,1,0) | |

f(Cs,Cd) = Cd | |

XOR_NV (X,Y,Z) = (0,1,1) | |

f(Cs,Cd) = 0 | |

MULTIPLY_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = Cs*Cd | |

SCREEN_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = Cs+Cd-Cs*Cd | |

OVERLAY_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = 2*Cs*Cd, if Cd <= 0.5 | |

1-2*(1-Cs)*(1-Cd), otherwise | |

DARKEN_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = min(Cs,Cd) | |

LIGHTEN_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = max(Cs,Cd) | |

COLORDODGE_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

0, if Cd <= 0 | |

min(1,Cd/(1-Cs)), if Cd > 0 and Cs < 1 | |

1, if Cd > 0 and Cs >= 1 | |

COLORBURN_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

1, if Cd >= 1 | |

1 - min(1,(1-Cd)/Cs), if Cd < 1 and Cs > 0 | |

0, if Cd < 1 and Cs <= 0 | |

HARDLIGHT_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = 2*Cs*Cd, if Cs <= 0.5 | |

1-2*(1-Cs)*(1-Cd), otherwise | |

SOFTLIGHT_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

Cd-(1-2*Cs)*Cd*(1-Cd), | |

if Cs <= 0.5 | |

Cd+(2*Cs-1)*Cd*((16*Cd-12)*Cd+3), | |

if Cs > 0.5 and Cd <= 0.25 | |

Cd+(2*Cs-1)*(sqrt(Cd)-Cd), | |

if Cs > 0.5 and Cd > 0.25 | |

DIFFERENCE_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = abs(Cd-Cs) | |

EXCLUSION_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = Cs+Cd-2*Cs*Cd | |

INVERT (X,Y,Z) = (1,0,1) | |

f(Cs,Cd) = 1-Cd | |

INVERT_RGB_NV (X,Y,Z) = (1,0,1) | |

f(Cs,Cd) = Cs*(1-Cd) | |

LINEARDODGE_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

Cs+Cd, if Cs+Cd<=1 | |

1, otherwise | |

LINEARBURN_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

Cs+Cd-1, if Cs+Cd>1 | |

0, otherwise | |

VIVIDLIGHT_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

1-min(1,(1-Cd)/(2*Cs)), if 0 < Cs < 0.5 | |

0, if Cs <= 0 | |

min(1,Cd/(2*(1-Cs))), if 0.5 <= Cs < 1 | |

1, if Cs >= 1 | |

LINEARLIGHT_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

1, if 2*Cs+Cd>2 | |

2*Cs+Cd-1, if 1 < 2*Cs+Cd <= 2 | |

0, if 2*Cs+Cd<=1 | |

PINLIGHT_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = | |

0, if 2*Cs-1>Cd and Cs<0.5 | |

2*Cs-1, if 2*Cs-1>Cd and Cs>=0.5 | |

2*Cs, if 2*Cs-1<=Cd and Cs<0.5*Cd | |

Cd, if 2*Cs-1<=Cd and Cs>=0.5*Cd | |

??? | |

HARDMIX_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = 0, if Cs+Cd<1 | |

1, otherwise | |

Table X.2, Advanced Blend Equations | |

When using one of the HSL blend equations in table X.3 as the blend | |

equation, the RGB color components produced by the function f() are | |

effectively obtained by converting both the non-premultiplied source and | |

destination colors to the HSL (hue, saturation, luminosity) color space, | |

generating a new HSL color by selecting H, S, and L components from the | |

source or destination according to the blend equation, and then converting | |

the result back to RGB. The HSL blend equations are only well defined | |

when the values of the input color components are in the range [0..1]. | |

In the equations below, a blended RGB color is produced according to the | |

following pseudocode: | |

float minv3(vec3 c) { | |

return min(min(c.r, c.g), c.b); | |

} | |

float maxv3(vec3 c) { | |

return max(max(c.r, c.g), c.b); | |

} | |

float lumv3(vec3 c) { | |

return dot(c, vec3(0.30, 0.59, 0.11)); | |

} | |

float satv3(vec3 c) { | |

return maxv3(c) - minv3(c); | |

} | |

// If any color components are outside [0,1], adjust the color to | |

// get the components in range. | |

vec3 ClipColor(vec3 color) { | |

float lum = lumv3(color); | |

float mincol = minv3(color); | |

float maxcol = maxv3(color); | |

if (mincol < 0.0) { | |

color = lum + ((color-lum)*lum) / (lum-mincol); | |

} | |

if (maxcol > 1.0) { | |

color = lum + ((color-lum)*(1-lum)) / (maxcol-lum); | |

} | |

return color; | |

} | |

// Take the base RGB color <cbase> and override its luminosity | |

// with that of the RGB color <clum>. | |

vec3 SetLum(vec3 cbase, vec3 clum) { | |

float lbase = lumv3(cbase); | |

float llum = lumv3(clum); | |

float ldiff = llum - lbase; | |

vec3 color = cbase + vec3(ldiff); | |

return ClipColor(color); | |

} | |

// Take the base RGB color <cbase> and override its saturation with | |

// that of the RGB color <csat>. The override the luminosity of the | |

// result with that of the RGB color <clum>. | |

vec3 SetLumSat(vec3 cbase, vec3 csat, vec3 clum) | |

{ | |

float minbase = minv3(cbase); | |

float sbase = satv3(cbase); | |

float ssat = satv3(csat); | |

vec3 color; | |

if (sbase > 0) { | |

// Equivalent (modulo rounding errors) to setting the | |

// smallest (R,G,B) component to 0, the largest to <ssat>, | |

// and interpolating the "middle" component based on its | |

// original value relative to the smallest/largest. | |

color = (cbase - minbase) * ssat / sbase; | |

} else { | |

color = vec3(0.0); | |

} | |

return SetLum(color, clum); | |

} | |

Mode Result | |

-------------------- ---------------------------------------- | |

HSL_HUE_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = SetLumSat(Cs,Cd,Cd); | |

HSL_SATURATION_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = SetLumSat(Cd,Cs,Cd); | |

HSL_COLOR_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = SetLum(Cs,Cd); | |

HSL_LUMINOSITY_NV (X,Y,Z) = (1,1,1) | |

f(Cs,Cd) = SetLum(Cd,Cs); | |

Table X.3, Hue-Saturation-Luminosity Advanced Blend Equations | |

When using one of the equations in table X.4 as the blend equation, the | |

source color used by these blending equations is interpreted according to | |

the BLEND_PREMULTIPLIED_SRC_NV blending parameter. The blending equations | |

below are evaluated where the RGB source and destination color components | |

are both considered to have been premultiplied by the corresponding A | |

component. | |

(Rs', Gs', Bs') = | |

(Rs, Gs, Bs), if BLEND_PREMULTIPLIED_SRC_NV is TRUE | |

(Rs*As, Gs*As, Bs*As), if BLEND_PREMULTIPLIED_SRC_NV is FALSE | |

Mode Result | |

-------------------- ---------------------------------------- | |

PLUS_NV (R,G,B,A) = (Rs'+Rd, Gs'+Gd, Bs'+Bd,As'+Ad) | |

PLUS_CLAMPED_NV (R,G,B,A) = | |

(min(1,Rs'+Rd), min(1,Gs'+Gd), | |

min(1,Bs'+Bd), min(1,As+Ad)) | |

PLUS_CLAMPED_ALPHA_NV (R,G,B,A) = | |

(min(min(1,As+Ad),Rs'+Rd), | |

min(min(1,As+Ad),Gs'+Gd), | |

min(min(1,As+Ad),Bs'+Bd), min(1,As+Ad)) | |

PLUS_DARKER_NV (R,G,B,A) = | |

(max(0,min(1,As+Ad)-((As-Rs')+(Ad-Rd))), | |

max(0,min(1,As+Ad)-((As-Gs')+(Ad-Gd))), | |

max(0,min(1,As+Ad)-((As-Bs')+(Ad-Bd))), | |

min(1,As+Ad)) | |

MINUS_NV (R,G,B,A) = (Rd-Rs', Gd-Gs', Bd-Bs', Ad-As) | |

MINUS_CLAMPED_NV (R,G,B,A) = | |

(max(0,Rd-Rs'), max(0,Gd-Gs'), | |

max(0,Bd-Bs'), max(0,Ad-As)) | |

CONTRAST_NV (R,G,B,A) = | |

(Ad/2 + 2*(Rd-Ad/2)*(Rs'-As/2), | |

Ad/2 + 2*(Gd-Ad/2)*(Gs'-As/2), | |

Ad/2 + 2*(Bd-Ad/2)*(Bs'-As/2), | |

Ad) | |

INVERT_OVG_NV (R,G,B,A) = | |

(As*(1-Rd)+(1-As)*Rd, | |

As*(1-Gd)+(1-As)*Gd, | |

As*(1-Bd)+(1-As)*Bd, | |

As+Ad-As*Ad) | |

RED_NV (R,G,B,A) = (Rs', Gd, Bd, Ad) | |

GREEN_NV (R,G,B,A) = (Rd, Gs', Bd, Ad) | |

BLUE_NV (R,G,B,A) = (Rd, Gd, Bs', Ad) | |

Table X.4, Additional RGB Blend Equations | |

Advanced blending equations are supported only when rendering to a single | |

color buffer using fragment color zero. If any non-NONE draw buffer uses | |

a blend equation found in table X.2, X.3, or X.4, the error | |

INVALID_OPERATION is generated by [[Compatibility Profile: Begin or any | |

operation that implicitly calls Begin (such as DrawElements)]] [[Core | |

Profile: DrawArrays and the other drawing commands defined in section | |

2.8.3]] if: | |

* the draw buffer for color output zero selects multiple color buffers | |

(e.g., FRONT_AND_BACK in the default framebuffer); or | |

* the draw buffer for any other color output is not NONE. | |

[[ The following paragraph applies to NV_blend_equation_advanced only. ]] | |

When using advanced blending equations, applications should split their | |

rendering into a collection of blending passes, none of which touch an | |

individual sample more than once. The results of blending are undefined | |

if the sample being blended has been touched previously in the same pass. | |

The command | |

void BlendBarrierNV(void); | |

specifies a boundary between passes when using advanced blend equations. | |

Any command that causes the value of a sample to be modified is considered | |

to touch the sample, including clears, blended or unblended primitives, | |

BlitFramebuffer copies, and direct updates by commands such as | |

TexSubImage2D. | |

[[ The following paragraph applies to NV_blend_equation_advanced_coherent | |

only. ]] | |

When using advanced blending equations, blending is typically done | |

coherently and in primitive order. When an individual sample is covered | |

by multiple primitives, blending for that sample is performed sequentially | |

in the order in which the primitives were submitted. This coherent | |

blending is enabled by default, but can be enabled or disabled by calling | |

Enable or Disable with the symbolic constant BLEND_ADVANCED_COHERENT_NV. | |

If coherent blending is disabled, applications should split their | |

rendering into a collection of blending passes, none of which touch an | |

individual sample more than once. When coherent blending is disabled, the | |

results of blending are undefined if the sample being blended has been | |

touched previously in the same pass. The command | |

void BlendBarrierNV(void); | |

specifies a boundary between passes when using advanced blend equations. | |

Any command that causes the value of a sample to be modified is considered | |

to touch the sample, including clears, blended or unblended primitives, | |

BlitFramebuffer copies, and direct updates by commands such as | |

TexSubImage2D. | |

Additions to Chapter 5 of the OpenGL 4.1 Specification (Special Functions) | |

None. | |

Additions to Chapter 6 of the OpenGL 4.1 Specification (State and | |

State Requests) | |

None. | |

Additions to Appendix A of the OpenGL 4.1 Specification (Invariance) | |

None. | |

Additions to the AGL/GLX/WGL/EGL Specifications | |

None. | |

GLX Protocol | |

!!! TBD | |

Dependencies on OpenGL 4.0 | |

If OpenGL 4.0 is not supported, references to the BlendEquationi API should | |

be removed. | |

Dependencies on OpenGL 4.1 (Core Profile) | |

This extension throws an INVALID_OPERATION when Begin is called if advanced | |

blend equations are used in conjunction with multiple draw buffers. For | |

the core profile of OpenGL 4.1 (and other versions of OpenGL), there is no | |

Begin command; instead, the error is thrown by other rendering commands | |

such as DrawArrays. The language in this specification documenting the | |

error has separate versions for the core and compatibility profiles. | |

Dependencies on OpenGL 4.3 or later (any Profile) | |

References to Chapter 4 are replaced with references to Chapter 17 (Writing | |

Fragments and Samples to the Framebuffer). | |

References to section 4.1.8 are replaced with references to section 17.3.8. | |

References to Table 4.1 are replace with references to Table 17.1. | |

References to section 2.1.1 are replaced with references to section 2.3.3. | |

Dependencies on OpenGL ES 2.0 | |

If unextended OpenGL ES 2.0 is supported, references to BlendEquationi, | |

BlendEquationSeparatei, GetInteger64v, and GetDoublev should be ignored. | |

Ignore any references to multiple draw buffers if EXT_draw_buffers or | |

NV_draw_buffers is not supported. | |

Dependencies on EXT_blend_minmax | |

Requires EXT_blend_minmax on OpenGL ES 2.0 implementations and references | |

to MIN and MAX should be replace by references to MIN_EXT and MAX_EXT as | |

introduced by that extension. | |

Dependencies on OpenGL ES 3.0 | |

If unextended OpenGL ES 3.0 is supported, references to BlendEquationi, | |

BlendEquationSeparatei, and GetDoublev should be ignored. | |

Dependencies on NV_path_rendering | |

When NV_path_rendering is supported, covering geometry generated by the | |

commands CoverFillPathNV, CoverFillPathInstancedNV, CoverStrokePathNV, and | |

CoverStrokePathInstancedNV will automatically be blended coherently | |

relative to previous geometry when using the blend equations in this | |

extension. This guarantee is provided even on implementations supporting | |

only NV_blend_equation_advanced. | |

Insert the following language after the discussion of the BlendBarrierNV() | |

command for both extensions: | |

[[ For NV_blend_equation_advanced only: ]] | |

The commands CoverFillPathNV, CoverFillPathInstancedNV, | |

CoverStrokePathNV, and CoverStrokePathInstancedNV are considered to | |

start a new blending pass, as though BlendBarrierNV were called prior to | |

the cover operation. If a cover primitive is followed by subsequent | |

non-cover primitives using advanced blend equations and touching the | |

same samples, applications must call BlendBarrierNV after the cover | |

primitives to ensure defined blending results. | |

[[ For NV_blend_equation_advanced_coherent, the language immediately | |

above should be used, but the first sentence should be prefixed with | |

"When coherent blending is disabled, ...". ]] | |

Errors | |

If any non-NONE draw buffer uses a blend equation found in table X.2, X.3, | |

or X.4, the error INVALID_OPERATION is generated by Begin or any operation | |

that implicitly calls Begin (such as DrawElements) if: | |

* the draw buffer for color output zero selects multiple color buffers | |

(e.g., FRONT_AND_BACK in the default framebuffer); or | |

* the draw buffer for any other color output is not NONE. | |

If BlendParameteriNV is called and <pname> is not | |

BLEND_PREMULTIPLIED_SRC_NV or BLEND_OVERLAP_NV the error INVALID_ENUM is | |

generated. | |

If BlendParameteriNV is called with <pname> set to | |

BLEND_PREMULTIPLIED_SRC_NV the error INVALID_ENUM is generated if <param> | |

is not TRUE or FALSE. | |

If BlendParameteriNV is called with <pname> set to BLEND_OVERLAP_NV the | |

error INVALID_ENUM is generated if <param> is not one of UNCORRELATED_NV, | |

DISJOINT_NV, or CONJOINT_NV. | |

New State | |

Initial | |

Get Value Type Get Command Value Description Sec Attribute | |

-------------------- ---- ------------ ------------ ------------------------ ----- ------------ | |

BLEND_ADVANCED_ B IsEnabled TRUE are advanced blending 4.1.8 color-buffer | |

COHERENT_NV equations guaranteed to | |

be evaluated coherently? | |

BLEND_PREMULTIPLIED_ B GetBooleanv TRUE use premultiplied src 4.1.8 color-buffer | |

SRC_NV colors with advanced | |

blend equations | |

BLEND_OVERLAP_NV Z3 GetIntegerv UNCORRELATED correlation of src/dst 4.1.8 color-buffer | |

_NV coverage within a pixel | |

Note: The BLEND_ADVANCED_COHERENT_NV enable is provided if and only if | |

the NV_blend_equation_advanced_coherent extension is supported. On | |

implementations supporting only NV_blend_equation_advanced, this enable is | |

considered not to exist. | |

New Implementation Dependent State | |

None. | |

NVIDIA Implementation Details | |

Older versions of this extension specification and early shipping | |

implementations supported the COLORDODGE_NV and COLORBURN_NV equations | |

without the special case discussed in issue (34). This should be fixed for | |

newer driver releases. | |

Issues | |

(1) How should these new blending operations be supported? | |

RESOLVED: Provide a separate blend equation for each of the various | |

blending operations. | |

(2) Many of these blending operations involve complicated computations on | |

the RGB color components, but corresponding alpha operations are | |

typically very simple. How should blending on the alpha channel work? | |

RESOLVED: Each new blend equation provides one equation for color and | |

another for alpha. In this extension, separate advanced blend equations | |

for color and alpha are not supported; BlendEquationSeparate does not | |

accept these enums. | |

This extension contemplated separate blend equations for RGB and alpha, | |

perhaps with only basic equations for alpha, but we chose to tie RGB and | |

alpha blending together for simplicity. | |

(3) Should we provide explicit support for premultiplied colors? | |

RESOLVED: Yes. Many of the imaging APIs supporting similar blend | |

equations use premultiplied colors, some exclusively. Additionally, | |

many equations are simpler to express and compute with premultiplied | |

colors. | |

In this extension, we choose to treat the destination colors and the | |

blend result as premultiplied. We considered providing a blend | |

parameter supporting non-premultiplied destinations, but chose to | |

support only premultiplied destinations for mathematical simplicity. | |

(4) Should we support blending where some, but not all, colors are | |

premultiplied? For example, there may be cases where the source | |

fragment colors are not premultiplied, but where the destination | |

colors are premultiplied. | |

RESOLVED: Yes, we will provide support for non-premultiplied fragment | |

colors (via a blending parameter), in which case the RGB color | |

components are multiplied by alpha prior to blending. | |

We considered requiring premultiplication in the fragment shader, but | |

opted to provide a fixed-function premultiply operation for cases where | |

it was inconvenient to modify the fragment shader to perform the | |

multiplication, or where no fragment shader is executed (e.g., | |

fixed-function fragment processing, blits via the NV_draw_texture | |

extension). | |

(5) Should we support different types of correlation between source and | |

destination coverage in partially covered pixels? If so, how? | |

RESOLVED: We will provide a blend parameter allowing for multiple | |

versions of many blending equations based on the "correlation" between | |

source and destination coverage. For pixels with partial opacity, there | |

might be three different blend cases: (a) where the portions of the | |

pixel covered by the primitives are considered to have minimal overlap | |

(e.g., abutting primitives in a mesh), (b) where the portions of the | |

pixel covered by the primitives are considered to have maximal overlap | |

(e.g., overlapping geometry), (c) where the portions of the pixel | |

covered by the primitives are considered uncorrelated. | |

(6) Should we support swapping source and destination coverage in advanced | |

blends? If so, how? | |

RESOLVED: In the current version, we don't support fully general | |

swapping. We do provide several pairs of blend equations that are | |

equivalent, other than swapping source and destination colors. For | |

example, we provide complementary blend equations SRC_OVER_NV, where the | |

source color is considered to be "over" the destination, and | |

DST_OVER_NV, where the destination color is considered to be "over the | |

source. Having pairs of equations such as "SRC_OVER" and "DST_OVER" | |

seems to be common practice in various imaging APIs. | |

Alternately, we could provide a blend parameter that simply swaps source | |

and destination for arbitrary blend equations. In the example above, we | |

could provide a single blend equation OVER_NV, where the source color is | |

considered "over" when unswapped and the destination color is considered | |

"over" when swapped. | |

(7) Should we generalize the blending operation, replacing the notions of | |

"source" and "destination" colors with more generic "A" and "B" | |

parameters, which might be obtained from a variety of sources | |

(fragment color, one of <N> color attachment points, some additional | |

source of textures/images)? | |

RESOLVED: Not in this extension; the only blending operation we support | |

takes a fragment color (which could be obtained from an arbitrary | |

source, either through a fragment shader, fixed function fragment | |

processing, or an imaging API such as NV_draw_texture) and a destination | |

color, performs a blend, and stores the result in the buffer from which | |

the destination color was extracted. | |

(8) How should we expose the various combinations of blending modes? | |

RESOLVED: The base blending equation is specified by the same | |

BlendEquation() API supported for regular OpenGL blending. Additional | |

parameters (such as pre-multiplied source colors, overlap mode, source | |

destination swapping, input selection) can be specified via the | |

BlendParameteriNV() API. | |

We could provide for a "general" blend equation API specifying multiple | |

parameters at once, such as: | |

void BlendEquationGeneralNV(enum blend, enum overlap, | |

boolean swapSrcDst); | |

but that API would require applications to pass parameters that are | |

always the same (e.g., overlap as UNCORRELATED_NV) and wouldn't be | |

easily extensible. Note that there are several features that we've | |

chosen not to include but might be usefully added as blend parameters in | |

the future -- see issues (3), (6), and (7), for example. | |

(9) What limitations apply to the new blend modes? | |

RESOLVED: In the current implementation, these blend equations are not | |

supported with more than one color buffer; if this is attempted, a | |

draw-time error is generated. This limitation is similar in nature to | |

one for dual-source blending, which implementations are not required to | |

support in conjunction with multiple color buffers. This limitation may | |

be relaxed in a future version of this extension. | |

(10) What precision is used in the computations for these blending | |

equations? | |

RESOLVED: There are no minimum precision requirements specified in | |

OpenGL 4.1, though one would expect implementations to blend with at | |

least the precision used to store destination color components. This | |

extension provides this as a minimum baseline for existing blending | |

equations. | |

For the new equations, we specify a minimum precision that is the | |

smaller of the precision of the destination buffer or the precision of | |

16-bit floating-point computations. For most formats, this meets the | |

limit for basic blend equations. However, there may be precision loss | |

if these new blending equations are used with 12-bit unsigned normalized | |

components, 16-bit unsigned or signed normalized components, or 32-bit | |

floating-point components. | |

This restriction is specified so that implementations are not required | |

to support the large number of blending equations specified here with | |

full 32-bit floating-point computations. | |

(11) When targeting a fixed-point buffer, are input color components | |

clamped to [-1,1] for signed normalized color buffers or to [0,1] for | |

unsigned normalized color buffers? | |

RESOLVED: We will use the same clamping behavior as for basic blend | |

equations, where fragment color components are clamped to [0,1] prior to | |

blending for unsigned normalized color targets. | |

Note that the OpenGL 4.1 specification, against which this spec is | |

written, had an oversight related signed normalized color buffers. It | |

specifies [0,1] clamping for all "fixed point" targets, which is clearly | |

not desired for signed normalized color buffers. Fragment shader color | |

outputs should be clamped to [-1,+1] in this case; this was fixed in | |

OpenGL 4.2 (bug 6849). | |

(12) What happens when converting a premultiplied color with an alpha of | |

zero to a non-premultiplied color? | |

RESOLVED: We specify that a premultiplied color of (0,0,0,0) should | |

produce non-premultiplied (R,G,B) values of (0,0,0). A premultiplied | |

color with an alpha of zero and a non-zero R, G, or B component is | |

considered to be ill-formed and will produce undefined blending results. | |

For a non-premultiplied color (R',G',B',A'), the corresponding | |

premultiplied color (R,G,B,A) should satisfy the equation: | |

(R,G,B,A) = (R'*A', G'*A', B'*A', A') | |

If the alpha of a non-premultiplied color is zero, the corresponding | |

premultiplied color (R,G,B,A) should be (0,0,0,0). | |

We specify that ill-formed premultiplied colors produce undefined | |

blending results to enable certain performance optimizations. In many | |

of these blending equations, the alpha component used as a denominator | |

to compute the non-premultiplied color ends up being multiplied by the | |

same alpha component in the coverage, resulting in cancellation. For | |

example, implementations may want to substitute a premultiplied | |

destination color into the last term of the basic blend equation: | |

R = f(Rs',Rd')*p0(As,Ad) + Y*Rs'*p1(As,Ad) + Z*Rd'*p2(As,Ad) | |

= ... + Z*Rd'*(Ad*(1-As)) | |

= ... + Z*(Rd'*Ad)*(1-As) | |

= ... + Z* Rd * (1-As) | |

This substitution would be invalid for ill-formed premultiplied | |

destination colors. We choose to specify undefined results for invalid | |

input colors rather than requiring implementations to skip such | |

optimizations or include logic to check for zero alpha values for each | |

input. | |

(13) Should we provide "advanced" RGB blend equations for modes commonly | |

used in dedicated imaging APIs that can already be expressed with | |

current OpenGL blending modes? | |

RESOLVED: Yes; we will provide a number of "advanced" blend equations | |

for basic computations that can be done with existing blend equations. | |

This allows applications wanting to use these advanced modes to use them | |

exclusively, without having to figure out which blends are not supported | |

and generate separate BlendEquation/BlendFunc state for each. | |

(14) How do the advanced RGB blend equations interact with sRGB color | |

buffers? In particular, how does it interact with storing | |

premultiplied color values in the framebuffer? | |

RESOLVED: When targeting an sRGB color buffer with the blend equations | |

in this extension, we will convert the destination colors from sRGB to | |

linear and will convert the linear blend result back to sRGB when | |

writing it to the framebuffer. This approach is no different from | |

regular blends. | |

sRGB conversions will affect premultiplied colors differently than | |

non-premultiplied colors since: | |

linear_to_srgb(C*A) != A * linear_to_srgb(C) | |

When storing an sRGB-encoded value into an sRGB texture or renderbuffer, | |

we expect that the values will be extracted as sRGB colors in a | |

subsequent texturing, blending, or display operation. The fetched sRGB | |

color components will be converted back to linear. Except from rounding | |

errors in converting the color components to fixed-point, converting to | |

and from sRGB will not modify the color, with or without | |

premultiplication. | |

(15) The HSL blend equations are "color surgery" operations where | |

components from the source and destination colors are mixed. Are | |

there any problems using these equations with premultiplied color | |

components? | |

RESOLVED: Like all of the "f/X/Y/Z" blends, the function f() in HSL | |

blend equations are expressed in terms of non-premultiplied colors, | |

which implies a division operation prior to evaluating f(). However, it | |

may be possible to perform some or all of the blending operation using | |

pre-multiplied colors directly. In particular, the luminosity and | |

saturation of a color with components scaled by alpha is equal to alpha | |

times the luminosity or saturation of the un-scaled color: | |

lumv3(C*A) = A * lumv3(C) | |

satv3(C*A) = A * satv3(C) | |

(16) How should we express the blending equations? | |

RESOLVED: In general, we will use the formulation found in the PDF and | |

SVG specifications, which define each blend in terms of four parameters: | |

* a function f(Cs,Cd) specifies the blended color contribution in the | |

portion of the pixel containing both the source and destination; | |

* a constant X specifies whether the region containing both the source | |

and destination contributes to the final alpha; | |

* a constant Y specifies whether the region containing only the source | |

contributes to the final color and alpha; and | |

* a constant Z specifies whether the region containing only the | |

destination contributes to the final color and alpha. | |

This formulation is relatively compact and nicely illustrates the | |

contributions from the three relevant combinations of source and | |

destination coverage; the portion of the pixel covered by neither the | |

source nor the destination contributes nothing to color or alpha. | |

Additionally, we specify three functions p0(As,Ad), p1(As,Ad), and | |

p2(As,Ad) specifying the relative portion of the pixel covered by both | |

the source and destination, just the source, and just the destination, | |

respectively. These functions are defined according to the overlap | |

blend parameter; the most common mode (UNCORRELATED) defines: | |

p0(As,Ad) = As*Ad | |

p1(As,Ad) = As*(1-Ad) | |

p2(As,Ad) = Ad*(1-As) | |

There are certain special-purpose blending equations that don't fit | |

this general model (modes that mix RGB or HSL components from the | |

source and destination). These blends don't fit nicely into the | |

mathematical formulas above and are instead defined separately as a | |

component-by-component operation. | |

(17) How should we express the equations for the HSL blend equations? | |

RESOLVED: The equations used by this specification are loosely adapted | |

from similar code in the version 1.7 of the PDF (Portable Document | |

Format) specification. The equations have been modified to use | |

GLSL-style "vec3" syntax. Additionally, they use vector math in the | |

pseudocode overriding the saturation of a base color instead of using | |

"C_min", "C_mid", and "C_max" syntax effectively defining references to | |

the three components of the base color. | |

Alternately, we could have specified functions for converting (R,G,B) | |

colors to and from an (H,S,L) color space. But we decided not to do | |

that because actual (H,S,L) colors are never used in the pipeline. | |

(18) What issues apply to the PLUS and MINUS equations? | |

RESOLVED: The PLUS and MINUS equations provide arithmetically simple | |

operations; we simply perform a component-wise add or subtract | |

operations. The most interesting question is how and where clamping is | |

performed. The original Porter-Duff compositing specification provided | |

a "plus" equation intended to support blending between two images, | |

effectively performing: | |

weight * image1 + (1-weight) * image2 | |

If the components of <image1>, <image2>, and <weight> are all in [0,1], | |

there is no need for clamping. However, in a general add with no | |

<weight> built in, there is no guarantee that adding components of two | |

images will remain inside the range [0,1]. When using fixed-point | |

unsigned normalized color buffers, the sum will automatically be clamped | |

to [0,1] when stored in the framebuffer. However, there may be cases | |

with floating-point color buffers where not clamping the sum also makes | |

sense. | |

Additionally, when storing premultiplied colors, it may also be | |

desirable to clamp R/G/B components to the range [0,A]. Premultiplied | |

colors effectively store "R*A" in the R channel, where "R" is the | |

non-premultiplied color and A is alpha. Clamping this value to A | |

ensures that the non-premultiplied form of R is in [0,1]. | |

To handle all possible cases, we provide five "PLUS" and "MINUS" | |

equations. | |

PLUS_NV: Add color and alpha components without clamping. | |

PLUS_CLAMPED_NV: Add color and alpha components; clamp each sum to | |

1.0. | |

PLUS_CLAMPED_ALPHA_NV: Add color and alpha components. Clamp the | |

alpha sum to 1.0; clamp the color sums to the alpha result (i.e., the | |

clamped alpha sum). Note that if premultiplied inputs are clamped | |

properly where 0<=R,G,B<=A, this equation isn't needed since the color | |

sums will always be less than the alpha sum. | |

MINUS_NV: Subtract the source color and alpha components from the | |

destination without clamping. | |

MINUS_CLAMPED_NV: Subtract the source color and alpha components from | |

the destination; clamp the difference to 0.0. | |

We don't bother clamping in "unexpected" direction. We don't bother | |

clamping sums to be greater than or equal to zero or differences to be | |

less than or equal to one; either case would require an unclamped input | |

with a negative component. | |

Note that when blending to an unsigned fixed-point buffer, the clamped | |

and non-clamped versions of "PLUS" and "MINUS" produce the same results, | |

since inputs and outputs are both clamped to [0,1]. | |

Note that the LINEARDODGE_NV equation is another form of "PLUS"; in the | |

area of intersection, the source and destination colors are added and | |

clamped to 1.0. | |

(19) Should we provide a blend parameter to clamp the destination color | |

(when read) to [0,1]? What about clamping premultiplied RGB | |

components to [0,a]? | |

RESOLVED: No. We expect the most common use case to involve unsigned | |

normalized color buffers, where components will automatically be clamped | |

to [0,1] by virtue of how they're stored in the framebuffer. It doesn't | |

seem worth the trouble to add a clamp-on-read feature to clamp to [0,a] | |

when it seems easy enough to program colors to stay in range. | |

(20) Should we provide a blend parameter to clamp final color or alpha | |

output components to [0,1]? What about clamping premultiplied RGB | |

outputs to [0,a]? | |

RESOLVED: As above, when writing the blend results to unsigned | |

normalized targets, output components will automatically be clamped to | |

[0,1] by virtue of how they're stored in the framebuffer. It doesn't | |

seem worth the trouble to clamp to [0,a], either. Most of the blend | |

equations supported by this extension will produce outputs with | |

premultiplied color component values in the range [0,a] as long as the | |

inputs also have that property. One exception is PLUS_NV, but we | |

explicitly provide a PLUS_CLAMPED_ALPHA_NV equation to for that case. | |

(21) Should we provide an equation like the VG_BLEND_SOFTLIGHT_SVG_KHR | |

blending equation in the KHR_advanced_blending extension to OpenVG? | |

RESOLVED: No. The KHR_advanced_blending appears to have specified a | |

equation implementing the "soft-light" compositing property in a working | |

draft of a SVG 1.2 specification, as described here: | |

http://www.w3.org/TR/2004/WD-SVG12-20041027/ | |

rendering.html#compositing | |

This version of the specification appears to have been abandoned. The | |

equations for the "soft-light" property in the SVG Compositing | |

Specification at: | |

http://www.w3.org/TR/SVGCompositing/ | |

match the SOFTLIGHT_NV equation provided by this extension and | |

VG_BLEND_SOFTLIGHT_KHR (no "SVG") in KHR_advanced_blending. | |

Additionally, the equations in the SVG 1.2 draft and the | |

KHR_advanced_blending extension both appear to contain clear errors in | |

the first and second cases. Both begin with "(cd*(as-(1-cd/ad)*..." in | |

the KHR spec but should be "(cd*(as+(1-cd/ad)*...". Both of these sign | |

errors are corrected in the "SVG" functions in this extension. With the | |

errors, there is a local minimum at Cs=0.5 (where we switch from the | |

first form to the second or third) and the function has a major | |

discontinuity at Cd=0.125 when Cs>0.5 (where we switch from the second | |

form to the third). For example, when Cs=0.8 and Cd=0.125, the second | |

form of the KHR extension would generate a result of -0.00625 and the | |

third form would generate a result of ~0.26213. Note that the corrected | |

equations still aren't continuous at Cd=0.125; the fixed second and | |

third forms generate 0.25625 and 0.26213, respectively, when Cs=0.8 and | |

Cd=0.125. | |

(22) What issues apply to the INVERT and INVERT_OVG_NV equations? | |

RESOLVED: The INVERT and INVERT_OVG_NV equations were included to | |

provide functionality similar to the same VG_BLEND_INVERT_KHR blend | |

equation provided by the KHR_advanced_blending extension to OpenVG and | |

similar equations in a few other compositing APIs/standards. | |

Unfortunately, the equation specified by the KHR extension has issues. | |

The apparent intent of this blend equation is to use the source alpha to | |

blend between the destination color and an inverted form of the | |

destination color. This description conceptually matches the | |

description in the KHR extension: | |

(1 - asrc) * c'dst + asrc * (1 - c'dst) | |

However, since source and destination colors are premultiplied, the | |

expression "1-c'dst" doesn't correctly invert the destination color. To | |

invert a premultiplied destination color, "adst-c'dst" should be used. | |

For example, if the premultiplied destination color is 50% gray and 50% | |

opaque (adst=0.5), the RGBA destination color will be | |

(0.25,0.25,0.25,0.5). Inverting the color components via "1-c'dst" | |

would yield RGB component values of 0.75, which isn't consistent with an | |

alpha of 0.5. Inverting via "adst-c'dst" would yield correct RGB | |

component values of 0.25. | |

Additionally, the alpha computed for this equation in the KHR extension | |

is the standard "asrc+adst*(1-asrc)", equivalent to X=Y=Z=1 in our | |

normal formulation. However, given that the source color doesn't | |

contribute at all, having "Y=1" doesn't make a whole lot of sense. The | |

INVERT equation used in this extension uses X=Z=1 and Y=0, which means | |

that blending with this equation never changes destination alpha. | |

We provide a separate blend equation INVERT_OVG_NV to provide | |

compatibility with the formulation in the KHR extension. The math in | |

the KHR extension does perform a "valid" blending operation -- it will | |

produce results that remain in [0,1] when inputs are in [0,1], and its | |

results are continuous. It can't be expressed directly via our f/X/Y/Z | |

parameterization, but it does match our general f/X/Y/Z model if you | |

consider all three areas to contribute where: | |

* the intersection area contributes the inverted destination color | |

* the destination-only area contributes the destination color | |

* the source-only area contributes full white | |

Note that INVERT and INVERT_OVG_NV equations are mathematically | |

equivalent when the destination is opaque (i.e., adst=1.0); in this | |

case, "1-c'dst" and "adst-c'dst" are equivalent. In our f/X/Y/Z model, | |

the full destination coverage means there is no "source-only" area in | |

this case. | |

(23) What issues apply to the PLUS_DARKER_NV blend equation? | |

RESOLVED: The PLUS_DARKER_NV equation corresponds to an equation | |

provided in the Quartz 2D API from Apple. The public documentation for | |

this equation specifies the color computed by this operation as: | |

R = MAX(0, 1 - ((1 - D) + (1 - S))) | |

This equation appears to want to invert the source and destination | |

colors, add the two inverted colors, and then invert the result. | |

However, this equation appears to assume opaque source and destination | |

colors. As noted in the discussion for INVERT_OVG_NV, inverting a color | |

via "1-C" doesn't make any sense. We've reformulated the equations to | |

use pre-multipled colors and invert with "A-C" in a manner similar to | |

that described in this email thread: | |

http://www.mail-archive.com/whatwg@lists.whatwg.org/msg06536.html | |

which appears to be the "darker" mode implemented in the Safari browser | |

(at least in 2007). Our formulation is equivalent to the one in the | |

Quartz 2D documentation when As=Ad=1. | |

(24) Should we apply the f/X/Y/Z formulation to blend equations where the | |

equations can be expressed this way only if one or more of X, Y, or | |

Z are neither zero nor one? | |

RESOLVED: No. The f/X/Y/Z model subdivides a pixel into four regions | |

based on the alpha of the source and the destination, three of which | |

(intersection, source only, destination only) either contribute or don't | |

contribute color and coverage based on the given blend equation. The | |

figure below depicts a pixel where the source and destination both have | |

coverage of 0.5 (50%). The picture assigns source coverage to the upper | |

left portion of the pixel and the destination coverage to the upper | |

right, and assumes an UNCORRELATED model. In this case, the pixel is | |

divided into four areas of equal size. The area of intersection is at | |

the top, and its color and coverage are controlled by the f() and X | |

parameters. The source-only and destination-only regions are on the | |

left and right, respectively, and color and coverage are both controlled | |

by the Y and Z parameters. | |

+-----------+ | |

|\_ f/X _/| | |

source | \_ _/ | destination | |

(upper ==>| Y \_/ Z | (upper | |

left) | _/ \_ | <== right) | |

| _/ \_ | | |

|/ \| | |

+-----------+ | |

The PLUS_NV equation could be expressed with f(Cs,Cd) = Cs+Cd, X=2, Y=1, | |

and Z=1. The X=2 term effectively has the source and destination *both* | |

contribute coverage in the area of intersection. The MINUS_NV equation | |

could be expressed with f(Cs,Cd) = Cd-Cs, X=1, Y=-1, and Z=1. The Y=-1 | |

term effectively has the source-only portion of the pixel *remove* | |

coverage. Both of these don't match the physical model, and would yield | |

odd results when combined with conjoint or disjoint overlap modes. | |

(25) Should we provide more specialized versions of CONJOINT_NV and | |

DISJOINT_NV? | |

RESOLVED: Not in this extension. In the future, we could add new | |

overlap modes such as: | |

NON_INTERSECTING_NV: Like DISJOINT_NV, except that it assumes that | |

As+Ad<=1. This might be interesting when rendering polygons with | |

POLYGON_SMOOTH? | |

DST_INSIDE_NV, SRC_INSIDE_NV: Like CONJOINT_NV, except that it | |

assumes that the destination coverage is fully inside the source or | |

vice versa. For DST_INSIDE, the p0/p1/p2 terms would be Ad, As-Ad, | |

and 0, respectively. | |

For all three of these modes, the specialized versions would have | |

simpler and possibly more efficient math. We're not going to add any of | |

these modes in this extension, however. | |

(26) Should the blend equations have a common prefix (e.g., | |

"BLEND_SRC_OVER") or just use forms without a prefix? | |

RESOLVED: Use forms without a prefix where the tokens are only used in | |

the context of blending (i.e., via the BlendEquation API). We will use | |

a "BLEND_" prefix to identify BlendParameter <pname> values because | |

those tokens can also be used in the general GetIntegerv API. Note that | |

in current OpenGL, some parameters have their own Get* API (e.g., | |

TexParameter), while others use the general GetInteger queries (e.g., | |

PointParameter). | |

(27) Should we use standard GL enums for the blend equations that already | |

have these names? | |

RESOLVED: Yes, to minimize the number of new enums. The primary risk | |

is that reusing standard enum definitions would be problematic if a | |

future core version wanted to use these parameters in the same place | |

with a different meaning. However, all such names are in common use in | |

various compositing standards and our semantics are consistent with | |

those standards. | |

(28) What other APIs support blend equations similar to the ones provided | |

here, and how does the feature set compare? | |

RESOLVED: Khronos' OpenVG 1.1 vector graphics library provides a | |

variety of basic blending equations, with additional modes provided by | |

the KHR_advanced_blending extension: | |

* http://www.khronos.org/registry/vg/specs/openvg-1.1.pdf | |

* http://www.khronos.org/registry/vg/extensions/KHR/advanced_blending.txt | |

The World Wide Web Consortium (W3C)'s Scalable Vector Graphics format | |

supports a variety of blending equations in its compositing | |

specification: | |

* http://www.w3.org/TR/SVGCompositing | |

W3C also has a CSS standard (Compositing and Blending Level 1): | |

* http://www.w3.org/TR/compositing-1/ | |

Adobe's widely-used Portable Document Format (PDF) specification | |

provides numerous blending equations in its "Transparency" section: | |

* http://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/ | |

pdf_reference_1-7.pdf | |

Adobe's SWF (Flash) File Format Specification | |

* http://www.adobe.com/go/swfspec | |

Various "2D" graphics APIs, including Oracle's JavaFX, Apple's Quartz | |

2D, Qt's QPainter class, and X Window System's X Rendering Extension | |

also support a variety of blending equations: | |

* http://docs.oracle.com/javafx/2/api/javafx/scene/effect/BlendMode.html | |

* http://developer.apple.com/library/ios/#documentation/GraphicsImaging/ | |

Reference/CGContext/Reference/reference.html | |

* http://doc.qt.digia.com/4.7/qpainter.html#composition-modes | |

* http://www.x.org/releases/current/doc/renderproto/renderproto.txt | |

The following table indicates the set of blend equations from this | |

extension that are supported in these various standards or APIs. "X" | |

indicates that the equation is supported. For OpenVG, "E" indicates | |

that the equation is supported by the KHR_advanced_blending extension. | |

"XO" that the indicates that the equation is supported with conjoint and | |

disjoint overlap modes; others support only the uncorrelated overlap | |

mode. | |

Blending Equation OVG SVG PDF SWF JFX Q2D QPT XRE | |

-------------------- ----- ----- ----- ----- ----- ----- ----- ----- | |

ZERO E X - - - X X XO | |

SRC_NV X X - X - X X XO | |

DST_NV E X - - - - X XO | |

SRC_OVER_NV X X X X X X X XO | |

DST_OVER_NV X X - - - X X XO | |

SRC_IN_NV X X - - - X X XO | |

DST_IN_NV X X - X - X X XO | |

SRC_OUT_NV E X - - - X X XO | |

DST_OUT_NV E X - X - X X XO | |

SRC_ATOP_NV E X - - X X X XO | |

DST_ATOP_NV E X - - - X X XO | |

XOR_NV E X - - - X X XO | |

MULTIPLY_NV X X X X X X X X | |

SCREEN_NV X X X X X X X X | |

OVERLAY_NV E X X X X X X X | |

DARKEN_NV X X X X X X X X | |

LIGHTEN_NV X X X X X X X X | |

COLORDODGE_NV E X X - X X X X | |

COLORBURN_NV E X X - X X X X | |

HARDLIGHT_NV E X X X X X X X | |

SOFTLIGHT_NV E X X - X X X X | |

DIFFERENCE_NV E X X X X X X X | |

EXCLUSION_NV E X X - X X X X | |

INVERT - - - X - - - - | |

INVERT_RGB_NV - - - - - - - - | |

LINEARDODGE_NV E - - - - - - - | |

LINEARBURN_NV E - - - - - - - | |

VIVIDLIGHT_NV E - - - - - - - | |

LINEARLIGHT_NV E - - - - - - - | |

PINLIGHT_NV E - - - - - - - | |

HARDMIX_NV E - - - - - - - | |

HSL_HUE_NV - - X - - X - X | |

HSL_SATURATION_NV - - X - - X - X | |

HSL_COLOR_NV - - X - - X - X | |

HSL_LUMINOSITY_NV - - X - - X - X | |

PLUS_NV / | |

PLUS_CLAMPED_NV / X X - X X X X X | |

PLUS_CLAMPED_ALPHA_NV | |

PLUS_DARKER_NV - - - - - X - - | |

MINUS_NV / E - - X - - - - | |

MINUS_CLAMPED_NV | |

CONTRAST_NV - - - - - - - - | |

INVERT_OVG_NV E - - - - - - - | |

RED_NV - - - - X - - - | |

GREEN_NV - - - - X - - - | |

BLUE_NV - - - - X - - - | |

OpenGL COLOR_LOGIC_OP - - - - - - X - | |

(not in this extension) | |

Notes: | |

* The PLUS_NV, PLUS_CLAMPED_NV, and PLUS_CLAMPED_ALPHA_NV equations | |

are very similar and may be indistinguishable when the destination | |

buffer components are stored in normalized [0,1] numeric spaces, as | |

is the case in most of these standards. The MINUS_NV and | |

MINUS_CLAMPED_NV equations behave similarly. | |

* The SWF specification has a mode called "invert", but it's not clear | |

whether the mode is implemented using INVERT, INVERT_OVG_NV, or some | |

other equation. | |

(29) Should we provide an extension that can be supported on | |

implementations that may not provide fully coherent blending when | |

using the new equations? If so, how will this support be provided | |

and what limitations apply? | |

RESOLVED: Yes, this functionality is useful not just for general 3D | |

rendering, but also for 2D rendering operations (where the primitives | |

rendered may be less complex). As indicated in the issue above, the | |

blend equations provided by this extension are already very commonly | |

used in 2D rendering. Accelerating them on a wide range of GPUs, old | |

and new, would be very useful. | |

Older NVIDIA GPUs are able to support these blending equations as long | |

as rendering is split into distinct passes and no pixel is touched more | |

than once in any given pass. For such GPUs, we specify that the results | |

of blending are undefined if a single pixel (or sample) is touched more | |

than once in a pass, and provide the command BlendBarrierNV() to allow | |

applications to delimit boundaries between passes. As long as rendering | |

commands can be split into passes with barriers, advanced blending will | |

work "normally" even on these older GPUs. | |

Since there are two distinct levels of capability, we will advertise two | |

different extension string entries: | |

- GL_NV_blend_equation_advanced: Provides the new blending | |

functionality without support for full coherence (older GPUs). | |

- GL_NV_blend_equation_advanced_coherent: Provides the new blending | |

functionality with full coherence. | |

Since the functionality of these two extensions is nearly identical, we | |

document them in a single extension specification. | |

(30) On implementations that don't support fully coherent blending, should | |

we provide any convenience features so that "2D" applications aren't | |

required to manually sprinkle BlendBarrierNV() throughout the code? | |

RESOLVED: Yes. When using NV_blend_equation_advanced in conjunction | |

with NV_path_rendering commands like CoverFillPathNV and | |

CoverStrokePathNV, the driver will assist in ensuring coherent and | |

properly ordered blending by inserting implicit blend barriers before | |

rendering each cover primitive. | |

(31) When we generate fragments using the automatic coherence guarantees | |

from NV_path_rendering commands like CoverFillPathNV, what happens if | |

a pixel touched by CoverFillPathNV had already been touched by a | |

previous non-NVpr rendering command without an intervening call to | |

BlendBarrierNV? What happens if a pixel touched by CoverFillPathNV | |

is subsequently touched by a subsequent non-NVpr without an | |

intervening call to BlendBarrierNV? | |

RESOLVED: We specify that a blend barrier is inserted prior to each | |

cover primitives, so that cover primitives are blended coherently | |

relative to geometry from previous primitives (cover or otherwise). We | |

do not guarantee that a blend barrier is inserted after each cover | |

primitive, so applications need to call BlendBarrierNV manually if | |

subsequent non-cover primitives are rendered to the same set of pixels. | |

(32) On implementations supporting fully coherent blending, should we | |

provide some mode allowing implementations to opt out of coherent | |

blending? | |

RESOLVED: Yes. We will provide an enable allowing applications to | |

disable coherent blending in case where (a) implementations are able to | |

provide higher-performance implementations if they don't have to worry | |

about full coherence and/or ordering and (b) applications are willing to | |

use BlendBarrierNV() to take advantage of the higher-performance | |

implementation. The enable will be on by default, which means that | |

advanced blending on fully capable implementations will be "safe" unless | |

explicitly disabled. | |

(33) When fully coherent blending is disabled or not supported, | |

BlendBarrierNV() is used to indicate boundaries between passes. | |

Should any other commands in the OpenGL API also implicitly serve as | |

blend barriers? | |

RESOLVED: In general, no. Except for the NV_path_rendering case above, | |

we will require applications manually use BlendBarrierNV(). There may | |

be other operations that indirectly cause blend results to become | |

coherent (in an implementation-dependent way), but we don't attempt to | |

provide any explicit guarantees. Except for path rendering cover | |

primitives (see issues 30 and 31), applications should always call | |

BlendBarrierNV() between possibly overlapping passes. | |

Note that implementations of this extension may use texture mapping | |

hardware to source the framebuffer for blending and may end up caching | |

pre-blended texel values. This can cause subsequent texture fetches to | |

return stale values unless the texture is re-bound, the | |

TextureBarrierNV() command from the NV_texture_barrier extension is | |

used, or some other action is taken to break the "rendering feedback | |

loop". The existing spec already defines that texel fetches produce | |

undefined results when a texture object is bound both as a texture and | |

attached to the current draw framebuffer, with or without advanced blend | |

equations. See the "Rendering Feedback Loops" section (p. 316 in the | |

OpenGL 4.1 Compatibility Profile specification) for more information. | |

(34) How should the blend equations COLORDODGE_NV and COLORBURN_NV be | |

expressed mathematically? | |

RESOLVED: We changed the definition of these equations after the | |

NV_blend_equation_advanced spec was originally published, as discussed | |

below. These changes add new special cases to the COLORDODGE_NV and | |

COLORBURN_NV equations that are found in newer compositing standard | |

specifications and in a number of implementations of old and new | |

standards. We believe that the omission of the special case in other | |

older specifications is a bug. We have no plans to add new blend | |

equation tokens to support "equivalent" modes without the new special | |

case. | |

Note, however, that older versions of this extension and older NVIDIA | |

drivers implementing it will lack these special cases. A driver update | |

may be required to get the new behavior. | |

There is some disagreement in different published specifications about | |

how these two blend equations should be handled. At the time this | |

extension was initially developed, all specifications we found that | |

specified blending equations mathematically (see issue 28) were written | |

the same way. Since then, we discovered that newer working drafts of | |

the W3C Compositing and Blending Level 1 specification (for CSS and SVG) | |

express "color-burn" as follows (translated to our nomenclature): | |

if (Cd == 1) // their Cb (backdrop) is our Cd (destination) | |

f(Cs,Cd) = 1 // their B() is our f() | |

else if (Cs == 0) | |

f(Cs,Cd) = 0 | |

else | |

f(Cs,Cd) = 1 - min(1, (1-Cd)/Cs) | |

http://www.w3.org/TR/2013/WD-compositing-1-20131010/ | |

#blendingcolorburn | |

Earlier versions of the same W3C specification, an older SVG compositing | |

draft specification, the Adobe PDF specification (and the ISO 32000-1 | |

standard), and the KHR_advanced_blending extension to OpenVG all specify | |

the following equation without the initial special case: | |

if (Cs == 0) | |

f(Cs,Cd) = 0 | |

else | |

f(Cs,Cd) = 1 - min(1, (1-Cd)/Cs) | |

http://www.w3.org/TR/2012/WD-compositing-20120816/ | |

#blendingcolorburn | |

http://www.w3.org/TR/2011/WD-SVGCompositing-20110315/ | |

http://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/ | |

pdfs/pdf_reference_1-7.pdf | |

http://www.khronos.org/registry/vg/extensions/KHR/ | |

advanced_blending.txt | |

For the Adobe PDF specification, the corrected blend equations are | |

published in an Adobe supplement to ISO 32000-1 and are expected to be | |

accepted in a future version of the standard: | |

http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/ | |

devnet/pdf/pdfs/adobe_supplement_iso32000_1.pdf | |

The author's understanding is that multiple shipping implementations of | |

these blending modes implement the special case for "Cd==1" above, | |

including various Adobe products and the open-source Ghostscript | |

project. | |

We believe that the extra special case in this specification is | |

consistent with the physical model of color burning. Burning is | |

described in | |

http://en.wikipedia.org/wiki/Dodging_and_burning | |

as making a print with normal exposure, and then adding additional | |

exposure to darken the overall image. In the general equation: | |

1 - min(1, (1-Cd)/Cs) | |

Cs operates as a sort of fudge factor where a value of 1.0 implies no | |

additional exposure time and 0.0 implies arbitrarily long additional | |

exposure time, where the initial amount of exposure (1-Cd) is multiplied | |

by 1/Cs and then clamped to maximum exposure by the min() operation. | |

The Cd==1 special case here implies that we get zero exposure in the | |

initial print, since 1-Cd==0. No amount of extra exposure time will | |

generate any additional exposure. This would imply that the final | |

result should have zero exposure and thus a final f() value of 1. This | |

matches the initial special case. Without that special case, we would | |

hit the second special case if Cs==0 (infinite exposure time), which | |

would yield an incorrect final value of 0 (full exposure). | |

A similar issue applies to COLORDODGE_NV, where some specifications | |

include a special case for Cb==0 while others do not. We have added a | |

special case there as well. | |

(35) For "HSL" blend equations, the blend equation involves a clipping | |

step where colors may be "clipped" if the blend would produce | |

components are outside the range [0,1]. Are there inputs where this | |

blend could produce ill-defined or nonsensical results? | |

RESOLVED: Yes, the results of HSL blend equations are undefined if the | |

input colors have components outside the range [0,1]. Even if the input | |

colors are in-range, the basic color adjustment done in these blends | |

could produce result components outside the range [0,1]. To compensate, | |

the ClipColor() function in the specification interpolates the result | |

color and a greyscale value that matches the luminance of the result. | |

The math for the clipping operation assumes the luminance of the result | |

color is in the range [0,1]. If that isn't the case, the clipping | |

operation could result in a divide by zero (when all result components | |

have the same out-of-bounds value) or perform an otherwise nonsensical | |

computation. | |

Revision History | |

Rev. Date Author Changes | |

---- -------- -------- ---------------------------------------------- | |

10 02/14/18 pdaniell Fix ClipColor() equation where in the | |

"if (maxcol > 1.0)" body the "(color-lum)*lum" | |

term should have been "(color-lum)*(1-lum)". | |

Also add new issue 35 for the case where the | |

inputs to SetLum() are outside the range | |

[0..1] and could cause a divide-by-zero in | |

ClipColor(). | |

9 09/30/14 pbrown Fix incorrectly specified color clamping in | |

the HSL blend modes. | |

8 02/26/14 pbrown For non-coherent blending, clarify that all | |

writes to a sample are considered to "touch" | |

that sample and require a BlendBarrierOES call | |

before blending overlapping geometry. Clears, | |

non-blended geometry, and copies by | |

BlitFramebuffer or TexSubImage are all | |

considered to "touch" a sample (bug 11738). | |

Specify that non-premultiplied values | |

corresponding to ill-conditioned premultiplied | |

colors such as (1,1,1,0) are undefined (bug | |

11739). Update issue (12) related to | |

ill-conditioned premultiplied colors. | |

7 11/06/13 pbrown Fix the language about non-coherent blending | |

to specify that results are undefined only if an | |

individual *sample* is touched more than once | |

(instead of *pixel*). Minor language tweaks to | |

use "equations" consistently, instead of | |

sometimes using "modes". | |

6 10/21/13 pbrown Add NV-suffixed names for tokens reusing values | |

from core OpenGL enums (XOR, RED, GREEN, BLUE) | |

that are not in core OpenGL ES 2.0. This allows | |

code targeting both APIs to use the same | |

NV-suffixed #defines. Some older versions of | |

the OpenGL "glext.h" header will not have the | |

NV-suffixed names. | |

5 10/21/13 pbrown Add a reference to the Adobe supplement to | |

ISO 32000-1, which includes the corrected | |

equations for COLORDODGE_NV and COLORBURN_NV. | |

Move "NVIDIA Implementation Details" down | |

a bit in the spec. | |

4 10/16/13 pbrown Modify the definition of COLORDODGE_NV and | |

COLORBURN_NV to match de facto standard | |

implemenations and new CSS/SVG compositing | |

spec; add issue (34). | |

3 08/19/13 pbrown Fix typos in the OpenGL ES 2.0 and 3.0 | |

interactions sections. | |

2 07/25/13 mjk Add W3C CSS compositing reference. | |

1 pbrown Internal revisions. |