mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 00:35:44 +00:00
541 lines
16 KiB
Plaintext
541 lines
16 KiB
Plaintext
float4 BlendMultiplyPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendMultiply(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendScreenPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendScreen(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendOverlayPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendOverlay(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendDarkenPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendDarken(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendLightenPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendLighten(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendColorDodgePS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendColorDodge(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendColorBurnPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendColorBurn(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendHardLightPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= sOpacity;
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendHardLight(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendSoftLightPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendSoftLight(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendDifferencePS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendDifference(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendExclusionPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendExclusion(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendHuePS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendHue(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendSaturationPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendSaturation(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendColorPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendColor(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|
|
float4 BlendLuminosityPS(const VS_BLEND_OUTPUT aInput) : SV_Target
|
|
{
|
|
if (!RectContainsPoint(aInput.vClipRect, aInput.vPosition.xy)) {
|
|
discard;
|
|
}
|
|
|
|
float4 backdrop = tBackdrop.Sample(sSampler, aInput.vBackdropCoords);
|
|
float4 source = simpleTex.Sample(sSampler, aInput.vTexCoords);
|
|
|
|
source *= ReadMask(aInput.vMaskCoords);
|
|
|
|
// Shortcut when the backdrop or source alpha is 0, otherwise we may leak
|
|
// infinity into the blend function and return incorrect results.
|
|
if (backdrop.a == 0.0) {
|
|
return source;
|
|
}
|
|
if (source.a == 0.0) {
|
|
return float4(0, 0, 0, 0);
|
|
}
|
|
|
|
// The spec assumes there is no premultiplied alpha. The backdrop and
|
|
// source are both render targets and always premultiplied, so we undo
|
|
// that here.
|
|
backdrop.rgb /= backdrop.a;
|
|
source.rgb /= source.a;
|
|
|
|
float4 result;
|
|
result.rgb = BlendLuminosity(backdrop.rgb, source.rgb);
|
|
result.a = source.a;
|
|
|
|
// Factor backdrop alpha, then premultiply for the final OP_OVER.
|
|
result.rgb = (1.0 - backdrop.a) * source.rgb + backdrop.a * result.rgb;
|
|
result.rgb *= result.a;
|
|
return result;
|
|
}
|
|
|