framework2

1
/*
2
 *  FxaaPass.cpp
3
 *
4
 *  Copyright (c) 2012, Neil Mendoza, http://www.neilmendoza.com
5
 *  All rights reserved. 
6
 *  
7
 *  Redistribution and use in source and binary forms, with or without 
8
 *  modification, are permitted provided that the following conditions are met: 
9
 *  
10
 *  * Redistributions of source code must retain the above copyright notice, 
11
 *    this list of conditions and the following disclaimer. 
12
 *  * Redistributions in binary form must reproduce the above copyright 
13
 *    notice, this list of conditions and the following disclaimer in the 
14
 *    documentation and/or other materials provided with the distribution. 
15
 *  * Neither the name of Neil Mendoza nor the names of its contributors may be used 
16
 *    to endorse or promote products derived from this software without 
17
 *    specific prior written permission. 
18
 *  
19
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
20
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
21
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
22
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
23
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
24
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
25
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
26
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
27
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
28
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
29
 *  POSSIBILITY OF SUCH DAMAGE. 
30
 *
31
 */
32
#include "FxaaPass.h"
33

34
namespace itg
35
{
36
    FxaaPass::FxaaPass(const ofVec2f& aspect, bool arb) : RenderPass(aspect, arb, "fxaa")
37
    {
38
        string fragShaderSrc = STRINGIFY(
39
             uniform SAMPLER_TYPE tDiffuse;
40
             uniform vec2 resolution;
41
             
42
             varying vec2 vUv;
43
             
44
             const float FXAA_REDUCE_MIN = 1.0/128.0;
45
             const float FXAA_REDUCE_MUL = 1.0/8.0;
46
             const float FXAA_SPAN_MAX = 8.0;
47
             
48
             void main() {
49
                 
50
                 vec3 rgbNW = TEXTURE_FN( tDiffuse, ( gl_FragCoord.xy + vec2( -1.0, -1.0 ) ) * resolution ).xyz;
51
                 vec3 rgbNE = TEXTURE_FN( tDiffuse, ( gl_FragCoord.xy + vec2( 1.0, -1.0 ) ) * resolution ).xyz;
52
                 vec3 rgbSW = TEXTURE_FN( tDiffuse, ( gl_FragCoord.xy + vec2( -1.0, 1.0 ) ) * resolution ).xyz;
53
                 vec3 rgbSE = TEXTURE_FN( tDiffuse, ( gl_FragCoord.xy + vec2( 1.0, 1.0 ) ) * resolution ).xyz;
54
                 vec4 rgbaM  = TEXTURE_FN( tDiffuse,  gl_FragCoord.xy  * resolution );
55
                 vec3 rgbM  = rgbaM.xyz;
56
                 float opacity  = rgbaM.w;
57
                 
58
                 vec3 luma = vec3( 0.299, 0.587, 0.114 );
59
                 
60
                 float lumaNW = dot( rgbNW, luma );
61
                 float lumaNE = dot( rgbNE, luma );
62
                 float lumaSW = dot( rgbSW, luma );
63
                 float lumaSE = dot( rgbSE, luma );
64
                 float lumaM  = dot( rgbM,  luma );
65
                 float lumaMin = min( lumaM, min( min( lumaNW, lumaNE ), min( lumaSW, lumaSE ) ) );
66
                 float lumaMax = max( lumaM, max( max( lumaNW, lumaNE) , max( lumaSW, lumaSE ) ) );
67
                 
68
                 vec2 dir;
69
                 dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
70
                 dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
71
                 
72
                 float dirReduce = max( ( lumaNW + lumaNE + lumaSW + lumaSE ) * ( 0.25 * FXAA_REDUCE_MUL ), FXAA_REDUCE_MIN );
73
                 
74
                 float rcpDirMin = 1.0 / ( min( abs( dir.x ), abs( dir.y ) ) + dirReduce );
75
                 dir = min( vec2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),
76
                           max( vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
77
                               dir * rcpDirMin)) * resolution;
78
                 
79
                 vec3 rgbA = 0.5 * (
80
                                    TEXTURE_FN( tDiffuse, gl_FragCoord.xy  * resolution + dir * ( 1.0 / 3.0 - 0.5 ) ).xyz +
81
                                    TEXTURE_FN( tDiffuse, gl_FragCoord.xy  * resolution + dir * ( 2.0 / 3.0 - 0.5 ) ).xyz );
82
                 
83
                 vec3 rgbB = rgbA * 0.5 + 0.25 * (
84
                                                  TEXTURE_FN( tDiffuse, gl_FragCoord.xy  * resolution + dir * -0.5 ).xyz +
85
                                                  TEXTURE_FN( tDiffuse, gl_FragCoord.xy  * resolution + dir * 0.5 ).xyz );
86
                 
87
                 float lumaB = dot( rgbB, luma );
88
                 
89
                 if ( ( lumaB < lumaMin ) || ( lumaB > lumaMax ) ) {
90
                     
91
                     gl_FragColor = vec4( rgbA, opacity );
92
                     
93
                 } else {
94
                     
95
                     gl_FragColor = vec4( rgbB, opacity );
96
                     
97
                 }
98
                 
99
             }
100
        );
101
        ostringstream oss;
102
        oss << "#version 120" << endl;
103
        if (arb)
104
        {
105
            oss << "#define SAMPLER_TYPE sampler2DRect" << endl;
106
            oss << "#define TEXTURE_FN texture2DRect" << endl;
107
            oss << fragShaderSrc;
108
        }
109
        else
110
        {
111
            oss << "#define SAMPLER_TYPE sampler2D" << endl;
112
            oss << "#define TEXTURE_FN texture2D" << endl;
113
            oss << fragShaderSrc;
114
        }
115
        shader.setupShaderFromSource(GL_FRAGMENT_SHADER, oss.str());
116
        shader.linkProgram();
117
    }
118
    
119
    void FxaaPass::render(ofFbo& readFbo, ofFbo& writeFbo)
120
    {
121
        writeFbo.begin();
122
        
123
        shader.begin();
124
        
125
        shader.setUniformTexture("tDiffuse", readFbo.getTexture(), 0);
126
        if (arb) shader.setUniform2f("resolution", 1.f, 1.f);
127
        else shader.setUniform2f("resolution", 1.f / writeFbo.getWidth(), 1.f / writeFbo.getHeight());
128
        
129
        texturedQuad(0, 0, writeFbo.getWidth(), writeFbo.getHeight());
130
        
131
        shader.end();
132
        writeFbo.end();
133
    }
134
}