yetangitu/Oinktube
1
0
Fork 0
mirror of https://github.com/DanielnetoDotCom/YouPHPTube synced 2025-10-03 17:59:55 +02:00
Code Issues Releases Wiki Activity
Oinktube/node_modules/three/examples/js/shaders/FXAAShader.js
Daniel Neto 7e26256cac https://github.com/WWBN/AVideo/issues/8713
2023-12-11 11:59:56 -03:00

1112 lines
51 KiB
JavaScript
Raw Blame History

/**
* NVIDIA FXAA by Timothy Lottes
* http://timothylottes.blogspot.com/2011/06/fxaa3-source-released.html
* - WebGL port by @supereggbert
* http://www.glge.org/demos/fxaa/
*/
THREE.FXAAShader = {
uniforms: {
'tDiffuse': { value: null },
'resolution': { value: new THREE.Vector2( 1 / 1024, 1 / 512 ) }
},
vertexShader: [
'varying vec2 vUv;',
'void main() {',
' vUv = uv;',
' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
'}'
].join( '\n' ),
fragmentShader: [
'precision highp float;',
'',
'uniform sampler2D tDiffuse;',
'',
'uniform vec2 resolution;',
'',
'varying vec2 vUv;',
'',
'// FXAA 3.11 implementation by NVIDIA, ported to WebGL by Agost Biro (biro@archilogic.com)',
'',
'//----------------------------------------------------------------------------------',
'// File: es3-kepler\FXAA\assets\shaders/FXAA_DefaultES.frag',
'// SDK Version: v3.00',
'// Email: gameworks@nvidia.com',
'// Site: http://developer.nvidia.com/',
'//',
'// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.',
'//',
'// Redistribution and use in source and binary forms, with or without',
'// modification, are permitted provided that the following conditions',
'// are met:',
'// * Redistributions of source code must retain the above copyright',
'// notice, this list of conditions and the following disclaimer.',
'// * Redistributions in binary form must reproduce the above copyright',
'// notice, this list of conditions and the following disclaimer in the',
'// documentation and/or other materials provided with the distribution.',
'// * Neither the name of NVIDIA CORPORATION nor the names of its',
'// contributors may be used to endorse or promote products derived',
'// from this software without specific prior written permission.',
'//',
'// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS\'\' AND ANY',
'// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE',
'// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR',
'// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR',
'// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,',
'// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,',
'// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR',
'// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY',
'// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT',
'// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE',
'// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.',
'//',
'//----------------------------------------------------------------------------------',
'',
'#define FXAA_PC 1',
'#define FXAA_GLSL_100 1',
'#define FXAA_QUALITY_PRESET 12',
'',
'#define FXAA_GREEN_AS_LUMA 1',
'',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_PC_CONSOLE',
' //',
' // The console algorithm for PC is included',
' // for developers targeting really low spec machines.',
' // Likely better to just run FXAA_PC, and use a really low preset.',
' //',
' #define FXAA_PC_CONSOLE 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_GLSL_120',
' #define FXAA_GLSL_120 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_GLSL_130',
' #define FXAA_GLSL_130 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_HLSL_3',
' #define FXAA_HLSL_3 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_HLSL_4',
' #define FXAA_HLSL_4 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_HLSL_5',
' #define FXAA_HLSL_5 0',
'#endif',
'/*==========================================================================*/',
'#ifndef FXAA_GREEN_AS_LUMA',
' //',
' // For those using non-linear color,',
' // and either not able to get luma in alpha, or not wanting to,',
' // this enables FXAA to run using green as a proxy for luma.',
' // So with this enabled, no need to pack luma in alpha.',
' //',
' // This will turn off AA on anything which lacks some amount of green.',
' // Pure red and blue or combination of only R and B, will get no AA.',
' //',
' // Might want to lower the settings for both,',
' // fxaaConsoleEdgeThresholdMin',
' // fxaaQualityEdgeThresholdMin',
' // In order to insure AA does not get turned off on colors',
' // which contain a minor amount of green.',
' //',
' // 1 = On.',
' // 0 = Off.',
' //',
' #define FXAA_GREEN_AS_LUMA 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_EARLY_EXIT',
' //',
' // Controls algorithm\'s early exit path.',
' // On PS3 turning this ON adds 2 cycles to the shader.',
' // On 360 turning this OFF adds 10ths of a millisecond to the shader.',
' // Turning this off on console will result in a more blurry image.',
' // So this defaults to on.',
' //',
' // 1 = On.',
' // 0 = Off.',
' //',
' #define FXAA_EARLY_EXIT 1',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_DISCARD',
' //',
' // Only valid for PC OpenGL currently.',
' // Probably will not work when FXAA_GREEN_AS_LUMA = 1.',
' //',
' // 1 = Use discard on pixels which don\'t need AA.',
' // For APIs which enable concurrent TEX+ROP from same surface.',
' // 0 = Return unchanged color on pixels which don\'t need AA.',
' //',
' #define FXAA_DISCARD 0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_FAST_PIXEL_OFFSET',
' //',
' // Used for GLSL 120 only.',
' //',
' // 1 = GL API supports fast pixel offsets',
' // 0 = do not use fast pixel offsets',
' //',
' #ifdef GL_EXT_gpu_shader4',
' #define FXAA_FAST_PIXEL_OFFSET 1',
' #endif',
' #ifdef GL_NV_gpu_shader5',
' #define FXAA_FAST_PIXEL_OFFSET 1',
' #endif',
' #ifdef GL_ARB_gpu_shader5',
' #define FXAA_FAST_PIXEL_OFFSET 1',
' #endif',
' #ifndef FXAA_FAST_PIXEL_OFFSET',
' #define FXAA_FAST_PIXEL_OFFSET 0',
' #endif',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#ifndef FXAA_GATHER4_ALPHA',
' //',
' // 1 = API supports gather4 on alpha channel.',
' // 0 = API does not support gather4 on alpha channel.',
' //',
' #if (FXAA_HLSL_5 == 1)',
' #define FXAA_GATHER4_ALPHA 1',
' #endif',
' #ifdef GL_ARB_gpu_shader5',
' #define FXAA_GATHER4_ALPHA 1',
' #endif',
' #ifdef GL_NV_gpu_shader5',
' #define FXAA_GATHER4_ALPHA 1',
' #endif',
' #ifndef FXAA_GATHER4_ALPHA',
' #define FXAA_GATHER4_ALPHA 0',
' #endif',
'#endif',
'',
'',
'/*============================================================================',
' FXAA QUALITY - TUNING KNOBS',
'------------------------------------------------------------------------------',
'NOTE the other tuning knobs are now in the shader function inputs!',
'============================================================================*/',
'#ifndef FXAA_QUALITY_PRESET',
' //',
' // Choose the quality preset.',
' // This needs to be compiled into the shader as it effects code.',
' // Best option to include multiple presets is to',
' // in each shader define the preset, then include this file.',
' //',
' // OPTIONS',
' // -----------------------------------------------------------------------',
' // 10 to 15 - default medium dither (10=fastest, 15=highest quality)',
' // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)',
' // 39 - no dither, very expensive',
' //',
' // NOTES',
' // -----------------------------------------------------------------------',
' // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)',
' // 13 = about same speed as FXAA 3.9 and better than 12',
' // 23 = closest to FXAA 3.9 visually and performance wise',
' // _ = the lowest digit is directly related to performance',
' // _ = the highest digit is directly related to style',
' //',
' #define FXAA_QUALITY_PRESET 12',
'#endif',
'',
'',
'/*============================================================================',
'',
' FXAA QUALITY - PRESETS',
'',
'============================================================================*/',
'',
'/*============================================================================',
' FXAA QUALITY - MEDIUM DITHER PRESETS',
'============================================================================*/',
'#if (FXAA_QUALITY_PRESET == 10)',
' #define FXAA_QUALITY_PS 3',
' #define FXAA_QUALITY_P0 1.5',
' #define FXAA_QUALITY_P1 3.0',
' #define FXAA_QUALITY_P2 12.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 11)',
' #define FXAA_QUALITY_PS 4',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 3.0',
' #define FXAA_QUALITY_P3 12.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 12)',
' #define FXAA_QUALITY_PS 5',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 4.0',
' #define FXAA_QUALITY_P4 12.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 13)',
' #define FXAA_QUALITY_PS 6',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 4.0',
' #define FXAA_QUALITY_P5 12.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 14)',
' #define FXAA_QUALITY_PS 7',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 4.0',
' #define FXAA_QUALITY_P6 12.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 15)',
' #define FXAA_QUALITY_PS 8',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 2.0',
' #define FXAA_QUALITY_P6 4.0',
' #define FXAA_QUALITY_P7 12.0',
'#endif',
'',
'/*============================================================================',
' FXAA QUALITY - LOW DITHER PRESETS',
'============================================================================*/',
'#if (FXAA_QUALITY_PRESET == 20)',
' #define FXAA_QUALITY_PS 3',
' #define FXAA_QUALITY_P0 1.5',
' #define FXAA_QUALITY_P1 2.0',
' #define FXAA_QUALITY_P2 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 21)',
' #define FXAA_QUALITY_PS 4',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 22)',
' #define FXAA_QUALITY_PS 5',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 23)',
' #define FXAA_QUALITY_PS 6',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 24)',
' #define FXAA_QUALITY_PS 7',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 3.0',
' #define FXAA_QUALITY_P6 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 25)',
' #define FXAA_QUALITY_PS 8',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 2.0',
' #define FXAA_QUALITY_P6 4.0',
' #define FXAA_QUALITY_P7 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 26)',
' #define FXAA_QUALITY_PS 9',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 2.0',
' #define FXAA_QUALITY_P6 2.0',
' #define FXAA_QUALITY_P7 4.0',
' #define FXAA_QUALITY_P8 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 27)',
' #define FXAA_QUALITY_PS 10',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 2.0',
' #define FXAA_QUALITY_P6 2.0',
' #define FXAA_QUALITY_P7 2.0',
' #define FXAA_QUALITY_P8 4.0',
' #define FXAA_QUALITY_P9 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 28)',
' #define FXAA_QUALITY_PS 11',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 2.0',
' #define FXAA_QUALITY_P6 2.0',
' #define FXAA_QUALITY_P7 2.0',
' #define FXAA_QUALITY_P8 2.0',
' #define FXAA_QUALITY_P9 4.0',
' #define FXAA_QUALITY_P10 8.0',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_QUALITY_PRESET == 29)',
' #define FXAA_QUALITY_PS 12',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.5',
' #define FXAA_QUALITY_P2 2.0',
' #define FXAA_QUALITY_P3 2.0',
' #define FXAA_QUALITY_P4 2.0',
' #define FXAA_QUALITY_P5 2.0',
' #define FXAA_QUALITY_P6 2.0',
' #define FXAA_QUALITY_P7 2.0',
' #define FXAA_QUALITY_P8 2.0',
' #define FXAA_QUALITY_P9 2.0',
' #define FXAA_QUALITY_P10 4.0',
' #define FXAA_QUALITY_P11 8.0',
'#endif',
'',
'/*============================================================================',
' FXAA QUALITY - EXTREME QUALITY',
'============================================================================*/',
'#if (FXAA_QUALITY_PRESET == 39)',
' #define FXAA_QUALITY_PS 12',
' #define FXAA_QUALITY_P0 1.0',
' #define FXAA_QUALITY_P1 1.0',
' #define FXAA_QUALITY_P2 1.0',
' #define FXAA_QUALITY_P3 1.0',
' #define FXAA_QUALITY_P4 1.0',
' #define FXAA_QUALITY_P5 1.5',
' #define FXAA_QUALITY_P6 2.0',
' #define FXAA_QUALITY_P7 2.0',
' #define FXAA_QUALITY_P8 2.0',
' #define FXAA_QUALITY_P9 2.0',
' #define FXAA_QUALITY_P10 4.0',
' #define FXAA_QUALITY_P11 8.0',
'#endif',
'',
'',
'',
'/*============================================================================',
'',
' API PORTING',
'',
'============================================================================*/',
'#if (FXAA_GLSL_100 == 1) || (FXAA_GLSL_120 == 1) || (FXAA_GLSL_130 == 1)',
' #define FxaaBool bool',
' #define FxaaDiscard discard',
' #define FxaaFloat float',
' #define FxaaFloat2 vec2',
' #define FxaaFloat3 vec3',
' #define FxaaFloat4 vec4',
' #define FxaaHalf float',
' #define FxaaHalf2 vec2',
' #define FxaaHalf3 vec3',
' #define FxaaHalf4 vec4',
' #define FxaaInt2 ivec2',
' #define FxaaSat(x) clamp(x, 0.0, 1.0)',
' #define FxaaTex sampler2D',
'#else',
' #define FxaaBool bool',
' #define FxaaDiscard clip(-1)',
' #define FxaaFloat float',
' #define FxaaFloat2 float2',
' #define FxaaFloat3 float3',
' #define FxaaFloat4 float4',
' #define FxaaHalf half',
' #define FxaaHalf2 half2',
' #define FxaaHalf3 half3',
' #define FxaaHalf4 half4',
' #define FxaaSat(x) saturate(x)',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_GLSL_100 == 1)',
' #define FxaaTexTop(t, p) texture2D(t, p, 0.0)',
' #define FxaaTexOff(t, p, o, r) texture2D(t, p + (o * r), 0.0)',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_GLSL_120 == 1)',
' // Requires,',
' // #version 120',
' // And at least,',
' // #extension GL_EXT_gpu_shader4 : enable',
' // (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)',
' #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)',
' #if (FXAA_FAST_PIXEL_OFFSET == 1)',
' #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)',
' #else',
' #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)',
' #endif',
' #if (FXAA_GATHER4_ALPHA == 1)',
' // use #extension GL_ARB_gpu_shader5 : enable',
' #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
' #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
' #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
' #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
' #endif',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_GLSL_130 == 1)',
' // Requires "#version 130" or better',
' #define FxaaTexTop(t, p) textureLod(t, p, 0.0)',
' #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)',
' #if (FXAA_GATHER4_ALPHA == 1)',
' // use #extension GL_ARB_gpu_shader5 : enable',
' #define FxaaTexAlpha4(t, p) textureGather(t, p, 3)',
' #define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)',
' #define FxaaTexGreen4(t, p) textureGather(t, p, 1)',
' #define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)',
' #endif',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_HLSL_3 == 1)',
' #define FxaaInt2 float2',
' #define FxaaTex sampler2D',
' #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))',
' #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_HLSL_4 == 1)',
' #define FxaaInt2 int2',
' struct FxaaTex { SamplerState smpl; Texture2D tex; };',
' #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
' #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
'#endif',
'/*--------------------------------------------------------------------------*/',
'#if (FXAA_HLSL_5 == 1)',
' #define FxaaInt2 int2',
' struct FxaaTex { SamplerState smpl; Texture2D tex; };',
' #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)',
' #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)',
' #define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)',
' #define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)',
' #define FxaaTexGreen4(t, p) t.tex.GatherGreen(t.smpl, p)',
' #define FxaaTexOffGreen4(t, p, o) t.tex.GatherGreen(t.smpl, p, o)',
'#endif',
'',
'',
'/*============================================================================',
' GREEN AS LUMA OPTION SUPPORT FUNCTION',
'============================================================================*/',
'#if (FXAA_GREEN_AS_LUMA == 0)',
' FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }',
'#else',
' FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }',
'#endif',
'',
'',
'',
'',
'/*============================================================================',
'',
' FXAA3 QUALITY - PC',
'',
'============================================================================*/',
'#if (FXAA_PC == 1)',
'/*--------------------------------------------------------------------------*/',
'FxaaFloat4 FxaaPixelShader(',
' //',
' // Use noperspective interpolation here (turn off perspective interpolation).',
' // {xy} = center of pixel',
' FxaaFloat2 pos,',
' //',
' // Used only for FXAA Console, and not used on the 360 version.',
' // Use noperspective interpolation here (turn off perspective interpolation).',
' // {xy_} = upper left of pixel',
' // {_zw} = lower right of pixel',
' FxaaFloat4 fxaaConsolePosPos,',
' //',
' // Input color texture.',
' // {rgb_} = color in linear or perceptual color space',
' // if (FXAA_GREEN_AS_LUMA == 0)',
' // {__a} = luma in perceptual color space (not linear)',
' FxaaTex tex,',
' //',
' // Only used on the optimized 360 version of FXAA Console.',
' // For everything but 360, just use the same input here as for "tex".',
' // For 360, same texture, just alias with a 2nd sampler.',
' // This sampler needs to have an exponent bias of -1.',
' FxaaTex fxaaConsole360TexExpBiasNegOne,',
' //',
' // Only used on the optimized 360 version of FXAA Console.',
' // For everything but 360, just use the same input here as for "tex".',
' // For 360, same texture, just alias with a 3nd sampler.',
' // This sampler needs to have an exponent bias of -2.',
' FxaaTex fxaaConsole360TexExpBiasNegTwo,',
' //',
' // Only used on FXAA Quality.',
' // This must be from a constant/uniform.',
' // {x_} = 1.0/screenWidthInPixels',
' // {_y} = 1.0/screenHeightInPixels',
' FxaaFloat2 fxaaQualityRcpFrame,',
' //',
' // Only used on FXAA Console.',
' // This must be from a constant/uniform.',
' // This effects sub-pixel AA quality and inversely sharpness.',
' // Where N ranges between,',
' // N = 0.50 (default)',
' // N = 0.33 (sharper)',
' // {x__} = -N/screenWidthInPixels',
' // {_y_} = -N/screenHeightInPixels',
' // {_z_} = N/screenWidthInPixels',
' // {__w} = N/screenHeightInPixels',
' FxaaFloat4 fxaaConsoleRcpFrameOpt,',
' //',
' // Only used on FXAA Console.',
' // Not used on 360, but used on PS3 and PC.',
' // This must be from a constant/uniform.',
' // {x__} = -2.0/screenWidthInPixels',
' // {_y_} = -2.0/screenHeightInPixels',
' // {_z_} = 2.0/screenWidthInPixels',
' // {__w} = 2.0/screenHeightInPixels',
' FxaaFloat4 fxaaConsoleRcpFrameOpt2,',
' //',
' // Only used on FXAA Console.',
' // Only used on 360 in place of fxaaConsoleRcpFrameOpt2.',
' // This must be from a constant/uniform.',
' // {x__} = 8.0/screenWidthInPixels',
' // {_y_} = 8.0/screenHeightInPixels',
' // {_z_} = -4.0/screenWidthInPixels',
' // {__w} = -4.0/screenHeightInPixels',
' FxaaFloat4 fxaaConsole360RcpFrameOpt2,',
' //',
' // Only used on FXAA Quality.',
' // This used to be the FXAA_QUALITY_SUBPIX define.',
' // It is here now to allow easier tuning.',
' // Choose the amount of sub-pixel aliasing removal.',
' // This can effect sharpness.',
' // 1.00 - upper limit (softer)',
' // 0.75 - default amount of filtering',
' // 0.50 - lower limit (sharper, less sub-pixel aliasing removal)',
' // 0.25 - almost off',
' // 0.00 - completely off',
' FxaaFloat fxaaQualitySubpix,',
' //',
' // Only used on FXAA Quality.',
' // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.',
' // It is here now to allow easier tuning.',
' // The minimum amount of local contrast required to apply algorithm.',
' // 0.333 - too little (faster)',
' // 0.250 - low quality',
' // 0.166 - default',
' // 0.125 - high quality',
' // 0.063 - overkill (slower)',
' FxaaFloat fxaaQualityEdgeThreshold,',
' //',
' // Only used on FXAA Quality.',
' // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.',
' // It is here now to allow easier tuning.',
' // Trims the algorithm from processing darks.',
' // 0.0833 - upper limit (default, the start of visible unfiltered edges)',
' // 0.0625 - high quality (faster)',
' // 0.0312 - visible limit (slower)',
' // Special notes when using FXAA_GREEN_AS_LUMA,',
' // Likely want to set this to zero.',
' // As colors that are mostly not-green',
' // will appear very dark in the green channel!',
' // Tune by looking at mostly non-green content,',
' // then start at zero and increase until aliasing is a problem.',
' FxaaFloat fxaaQualityEdgeThresholdMin,',
' //',
' // Only used on FXAA Console.',
' // This used to be the FXAA_CONSOLE_EDGE_SHARPNESS define.',
' // It is here now to allow easier tuning.',
' // This does not effect PS3, as this needs to be compiled in.',
' // Use FXAA_CONSOLE_PS3_EDGE_SHARPNESS for PS3.',
' // Due to the PS3 being ALU bound,',
' // there are only three safe values here: 2 and 4 and 8.',
' // These options use the shaders ability to a free *|/ by 2|4|8.',
' // For all other platforms can be a non-power of two.',
' // 8.0 is sharper (default!!!)',
' // 4.0 is softer',
' // 2.0 is really soft (good only for vector graphics inputs)',
' FxaaFloat fxaaConsoleEdgeSharpness,',
' //',
' // Only used on FXAA Console.',
' // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD define.',
' // It is here now to allow easier tuning.',
' // This does not effect PS3, as this needs to be compiled in.',
' // Use FXAA_CONSOLE_PS3_EDGE_THRESHOLD for PS3.',
' // Due to the PS3 being ALU bound,',
' // there are only two safe values here: 1/4 and 1/8.',
' // These options use the shaders ability to a free *|/ by 2|4|8.',
' // The console setting has a different mapping than the quality setting.',
' // Other platforms can use other values.',
' // 0.125 leaves less aliasing, but is softer (default!!!)',
' // 0.25 leaves more aliasing, and is sharper',
' FxaaFloat fxaaConsoleEdgeThreshold,',
' //',
' // Only used on FXAA Console.',
' // This used to be the FXAA_CONSOLE_EDGE_THRESHOLD_MIN define.',
' // It is here now to allow easier tuning.',
' // Trims the algorithm from processing darks.',
' // The console setting has a different mapping than the quality setting.',
' // This only applies when FXAA_EARLY_EXIT is 1.',
' // This does not apply to PS3,',
' // PS3 was simplified to avoid more shader instructions.',
' // 0.06 - faster but more aliasing in darks',
' // 0.05 - default',
' // 0.04 - slower and less aliasing in darks',
' // Special notes when using FXAA_GREEN_AS_LUMA,',
' // Likely want to set this to zero.',
' // As colors that are mostly not-green',
' // will appear very dark in the green channel!',
' // Tune by looking at mostly non-green content,',
' // then start at zero and increase until aliasing is a problem.',
' FxaaFloat fxaaConsoleEdgeThresholdMin,',
' //',
' // Extra constants for 360 FXAA Console only.',
' // Use zeros or anything else for other platforms.',
' // These must be in physical constant registers and NOT immediates.',
' // Immediates will result in compiler un-optimizing.',
' // {xyzw} = float4(1.0, -1.0, 0.25, -0.25)',
' FxaaFloat4 fxaaConsole360ConstDir',
') {',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat2 posM;',
' posM.x = pos.x;',
' posM.y = pos.y;',
' #if (FXAA_GATHER4_ALPHA == 1)',
' #if (FXAA_DISCARD == 0)',
' FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
' #if (FXAA_GREEN_AS_LUMA == 0)',
' #define lumaM rgbyM.w',
' #else',
' #define lumaM rgbyM.y',
' #endif',
' #endif',
' #if (FXAA_GREEN_AS_LUMA == 0)',
' FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);',
' FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));',
' #else',
' FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);',
' FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));',
' #endif',
' #if (FXAA_DISCARD == 1)',
' #define lumaM luma4A.w',
' #endif',
' #define lumaE luma4A.z',
' #define lumaS luma4A.x',
' #define lumaSE luma4A.y',
' #define lumaNW luma4B.w',
' #define lumaN luma4B.z',
' #define lumaW luma4B.x',
' #else',
' FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);',
' #if (FXAA_GREEN_AS_LUMA == 0)',
' #define lumaM rgbyM.w',
' #else',
' #define lumaM rgbyM.y',
' #endif',
' #if (FXAA_GLSL_100 == 1)',
' FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0, 1.0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 0.0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 0.0,-1.0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 0.0), fxaaQualityRcpFrame.xy));',
' #else',
' FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));',
' #endif',
' #endif',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat maxSM = max(lumaS, lumaM);',
' FxaaFloat minSM = min(lumaS, lumaM);',
' FxaaFloat maxESM = max(lumaE, maxSM);',
' FxaaFloat minESM = min(lumaE, minSM);',
' FxaaFloat maxWN = max(lumaN, lumaW);',
' FxaaFloat minWN = min(lumaN, lumaW);',
' FxaaFloat rangeMax = max(maxWN, maxESM);',
' FxaaFloat rangeMin = min(minWN, minESM);',
' FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;',
' FxaaFloat range = rangeMax - rangeMin;',
' FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);',
' FxaaBool earlyExit = range < rangeMaxClamped;',
'/*--------------------------------------------------------------------------*/',
' if(earlyExit)',
' #if (FXAA_DISCARD == 1)',
' FxaaDiscard;',
' #else',
' return rgbyM;',
' #endif',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_GATHER4_ALPHA == 0)',
' #if (FXAA_GLSL_100 == 1)',
' FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0,-1.0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0, 1.0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2( 1.0,-1.0), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaFloat2(-1.0, 1.0), fxaaQualityRcpFrame.xy));',
' #else',
' FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
' #endif',
' #else',
' FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));',
' FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));',
' #endif',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat lumaNS = lumaN + lumaS;',
' FxaaFloat lumaWE = lumaW + lumaE;',
' FxaaFloat subpixRcpRange = 1.0/range;',
' FxaaFloat subpixNSWE = lumaNS + lumaWE;',
' FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;',
' FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat lumaNESE = lumaNE + lumaSE;',
' FxaaFloat lumaNWNE = lumaNW + lumaNE;',
' FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;',
' FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat lumaNWSW = lumaNW + lumaSW;',
' FxaaFloat lumaSWSE = lumaSW + lumaSE;',
' FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);',
' FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);',
' FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;',
' FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;',
' FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;',
' FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;',
' FxaaFloat lengthSign = fxaaQualityRcpFrame.x;',
' FxaaBool horzSpan = edgeHorz >= edgeVert;',
' FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;',
'/*--------------------------------------------------------------------------*/',
' if(!horzSpan) lumaN = lumaW;',
' if(!horzSpan) lumaS = lumaE;',
' if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;',
' FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat gradientN = lumaN - lumaM;',
' FxaaFloat gradientS = lumaS - lumaM;',
' FxaaFloat lumaNN = lumaN + lumaM;',
' FxaaFloat lumaSS = lumaS + lumaM;',
' FxaaBool pairN = abs(gradientN) >= abs(gradientS);',
' FxaaFloat gradient = max(abs(gradientN), abs(gradientS));',
' if(pairN) lengthSign = -lengthSign;',
' FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat2 posB;',
' posB.x = posM.x;',
' posB.y = posM.y;',
' FxaaFloat2 offNP;',
' offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;',
' offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;',
' if(!horzSpan) posB.x += lengthSign * 0.5;',
' if( horzSpan) posB.y += lengthSign * 0.5;',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat2 posN;',
' posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;',
' posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;',
' FxaaFloat2 posP;',
' posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;',
' posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;',
' FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;',
' FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));',
' FxaaFloat subpixE = subpixC * subpixC;',
' FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));',
'/*--------------------------------------------------------------------------*/',
' if(!pairN) lumaNN = lumaSS;',
' FxaaFloat gradientScaled = gradient * 1.0/4.0;',
' FxaaFloat lumaMM = lumaM - lumaNN * 0.5;',
' FxaaFloat subpixF = subpixD * subpixE;',
' FxaaBool lumaMLTZero = lumaMM < 0.0;',
'/*--------------------------------------------------------------------------*/',
' lumaEndN -= lumaNN * 0.5;',
' lumaEndP -= lumaNN * 0.5;',
' FxaaBool doneN = abs(lumaEndN) >= gradientScaled;',
' FxaaBool doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;',
' FxaaBool doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;',
'/*--------------------------------------------------------------------------*/',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 3)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 4)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 5)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 6)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 7)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 8)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 9)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 10)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 11)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;',
'/*--------------------------------------------------------------------------*/',
' #if (FXAA_QUALITY_PS > 12)',
' if(doneNP) {',
' if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));',
' if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));',
' if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;',
' if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;',
' doneN = abs(lumaEndN) >= gradientScaled;',
' doneP = abs(lumaEndP) >= gradientScaled;',
' if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;',
' if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;',
' doneNP = (!doneN) || (!doneP);',
' if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;',
' if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
' #endif',
'/*--------------------------------------------------------------------------*/',
' }',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat dstN = posM.x - posN.x;',
' FxaaFloat dstP = posP.x - posM.x;',
' if(!horzSpan) dstN = posM.y - posN.y;',
' if(!horzSpan) dstP = posP.y - posM.y;',
'/*--------------------------------------------------------------------------*/',
' FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;',
' FxaaFloat spanLength = (dstP + dstN);',
' FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;',
' FxaaFloat spanLengthRcp = 1.0/spanLength;',
'/*--------------------------------------------------------------------------*/',
' FxaaBool directionN = dstN < dstP;',
' FxaaFloat dst = min(dstN, dstP);',
' FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;',
' FxaaFloat subpixG = subpixF * subpixF;',
' FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;',
' FxaaFloat subpixH = subpixG * fxaaQualitySubpix;',
'/*--------------------------------------------------------------------------*/',
' FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;',
' FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);',
' if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;',
' if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;',
' #if (FXAA_DISCARD == 1)',
' return FxaaTexTop(tex, posM);',
' #else',
' return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);',
' #endif',
'}',
'/*==========================================================================*/',
'#endif',
'',
'void main() {',
' gl_FragColor = FxaaPixelShader(',
' vUv,',
' vec4(0.0),',
' tDiffuse,',
' tDiffuse,',
' tDiffuse,',
' resolution,',
' vec4(0.0),',
' vec4(0.0),',
' vec4(0.0),',
' 0.75,',
' 0.166,',
' 0.0833,',
' 0.0,',
' 0.0,',
' 0.0,',
' vec4(0.0)',
' );',
'',
' // TODO avoid querying texture twice for same texel',
' gl_FragColor.a = texture2D(tDiffuse, vUv).a;',
'}'
].join( '\n' )
};
Reference in a new issue View git blame Copy permalink