Using the NV_blend_equation_advanced extension, your OpenGL programs can use the standard set of blend modes used by 2D compositing applications. NV_path_rendering makes path rendering with blend modes easy. These extensions work on all Fermi- and Kepler-based NVIDIA GPUs.

1. Blend Modes for OpenGL
Mark Kilgard
NVIDIA Corporation
February 12, 2014

2. Background
• Various standards support “blend modes”
– Compositing standards
– 2D standards
– Path rendering standards
• Example standards
– PostScript, PDF, SVG, OpenVG, XRender, Cairo,
Skia, Mac’s Quartz 2D, Flash, Java 2D, Photoshop,
Illustrator
• Blend modes have a theory distinct from 3D’s
glBlendFunc, etc. functionality
– glBlendFunc, etc. expose hardware operations
– Blend modes based on sound compositing theory

3. Blend Mode
Examples
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Normal
Multiply
Screen
Overlay
Soft Light
Hard Light
Color Dodge
Color Burn
Darken
Lighten
Difference
Exclusion
Hue
Saturation
Color
Luminosity

4. Goal for Accelerating Blend Modes
• Market motivation: 2D, compositing, and path
rendering standards key to smart phones,
tablets, and similar devices
– Motivation is primarily for low-end, power-constrained
devices
• Also part of content creation
– Autodesk Mudbox, Adobe Illustrator, etc. all use blend
modes as their vocabulary for compositing
• Power-efficient hardware support for “blend
modes”

5. Standards Reliant on Blend Modes
Document
Printing and
Exchange
Immersive
Web
Experience
2D Graphics
Programming
Interfaces
Context
Creation
Applications
Java 2D
API
Adobe Illustrator
Flash
QtGui
API
Scalable
Vector
Graphics
Mac OS X
2D API
Open XML
Paper (XPS)
HTML 5
Khronos API
Inkscape
Open Source

6. Adobe Illustrator CS6

7. Mudbox Blend Modes

8. PaintShop Pro

9. Gimp too!

10. Blend Modes are Part of
Vocabulary of Digital Media
• Example: $200 course on mastering blend modes

11. Artists have Blend Modes
at their Fingertips
• Literally…
Adobe
Creative
Suite
shortcuts

12. Why the Weird Names?
• A few blend modes have weird names
– Color Dodge
– Color Burn, etc.
• These come from photography
Antiquated process of
dodging while
developing photos
Blend modes provide
“digital” version of same effect

13. Observations
• Blend mode standards decouple blend mode from
fragment coloring
– Jargon of these standards
• Fragment coloring = “paint mode”
– Examples: radial color ramp, linear color ramp, constant color, image
gradient
• Blending = “blend mode”
– Examples: src-over, color-dodge, soft-light, src-atop
– Motivates keeping blend mode & fragment shaders distinct
• Compositing lacks need for multi-render targets
– Multiple render targets (MRT) is a 3D concept primarily for
deferred rendering
– Compositing standards have relatively cheap fragment coloring
+ transparency is common (opaque hiding is rare) so deferred
rendering isn’t applicable
– Comparable concept in blend mode standards is layering, but
layering is an explicit concept

14. Paint independent from
Blend Mode
• OpenGL decouples
• Blend mode
blending from shading
standards also
decouple
Primitive
Rasterization
Path
Rasterization
Fragment
Shading
Paint
Blending
Blend Mode
Paint &
blend mode
are independently
specified!

15. What is a Blend Mode?
• Two inputs
– RGBA color A
– RGBA color B
• One result
RGBA
RGBA
RGBA
Blend Mode
– RGBA color result
• Essentially a function
RGBA
– result = blendMode(colorA, colorB)
• More can be said about the nature of this
blendMode function…

16. Pre-multiplied Alpha
• Blend modes assume pre-multiplied alpha
– Pre-requisite for associative blending
• OpenGL users often naïve about this
– Often use “straight alpha” wrongly
– Examples
• RGBA colors texture filter incorrectly unless stored in pre-multiplied
alpha
• Use GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA for glBlendFunc
– Instead proper mode is GL_ONE,GL_ONE_MINUS_SRC_ALPHA
– Otherwise destination alpha is useless for further compositing
• Major contribution of Porter-Duff paper: pre-multiplied alpha
– 2D compositing people know this and only use pre-multiplied alpha
– Blend modes make sense in terms of pre-multiplied alpha
Pre-multiplied alpha: ( A×R,A×G,A×B,A )
Straight alpha: ( R,G,B,A )
GOOD
 BAD

17. Blend Mode Associativity
•
Associativity is useful & common
– srcOver(A, srcOver(B,C)) = srcOver(srcOver(A,B), C)
– srcOver(X,Y) function is Xca + (1-Xa)×Yca
– Notation, assuming pre-multiplied alpha
• Xc = color component (R, G, or B) of X
• Xa = alpha component of X
• Xca = Xc×Xa
•
identical
expansion
•
Math proof
– srcOver(A, srcOver(B,C)
= Aca + (1-Aa)×(Bca+(1-Ba)×Cca)
= Ac×Aa+Bc×Ba+Cc×Ca-Cc×Ca×Ba-Aa×Bc×Ba-Cc×Ca×Aa+Cc×Ca×Ba×Aa
– srcOver(srcOver(A,B), C)
= (Aca+(1-Aa)×Bca)+(1-(Aa+(1-Aa)×Ba))×Cca
= Ac×Aa+Bc×Ba+Cc×Ca-Cc×Ca×Ba-Aa×Bc×Ba-Cc×Ca×Aa+Cc×Ca×Ba×Aa
Interpretation
– “over” compositing of A(BC) is same as (AB)C
– Not all blend modes are associative, but many are

18. Blend Mode Structure
• How is a blend mode structured?
• When color A and B composite on a pixel, there
are four regions
–
–
–
–
A∩B
A ∩ ~B
~A ∩ B
~A ∩ ~B
• Each region has a percentage of coverage
– Notation: cover(X) means % of region X covering the pixel
– 100% = cover(A ∩ B)+cover(A ∩ ~B)+cover(~A ∩ B)+cover(~A ∩ ~B)
• “Whole is the sum of its parts”
– Color contributions should be weighted by coverage percentage

19. Intra-pixel Regions for Compositing
A∩B
A ∩ ~B
~A ∩ B
~A ∩ ~B
Source: SVG Compositing Specification

20. Blend Model Internals
•
Assume uncorrelated overlap within a pixel
– Based on conditional probability
– (We will change this uncorrelated overlap assumption later…)
•
Analytical coverage of each of the 4 regions
–
–
–
–
–
cover(A ∩ B) = Aa×Ba
cover(A ∩ ~B) = Aa×(1-Ba)
cover(~A ∩ B) = (1-Aa)×Ba
cover(~A ∩ ~B) = (1-Aa)×(1-Ba)
Confirm sums to 100%
• Yep, Aa×Ba+Aa×(1-Ba) + (1-Aa)×Ba+(1-Aa)×(1-Ba) = 100%
•
Included color of A ∩ ~B and ~A ∩ B regions is fairly obvious
– color(A ∩ ~B) = Ac
• because this is the region of A that’s not overlapped with B, its color is obviously the
color A (no mixing with B occurs)
– color(~A ∩ B) = Bc
• similarly, because this is the region of B that’s not overlapped with A, its color is
obviously the color B (no mixing with A occurs)
•
Trivial when ~A ∩ ~B
– color(~A ∩ ~B) = (0,0,0,0) since no color here, treat as 0% opaque, no color
•
The interesting region is A ∩ B — this the region where A and B are mixing

21. Blend Mode Assembled
• RGB result = color(A ∩ B)×cover(A ∩ B) +
color(A ∩ ~B)×cover(A ∩ ~B) +
color(~A ∩ B)×cover(~A ∩ B) +
0%
• Alpha result= cover(A ∩ B) +
cover(A ∩ ~B) +
cover(~A ∩ B) + 0%
= Aa×Ba + Aa×(1-Ba) + (1-Aa)×Ba
=Aa + (1-Aa)×Ba

22. (f,X,Y,Z) Notation for Blend Modes
• Each blend mode can be specified by quadruple
of state: f, X, Y, and Z
– f is arbitrary function of input colors
– X, Y, and Z are either zero or one
• Together make RGBA result
R
G
B
A
= f(Rs',Rd')*p0(As,Ad) + Y*Rs'*p1(As,Ad) +
= f(Gs',Gd')*p0(As,Ad) + Y*Gs'*p1(As,Ad) +
= f(Bs',Bd')*p0(As,Ad) + Y*Bs'*p1(As,Ad) +
=
X*p0(As,Ad) + Y*
p1(As,Ad) +
Z*Rd'*p2(As,Ad)
Z*Gd'*p2(As,Ad)
Z*Bd'*p2(As,Ad)
Z*
p2(As,Ad)
where p0, p1, and p2 are overlap weighting functions
– Always between 0% and 100%

23. Example Blend Modes
(X,Y,Z) = (1,1,0)
f(Cs,Cd) = Cs
DST
(X,Y,Z) = (1,0,1)
f(Cs,Cd) = Cd
DST_OVER
(X,Y,Z) = (1,1,1)
f(Cs,Cd) = Cd
COLORDODGE
difficult
(f,X,Y,Z) Notation
SRC
easy
Blend Mode
(X,Y,Z) = (1,1,1)
f(Cs,Cd) = min(1,Cd/(1-Cs)), Cs < 1
= 1, Cs ≥ 1
COLORBURN
(X,Y,Z) = (1,1,1)
f(Cs,Cd) = 1-min(1,(1-Cd)/Cs), Cs > 0
= 0, Cs ≤ 0

24. Difficult Blend Mode
Usage Examples
Color Burn
Color Dodge

25. Mixing color(A ∩ B) into Complete
Blend Mode Function
• Mixed region is color(A ∩ B)
• Described by a function f(Ac,Bc)
–
–
–
–
3-component vector function
inputs are two RGB color
output is a mixed RGB color
Mixing means “mixing RGB colors” (alpha isn’t involve)
• Function f has an intuitive mean
– Example: src-over’s f(Ac,Bc) is simply Ac
• Template blend mode function (uncorrelated):
result
= f(Ac,Bc)×Aa×Ba + Ac×Aa×(1-Ba) + Bc×(1-Aa)×Ba
• Example: Substitute template for src-cover case when
f(Ac,Bc)=Ac
result
= Ac×Aa×Ba + Ac×Aa×(1-Ba) + Bc×(1-Aa)×Ba
= Ac×Aa + (1-Aa)×Bc×Ba
= Aca + (1-Aa)×Bca

26. Selecting Coverage Contributions
•
Classic Porter & Duff “Compositing Digital Images” paper
– Says how A and B composite
•
Supports idea of constraining contributions
– Example: A src-in B means “portion of A that is inside B’s region”
• Not interested in contributions from A∩~B and ~A∩B regions
• So zero these contributions
• But src-in’s f(Sc,Dc) function is Sc (just like src-over)
•
Selectable template blend mode template equation:
Rca = f(Ac,Bc)×Aa×Ba + Y×Ac×Aa×(1-Ba) + Z×Bc×(1-Aa)×Ba
Ra = X×Aa×Ba + Y×Aa×(1-Ba) + Z×(1-Aa)×Ba
– Notice the X, Y, and Z selection terms
– X, Y, and Z are either one (meaning include) or zero (meaning exclude)
• Note: X is only used in the alpha version
•
Value of (X,Y,Z) for src-in is (1,0,0), expansion becomes
– Rca
– Ra
= Ac×Aa×Ba + 0%×Ac×Aa×(1-Ba) + 0%×Bc×(1-Aa)×Ba
= Aca×Ba + 0% + 0%
= Aca×Ba
= X×Aa×Ba + Y×Aa×(1-Ba) + Z×(1-Aa)×Ba
= Aa×Ba

27. Seminal Paper in
Computer Graphics

28. Porter & Duff Modes
Operation
X
Y
Z
Clear
All Porter-Duff
modes are
expressible
in (f,X,Y,Z)
notation…
f(Ac,Bc)
0
0
0
0
Src
Ac
1
1
0
Dst
Bc
1
0
1
Src-Over
Ac
1
1
1
Dst-Over
Bc
1
1
1
Src-In
Ac
1
0
0
Dst-In
Bc
0
1
0
Src-out
0
0
1
0
Dst-out
0
0
0
1
Src-atop
Ac
1
0
1
Dst-atop
Bc
1
1
0
Xor
0
0
1
1
Porter & Duff blend modes

29. Conceptualization of
Porter-Duff Blend Modes

30. Porter & Duff Modes Expanded
Operation
f(Ac,Bc)
X
Y
Z
Blend mode
Clear
0
0
0
0
0
Src
Ac
1
1
0
Aca
Dst
Bc
1
0
1
Bca
Src-Over
Ac
1
1
1
Aca+(1-Aa)×Bca
Dst-Over
Bc
1
1
1
Bca+(1-Ba)×Aca
Src-In
Ac
1
0
0
Aca×Ba
Dst-In
Bc
0
1
0
Bca×Aa
Src-out
0
0
1
0
(1-Ba)×Aca
Dst-out
0
0
0
1
(1-Aa)×Bca
Src-atop
Ac
1
0
1
Aca×Ba+(1-Aa)×Bca
Dst-atop
Bc
1
1
0
(1-Ba)×Aca+Aa×Bca
Xor
0
0
1
1
Aca×(1-Ba)+(1-Aa)×Bca
Uncorrelated blend mode expansion of Porter & Duff blend modes

31. Other Blend Overlap Modes
• Uncorrelated is one assumption for how two colors
overlap with a pixel
– Typically treated as conditional probability
– Not the only assumption!
– Ideally, you’d know the exact region within the pixel that colors A
and B cover
• Don’t generally have this knowledge of sub-pixel geometry
• Other reasonable assumptions possible
– Disjoint – means colors A and B avoid overlapping to the
greatest extent possible
• Proper assumption when geometry of A and B is result of a nonoverlapping tessellation
– Conjoint – means colors B overlaps A to the greatest extent
possible
• Proper assumption when geometry of B is known to be “within” the
geometry of A
• Example: smiley face is a yellow circle with black eyes and mouth;
you know the mouth and eyes are fully within the yellow circle
• These assumptions result in different coverage functions
than uncorrelated overlap assumption

32. Example of Overlap Assumption for
Src-Over Blend Mode
Source: “A Realistic 2D Drawing System”
rejected SIGGRAPH 2003(?) paper on Xre before being renamed Cairo

33. Overlap Assumptions Affect
Weighting Functions
• Recall p0, p1, p2 functions in equation…
R
G
B
A
= f(Rs',Rd')*p0(As,Ad) + Y*Rs'*p1(As,Ad) +
= f(Gs',Gd')*p0(As,Ad) + Y*Gs'*p1(As,Ad) +
= f(Bs',Bd')*p0(As,Ad) + Y*Bs'*p1(As,Ad) +
=
X*p0(As,Ad) + Y*
p1(As,Ad) +
Z*Rd'*p2(As,Ad)
Z*Gd'*p2(As,Ad)
Z*Bd'*p2(As,Ad)
Z*
p2(As,Ad)
where p0, p1, and p2 are overlap weighting functions…
Overlap Mode
Weighting Equations
UNCORRELATED
p0(As,Ad) = As*Ad
p1(As,Ad) = As*(1-Ad)
p2(As,Ad) = Ad*(1-As)
CONJOINT
p0(As,Ad) = min(As,Ad)
p1(As,Ad) = max(As-Ad,0)
p2(As,Ad) = max(Ad-As,0)
DISJOINT
p0(As,Ad) = max(As+Ad-1,0)
p1(As,Ad) = min(As,1-Ad)
p2(As,Ad) = min(Ad,1-As)

34. Blend Overlap Modes
Overlap
mode
A∩B
A ∩ ~B
~A ∩ B
~A ∩ ~B
Uncorrelated
Sa×Da
Sa×(1-Da)
Da×(1-Sa)
(1-Sa)×(1-Da)
Disjoint
max(Sa+Da-1,0)
min(Sa,1-Da)
min(Da,1-Sa)
1-min(Sa,1-Da)min(Da,1-Sa)max(Sa+Da-1,0)
Conjoint
max(Sa+Da-1,0)
Sa
max(Sa+Da-1,0)
1-max(Da,Sa)max(Sa+Da-1,0)

35. Resulting Selectable Template
Blend Mode Equations
Overlap
mode
Selectable template blend mode equation
Uncorrelated
Rca = f(Ac,Bc)×Aa×Ba + Y×Aca×(1-Ba) + Z×Bca×(1-Aa)
Ra = X×Aa×Ba + Y×Aa×(1-Ba) + Z×(1-Aa)×Ba
Disjoint
Rca = f(Ac,Bc)×max(Aa+Ba-1,0) + Y×Ac×min(Aa,1-Ba) + Z×Bc×min(Ba,1-Aa)
Ra = X×max(Aa+Ba-1,0) + Y×min(Aa,1-Ba) + Z×min(Ba,1-Aa)
Ra = Aa+Ba assuming (X,Y,Z) = (0,1,1)
Conjoint
Rca = X×f(Ac,Bc)×max(Aa+Ba-1,0) + Y×Aca + Z×Bc×(max(Ba,Aa)-Sa)
Ra = X×max(Aa+Ba-1,0) + Y×Aa + Z×(max(Ba,Aa)-Aa)
Ra = Aa
Further assumptions:
Disjoint: Aa + Ba ≤ 1
Conjoint: Aa ≥ Ba, Aa ≤ 1

36. Prior Work Developing
Blend Modes
•
Ed Catmull & Alvy Ray Smith invent “alpha component” to accompany RGB (1970s)
–
Called this “integral alpha”
•
•
Tom Porter & Tom Duff develop alpha-based image compositing algebra (1984)
–
•
based on pre-multiplied alpha
Adobe publishes “Transparency in PDF” Technical Note #5407 (2000)
–
–
–
PDF 1.4 includes transparency support
Adobe Illustrator 9 supports PDF 1.4 transparency
Introduces blend modes
•
–
•
Concept incorporated in Pixman / XRender APIs
Flash 8 introduces blend modes (2005)
Adobe’s PixelBender language (2008?) provides fully programmable blending
–
•
Detailed compositing theory developed
Adobe Flash avoids conflation artifacts in blending
–
•
Includes separable & non-separable blend modes
Carl Worth and Keith Packard develop Xr (later Cairo) and explain correlated, disjoint,
and conjoint overlap modes (2002?)
–
•
(alpha integrated with the RGB components, unrelated to integers)
Overly general unfortunately
SVG Compositing specification (2009) proposed (f,X,Y,Z) notion to describe blend
modes
–
Includes layers

37. Advanced Blend Modes
• Adobe for Illustrator introduces blend
modes such as
– ColorDodge, ColorBurn, HardLight, SoftLight,
etc.
– These modes are well-known to digital artists
who intuit their meaning & effect
• In (f,X,Y,Z) notation, (X,Y,Z)=(1,1,1)
• It’s the f function that makes these modes
interesting

38. SVG Compositing has
all the major blend modes

39. Still missing some blend modes
• Additional blend modes key to implementing ISO
32000 standard
– Also known as PDF
– Blend modes also in Photoshop, etc.

40. Non-separable Blend Mode Examples
Hue
Saturation
Color
Luminosity

41. Non-Separable Blend Modes
• Non-separable means color components are
processed differently (so not vector RGB math)
– Color information “crosses” components
• General usage
– Artists works in intuitive Hue, Saturation, Luminance
(HSL) color space
– Wants to get hue from color A but retain color B’s
saturation and luminance
– Not really about compositing (no sense of how the
colors overlap); more about color intuition
• Specific modes
– Hue, Saturation, Luminance, Color

42. Additional Blend Modes
• Some blend modes exist in standards…
– But aren’t expressed in (f,X,Y,Z) notation
– Nor are HSL color space blend modes
• Come from a variety of sources
–
–
–
–
JavaFX
OpenVG
Apple’s Quartz 2D
PhotoShop
• For completeness, these should be supported
– Goal: Make OpenGL a blend mode superset

43. Additional Blend Modes
Result
PLUS
(R,G,B,A) = (Rs'+Rd, Gs'+Gd, Bs'+Bd,As'+Ad)
PLUS_CLAMPED
(R,G,B,A) = (min(1,Rs'+Rd), min(1,Gs'+Gd),
min(1,Bs'+Bd), min(1,As+Ad))
PLUS_CLAMPED_ALPHA
(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
(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
(R,G,B,A) = (Rd-Rs', Gd-Gs', Bd-Bs', Ad-As)
MINUS_CLAMPED
(R,G,B,A) = (max(0,Rd-Rs'), max(0,Gd-Gs'),
max(0,Bd-Bs'), max(0,Ad-As))
CONTRAST
(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
(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
(R,G,B,A) = (Rs', Gd, Bd, Ad)
GREEN
(R,G,B,A) = (Rd, Gs', Bd, Ad)
BLUE
(R,G,B,A) = (Rd, Gd, Bs', Ad)

44. Fragment-rate, Sample-rate, and sRGB
Fragment
Shader
per-fragment processing
linear RGBA source color
per-sample processing (2x, 4x, or 8x fragment rate)
linear RGB destination color
Blend Mode
Blend Mode
Blend Mode
Blend Mode
linear RGB result color
Decode to
Decode to
sRGB
Decode to
sRGB
Decode to
sRGB
sRGB
Encode to
Encode to
sRGB
Encode to
sRGB
Encode to
sRGB
sRGB
sRGB encoded result color
sRGB encoded destination color
Framebuffer

45. OpenGL Support Today
• NV_blend_equation_advanced
– Directly supports standard blend modes efficiently
– Works like standard glBlendEquation, just supporting
the standard blend modes
• Better than frustrating fragment interlock
extensions
– Blend mode should be orthogonal to fragment shader!
– Blend equations more power efficient
• Work better with multisampling, color compression, and
blend optimizations
• Extension support today!
– All Fermi- and Kepler-based NVIDIA GPUs
– Also for Logan-based Tegra
– Introduced with OpenGL 4.4 (Release 326 on)

46. NV_blend_equation_advanced
Example Usage
• Very easy
– glEnable(GL_BLEND);
– glBlendEquation(GL_COLOR_DODGE_NV);
• Yes, it’s that easy *
* However for older hardware, call
glBlendBarrierNV() between rendering of
primitives that double hit color samples
– New hardware: “just works” with blend barriers
• glBlendBarrierNV is simply a no-operation

47. Complete NV_blend_equation_advanced
Blend Mode List (1 of 2)
Blending Equation
----------------GL_ZERO
GL_SRC_NV
GL_DST_NV
GL_SRC_OVER_NV
GL_DST_OVER_NV
GL_SRC_IN_NV
GL_DST_IN_NV
GL_SRC_OUT_NV
GL_DST_OUT_NV
GL_SRC_ATOP_NV
GL_DST_ATOP_NV
GL_XOR_NV
GL_MULTIPLY_NV
GL_SCREEN_NV
GL_OVERLAY_NV
GL_DARKEN_NV
GL_LIGHTEN_NV
GL_COLORDODGE_NV
GL_COLORBURN_NV
GL_HARDLIGHT_NV
GL_SOFTLIGHT_NV
GL_DIFFERENCE_NV
GL_EXCLUSION_NV
OpenVG SVG
PDF Flash JavaFX Quartz2D Qt
XRE
------ ----- ----- ----- ------ -------- ---- ----E
X
X
X
XO
X
X
X
X
X
XO
E
X
X
XO
X
X
X
X
X
X
X
XO
X
X
X
X
XO
X
X
X
X
XO
X
X
X
X
X
XO
E
X
X
X
XO
E
X
X
X
X
XO
E
X
X
X
X
XO
E
X
X
X
XO
E
X
X
X
XO
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
E
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
E
X
X
X
X
X
X
E
X
X
X
X
X
X
E
X
X
X
X
X
X
X
E
X
X
X
X
X
X
E
X
X
X
X
X
X
X
E
X
X
X
X
X
X
X = Supported, E = OpenVG extension, X0 = includes disjoint & conjoint

48. Complete NV_blend_equation_advanced
Blend Mode List (1 of 2)
Blending Equation
OpenVG SVG
PDF Flash JavaFX Quartz2D Qt
XRE
----------------------- ------ ----- ----- ----- ------ -------- ---- ----GL_INVERT
X
GL_INVERT_RGB_NV
GL_LINEARDODGE_NV
E
GL_LINEARBURN_NV
E
GL_VIVIDLIGHT_NV
E
GL_LINEARLIGHT_NV
E
GL_PINLIGHT_NV
E
GL_HARDMIX_NV
E
GL_HSL_HUE_NV
X
X
X
GL_HSL_SATURATION_NV
X
X
X
GL_HSL_COLOR_NV
X
X
X
GL_HSL_LUMINOSITY_NV
X
X
X
GL_PLUS_NV /
GL_PLUS_CLAMPED_NV /
X
X
X
X
X
X
X
GL_PLUS_CLAMPED_ALPHA_NV
GL_PLUS_DARKER_NV
X
GL_MINUS_NV /
E
X
GL_MINUS_CLAMPED_NV
GL_CONTRAST_NV
GL_INVERT_OVG_NV
E
GL_RED_NV
X
GL_GREEN_NV
X
GL_BLUE_NV
X
-
X = Supported, E = OpenVG extension, X0 = includes disjoint & conjoint

49. What is NV_path_rendering?
• Another very powerful
OpenGL extension
– “Stencil, then Cover” (StC)
approach to GPUaccelerated path rendering
– Fastest path rendering
available
• Supports all manner of
2D vector graphics
– Not normally the domain of
OpenGL but now is!
https://developer.nvidia.com/gpu-accelerated-path-rendering

50. NV_path_rendering Interaction
• Works great with NV_blend_equation_advanced
– No need for explicit glBlendBarrierNV commands
when rendering paths with “stencil, then cover”
– Blend modes “just work” on old and new GPUs
• When you “stencil” your path, then “cover” that
automatically provides the blend barrier
– Makes using advanced Blend Modes with
NV_path_rendering super-easy
• Example filling a path with “color burn”:
glBlendEquation(GL_COLORBURN_NV);
glStencilFillPathNV(path_object, GL_COUNT_UP_NV, 0xFF);
glCoverFillPathNV(path_object, GL_CONVEX_HULL_NV);

51. NV_path_rendering +
NV_blend_equation_advanced Examples
GL_DIFFERENCE_NV
GL_SRC_OVER_NV
“Normal”
• Several advanced
Blend Modes
– Applied to paths
rendered with
NV_path_rendering
• Composites
arbitrary paths
– Notice paths
overlap, have holes
(stars), curves
(hearts), and
stroking
• Bonus: Drawn in
perspective too!
GL_DST_IN_NV
GL_CONTRAST_NV

52. Conclusions
• Blend modes have good working theory
• Used in nearly all Digital Media apps and
standards
– Part of the common vocabulary of digital
artists now
• NVIDIA OpenGL provides these modes
– Both current and future hardware!
– Works hand-in-glove with NV_path_rendering

53. Thanks
• Pat Brown (extension specification
author), Jeff Bolz, Daniel Koch, Tristan
Lorach
– NVIDIA
• Rik Cabanier
– Adobe