SMAA.h

/*Copyright (C) 2011 Jorge Jimenez (jorge@iryoku.com)
Copyright (C) 2011 Belen Masia (bmasia@unizar.es) 
Copyright (C) 2011 Jose I. Echevarria (joseignacioechevarria@gmail.com) 
Copyright (C) 2011 Fernando Navarro (fernandn@microsoft.com) 
Copyright (C) 2011 Diego Gutierrez (diegog@unizar.es)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the following disclaimer
in the documentation and/or other materials provided with the 
distribution:
"Uses SMAA. Copyright (C) 2011 by Jorge Jimenez, Jose I. Echevarria,
Belen Masia, Fernando Navarro and Diego Gutierrez."
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``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 COPYRIGHT HOLDERS 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.
The views and conclusions contained in the software and documentation are 
those of the authors and should not be interpreted as representing official
policies, either expressed or implied, of the copyright holders.*/
#ifndef SMAA_H
#define SMAA_H
#include <dxgi.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <dxerr.h>
#include "Effect.h"
#include "main.h"
class SMAA : public Effect {
    public:
        class ExternalStorage;
        enum Preset { PRESET_LOW, PRESET_MEDIUM, PRESET_HIGH, PRESET_ULTRA, PRESET_CUSTOM };
        enum Input { INPUT_LUMA, INPUT_COLOR, INPUT_DEPTH };
        /*If you have one or two spare render targets of the same size as the
         *backbuffer, you may want to pass them in the 'storage' parameter.
         *You may pass one or the two, depending on what you have available.
         *A RG buffer (at least) is expected for storing edges.
         *A RGBA buffer is expected for the blending weights.
         *By default, two render targets will be created for storing
         *intermediate calculations.*/
        SMAA(IDirect3DDevice9 *device, int width, int height, Preset preset,
             const ExternalStorage &storage=ExternalStorage());
        virtual ~SMAA();
        /*Processes input texture 'src', storing the antialiased image into
         *'dst'. Note that 'src' and 'dst' should be associated to different
         *buffers.
         *'edges' should be the input for using for edge detection: either a
         *depth buffer or a non-sRGB color buffer. Input must be set 
         *accordingly.
         *IMPORTANT: the stencil component of currently bound depth-stencil
         *buffer will be used to mask the zones to be processed. It is assumed
         *to be already cleared to zero when this function is called. It is 
         *not done here because it is usually cleared together with the depth.
         *For performance reasons, the state is not restored before returning
         *from this function (the render target, the input layout, the 
         *depth-stencil and blend states...)*/
        void go(IDirect3DTexture9 *edges,
                IDirect3DTexture9 *src, 
                IDirect3DSurface9 *dst,
                Input input);
        //Maximum length to search for patterns. Each step is two pixels wide.
        int getMaxSearchSteps() const { return maxSearchSteps; }
        void setMaxSearchSteps(int maxSearchSteps) { this->maxSearchSteps = maxSearchSteps; }
        //Threshold for the edge detection.
        float getThreshold() const { return threshold; }
        void setThreshold(float threshold) { this->threshold = threshold; }
        //This class allows to pass spare storage buffers to the SMAA class.
        class ExternalStorage {
            public:
                ExternalStorage(IDirect3DTexture9 *edgeTex=NULL,
                                IDirect3DSurface9 *edgeSurface=NULL,
                                IDirect3DTexture9 *blendTex=NULL,
                                IDirect3DSurface9 *blendSurface=NULL)
                    : edgeTex(edgeTex),
                      edgeSurface(edgeSurface), 
                      blendTex(blendTex),
                      blendSurface(blendSurface) {}
            IDirect3DTexture9 *edgeTex, *blendTex;
            IDirect3DSurface9 *edgeSurface, *blendSurface;
        };
    private:
        void loadAreaTex();
        void loadSearchTex();
        void edgesDetectionPass(IDirect3DTexture9 *edges, Input input);
        void blendingWeightsCalculationPass();
        void neighborhoodBlendingPass(IDirect3DTexture9 *src, IDirect3DSurface9 *dst);
        ID3DXEffect *effect;
        IDirect3DTexture9 *edgeTex;
        IDirect3DSurface9 *edgeSurface;
        bool releaseEdgeResources;
        IDirect3DTexture9 *blendTex;
        IDirect3DSurface9 *blendSurface;
        bool releaseBlendResources;
        IDirect3DTexture9 *areaTex;
        IDirect3DTexture9 *searchTex;
        D3DXHANDLE thresholdHandle, maxSearchStepsHandle;
        D3DXHANDLE areaTexHandle, searchTexHandle;
        D3DXHANDLE colorTexHandle, depthTexHandle;
        D3DXHANDLE edgesTexHandle, blendTexHandle;
        D3DXHANDLE lumaEdgeDetectionHandle, colorEdgeDetectionHandle, depthEdgeDetectionHandle,
                   blendWeightCalculationHandle, neighborhoodBlendingHandle;
        int maxSearchSteps;
        float threshold;
        int width, height;
};
#endif