#include "BLI_assert.h"
#include "BLI_math_vector.hh"
#include "IMB_colormanagement.hh"
#include "GPU_shader.hh"
#include "GPU_texture.hh"
#include "COM_context.hh"
#include "COM_result.hh"
#include "COM_utilities.hh"
#include "COM_algorithm_smaa.hh"
#include "COM_smaa_precomputed_textures.hh"

Namespaces
namespace	blender
namespace	blender::compositor

Macros
#define	SMAA_CUSTOM_SL
#define	SMAA_AREATEX_SELECT(sample)
#define	SMAA_SEARCHTEX_SELECT(sample)
#define	SMAATexture2D(tex)
#define	SMAATexturePass2D(tex)
#define	SMAASampleLevelZero(tex, coord)
#define	SMAASampleLevelZeroPoint(tex, coord)
#define	SMAASampleLevelZeroOffset(tex, coord, offset, size)
#define	SMAASample(tex, coord)
#define	SMAASamplePoint(tex, coord)
#define	SMAASamplePointOffset(tex, coord, offset, size)
#define	SMAASampleOffset(tex, coord, offset, size)
#define	SMAA_FLATTEN
#define	SMAA_BRANCH
#define	lerp(a, b, t)
#define	saturate(a)
#define	mad(a, b, c)
#define	SMAA_THRESHOLD 0.1f
#define	SMAA_DEPTH_THRESHOLD (0.1f * SMAA_THRESHOLD)
#define	SMAA_MAX_SEARCH_STEPS 16
#define	SMAA_MAX_SEARCH_STEPS_DIAG 8
#define	SMAA_CORNER_ROUNDING 25
#define	SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR 2.0f
#define	SMAA_PREDICATION 0
#define	SMAA_PREDICATION_THRESHOLD 0.01f
#define	SMAA_PREDICATION_SCALE 2.0f
#define	SMAA_PREDICATION_STRENGTH 0.4f
#define	SMAA_REPROJECTION 0
#define	SMAA_REPROJECTION_WEIGHT_SCALE 30.0f
#define	SMAA_INCLUDE_VS 1
#define	SMAA_INCLUDE_PS 1
#define	SMAA_DECODE_VELOCITY(sample)
#define	SMAA_AREATEX_MAX_DISTANCE 16
#define	SMAA_AREATEX_MAX_DISTANCE_DIAG 20
#define	SMAA_AREATEX_PIXEL_SIZE (1.0f / float2(160.0f, 560.0f))
#define	SMAA_AREATEX_SUBTEX_SIZE (1.0f / 7.0f)
#define	SMAA_SEARCHTEX_SIZE float2(66.0f, 33.0f)
#define	SMAA_SEARCHTEX_PACKED_SIZE float2(64.0f, 16.0f)
#define	SMAA_CORNER_ROUNDING_NORM (float(SMAA_CORNER_ROUNDING) / 100.0f)

Functions
static void	blender::compositor::SMAAMovc (float2 cond, float2 &variable, float2 value)
static void	blender::compositor::SMAAMovc (float4 cond, float4 &variable, float4 value)
static void	blender::compositor::SMAAEdgeDetectionVS (float2 texcoord, int2 size, float4 offset[3])
static void	blender::compositor::SMAABlendingWeightCalculationVS (float2 texcoord, int2 size, float2 &pixcoord, float4 offset[3])
static void	blender::compositor::SMAANeighborhoodBlendingVS (float2 texcoord, int2 size, float4 &offset)
static float2	blender::compositor::SMAALumaEdgeDetectionPS (float2 texcoord, float4 offset[3], SMAATexture2D(colorTex), float edge_threshold, float3 luminance_coefficients, float local_contrast_adaptation_factor)
static float2	blender::compositor::SMAADecodeDiagBilinearAccess (float2 e)
static float4	blender::compositor::SMAADecodeDiagBilinearAccess (float4 e)
static float2	blender::compositor::SMAASearchDiag1 (SMAATexture2D(edgesTex), float2 texcoord, float2 dir, int2 size, float2 &e)
static float2	blender::compositor::SMAASearchDiag2 (SMAATexture2D(edgesTex), float2 texcoord, float2 dir, int2 size, float2 &e)
static float2	blender::compositor::SMAAAreaDiag (SMAATexture2D(areaTex), float2 dist, float2 e, float offset)
static float2	blender::compositor::SMAACalculateDiagWeights (SMAATexture2D(edgesTex), SMAATexture2D(areaTex), float2 texcoord, float2 e, float4 subsampleIndices, int2 size)
static float	blender::compositor::SMAASearchLength (SMAATexture2D(searchTex), float2 e, float offset)
static float	blender::compositor::SMAASearchXLeft (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float	blender::compositor::SMAASearchXRight (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float	blender::compositor::SMAASearchYUp (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float	blender::compositor::SMAASearchYDown (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float2	blender::compositor::SMAAArea (SMAATexture2D(areaTex), float2 dist, float e1, float e2, float offset)
static void	blender::compositor::SMAADetectHorizontalCornerPattern (SMAATexture2D(edgesTex), float2 &weights, float4 texcoord, float2 d, int2 size, int corner_rounding)
static void	blender::compositor::SMAADetectVerticalCornerPattern (SMAATexture2D(edgesTex), float2 &weights, float4 texcoord, float2 d, int2 size, int corner_rounding)
static float4	blender::compositor::SMAABlendingWeightCalculationPS (float2 texcoord, float2 pixcoord, float4 offset[3], SMAATexture2D(edgesTex), SMAATexture2D(areaTex), SMAATexture2D(searchTex), float4 subsampleIndices, int2 size, int corner_rounding)
static float4	blender::compositor::SMAANeighborhoodBlendingPS (float2 texcoord, float4 offset, SMAATexture2D(colorTex), SMAATexture2D(blendTex), int2 size)
static float3	blender::compositor::get_luminance_coefficients (ResultType type)
static Result	blender::compositor::detect_edges_gpu (Context &context, const Result &input, const float threshold, const float local_contrast_adaptation_factor)
static Result	blender::compositor::detect_edges_cpu (Context &context, const Result &input, const float threshold, const float local_contrast_adaptation_factor)
static Result	blender::compositor::detect_edges (Context &context, const Result &input, const float threshold, const float local_contrast_adaptation_factor)
static Result	blender::compositor::calculate_blending_weights_gpu (Context &context, const Result &edges, const int corner_rounding)
static Result	blender::compositor::calculate_blending_weights_cpu (Context &context, const Result &edges, const int corner_rounding)
static Result	blender::compositor::calculate_blending_weights (Context &context, const Result &edges, const int corner_rounding)
static const char *	blender::compositor::get_blend_shader_name (ResultType type)
static void	blender::compositor::blend_neighborhood_gpu (Context &context, const Result &input, const Result &weights, Result &output)
static void	blender::compositor::blend_neighborhood_cpu (const Result &input, const Result &weights, Result &output)
static void	blender::compositor::blend_neighborhood (Context &context, const Result &input, const Result &weights, Result &output)
void	blender::compositor::smaa (Context &context, const Result &input, Result &output, const float threshold=0.1f, const float local_contrast_adaptation_factor=2.0f, const int corner_rounding=25)

Macro Definition Documentation

◆ lerp

#define lerp	(	a,
		b,
		t )

Value:

math::interpolate(a, b, t)

b

Definition compositor_morphological_distance_infos.hh:24

blender::math::interpolate

T interpolate(const T &a, const T &b, const FactorT &t)

Definition BLI_math_base.hh:274

Definition at line 314 of file smaa.cc.

Referenced by btSoftBodyHelpers::CreatePatch(), btSoftBodyHelpers::CreatePatchUV(), btSoftBodyHelpers::CreateRope(), debugDrawPhase(), newPerlin(), and noise3_perlin().

◆ mad

#define mad	(	a,
		b,
		c )

Value:

(a * b + c)

Definition at line 316 of file smaa.cc.

Referenced by blender::compositor::SMAAArea(), blender::compositor::SMAAAreaDiag(), blender::compositor::SMAABlendingWeightCalculationPS(), blender::compositor::SMAACalculateDiagWeights(), blender::compositor::SMAASearchDiag1(), blender::compositor::SMAASearchDiag2(), blender::compositor::SMAASearchLength(), blender::compositor::SMAASearchXLeft(), blender::compositor::SMAASearchXRight(), blender::compositor::SMAASearchYDown(), and blender::compositor::SMAASearchYUp().

◆ saturate

#define saturate ( a )

Value:

math::clamp(a, 0.0f, 1.0f)

blender::math::clamp

T clamp(const T &a, const T &min, const T &max)

Definition BLI_math_base.hh:69

Definition at line 315 of file smaa.cc.

Referenced by bsdf_microfacet_setup_fresnel_generalized_schlick(), bsdf_oren_nayar_setup(), MixVectorNonUniformNode::constant_fold(), blender::eevee::film_filter_weight(), fresnel_conductor_Fss(), fresnel_f82(), fresnel_iridescence(), SkyMultipleScattering::lookup_transmittance(), SkyMultipleScattering::lookup_transmittance_at_ground(), SkyMultipleScattering::lookup_transmittance_to_sun(), blender::compositor::SMAADetectHorizontalCornerPattern(), blender::compositor::SMAADetectVerticalCornerPattern(), surface_shader_alpha(), svm_mix_clamp(), svm_node_closure_bsdf(), svm_node_mix_color(), and svm_node_mix_vector_non_uniform().

◆ SMAA_AREATEX_MAX_DISTANCE

#define SMAA_AREATEX_MAX_DISTANCE 16

Definition at line 539 of file smaa.cc.

Referenced by blender::compositor::SMAAArea().

◆ SMAA_AREATEX_MAX_DISTANCE_DIAG

#define SMAA_AREATEX_MAX_DISTANCE_DIAG 20

Definition at line 540 of file smaa.cc.

Referenced by blender::compositor::SMAAAreaDiag().

◆ SMAA_AREATEX_PIXEL_SIZE

#define SMAA_AREATEX_PIXEL_SIZE (1.0f / float2(160.0f, 560.0f))

Definition at line 541 of file smaa.cc.

Referenced by blender::compositor::SMAAArea(), and blender::compositor::SMAAAreaDiag().

◆ SMAA_AREATEX_SELECT

#define SMAA_AREATEX_SELECT ( sample )

Value:

sample.xy()

sample

uint sample

Definition kernel/device/gpu/kernel.h:98

Definition at line 298 of file smaa.cc.

Referenced by blender::compositor::SMAAArea(), and blender::compositor::SMAAAreaDiag().

◆ SMAA_AREATEX_SUBTEX_SIZE

#define SMAA_AREATEX_SUBTEX_SIZE (1.0f / 7.0f)

Definition at line 542 of file smaa.cc.

Referenced by blender::compositor::SMAAArea(), and blender::compositor::SMAAAreaDiag().

◆ SMAA_BRANCH

#define SMAA_BRANCH

Definition at line 313 of file smaa.cc.

Referenced by blender::compositor::SMAABlendingWeightCalculationPS(), blender::compositor::SMAACalculateDiagWeights(), and blender::compositor::SMAANeighborhoodBlendingPS().

◆ SMAA_CORNER_ROUNDING

#define SMAA_CORNER_ROUNDING 25

SMAA_CORNER_ROUNDING specifies how much sharp corners will be rounded.

Range: [0, 100]

Define SMAA_DISABLE_CORNER_DETECTION to disable corner processing.

Definition at line 414 of file smaa.cc.

◆ SMAA_CORNER_ROUNDING_NORM

#define SMAA_CORNER_ROUNDING_NORM (float(SMAA_CORNER_ROUNDING) / 100.0f)

Definition at line 545 of file smaa.cc.

◆ SMAA_CUSTOM_SL

#define SMAA_CUSTOM_SL

             _______  ___  ___       ___           ___
            /       ||   \/   |     /   \         /   \
           |   (---- |  \  /  |    /  ^  \       /  ^  \
            \   \    |  |\/|  |   /  /_\  \     /  /_\  \
         ----)   |   |  |  |  |  /  _____  \   /  _____  \
        |_______/    |__|  |__| /__/     \__\ /__/     \__\

                          E N H A N C E D
  S U B P I X E L   M O R P H O L O G I C A L   A N T I A L I A S I N G

                    http://www.iryoku.com/smaa/

Hi, welcome aboard!

Here you'll find instructions to get the shader up and running as fast as possible.

IMPORTANTE NOTICE: when updating, remember to update both this file and the precomputed textures! They may change from version to version.

The shader has three passes, chained together as follows:

                      |input|------------------�
                         v                     |
               [ SMAA*EdgeDetection ]          |
                         v                     |
                     |edgesTex|                |
                         v                     |
         [ SMAABlendingWeightCalculation ]     |
                         v                     |
                     |blendTex|                |
                         v                     |
           [ SMAANeighborhoodBlending ] <------�
                         v
                      |output|

Note that each [pass] has its own vertex and pixel shader. Remember to use over-sized triangles instead of quads to avoid over-shading along the diagonal.

You've three edge detection methods to choose from: luma, color or depth. They represent different quality/performance and anti-aliasing/sharpness tradeoffs, so our recommendation is for you to choose the one that best suits your particular scenario:

Depth edge detection is usually the fastest but it may miss some edges.
Luma edge detection is usually more expensive than depth edge detection, but catches visible edges that depth edge detection can miss.
Color edge detection is usually the most expensive one but catches chroma-only edges.

For quick-starters: just use luma edge detection.

The general advice is to not rush the integration process and ensure each step is done correctly (don't try to integrate SMAA T2x with predicated edge detection from the start!). Ok then, let's go!

The first step is to create two RGBA temporal render targets for holding |edgesTex| and |blendTex|.

In DX10 or DX11, you can use a RG render target for the edges texture. In the case of NVIDIA GPUs, using RG render targets seems to actually be slower.

On the Xbox 360, you can use the same render target for resolving both |edgesTex| and |blendTex|, as they aren't needed simultaneously.
Both temporal render targets |edgesTex| and |blendTex| must be cleared each frame. Do not forget to clear the alpha channel!
The next step is loading the two supporting precalculated textures, 'areaTex' and 'searchTex'. You'll find them in the 'Textures' folder as C++ headers, and also as regular DDS files. They'll be needed for the 'SMAABlendingWeightCalculation' pass.

If you use the C++ headers, be sure to load them in the format specified inside of them.

You can also compress 'areaTex' and 'searchTex' using BC5 and BC4 respectively, if you have that option in your content processor pipeline. When compressing then, you get a non-perceptible quality decrease, and a marginal performance increase.
All samplers must be set to linear filtering and clamp.

After you get the technique working, remember that 64-bit inputs have half-rate linear filtering on GCN.

If SMAA is applied to 64-bit color buffers, switching to point filtering when accessing them will increase the performance. Search for 'SMAASamplePoint' to see which textures may benefit from point filtering, and where (which is basically the color input in the edge detection and resolve passes).
All texture reads and buffer writes must be non-sRGB, with the exception of the input read and the output write in 'SMAANeighborhoodBlending' (and only in this pass!). If sRGB reads in this last pass are not possible, the technique will work anyway, but will perform anti-aliasing in gamma space.

IMPORTANT: for best results the input read for the color/luma edge detection should NOT be sRGB.
Before including SMAA.h you'll have to setup the render target metrics, the target and any optional configuration defines. Optionally you can use a preset.

You have the following targets available: SMAA_HLSL_3 SMAA_HLSL_4 SMAA_HLSL_4_1 SMAA_GLSL_3 * SMAA_GLSL_4 *
- (See SMAA_INCLUDE_VS and SMAA_INCLUDE_PS below).
And four presets: SMAA_PRESET_LOW (%60 of the quality) SMAA_PRESET_MEDIUM (%80 of the quality) SMAA_PRESET_HIGH (%95 of the quality) SMAA_PRESET_ULTRA (%99 of the quality)

For example: #define SMAA_RT_METRICS float4(1.0 / 1280.0, 1.0 / 720.0, 1280.0, 720.0) #define SMAA_HLSL_4 #define SMAA_PRESET_HIGH #include "SMAA.h"

Note that SMAA_RT_METRICS doesn't need to be a macro, it can be a uniform variable. The code is designed to minimize the impact of not using a constant value, but it is still better to hard-code it.

Depending on how you encoded 'areaTex' and 'searchTex', you may have to add (and customize) the following defines before including SMAA.h: #define SMAA_AREATEX_SELECT(sample) sample.rg #define SMAA_SEARCHTEX_SELECT(sample) sample.r

If your engine is already using porting macros, you can define SMAA_CUSTOM_SL, and define the porting functions by yourself.
Then, you'll have to setup the passes as indicated in the scheme above. You can take a look into SMAA.fx, to see how we did it for our demo. Checkout the function wrappers, you may want to copy-paste them!
It's recommended to validate the produced |edgesTex| and |blendTex|. You can use a screenshot from your engine to compare the |edgesTex| and |blendTex| produced inside of the engine with the results obtained with the reference demo.
After you get the last pass to work, it's time to optimize. You'll have to initialize a stencil buffer in the first pass (discard is already in the code), then mask execution by using it the second pass. The last pass should be executed in all pixels.

After this point you can choose to enable predicated thresholding, temporal supersampling and motion blur integration:

a) If you want to use predicated thresholding, take a look into SMAA_PREDICATION; you'll need to pass an extra texture in the edge detection pass.

b) If you want to enable temporal supersampling (SMAA T2x):

The first step is to render using sub-pixel jitters. I won't go into detail, but it's as simple as moving each vertex position in the vertex shader, you can check how we do it in our DX10 demo.
Then, you must setup the temporal resolve. You may want to take a look into SMAAResolve for resolving 2x modes. After you get it working, you'll probably see ghosting everywhere. But fear not, you can enable the CryENGINE temporal reprojection by setting the SMAA_REPROJECTION macro. Check out SMAA_DECODE_VELOCITY if your velocity buffer is encoded.
The next step is to apply SMAA to each sub-pixel jittered frame, just as done for 1x.
At this point you should already have something usable, but for best results the proper area textures must be set depending on current jitter. For this, the parameter 'subsampleIndices' of 'SMAABlendingWeightCalculationPS' must be set as follows, for our T2x mode:

@SUBSAMPLE_INDICES

| S# | Camera Jitter | subsampleIndices | +-—+---------------—+------------------—+ | 0 | ( 0.25, -0.25) | float4(1, 1, 1, 0) | | 1 | (-0.25, 0.25) | float4(2, 2, 2, 0) |

These jitter positions assume a bottom-to-top y axis. S# stands for the sample number.

More information about temporal supersampling here: http://iryoku.com/aacourse/downloads/13-Anti-Aliasing-Methods-in-CryENGINE-3.pdf

c) If you want to enable spatial multisampling (SMAA S2x):

The scene must be rendered using MSAA 2x. The MSAA 2x buffer must be created with:
- DX10: see below (*)
- DX10.1: D3D10_STANDARD_MULTISAMPLE_PATTERN or
- DX11: D3D11_STANDARD_MULTISAMPLE_PATTERN
This allows to ensure that the subsample order matches the table in @SUBSAMPLE_INDICES.

(*) In the case of DX10, we refer the reader to:
- SMAA::detectMSAAOrder and
- SMAA::msaaReorder
These functions allow matching the standard multisample patterns by detecting the subsample order for a specific GPU, and reordering them appropriately.
A shader must be run to output each subsample into a separate buffer (DX10 is required). You can use SMAASeparate for this purpose, or just do it in an existing pass (for example, in the tone mapping pass, which has the advantage of feeding tone mapped subsamples to SMAA, which will yield better results).
The full SMAA 1x pipeline must be run for each separated buffer, storing the results in the final buffer. The second run should alpha blend with the existing final buffer using a blending factor of 0.5. 'subsampleIndices' must be adjusted as in the SMAA T2x case (see point b).

d) If you want to enable temporal supersampling on top of SMAA S2x (which actually is SMAA 4x):

SMAA 4x consists on temporally jittering SMAA S2x, so the first step is to calculate SMAA S2x for current frame. In this case, 'subsampleIndices' must be set as follows:

| F# | S# | Camera Jitter | Net Jitter | subsampleIndices | +-—+-—+-----------------—+----------------—+-------------------—+ | 0 | 0 | ( 0.125, 0.125) | ( 0.375, -0.125) | float4(5, 3, 1, 3) | | 0 | 1 | ( 0.125, 0.125) | (-0.125, 0.375) | float4(4, 6, 2, 3) | +-—+-—+-----------------—+----------------—+-------------------—+ | 1 | 2 | (-0.125, -0.125) | ( 0.125, -0.375) | float4(3, 5, 1, 4) | | 1 | 3 | (-0.125, -0.125) | (-0.375, 0.125) | float4(6, 4, 2, 4) |

These jitter positions assume a bottom-to-top y axis. F# stands for the frame number. S# stands for the sample number.
After calculating SMAA S2x for current frame (with the new subsample indices), previous frame must be reprojected as in SMAA T2x mode (see point b).

e) If motion blur is used, you may want to do the edge detection pass together with motion blur. This has two advantages:

Pixels under heavy motion can be omitted from the edge detection process. For these pixels we can just store "no edge", as motion blur will take care of them.
The center pixel tap is reused.

Note that in this case depth testing should be used instead of stenciling, as we have to write all the pixels in the motion blur pass.

That's it!

Definition at line 297 of file smaa.cc.

◆ SMAA_DECODE_VELOCITY

#define SMAA_DECODE_VELOCITY ( sample )

Value:

sample.rg

Definition at line 533 of file smaa.cc.

Referenced by blender::compositor::SMAANeighborhoodBlendingPS().

◆ SMAA_DEPTH_THRESHOLD

#define SMAA_DEPTH_THRESHOLD (0.1f * SMAA_THRESHOLD)

SMAA_DEPTH_THRESHOLD specifies the threshold for depth edge detection.

Range: depends on the depth range of the scene.

Definition at line 373 of file smaa.cc.

◆ SMAA_FLATTEN

#define SMAA_FLATTEN

Definition at line 312 of file smaa.cc.

◆ SMAA_INCLUDE_PS

#define SMAA_INCLUDE_PS 1

Definition at line 514 of file smaa.cc.

◆ SMAA_INCLUDE_VS

#define SMAA_INCLUDE_VS 1

On some compilers, discard cannot be used in vertex shaders. Thus, they need to be compiled separately.

Definition at line 511 of file smaa.cc.

◆ SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR

#define SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR 2.0f

If there is an neighbor edge that has SMAA_LOCAL_CONTRAST_FACTOR times bigger contrast than current edge, current edge will be discarded.

This allows to eliminate spurious crossing edges, and is based on the fact that, if there is too much contrast in a direction, that will hide perceptually contrast in the other neighbors.

Definition at line 426 of file smaa.cc.

◆ SMAA_MAX_SEARCH_STEPS

#define SMAA_MAX_SEARCH_STEPS 16

SMAA_MAX_SEARCH_STEPS specifies the maximum steps performed in the horizontal/vertical pattern searches, at each side of the pixel.

In number of pixels, it's actually the double. So the maximum line length perfectly handled by, for example 16, is 64 (by perfectly, we meant that longer lines won't look as good, but still anti-aliased).

Range: [0, 112]

Definition at line 387 of file smaa.cc.

Referenced by blender::compositor::SMAABlendingWeightCalculationVS().

◆ SMAA_MAX_SEARCH_STEPS_DIAG

#define SMAA_MAX_SEARCH_STEPS_DIAG 8

SMAA_MAX_SEARCH_STEPS_DIAG specifies the maximum steps performed in the diagonal pattern searches, at each side of the pixel. In this case we jump one pixel at time, instead of two.

Range: [0, 20]

On high-end machines it is cheap (between a 0.8x and 0.9x slower for 16 steps), but it can have a significant impact on older machines.

Define SMAA_DISABLE_DIAG_DETECTION to disable diagonal processing.

Definition at line 403 of file smaa.cc.

Referenced by blender::compositor::SMAASearchDiag1(), and blender::compositor::SMAASearchDiag2().

◆ SMAA_PREDICATION

#define SMAA_PREDICATION 0

Predicated thresholding allows to better preserve texture details and to improve performance, by decreasing the number of detected edges using an additional buffer like the light accumulation buffer, object ids or even the depth buffer (the depth buffer usage may be limited to indoor or short range scenes).

It locally decreases the luma or color threshold if an edge is found in an additional buffer (so the global threshold can be higher).

This method was developed by Playstation EDGE MLAA team, and used in Killzone 3, by using the light accumulation buffer. More information here: http://iryoku.com/aacourse/downloads/06-MLAA-on-PS3.pptx

Definition at line 444 of file smaa.cc.

Referenced by blender::compositor::SMAALumaEdgeDetectionPS().

◆ SMAA_PREDICATION_SCALE

#define SMAA_PREDICATION_SCALE 2.0f

How much to scale the global threshold used for luma or color edge detection when using predication.

Range: [1, 5]

Definition at line 464 of file smaa.cc.

◆ SMAA_PREDICATION_STRENGTH

#define SMAA_PREDICATION_STRENGTH 0.4f

How much to locally decrease the threshold.

Range: [0, 1]

Definition at line 473 of file smaa.cc.

◆ SMAA_PREDICATION_THRESHOLD

#define SMAA_PREDICATION_THRESHOLD 0.01f

Threshold to be used in the additional predication buffer.

Range: depends on the input, so you'll have to find the magic number that works for you.

Definition at line 454 of file smaa.cc.

◆ SMAA_REPROJECTION

#define SMAA_REPROJECTION 0

Temporal reprojection allows to remove ghosting artifacts when using temporal supersampling. We use the CryEngine 3 method which also introduces velocity weighting. This feature is of extreme importance for totally removing ghosting. More information here: http://iryoku.com/aacourse/downloads/13-Anti-Aliasing-Methods-in-CryENGINE-3.pdf

Note that you'll need to setup a velocity buffer for enabling reprojection. For static geometry, saving the previous depth buffer is a viable alternative.

Definition at line 488 of file smaa.cc.

Referenced by blender::compositor::SMAANeighborhoodBlendingPS().

◆ SMAA_REPROJECTION_WEIGHT_SCALE

#define SMAA_REPROJECTION_WEIGHT_SCALE 30.0f

SMAA_REPROJECTION_WEIGHT_SCALE controls the velocity weighting. It allows to remove ghosting trails behind the moving object, which are not removed by just using reprojection. Using low values will exhibit ghosting, while using high values will disable temporal supersampling under motion.

Behind the scenes, velocity weighting removes temporal supersampling when the velocity of the subsamples differs (meaning they are different objects).

Range: [0, 80]

Definition at line 503 of file smaa.cc.

◆ SMAA_SEARCHTEX_PACKED_SIZE

#define SMAA_SEARCHTEX_PACKED_SIZE float2(64.0f, 16.0f)

Definition at line 544 of file smaa.cc.

Referenced by blender::compositor::SMAASearchLength().

◆ SMAA_SEARCHTEX_SELECT

#define SMAA_SEARCHTEX_SELECT ( sample )

Value:

sample.x

Definition at line 299 of file smaa.cc.

Referenced by blender::compositor::SMAASearchLength().

◆ SMAA_SEARCHTEX_SIZE

#define SMAA_SEARCHTEX_SIZE float2(66.0f, 33.0f)

Definition at line 543 of file smaa.cc.

Referenced by blender::compositor::SMAASearchLength().

◆ SMAA_THRESHOLD

#define SMAA_THRESHOLD 0.1f

Note that if you use one of these presets, the following configuration macros will be ignored if set in the "Configurable Defines" section. SMAA_THRESHOLD specifies the threshold or sensitivity to edges. Lowering this value you will be able to detect more edges at the expense of performance.

Range: [0, 0.5] 0.1 is a reasonable value, and allows to catch most visible edges. 0.05 is a rather overkill value, that allows to catch 'em all.

If temporal supersampling is used, 0.2 could be a reasonable value, as low contrast edges are properly filtered by just 2x.

Definition at line 364 of file smaa.cc.

◆ SMAASample

#define SMAASample	(		tex,
			coord )

Value:

tex.sample_bilinear_extended(coord)

Definition at line 306 of file smaa.cc.

Referenced by blender::compositor::SMAANeighborhoodBlendingPS().

◆ SMAASampleLevelZero

#define SMAASampleLevelZero	(		tex,
			coord )

Value:

tex.sample_bilinear_extended(coord)

Definition at line 302 of file smaa.cc.

Referenced by blender::compositor::SMAAArea(), blender::compositor::SMAAAreaDiag(), blender::compositor::SMAABlendingWeightCalculationPS(), blender::compositor::SMAANeighborhoodBlendingPS(), blender::compositor::SMAASearchDiag2(), blender::compositor::SMAASearchLength(), blender::compositor::SMAASearchXLeft(), blender::compositor::SMAASearchXRight(), blender::compositor::SMAASearchYDown(), and blender::compositor::SMAASearchYUp().

◆ SMAASampleLevelZeroOffset

#define SMAASampleLevelZeroOffset	(	tex,
		coord,
		offset,
		size )

Value:

tex.sample_bilinear_extended(coord + float2(offset) / float2(size))

size

static DBVT_INLINE btScalar size(const btDbvtVolume &a)

Definition btDbvt.cpp:52

float2

VecBase< float, 2 > float2

Definition gpu_shader_cxx_vector.hh:344

Definition at line 304 of file smaa.cc.

Referenced by blender::compositor::SMAABlendingWeightCalculationPS(), blender::compositor::SMAACalculateDiagWeights(), blender::compositor::SMAADetectHorizontalCornerPattern(), and blender::compositor::SMAADetectVerticalCornerPattern().

◆ SMAASampleLevelZeroPoint

#define SMAASampleLevelZeroPoint	(		tex,
			coord )

Value:

tex.sample_bilinear_extended(coord)

Definition at line 303 of file smaa.cc.

◆ SMAASampleOffset

#define SMAASampleOffset	(	tex,
		coord,
		offset,
		size )

Value:

tex.sample_bilinear_extended(coord + float2(offset) / float2(size))

Definition at line 310 of file smaa.cc.

◆ SMAASamplePoint

#define SMAASamplePoint	(		tex,
			coord )

Value:

tex.sample_nearest_extended(coord)

Definition at line 307 of file smaa.cc.

Referenced by blender::compositor::SMAABlendingWeightCalculationPS(), blender::compositor::SMAALumaEdgeDetectionPS(), and blender::compositor::SMAASearchDiag1().

◆ SMAASamplePointOffset

#define SMAASamplePointOffset	(	tex,
		coord,
		offset,
		size )

Value:

tex.sample_nearest_extended(coord + float2(offset) / float2(size))

Definition at line 308 of file smaa.cc.

Referenced by blender::compositor::SMAACalculateDiagWeights().

◆ SMAATexture2D

#define SMAATexture2D ( tex )

Value:

const Result &tex

Definition at line 300 of file smaa.cc.

◆ SMAATexturePass2D

#define SMAATexturePass2D ( tex )

Value:

tex

Definition at line 301 of file smaa.cc.

Referenced by blender::compositor::SMAABlendingWeightCalculationPS(), blender::compositor::SMAACalculateDiagWeights(), blender::compositor::SMAALumaEdgeDetectionPS(), blender::compositor::SMAASearchXLeft(), blender::compositor::SMAASearchXRight(), blender::compositor::SMAASearchYDown(), and blender::compositor::SMAASearchYUp().

Namespaces

Macros

Functions

Macro Definition Documentation

◆ lerp

◆ mad

◆ saturate

◆ SMAA_AREATEX_MAX_DISTANCE

◆ SMAA_AREATEX_MAX_DISTANCE_DIAG

◆ SMAA_AREATEX_PIXEL_SIZE

◆ SMAA_AREATEX_SELECT

◆ SMAA_AREATEX_SUBTEX_SIZE

◆ SMAA_BRANCH

◆ SMAA_CORNER_ROUNDING

◆ SMAA_CORNER_ROUNDING_NORM

◆ SMAA_CUSTOM_SL

◆ SMAA_DECODE_VELOCITY

◆ SMAA_DEPTH_THRESHOLD

◆ SMAA_FLATTEN

◆ SMAA_INCLUDE_PS

◆ SMAA_INCLUDE_VS

◆ SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR

◆ SMAA_MAX_SEARCH_STEPS

◆ SMAA_MAX_SEARCH_STEPS_DIAG

◆ SMAA_PREDICATION

◆ SMAA_PREDICATION_SCALE

◆ SMAA_PREDICATION_STRENGTH

◆ SMAA_PREDICATION_THRESHOLD

◆ SMAA_REPROJECTION

◆ SMAA_REPROJECTION_WEIGHT_SCALE

◆ SMAA_SEARCHTEX_PACKED_SIZE

◆ SMAA_SEARCHTEX_SELECT

◆ SMAA_SEARCHTEX_SIZE

◆ SMAA_THRESHOLD

◆ SMAASample

◆ SMAASampleLevelZero

◆ SMAASampleLevelZeroOffset

◆ SMAASampleLevelZeroPoint

◆ SMAASampleOffset

◆ SMAASamplePoint

◆ SMAASamplePointOffset

◆ SMAATexture2D

◆ SMAATexturePass2D