From 6035d32e1765073ed9bcbc80e0c6c6696eb47154 Mon Sep 17 00:00:00 2001 From: hunterk Date: Fri, 26 Aug 2016 11:28:24 -0500 Subject: [PATCH] big royale cleanup --- blurs/blur9fast-horizontal.slang | 5 +- blurs/blur9fast-vertical.slang | 5 +- crt/crt-royale-test.slangp | 92 - crt/shaders/crt-royale/src/bloom-functions.h | 33 + .../crt-royale/src/blur-functions-old.h | 1916 ----------------- crt/shaders/crt-royale/src/blur-functions.h | 595 ----- .../src/crt-royale-bloom-approx.slang | 8 +- ...royale-bloom-horizontal-reconstitute.slang | 4 +- .../src/crt-royale-bloom-vertical.slang | 5 +- .../src/crt-royale-brightpass.slang | 6 +- ...-pass-linearize-crt-gamma-bob-fields.slang | 7 +- .../crt-royale-geometry-aa-last-pass.slang | 10 +- .../crt-royale-mask-resize-horizontal.slang | 8 +- .../src/crt-royale-mask-resize-vertical.slang | 6 +- ...yale-scanlines-horizontal-apply-mask.slang | 23 +- ...oyale-scanlines-vertical-interlacing.slang | 6 +- .../crt-royale/src/gamma-management-old.h | 547 ----- .../crt-royale/src/geometry-functions-old.h | 692 ------ .../crt-royale/src/geometry-functions.h | 23 + crt/shaders/crt-royale/src/includes.h | 11 - .../src/phosphor-mask-resizing-old.h | 678 ------ .../crt-royale/src/phosphor-mask-resizing.h | 5 +- .../crt-royale/src/quad-pixel-communication.h | 243 --- .../crt-royale/src/scanline-functions-old.h | 572 ----- .../crt-royale/src/scanline-functions.h | 8 +- .../crt-royale/src/special-functions-old.h | 498 ----- .../crt-royale/src/special-functions.h | 498 ----- .../crt-royale/src/tex2Dantialias-old.h | 1393 ------------ crt/shaders/crt-royale/user-settings.h | 2 +- include/blur-functions-old.h | 1916 ----------------- include/blur-functions.h | 326 ++- include/gamma-management-old.h | 547 ----- include/gamma-management.h | 7 +- include/special-functions-old.h | 498 ----- include/special-functions.h | 8 +- 35 files changed, 452 insertions(+), 10749 deletions(-) delete mode 100644 crt/crt-royale-test.slangp delete mode 100644 crt/shaders/crt-royale/src/blur-functions-old.h delete mode 100644 crt/shaders/crt-royale/src/blur-functions.h delete mode 100644 crt/shaders/crt-royale/src/gamma-management-old.h delete mode 100644 crt/shaders/crt-royale/src/geometry-functions-old.h delete mode 100644 crt/shaders/crt-royale/src/includes.h delete mode 100644 crt/shaders/crt-royale/src/phosphor-mask-resizing-old.h delete mode 100644 crt/shaders/crt-royale/src/quad-pixel-communication.h delete mode 100644 crt/shaders/crt-royale/src/scanline-functions-old.h delete mode 100644 crt/shaders/crt-royale/src/special-functions-old.h delete mode 100644 crt/shaders/crt-royale/src/special-functions.h delete mode 100644 crt/shaders/crt-royale/src/tex2Dantialias-old.h delete mode 100644 include/blur-functions-old.h delete mode 100644 include/gamma-management-old.h delete mode 100644 include/special-functions-old.h diff --git a/blurs/blur9fast-horizontal.slang b/blurs/blur9fast-horizontal.slang index bd1fa2f..6215b58 100644 --- a/blurs/blur9fast-horizontal.slang +++ b/blurs/blur9fast-horizontal.slang @@ -54,9 +54,8 @@ layout(std140, set = 0, binding = 0) uniform UBO ////////////////////////////////// INCLUDES ////////////////////////////////// // #included by vertex shader: -//#include "../include/gamma-management.h" -//#include "../include/blur-functions.h" -#include "../crt/shaders/crt-royale/src/includes.h" +#include "../include/gamma-management.h" +#include "../include/blur-functions.h" #pragma stage vertex layout(location = 0) in vec4 Position; diff --git a/blurs/blur9fast-vertical.slang b/blurs/blur9fast-vertical.slang index 30ed5e5..be8a770 100644 --- a/blurs/blur9fast-vertical.slang +++ b/blurs/blur9fast-vertical.slang @@ -54,9 +54,8 @@ layout(std140, set = 0, binding = 0) uniform UBO ////////////////////////////////// INCLUDES ////////////////////////////////// // #included by vertex shader: -//#include "../include/gamma-management.h" -//#include "../include/blur-functions.h" -#include "../crt/shaders/crt-royale/src/includes.h" +#include "../include/gamma-management.h" +#include "../include/blur-functions.h" #pragma stage vertex layout(location = 0) in vec4 Position; diff --git a/crt/crt-royale-test.slangp b/crt/crt-royale-test.slangp deleted file mode 100644 index 0104a01..0000000 --- a/crt/crt-royale-test.slangp +++ /dev/null @@ -1,92 +0,0 @@ -# IMPORTANT: -# Shader passes need to know details about the image in the mask_texture LUT -# files, so set the following constants in user-preset-constants.h accordingly: -# 1.) mask_triads_per_tile = (number of horizontal triads in mask texture LUT's) -# 2.) mask_texture_small_size = (texture size of mask*texture_small LUT's) -# 3.) mask_texture_large_size = (texture size of mask*texture_large LUT's) -# 4.) mask_grille_avg_color = (avg. brightness of mask_grille_texture* LUT's, in [0, 1]) -# 5.) mask_slot_avg_color = (avg. brightness of mask_slot_texture* LUT's, in [0, 1]) -# 6.) mask_shadow_avg_color = (avg. brightness of mask_shadow_texture* LUT's, in [0, 1]) -# Shader passes also need to know certain scales set in this preset, but their -# compilation model doesn't currently allow the preset file to tell them. Make -# sure to set the following constants in user-preset-constants.h accordingly too: -# 1.) bloom_approx_scale_x = scale_x2 -# 2.) mask_resize_viewport_scale = vec2(scale_x6, scale_y5) -# Finally, shader passes need to know the value of geom_max_aspect_ratio used to -# calculate scale_y5 (among other values): -# 1.) geom_max_aspect_ratio = (geom_max_aspect_ratio used to calculate scale_y5) - -shaders = "1"//"12" - -# Set an identifier, filename, and sampling traits for the phosphor mask texture. -# Load an aperture grille, slot mask, and an EDP shadow mask, and load a small -# non-mipmapped version and a large mipmapped version. -# TODO: Test masks in other directories. -textures = "mask_grille_texture_small;mask_grille_texture_large;mask_slot_texture_small;mask_slot_texture_large;mask_shadow_texture_small;mask_shadow_texture_large" -mask_grille_texture_small = "shaders/crt-royale/TileableLinearApertureGrille15Wide8And5d5SpacingResizeTo64.png" -mask_grille_texture_large = "shaders/crt-royale/TileableLinearApertureGrille15Wide8And5d5Spacing.png" -mask_slot_texture_small = "shaders/crt-royale/TileableLinearSlotMaskTall15Wide9And4d5Horizontal9d14VerticalSpacingResizeTo64.png" -mask_slot_texture_large = "shaders/crt-royale/TileableLinearSlotMaskTall15Wide9And4d5Horizontal9d14VerticalSpacing.png" -mask_shadow_texture_small = "shaders/crt-royale/TileableLinearShadowMaskEDPResizeTo64.png" -mask_shadow_texture_large = "shaders/crt-royale/TileableLinearShadowMaskEDP.png" -mask_grille_texture_small_wrap_mode = "repeat" -mask_grille_texture_large_wrap_mode = "repeat" -mask_slot_texture_small_wrap_mode = "repeat" -mask_slot_texture_large_wrap_mode = "repeat" -mask_shadow_texture_small_wrap_mode = "repeat" -mask_shadow_texture_large_wrap_mode = "repeat" -mask_grille_texture_small_linear = "true" -mask_grille_texture_large_linear = "true" -mask_slot_texture_small_linear = "true" -mask_slot_texture_large_linear = "true" -mask_shadow_texture_small_linear = "true" -mask_shadow_texture_large_linear = "true" -mask_grille_texture_small_mipmap = "false" # Mipmapping causes artifacts with manually resized masks without tex2Dlod -mask_grille_texture_large_mipmap = "true" # Essential for hardware-resized masks -mask_slot_texture_small_mipmap = "false" # Mipmapping causes artifacts with manually resized masks without tex2Dlod -mask_slot_texture_large_mipmap = "true" # Essential for hardware-resized masks -mask_shadow_texture_small_mipmap = "false" # Mipmapping causes artifacts with manually resized masks without tex2Dlod -mask_shadow_texture_large_mipmap = "true" # Essential for hardware-resized masks - - -# Pass5: Lanczos-resize the phosphor mask vertically. Set the absolute -# scale_x5 == mask_texture_small_size.x (see IMPORTANT above). Larger scales -# will blur, and smaller scales could get nasty. The vertical size must be -# based on the viewport size and calculated carefully to avoid artifacts later. -# First calculate the minimum number of mask tiles we need to draw. -# Since curvature is computed after the scanline masking pass: -# num_resized_mask_tiles = 2.0; -# If curvature were computed in the scanline masking pass (it's not): -# max_mask_texel_border = ~3.0 * (1/3.0 + 4.0*sqrt(2.0) + 0.5 + 1.0); -# max_mask_tile_border = max_mask_texel_border/ -# (min_resized_phosphor_triad_size * mask_triads_per_tile); -# num_resized_mask_tiles = max(2.0, 1.0 + max_mask_tile_border * 2.0); -# At typical values (triad_size >= 2.0, mask_triads_per_tile == 8): -# num_resized_mask_tiles = ~3.8 -# Triad sizes are given in horizontal terms, so we need geom_max_aspect_ratio -# to relate them to vertical resolution. The widest we expect is: -# geom_max_aspect_ratio = 4.0/3.0 # Note: Shader passes need to know this! -# The fewer triads we tile across the screen, the larger each triad will be as a -# fraction of the viewport size, and the larger scale_y5 must be to draw a full -# num_resized_mask_tiles. Therefore, we must decide the smallest number of -# triads we'll guarantee can be displayed on screen. We'll set this according -# to 3-pixel triads at 768p resolution (the lowest anyone's likely to use): -# min_allowed_viewport_triads = 768.0*geom_max_aspect_ratio / 3.0 = 341.333333 -# Now calculate the viewport scale that ensures we can draw resized_mask_tiles: -# min_scale_x = resized_mask_tiles * mask_triads_per_tile / -# min_allowed_viewport_triads -# scale_y5 = geom_max_aspect_ratio * min_scale_x -# # Some code might depend on equal scales: -# scale_x6 = scale_y5 -# Given our default geom_max_aspect_ratio and min_allowed_viewport_triads: -# scale_y5 = 4.0/3.0 * 2.0/(341.33333 / 8.0) = 0.0625 -# IMPORTANT: The scales MUST be calculated in this way. If you wish to change -# geom_max_aspect_ratio, update that constant in user-preset-constants.h! -shader0 = "shaders/crt-royale/src/crt-royale-mask-resize-vertical.slang" -filter_linear0 = "true" -scale_type_x0 = "absolute" -scale_x0 = "64" -scale_type_y0 = "viewport" -scale_y0 = "0.0625" # Safe for >= 341.333 horizontal triads at viewport size -#srgb_framebuffer0 = "false" # mask_texture is already assumed linear - diff --git a/crt/shaders/crt-royale/src/bloom-functions.h b/crt/shaders/crt-royale/src/bloom-functions.h index 2f77d4f..35909cd 100644 --- a/crt/shaders/crt-royale/src/bloom-functions.h +++ b/crt/shaders/crt-royale/src/bloom-functions.h @@ -1,6 +1,39 @@ #ifndef BLOOM_FUNCTIONS_H #define BLOOM_FUNCTIONS_H +///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// + +// crt-royale: A full-featured CRT shader, with cheese. +// Copyright (C) 2014 TroggleMonkey +// +// This program is free software; you can redistribute it and/or modify it +// under the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 of the License, or any later version. +// +// This program is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +// more details. +// +// You should have received a copy of the GNU General Public License along with +// this program; if not, write to the Free Software Foundation, Inc., 59 Temple +// Place, Suite 330, Boston, MA 02111-1307 USA + + +///////////////////////////////// DESCRIPTION //////////////////////////////// + +// These utility functions and constants help several passes determine the +// size and center texel weight of the phosphor bloom in a uniform manner. + + +////////////////////////////////// INCLUDES ////////////////////////////////// + +// We need to calculate the correct blur sigma using some .cgp constants: +#include "../user-settings.h" +#include "derived-settings-and-constants.h" +#include "../../../../include/blur-functions.h" + + /////////////////////////////// BLOOM CONSTANTS ////////////////////////////// // Compute constants with manual inlines of the functions below: diff --git a/crt/shaders/crt-royale/src/blur-functions-old.h b/crt/shaders/crt-royale/src/blur-functions-old.h deleted file mode 100644 index 05da1c7..0000000 --- a/crt/shaders/crt-royale/src/blur-functions-old.h +++ /dev/null @@ -1,1916 +0,0 @@ -#ifndef BLUR_FUNCTIONS_H -#define BLUR_FUNCTIONS_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file provides reusable one-pass and separable (two-pass) blurs. -// Requires: All blurs share these requirements (dxdy requirement is split): -// 1.) All requirements of gamma-management.h must be satisfied! -// 2.) filter_linearN must == "true" in your .cgp preset unless -// you're using tex2DblurNresize at 1x scale. -// 3.) mipmap_inputN must == "true" in your .cgp preset if -// IN.output_size < IN.video_size. -// 4.) IN.output_size == IN.video_size / pow(2, M), where M is some -// positive integer. tex2Dblur*resize can resize arbitrarily -// (and the blur will be done after resizing), but arbitrary -// resizes "fail" with other blurs due to the way they mix -// static weights with bilinear sample exploitation. -// 5.) In general, dxdy should contain the uv pixel spacing: -// dxdy = (IN.video_size/IN.output_size)/IN.texture_size -// 6.) For separable blurs (tex2DblurNresize and tex2DblurNfast), -// zero out the dxdy component in the unblurred dimension: -// dxdy = vec2(dxdy.x, 0.0) or vec2(0.0, dxdy.y) -// Many blurs share these requirements: -// 1.) One-pass blurs require scale_xN == scale_yN or scales > 1.0, -// or they will blur more in the lower-scaled dimension. -// 2.) One-pass shared sample blurs require ddx(), ddy(), and -// tex2Dlod() to be supported by the current Cg profile, and -// the drivers must support high-quality derivatives. -// 3.) One-pass shared sample blurs require: -// tex_uv.w == log2(IN.video_size/IN.output_size).y; -// Non-wrapper blurs share this requirement: -// 1.) sigma is the intended standard deviation of the blur -// Wrapper blurs share this requirement, which is automatically -// met (unless OVERRIDE_BLUR_STD_DEVS is #defined; see below): -// 1.) blurN_std_dev must be global static const float values -// specifying standard deviations for Nx blurs in units -// of destination pixels -// Optional: 1.) The including file (or an earlier included file) may -// optionally #define USE_BINOMIAL_BLUR_STD_DEVS to replace -// default standard deviations with those matching a binomial -// distribution. (See below for details/properties.) -// 2.) The including file (or an earlier included file) may -// optionally #define OVERRIDE_BLUR_STD_DEVS and override: -// static const float blur3_std_dev -// static const float blur4_std_dev -// static const float blur5_std_dev -// static const float blur6_std_dev -// static const float blur7_std_dev -// static const float blur8_std_dev -// static const float blur9_std_dev -// static const float blur10_std_dev -// static const float blur11_std_dev -// static const float blur12_std_dev -// static const float blur17_std_dev -// static const float blur25_std_dev -// static const float blur31_std_dev -// static const float blur43_std_dev -// 3.) The including file (or an earlier included file) may -// optionally #define OVERRIDE_ERROR_BLURRING and override: -// static const float error_blurring -// This tuning value helps mitigate weighting errors from one- -// pass shared-sample blurs sharing bilinear samples between -// fragments. Values closer to 0.0 have "correct" blurriness -// but allow more artifacts, and values closer to 1.0 blur away -// artifacts by sampling closer to halfway between texels. -// UPDATE 6/21/14: The above static constants may now be overridden -// by non-static uniform constants. This permits exposing blur -// standard deviations as runtime GUI shader parameters. However, -// using them keeps weights from being statically computed, and the -// speed hit depends on the blur: On my machine, uniforms kill over -// 53% of the framerate with tex2Dblur12x12shared, but they only -// drop the framerate by about 18% with tex2Dblur11fast. -// Quality and Performance Comparisons: -// For the purposes of the following discussion, "no sRGB" means -// GAMMA_ENCODE_EVERY_FBO is #defined, and "sRGB" means it isn't. -// 1.) tex2DblurNfast is always faster than tex2DblurNresize. -// 2.) tex2DblurNresize functions are the only ones that can arbitrarily resize -// well, because they're the only ones that don't exploit bilinear samples. -// This also means they're the only functions which can be truly gamma- -// correct without linear (or sRGB FBO) input, but only at 1x scale. -// 3.) One-pass shared sample blurs only have a speed advantage without sRGB. -// They also have some inaccuracies due to their shared-[bilinear-]sample -// design, which grow increasingly bothersome for smaller blurs and higher- -// frequency source images (relative to their resolution). I had high -// hopes for them, but their most realistic use case is limited to quickly -// reblurring an already blurred input at full resolution. Otherwise: -// a.) If you're blurring a low-resolution source, you want a better blur. -// b.) If you're blurring a lower mipmap, you want a better blur. -// c.) If you're blurring a high-resolution, high-frequency source, you -// want a better blur. -// 4.) The one-pass blurs without shared samples grow slower for larger blurs, -// but they're competitive with separable blurs at 5x5 and smaller, and -// even tex2Dblur7x7 isn't bad if you're wanting to conserve passes. -// Here are some framerates from a GeForce 8800GTS. The first pass resizes to -// viewport size (4x in this test) and linearizes for sRGB codepaths, and the -// remaining passes perform 6 full blurs. Mipmapped tests are performed at the -// same scale, so they just measure the cost of mipmapping each FBO (only every -// other FBO is mipmapped for separable blurs, to mimic realistic usage). -// Mipmap Neither sRGB+Mipmap sRGB Function -// 76.0 92.3 131.3 193.7 tex2Dblur3fast -// 63.2 74.4 122.4 175.5 tex2Dblur3resize -// 93.7 121.2 159.3 263.2 tex2Dblur3x3 -// 59.7 68.7 115.4 162.1 tex2Dblur3x3resize -// 63.2 74.4 122.4 175.5 tex2Dblur5fast -// 49.3 54.8 100.0 132.7 tex2Dblur5resize -// 59.7 68.7 115.4 162.1 tex2Dblur5x5 -// 64.9 77.2 99.1 137.2 tex2Dblur6x6shared -// 55.8 63.7 110.4 151.8 tex2Dblur7fast -// 39.8 43.9 83.9 105.8 tex2Dblur7resize -// 40.0 44.2 83.2 104.9 tex2Dblur7x7 -// 56.4 65.5 71.9 87.9 tex2Dblur8x8shared -// 49.3 55.1 99.9 132.5 tex2Dblur9fast -// 33.3 36.2 72.4 88.0 tex2Dblur9resize -// 27.8 29.7 61.3 72.2 tex2Dblur9x9 -// 37.2 41.1 52.6 60.2 tex2Dblur10x10shared -// 44.4 49.5 91.3 117.8 tex2Dblur11fast -// 28.8 30.8 63.6 75.4 tex2Dblur11resize -// 33.6 36.5 40.9 45.5 tex2Dblur12x12shared -// TODO: Fill in benchmarks for new untested blurs. -// tex2Dblur17fast -// tex2Dblur25fast -// tex2Dblur31fast -// tex2Dblur43fast -// tex2Dblur3x3resize - - -///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// - -// Set static standard deviations, but allow users to override them with their -// own constants (even non-static uniforms if they're okay with the speed hit): -#ifndef OVERRIDE_BLUR_STD_DEVS - // blurN_std_dev values are specified in terms of dxdy strides. - #ifdef USE_BINOMIAL_BLUR_STD_DEVS - // By request, we can define standard deviations corresponding to a - // binomial distribution with p = 0.5 (related to Pascal's triangle). - // This distribution works such that blurring multiple times should - // have the same result as a single larger blur. These values are - // larger than default for blurs up to 6x and smaller thereafter. - const float blur3_std_dev = 0.84931640625; - const float blur4_std_dev = 0.84931640625; - const float blur5_std_dev = 1.0595703125; - const float blur6_std_dev = 1.06591796875; - const float blur7_std_dev = 1.17041015625; - const float blur8_std_dev = 1.1720703125; - const float blur9_std_dev = 1.2259765625; - const float blur10_std_dev = 1.21982421875; - const float blur11_std_dev = 1.25361328125; - const float blur12_std_dev = 1.2423828125; - const float blur17_std_dev = 1.27783203125; - const float blur25_std_dev = 1.2810546875; - const float blur31_std_dev = 1.28125; - const float blur43_std_dev = 1.28125; - #else - // The defaults are the largest values that keep the largest unused - // blur term on each side <= 1.0/256.0. (We could get away with more - // or be more conservative, but this compromise is pretty reasonable.) - const float blur3_std_dev = 0.62666015625; - const float blur4_std_dev = 0.66171875; - const float blur5_std_dev = 0.9845703125; - const float blur6_std_dev = 1.02626953125; - const float blur7_std_dev = 1.36103515625; - const float blur8_std_dev = 1.4080078125; - const float blur9_std_dev = 1.7533203125; - const float blur10_std_dev = 1.80478515625; - const float blur11_std_dev = 2.15986328125; - const float blur12_std_dev = 2.215234375; - const float blur17_std_dev = 3.45535583496; - const float blur25_std_dev = 5.3409576416; - const float blur31_std_dev = 6.86488037109; - const float blur43_std_dev = 10.1852050781; - #endif // USE_BINOMIAL_BLUR_STD_DEVS -#endif // OVERRIDE_BLUR_STD_DEVS - -#ifndef OVERRIDE_ERROR_BLURRING - // error_blurring should be in [0.0, 1.0]. Higher values reduce ringing - // in shared-sample blurs but increase blurring and feature shifting. - const float error_blurring = 0.5; -#endif - - -////////////////////////////////// INCLUDES ////////////////////////////////// - -// gamma-management.h relies on pass-specific settings to guide its behavior: -// FIRST_PASS, LAST_PASS, GAMMA_ENCODE_EVERY_FBO, etc. See it for details. -//#include "gamma-management.h" -#include "quad-pixel-communication.h" -#include "special-functions.h" - - -/////////////////////////////////// HELPERS ////////////////////////////////// - -vec4 uv2_to_uv4(vec2 tex_uv) -{ - // Make a vec2 uv offset safe for adding to vec4 tex2Dlod coords: - return vec4(tex_uv, 0.0, 0.0); -} - -// Make a length squared helper macro (for usage with static constants): -#define LENGTH_SQ(vec) (dot(vec, vec)) - -float get_fast_gaussian_weight_sum_inv(const float sigma) -{ - // We can use the Gaussian integral to calculate the asymptotic weight for - // the center pixel. Since the unnormalized center pixel weight is 1.0, - // the normalized weight is the same as the weight sum inverse. Given a - // large enough blur (9+), the asymptotic weight sum is close and faster: - // center_weight = 0.5 * - // (erf(0.5/(sigma*sqrt(2.0))) - erf(-0.5/(sigma*sqrt(2.0)))) - // erf(-x) == -erf(x), so we get 0.5 * (2.0 * erf(blah blah)): - // However, we can get even faster results with curve-fitting. These are - // also closer than the asymptotic results, because they were constructed - // from 64 blurs sizes from [3, 131) and 255 equally-spaced sigmas from - // (0, blurN_std_dev), so the results for smaller sigmas are biased toward - // smaller blurs. The max error is 0.0031793913. - // Relative FPS: 134.3 with erf, 135.8 with curve-fitting. - //static const float temp = 0.5/sqrt(2.0); - //return erf(temp/sigma); - return min(exp(exp(0.348348412457428/ - (sigma - 0.0860587260734721))), 0.399334576340352/sigma); -} - - -//////////////////// ARBITRARILY RESIZABLE SEPARABLE BLURS /////////////////// - -vec3 tex2Dblur11resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 11x Gaussian blurred texture lookup using a 11-tap blur. - // It may be mipmapped depending on settings and dxdy. - // Calculate Gaussian blur kernel weights and a normalization factor for - // distances of 0-4, ignoring constant factors (since we're normalizing). - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float weight_sum_inv = 1.0 / - (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5)); - // Statically normalize weights, sum weighted samples, and return. Blurs are - // currently optimized for dynamic weights. - vec3 sum = vec3(0.0); - sum += w5 * tex2D_linearize(texture, tex_uv - 5.0 * dxdy).rgb; - sum += w4 * tex2D_linearize(texture, tex_uv - 4.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv - 3.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv + 3.0 * dxdy).rgb; - sum += w4 * tex2D_linearize(texture, tex_uv + 4.0 * dxdy).rgb; - sum += w5 * tex2D_linearize(texture, tex_uv + 5.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur9resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 9x Gaussian blurred texture lookup using a 9-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4)); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w4 * tex2D_linearize(texture, tex_uv - 4.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv - 3.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv + 3.0 * dxdy).rgb; - sum += w4 * tex2D_linearize(texture, tex_uv + 4.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur7resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 7x Gaussian blurred texture lookup using a 7-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3)); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w3 * tex2D_linearize(texture, tex_uv - 3.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv + 3.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur5resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 5x Gaussian blurred texture lookup using a 5-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2)); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 3x Gaussian blurred texture lookup using a 3-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * w1); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - - -/////////////////////////// FAST SEPARABLE BLURS /////////////////////////// - -vec3 tex2Dblur11fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: 1.) Global requirements must be met (see file description). - // 2.) filter_linearN must = "true" in your .cgp file. - // 3.) For gamma-correct bilinear filtering, global - // gamma_aware_bilinear == true (from gamma-management.h) - // Returns: A 1D 11x Gaussian blurred texture lookup using 6 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float weight_sum_inv = 1.0 / - (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5)); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w01 = w0 * 0.5 + w1; - const float w23 = w2 + w3; - const float w45 = w4 + w5; - const float w01_ratio = w1/w01; - const float w23_ratio = w3/w23; - const float w45_ratio = w5/w45; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w45 * tex2D_linearize(texture, tex_uv - (4.0 + w45_ratio) * dxdy).rgb; - sum += w23 * tex2D_linearize(texture, tex_uv - (2.0 + w23_ratio) * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv - w01_ratio * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv + w01_ratio * dxdy).rgb; - sum += w23 * tex2D_linearize(texture, tex_uv + (2.0 + w23_ratio) * dxdy).rgb; - sum += w45 * tex2D_linearize(texture, tex_uv + (4.0 + w45_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur9fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 9x Gaussian blurred texture lookup using 1 nearest - // neighbor and 4 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4)); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w12 = w1 + w2; - const float w34 = w3 + w4; - const float w12_ratio = w2/w12; - const float w34_ratio = w4/w34; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w34 * tex2D_linearize(texture, tex_uv - (3.0 + w34_ratio) * dxdy).rgb; - sum += w12 * tex2D_linearize(texture, tex_uv - (1.0 + w12_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w12 * tex2D_linearize(texture, tex_uv + (1.0 + w12_ratio) * dxdy).rgb; - sum += w34 * tex2D_linearize(texture, tex_uv + (3.0 + w34_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur7fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 7x Gaussian blurred texture lookup using 4 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3)); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w01 = w0 * 0.5 + w1; - const float w23 = w2 + w3; - const float w01_ratio = w1/w01; - const float w23_ratio = w3/w23; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w23 * tex2D_linearize(texture, tex_uv - (2.0 + w23_ratio) * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv - w01_ratio * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv + w01_ratio * dxdy).rgb; - sum += w23 * tex2D_linearize(texture, tex_uv + (2.0 + w23_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur5fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 5x Gaussian blurred texture lookup using 1 nearest - // neighbor and 2 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2)); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w12 = w1 + w2; - const float w12_ratio = w2/w12; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w12 * tex2D_linearize(texture, tex_uv - (1.0 + w12_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w12 * tex2D_linearize(texture, tex_uv + (1.0 + w12_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur3fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 3x Gaussian blurred texture lookup using 2 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * w1); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w01 = w0 * 0.5 + w1; - const float w01_ratio = w1/w01; - // Weights for all samples are the same, so just average them: - return 0.5 * ( - tex2D_linearize(texture, tex_uv - w01_ratio * dxdy).rgb + - tex2D_linearize(texture, tex_uv + w01_ratio * dxdy).rgb); -} - - -//////////////////////////// HUGE SEPARABLE BLURS //////////////////////////// - -// Huge separable blurs come only in "fast" versions. -vec3 tex2Dblur43fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 43x Gaussian blurred texture lookup using 22 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - const float w13 = exp(-169.0 * denom_inv); - const float w14 = exp(-196.0 * denom_inv); - const float w15 = exp(-225.0 * denom_inv); - const float w16 = exp(-256.0 * denom_inv); - const float w17 = exp(-289.0 * denom_inv); - const float w18 = exp(-324.0 * denom_inv); - const float w19 = exp(-361.0 * denom_inv); - const float w20 = exp(-400.0 * denom_inv); - const float w21 = exp(-441.0 * denom_inv); - //const float weight_sum_inv = 1.0 / - // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + - // w12 + w13 + w14 + w15 + w16 + w17 + w18 + w19 + w20 + w21)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w0_1 = w0 * 0.5 + w1; - const float w2_3 = w2 + w3; - const float w4_5 = w4 + w5; - const float w6_7 = w6 + w7; - const float w8_9 = w8 + w9; - const float w10_11 = w10 + w11; - const float w12_13 = w12 + w13; - const float w14_15 = w14 + w15; - const float w16_17 = w16 + w17; - const float w18_19 = w18 + w19; - const float w20_21 = w20 + w21; - const float w0_1_ratio = w1/w0_1; - const float w2_3_ratio = w3/w2_3; - const float w4_5_ratio = w5/w4_5; - const float w6_7_ratio = w7/w6_7; - const float w8_9_ratio = w9/w8_9; - const float w10_11_ratio = w11/w10_11; - const float w12_13_ratio = w13/w12_13; - const float w14_15_ratio = w15/w14_15; - const float w16_17_ratio = w17/w16_17; - const float w18_19_ratio = w19/w18_19; - const float w20_21_ratio = w21/w20_21; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w20_21 * tex2D_linearize(texture, tex_uv - (20.0 + w20_21_ratio) * dxdy).rgb; - sum += w18_19 * tex2D_linearize(texture, tex_uv - (18.0 + w18_19_ratio) * dxdy).rgb; - sum += w16_17 * tex2D_linearize(texture, tex_uv - (16.0 + w16_17_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(texture, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv - w0_1_ratio * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv + w0_1_ratio * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(texture, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w16_17 * tex2D_linearize(texture, tex_uv + (16.0 + w16_17_ratio) * dxdy).rgb; - sum += w18_19 * tex2D_linearize(texture, tex_uv + (18.0 + w18_19_ratio) * dxdy).rgb; - sum += w20_21 * tex2D_linearize(texture, tex_uv + (20.0 + w20_21_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur31fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 31x Gaussian blurred texture lookup using 16 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - const float w13 = exp(-169.0 * denom_inv); - const float w14 = exp(-196.0 * denom_inv); - const float w15 = exp(-225.0 * denom_inv); - //const float weight_sum_inv = 1.0 / - // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + - // w9 + w10 + w11 + w12 + w13 + w14 + w15)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w0_1 = w0 * 0.5 + w1; - const float w2_3 = w2 + w3; - const float w4_5 = w4 + w5; - const float w6_7 = w6 + w7; - const float w8_9 = w8 + w9; - const float w10_11 = w10 + w11; - const float w12_13 = w12 + w13; - const float w14_15 = w14 + w15; - const float w0_1_ratio = w1/w0_1; - const float w2_3_ratio = w3/w2_3; - const float w4_5_ratio = w5/w4_5; - const float w6_7_ratio = w7/w6_7; - const float w8_9_ratio = w9/w8_9; - const float w10_11_ratio = w11/w10_11; - const float w12_13_ratio = w13/w12_13; - const float w14_15_ratio = w15/w14_15; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w14_15 * tex2D_linearize(texture, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv - w0_1_ratio * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv + w0_1_ratio * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(texture, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur25fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 25x Gaussian blurred texture lookup using 1 nearest - // neighbor and 12 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( - // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + w12)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w1_2 = w1 + w2; - const float w3_4 = w3 + w4; - const float w5_6 = w5 + w6; - const float w7_8 = w7 + w8; - const float w9_10 = w9 + w10; - const float w11_12 = w11 + w12; - const float w1_2_ratio = w2/w1_2; - const float w3_4_ratio = w4/w3_4; - const float w5_6_ratio = w6/w5_6; - const float w7_8_ratio = w8/w7_8; - const float w9_10_ratio = w10/w9_10; - const float w11_12_ratio = w12/w11_12; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w11_12 * tex2D_linearize(texture, tex_uv - (11.0 + w11_12_ratio) * dxdy).rgb; - sum += w9_10 * tex2D_linearize(texture, tex_uv - (9.0 + w9_10_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(texture, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(texture, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w9_10 * tex2D_linearize(texture, tex_uv + (9.0 + w9_10_ratio) * dxdy).rgb; - sum += w11_12 * tex2D_linearize(texture, tex_uv + (11.0 + w11_12_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur17fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 17x Gaussian blurred texture lookup using 1 nearest - // neighbor and 8 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( - // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w1_2 = w1 + w2; - const float w3_4 = w3 + w4; - const float w5_6 = w5 + w6; - const float w7_8 = w7 + w8; - const float w1_2_ratio = w2/w1_2; - const float w3_4_ratio = w4/w3_4; - const float w5_6_ratio = w6/w5_6; - const float w7_8_ratio = w8/w7_8; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w7_8 * tex2D_linearize(texture, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(texture, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - - -//////////////////// ARBITRARILY RESIZABLE ONE-PASS BLURS //////////////////// - -vec3 tex2Dblur3x3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 3x3 Gaussian blurred mipmapped texture lookup of the - // resized input. - // Description: - // This is the only arbitrarily resizable one-pass blur; tex2Dblur5x5resize - // would perform like tex2Dblur9x9, MUCH slower than tex2Dblur5resize. - const float denom_inv = 0.5/(sigma*sigma); - // Load each sample. We need all 3x3 samples. Quad-pixel communication - // won't help either: This should perform like tex2Dblur5x5, but sharing a - // 4x4 sample field would perform more like tex2Dblur8x8shared (worse). - const vec2 sample4_uv = tex_uv; - const vec2 dx = vec2(dxdy.x, 0.0); - const vec2 dy = vec2(0.0, dxdy.y); - const vec2 sample1_uv = sample4_uv - dy; - const vec2 sample7_uv = sample4_uv + dy; - const vec3 sample0 = tex2D_linearize(texture, sample1_uv - dx).rgb; - const vec3 sample1 = tex2D_linearize(texture, sample1_uv).rgb; - const vec3 sample2 = tex2D_linearize(texture, sample1_uv + dx).rgb; - const vec3 sample3 = tex2D_linearize(texture, sample4_uv - dx).rgb; - const vec3 sample4 = tex2D_linearize(texture, sample4_uv).rgb; - const vec3 sample5 = tex2D_linearize(texture, sample4_uv + dx).rgb; - const vec3 sample6 = tex2D_linearize(texture, sample7_uv - dx).rgb; - const vec3 sample7 = tex2D_linearize(texture, sample7_uv).rgb; - const vec3 sample8 = tex2D_linearize(texture, sample7_uv + dx).rgb; - // Statically compute Gaussian sample weights: - const float w4 = 1.0; - const float w1_3_5_7 = exp(-LENGTH_SQ(vec2(1.0, 0.0)) * denom_inv); - const float w0_2_6_8 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float weight_sum_inv = 1.0/(w4 + 4.0 * (w1_3_5_7 + w0_2_6_8)); - // Weight and sum the samples: - const vec3 sum = w4 * sample4 + - w1_3_5_7 * (sample1 + sample3 + sample5 + sample7) + - w0_2_6_8 * (sample0 + sample2 + sample6 + sample8); - return sum * weight_sum_inv; -} - - -//////////////////////////// FASTER ONE-PASS BLURS /////////////////////////// - -vec3 tex2Dblur9x9(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 9x9 blur with 5x5 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 9x9 Gaussian blurred mipmapped texture lookup composed of - // 5x5 carefully selected bilinear samples. - // Description: - // Perform a 1-pass 9x9 blur with 5x5 bilinear samples. Adjust the - // bilinear sample location to reflect the true Gaussian weights for each - // underlying texel. The following diagram illustrates the relative - // locations of bilinear samples. Each sample with the same number has the - // same weight (notice the symmetry). The letters a, b, c, d distinguish - // quadrants, and the letters U, D, L, R, C (up, down, left, right, center) - // distinguish 1D directions along the line containing the pixel center: - // 6a 5a 2U 5b 6b - // 4a 3a 1U 3b 4b - // 2L 1L 0C 1R 2R - // 4c 3c 1D 3d 4d - // 6c 5c 2D 5d 6d - // The following diagram illustrates the underlying equally spaced texels, - // named after the sample that accesses them and subnamed by their location - // within their 2x2, 2x1, 1x2, or 1x1 texel block: - // 6a4 6a3 5a4 5a3 2U2 5b3 5b4 6b3 6b4 - // 6a2 6a1 5a2 5a1 2U1 5b1 5b2 6b1 6b2 - // 4a4 4a3 3a4 3a3 1U2 3b3 3b4 4b3 4b4 - // 4a2 4a1 3a2 3a1 1U1 3b1 3b2 4b1 4b2 - // 2L2 2L1 1L2 1L1 0C1 1R1 1R2 2R1 2R2 - // 4c2 4c1 3c2 3c1 1D1 3d1 3d2 4d1 4d2 - // 4c4 4c3 3c4 3c3 1D2 3d3 3d4 4d3 4d4 - // 6c2 6c1 5c2 5c1 2D1 5d1 5d2 6d1 6d2 - // 6c4 6c3 5c4 5c3 2D2 5d3 5d4 6d3 6d4 - // Note there is only one C texel and only two texels for each U, D, L, or - // R sample. The center sample is effectively a nearest neighbor sample, - // and the U/D/L/R samples use 1D linear filtering. All other texels are - // read with bilinear samples somewhere within their 2x2 texel blocks. - - // COMPUTE TEXTURE COORDS: - // Statically compute sampling offsets within each 2x2 texel block, based - // on 1D sampling ratios between texels [1, 2] and [3, 4] texels away from - // the center, and reuse them independently for both dimensions. Compute - // these offsets based on the relative 1D Gaussian weights of the texels - // in question. (w1off means "Gaussian weight for the texel 1.0 texels - // away from the pixel center," etc.). - const float denom_inv = 0.5/(sigma*sigma); - const float w1off = exp(-1.0 * denom_inv); - const float w2off = exp(-4.0 * denom_inv); - const float w3off = exp(-9.0 * denom_inv); - const float w4off = exp(-16.0 * denom_inv); - const float texel1to2ratio = w2off/(w1off + w2off); - const float texel3to4ratio = w4off/(w3off + w4off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including x-axis-aligned: - const vec2 sample1R_texel_offset = vec2(1.0, 0.0) + vec2(texel1to2ratio, 0.0); - const vec2 sample2R_texel_offset = vec2(3.0, 0.0) + vec2(texel3to4ratio, 0.0); - const vec2 sample3d_texel_offset = vec2(1.0, 1.0) + vec2(texel1to2ratio, texel1to2ratio); - const vec2 sample4d_texel_offset = vec2(3.0, 1.0) + vec2(texel3to4ratio, texel1to2ratio); - const vec2 sample5d_texel_offset = vec2(1.0, 3.0) + vec2(texel1to2ratio, texel3to4ratio); - const vec2 sample6d_texel_offset = vec2(3.0, 3.0) + vec2(texel3to4ratio, texel3to4ratio); - - // CALCULATE KERNEL WEIGHTS FOR ALL SAMPLES: - // Statically compute Gaussian texel weights for the bottom-right quadrant. - // Read underscores as "and." - const float w1R1 = w1off; - const float w1R2 = w2off; - const float w2R1 = w3off; - const float w2R2 = w4off; - const float w3d1 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float w3d2_3d3 = exp(-LENGTH_SQ(vec2(2.0, 1.0)) * denom_inv); - const float w3d4 = exp(-LENGTH_SQ(vec2(2.0, 2.0)) * denom_inv); - const float w4d1_5d1 = exp(-LENGTH_SQ(vec2(3.0, 1.0)) * denom_inv); - const float w4d2_5d3 = exp(-LENGTH_SQ(vec2(4.0, 1.0)) * denom_inv); - const float w4d3_5d2 = exp(-LENGTH_SQ(vec2(3.0, 2.0)) * denom_inv); - const float w4d4_5d4 = exp(-LENGTH_SQ(vec2(4.0, 2.0)) * denom_inv); - const float w6d1 = exp(-LENGTH_SQ(vec2(3.0, 3.0)) * denom_inv); - const float w6d2_6d3 = exp(-LENGTH_SQ(vec2(4.0, 3.0)) * denom_inv); - const float w6d4 = exp(-LENGTH_SQ(vec2(4.0, 4.0)) * denom_inv); - // Statically add texel weights in each sample to get sample weights: - const float w0 = 1.0; - const float w1 = w1R1 + w1R2; - const float w2 = w2R1 + w2R2; - const float w3 = w3d1 + 2.0 * w3d2_3d3 + w3d4; - const float w4 = w4d1_5d1 + w4d2_5d3 + w4d3_5d2 + w4d4_5d4; - const float w5 = w4; - const float w6 = w6d1 + 2.0 * w6d2_6d3 + w6d4; - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = - 1.0/(w0 + 4.0 * (w1 + w2 + w3 + w4 + w5 + w6)); - - // LOAD TEXTURE SAMPLES: - // Load all 25 samples (1 nearest, 8 linear, 16 bilinear) using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - // Sampling order doesn't seem to affect performance, so just be clear: - const vec3 sample0C = tex2D_linearize(texture, tex_uv).rgb; - const vec3 sample1R = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset).rgb; - const vec3 sample1D = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample1L = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset).rgb; - const vec3 sample1U = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample2R = tex2D_linearize(texture, tex_uv + dxdy * sample2R_texel_offset).rgb; - const vec3 sample2D = tex2D_linearize(texture, tex_uv + dxdy * sample2R_texel_offset.yx).rgb; - const vec3 sample2L = tex2D_linearize(texture, tex_uv - dxdy * sample2R_texel_offset).rgb; - const vec3 sample2U = tex2D_linearize(texture, tex_uv - dxdy * sample2R_texel_offset.yx).rgb; - const vec3 sample3d = tex2D_linearize(texture, tex_uv + dxdy * sample3d_texel_offset).rgb; - const vec3 sample3c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample3d_texel_offset).rgb; - const vec3 sample3b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample3d_texel_offset).rgb; - const vec3 sample3a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample3d_texel_offset).rgb; - const vec3 sample4d = tex2D_linearize(texture, tex_uv + dxdy * sample4d_texel_offset).rgb; - const vec3 sample4c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample4d_texel_offset).rgb; - const vec3 sample4b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample4d_texel_offset).rgb; - const vec3 sample4a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample4d_texel_offset).rgb; - const vec3 sample5d = tex2D_linearize(texture, tex_uv + dxdy * sample5d_texel_offset).rgb; - const vec3 sample5c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample5d_texel_offset).rgb; - const vec3 sample5b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample5d_texel_offset).rgb; - const vec3 sample5a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample5d_texel_offset).rgb; - const vec3 sample6d = tex2D_linearize(texture, tex_uv + dxdy * sample6d_texel_offset).rgb; - const vec3 sample6c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample6d_texel_offset).rgb; - const vec3 sample6b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample6d_texel_offset).rgb; - const vec3 sample6a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample6d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Statically normalize weights (so total = 1.0), and sum weighted samples. - vec3 sum = w0 * sample0C; - sum += w1 * (sample1R + sample1D + sample1L + sample1U); - sum += w2 * (sample2R + sample2D + sample2L + sample2U); - sum += w3 * (sample3d + sample3c + sample3b + sample3a); - sum += w4 * (sample4d + sample4c + sample4b + sample4a); - sum += w5 * (sample5d + sample5c + sample5b + sample5a); - sum += w6 * (sample6d + sample6c + sample6b + sample6a); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur7x7(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 7x7 blur with 5x5 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 7x7 Gaussian blurred mipmapped texture lookup composed of - // 4x4 carefully selected bilinear samples. - // Description: - // First see the descriptions for tex2Dblur9x9() and tex2Dblur7(). This - // blur mixes concepts from both. The sample layout is as follows: - // 4a 3a 3b 4b - // 2a 1a 1b 2b - // 2c 1c 1d 2d - // 4c 3c 3d 4d - // The texel layout is as follows. Note that samples 3a/3b, 1a/1b, 1c/1d, - // and 3c/3d share a vertical column of texels, and samples 2a/2c, 1a/1c, - // 1b/1d, and 2b/2d share a horizontal row of texels (all sample1's share - // the center texel): - // 4a4 4a3 3a4 3ab3 3b4 4b3 4b4 - // 4a2 4a1 3a2 3ab1 3b2 4b1 4b2 - // 2a4 2a3 1a4 1ab3 1b4 2b3 2b4 - // 2ac2 2ac1 1ac2 1* 1bd2 2bd1 2bd2 - // 2c4 2c3 1c4 1cd3 1d4 2d3 2d4 - // 4c2 4c1 3c2 3cd1 3d2 4d1 4d2 - // 4c4 4c3 3c4 3cd3 3d4 4d3 4d4 - - // COMPUTE TEXTURE COORDS: - // Statically compute bilinear sampling offsets (details in tex2Dblur9x9). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w1off = exp(-1.0 * denom_inv); - const float w2off = exp(-4.0 * denom_inv); - const float w3off = exp(-9.0 * denom_inv); - const float texel0to1ratio = w1off/(w0off * 0.5 + w1off); - const float texel2to3ratio = w3off/(w2off + w3off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including axis-aligned: - const vec2 sample1d_texel_offset = vec2(texel0to1ratio, texel0to1ratio); - const vec2 sample2d_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample3d_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample4d_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - - // CALCULATE KERNEL WEIGHTS FOR ALL SAMPLES: - // Statically compute Gaussian texel weights for the bottom-right quadrant. - // Read underscores as "and." - const float w1abcd = 1.0; - const float w1bd2_1cd3 = exp(-LENGTH_SQ(vec2(1.0, 0.0)) * denom_inv); - const float w2bd1_3cd1 = exp(-LENGTH_SQ(vec2(2.0, 0.0)) * denom_inv); - const float w2bd2_3cd2 = exp(-LENGTH_SQ(vec2(3.0, 0.0)) * denom_inv); - const float w1d4 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float w2d3_3d2 = exp(-LENGTH_SQ(vec2(2.0, 1.0)) * denom_inv); - const float w2d4_3d4 = exp(-LENGTH_SQ(vec2(3.0, 1.0)) * denom_inv); - const float w4d1 = exp(-LENGTH_SQ(vec2(2.0, 2.0)) * denom_inv); - const float w4d2_4d3 = exp(-LENGTH_SQ(vec2(3.0, 2.0)) * denom_inv); - const float w4d4 = exp(-LENGTH_SQ(vec2(3.0, 3.0)) * denom_inv); - // Statically add texel weights in each sample to get sample weights. - // Split weights for shared texels between samples sharing them: - const float w1 = w1abcd * 0.25 + w1bd2_1cd3 + w1d4; - const float w2_3 = (w2bd1_3cd1 + w2bd2_3cd2) * 0.5 + w2d3_3d2 + w2d4_3d4; - const float w4 = w4d1 + 2.0 * w4d2_4d3 + w4d4; - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = - 1.0/(4.0 * (w1 + 2.0 * w2_3 + w4)); - - // LOAD TEXTURE SAMPLES: - // Load all 16 samples using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - const vec3 sample1a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample1d_texel_offset).rgb; - const vec3 sample2a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample2d_texel_offset).rgb; - const vec3 sample3a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample3d_texel_offset).rgb; - const vec3 sample4a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample4d_texel_offset).rgb; - const vec3 sample1b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample1d_texel_offset).rgb; - const vec3 sample2b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample2d_texel_offset).rgb; - const vec3 sample3b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample3d_texel_offset).rgb; - const vec3 sample4b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample4d_texel_offset).rgb; - const vec3 sample1c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample1d_texel_offset).rgb; - const vec3 sample2c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample2d_texel_offset).rgb; - const vec3 sample3c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample3d_texel_offset).rgb; - const vec3 sample4c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample4d_texel_offset).rgb; - const vec3 sample1d = tex2D_linearize(texture, tex_uv + dxdy * sample1d_texel_offset).rgb; - const vec3 sample2d = tex2D_linearize(texture, tex_uv + dxdy * sample2d_texel_offset).rgb; - const vec3 sample3d = tex2D_linearize(texture, tex_uv + dxdy * sample3d_texel_offset).rgb; - const vec3 sample4d = tex2D_linearize(texture, tex_uv + dxdy * sample4d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Statically normalize weights (so total = 1.0), and sum weighted samples. - vec3 sum = vec3(0.0); - sum += w1 * (sample1a + sample1b + sample1c + sample1d); - sum += w2_3 * (sample2a + sample2b + sample2c + sample2d); - sum += w2_3 * (sample3a + sample3b + sample3c + sample3d); - sum += w4 * (sample4a + sample4b + sample4c + sample4d); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur5x5(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 5x5 blur with 3x3 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 5x5 Gaussian blurred mipmapped texture lookup composed of - // 3x3 carefully selected bilinear samples. - // Description: - // First see the description for tex2Dblur9x9(). This blur uses the same - // concept and sample/texel locations except on a smaller scale. Samples: - // 2a 1U 2b - // 1L 0C 1R - // 2c 1D 2d - // Texels: - // 2a4 2a3 1U2 2b3 2b4 - // 2a2 2a1 1U1 2b1 2b2 - // 1L2 1L1 0C1 1R1 1R2 - // 2c2 2c1 1D1 2d1 2d2 - // 2c4 2c3 1D2 2d3 2d4 - - // COMPUTE TEXTURE COORDS: - // Statically compute bilinear sampling offsets (details in tex2Dblur9x9). - const float denom_inv = 0.5/(sigma*sigma); - const float w1off = exp(-1.0 * denom_inv); - const float w2off = exp(-4.0 * denom_inv); - const float texel1to2ratio = w2off/(w1off + w2off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including x-axis-aligned: - const vec2 sample1R_texel_offset = vec2(1.0, 0.0) + vec2(texel1to2ratio, 0.0); - const vec2 sample2d_texel_offset = vec2(1.0, 1.0) + vec2(texel1to2ratio, texel1to2ratio); - - // CALCULATE KERNEL WEIGHTS FOR ALL SAMPLES: - // Statically compute Gaussian texel weights for the bottom-right quadrant. - // Read underscores as "and." - const float w1R1 = w1off; - const float w1R2 = w2off; - const float w2d1 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float w2d2_3 = exp(-LENGTH_SQ(vec2(2.0, 1.0)) * denom_inv); - const float w2d4 = exp(-LENGTH_SQ(vec2(2.0, 2.0)) * denom_inv); - // Statically add texel weights in each sample to get sample weights: - const float w0 = 1.0; - const float w1 = w1R1 + w1R2; - const float w2 = w2d1 + 2.0 * w2d2_3 + w2d4; - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = 1.0/(w0 + 4.0 * (w1 + w2)); - - // LOAD TEXTURE SAMPLES: - // Load all 9 samples (1 nearest, 4 linear, 4 bilinear) using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - const vec3 sample0C = tex2D_linearize(texture, tex_uv).rgb; - const vec3 sample1R = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset).rgb; - const vec3 sample1D = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample1L = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset).rgb; - const vec3 sample1U = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample2d = tex2D_linearize(texture, tex_uv + dxdy * sample2d_texel_offset).rgb; - const vec3 sample2c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample2d_texel_offset).rgb; - const vec3 sample2b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample2d_texel_offset).rgb; - const vec3 sample2a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample2d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Statically normalize weights (so total = 1.0), and sum weighted samples. - vec3 sum = w0 * sample0C; - sum += w1 * (sample1R + sample1D + sample1L + sample1U); - sum += w2 * (sample2a + sample2b + sample2c + sample2d); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur3x3(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 3x3 blur with 5x5 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 3x3 Gaussian blurred mipmapped texture lookup composed of - // 2x2 carefully selected bilinear samples. - // Description: - // First see the descriptions for tex2Dblur9x9() and tex2Dblur7(). This - // blur mixes concepts from both. The sample layout is as follows: - // 0a 0b - // 0c 0d - // The texel layout is as follows. Note that samples 0a/0b and 0c/0d share - // a vertical column of texels, and samples 0a/0c and 0b/0d share a - // horizontal row of texels (all samples share the center texel): - // 0a3 0ab2 0b3 - // 0ac1 0*0 0bd1 - // 0c3 0cd2 0d3 - - // COMPUTE TEXTURE COORDS: - // Statically compute bilinear sampling offsets (details in tex2Dblur9x9). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w1off = exp(-1.0 * denom_inv); - const float texel0to1ratio = w1off/(w0off * 0.5 + w1off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including axis-aligned: - const vec2 sample0d_texel_offset = vec2(texel0to1ratio, texel0to1ratio); - - // LOAD TEXTURE SAMPLES: - // Load all 4 samples using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - const vec3 sample0a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample0d_texel_offset).rgb; - const vec3 sample0b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample0d_texel_offset).rgb; - const vec3 sample0c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample0d_texel_offset).rgb; - const vec3 sample0d = tex2D_linearize(texture, tex_uv + dxdy * sample0d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Weights for all samples are the same, so just average them: - return 0.25 * (sample0a + sample0b + sample0c + sample0d); -} - - -////////////////// LINEAR ONE-PASS BLURS WITH SHARED SAMPLES ///////////////// - -vec3 tex2Dblur12x12shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: 1.) Same as tex2Dblur9() - // 2.) ddx() and ddy() are present in the current Cg profile. - // 3.) The GPU driver is using fine/high-quality derivatives. - // 4.) quad_vector *correctly* describes the current fragment's - // location in its pixel quad, by the conventions noted in - // get_quad_vector[_naive]. - // 5.) tex_uv.w = log2(IN.video_size/IN.output_size).y - // 6.) tex2Dlod() is present in the current Cg profile. - // Optional: Tune artifacts vs. excessive blurriness with the global - // float error_blurring. - // Returns: A blurred texture lookup using a "virtual" 12x12 Gaussian - // blur (a 6x6 blur of carefully selected bilinear samples) - // of the given mip level. There will be subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // Perform a 1-pass blur with shared texture lookups across a pixel quad. - // We'll get neighboring samples with high-quality ddx/ddy derivatives, as - // in GPU Pro 2, Chapter VI.2, "Shader Amortization using Pixel Quad - // Message Passing" by Eric Penner. - // - // Our "virtual" 12x12 blur will be comprised of ((6 - 1)^2)/4 + 3 = 12 - // bilinear samples, where bilinear sampling positions are computed from - // the relative Gaussian weights of the 4 surrounding texels. The catch is - // that the appropriate texel weights and sample coords differ for each - // fragment, but we're reusing most of the same samples across a quad of - // destination fragments. (We do use unique coords for the four nearest - // samples at each fragment.) Mixing bilinear filtering and sample-sharing - // therefore introduces some error into the weights, and this can get nasty - // when the source image is small or high-frequency. Computing bilinear - // ratios based on weights at the sample field center results in sharpening - // and ringing artifacts, but we can move samples closer to halfway between - // texels to try blurring away the error (which can move features around by - // a texel or so). Tune this with the global float "error_blurring". - // - // The pixel quad's sample field covers 12x12 texels, accessed through 6x6 - // bilinear (2x2 texel) taps. Each fragment depends on a window of 10x10 - // texels (5x5 bilinear taps), and each fragment is responsible for loading - // a 6x6 texel quadrant as a 3x3 block of bilinear taps, plus 3 more taps - // to use unique bilinear coords for sample0* for each fragment. This - // diagram illustrates the relative locations of bilinear samples 1-9 for - // each quadrant a, b, c, d (note samples will not be equally spaced): - // 8a 7a 6a 6b 7b 8b - // 5a 4a 3a 3b 4b 5b - // 2a 1a 0a 0b 1b 2b - // 2c 1c 0c 0d 1d 2d - // 5c 4c 3c 3d 4d 5d - // 8c 7c 6c 6d 7d 8d - // The following diagram illustrates the underlying equally spaced texels, - // named after the sample that accesses them and subnamed by their location - // within their 2x2 texel block: - // 8a3 8a2 7a3 7a2 6a3 6a2 6b2 6b3 7b2 7b3 8b2 8b3 - // 8a1 8a0 7a1 7a0 6a1 6a0 6b0 6b1 7b0 7b1 8b0 8b1 - // 5a3 5a2 4a3 4a2 3a3 3a2 3b2 3b3 4b2 4b3 5b2 5b3 - // 5a1 5a0 4a1 4a0 3a1 3a0 3b0 3b1 4b0 4b1 5b0 5b1 - // 2a3 2a2 1a3 1a2 0a3 0a2 0b2 0b3 1b2 1b3 2b2 2b3 - // 2a1 2a0 1a1 1a0 0a1 0a0 0b0 0b1 1b0 1b1 2b0 2b1 - // 2c1 2c0 1c1 1c0 0c1 0c0 0d0 0d1 1d0 1d1 2d0 2d1 - // 2c3 2c2 1c3 1c2 0c3 0c2 0d2 0d3 1d2 1d3 2d2 2d3 - // 5c1 5c0 4c1 4c0 3c1 3c0 3d0 3d1 4d0 4d1 5d0 5d1 - // 5c3 5c2 4c3 4c2 3c3 3c2 3d2 3d3 4d2 4d3 5d2 5d3 - // 8c1 8c0 7c1 7c0 6c1 6c0 6d0 6d1 7d0 7d1 8d0 8d1 - // 8c3 8c2 7c3 7c2 6c3 6c2 6d2 6d3 7d2 7d3 8d2 8d3 - // With this symmetric arrangement, we don't have to know which absolute - // quadrant a sample lies in to assign kernel weights; it's enough to know - // the sample number and the relative quadrant of the sample (relative to - // the current quadrant): - // {current, adjacent x, adjacent y, diagonal} - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute sampling offsets within each 2x2 texel block, based - // on appropriate 1D Gaussian sampling ratio between texels [0, 1], [2, 3], - // and [4, 5] away from the fragment, and reuse them independently for both - // dimensions. Use the sample field center as the estimated destination, - // but nudge the result closer to halfway between texels to blur error. - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float w4_5off = exp(-(4.5*4.5) * denom_inv); - const float w5_5off = exp(-(5.5*5.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - const float texel4to5ratio = mix(w5_5off/(w4_5off + w5_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(4.0, 0.0) + vec2(texel4to5ratio, texel0to1ratio); - const vec2 sample3_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample4_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - const vec2 sample5_texel_offset = vec2(4.0, 2.0) + vec2(texel4to5ratio, texel2to3ratio); - const vec2 sample6_texel_offset = vec2(0.0, 4.0) + vec2(texel0to1ratio, texel4to5ratio); - const vec2 sample7_texel_offset = vec2(2.0, 4.0) + vec2(texel2to3ratio, texel4to5ratio); - const vec2 sample8_texel_offset = vec2(4.0, 4.0) + vec2(texel4to5ratio, texel4to5ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // based on the sum of their 4 underlying texel weights. Assume a same- - // resolution blur, so each symmetrically named sample weight will compute - // the same at every fragment in the pixel quad: We can therefore compute - // texel weights based only on the bottom-right quadrant (fragment at 0d0). - // Too avoid too much boilerplate code, use a macro to get all 4 texel - // weights for a bilinear sample based on the offset of its top-left texel: - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - const float w8diag = GET_TEXEL_QUAD_WEIGHTS(-6.0, -6.0); - const float w7diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -6.0); - const float w6diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -6.0); - const float w6adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -6.0); - const float w7adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -6.0); - const float w8adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -6.0); - const float w5diag = GET_TEXEL_QUAD_WEIGHTS(-6.0, -4.0); - const float w4diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -4.0); - const float w3diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -4.0); - const float w3adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -4.0); - const float w4adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -4.0); - const float w5adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -4.0); - const float w2diag = GET_TEXEL_QUAD_WEIGHTS(-6.0, -2.0); - const float w1diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -2.0); - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w2adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -2.0); - const float w2adjx = GET_TEXEL_QUAD_WEIGHTS(-6.0, 0.0); - const float w1adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 0.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 0.0); - const float w5adjx = GET_TEXEL_QUAD_WEIGHTS(-6.0, 2.0); - const float w4adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 2.0); - const float w3adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w4curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - const float w5curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 2.0); - const float w8adjx = GET_TEXEL_QUAD_WEIGHTS(-6.0, 4.0); - const float w7adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 4.0); - const float w6adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 4.0); - const float w6curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 4.0); - const float w7curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 4.0); - const float w8curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 4.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Statically pack weights for runtime: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - const vec4 w1 = vec4(w1curr, w1adjx, w1adjy, w1diag); - const vec4 w2 = vec4(w2curr, w2adjx, w2adjy, w2diag); - const vec4 w3 = vec4(w3curr, w3adjx, w3adjy, w3diag); - const vec4 w4 = vec4(w4curr, w4adjx, w4adjy, w4diag); - const vec4 w5 = vec4(w5curr, w5adjx, w5adjy, w5diag); - const vec4 w6 = vec4(w6curr, w6adjx, w6adjy, w6diag); - const vec4 w7 = vec4(w7curr, w7adjx, w7adjy, w7diag); - const vec4 w8 = vec4(w8curr, w8adjx, w8adjy, w8diag); - // Get the weight sum inverse (normalization factor): - const vec4 weight_sum4 = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8; - const vec2 weight_sum2 = weight_sum4.xy + weight_sum4.zw; - const float weight_sum = weight_sum2.x + weight_sum2.y; - const float weight_sum_inv = 1.0/(weight_sum); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - const vec3 sample4curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample4_texel_offset)).rgb; - const vec3 sample5curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample5_texel_offset)).rgb; - const vec3 sample6curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample6_texel_offset)).rgb; - const vec3 sample7curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample7_texel_offset)).rgb; - const vec3 sample8curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample8_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - vec3 sample3adjx, sample3adjy, sample3diag; - vec3 sample4adjx, sample4adjy, sample4diag; - vec3 sample5adjx, sample5adjy, sample5diag; - vec3 sample6adjx, sample6adjy, sample6diag; - vec3 sample7adjx, sample7adjy, sample7diag; - vec3 sample8adjx, sample8adjy, sample8diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - quad_gather(quad_vector, sample3curr, sample3adjx, sample3adjy, sample3diag); - quad_gather(quad_vector, sample4curr, sample4adjx, sample4adjy, sample4diag); - quad_gather(quad_vector, sample5curr, sample5adjx, sample5adjy, sample5diag); - quad_gather(quad_vector, sample6curr, sample6adjx, sample6adjy, sample6diag); - quad_gather(quad_vector, sample7curr, sample7adjx, sample7adjy, sample7diag); - quad_gather(quad_vector, sample8curr, sample8adjx, sample8adjy, sample8diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += (mat4x3(sample1curr, sample1adjx, sample1adjy, sample1diag) * w1); - sum += (mat4x3(sample2curr, sample2adjx, sample2adjy, sample2diag) * w2); - sum += (mat4x3(sample3curr, sample3adjx, sample3adjy, sample3diag) * w3); - sum += (mat4x3(sample4curr, sample4adjx, sample4adjy, sample4diag) * w4); - sum += (mat4x3(sample5curr, sample5adjx, sample5adjy, sample5diag) * w5); - sum += (mat4x3(sample6curr, sample6adjx, sample6adjy, sample6diag) * w6); - sum += (mat4x3(sample7curr, sample7adjx, sample7adjy, sample7diag) * w7); - sum += (mat4x3(sample8curr, sample8adjx, sample8adjy, sample8diag) * w8); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur10x10shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: Same as tex2Dblur12x12shared() - // Returns: A blurred texture lookup using a "virtual" 10x10 Gaussian - // blur (a 5x5 blur of carefully selected bilinear samples) - // of the given mip level. There will be subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // First see the description for tex2Dblur12x12shared(). This - // function shares the same concept and sample placement, but each fragment - // only uses 25 of the 36 samples taken across the pixel quad (to cover a - // 5x5 sample area, or 10x10 texel area), and it uses a lower standard - // deviation to compensate. Thanks to symmetry, the 11 omitted samples - // are always the "same:" - // 8adjx, 2adjx, 5adjx, - // 6adjy, 7adjy, 8adjy, - // 2diag, 5diag, 6diag, 7diag, 8diag - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute bilinear sampling offsets (details in tex2Dblur12x12shared). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float w4_5off = exp(-(4.5*4.5) * denom_inv); - const float w5_5off = exp(-(5.5*5.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - const float texel4to5ratio = mix(w5_5off/(w4_5off + w5_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(4.0, 0.0) + vec2(texel4to5ratio, texel0to1ratio); - const vec2 sample3_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample4_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - const vec2 sample5_texel_offset = vec2(4.0, 2.0) + vec2(texel4to5ratio, texel2to3ratio); - const vec2 sample6_texel_offset = vec2(0.0, 4.0) + vec2(texel0to1ratio, texel4to5ratio); - const vec2 sample7_texel_offset = vec2(2.0, 4.0) + vec2(texel2to3ratio, texel4to5ratio); - const vec2 sample8_texel_offset = vec2(4.0, 4.0) + vec2(texel4to5ratio, texel4to5ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // from the sum of their 4 texel weights (details in tex2Dblur12x12shared). - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - // We only need 25 of the 36 sample weights. Skip the following weights: - // 8adjx, 2adjx, 5adjx, - // 6adjy, 7adjy, 8adjy, - // 2diag, 5diag, 6diag, 7diag, 8diag - const float w4diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -4.0); - const float w3diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -4.0); - const float w3adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -4.0); - const float w4adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -4.0); - const float w5adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -4.0); - const float w1diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -2.0); - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w2adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -2.0); - const float w1adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 0.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 0.0); - const float w4adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 2.0); - const float w3adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w4curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - const float w5curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 2.0); - const float w7adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 4.0); - const float w6adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 4.0); - const float w6curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 4.0); - const float w7curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 4.0); - const float w8curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 4.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = 1.0/(w0curr + w1curr + w2curr + w3curr + - w4curr + w5curr + w6curr + w7curr + w8curr + - w0adjx + w1adjx + w3adjx + w4adjx + w6adjx + w7adjx + - w0adjy + w1adjy + w2adjy + w3adjy + w4adjy + w5adjy + - w0diag + w1diag + w3diag + w4diag); - // Statically pack most weights for runtime. Note the mixed packing: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - const vec4 w1 = vec4(w1curr, w1adjx, w1adjy, w1diag); - const vec4 w3 = vec4(w3curr, w3adjx, w3adjy, w3diag); - const vec4 w4 = vec4(w4curr, w4adjx, w4adjy, w4diag); - const vec4 w2and5 = vec4(w2curr, w2adjy, w5curr, w5adjy); - const vec4 w6and7 = vec4(w6curr, w6adjx, w7curr, w7adjx); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - const vec3 sample4curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample4_texel_offset)).rgb; - const vec3 sample5curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample5_texel_offset)).rgb; - const vec3 sample6curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample6_texel_offset)).rgb; - const vec3 sample7curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample7_texel_offset)).rgb; - const vec3 sample8curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample8_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad in order of need: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - vec3 sample3adjx, sample3adjy, sample3diag; - vec3 sample4adjx, sample4adjy, sample4diag; - vec3 sample5adjx, sample5adjy, sample5diag; - vec3 sample6adjx, sample6adjy, sample6diag; - vec3 sample7adjx, sample7adjy, sample7diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - quad_gather(quad_vector, sample3curr, sample3adjx, sample3adjy, sample3diag); - quad_gather(quad_vector, sample4curr, sample4adjx, sample4adjy, sample4diag); - quad_gather(quad_vector, sample5curr, sample5adjx, sample5adjy, sample5diag); - quad_gather(quad_vector, sample6curr, sample6adjx, sample6adjy, sample6diag); - quad_gather(quad_vector, sample7curr, sample7adjx, sample7adjy, sample7diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result. First do the simple ones: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += (mat4x3(sample1curr, sample1adjx, sample1adjy, sample1diag) * w1); - sum += (mat4x3(sample3curr, sample3adjx, sample3adjy, sample3diag) * w2); - sum += (mat4x3(sample4curr, sample4adjx, sample4adjy, sample4diag) * w3); - // Now do the mixed-sample ones: - sum += (mat4x3(sample2curr, sample2adjy, sample5curr, sample5adjy) * w2and5); - sum += (mat4x3(sample6curr, sample6adjx, sample7curr, sample7adjx) * w6and7); - sum += w8curr * sample8curr; - // Normalize the sum (so the weights add to 1.0) and return: - return sum * weight_sum_inv; -} - -vec3 tex2Dblur8x8shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: Same as tex2Dblur12x12shared() - // Returns: A blurred texture lookup using a "virtual" 8x8 Gaussian - // blur (a 4x4 blur of carefully selected bilinear samples) - // of the given mip level. There will be subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // First see the description for tex2Dblur12x12shared(). This function - // shares the same concept and a similar sample placement, except each - // quadrant contains 4x4 texels and 2x2 samples instead of 6x6 and 3x3 - // respectively. There could be a total of 16 samples, 4 of which each - // fragment is responsible for, but each fragment loads 0a/0b/0c/0d with - // its own offset to reduce shared sample artifacts, bringing the sample - // count for each fragment to 7. Sample placement: - // 3a 2a 2b 3b - // 1a 0a 0b 1b - // 1c 0c 0d 1d - // 3c 2c 2d 3d - // Texel placement: - // 3a3 3a2 2a3 2a2 2b2 2b3 3b2 3b3 - // 3a1 3a0 2a1 2a0 2b0 2b1 3b0 3b1 - // 1a3 1a2 0a3 0a2 0b2 0b3 1b2 1b3 - // 1a1 1a0 0a1 0a0 0b0 0b1 1b0 1b1 - // 1c1 1c0 0c1 0c0 0d0 0d1 1d0 1d1 - // 1c3 1c2 0c3 0c2 0d2 0d3 1d2 1d3 - // 3c1 3c0 2c1 2c0 2d0 2d1 3d0 4d1 - // 3c3 3c2 2c3 2c2 2d2 2d3 3d2 4d3 - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute bilinear sampling offsets (details in tex2Dblur12x12shared). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample3_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // from the sum of their 4 texel weights (details in tex2Dblur12x12shared). - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - const float w3diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -4.0); - const float w2diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -4.0); - const float w2adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -4.0); - const float w3adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -4.0); - const float w1diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -2.0); - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w1adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 0.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w3adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 2.0); - const float w2adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Statically pack weights for runtime: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - const vec4 w1 = vec4(w1curr, w1adjx, w1adjy, w1diag); - const vec4 w2 = vec4(w2curr, w2adjx, w2adjy, w2diag); - const vec4 w3 = vec4(w3curr, w3adjx, w3adjy, w3diag); - // Get the weight sum inverse (normalization factor): - const vec4 weight_sum4 = w0 + w1 + w2 + w3; - const vec2 weight_sum2 = weight_sum4.xy + weight_sum4.zw; - const float weight_sum = weight_sum2.x + weight_sum2.y; - const float weight_sum_inv = 1.0/(weight_sum); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - vec3 sample3adjx, sample3adjy, sample3diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - quad_gather(quad_vector, sample3curr, sample3adjx, sample3adjy, sample3diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += (mat4x3(sample1curr, sample1adjx, sample1adjy, sample1diag) * w1); - sum += (mat4x3(sample2curr, sample2adjx, sample2adjy, sample2diag) * w2); - sum += (mat4x3(sample3curr, sample3adjx, sample3adjy, sample3diag) * w3); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur6x6shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: Same as tex2Dblur12x12shared() - // Returns: A blurred texture lookup using a "virtual" 6x6 Gaussian - // blur (a 3x3 blur of carefully selected bilinear samples) - // of the given mip level. There will be some inaccuracies,subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // First see the description for tex2Dblur8x8shared(). This - // function shares the same concept and sample placement, but each fragment - // only uses 9 of the 16 samples taken across the pixel quad (to cover a - // 3x3 sample area, or 6x6 texel area), and it uses a lower standard - // deviation to compensate. Thanks to symmetry, the 7 omitted samples - // are always the "same:" - // 1adjx, 3adjx - // 2adjy, 3adjy - // 1diag, 2diag, 3diag - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute bilinear sampling offsets (details in tex2Dblur12x12shared). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample3_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // from the sum of their 4 texel weights (details in tex2Dblur12x12shared). - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - // We only need 9 of the 16 sample weights. Skip the following weights: - // 1adjx, 3adjx - // 2adjy, 3adjy - // 1diag, 2diag, 3diag - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w2adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = 1.0/(w0curr + w1curr + w2curr + w3curr + - w0adjx + w2adjx + w0adjy + w1adjy + w0diag); - // Statically pack some weights for runtime: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result for sample1*, and handle the rest - // of the weights more directly/verbosely: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += w1curr * sample1curr + w1adjy * sample1adjy + w2curr * sample2curr + - w2adjx * sample2adjx + w3curr * sample3curr; - return sum * weight_sum_inv; -} - - -/////////////////////// MAX OPTIMAL SIGMA BLUR WRAPPERS ////////////////////// - -// The following blurs are static wrappers around the dynamic blurs above. -// HOPEFULLY, the compiler will be smart enough to do constant-folding. - -// Resizable separable blurs: -vec3 tex2Dblur11resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur11resize(texture, tex_uv, dxdy, blur11_std_dev); -} -vec3 tex2Dblur9resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9resize(texture, tex_uv, dxdy, blur9_std_dev); -} -vec3 tex2Dblur7resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur7resize(texture, tex_uv, dxdy, blur7_std_dev); -} -vec3 tex2Dblur5resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur5resize(texture, tex_uv, dxdy, blur5_std_dev); -} -vec3 tex2Dblur3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3resize(texture, tex_uv, dxdy, blur3_std_dev); -} -// Fast separable blurs: -vec3 tex2Dblur11fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur11fast(texture, tex_uv, dxdy, blur11_std_dev); -} -vec3 tex2Dblur9fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9fast(texture, tex_uv, dxdy, blur9_std_dev); -} -vec3 tex2Dblur7fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur7fast(texture, tex_uv, dxdy, blur7_std_dev); -} -vec3 tex2Dblur5fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur5fast(texture, tex_uv, dxdy, blur5_std_dev); -} -vec3 tex2Dblur3fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3fast(texture, tex_uv, dxdy, blur3_std_dev); -} -// Huge, "fast" separable blurs: -vec3 tex2Dblur43fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur43fast(texture, tex_uv, dxdy, blur43_std_dev); -} -vec3 tex2Dblur31fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur31fast(texture, tex_uv, dxdy, blur31_std_dev); -} -vec3 tex2Dblur25fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur25fast(texture, tex_uv, dxdy, blur25_std_dev); -} -vec3 tex2Dblur17fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur17fast(texture, tex_uv, dxdy, blur17_std_dev); -} -// Resizable one-pass blurs: -vec3 tex2Dblur3x3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3x3resize(texture, tex_uv, dxdy, blur3_std_dev); -} -// "Fast" one-pass blurs: -vec3 tex2Dblur9x9(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9x9(texture, tex_uv, dxdy, blur9_std_dev); -} -vec3 tex2Dblur7x7(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur7x7(texture, tex_uv, dxdy, blur7_std_dev); -} -vec3 tex2Dblur5x5(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur5x5(texture, tex_uv, dxdy, blur5_std_dev); -} -vec3 tex2Dblur3x3(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3x3(texture, tex_uv, dxdy, blur3_std_dev); -} -// "Fast" shared-sample one-pass blurs: -vec3 tex2Dblur12x12shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur12x12shared(texture, tex_uv, dxdy, quad_vector, blur12_std_dev); -} -vec3 tex2Dblur10x10shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur10x10shared(texture, tex_uv, dxdy, quad_vector, blur10_std_dev); -} -vec3 tex2Dblur8x8shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur8x8shared(texture, tex_uv, dxdy, quad_vector, blur8_std_dev); -} -vec3 tex2Dblur6x6shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur6x6shared(texture, tex_uv, dxdy, quad_vector, blur6_std_dev); -} - - -#endif // BLUR_FUNCTIONS_H - diff --git a/crt/shaders/crt-royale/src/blur-functions.h b/crt/shaders/crt-royale/src/blur-functions.h deleted file mode 100644 index 930b6e1..0000000 --- a/crt/shaders/crt-royale/src/blur-functions.h +++ /dev/null @@ -1,595 +0,0 @@ -#ifndef BLUR_FUNCTIONS_H -#define BLUR_FUNCTIONS_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file provides reusable one-pass and separable (two-pass) blurs. -// Requires: All blurs share these requirements (dxdy requirement is split): -// 1.) All requirements of gamma-management.h must be satisfied! -// 2.) filter_linearN must == "true" in your .cgp preset unless -// you're using tex2DblurNresize at 1x scale. -// 3.) mipmap_inputN must == "true" in your .cgp preset if -// IN.output_size < IN.video_size. -// 4.) IN.output_size == IN.video_size / pow(2, M), where M is some -// positive integer. tex2Dblur*resize can resize arbitrarily -// (and the blur will be done after resizing), but arbitrary -// resizes "fail" with other blurs due to the way they mix -// static weights with bilinear sample exploitation. -// 5.) In general, dxdy should contain the uv pixel spacing: -// dxdy = (IN.video_size/IN.output_size)/IN.texture_size -// 6.) For separable blurs (tex2DblurNresize and tex2DblurNfast), -// zero out the dxdy component in the unblurred dimension: -// dxdy = vec2(dxdy.x, 0.0) or vec2(0.0, dxdy.y) -// Many blurs share these requirements: -// 1.) One-pass blurs require scale_xN == scale_yN or scales > 1.0, -// or they will blur more in the lower-scaled dimension. -// 2.) One-pass shared sample blurs require ddx(), ddy(), and -// tex2Dlod() to be supported by the current Cg profile, and -// the drivers must support high-quality derivatives. -// 3.) One-pass shared sample blurs require: -// tex_uv.w == log2(IN.video_size/IN.output_size).y; -// Non-wrapper blurs share this requirement: -// 1.) sigma is the intended standard deviation of the blur -// Wrapper blurs share this requirement, which is automatically -// met (unless OVERRIDE_BLUR_STD_DEVS is #defined; see below): -// 1.) blurN_std_dev must be global static const float values -// specifying standard deviations for Nx blurs in units -// of destination pixels -// Optional: 1.) The including file (or an earlier included file) may -// optionally #define USE_BINOMIAL_BLUR_STD_DEVS to replace -// default standard deviations with those matching a binomial -// distribution. (See below for details/properties.) -// 2.) The including file (or an earlier included file) may -// optionally #define OVERRIDE_BLUR_STD_DEVS and override: -// static const float blur3_std_dev -// static const float blur4_std_dev -// static const float blur5_std_dev -// static const float blur6_std_dev -// static const float blur7_std_dev -// static const float blur8_std_dev -// static const float blur9_std_dev -// static const float blur10_std_dev -// static const float blur11_std_dev -// static const float blur12_std_dev -// static const float blur17_std_dev -// static const float blur25_std_dev -// static const float blur31_std_dev -// static const float blur43_std_dev -// 3.) The including file (or an earlier included file) may -// optionally #define OVERRIDE_ERROR_BLURRING and override: -// static const float error_blurring -// This tuning value helps mitigate weighting errors from one- -// pass shared-sample blurs sharing bilinear samples between -// fragments. Values closer to 0.0 have "correct" blurriness -// but allow more artifacts, and values closer to 1.0 blur away -// artifacts by sampling closer to halfway between texels. -// UPDATE 6/21/14: The above static constants may now be overridden -// by non-static uniform constants. This permits exposing blur -// standard deviations as runtime GUI shader parameters. However, -// using them keeps weights from being statically computed, and the -// speed hit depends on the blur: On my machine, uniforms kill over -// 53% of the framerate with tex2Dblur12x12shared, but they only -// drop the framerate by about 18% with tex2Dblur11fast. -// Quality and Performance Comparisons: -// For the purposes of the following discussion, "no sRGB" means -// GAMMA_ENCODE_EVERY_FBO is #defined, and "sRGB" means it isn't. -// 1.) tex2DblurNfast is always faster than tex2DblurNresize. -// 2.) tex2DblurNresize functions are the only ones that can arbitrarily resize -// well, because they're the only ones that don't exploit bilinear samples. -// This also means they're the only functions which can be truly gamma- -// correct without linear (or sRGB FBO) input, but only at 1x scale. -// 3.) One-pass shared sample blurs only have a speed advantage without sRGB. -// They also have some inaccuracies due to their shared-[bilinear-]sample -// design, which grow increasingly bothersome for smaller blurs and higher- -// frequency source images (relative to their resolution). I had high -// hopes for them, but their most realistic use case is limited to quickly -// reblurring an already blurred input at full resolution. Otherwise: -// a.) If you're blurring a low-resolution source, you want a better blur. -// b.) If you're blurring a lower mipmap, you want a better blur. -// c.) If you're blurring a high-resolution, high-frequency source, you -// want a better blur. -// 4.) The one-pass blurs without shared samples grow slower for larger blurs, -// but they're competitive with separable blurs at 5x5 and smaller, and -// even tex2Dblur7x7 isn't bad if you're wanting to conserve passes. -// Here are some framerates from a GeForce 8800GTS. The first pass resizes to -// viewport size (4x in this test) and linearizes for sRGB codepaths, and the -// remaining passes perform 6 full blurs. Mipmapped tests are performed at the -// same scale, so they just measure the cost of mipmapping each FBO (only every -// other FBO is mipmapped for separable blurs, to mimic realistic usage). -// Mipmap Neither sRGB+Mipmap sRGB Function -// 76.0 92.3 131.3 193.7 tex2Dblur3fast -// 63.2 74.4 122.4 175.5 tex2Dblur3resize -// 93.7 121.2 159.3 263.2 tex2Dblur3x3 -// 59.7 68.7 115.4 162.1 tex2Dblur3x3resize -// 63.2 74.4 122.4 175.5 tex2Dblur5fast -// 49.3 54.8 100.0 132.7 tex2Dblur5resize -// 59.7 68.7 115.4 162.1 tex2Dblur5x5 -// 64.9 77.2 99.1 137.2 tex2Dblur6x6shared -// 55.8 63.7 110.4 151.8 tex2Dblur7fast -// 39.8 43.9 83.9 105.8 tex2Dblur7resize -// 40.0 44.2 83.2 104.9 tex2Dblur7x7 -// 56.4 65.5 71.9 87.9 tex2Dblur8x8shared -// 49.3 55.1 99.9 132.5 tex2Dblur9fast -// 33.3 36.2 72.4 88.0 tex2Dblur9resize -// 27.8 29.7 61.3 72.2 tex2Dblur9x9 -// 37.2 41.1 52.6 60.2 tex2Dblur10x10shared -// 44.4 49.5 91.3 117.8 tex2Dblur11fast -// 28.8 30.8 63.6 75.4 tex2Dblur11resize -// 33.6 36.5 40.9 45.5 tex2Dblur12x12shared -// TODO: Fill in benchmarks for new untested blurs. -// tex2Dblur17fast -// tex2Dblur25fast -// tex2Dblur31fast -// tex2Dblur43fast -// tex2Dblur3x3resize - -///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// - -// Set static standard deviations, but allow users to override them with their -// own constants (even non-static uniforms if they're okay with the speed hit): -#ifndef OVERRIDE_BLUR_STD_DEVS - // blurN_std_dev values are specified in terms of dxdy strides. - #ifdef USE_BINOMIAL_BLUR_STD_DEVS - // By request, we can define standard deviations corresponding to a - // binomial distribution with p = 0.5 (related to Pascal's triangle). - // This distribution works such that blurring multiple times should - // have the same result as a single larger blur. These values are - // larger than default for blurs up to 6x and smaller thereafter. - const float blur3_std_dev = 0.84931640625; - const float blur4_std_dev = 0.84931640625; - const float blur5_std_dev = 1.0595703125; - const float blur6_std_dev = 1.06591796875; - const float blur7_std_dev = 1.17041015625; - const float blur8_std_dev = 1.1720703125; - const float blur9_std_dev = 1.2259765625; - const float blur10_std_dev = 1.21982421875; - const float blur11_std_dev = 1.25361328125; - const float blur12_std_dev = 1.2423828125; - const float blur17_std_dev = 1.27783203125; - const float blur25_std_dev = 1.2810546875; - const float blur31_std_dev = 1.28125; - const float blur43_std_dev = 1.28125; - #else - // The defaults are the largest values that keep the largest unused - // blur term on each side <= 1.0/256.0. (We could get away with more - // or be more conservative, but this compromise is pretty reasonable.) - const float blur3_std_dev = 0.62666015625; - const float blur4_std_dev = 0.66171875; - const float blur5_std_dev = 0.9845703125; - const float blur6_std_dev = 1.02626953125; - const float blur7_std_dev = 1.36103515625; - const float blur8_std_dev = 1.4080078125; - const float blur9_std_dev = 1.7533203125; - const float blur10_std_dev = 1.80478515625; - const float blur11_std_dev = 2.15986328125; - const float blur12_std_dev = 2.215234375; - const float blur17_std_dev = 3.45535583496; - const float blur25_std_dev = 5.3409576416; - const float blur31_std_dev = 6.86488037109; - const float blur43_std_dev = 10.1852050781; - #endif // USE_BINOMIAL_BLUR_STD_DEVS -#endif // OVERRIDE_BLUR_STD_DEVS - -#ifndef OVERRIDE_ERROR_BLURRING - // error_blurring should be in [0.0, 1.0]. Higher values reduce ringing - // in shared-sample blurs but increase blurring and feature shifting. - const float error_blurring = 0.5; -#endif - -// Make a length squared helper macro (for usage with static constants): -#define LENGTH_SQ(vec) (dot(vec, vec)) - -/////////////////////////////////// HELPERS ////////////////////////////////// - -vec4 uv2_to_uv4(vec2 tex_uv) -{ - // Make a vec2 uv offset safe for adding to vec4 tex2Dlod coords: - return vec4(tex_uv, 0.0, 0.0); -} - -// Make a length squared helper macro (for usage with static constants): -#define LENGTH_SQ(vec) (dot(vec, vec)) - -float get_fast_gaussian_weight_sum_inv(const float sigma) -{ - // We can use the Gaussian integral to calculate the asymptotic weight for - // the center pixel. Since the unnormalized center pixel weight is 1.0, - // the normalized weight is the same as the weight sum inverse. Given a - // large enough blur (9+), the asymptotic weight sum is close and faster: - // center_weight = 0.5 * - // (erf(0.5/(sigma*sqrt(2.0))) - erf(-0.5/(sigma*sqrt(2.0)))) - // erf(-x) == -erf(x), so we get 0.5 * (2.0 * erf(blah blah)): - // However, we can get even faster results with curve-fitting. These are - // also closer than the asymptotic results, because they were constructed - // from 64 blurs sizes from [3, 131) and 255 equally-spaced sigmas from - // (0, blurN_std_dev), so the results for smaller sigmas are biased toward - // smaller blurs. The max error is 0.0031793913. - // Relative FPS: 134.3 with erf, 135.8 with curve-fitting. - //static const float temp = 0.5/sqrt(2.0); - //return erf(temp/sigma); - return min(exp(exp(0.348348412457428/ - (sigma - 0.0860587260734721))), 0.399334576340352/sigma); -} - -vec3 tex2Dblur17fast(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 17x Gaussian blurred texture lookup using 1 nearest - // neighbor and 8 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( - // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w1_2 = w1 + w2; - const float w3_4 = w3 + w4; - const float w5_6 = w5 + w6; - const float w7_8 = w7 + w8; - const float w1_2_ratio = w2/w1_2; - const float w3_4_ratio = w4/w3_4; - const float w5_6_ratio = w6/w5_6; - const float w7_8_ratio = w8/w7_8; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w7_8 * tex2D_linearize(tex, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(tex, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(tex, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w1_2 * tex2D_linearize(tex, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(tex, tex_uv).rgb; - sum += w1_2 * tex2D_linearize(tex, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(tex, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(tex, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(tex, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur25fast(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 25x Gaussian blurred texture lookup using 1 nearest - // neighbor and 12 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( - // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + w12)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w1_2 = w1 + w2; - const float w3_4 = w3 + w4; - const float w5_6 = w5 + w6; - const float w7_8 = w7 + w8; - const float w9_10 = w9 + w10; - const float w11_12 = w11 + w12; - const float w1_2_ratio = w2/w1_2; - const float w3_4_ratio = w4/w3_4; - const float w5_6_ratio = w6/w5_6; - const float w7_8_ratio = w8/w7_8; - const float w9_10_ratio = w10/w9_10; - const float w11_12_ratio = w12/w11_12; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w11_12 * tex2D_linearize(tex, tex_uv - (11.0 + w11_12_ratio) * dxdy).rgb; - sum += w9_10 * tex2D_linearize(tex, tex_uv - (9.0 + w9_10_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(tex, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(tex, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(tex, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w1_2 * tex2D_linearize(tex, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(tex, tex_uv).rgb; - sum += w1_2 * tex2D_linearize(tex, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(tex, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(tex, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(tex, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w9_10 * tex2D_linearize(tex, tex_uv + (9.0 + w9_10_ratio) * dxdy).rgb; - sum += w11_12 * tex2D_linearize(tex, tex_uv + (11.0 + w11_12_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur31fast(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 31x Gaussian blurred texture lookup using 16 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - const float w13 = exp(-169.0 * denom_inv); - const float w14 = exp(-196.0 * denom_inv); - const float w15 = exp(-225.0 * denom_inv); - //const float weight_sum_inv = 1.0 / - // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + - // w9 + w10 + w11 + w12 + w13 + w14 + w15)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w0_1 = w0 * 0.5 + w1; - const float w2_3 = w2 + w3; - const float w4_5 = w4 + w5; - const float w6_7 = w6 + w7; - const float w8_9 = w8 + w9; - const float w10_11 = w10 + w11; - const float w12_13 = w12 + w13; - const float w14_15 = w14 + w15; - const float w0_1_ratio = w1/w0_1; - const float w2_3_ratio = w3/w2_3; - const float w4_5_ratio = w5/w4_5; - const float w6_7_ratio = w7/w6_7; - const float w8_9_ratio = w9/w8_9; - const float w10_11_ratio = w11/w10_11; - const float w12_13_ratio = w13/w12_13; - const float w14_15_ratio = w15/w14_15; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w14_15 * tex2D_linearize(tex, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(tex, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(tex, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(tex, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(tex, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(tex, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w2_3 * tex2D_linearize(tex, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w0_1 * tex2D_linearize(tex, tex_uv - w0_1_ratio * dxdy).rgb; - sum += w0_1 * tex2D_linearize(tex, tex_uv + w0_1_ratio * dxdy).rgb; - sum += w2_3 * tex2D_linearize(tex, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(tex, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(tex, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(tex, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(tex, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(tex, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(tex, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur43fast(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 43x Gaussian blurred texture lookup using 22 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - const float w13 = exp(-169.0 * denom_inv); - const float w14 = exp(-196.0 * denom_inv); - const float w15 = exp(-225.0 * denom_inv); - const float w16 = exp(-256.0 * denom_inv); - const float w17 = exp(-289.0 * denom_inv); - const float w18 = exp(-324.0 * denom_inv); - const float w19 = exp(-361.0 * denom_inv); - const float w20 = exp(-400.0 * denom_inv); - const float w21 = exp(-441.0 * denom_inv); - //const float weight_sum_inv = 1.0 / - // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + - // w12 + w13 + w14 + w15 + w16 + w17 + w18 + w19 + w20 + w21)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w0_1 = w0 * 0.5 + w1; - const float w2_3 = w2 + w3; - const float w4_5 = w4 + w5; - const float w6_7 = w6 + w7; - const float w8_9 = w8 + w9; - const float w10_11 = w10 + w11; - const float w12_13 = w12 + w13; - const float w14_15 = w14 + w15; - const float w16_17 = w16 + w17; - const float w18_19 = w18 + w19; - const float w20_21 = w20 + w21; - const float w0_1_ratio = w1/w0_1; - const float w2_3_ratio = w3/w2_3; - const float w4_5_ratio = w5/w4_5; - const float w6_7_ratio = w7/w6_7; - const float w8_9_ratio = w9/w8_9; - const float w10_11_ratio = w11/w10_11; - const float w12_13_ratio = w13/w12_13; - const float w14_15_ratio = w15/w14_15; - const float w16_17_ratio = w17/w16_17; - const float w18_19_ratio = w19/w18_19; - const float w20_21_ratio = w21/w20_21; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w20_21 * tex2D_linearize(tex, tex_uv - (20.0 + w20_21_ratio) * dxdy).rgb; - sum += w18_19 * tex2D_linearize(tex, tex_uv - (18.0 + w18_19_ratio) * dxdy).rgb; - sum += w16_17 * tex2D_linearize(tex, tex_uv - (16.0 + w16_17_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(tex, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(tex, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(tex, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(tex, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(tex, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(tex, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w2_3 * tex2D_linearize(tex, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w0_1 * tex2D_linearize(tex, tex_uv - w0_1_ratio * dxdy).rgb; - sum += w0_1 * tex2D_linearize(tex, tex_uv + w0_1_ratio * dxdy).rgb; - sum += w2_3 * tex2D_linearize(tex, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(tex, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(tex, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(tex, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(tex, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(tex, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(tex, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w16_17 * tex2D_linearize(tex, tex_uv + (16.0 + w16_17_ratio) * dxdy).rgb; - sum += w18_19 * tex2D_linearize(tex, tex_uv + (18.0 + w18_19_ratio) * dxdy).rgb; - sum += w20_21 * tex2D_linearize(tex, tex_uv + (20.0 + w20_21_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -//////////////////// ARBITRARILY RESIZABLE ONE-PASS BLURS //////////////////// - -vec3 tex2Dblur3x3resize(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 3x3 Gaussian blurred mipmapped texture lookup of the - // resized input. - // Description: - // This is the only arbitrarily resizable one-pass blur; tex2Dblur5x5resize - // would perform like tex2Dblur9x9, MUCH slower than tex2Dblur5resize. - const float denom_inv = 0.5/(sigma*sigma); - // Load each sample. We need all 3x3 samples. Quad-pixel communication - // won't help either: This should perform like tex2Dblur5x5, but sharing a - // 4x4 sample field would perform more like tex2Dblur8x8shared (worse). - const vec2 sample4_uv = tex_uv; - const vec2 dx = vec2(dxdy.x, 0.0); - const vec2 dy = vec2(0.0, dxdy.y); - const vec2 sample1_uv = sample4_uv - dy; - const vec2 sample7_uv = sample4_uv + dy; - const vec3 sample0 = tex2D_linearize(tex, sample1_uv - dx).rgb; - const vec3 sample1 = tex2D_linearize(tex, sample1_uv).rgb; - const vec3 sample2 = tex2D_linearize(tex, sample1_uv + dx).rgb; - const vec3 sample3 = tex2D_linearize(tex, sample4_uv - dx).rgb; - const vec3 sample4 = tex2D_linearize(tex, sample4_uv).rgb; - const vec3 sample5 = tex2D_linearize(tex, sample4_uv + dx).rgb; - const vec3 sample6 = tex2D_linearize(tex, sample7_uv - dx).rgb; - const vec3 sample7 = tex2D_linearize(tex, sample7_uv).rgb; - const vec3 sample8 = tex2D_linearize(tex, sample7_uv + dx).rgb; - // Statically compute Gaussian sample weights: - const float w4 = 1.0; - const float w1_3_5_7 = exp(-LENGTH_SQ(vec2(1.0, 0.0)) * denom_inv); - const float w0_2_6_8 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float weight_sum_inv = 1.0/(w4 + 4.0 * (w1_3_5_7 + w0_2_6_8)); - // Weight and sum the samples: - const vec3 sum = w4 * sample4 + - w1_3_5_7 * (sample1 + sample3 + sample5 + sample7) + - w0_2_6_8 * (sample0 + sample2 + sample6 + sample8); - return sum * weight_sum_inv; -} - -// Resizable one-pass blurs: -vec3 tex2Dblur3x3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3x3resize(texture, tex_uv, dxdy, blur3_std_dev); -} - -vec3 tex2Dblur9fast(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 9x Gaussian blurred texture lookup using 1 nearest - // neighbor and 4 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4)); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w12 = w1 + w2; - const float w34 = w3 + w4; - const float w12_ratio = w2/w12; - const float w34_ratio = w4/w34; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w34 * tex2D_linearize(tex, tex_uv - (3.0 + w34_ratio) * dxdy).rgb; - sum += w12 * tex2D_linearize(tex, tex_uv - (1.0 + w12_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(tex, tex_uv).rgb; - sum += w12 * tex2D_linearize(tex, tex_uv + (1.0 + w12_ratio) * dxdy).rgb; - sum += w34 * tex2D_linearize(tex, tex_uv + (3.0 + w34_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur9fast(const sampler2D tex, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9fast(tex, tex_uv, dxdy, blur9_std_dev); -} - -vec3 tex2Dblur17fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur17fast(texture, tex_uv, dxdy, blur17_std_dev); -} - -vec3 tex2Dblur25fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur25fast(texture, tex_uv, dxdy, blur25_std_dev); -} - -vec3 tex2Dblur43fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur43fast(texture, tex_uv, dxdy, blur43_std_dev); -} -vec3 tex2Dblur31fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur31fast(texture, tex_uv, dxdy, blur31_std_dev); -} - -#endif // BLUR_FUNCTIONS_H \ No newline at end of file diff --git a/crt/shaders/crt-royale/src/crt-royale-bloom-approx.slang b/crt/shaders/crt-royale/src/crt-royale-bloom-approx.slang index 13c06d6..30e5775 100644 --- a/crt/shaders/crt-royale/src/crt-royale-bloom-approx.slang +++ b/crt/shaders/crt-royale/src/crt-royale-bloom-approx.slang @@ -32,7 +32,13 @@ layout(push_constant) uniform Push ////////////////////////////////// INCLUDES ////////////////////////////////// -#include "includes.h" +#include "../user-settings.h" +#include "derived-settings-and-constants.h" +#include "bind-shader-params.h" +#include "../../../../include/gamma-management.h" +#include "../../../../include/blur-functions.h" +#include "scanline-functions.h" +#include "bloom-functions.h" /////////////////////////////////// HELPERS ////////////////////////////////// diff --git a/crt/shaders/crt-royale/src/crt-royale-bloom-horizontal-reconstitute.slang b/crt/shaders/crt-royale/src/crt-royale-bloom-horizontal-reconstitute.slang index 09b90e6..759cd87 100644 --- a/crt/shaders/crt-royale/src/crt-royale-bloom-horizontal-reconstitute.slang +++ b/crt/shaders/crt-royale/src/crt-royale-bloom-horizontal-reconstitute.slang @@ -40,8 +40,8 @@ layout(push_constant) uniform Push ////////////////////////////////// INCLUDES ////////////////////////////////// -//#include "../../../../include/gamma-management.h" -//#include "bloom-functions.h" +#include "../../../../include/gamma-management.h" +#include "bloom-functions.h" #include "phosphor-mask-resizing.h" #include "scanline-functions.h" diff --git a/crt/shaders/crt-royale/src/crt-royale-bloom-vertical.slang b/crt/shaders/crt-royale/src/crt-royale-bloom-vertical.slang index edf2134..3d9c3d6 100644 --- a/crt/shaders/crt-royale/src/crt-royale-bloom-vertical.slang +++ b/crt/shaders/crt-royale/src/crt-royale-bloom-vertical.slang @@ -38,10 +38,9 @@ layout(push_constant) uniform Push ////////////////////////////////// INCLUDES ////////////////////////////////// -//#include "../../../../include/gamma-management.h" -//#include "bloom-functions.h" +#include "../../../../include/gamma-management.h" +#include "bloom-functions.h" #include "phosphor-mask-resizing.h" -#include "includes.h" #pragma stage vertex layout(location = 0) in vec4 Position; diff --git a/crt/shaders/crt-royale/src/crt-royale-brightpass.slang b/crt/shaders/crt-royale/src/crt-royale-brightpass.slang index 151d7af..cfdfe54 100644 --- a/crt/shaders/crt-royale/src/crt-royale-brightpass.slang +++ b/crt/shaders/crt-royale/src/crt-royale-brightpass.slang @@ -40,12 +40,12 @@ layout(push_constant) uniform Push ////////////////////////////////// INCLUDES ////////////////////////////////// -//#include "../../../../include/gamma-management.h" -//#include "../../../../include/blur-functions.h" +#include "../../../../include/gamma-management.h" +#include "../../../../include/blur-functions.h" #include "phosphor-mask-resizing.h" #include "scanline-functions.h" #include "bloom-functions.h" -#include "includes.h" + #pragma stage vertex layout(location = 0) in vec4 Position; diff --git a/crt/shaders/crt-royale/src/crt-royale-first-pass-linearize-crt-gamma-bob-fields.slang b/crt/shaders/crt-royale/src/crt-royale-first-pass-linearize-crt-gamma-bob-fields.slang index 9e0c97c..888fc04 100644 --- a/crt/shaders/crt-royale/src/crt-royale-first-pass-linearize-crt-gamma-bob-fields.slang +++ b/crt/shaders/crt-royale/src/crt-royale-first-pass-linearize-crt-gamma-bob-fields.slang @@ -42,11 +42,12 @@ layout(std140, set = 0, binding = 0) uniform UBO #define FIRST_PASS #define SIMULATE_CRT_ON_LCD -//#include "params.inc" - ////////////////////////////////// INCLUDES ////////////////////////////////// -#include "includes.h" +#include "../user-settings.h" +#include "bind-shader-params.h" +#include "../../../../include/gamma-management.h" +#include "scanline-functions.h" #pragma stage vertex layout(location = 0) in vec4 Position; diff --git a/crt/shaders/crt-royale/src/crt-royale-geometry-aa-last-pass.slang b/crt/shaders/crt-royale/src/crt-royale-geometry-aa-last-pass.slang index 2438a04..928b89d 100644 --- a/crt/shaders/crt-royale/src/crt-royale-geometry-aa-last-pass.slang +++ b/crt/shaders/crt-royale/src/crt-royale-geometry-aa-last-pass.slang @@ -37,7 +37,7 @@ layout(push_constant) uniform Push #include "derived-settings-and-constants.h" #include "bind-shader-params.h" -#ifndef RUNTIME_GEOMETRY_TILT +#ifndef DONT_DEFINE //RUNTIME_GEOMETRY_TILT // Create a local-to-global rotation matrix for the CRT's coordinate frame // and its global-to-local inverse. See the vertex shader for details. // It's faster to compute these statically if possible. @@ -97,7 +97,7 @@ void main() const vec2 geom_overscan = get_geom_overscan_vector(); geom_aspect_and_overscan = vec4(geom_aspect, geom_overscan); - #ifdef RUNTIME_GEOMETRY_TILT + #ifdef DONT_DEFINE //RUNTIME_GEOMETRY_TILT // Create a local-to-global rotation matrix for the CRT's coordinate // frame and its global-to-local inverse. Rotate around the x axis // first (pitch) and then the y axis (yaw) with yucky Euler angles. @@ -237,6 +237,10 @@ void main() { color = tex2D_linearize(Source, tex_uv).rgb; } + + // Dim borders and output the final result: + const float border_dim_factor = get_border_dim_factor(video_uv, geom_aspect); + const vec3 final_color = color * border_dim_factor; - FragColor = vec4(texture(Source, tex_uv).rgb, 1.0); + FragColor = encode_output(vec4(final_color, 1.0)); } \ No newline at end of file diff --git a/crt/shaders/crt-royale/src/crt-royale-mask-resize-horizontal.slang b/crt/shaders/crt-royale/src/crt-royale-mask-resize-horizontal.slang index 7ef2152..0f36ed6 100644 --- a/crt/shaders/crt-royale/src/crt-royale-mask-resize-horizontal.slang +++ b/crt/shaders/crt-royale/src/crt-royale-mask-resize-horizontal.slang @@ -71,17 +71,17 @@ void main() // and the number of tiles that will fit in the FBO. const vec2 output_tiles_this_pass = registers.OutputSize.xy / mask_resize_tile_size; const vec2 output_video_uv = tex_uv; - const vec2 tile_uv_wrap = output_video_uv * output_tiles_this_pass; + tile_uv_wrap = output_video_uv * output_tiles_this_pass; // Get the texel size of an input tile and related values: const vec2 input_tile_size = vec2(min( mask_resize_src_lut_size.x, registers.SourceSize.x), mask_resize_tile_size.y); - const vec2 tile_size_uv = input_tile_size * registers.SourceSize.zw; - const vec2 input_tiles_per_texture = registers.SourceSize.xy / input_tile_size; + tile_size_uv = input_tile_size * registers.SourceSize.zw; + input_tiles_per_texture = registers.SourceSize.xy / input_tile_size; // Derive [wrapped] texture uv coords from [wrapped] tile uv coords and // the tile size in uv coords, and save frac() for the fragment shader. - const vec2 src_tex_uv_wrap = tile_uv_wrap * tile_size_uv; + src_tex_uv_wrap = tile_uv_wrap * tile_size_uv; resize_magnification_scale = mask_resize_tile_size / input_tile_size; src_dxdy = vec2(registers.SourceSize.z, 0.0); diff --git a/crt/shaders/crt-royale/src/crt-royale-mask-resize-vertical.slang b/crt/shaders/crt-royale/src/crt-royale-mask-resize-vertical.slang index 63cea12..eea2cc7 100644 --- a/crt/shaders/crt-royale/src/crt-royale-mask-resize-vertical.slang +++ b/crt/shaders/crt-royale/src/crt-royale-mask-resize-vertical.slang @@ -31,9 +31,9 @@ layout(push_constant) uniform Push ///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// -//#include "../user-settings.h" -//#include "derived-settings-and-constants.h" -//#include "bind-shader-params.h" +#include "../user-settings.h" +#include "derived-settings-and-constants.h" +#include "bind-shader-params.h" ////////////////////////////////// INCLUDES ////////////////////////////////// diff --git a/crt/shaders/crt-royale/src/crt-royale-scanlines-horizontal-apply-mask.slang b/crt/shaders/crt-royale/src/crt-royale-scanlines-horizontal-apply-mask.slang index 0b6a665..2fff5bd 100644 --- a/crt/shaders/crt-royale/src/crt-royale-scanlines-horizontal-apply-mask.slang +++ b/crt/shaders/crt-royale/src/crt-royale-scanlines-horizontal-apply-mask.slang @@ -41,11 +41,11 @@ layout(push_constant) uniform Push ////////////////////////////////// INCLUDES ////////////////////////////////// -//#include "scanline-functions.h" +#include "scanline-functions.h" #include "phosphor-mask-resizing.h" -//#include "bloom-functions.h"//"bloom-functions.h" -//#include "../../../../include/gamma-management.h" -#include "includes.h" +#include "bloom-functions.h"//"bloom-functions.h" +#include "../../../../include/gamma-management.h" + /////////////////////////////////// HELPERS ////////////////////////////////// vec4 tex2Dtiled_mask_linearize(const sampler2D tex, @@ -88,11 +88,11 @@ void main() video_uv = TexCoord; const vec2 scanline_texture_size_inv = registers.VERTICAL_SCANLINESSize.zw; - scanline_tex_uv = video_uv * registers.VERTICAL_SCANLINESSize.xy * + scanline_tex_uv = video_uv;// * registers.VERTICAL_SCANLINESSize.xy * scanline_texture_size_inv; - blur3x3_tex_uv = video_uv * registers.BLOOM_APPROXSize.xy * + blur3x3_tex_uv = video_uv;// * registers.BLOOM_APPROXSize.xy * registers.BLOOM_APPROXSize.zw; - halation_tex_uv = video_uv * registers.HALATION_BLURSize.xy * + halation_tex_uv = video_uv;// * registers.HALATION_BLURSize.xy * registers.HALATION_BLURSize.zw; // Get a consistent name for the final mask texture size. Sample mode 0 @@ -109,10 +109,9 @@ void main() #endif // Compute mask tile dimensions, starting points, etc.: - vec2 mask_tiles_per_screen; - mask_tile_start_uv_and_size = vec4(get_mask_sampling_parameters( + mask_tile_start_uv_and_size = get_mask_sampling_parameters( mask_resize_texture_size, mask_resize_video_size, registers.OutputSize.xy, - mask_tiles_per_screen)); //TODO/FIXME: is this right? I wrapped in a vec4 because that's what it needs to compile + mask_tiles_per_screen); } #pragma stage fragment @@ -200,12 +199,12 @@ void main() const vec3 halation_intensity_dim = vec3(dot(halation_color, vec3(auto_dim_factor/3.0))); const vec3 electron_intensity_dim = mix(scanline_color_dim, - halation_intensity_dim, halation_weight); + halation_intensity_dim, params.halation_weight); // Apply the phosphor mask: const vec3 phosphor_emission_dim = electron_intensity_dim * phosphor_mask_sample; - + #define PHOSPHOR_BLOOM_FAKE // TODO/FIXME: something seems wrong with the non-FAKE path #ifdef PHOSPHOR_BLOOM_FAKE // The BLOOM_APPROX pass approximates a blurred version of a masked // and scanlined image. It's usually used to compute the brightpass, diff --git a/crt/shaders/crt-royale/src/crt-royale-scanlines-vertical-interlacing.slang b/crt/shaders/crt-royale/src/crt-royale-scanlines-vertical-interlacing.slang index d541118..6487caf 100644 --- a/crt/shaders/crt-royale/src/crt-royale-scanlines-vertical-interlacing.slang +++ b/crt/shaders/crt-royale/src/crt-royale-scanlines-vertical-interlacing.slang @@ -31,7 +31,11 @@ layout(push_constant) uniform Push ////////////////////////////////// INCLUDES ////////////////////////////////// -#include "includes.h" +#include "../user-settings.h" +#include "derived-settings-and-constants.h" +#include "bind-shader-params.h" +#include "scanline-functions.h" +#include "../../../../include/gamma-management.h" #pragma stage vertex layout(location = 0) in vec4 Position; diff --git a/crt/shaders/crt-royale/src/gamma-management-old.h b/crt/shaders/crt-royale/src/gamma-management-old.h deleted file mode 100644 index 18963c7..0000000 --- a/crt/shaders/crt-royale/src/gamma-management-old.h +++ /dev/null @@ -1,547 +0,0 @@ -#ifndef GAMMA_MANAGEMENT_H -#define GAMMA_MANAGEMENT_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file provides gamma-aware tex*D*() and encode_output() functions. -// Requires: Before #include-ing this file, the including file must #define -// the following macros when applicable and follow their rules: -// 1.) #define FIRST_PASS if this is the first pass. -// 2.) #define LAST_PASS if this is the last pass. -// 3.) If sRGB is available, set srgb_framebufferN = "true" for -// every pass except the last in your .cgp preset. -// 4.) If sRGB isn't available but you want gamma-correctness with -// no banding, #define GAMMA_ENCODE_EVERY_FBO each pass. -// 5.) #define SIMULATE_CRT_ON_LCD if desired (precedence over 5-7) -// 6.) #define SIMULATE_GBA_ON_LCD if desired (precedence over 6-7) -// 7.) #define SIMULATE_LCD_ON_CRT if desired (precedence over 7) -// 8.) #define SIMULATE_GBA_ON_CRT if desired (precedence over -) -// If an option in [5, 8] is #defined in the first or last pass, it -// should be #defined for both. It shouldn't make a difference -// whether it's #defined for intermediate passes or not. -// Optional: The including file (or an earlier included file) may optionally -// #define a number of macros indicating it will override certain -// macros and associated constants are as follows: -// static constants with either static or uniform constants. The -// 1.) OVERRIDE_STANDARD_GAMMA: The user must first define: -// static const float ntsc_gamma -// static const float pal_gamma -// static const float crt_reference_gamma_high -// static const float crt_reference_gamma_low -// static const float lcd_reference_gamma -// static const float crt_office_gamma -// static const float lcd_office_gamma -// 2.) OVERRIDE_DEVICE_GAMMA: The user must first define: -// static const float crt_gamma -// static const float gba_gamma -// static const float lcd_gamma -// 3.) OVERRIDE_FINAL_GAMMA: The user must first define: -// static const float input_gamma -// static const float intermediate_gamma -// static const float output_gamma -// (intermediate_gamma is for GAMMA_ENCODE_EVERY_FBO.) -// 4.) OVERRIDE_ALPHA_ASSUMPTIONS: The user must first define: -// static const bool assume_opaque_alpha -// The gamma constant overrides must be used in every pass or none, -// and OVERRIDE_FINAL_GAMMA bypasses all of the SIMULATE* macros. -// OVERRIDE_ALPHA_ASSUMPTIONS may be set on a per-pass basis. -// Usage: After setting macros appropriately, ignore gamma correction and -// replace all tex*D*() calls with equivalent gamma-aware -// tex*D*_linearize calls, except: -// 1.) When you read an LUT, use regular tex*D or a gamma-specified -// function, depending on its gamma encoding: -// tex*D*_linearize_gamma (takes a runtime gamma parameter) -// 2.) If you must read pass0's original input in a later pass, use -// tex2D_linearize_ntsc_gamma. If you want to read pass0's -// input with gamma-corrected bilinear filtering, consider -// creating a first linearizing pass and reading from the input -// of pass1 later. -// Then, return encode_output(color) from every fragment shader. -// Finally, use the global gamma_aware_bilinear boolean if you want -// to statically branch based on whether bilinear filtering is -// gamma-correct or not (e.g. for placing Gaussian blur samples). -// -// Detailed Policy: -// tex*D*_linearize() functions enforce a consistent gamma-management policy -// based on the FIRST_PASS and GAMMA_ENCODE_EVERY_FBO settings. They assume -// their input texture has the same encoding characteristics as the input for -// the current pass (which doesn't apply to the exceptions listed above). -// Similarly, encode_output() enforces a policy based on the LAST_PASS and -// GAMMA_ENCODE_EVERY_FBO settings. Together, they result in one of the -// following two pipelines. -// Typical pipeline with intermediate sRGB framebuffers: -// linear_color = pow(pass0_encoded_color, input_gamma); -// intermediate_output = linear_color; // Automatic sRGB encoding -// linear_color = intermediate_output; // Automatic sRGB decoding -// final_output = pow(intermediate_output, 1.0/output_gamma); -// Typical pipeline without intermediate sRGB framebuffers: -// linear_color = pow(pass0_encoded_color, input_gamma); -// intermediate_output = pow(linear_color, 1.0/intermediate_gamma); -// linear_color = pow(intermediate_output, intermediate_gamma); -// final_output = pow(intermediate_output, 1.0/output_gamma); -// Using GAMMA_ENCODE_EVERY_FBO is much slower, but it's provided as a way to -// easily get gamma-correctness without banding on devices where sRGB isn't -// supported. -// -// Use This Header to Maximize Code Reuse: -// The purpose of this header is to provide a consistent interface for texture -// reads and output gamma-encoding that localizes and abstracts away all the -// annoying details. This greatly reduces the amount of code in each shader -// pass that depends on the pass number in the .cgp preset or whether sRGB -// FBO's are being used: You can trivially change the gamma behavior of your -// whole pass by commenting or uncommenting 1-3 #defines. To reuse the same -// code in your first, Nth, and last passes, you can even put it all in another -// header file and #include it from skeleton .cg files that #define the -// appropriate pass-specific settings. -// -// Rationale for Using Three Macros: -// This file uses GAMMA_ENCODE_EVERY_FBO instead of an opposite macro like -// SRGB_PIPELINE to ensure sRGB is assumed by default, which hopefully imposes -// a lower maintenance burden on each pass. At first glance it seems we could -// accomplish everything with two macros: GAMMA_CORRECT_IN / GAMMA_CORRECT_OUT. -// This works for simple use cases where input_gamma == output_gamma, but it -// breaks down for more complex scenarios like CRT simulation, where the pass -// number determines the gamma encoding of the input and output. - - -/////////////////////////////// BASE CONSTANTS /////////////////////////////// - -// Set standard gamma constants, but allow users to override them: -#ifndef OVERRIDE_STANDARD_GAMMA - // Standard encoding gammas: - const float ntsc_gamma = 2.2; // Best to use NTSC for PAL too? - const float pal_gamma = 2.8; // Never actually 2.8 in practice - // Typical device decoding gammas (only use for emulating devices): - // CRT/LCD reference gammas are higher than NTSC and Rec.709 video standard - // gammas: The standards purposely undercorrected for an analog CRT's - // assumed 2.5 reference display gamma to maintain contrast in assumed - // [dark] viewing conditions: http://www.poynton.com/PDFs/GammaFAQ.pdf - // These unstated assumptions about display gamma and perceptual rendering - // intent caused a lot of confusion, and more modern CRT's seemed to target - // NTSC 2.2 gamma with circuitry. LCD displays seem to have followed suit - // (they struggle near black with 2.5 gamma anyway), especially PC/laptop - // displays designed to view sRGB in bright environments. (Standards are - // also in flux again with BT.1886, but it's underspecified for displays.) - const float crt_reference_gamma_high = 2.5; // In (2.35, 2.55) - const float crt_reference_gamma_low = 2.35; // In (2.35, 2.55) - const float lcd_reference_gamma = 2.5; // To match CRT - const float crt_office_gamma = 2.2; // Circuitry-adjusted for NTSC - const float lcd_office_gamma = 2.2; // Approximates sRGB -#endif // OVERRIDE_STANDARD_GAMMA - -// Assuming alpha == 1.0 might make it easier for users to avoid some bugs, -// but only if they're aware of it. -#ifndef OVERRIDE_ALPHA_ASSUMPTIONS - const bool assume_opaque_alpha = false; -#endif - - -/////////////////////// DERIVED CONSTANTS AS FUNCTIONS /////////////////////// - -// gamma-management.h should be compatible with overriding gamma values with -// runtime user parameters, but we can only define other global constants in -// terms of static constants, not uniform user parameters. To get around this -// limitation, we need to define derived constants using functions. - -// Set device gamma constants, but allow users to override them: -#ifdef OVERRIDE_DEVICE_GAMMA - // The user promises to globally define the appropriate constants: - float get_crt_gamma() { return crt_gamma; } - float get_gba_gamma() { return gba_gamma; } - float get_lcd_gamma() { return lcd_gamma; } -#else - float get_crt_gamma() { return crt_reference_gamma_high; } - float get_gba_gamma() { return 3.5; } // Game Boy Advance; in (3.0, 4.0) - float get_lcd_gamma() { return lcd_office_gamma; } -#endif // OVERRIDE_DEVICE_GAMMA - -// Set decoding/encoding gammas for the first/lass passes, but allow overrides: -#ifdef OVERRIDE_FINAL_GAMMA - // The user promises to globally define the appropriate constants: - float get_intermediate_gamma() { return intermediate_gamma; } - float get_input_gamma() { return input_gamma; } - float get_output_gamma() { return output_gamma; } -#else - // If we gamma-correct every pass, always use ntsc_gamma between passes to - // ensure middle passes don't need to care if anything is being simulated: - float get_intermediate_gamma() { return ntsc_gamma; } - #ifdef SIMULATE_CRT_ON_LCD - float get_input_gamma() { return get_crt_gamma(); } - float get_output_gamma() { return get_lcd_gamma(); } - #else - #ifdef SIMULATE_GBA_ON_LCD - float get_input_gamma() { return get_gba_gamma(); } - float get_output_gamma() { return get_lcd_gamma(); } - #else - #ifdef SIMULATE_LCD_ON_CRT - float get_input_gamma() { return get_lcd_gamma(); } - float get_output_gamma() { return get_crt_gamma(); } - #else - #ifdef SIMULATE_GBA_ON_CRT - float get_input_gamma() { return get_gba_gamma(); } - float get_output_gamma() { return get_crt_gamma(); } - #else // Don't simulate anything: - float get_input_gamma() { return ntsc_gamma; } - float get_output_gamma() { return ntsc_gamma; } - #endif // SIMULATE_GBA_ON_CRT - #endif // SIMULATE_LCD_ON_CRT - #endif // SIMULATE_GBA_ON_LCD - #endif // SIMULATE_CRT_ON_LCD -#endif // OVERRIDE_FINAL_GAMMA - -// Set decoding/encoding gammas for the current pass. Use static constants for -// linearize_input and gamma_encode_output, because they aren't derived, and -// they let the compiler do dead-code elimination. -#ifndef GAMMA_ENCODE_EVERY_FBO - #ifdef FIRST_PASS - const bool linearize_input = true; - float get_pass_input_gamma() { return get_input_gamma(); } - #else - const bool linearize_input = false; - float get_pass_input_gamma() { return 1.0; } - #endif - #ifdef LAST_PASS - const bool gamma_encode_output = true; - float get_pass_output_gamma() { return get_output_gamma(); } - #else - const bool gamma_encode_output = false; - float get_pass_output_gamma() { return 1.0; } - #endif -#else - const bool linearize_input = true; - const bool gamma_encode_output = true; - #ifdef FIRST_PASS - float get_pass_input_gamma() { return get_input_gamma(); } - #else - float get_pass_input_gamma() { return get_intermediate_gamma(); } - #endif - #ifdef LAST_PASS - float get_pass_output_gamma() { return get_output_gamma(); } - #else - float get_pass_output_gamma() { return get_intermediate_gamma(); } - #endif -#endif - -// Users might want to know if bilinear filtering will be gamma-correct: -const bool gamma_aware_bilinear = !linearize_input; - - -////////////////////// COLOR ENCODING/DECODING FUNCTIONS ///////////////////// - -vec4 encode_output(const vec4 color) -{ - if(gamma_encode_output) - { - if(assume_opaque_alpha) - { - return vec4(pow(color.rgb, vec3(1.0/get_pass_output_gamma())), 1.0); - } - else - { - return vec4(pow(color.rgb, vec3(1.0/get_pass_output_gamma())), color.a); - } - } - else - { - return color; - } -} - -vec4 decode_input(const vec4 color) -{ - if(linearize_input) - { - if(assume_opaque_alpha) - { - return vec4(pow(color.rgb, vec3(get_pass_input_gamma())), 1.0); - } - else - { - return vec4(pow(color.rgb, vec3(get_pass_input_gamma())), color.a); - } - } - else - { - return color; - } -} - -vec4 decode_gamma_input(const vec4 color, const vec3 gamma) -{ - if(assume_opaque_alpha) - { - return vec4(pow(color.rgb, vec3(gamma)), 1.0); - } - else - { - return vec4(pow(color.rgb, vec3(gamma)), color.a); - } -} - - -/////////////////////////// TEXTURE LOOKUP WRAPPERS ////////////////////////// - -// "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS: -// Provide a wide array of linearizing texture lookup wrapper functions. The -// Cg shader spec Retroarch uses only allows for 2D textures, but 1D and 3D -// lookups are provided for completeness in case that changes someday. Nobody -// is likely to use the *fetch and *proj functions, but they're included just -// in case. The only tex*D texture sampling functions omitted are: -// - tex*Dcmpbias -// - tex*Dcmplod -// - tex*DARRAY* -// - tex*DMS* -// - Variants returning integers -// Standard line length restrictions are ignored below for vertical brevity. - -/* -// tex1D: -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords) -{ return decode_input(tex1D(texture, tex_coords)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords) -{ return decode_input(tex1D(texture, tex_coords)); } - -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, texel_off)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, texel_off)); } - -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords, const float dx, const float dy) -{ return decode_input(tex1D(texture, tex_coords, dx, dy)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords, const float dx, const float dy) -{ return decode_input(tex1D(texture, tex_coords, dx, dy)); } - -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords, const float dx, const float dy, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, dx, dy, texel_off)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords, const float dx, const float dy, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, dx, dy, texel_off)); } - -// tex1Dbias: -vec4 tex1Dbias_linearize(const sampler1D texture, const vec4 tex_coords) -{ return decode_input(tex1Dbias(texture, tex_coords)); } - -vec4 tex1Dbias_linearize(const sampler1D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex1Dbias(texture, tex_coords, texel_off)); } - -// tex1Dfetch: -vec4 tex1Dfetch_linearize(const sampler1D texture, const int4 tex_coords) -{ return decode_input(tex1Dfetch(texture, tex_coords)); } - -vec4 tex1Dfetch_linearize(const sampler1D texture, const int4 tex_coords, const int texel_off) -{ return decode_input(tex1Dfetch(texture, tex_coords, texel_off)); } - -// tex1Dlod: -vec4 tex1Dlod_linearize(const sampler1D texture, const vec4 tex_coords) -{ return decode_input(tex1Dlod(texture, tex_coords)); } - -vec4 tex1Dlod_linearize(const sampler1D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex1Dlod(texture, tex_coords, texel_off)); } - -// tex1Dproj: -vec4 tex1Dproj_linearize(const sampler1D texture, const vec2 tex_coords) -{ return decode_input(tex1Dproj(texture, tex_coords)); } - -vec4 tex1Dproj_linearize(const sampler1D texture, const vec3 tex_coords) -{ return decode_input(tex1Dproj(texture, tex_coords)); } - -vec4 tex1Dproj_linearize(const sampler1D texture, const vec2 tex_coords, const int texel_off) -{ return decode_input(tex1Dproj(texture, tex_coords, texel_off)); } - -vec4 tex1Dproj_linearize(const sampler1D texture, const vec3 tex_coords, const int texel_off) -{ return decode_input(tex1Dproj(texture, tex_coords, texel_off)); } -*/ - -// tex2D: -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords) -{ return decode_input(vec4(texture(tex, tex_coords))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords) -{ return decode_input(vec4(texture(tex, tex_coords))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, texel_off))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, texel_off))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy, texel_off))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy, texel_off))); } - -// tex2Dbias: -vec4 tex2Dbias_linearize(const sampler2D tex, const vec4 tex_coords) -{ return decode_input(vec4(tex2Dbias(tex, tex_coords))); } - -vec4 tex2Dbias_linearize(const sampler2D tex, const vec4 tex_coords, const int texel_off) -{ return decode_input(vec4(tex2Dbias(tex, tex_coords, texel_off))); } - -// tex2Dfetch: -vec4 tex2Dfetch_linearize(const sampler2D tex, const ivec4 tex_coords) -{ return decode_input(vec4(texture2Dfetch(tex, tex_coords))); } - -vec4 tex2Dfetch_linearize(const sampler2D tex, const ivec4 tex_coords, const int texel_off) -{ return decode_input(vec4(texture2Dfetch(tex, tex_coords, texel_off))); } - -// tex2Dlod: -vec4 tex2Dlod_linearize(const sampler2D tex, const vec4 tex_coords) -{ return decode_input(vec4(texture2Dlod(tex, tex_coords))); } - -vec4 tex2Dlod_linearize(const sampler2D tex, const vec4 tex_coords, const int texel_off) -{ return decode_input(vec4(texture2Dlod(tex, tex_coords, texel_off))); } - -// tex2Dproj: -vec4 tex2Dproj_linearize(const sampler2D tex, const vec3 tex_coords) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords))); } - -vec4 tex2Dproj_linearize(const sampler2D tex, const vec4 tex_coords) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords))); } - -vec4 tex2Dproj_linearize(const sampler2D tex, const vec3 tex_coords, const int texel_off) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords, texel_off))); } - -vec4 tex2Dproj_linearize(const sampler2D tex, const vec4 tex_coords, const int texel_off) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords, texel_off))); } - -/* -// tex3D: -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords) -{ return decode_input(tex3D(texture, tex_coords)); } - -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords, const int texel_off) -{ return decode_input(tex3D(texture, tex_coords, texel_off)); } - -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords, const vec3 dx, const vec3 dy) -{ return decode_input(tex3D(texture, tex_coords, dx, dy)); } - -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords, const vec3 dx, const vec3 dy, const int texel_off) -{ return decode_input(tex3D(texture, tex_coords, dx, dy, texel_off)); } - -// tex3Dbias: -vec4 tex3Dbias_linearize(const sampler3D texture, const vec4 tex_coords) -{ return decode_input(tex3Dbias(texture, tex_coords)); } - -vec4 tex3Dbias_linearize(const sampler3D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex3Dbias(texture, tex_coords, texel_off)); } - -// tex3Dfetch: -vec4 tex3Dfetch_linearize(const sampler3D texture, const int4 tex_coords) -{ return decode_input(tex3Dfetch(texture, tex_coords)); } - -vec4 tex3Dfetch_linearize(const sampler3D texture, const int4 tex_coords, const int texel_off) -{ return decode_input(tex3Dfetch(texture, tex_coords, texel_off)); } - -// tex3Dlod: -vec4 tex3Dlod_linearize(const sampler3D texture, const vec4 tex_coords) -{ return decode_input(tex3Dlod(texture, tex_coords)); } - -vec4 tex3Dlod_linearize(const sampler3D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex3Dlod(texture, tex_coords, texel_off)); } - -// tex3Dproj: -vec4 tex3Dproj_linearize(const sampler3D texture, const vec4 tex_coords) -{ return decode_input(tex3Dproj(texture, tex_coords)); } - -vec4 tex3Dproj_linearize(const sampler3D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex3Dproj(texture, tex_coords, texel_off)); } -*/ - - -// NONSTANDARD "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS: -// This narrow selection of nonstandard tex2D* functions can be useful: - -// tex2Dlod0: Automatically fill in the tex2D LOD parameter for mip level 0. -vec4 tex2Dlod0_linearize(const sampler2D texture, const vec2 tex_coords) -{ return decode_input(vec4(texture2Dlod(texture, vec4(tex_coords, 0.0, 0.0)))); } - -vec4 tex2Dlod0_linearize(const sampler2D texture, const vec2 tex_coords, const int texel_off) -{ return decode_input(vec4(texture2Dlod(texture, vec4(tex_coords, 0.0, 0.0), texel_off))); } - - -// MANUALLY LINEARIZING TEXTURE LOOKUP FUNCTIONS: -// Provide a narrower selection of tex2D* wrapper functions that decode an -// input sample with a specified gamma value. These are useful for reading -// LUT's and for reading the input of pass0 in a later pass. - -// tex2D: -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, texel_off), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, texel_off), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy, texel_off), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy, texel_off), vec3(gamma))); } - -// tex2Dbias: -vec4 tex2Dbias_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dbias(tex, tex_coords), vec3(gamma))); } - -vec4 tex2Dbias_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dbias(tex, tex_coords, texel_off), vec3(gamma))); } - -// tex2Dfetch: -vec4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dfetch(tex, tex_coords), vec3(gamma))); } - -vec4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dfetch(tex, tex_coords, texel_off), vec3(gamma))); } - -// tex2Dlod: -vec4 tex2Dlod_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dlod(tex, tex_coords), vec3(gamma))); } - -vec4 tex2Dlod_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dlod(tex, tex_coords, texel_off), vec3(gamma))); } - - -#endif // GAMMA_MANAGEMENT_H - diff --git a/crt/shaders/crt-royale/src/geometry-functions-old.h b/crt/shaders/crt-royale/src/geometry-functions-old.h deleted file mode 100644 index e328a76..0000000 --- a/crt/shaders/crt-royale/src/geometry-functions-old.h +++ /dev/null @@ -1,692 +0,0 @@ -#ifndef GEOMETRY_FUNCTIONS_H -#define GEOMETRY_FUNCTIONS_H - -///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// - -// crt-royale: A full-featured CRT shader, with cheese. -// Copyright (C) 2014 TroggleMonkey -// -// This program is free software; you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation; either version 2 of the License, or any later version. -// -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. -// -// You should have received a copy of the GNU General Public License along with -// this program; if not, write to the Free Software Foundation, Inc., 59 Temple -// Place, Suite 330, Boston, MA 02111-1307 USA - - -////////////////////////////////// INCLUDES ////////////////////////////////// - -#include "../user-settings.h" -#include "derived-settings-and-constants.h" -#include "bind-shader-params.h" - - -//////////////////////////// MACROS AND CONSTANTS //////////////////////////// - -// Curvature-related constants: -#define MAX_POINT_CLOUD_SIZE 9 - - -///////////////////////////// CURVATURE FUNCTIONS ///////////////////////////// - -vec2 quadratic_solve(const float a, const float b_over_2, const float c) -{ - // Requires: 1.) a, b, and c are quadratic formula coefficients - // 2.) b_over_2 = b/2.0 (simplifies terms to factor 2 out) - // 3.) b_over_2 must be guaranteed < 0.0 (avoids a branch) - // Returns: Returns vec2(first_solution, discriminant), so the caller - // can choose how to handle the "no intersection" case. The - // Kahan or Citardauq formula is used for numerical robustness. - const float discriminant = b_over_2*b_over_2 - a*c; - const float solution0 = c/(-b_over_2 + sqrt(discriminant)); - return vec2(solution0, discriminant); -} - -vec2 intersect_sphere(const vec3 view_vec, const vec3 eye_pos_vec) -{ - // Requires: 1.) view_vec and eye_pos_vec are 3D vectors in the sphere's - // local coordinate frame (eye_pos_vec is a position, i.e. - // a vector from the origin to the eye/camera) - // 2.) geom_radius is a global containing the sphere's radius - // Returns: Cast a ray of direction view_vec from eye_pos_vec at a - // sphere of radius geom_radius, and return the distance to - // the first intersection in units of length(view_vec). - // http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection - // Quadratic formula coefficients (b_over_2 is guaranteed negative): - const float a = dot(view_vec, view_vec); - const float b_over_2 = dot(view_vec, eye_pos_vec); // * 2.0 factored out - const float c = dot(eye_pos_vec, eye_pos_vec) - geom_radius*geom_radius; - return quadratic_solve(a, b_over_2, c); -} - -vec2 intersect_cylinder(const vec3 view_vec, const vec3 eye_pos_vec) -{ - // Requires: 1.) view_vec and eye_pos_vec are 3D vectors in the sphere's - // local coordinate frame (eye_pos_vec is a position, i.e. - // a vector from the origin to the eye/camera) - // 2.) geom_radius is a global containing the cylinder's radius - // Returns: Cast a ray of direction view_vec from eye_pos_vec at a - // cylinder of radius geom_radius, and return the distance to - // the first intersection in units of length(view_vec). The - // derivation of the coefficients is in Christer Ericson's - // Real-Time Collision Detection, p. 195-196, and this version - // uses LaGrange's identity to reduce operations. - // Arbitrary "cylinder top" reference point for an infinite cylinder: - const vec3 cylinder_top_vec = vec3(0.0, geom_radius, 0.0); - const vec3 cylinder_axis_vec = vec3(0.0, 1.0, 0.0);//vec3(0.0, 2.0*geom_radius, 0.0); - const vec3 top_to_eye_vec = eye_pos_vec - cylinder_top_vec; - const vec3 axis_x_view = cross(cylinder_axis_vec, view_vec); - const vec3 axis_x_top_to_eye = cross(cylinder_axis_vec, top_to_eye_vec); - // Quadratic formula coefficients (b_over_2 is guaranteed negative): - const float a = dot(axis_x_view, axis_x_view); - const float b_over_2 = dot(axis_x_top_to_eye, axis_x_view); - const float c = dot(axis_x_top_to_eye, axis_x_top_to_eye) - - geom_radius*geom_radius;//*dot(cylinder_axis_vec, cylinder_axis_vec); - return quadratic_solve(a, b_over_2, c); -} - -vec2 cylinder_xyz_to_uv(const vec3 intersection_pos_local, - const vec2 geom_aspect) -{ - // Requires: An xyz intersection position on a cylinder. - // Returns: video_uv coords mapped to range [-0.5, 0.5] - // Mapping: Define square_uv.x to be the signed arc length in xz-space, - // and define square_uv.y = -intersection_pos_local.y (+v = -y). - // Start with a numerically robust arc length calculation. - const float angle_from_image_center = atan(intersection_pos_local.z, - intersection_pos_local.x); - const float signed_arc_len = angle_from_image_center * geom_radius; - // Get a uv-mapping where [-0.5, 0.5] maps to a "square" area, then divide - // by the aspect ratio to stretch the mapping appropriately: - const vec2 square_uv = vec2(signed_arc_len, -intersection_pos_local.y); - const vec2 video_uv = square_uv / geom_aspect; - return video_uv; -} - -vec3 cylinder_uv_to_xyz(const vec2 video_uv, const vec2 geom_aspect) -{ - // Requires: video_uv coords mapped to range [-0.5, 0.5] - // Returns: An xyz intersection position on a cylinder. This is the - // inverse of cylinder_xyz_to_uv(). - // Expand video_uv by the aspect ratio to get proportionate x/y lengths, - // then calculate an xyz position for the cylindrical mapping above. - const vec2 square_uv = video_uv * geom_aspect; - const float arc_len = square_uv.x; - const float angle_from_image_center = arc_len / geom_radius; - const float x_pos = sin(angle_from_image_center) * geom_radius; - const float z_pos = cos(angle_from_image_center) * geom_radius; - // Or: z = sqrt(geom_radius**2 - x**2) - // Or: z = geom_radius/sqrt(1.0 + tan(angle)**2), x = z * tan(angle) - const vec3 intersection_pos_local = vec3(x_pos, -square_uv.y, z_pos); - return intersection_pos_local; -} - -vec2 sphere_xyz_to_uv(const vec3 intersection_pos_local, - const vec2 geom_aspect) -{ - // Requires: An xyz intersection position on a sphere. - // Returns: video_uv coords mapped to range [-0.5, 0.5] - // Mapping: First define square_uv.x/square_uv.y == - // intersection_pos_local.x/intersection_pos_local.y. Then, - // length(square_uv) is the arc length from the image center - // at (0.0, 0.0, geom_radius) along the tangent great circle. - // Credit for this mapping goes to cgwg: I never managed to - // understand his code, but he told me his mapping was based on - // great circle distances when I asked him about it, which - // informed this very similar (almost identical) mapping. - // Start with a numerically robust arc length calculation between the ray- - // sphere intersection point and the image center using a method posted by - // Roger Stafford on comp.soft-sys.matlab: - // https://groups.google.com/d/msg/comp.soft-sys.matlab/zNbUui3bjcA/c0HV_bHSx9cJ - const vec3 image_center_pos_local = vec3(0.0, 0.0, geom_radius); - const float cp_len = - length(cross(intersection_pos_local, image_center_pos_local)); - const float dp = dot(intersection_pos_local, image_center_pos_local); - const float angle_from_image_center = atan(dp, cp_len); - const float arc_len = angle_from_image_center * geom_radius; - // Get a uv-mapping where [-0.5, 0.5] maps to a "square" area, then divide - // by the aspect ratio to stretch the mapping appropriately: - const vec2 square_uv_unit = normalize(vec2(intersection_pos_local.x, - -intersection_pos_local.y)); - const vec2 square_uv = arc_len * square_uv_unit; - const vec2 video_uv = square_uv / geom_aspect; - return video_uv; -} - -vec3 sphere_uv_to_xyz(const vec2 video_uv, const vec2 geom_aspect) -{ - // Requires: video_uv coords mapped to range [-0.5, 0.5] - // Returns: An xyz intersection position on a sphere. This is the - // inverse of sphere_xyz_to_uv(). - // Expand video_uv by the aspect ratio to get proportionate x/y lengths, - // then calculate an xyz position for the spherical mapping above. - const vec2 square_uv = video_uv * geom_aspect; - // Using length or sqrt here butchers the framerate on my 8800GTS if - // this function is called too many times, and so does taking the max - // component of square_uv/square_uv_unit (program length threshold?). - //float arc_len = length(square_uv); - const vec2 square_uv_unit = normalize(square_uv); - const float arc_len = square_uv.y/square_uv_unit.y; - const float angle_from_image_center = arc_len / geom_radius; - const float xy_dist_from_sphere_center = - sin(angle_from_image_center) * geom_radius; - //vec2 xy_pos = xy_dist_from_sphere_center * (square_uv/FIX_ZERO(arc_len)); - const vec2 xy_pos = xy_dist_from_sphere_center * square_uv_unit; - const float z_pos = cos(angle_from_image_center) * geom_radius; - const vec3 intersection_pos_local = vec3(xy_pos.x, -xy_pos.y, z_pos); - return intersection_pos_local; -} - -vec2 sphere_alt_xyz_to_uv(const vec3 intersection_pos_local, - const vec2 geom_aspect) -{ - // Requires: An xyz intersection position on a cylinder. - // Returns: video_uv coords mapped to range [-0.5, 0.5] - // Mapping: Define square_uv.x to be the signed arc length in xz-space, - // and define square_uv.y == signed arc length in yz-space. - // See cylinder_xyz_to_uv() for implementation details (very similar). - const vec2 angle_from_image_center = atan((intersection_pos_local.zz), - vec2(intersection_pos_local.x, -intersection_pos_local.y)); - const vec2 signed_arc_len = angle_from_image_center * geom_radius; - const vec2 video_uv = signed_arc_len / geom_aspect; - return video_uv; -} - -vec3 sphere_alt_uv_to_xyz(const vec2 video_uv, const vec2 geom_aspect) -{ - // Requires: video_uv coords mapped to range [-0.5, 0.5] - // Returns: An xyz intersection position on a sphere. This is the - // inverse of sphere_alt_xyz_to_uv(). - // See cylinder_uv_to_xyz() for implementation details (very similar). - const vec2 square_uv = video_uv * geom_aspect; - const vec2 arc_len = square_uv; - const vec2 angle_from_image_center = arc_len / geom_radius; - const vec2 xy_pos = sin(angle_from_image_center) * geom_radius; - const float z_pos = sqrt(geom_radius*geom_radius - dot(xy_pos, xy_pos)); - return vec3(xy_pos.x, -xy_pos.y, z_pos); -} - -inline vec2 intersect(const vec3 view_vec_local, const vec3 eye_pos_local, - const float geom_mode) -{ - return geom_mode < 2.5 ? intersect_sphere(view_vec_local, eye_pos_local) : - intersect_cylinder(view_vec_local, eye_pos_local); -} - -inline vec2 xyz_to_uv(const vec3 intersection_pos_local, - const vec2 geom_aspect, const float geom_mode) -{ - return geom_mode < 1.5 ? - sphere_xyz_to_uv(intersection_pos_local, geom_aspect) : - geom_mode < 2.5 ? - sphere_alt_xyz_to_uv(intersection_pos_local, geom_aspect) : - cylinder_xyz_to_uv(intersection_pos_local, geom_aspect); -} - -inline vec3 uv_to_xyz(const vec2 uv, const vec2 geom_aspect, - const float geom_mode) -{ - return geom_mode < 1.5 ? sphere_uv_to_xyz(uv, geom_aspect) : - geom_mode < 2.5 ? sphere_alt_uv_to_xyz(uv, geom_aspect) : - cylinder_uv_to_xyz(uv, geom_aspect); -} - -vec2 view_vec_to_uv(const vec3 view_vec_local, const vec3 eye_pos_local, - const vec2 geom_aspect, const float geom_mode, out vec3 intersection_pos) -{ - // Get the intersection point on the primitive, given an eye position - // and view vector already in its local coordinate frame: - const vec2 intersect_dist_and_discriminant = intersect(view_vec_local, - eye_pos_local, geom_mode); - const vec3 intersection_pos_local = eye_pos_local + - view_vec_local * intersect_dist_and_discriminant.x; - // Save the intersection position to an output parameter: - intersection_pos = intersection_pos_local; - // Transform into uv coords, but give out-of-range coords if the - // view ray doesn't intersect the primitive in the first place: - return intersect_dist_and_discriminant.y > 0.005 ? - xyz_to_uv(intersection_pos_local, geom_aspect, geom_mode) : vec2(1.0); -} - -vec3 get_ideal_global_eye_pos_for_points(vec3 eye_pos, - const vec2 geom_aspect, const vec3 global_coords[MAX_POINT_CLOUD_SIZE], - const int num_points) -{ - // Requires: Parameters: - // 1.) Starting eye_pos is a global 3D position at which the - // camera contains all points in global_coords[] in its FOV - // 2.) geom_aspect = get_aspect_vector( - // IN.output_size.x / IN.output_size.y); - // 3.) global_coords is a point cloud containing global xyz - // coords of extreme points on the simulated CRT screen. - // Globals: - // 1.) geom_view_dist must be > 0.0. It controls the "near - // plane" used to interpret flat_video_uv as a view - // vector, which controls the field of view (FOV). - // Eyespace coordinate frame: +x = right, +y = up, +z = back - // Returns: Return an eye position at which the point cloud spans as - // much of the screen as possible (given the FOV controlled by - // geom_view_dist) without being cropped or sheared. - // Algorithm: - // 1.) Move the eye laterally to a point which attempts to maximize the - // the amount we can move forward without clipping the CRT screen. - // 2.) Move forward by as much as possible without clipping the CRT. - // Get the allowed movement range by solving for the eye_pos offsets - // that result in each point being projected to a screen edge/corner in - // pseudo-normalized device coords (where xy ranges from [-0.5, 0.5] - // and z = eyespace z): - // pndc_coord = vec3(vec2(eyespace_xyz.x, -eyespace_xyz.y)* - // geom_view_dist / (geom_aspect * -eyespace_xyz.z), eyespace_xyz.z); - // Notes: - // The field of view is controlled by geom_view_dist's magnitude relative to - // the view vector's x and y components: - // view_vec.xy ranges from [-0.5, 0.5] * geom_aspect - // view_vec.z = -geom_view_dist - // But for the purposes of perspective divide, it should be considered: - // view_vec.xy ranges from [-0.5, 0.5] * geom_aspect / geom_view_dist - // view_vec.z = -1.0 - const int max_centering_iters = 1; // Keep for easy testing. - for(int iter = 0; iter < max_centering_iters; iter++) - { - // 0.) Get the eyespace coordinates of our point cloud: - vec3 eyespace_coords[MAX_POINT_CLOUD_SIZE]; - for(int i = 0; i < num_points; i++) - { - eyespace_coords[i] = global_coords[i] - eye_pos; - } - // 1a.)For each point, find out how far we can move eye_pos in each - // lateral direction without the point clipping the frustum. - // Eyespace +y = up, screenspace +y = down, so flip y after - // applying the eyespace offset (on the way to "clip space"). - // Solve for two offsets per point based on: - // (eyespace_xyz.xy - offset_dr) * vec2(1.0, -1.0) * - // geom_view_dist / (geom_aspect * -eyespace_xyz.z) = vec2(-0.5) - // (eyespace_xyz.xy - offset_dr) * vec2(1.0, -1.0) * - // geom_view_dist / (geom_aspect * -eyespace_xyz.z) = vec2(0.5) - // offset_ul and offset_dr represent the farthest we can move the - // eye_pos up-left and down-right. Save the min of all offset_dr's - // and the max of all offset_ul's (since it's negative). - float abs_radius = abs(geom_radius); // In case anyone gets ideas. ;) - vec2 offset_dr_min = vec2(10.0 * abs_radius, 10.0 * abs_radius); - vec2 offset_ul_max = vec2(-10.0 * abs_radius, -10.0 * abs_radius); - for(int i = 0; i < num_points; i++) - { - const vec2 flipy = vec2(1.0, -1.0); - vec3 eyespace_xyz = eyespace_coords[i]; - vec2 offset_dr = eyespace_xyz.xy - vec2(-0.5) * - (geom_aspect * -eyespace_xyz.z) / (geom_view_dist * flipy); - vec2 offset_ul = eyespace_xyz.xy - vec2(0.5) * - (geom_aspect * -eyespace_xyz.z) / (geom_view_dist * flipy); - offset_dr_min = min(offset_dr_min, offset_dr); - offset_ul_max = max(offset_ul_max, offset_ul); - } - // 1b.)Update eye_pos: Adding the average of offset_ul_max and - // offset_dr_min gives it equal leeway on the top vs. bottom - // and left vs. right. Recalculate eyespace_coords accordingly. - vec2 center_offset = 0.5 * (offset_ul_max + offset_dr_min); - eye_pos.xy += center_offset; - for(int i = 0; i < num_points; i++) - { - eyespace_coords[i] = global_coords[i] - eye_pos; - } - // 2a.)For each point, find out how far we can move eye_pos forward - // without the point clipping the frustum. Flip the y - // direction in advance (matters for a later step, not here). - // Solve for four offsets per point based on: - // eyespace_xyz_flipy.x * geom_view_dist / - // (geom_aspect.x * (offset_z - eyespace_xyz_flipy.z)) =-0.5 - // eyespace_xyz_flipy.y * geom_view_dist / - // (geom_aspect.y * (offset_z - eyespace_xyz_flipy.z)) =-0.5 - // eyespace_xyz_flipy.x * geom_view_dist / - // (geom_aspect.x * (offset_z - eyespace_xyz_flipy.z)) = 0.5 - // eyespace_xyz_flipy.y * geom_view_dist / - // (geom_aspect.y * (offset_z - eyespace_xyz_flipy.z)) = 0.5 - // We'll vectorize the actual computation. Take the maximum of - // these four for a single offset, and continue taking the max - // for every point (use max because offset.z is negative). - float offset_z_max = -10.0 * geom_radius * geom_view_dist; - for(int i = 0; i < num_points; i++) - { - vec3 eyespace_xyz_flipy = eyespace_coords[i] * - vec3(1.0, -1.0, 1.0); - vec4 offset_zzzz = eyespace_xyz_flipy.zzzz + - (eyespace_xyz_flipy.xyxy * geom_view_dist) / - (vec4(-0.5, -0.5, 0.5, 0.5) * vec4(geom_aspect, geom_aspect)); - // Ignore offsets that push positive x/y values to opposite - // boundaries, and vice versa, and don't let the camera move - // past a point in the dead center of the screen: - offset_z_max = (eyespace_xyz_flipy.x < 0.0) ? - max(offset_z_max, offset_zzzz.x) : offset_z_max; - offset_z_max = (eyespace_xyz_flipy.y < 0.0) ? - max(offset_z_max, offset_zzzz.y) : offset_z_max; - offset_z_max = (eyespace_xyz_flipy.x > 0.0) ? - max(offset_z_max, offset_zzzz.z) : offset_z_max; - offset_z_max = (eyespace_xyz_flipy.y > 0.0) ? - max(offset_z_max, offset_zzzz.w) : offset_z_max; - offset_z_max = max(offset_z_max, eyespace_xyz_flipy.z); - } - // 2b.)Update eye_pos: Add the maximum (smallest negative) z offset. - eye_pos.z += offset_z_max; - } - return eye_pos; -} - -vec3 get_ideal_global_eye_pos(const vec3x3 local_to_global, - const vec2 geom_aspect, const float geom_mode) -{ - // Start with an initial eye_pos that includes the entire primitive - // (sphere or cylinder) in its field-of-view: - const vec3 high_view = vec3(0.0, geom_aspect.y, -geom_view_dist); - const vec3 low_view = high_view * vec3(1.0, -1.0, 1.0); - const float len_sq = dot(high_view, high_view); - const float fov = abs(acos(dot(high_view, low_view)/len_sq)); - // Trigonometry/similar triangles say distance = geom_radius/sin(fov/2): - const float eye_z_spherical = geom_radius/sin(fov*0.5); - const vec3 eye_pos = geom_mode < 2.5 ? - vec3(0.0, 0.0, eye_z_spherical) : - vec3(0.0, 0.0, max(geom_view_dist, eye_z_spherical)); - - // Get global xyz coords of extreme sample points on the simulated CRT - // screen. Start with the center, edge centers, and corners of the - // video image. We can't ignore backfacing points: They're occluded - // by closer points on the primitive, but they may NOT be occluded by - // the convex hull of the remaining samples (i.e. the remaining convex - // hull might not envelope points that do occlude a back-facing point.) - const int num_points = MAX_POINT_CLOUD_SIZE; - vec3 global_coords[MAX_POINT_CLOUD_SIZE]; - global_coords[0] = mul(local_to_global, uv_to_xyz(vec2(0.0, 0.0), geom_aspect, geom_mode)); - global_coords[1] = mul(local_to_global, uv_to_xyz(vec2(0.0, -0.5), geom_aspect, geom_mode)); - global_coords[2] = mul(local_to_global, uv_to_xyz(vec2(0.0, 0.5), geom_aspect, geom_mode)); - global_coords[3] = mul(local_to_global, uv_to_xyz(vec2(-0.5, 0.0), geom_aspect, geom_mode)); - global_coords[4] = mul(local_to_global, uv_to_xyz(vec2(0.5, 0.0), geom_aspect, geom_mode)); - global_coords[5] = mul(local_to_global, uv_to_xyz(vec2(-0.5, -0.5), geom_aspect, geom_mode)); - global_coords[6] = mul(local_to_global, uv_to_xyz(vec2(0.5, -0.5), geom_aspect, geom_mode)); - global_coords[7] = mul(local_to_global, uv_to_xyz(vec2(-0.5, 0.5), geom_aspect, geom_mode)); - global_coords[8] = mul(local_to_global, uv_to_xyz(vec2(0.5, 0.5), geom_aspect, geom_mode)); - // Adding more inner image points could help in extreme cases, but too many - // points will kille the framerate. For safety, default to the initial - // eye_pos if any z coords are negative: - float num_negative_z_coords = 0.0; - for(int i = 0; i < num_points; i++) - { - num_negative_z_coords += float(global_coords[0].z < 0.0); - } - // Outsource the optimized eye_pos calculation: - return num_negative_z_coords > 0.5 ? eye_pos : - get_ideal_global_eye_pos_for_points(eye_pos, geom_aspect, - global_coords, num_points); -} - -mat3x3 get_pixel_to_object_matrix(const mat3x3 global_to_local, - const vec3 eye_pos_local, const vec3 view_vec_global, - const vec3 intersection_pos_local, const vec3 normal, - const vec2 output_size_inv) -{ - // Requires: See get_curved_video_uv_coords_and_tangent_matrix for - // descriptions of each parameter. - // Returns: Return a transformation matrix from 2D pixel-space vectors - // (where (+1.0, +1.0) is a vector to one pixel down-right, - // i.e. same directionality as uv texels) to 3D object-space - // vectors in the CRT's local coordinate frame (right-handed) - // ***which are tangent to the CRT surface at the intersection - // position.*** (Basically, we want to convert pixel-space - // vectors to 3D vectors along the CRT's surface, for later - // conversion to uv vectors.) - // Shorthand inputs: - const vec3 pos = intersection_pos_local; - const vec3 eye_pos = eye_pos_local; - // Get a piecewise-linear matrix transforming from "pixelspace" offset - // vectors (1.0 = one pixel) to object space vectors in the tangent - // plane (faster than finding 3 view-object intersections). - // 1.) Get the local view vecs for the pixels to the right and down: - const vec3 view_vec_right_global = view_vec_global + - vec3(output_size_inv.x, 0.0, 0.0); - const vec3 view_vec_down_global = view_vec_global + - vec3(0.0, -output_size_inv.y, 0.0); - const vec3 view_vec_right_local = - (view_vec_right_global * global_to_local); - const vec3 view_vec_down_local = - (view_vec_down_global * global_to_local); - // 2.) Using the true intersection point, intersect the neighboring - // view vectors with the tangent plane: - const vec3 intersection_vec_dot_normal = dot(pos - eye_pos, normal); - const vec3 right_pos = eye_pos + (intersection_vec_dot_normal / - dot(view_vec_right_local, normal))*view_vec_right_local; - const vec3 down_pos = eye_pos + (intersection_vec_dot_normal / - dot(view_vec_down_local, normal))*view_vec_down_local; - // 3.) Subtract the original intersection pos from its neighbors; the - // resulting vectors are object-space vectors tangent to the plane. - // These vectors are the object-space transformations of (1.0, 0.0) - // and (0.0, 1.0) pixel offsets, so they form the first two basis - // vectors of a pixelspace to object space transformation. This - // transformation is 2D to 3D, so use (0, 0, 0) for the third vector. - const vec3 object_right_vec = right_pos - pos; - const vec3 object_down_vec = down_pos - pos; - const vec3x3 pixel_to_object = vec3x3( - object_right_vec.x, object_down_vec.x, 0.0, - object_right_vec.y, object_down_vec.y, 0.0, - object_right_vec.z, object_down_vec.z, 0.0); - return pixel_to_object; -} - -mat3x3 get_object_to_tangent_matrix(const vec3 intersection_pos_local, - const vec3 normal, const vec2 geom_aspect, const float geom_mode) -{ - // Requires: See get_curved_video_uv_coords_and_tangent_matrix for - // descriptions of each parameter. - // Returns: Return a transformation matrix from 3D object-space vectors - // in the CRT's local coordinate frame (right-handed, +y = up) - // to 2D video_uv vectors (+v = down). - // Description: - // The TBN matrix formed by the [tangent, bitangent, normal] basis - // vectors transforms ordinary vectors from tangent->object space. - // The cotangent matrix formed by the [cotangent, cobitangent, normal] - // basis vectors transforms normal vectors (covectors) from - // tangent->object space. It's the inverse-transpose of the TBN matrix. - // We want the inverse of the TBN matrix (transpose of the cotangent - // matrix), which transforms ordinary vectors from object->tangent space. - // Start by calculating the relevant basis vectors in accordance with - // Christian Schüler's blog post "Followup: Normal Mapping Without - // Precomputed Tangents": http://www.thetenthplanet.de/archives/1180 - // With our particular uv mapping, the scale of the u and v directions - // is determined entirely by the aspect ratio for cylindrical and ordinary - // spherical mappings, and so tangent and bitangent lengths are also - // determined by it (the alternate mapping is more complex). Therefore, we - // must ensure appropriate cotangent and cobitangent lengths as well. - // Base these off the uv<=>xyz mappings for each primitive. - const vec3 pos = intersection_pos_local; - const vec3 x_vec = vec3(1.0, 0.0, 0.0); - const vec3 y_vec = vec3(0.0, 1.0, 0.0); - // The tangent and bitangent vectors correspond with increasing u and v, - // respectively. Mathematically we'd base the cotangent/cobitangent on - // those, but we'll compute the cotangent/cobitangent directly when we can. - vec3 cotangent_unscaled, cobitangent_unscaled; - // geom_mode should be constant-folded without RUNTIME_GEOMETRY_MODE. - if(geom_mode < 1.5) - { - // Sphere: - // tangent = normalize(cross(normal, cross(x_vec, pos))) * geom_aspect.x - // bitangent = normalize(cross(cross(y_vec, pos), normal)) * geom_aspect.y - // inv_determinant = 1.0/length(cross(bitangent, tangent)) - // cotangent = cross(normal, bitangent) * inv_determinant - // == normalize(cross(y_vec, pos)) * geom_aspect.y * inv_determinant - // cobitangent = cross(tangent, normal) * inv_determinant - // == normalize(cross(x_vec, pos)) * geom_aspect.x * inv_determinant - // Simplified (scale by inv_determinant below): - cotangent_unscaled = normalize(cross(y_vec, pos)) * geom_aspect.y; - cobitangent_unscaled = normalize(cross(x_vec, pos)) * geom_aspect.x; - } - else if(geom_mode < 2.5) - { - // Sphere, alternate mapping: - // This mapping works a bit like the cylindrical mapping in two - // directions, which makes the lengths and directions more complex. - // Unfortunately, I can't find much of a shortcut: - const vec3 tangent = normalize( - cross(y_vec, vec3(pos.x, 0.0, pos.z))) * geom_aspect.x; - const vec3 bitangent = normalize( - cross(x_vec, vec3(0.0, pos.yz))) * geom_aspect.y; - cotangent_unscaled = cross(normal, bitangent); - cobitangent_unscaled = cross(tangent, normal); - } - else - { - // Cylinder: - // tangent = normalize(cross(y_vec, normal)) * geom_aspect.x; - // bitangent = vec3(0.0, -geom_aspect.y, 0.0); - // inv_determinant = 1.0/length(cross(bitangent, tangent)) - // cotangent = cross(normal, bitangent) * inv_determinant - // == normalize(cross(y_vec, pos)) * geom_aspect.y * inv_determinant - // cobitangent = cross(tangent, normal) * inv_determinant - // == vec3(0.0, -geom_aspect.x, 0.0) * inv_determinant - cotangent_unscaled = cross(y_vec, normal) * geom_aspect.y; - cobitangent_unscaled = vec3(0.0, -geom_aspect.x, 0.0); - } - const vec3 computed_normal = - cross(cobitangent_unscaled, cotangent_unscaled); - const float inv_determinant = rsqrt(dot(computed_normal, computed_normal)); - const vec3 cotangent = cotangent_unscaled * inv_determinant; - const vec3 cobitangent = cobitangent_unscaled * inv_determinant; - // The [cotangent, cobitangent, normal] column vecs form the cotangent - // frame, i.e. the inverse-transpose TBN matrix. Get its transpose: - const mat3x3 object_to_tangent = mat3x3(cotangent, cobitangent, normal); - return object_to_tangent; -} - -vec2 get_curved_video_uv_coords_and_tangent_matrix( - const vec2 flat_video_uv, const vec3 eye_pos_local, - const vec2 output_size_inv, const vec2 geom_aspect, - const float geom_mode, const mat3x3 global_to_local, - out mat2x2 pixel_to_tangent_video_uv) -{ - // Requires: Parameters: - // 1.) flat_video_uv coords are in range [0.0, 1.0], where - // (0.0, 0.0) is the top-left corner of the screen and - // (1.0, 1.0) is the bottom-right corner. - // 2.) eye_pos_local is the 3D camera position in the simulated - // CRT's local coordinate frame. For best results, it must - // be computed based on the same geom_view_dist used here. - // 3.) output_size_inv = vec2(1.0)/IN.output_size - // 4.) geom_aspect = get_aspect_vector( - // IN.output_size.x / IN.output_size.y); - // 5.) geom_mode is a static or runtime mode setting: - // 0 = off, 1 = sphere, 2 = sphere alt., 3 = cylinder - // 6.) global_to_local is a 3x3 matrix transforming (ordinary) - // worldspace vectors to the CRT's local coordinate frame - // Globals: - // 1.) geom_view_dist must be > 0.0. It controls the "near - // plane" used to interpret flat_video_uv as a view - // vector, which controls the field of view (FOV). - // Returns: Return final uv coords in [0.0, 1.0], and return a pixel- - // space to video_uv tangent-space matrix in the out parameter. - // (This matrix assumes pixel-space +y = down, like +v = down.) - // We'll transform flat_video_uv into a view vector, project - // the view vector from the camera/eye, intersect with a sphere - // or cylinder representing the simulated CRT, and convert the - // intersection position into final uv coords and a local - // transformation matrix. - // First get the 3D view vector (geom_aspect and geom_view_dist are globals): - // 1.) Center uv around (0.0, 0.0) and make (-0.5, -0.5) and (0.5, 0.5) - // correspond to the top-left/bottom-right output screen corners. - // 2.) Multiply by geom_aspect to preemptively "undo" Retroarch's screen- - // space 2D aspect correction. We'll reapply it in uv-space. - // 3.) (x, y) = (u, -v), because +v is down in 2D screenspace, but +y - // is up in 3D worldspace (enforce a right-handed system). - // 4.) The view vector z controls the "near plane" distance and FOV. - // For the effect of "looking through a window" at a CRT, it should be - // set equal to the user's distance from their physical screen, in - // units of the viewport's physical diagonal size. - const vec2 view_uv = (flat_video_uv - vec2(0.5)) * geom_aspect; - const vec3 view_vec_global = - vec3(view_uv.x, -view_uv.y, -geom_view_dist); - // Transform the view vector into the CRT's local coordinate frame, convert - // to video_uv coords, and get the local 3D intersection position: - const vec3 view_vec_local = mul(global_to_local, view_vec_global); - vec3 pos; - const vec2 centered_uv = view_vec_to_uv( - view_vec_local, eye_pos_local, geom_aspect, geom_mode, pos); - const vec2 video_uv = centered_uv + vec2(0.5); - // Get a pixel-to-tangent-video-uv matrix. The caller could deal with - // all but one of these cases, but that would be more complicated. - #ifdef DRIVERS_ALLOW_DERIVATIVES - // Derivatives obtain a matrix very fast, but the direction of pixel- - // space +y seems to depend on the pass. Enforce the correct direction - // on a best-effort basis (but it shouldn't matter for antialiasing). - const vec2 duv_dx = ddx(video_uv); - const vec2 duv_dy = ddy(video_uv); - #ifdef LAST_PASS - pixel_to_tangent_video_uv = vec2x2( - duv_dx.x, duv_dy.x, - -duv_dx.y, -duv_dy.y); - #else - pixel_to_tangent_video_uv = vec2x2( - duv_dx.x, duv_dy.x, - duv_dx.y, duv_dy.y); - #endif - #else - // Manually define a transformation matrix. We'll assume pixel-space - // +y = down, just like +v = down. - if(geom_force_correct_tangent_matrix) - { - // Get the surface normal based on the local intersection position: - const vec3 normal_base = geom_mode < 2.5 ? pos : - vec3(pos.x, 0.0, pos.z); - const vec3 normal = normalize(normal_base); - // Get pixel-to-object and object-to-tangent matrices and combine - // them into a 2x2 pixel-to-tangent matrix for video_uv offsets: - const vec3x3 pixel_to_object = get_pixel_to_object_matrix( - global_to_local, eye_pos_local, view_vec_global, pos, normal, - output_size_inv); - const vec3x3 object_to_tangent = get_object_to_tangent_matrix( - pos, normal, geom_aspect, geom_mode); - const vec3x3 pixel_to_tangent3x3 = - mul(object_to_tangent, pixel_to_object); - pixel_to_tangent_video_uv = vec2x2( - pixel_to_tangent3x3._m00_m01_m10_m11); - } - else - { - // Ignore curvature, and just consider flat scaling. The - // difference is only apparent with strong curvature: - pixel_to_tangent_video_uv = vec2x2( - output_size_inv.x, 0.0, 0.0, output_size_inv.y); - } - #endif - return video_uv; -} - -float get_border_dim_factor(const vec2 video_uv, const vec2 geom_aspect) -{ - // COPYRIGHT NOTE FOR THIS FUNCTION: - // Copyright (C) 2010-2012 cgwg, 2014 TroggleMonkey - // This function uses an algorithm first coded in several of cgwg's GPL- - // licensed lines in crt-geom-curved.cg and its ancestors. The line - // between algorithm and code is nearly indistinguishable here, so it's - // unclear whether I could even release this project under a non-GPL - // license with this function included. - - // Calculate border_dim_factor from the proximity to uv-space image - // borders; geom_aspect/border_size/border/darkness/border_compress are globals: - const vec2 edge_dists = min(video_uv, vec2(1.0) - video_uv) * - geom_aspect; - const vec2 border_penetration = - max(vec2(border_size) - edge_dists, vec2(0.0)); - const float penetration_ratio = length(border_penetration)/border_size; - const float border_escape_ratio = max(1.0 - penetration_ratio, 0.0); - const float border_dim_factor = - pow(border_escape_ratio, border_darkness) * max(1.0, border_compress); - return min(border_dim_factor, 1.0); -} - - - -#endif // GEOMETRY_FUNCTIONS_H - - - diff --git a/crt/shaders/crt-royale/src/geometry-functions.h b/crt/shaders/crt-royale/src/geometry-functions.h index 90b3e28..2d0e0cc 100644 --- a/crt/shaders/crt-royale/src/geometry-functions.h +++ b/crt/shaders/crt-royale/src/geometry-functions.h @@ -659,4 +659,27 @@ vec2 get_curved_video_uv_coords_and_tangent_matrix( return video_uv; } +float get_border_dim_factor(const vec2 video_uv, const vec2 geom_aspect) +{ + // COPYRIGHT NOTE FOR THIS FUNCTION: + // Copyright (C) 2010-2012 cgwg, 2014 TroggleMonkey + // This function uses an algorithm first coded in several of cgwg's GPL- + // licensed lines in crt-geom-curved.cg and its ancestors. The line + // between algorithm and code is nearly indistinguishable here, so it's + // unclear whether I could even release this project under a non-GPL + // license with this function included. + + // Calculate border_dim_factor from the proximity to uv-space image + // borders; geom_aspect/border_size/border/darkness/border_compress are globals: + const vec2 edge_dists = min(video_uv, vec2(1.0) - video_uv) * + geom_aspect; + const vec2 border_penetration = + max(vec2(border_size) - edge_dists, vec2(0.0)); + const float penetration_ratio = length(border_penetration)/border_size; + const float border_escape_ratio = max(1.0 - penetration_ratio, 0.0); + const float border_dim_factor = + pow(border_escape_ratio, border_darkness) * max(1.0, border_compress); + return min(border_dim_factor, 1.0); +} + #endif // GEOMETRY_FUNCTIONS_H \ No newline at end of file diff --git a/crt/shaders/crt-royale/src/includes.h b/crt/shaders/crt-royale/src/includes.h deleted file mode 100644 index 2b7c7c2..0000000 --- a/crt/shaders/crt-royale/src/includes.h +++ /dev/null @@ -1,11 +0,0 @@ -#define INCLUDES - -#include "../user-settings.h" -#include "derived-settings-and-constants.h" -#include "special-functions.h" //#include "../../../../include/special-functions.h" <-move includes into crt-royale's src directory until it's actually working -#include "bind-shader-params.h" -#include "gamma-management.h" //#include "../../../../include/gamma-management.h" <-move includes into crt-royale's src directory until it's actually working -#include "blur-functions.h" //#include "../../../../include/blur-functions.h" <-move includes into crt-royale's src directory until it's actually working -#include "scanline-functions.h" -#include "bloom-functions.h" -//#include "phosphor-mask-resizing.h" \ No newline at end of file diff --git a/crt/shaders/crt-royale/src/phosphor-mask-resizing-old.h b/crt/shaders/crt-royale/src/phosphor-mask-resizing-old.h deleted file mode 100644 index 4d28aed..0000000 --- a/crt/shaders/crt-royale/src/phosphor-mask-resizing-old.h +++ /dev/null @@ -1,678 +0,0 @@ -#ifndef PHOSPHOR_MASK_RESIZING_H -#define PHOSPHOR_MASK_RESIZING_H - -///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// - -// crt-royale: A full-featured CRT shader, with cheese. -// Copyright (C) 2014 TroggleMonkey -// -// This program is free software; you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation; either version 2 of the License, or any later version. -// -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. -// -// You should have received a copy of the GNU General Public License along with -// this program; if not, write to the Free Software Foundation, Inc., 59 Temple -// Place, Suite 330, Boston, MA 02111-1307 USA - - -////////////////////////////////// INCLUDES ////////////////////////////////// - -//#include "../user-settings.h" -//#include "derived-settings-and-constants.h" -#include "includes.h" - -///////////////////////////// CODEPATH SELECTION ///////////////////////////// - -// Choose a looping strategy based on what's allowed: -// Dynamic loops not allowed: Use a flat static loop. -// Dynamic loops accomodated: Coarsely branch around static loops. -// Dynamic loops assumed allowed: Use a flat dynamic loop. -#ifndef DRIVERS_ALLOW_DYNAMIC_BRANCHES - #ifdef ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS - #define BREAK_LOOPS_INTO_PIECES - #else - #define USE_SINGLE_STATIC_LOOP - #endif -#endif // No else needed: Dynamic loops assumed. - - -////////////////////////////////// CONSTANTS ///////////////////////////////// - -// The larger the resized tile, the fewer samples we'll need for downsizing. -// See if we can get a static min tile size > mask_min_allowed_tile_size: -const float mask_min_allowed_tile_size = ceil( - mask_min_allowed_triad_size * mask_triads_per_tile); -const float mask_min_expected_tile_size = - mask_min_allowed_tile_size; -// Limit the number of sinc resize taps by the maximum minification factor: -const float pi_over_lobes = pi/mask_sinc_lobes; -const float max_sinc_resize_samples_float = 2.0 * mask_sinc_lobes * - mask_resize_src_lut_size.x/mask_min_expected_tile_size; -// Vectorized loops sample in multiples of 4. Round up to be safe: -const float max_sinc_resize_samples_m4 = ceil( - max_sinc_resize_samples_float * 0.25) * 4.0; - - -///////////////////////// RESAMPLING FUNCTION HELPERS //////////////////////// - -float get_dynamic_loop_size(const float magnification_scale) -{ - // Requires: The following global constants must be defined: - // 1.) mask_sinc_lobes - // 2.) max_sinc_resize_samples_m4 - // Returns: The minimum number of texture samples for a correct downsize - // at magnification_scale. - // We're downsizing, so the filter is sized across 2*lobes output pixels - // (not 2*lobes input texels). This impacts distance measurements and the - // minimum number of input samples needed. - const float min_samples_float = 2.0 * mask_sinc_lobes / magnification_scale; - const float min_samples_m4 = ceil(min_samples_float * 0.25) * 4.0; - #ifdef DRIVERS_ALLOW_DYNAMIC_BRANCHES - const float max_samples_m4 = max_sinc_resize_samples_m4; - #else // ifdef BREAK_LOOPS_INTO_PIECES - // Simulating loops with branches imposes a 128-sample limit. - const float max_samples_m4 = min(128.0, max_sinc_resize_samples_m4); - #endif - return min(min_samples_m4, max_samples_m4); -} - -vec2 get_first_texel_tile_uv_and_dist(const vec2 tex_uv, - const vec2 texture_size, const float dr, - const float input_tiles_per_texture_r, const float samples, - const bool vertical) -{ - // Requires: 1.) dr == du == 1.0/texture_size.x or - // dr == dv == 1.0/texture_size.y - // (whichever direction we're resampling in). - // It's a scalar to save register space. - // 2.) input_tiles_per_texture_r is the number of input tiles - // that can fit in the input texture in the direction we're - // resampling this pass. - // 3.) vertical indicates whether we're resampling vertically - // this pass (or horizontally). - // Returns: Pack and return the first sample's tile_uv coord in [0, 1] - // and its texel distance from the destination pixel, in the - // resized dimension only. - // We'll start with the topmost or leftmost sample and work down or right, - // so get the first sample location and distance. Modify both dimensions - // as if we're doing a one-pass 2D resize; we'll throw away the unneeded - // (and incorrect) dimension at the end. - const vec2 curr_texel = tex_uv * texture_size; - const vec2 prev_texel = - floor(curr_texel - vec2(under_half)) + vec2(0.5); - const vec2 first_texel = prev_texel - vec2(samples/2.0 - 1.0); - const vec2 first_texel_uv_wrap_2D = first_texel * dr; - const vec2 first_texel_dist_2D = curr_texel - first_texel; - // Convert from tex_uv to tile_uv coords so we can sub fracts for fmods. - const vec2 first_texel_tile_uv_wrap_2D = - first_texel_uv_wrap_2D * input_tiles_per_texture_r; - // Project wrapped coordinates to the [0, 1] range. We'll do this with all - // samples,but the first texel is special, since it might be negative. - const vec2 coord_negative = - vec2(first_texel_tile_uv_wrap_2D < vec2(0.0)); - const vec2 first_texel_tile_uv_2D = - fract(first_texel_tile_uv_wrap_2D) + coord_negative; - // Pack the first texel's tile_uv coord and texel distance in 1D: - const vec2 tile_u_and_dist = - vec2(first_texel_tile_uv_2D.x, first_texel_dist_2D.x); - const vec2 tile_v_and_dist = - vec2(first_texel_tile_uv_2D.y, first_texel_dist_2D.y); - return vertical ? tile_v_and_dist : tile_u_and_dist; - //return mix(tile_u_and_dist, tile_v_and_dist, float(vertical)); -} - -vec4 tex2Dlod0try(const sampler2D tex, const vec2 tex_uv) -{ - // Mipmapping and anisotropic filtering get confused by sinc-resampling. - // One [slow] workaround is to select the lowest mip level: - #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD - return tex2Dlod(tex, vec4(tex_uv, 0.0, 0.0)); - #else - #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS - return tex2Dbias(tex, vec4(tex_uv, 0.0, -16.0)); - #else - return texture(tex, tex_uv); - #endif - #endif -} - - -////////////////////////////// LOOP BODY MACROS ////////////////////////////// - -// Using inline functions can exceed the temporary register limit, so we're -// stuck with #define macros (I'm TRULY sorry). They're declared here instead -// of above to be closer to the actual invocation sites. Steps: -// 1.) Get the exact texel location. -// 2.) Sample the phosphor mask (already assumed encoded in linear RGB). -// 3.) Get the distance from the current pixel and sinc weight: -// sinc(dist) = sin(pi * dist)/(pi * dist) -// We can also use the slower/smoother Lanczos instead: -// L(x) = sinc(dist) * sinc(dist / lobes) -// 4.) Accumulate the weight sum in weights, and accumulate the weighted texels -// in pixel_color (we'll normalize outside the loop at the end). -// We vectorize the loop to help reduce the Lanczos window's cost. - - // The r coord is the coord in the dimension we're resizing along (u or v), - // and first_texel_tile_uv_rrrr is a vec4 of the first texel's u or v - // tile_uv coord in [0, 1]. tex_uv_r will contain the tile_uv u or v coord - // for four new texel samples. - #define CALCULATE_R_COORD_FOR_4_SAMPLES \ - const vec4 true_i = vec4(i_base + i) + vec4(0.0, 1.0, 2.0, 3.0); \ - const vec4 tile_uv_r = fract( \ - first_texel_tile_uv_rrrr + true_i * tile_dr); \ - const vec4 tex_uv_r = tile_uv_r * tile_size_uv_r; - - #ifdef PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW - #define CALCULATE_SINC_RESAMPLE_WEIGHTS \ - const vec4 pi_dist_over_lobes = pi_over_lobes * dist; \ - const vec4 weights = min(sin(pi_dist) * sin(pi_dist_over_lobes) /\ - (pi_dist*pi_dist_over_lobes), vec4(1.0)); - #else - #define CALCULATE_SINC_RESAMPLE_WEIGHTS \ - const vec4 weights = min(sin(pi_dist)/pi_dist, vec4(1.0)); - #endif - - #define UPDATE_COLOR_AND_WEIGHT_SUMS \ - const vec4 dist = magnification_scale * \ - abs(first_dist_unscaled - true_i); \ - const vec4 pi_dist = pi * dist; \ - CALCULATE_SINC_RESAMPLE_WEIGHTS; \ - pixel_color += new_sample0 * weights.xxx; \ - pixel_color += new_sample1 * weights.yyy; \ - pixel_color += new_sample2 * weights.zzz; \ - pixel_color += new_sample3 * weights.www; \ - weight_sum += weights; - - #define VERTICAL_SINC_RESAMPLE_LOOP_BODY \ - CALCULATE_R_COORD_FOR_4_SAMPLES; \ - const vec3 new_sample0 = tex2Dlod0try(texture, \ - vec2(tex_uv.x, tex_uv_r.x)).rgb; \ - const vec3 new_sample1 = tex2Dlod0try(texture, \ - vec2(tex_uv.x, tex_uv_r.y)).rgb; \ - const vec3 new_sample2 = tex2Dlod0try(texture, \ - vec2(tex_uv.x, tex_uv_r.z)).rgb; \ - const vec3 new_sample3 = tex2Dlod0try(texture, \ - vec2(tex_uv.x, tex_uv_r.w)).rgb; \ - UPDATE_COLOR_AND_WEIGHT_SUMS; - - #define HORIZONTAL_SINC_RESAMPLE_LOOP_BODY \ - CALCULATE_R_COORD_FOR_4_SAMPLES; \ - const vec3 new_sample0 = tex2Dlod0try(texture, \ - vec2(tex_uv_r.x, tex_uv.y)).rgb; \ - const vec3 new_sample1 = tex2Dlod0try(texture, \ - vec2(tex_uv_r.y, tex_uv.y)).rgb; \ - const vec3 new_sample2 = tex2Dlod0try(texture, \ - vec2(tex_uv_r.z, tex_uv.y)).rgb; \ - const vec3 new_sample3 = tex2Dlod0try(texture, \ - vec2(tex_uv_r.w, tex_uv.y)).rgb; \ - UPDATE_COLOR_AND_WEIGHT_SUMS; - - -//////////////////////////// RESAMPLING FUNCTIONS //////////////////////////// - -vec3 downsample_vertical_sinc_tiled(const sampler2D texture, - const vec2 tex_uv, const vec2 texture_size, const float dr, - const float magnification_scale, const float tile_size_uv_r) -{ - // Requires: 1.) dr == du == 1.0/texture_size.x or - // dr == dv == 1.0/texture_size.y - // (whichever direction we're resampling in). - // It's a scalar to save register space. - // 2.) tile_size_uv_r is the number of texels an input tile - // takes up in the input texture, in the direction we're - // resampling this pass. - // 3.) magnification_scale must be <= 1.0. - // Returns: Return a [Lanczos] sinc-resampled pixel of a vertically - // downsized input tile embedded in an input texture. (The - // vertical version is special-cased though: It assumes the - // tile size equals the [static] texture size, since it's used - // on an LUT texture input containing one tile. For more - // generic use, eliminate the "static" in the parameters.) - // The "r" in "dr," "tile_size_uv_r," etc. refers to the dimension - // we're resizing along, e.g. "dy" in this case. - #ifdef USE_SINGLE_STATIC_LOOP - // A static loop can be faster, but it might blur too much from using - // more samples than it should. - const int samples = int(max_sinc_resize_samples_m4); - #else - const int samples = int(get_dynamic_loop_size(magnification_scale)); - #endif - - // Get the first sample location (scalar tile uv coord along the resized - // dimension) and distance from the output location (in texels): - const float input_tiles_per_texture_r = 1.0/tile_size_uv_r; - // true = vertical resize: - const vec2 first_texel_tile_r_and_dist = get_first_texel_tile_uv_and_dist( - tex_uv, texture_size, dr, input_tiles_per_texture_r, samples, true); - const vec4 first_texel_tile_uv_rrrr = first_texel_tile_r_and_dist.xxxx; - const vec4 first_dist_unscaled = first_texel_tile_r_and_dist.yyyy; - // Get the tile sample offset: - const float tile_dr = dr * input_tiles_per_texture_r; - - // Sum up each weight and weighted sample color, varying the looping - // strategy based on our expected dynamic loop capabilities. See the - // loop body macros above. - int i_base = 0; - vec4 weight_sum = vec4(0.0); - vec3 pixel_color = vec3(0.0); - const int i_step = 4; - #ifdef BREAK_LOOPS_INTO_PIECES - if(samples - i_base >= 64) - { - for(int i = 0; i < 64; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 64; - } - if(samples - i_base >= 32) - { - for(int i = 0; i < 32; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 32; - } - if(samples - i_base >= 16) - { - for(int i = 0; i < 16; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 16; - } - if(samples - i_base >= 8) - { - for(int i = 0; i < 8; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 8; - } - if(samples - i_base >= 4) - { - for(int i = 0; i < 4; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 4; - } - // Do another 4-sample block for a total of 128 max samples. - if(samples - i_base > 0) - { - for(int i = 0; i < 4; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - } - #else - for(int i = 0; i < samples; i += i_step) - { - VERTICAL_SINC_RESAMPLE_LOOP_BODY; - } - #endif - // Normalize so the weight_sum == 1.0, and return: - const vec2 weight_sum_reduce = weight_sum.xy + weight_sum.zw; - const vec3 scalar_weight_sum = vec3(weight_sum_reduce.x + - weight_sum_reduce.y); - return (pixel_color/scalar_weight_sum); -} - -vec3 downsample_horizontal_sinc_tiled(const sampler2D texture, - const vec2 tex_uv, const vec2 texture_size, const float dr, - const float magnification_scale, const float tile_size_uv_r) -{ - // Differences from downsample_horizontal_sinc_tiled: - // 1.) The dr and tile_size_uv_r parameters are not static consts. - // 2.) The "vertical" parameter to get_first_texel_tile_uv_and_dist is - // set to false instead of true. - // 3.) The horizontal version of the loop body is used. - // TODO: If we can get guaranteed compile-time dead code elimination, - // we can combine the vertical/horizontal downsampling functions by: - // 1.) Add an extra static const bool parameter called "vertical." - // 2.) Supply it with the result of get_first_texel_tile_uv_and_dist(). - // 3.) Use a conditional assignment in the loop body macro. This is the - // tricky part: We DO NOT want to incur the extra conditional - // assignment in the inner loop at runtime! - // The "r" in "dr," "tile_size_uv_r," etc. refers to the dimension - // we're resizing along, e.g. "dx" in this case. - #ifdef USE_SINGLE_STATIC_LOOP - // If we have to load all samples, we might as well use them. - const int samples = int(max_sinc_resize_samples_m4); - #else - const int samples = int(get_dynamic_loop_size(magnification_scale)); - #endif - - // Get the first sample location (scalar tile uv coord along resized - // dimension) and distance from the output location (in texels): - const float input_tiles_per_texture_r = 1.0/tile_size_uv_r; - // false = horizontal resize: - const vec2 first_texel_tile_r_and_dist = get_first_texel_tile_uv_and_dist( - tex_uv, texture_size, dr, input_tiles_per_texture_r, samples, false); - const vec4 first_texel_tile_uv_rrrr = first_texel_tile_r_and_dist.xxxx; - const vec4 first_dist_unscaled = first_texel_tile_r_and_dist.yyyy; - // Get the tile sample offset: - const float tile_dr = dr * input_tiles_per_texture_r; - - // Sum up each weight and weighted sample color, varying the looping - // strategy based on our expected dynamic loop capabilities. See the - // loop body macros above. - int i_base = 0; - vec4 weight_sum = vec4(0.0); - vec3 pixel_color = vec3(0.0); - const int i_step = 4; - #ifdef BREAK_LOOPS_INTO_PIECES - if(samples - i_base >= 64) - { - for(int i = 0; i < 64; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 64; - } - if(samples - i_base >= 32) - { - for(int i = 0; i < 32; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 32; - } - if(samples - i_base >= 16) - { - for(int i = 0; i < 16; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 16; - } - if(samples - i_base >= 8) - { - for(int i = 0; i < 8; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 8; - } - if(samples - i_base >= 4) - { - for(int i = 0; i < 4; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - i_base += 4; - } - // Do another 4-sample block for a total of 128 max samples. - if(samples - i_base > 0) - { - for(int i = 0; i < 4; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - } - #else - for(int i = 0; i < samples; i += i_step) - { - HORIZONTAL_SINC_RESAMPLE_LOOP_BODY; - } - #endif - // Normalize so the weight_sum == 1.0, and return: - const vec2 weight_sum_reduce = weight_sum.xy + weight_sum.zw; - const vec3 scalar_weight_sum = vec3(weight_sum_reduce.x + - weight_sum_reduce.y); - return (pixel_color/scalar_weight_sum); -} - - -//////////////////////////// TILE SIZE CALCULATION /////////////////////////// - -vec2 get_resized_mask_tile_size(const vec2 estimated_viewport_size, - const vec2 estimated_mask_resize_output_size, - const bool solemnly_swear_same_inputs_for_every_pass) -{ - // Requires: The following global constants must be defined according to - // certain constraints: - // 1.) mask_resize_num_triads: Must be high enough that our - // mask sampling method won't have artifacts later - // (long story; see derived-settings-and-constants.h) - // 2.) mask_resize_src_lut_size: Texel size of our mask LUT - // 3.) mask_triads_per_tile: Num horizontal triads in our LUT - // 4.) mask_min_allowed_triad_size: User setting (the more - // restrictive it is, the faster the resize will go) - // 5.) mask_min_allowed_tile_size_x < mask_resize_src_lut_size.x - // 6.) mask_triad_size_desired_{runtime, static} - // 7.) mask_num_triads_desired_{runtime, static} - // 8.) mask_specify_num_triads must be 0.0/1.0 (false/true) - // The function parameters must be defined as follows: - // 1.) estimated_viewport_size == (final viewport size); - // If mask_specify_num_triads is 1.0/true and the viewport - // estimate is wrong, the number of triads will differ from - // the user's preference by about the same factor. - // 2.) estimated_mask_resize_output_size: Must equal the - // output size of the MASK_RESIZE pass. - // Exception: The x component may be estimated garbage if - // and only if the caller throws away the x result. - // 3.) solemnly_swear_same_inputs_for_every_pass: Set to false, - // unless you can guarantee that every call across every - // pass will use the same sizes for the other parameters. - // When calling this across multiple passes, always use the - // same y viewport size/scale, and always use the same x - // viewport size/scale when using the x result. - // Returns: Return the final size of a manually resized mask tile, after - // constraining the desired size to avoid artifacts. Under - // unusual circumstances, tiles may become stretched vertically - // (see wall of text below). - // Stated tile properties must be correct: - const float tile_aspect_ratio_inv = - mask_resize_src_lut_size.y/mask_resize_src_lut_size.x; - const float tile_aspect_ratio = 1.0/tile_aspect_ratio_inv; - const vec2 tile_aspect = vec2(1.0, tile_aspect_ratio_inv); - // If mask_specify_num_triads is 1.0/true and estimated_viewport_size.x is - // wrong, the user preference will be misinterpreted: - const float desired_tile_size_x = mask_triads_per_tile * mix( - mask_triad_size_desired, - estimated_viewport_size.x / mask_num_triads_desired, - mask_specify_num_triads); - if(get_mask_sample_mode() > 0.5) - { - // We don't need constraints unless we're sampling MASK_RESIZE. - return desired_tile_size_x * tile_aspect; - } - // Make sure we're not upsizing: - const float temp_tile_size_x = - min(desired_tile_size_x, mask_resize_src_lut_size.x); - // Enforce min_tile_size and max_tile_size in both dimensions: - const vec2 temp_tile_size = temp_tile_size_x * tile_aspect; - const vec2 min_tile_size = - mask_min_allowed_tile_size * tile_aspect; - const vec2 max_tile_size = - estimated_mask_resize_output_size / mask_resize_num_tiles; - const vec2 clamped_tile_size = - clamp(temp_tile_size, min_tile_size, max_tile_size); - // Try to maintain tile_aspect_ratio. This is the tricky part: - // If we're currently resizing in the y dimension, the x components - // could be MEANINGLESS. (If estimated_mask_resize_output_size.x is - // bogus, then so is max_tile_size.x and clamped_tile_size.x.) - // We can't adjust the y size based on clamped_tile_size.x. If it - // clamps when it shouldn't, it won't clamp again when later passes - // call this function with the correct sizes, and the discrepancy will - // break the sampling coords in MASKED_SCANLINES. Instead, we'll limit - // the x size based on the y size, but not vice versa, unless the - // caller swears the parameters were the same (correct) in every pass. - // As a result, triads could appear vertically stretched if: - // a.) mask_resize_src_lut_size.x > mask_resize_src_lut_size.y: Wide - // LUT's might clamp x more than y (all provided LUT's are square) - // b.) true_viewport_size.x < true_viewport_size.y: The user is playing - // with a vertically oriented screen (not accounted for anyway) - // c.) mask_resize_viewport_scale.x < masked_resize_viewport_scale.y: - // Viewport scales are equal by default. - // If any of these are the case, you can fix the stretching by setting: - // mask_resize_viewport_scale.x = mask_resize_viewport_scale.y * - // (1.0 / min_expected_aspect_ratio) * - // (mask_resize_src_lut_size.x / mask_resize_src_lut_size.y) - const float x_tile_size_from_y = - clamped_tile_size.y * tile_aspect_ratio; - const float y_tile_size_from_x = mix(clamped_tile_size.y, - clamped_tile_size.x * tile_aspect_ratio_inv, - float(solemnly_swear_same_inputs_for_every_pass)); - const vec2 reclamped_tile_size = vec2( - min(clamped_tile_size.x, x_tile_size_from_y), - min(clamped_tile_size.y, y_tile_size_from_x)); - // We need integer tile sizes in both directions for tiled sampling to - // work correctly. Use floor (to make sure we don't round up), but be - // careful to avoid a rounding bug where floor decreases whole numbers: - const vec2 final_resized_tile_size = - floor(reclamped_tile_size + vec2(FIX_ZERO(0.0))); - return final_resized_tile_size; -} - - -///////////////////////// FINAL MASK SAMPLING HELPERS //////////////////////// - -vec4 get_mask_sampling_parameters(const vec2 mask_resize_texture_size, - const vec2 mask_resize_video_size, const vec2 true_viewport_size, - out vec2 mask_tiles_per_screen) -{ - // Requires: 1.) Requirements of get_resized_mask_tile_size() must be - // met, particularly regarding global constants. - // The function parameters must be defined as follows: - // 1.) mask_resize_texture_size == MASK_RESIZE.texture_size - // if get_mask_sample_mode() is 0 (otherwise anything) - // 2.) mask_resize_video_size == MASK_RESIZE.video_size - // if get_mask_sample_mode() is 0 (otherwise anything) - // 3.) true_viewport_size == IN.output_size for a pass set to - // 1.0 viewport scale (i.e. it must be correct) - // Returns: Return a vec4 containing: - // xy: tex_uv coords for the start of the mask tile - // zw: tex_uv size of the mask tile from start to end - // mask_tiles_per_screen is an out parameter containing the - // number of mask tiles that will fit on the screen. - // First get the final resized tile size. The viewport size and mask - // resize viewport scale must be correct, but don't solemnly swear they - // were correct in both mask resize passes unless you know it's true. - // (We can better ensure a correct tile aspect ratio if the parameters are - // guaranteed correct in all passes...but if we lie, we'll get inconsistent - // sizes across passes, resulting in broken texture coordinates.) - const float mask_sample_mode = get_mask_sample_mode(); - const vec2 mask_resize_tile_size = get_resized_mask_tile_size( - true_viewport_size, mask_resize_video_size, false); - if(mask_sample_mode < 0.5) - { - // Sample MASK_RESIZE: The resized tile is a fracttion of the texture - // size and starts at a nonzero offset to allow for border texels: - const vec2 mask_tile_uv_size = mask_resize_tile_size / - mask_resize_texture_size; - const vec2 skipped_tiles = mask_start_texels/mask_resize_tile_size; - const vec2 mask_tile_start_uv = skipped_tiles * mask_tile_uv_size; - // mask_tiles_per_screen must be based on the *true* viewport size: - mask_tiles_per_screen = true_viewport_size / mask_resize_tile_size; - return vec4(mask_tile_start_uv, mask_tile_uv_size); - } - else - { - // If we're tiling at the original size (1:1 pixel:texel), redefine a - // "tile" to be the full texture containing many triads. Otherwise, - // we're hardware-resampling an LUT, and the texture truly contains a - // single unresized phosphor mask tile anyway. - const vec2 mask_tile_uv_size = vec2(1.0); - const vec2 mask_tile_start_uv = vec2(0.0); - if(mask_sample_mode > 1.5) - { - // Repeat the full LUT at a 1:1 pixel:texel ratio without resizing: - mask_tiles_per_screen = true_viewport_size/mask_texture_large_size; - } - else - { - // Hardware-resize the original LUT: - mask_tiles_per_screen = true_viewport_size / mask_resize_tile_size; - } - return vec4(mask_tile_start_uv, mask_tile_uv_size); - } -} - -vec2 fix_tiling_discontinuities_normalized(const vec2 tile_uv, - vec2 duv_dx, vec2 duv_dy) -{ - // Requires: 1.) duv_dx == ddx(tile_uv) - // 2.) duv_dy == ddy(tile_uv) - // 3.) tile_uv contains tile-relative uv coords in [0, 1], - // such that (0.5, 0.5) is the center of a tile, etc. - // ("Tile" can mean texture, the video embedded in the - // texture, or some other "tile" embedded in a texture.) - // Returns: Return new tile_uv coords that contain no discontinuities - // across a 2x2 pixel quad. - // Description: - // When uv coords wrap from 1.0 to 0.0, they create a discontinuity in the - // derivatives, which we assume happened if the absolute difference between - // any fragment in a 2x2 block is > ~half a tile. If the current block has - // a u or v discontinuity and the current fragment is in the first half of - // the tile along that axis (i.e. it wrapped from 1.0 to 0.0), add a tile - // to that coord to make the 2x2 block continuous. (It will now have a - // coord > 1.0 in the padding area beyond the tile.) This function takes - // derivatives as parameters so the caller can reuse them. - // In case we're using high-quality (nVidia-style) derivatives, ensure - // diagonically opposite fragments see each other for correctness: - duv_dx = abs(duv_dx) + abs(ddy(duv_dx)); - duv_dy = abs(duv_dy) + abs(ddx(duv_dy)); - const vec2 pixel_in_first_half_tile = vec2(tile_uv < vec2(0.5)); - const vec2 jump_exists = vec2(duv_dx + duv_dy > vec2(0.5)); - return tile_uv + jump_exists * pixel_in_first_half_tile; -} - -vec2 convert_phosphor_tile_uv_wrap_to_tex_uv(const vec2 tile_uv_wrap, - const vec4 mask_tile_start_uv_and_size) -{ - // Requires: 1.) tile_uv_wrap contains tile-relative uv coords, where the - // tile spans from [0, 1], such that (0.5, 0.5) is at the - // tile center. The input coords can range from [0, inf], - // and their fracttional parts map to a repeated tile. - // ("Tile" can mean texture, the video embedded in the - // texture, or some other "tile" embedded in a texture.) - // 2.) mask_tile_start_uv_and_size.xy contains tex_uv coords - // for the start of the embedded tile in the full texture. - // 3.) mask_tile_start_uv_and_size.zw contains the [fracttional] - // tex_uv size of the embedded tile in the full texture. - // Returns: Return tex_uv coords (used for texture sampling) - // corresponding to tile_uv_wrap. - if(get_mask_sample_mode() < 0.5) - { - // Manually repeat the resized mask tile to fill the screen: - // First get fracttional tile_uv coords. Using fract/fmod on coords - // confuses anisotropic filtering; fix it as user options dictate. - // derived-settings-and-constants.h disables incompatible options. - #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE - vec2 tile_uv = fract(tile_uv_wrap * 0.5) * 2.0; - #else - vec2 tile_uv = fract(tile_uv_wrap); - #endif - #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES - const vec2 tile_uv_dx = ddx(tile_uv); - const vec2 tile_uv_dy = ddy(tile_uv); - tile_uv = fix_tiling_discontinuities_normalized(tile_uv, - tile_uv_dx, tile_uv_dy); - #endif - // The tile is embedded in a padded FBO, and it may start at a - // nonzero offset if border texels are used to avoid artifacts: - const vec2 mask_tex_uv = mask_tile_start_uv_and_size.xy + - tile_uv * mask_tile_start_uv_and_size.zw; - return mask_tex_uv; - } - else - { - // Sample from the input phosphor mask texture with hardware tiling. - // If we're tiling at the original size (mode 2), the "tile" is the - // whole texture, and it contains a large number of triads mapped with - // a 1:1 pixel:texel ratio. OTHERWISE, the texture contains a single - // unresized tile. tile_uv_wrap already has correct coords for both! - return tile_uv_wrap; - } -} - - -#endif // PHOSPHOR_MASK_RESIZING_H - diff --git a/crt/shaders/crt-royale/src/phosphor-mask-resizing.h b/crt/shaders/crt-royale/src/phosphor-mask-resizing.h index acde77d..2b71728 100644 --- a/crt/shaders/crt-royale/src/phosphor-mask-resizing.h +++ b/crt/shaders/crt-royale/src/phosphor-mask-resizing.h @@ -22,9 +22,8 @@ ////////////////////////////////// INCLUDES ////////////////////////////////// -//#include "../user-settings.h" -//#include "derived-settings-and-constants.h" -#include "includes.h" +#include "../user-settings.h" +#include "derived-settings-and-constants.h" ///////////////////////////// CODEPATH SELECTION ///////////////////////////// diff --git a/crt/shaders/crt-royale/src/quad-pixel-communication.h b/crt/shaders/crt-royale/src/quad-pixel-communication.h deleted file mode 100644 index 4c3f1cb..0000000 --- a/crt/shaders/crt-royale/src/quad-pixel-communication.h +++ /dev/null @@ -1,243 +0,0 @@ -#ifndef QUAD_PIXEL_COMMUNICATION_H -#define QUAD_PIXEL_COMMUNICATION_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey* -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - -///////////////////////////////// DISCLAIMER ///////////////////////////////// - -// *This code was inspired by "Shader Amortization using Pixel Quad Message -// Passing" by Eric Penner, published in GPU Pro 2, Chapter VI.2. My intent -// is not to plagiarize his fundamentally similar code and assert my own -// copyright, but the algorithmic helper functions require so little code that -// implementations can't vary by much except bugfixes and conventions. I just -// wanted to license my own particular code here to avoid ambiguity and make it -// clear that as far as I'm concerned, people can do as they please with it. - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// Given screen pixel numbers, derive a "quad vector" describing a fragment's -// position in its 2x2 pixel quad. Given that vector, obtain the values of any -// variable at neighboring fragments. -// Requires: Using this file in general requires: -// 1.) ddx() and ddy() are present in the current Cg profile. -// 2.) The GPU driver is using fine/high-quality derivatives. -// Functions will give incorrect results if this is not true, -// so a test function is included. - - -///////////////////// QUAD-PIXEL COMMUNICATION PRIMITIVES //////////////////// - -vec4 get_quad_vector_naive(const vec4 output_pixel_num_wrt_uvxy) -{ - // Requires: Two measures of the current fragment's output pixel number - // in the range ([0, IN.output_size.x), [0, IN.output_size.y)): - // 1.) output_pixel_num_wrt_uvxy.xy increase with uv coords. - // 2.) output_pixel_num_wrt_uvxy.zw increase with screen xy. - // Returns: Two measures of the fragment's position in its 2x2 quad: - // 1.) The .xy components are its 2x2 placement with respect to - // uv direction (the origin (0, 0) is at the top-left): - // top-left = (-1.0, -1.0) top-right = ( 1.0, -1.0) - // bottom-left = (-1.0, 1.0) bottom-right = ( 1.0, 1.0) - // You need this to arrange/weight shared texture samples. - // 2.) The .zw components are its 2x2 placement with respect to - // screen xy direction (IN.position); the origin varies. - // quad_gather needs this measure to work correctly. - // Note: quad_vector.zw = quad_vector.xy * vec2( - // ddx(output_pixel_num_wrt_uvxy.x), - // ddy(output_pixel_num_wrt_uvxy.y)); - // Caveats: This function assumes the GPU driver always starts 2x2 pixel - // quads at even pixel numbers. This assumption can be wrong - // for odd output resolutions (nondeterministically so). - const vec4 pixel_odd = frac(output_pixel_num_wrt_uvxy * 0.5) * 2.0; - const vec4 quad_vector = pixel_odd * 2.0 - vec4(1.0); - return quad_vector; -} - -vec4 get_quad_vector(const vec4 output_pixel_num_wrt_uvxy) -{ - // Requires: Same as get_quad_vector_naive() (see that first). - // Returns: Same as get_quad_vector_naive() (see that first), but it's - // correct even if the 2x2 pixel quad starts at an odd pixel, - // which can occur at odd resolutions. - const vec4 quad_vector_guess = - get_quad_vector_naive(output_pixel_num_wrt_uvxy); - // If quad_vector_guess.zw doesn't increase with screen xy, we know - // the 2x2 pixel quad starts at an odd pixel: - const vec2 odd_start_mirror = 0.5 * vec2(ddx(quad_vector_guess.z), - ddy(quad_vector_guess.w)); - return quad_vector_guess * odd_start_mirror.xyxy; -} - -vec4 get_quad_vector(const vec2 output_pixel_num_wrt_uv) -{ - // Requires: 1.) ddx() and ddy() are present in the current Cg profile. - // 2.) output_pixel_num_wrt_uv must increase with uv coords and - // measure the current fragment's output pixel number in: - // ([0, IN.output_size.x), [0, IN.output_size.y)) - // Returns: Same as get_quad_vector_naive() (see that first), but it's - // correct even if the 2x2 pixel quad starts at an odd pixel, - // which can occur at odd resolutions. - // Caveats: This function requires less information than the version - // taking a vec4, but it's potentially slower. - // Do screen coords increase with or against uv? Get the direction - // with respect to (uv.x, uv.y) for (screen.x, screen.y) in {-1, 1}. - const vec2 screen_uv_mirror = vec2(ddx(output_pixel_num_wrt_uv.x), - ddy(output_pixel_num_wrt_uv.y)); - const vec2 pixel_odd_wrt_uv = frac(output_pixel_num_wrt_uv * 0.5) * 2.0; - const vec2 quad_vector_uv_guess = (pixel_odd_wrt_uv - vec2(0.5)) * 2.0; - const vec2 quad_vector_screen_guess = quad_vector_uv_guess * screen_uv_mirror; - // If quad_vector_screen_guess doesn't increase with screen xy, we know - // the 2x2 pixel quad starts at an odd pixel: - const vec2 odd_start_mirror = 0.5 * vec2(ddx(quad_vector_screen_guess.x), - ddy(quad_vector_screen_guess.y)); - const vec4 quad_vector_guess = vec4( - quad_vector_uv_guess, quad_vector_screen_guess); - return quad_vector_guess * odd_start_mirror.xyxy; -} - -void quad_gather(const vec4 quad_vector, const vec4 curr, - out vec4 adjx, out vec4 adjy, out vec4 diag) -{ - // Requires: 1.) ddx() and ddy() are present in the current Cg profile. - // 2.) The GPU driver is using fine/high-quality derivatives. - // 3.) quad_vector describes the current fragment's location in - // its 2x2 pixel quad using get_quad_vector()'s conventions. - // 4.) curr is any vector you wish to get neighboring values of. - // Returns: Values of an input vector (curr) at neighboring fragments - // adjacent x, adjacent y, and diagonal (via out parameters). - adjx = curr - ddx(curr) * quad_vector.z; - adjy = curr - ddy(curr) * quad_vector.w; - diag = adjx - ddy(adjx) * quad_vector.w; -} - -void quad_gather(const vec4 quad_vector, const vec3 curr, - out vec3 adjx, out vec3 adjy, out vec3 diag) -{ - // vec3 version - adjx = curr - ddx(curr) * quad_vector.z; - adjy = curr - ddy(curr) * quad_vector.w; - diag = adjx - ddy(adjx) * quad_vector.w; -} - -void quad_gather(const vec4 quad_vector, const vec2 curr, - out vec2 adjx, out vec2 adjy, out vec2 diag) -{ - // vec2 version - adjx = curr - ddx(curr) * quad_vector.z; - adjy = curr - ddy(curr) * quad_vector.w; - diag = adjx - ddy(adjx) * quad_vector.w; -} - -vec4 quad_gather(const vec4 quad_vector, const float curr) -{ - // Float version: - // Returns: return.x == current - // return.y == adjacent x - // return.z == adjacent y - // return.w == diagonal - vec4 all = vec4(curr); - all.y = all.x - ddx(all.x) * quad_vector.z; - all.zw = all.xy - ddy(all.xy) * quad_vector.w; - return all; -} - -vec4 quad_gather_sum(const vec4 quad_vector, const vec4 curr) -{ - // Requires: Same as quad_gather() - // Returns: Sum of an input vector (curr) at all fragments in a quad. - vec4 adjx, adjy, diag; - quad_gather(quad_vector, curr, adjx, adjy, diag); - return (curr + adjx + adjy + diag); -} - -vec3 quad_gather_sum(const vec4 quad_vector, const vec3 curr) -{ - // vec3 version: - vec3 adjx, adjy, diag; - quad_gather(quad_vector, curr, adjx, adjy, diag); - return (curr + adjx + adjy + diag); -} - -vec2 quad_gather_sum(const vec4 quad_vector, const vec2 curr) -{ - // vec2 version: - vec2 adjx, adjy, diag; - quad_gather(quad_vector, curr, adjx, adjy, diag); - return (curr + adjx + adjy + diag); -} - -float quad_gather_sum(const vec4 quad_vector, const float curr) -{ - // Float version: - const vec4 all_values = quad_gather(quad_vector, curr); - return (all_values.x + all_values.y + all_values.z + all_values.w); -} - -bool fine_derivatives_working(const vec4 quad_vector, vec4 curr) -{ - // Requires: 1.) ddx() and ddy() are present in the current Cg profile. - // 2.) quad_vector describes the current fragment's location in - // its 2x2 pixel quad using get_quad_vector()'s conventions. - // 3.) curr must be a test vector with non-constant derivatives - // (its value should change nonlinearly across fragments). - // Returns: true if fine/hybrid/high-quality derivatives are used, or - // false if coarse derivatives are used or inconclusive - // Usage: Test whether quad-pixel communication is working! - // Method: We can confirm fine derivatives are used if the following - // holds (ever, for any value at any fragment): - // (ddy(curr) != ddy(adjx)) or (ddx(curr) != ddx(adjy)) - // The more values we test (e.g. test a vec4 two ways), the - // easier it is to demonstrate fine derivatives are working. - // TODO: Check for floating point exact comparison issues! - vec4 ddx_curr = ddx(curr); - vec4 ddy_curr = ddy(curr); - vec4 adjx = curr - ddx_curr * quad_vector.z; - vec4 adjy = curr - ddy_curr * quad_vector.w; - bool ddy_different = any(ddy_curr != ddy(adjx)); - bool ddx_different = any(ddx_curr != ddx(adjy)); - return any(bool2(ddy_different, ddx_different)); -} - -bool fine_derivatives_working_fast(const vec4 quad_vector, float curr) -{ - // Requires: Same as fine_derivatives_working() - // Returns: Same as fine_derivatives_working() - // Usage: This is faster than fine_derivatives_working() but more - // likely to return false negatives, so it's less useful for - // offline testing/debugging. It's also useless as the basis - // for dynamic runtime branching as of May 2014: Derivatives - // (and quad-pixel communication) are currently disallowed in - // branches. However, future GPU's may allow you to use them - // in dynamic branches if you promise the branch condition - // evaluates the same for every fragment in the quad (and/or if - // the driver enforces that promise by making a single fragment - // control branch decisions). If that ever happens, this - // version may become a more economical choice. - float ddx_curr = ddx(curr); - float ddy_curr = ddy(curr); - float adjx = curr - ddx_curr * quad_vector.z; - return (ddy_curr != ddy(adjx)); -} - -#endif // QUAD_PIXEL_COMMUNICATION_H - diff --git a/crt/shaders/crt-royale/src/scanline-functions-old.h b/crt/shaders/crt-royale/src/scanline-functions-old.h deleted file mode 100644 index d71a500..0000000 --- a/crt/shaders/crt-royale/src/scanline-functions-old.h +++ /dev/null @@ -1,572 +0,0 @@ -#ifndef SCANLINE_FUNCTIONS_H -#define SCANLINE_FUNCTIONS_H - -///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// - -// crt-royale: A full-featured CRT shader, with cheese. -// Copyright (C) 2014 TroggleMonkey -// -// This program is free software; you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation; either version 2 of the License, or any later version. -// -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. -// -// You should have received a copy of the GNU General Public License along with -// this program; if not, write to the Free Software Foundation, Inc., 59 Temple -// Place, Suite 330, Boston, MA 02111-1307 USA - - -////////////////////////////////// INCLUDES ////////////////////////////////// - -#include "../user-settings.h" -#include "derived-settings-and-constants.h" -#include "../../../../include/special-functions.h" -#include "../../../../include/gamma-management.h" - - -///////////////////////////// SCANLINE FUNCTIONS ///////////////////////////// -/* -inline float3 get_gaussian_sigma(const float3 color, const float sigma_range) -{ - // Requires: Globals: - // 1.) beam_min_sigma and beam_max_sigma are global floats - // containing the desired minimum and maximum beam standard - // deviations, for dim and bright colors respectively. - // 2.) beam_max_sigma must be > 0.0 - // 3.) beam_min_sigma must be in (0.0, beam_max_sigma] - // 4.) beam_spot_power must be defined as a global float. - // Parameters: - // 1.) color is the underlying source color along a scanline - // 2.) sigma_range = beam_max_sigma - beam_min_sigma; we take - // sigma_range as a parameter to avoid repeated computation - // when beam_{min, max}_sigma are runtime shader parameters - // Optional: Users may set beam_spot_shape_function to 1 to define the - // inner f(color) subfunction (see below) as: - // f(color) = sqrt(1.0 - (color - 1.0)*(color - 1.0)) - // Otherwise (technically, if beam_spot_shape_function < 0.5): - // f(color) = pow(color, beam_spot_power) - // Returns: The standard deviation of the Gaussian beam for "color:" - // sigma = beam_min_sigma + sigma_range * f(color) - // Details/Discussion: - // The beam's spot shape vaguely resembles an aspect-corrected f() in the - // range [0, 1] (not quite, but it's related). f(color) = color makes - // spots look like diamonds, and a spherical function or cube balances - // between variable width and a soft/realistic shape. A beam_spot_power - // > 1.0 can produce an ugly spot shape and more initial clipping, but the - // final shape also differs based on the horizontal resampling filter and - // the phosphor bloom. For instance, resampling horizontally in nonlinear - // light and/or with a sharp (e.g. Lanczos) filter will sharpen the spot - // shape, but a sixth root is still quite soft. A power function (default - // 1.0/3.0 beam_spot_power) is most flexible, but a fixed spherical curve - // has the highest variability without an awful spot shape. - // - // beam_min_sigma affects scanline sharpness/aliasing in dim areas, and its - // difference from beam_max_sigma affects beam width variability. It only - // affects clipping [for pure Gaussians] if beam_spot_power > 1.0 (which is - // a conservative estimate for a more complex constraint). - // - // beam_max_sigma affects clipping and increasing scanline width/softness - // as color increases. The wider this is, the more scanlines need to be - // evaluated to avoid distortion. For a pure Gaussian, the max_beam_sigma - // at which the first unused scanline always has a weight < 1.0/255.0 is: - // num scanlines = 2, max_beam_sigma = 0.2089; distortions begin ~0.34 - // num scanlines = 3, max_beam_sigma = 0.3879; distortions begin ~0.52 - // num scanlines = 4, max_beam_sigma = 0.5723; distortions begin ~0.70 - // num scanlines = 5, max_beam_sigma = 0.7591; distortions begin ~0.89 - // num scanlines = 6, max_beam_sigma = 0.9483; distortions begin ~1.08 - // Generalized Gaussians permit more leeway here as steepness increases. - if(beam_spot_shape_function < 0.5) - { - // Use a power function: - return float3(beam_min_sigma) + sigma_range * - pow(color, beam_spot_power); - } - else - { - // Use a spherical function: - const float3 color_minus_1 = color - float3(1.0); - return float3(beam_min_sigma) + sigma_range * - sqrt(float3(1.0) - color_minus_1*color_minus_1); - } -} - -inline float3 get_generalized_gaussian_beta(const float3 color, - const float shape_range) -{ - // Requires: Globals: - // 1.) beam_min_shape and beam_max_shape are global floats - // containing the desired min/max generalized Gaussian - // beta parameters, for dim and bright colors respectively. - // 2.) beam_max_shape must be >= 2.0 - // 3.) beam_min_shape must be in [2.0, beam_max_shape] - // 4.) beam_shape_power must be defined as a global float. - // Parameters: - // 1.) color is the underlying source color along a scanline - // 2.) shape_range = beam_max_shape - beam_min_shape; we take - // shape_range as a parameter to avoid repeated computation - // when beam_{min, max}_shape are runtime shader parameters - // Returns: The type-I generalized Gaussian "shape" parameter beta for - // the given color. - // Details/Discussion: - // Beta affects the scanline distribution as follows: - // a.) beta < 2.0 narrows the peak to a spike with a discontinuous slope - // b.) beta == 2.0 just degenerates to a Gaussian - // c.) beta > 2.0 flattens and widens the peak, then drops off more steeply - // than a Gaussian. Whereas high sigmas widen and soften peaks, high - // beta widen and sharpen peaks at the risk of aliasing. - // Unlike high beam_spot_powers, high beam_shape_powers actually soften shape - // transitions, whereas lower ones sharpen them (at the risk of aliasing). - return beam_min_shape + shape_range * pow(color, beam_shape_power); -} - -float3 scanline_gaussian_integral_contrib(const float3 dist, - const float3 color, const float pixel_height, const float sigma_range) -{ - // Requires: 1.) dist is the distance of the [potentially separate R/G/B] - // point(s) from a scanline in units of scanlines, where - // 1.0 means the sample point straddles the next scanline. - // 2.) color is the underlying source color along a scanline. - // 3.) pixel_height is the output pixel height in scanlines. - // 4.) Requirements of get_gaussian_sigma() must be met. - // Returns: Return a scanline's light output over a given pixel. - // Details: - // The CRT beam profile follows a roughly Gaussian distribution which is - // wider for bright colors than dark ones. The integral over the full - // range of a Gaussian function is always 1.0, so we can vary the beam - // with a standard deviation without affecting brightness. 'x' = distance: - // gaussian sample = 1/(sigma*sqrt(2*pi)) * e**(-(x**2)/(2*sigma**2)) - // gaussian integral = 0.5 (1.0 + erf(x/(sigma * sqrt(2)))) - // Use a numerical approximation of the "error function" (the Gaussian - // indefinite integral) to find the definite integral of the scanline's - // average brightness over a given pixel area. Even if curved coords were - // used in this pass, a flat scalar pixel height works almost as well as a - // pixel height computed from a full pixel-space to scanline-space matrix. - const float3 sigma = get_gaussian_sigma(color, sigma_range); - const float3 ph_offset = float3(pixel_height * 0.5); - const float3 denom_inv = 1.0/(sigma*sqrt(2.0)); - const float3 integral_high = erf((dist + ph_offset)*denom_inv); - const float3 integral_low = erf((dist - ph_offset)*denom_inv); - return color * 0.5*(integral_high - integral_low)/pixel_height; -} - -float3 scanline_generalized_gaussian_integral_contrib(const float3 dist, - const float3 color, const float pixel_height, const float sigma_range, - const float shape_range) -{ - // Requires: 1.) Requirements of scanline_gaussian_integral_contrib() - // must be met. - // 2.) Requirements of get_gaussian_sigma() must be met. - // 3.) Requirements of get_generalized_gaussian_beta() must be - // met. - // Returns: Return a scanline's light output over a given pixel. - // A generalized Gaussian distribution allows the shape (beta) to vary - // as well as the width (alpha). "gamma" refers to the gamma function: - // generalized sample = - // beta/(2*alpha*gamma(1/beta)) * e**(-(|x|/alpha)**beta) - // ligamma(s, z) is the lower incomplete gamma function, for which we only - // implement two of four branches (because we keep 1/beta <= 0.5): - // generalized integral = 0.5 + 0.5* sign(x) * - // ligamma(1/beta, (|x|/alpha)**beta)/gamma(1/beta) - // See get_generalized_gaussian_beta() for a discussion of beta. - // We base alpha on the intended Gaussian sigma, but it only strictly - // models models standard deviation at beta == 2, because the standard - // deviation depends on both alpha and beta (keeping alpha independent is - // faster and preserves intuitive behavior and a full spectrum of results). - const float3 alpha = sqrt(2.0) * get_gaussian_sigma(color, sigma_range); - const float3 beta = get_generalized_gaussian_beta(color, shape_range); - const float3 alpha_inv = float3(1.0)/alpha; - const float3 s = float3(1.0)/beta; - const float3 ph_offset = float3(pixel_height * 0.5); - // Pass beta to gamma_impl to avoid repeated divides. Similarly pass - // beta (i.e. 1/s) and 1/gamma(s) to normalized_ligamma_impl. - const float3 gamma_s_inv = float3(1.0)/gamma_impl(s, beta); - const float3 dist1 = dist + ph_offset; - const float3 dist0 = dist - ph_offset; - const float3 integral_high = sign(dist1) * normalized_ligamma_impl( - s, pow(abs(dist1)*alpha_inv, beta), beta, gamma_s_inv); - const float3 integral_low = sign(dist0) * normalized_ligamma_impl( - s, pow(abs(dist0)*alpha_inv, beta), beta, gamma_s_inv); - return color * 0.5*(integral_high - integral_low)/pixel_height; -} - -float3 scanline_gaussian_sampled_contrib(const float3 dist, const float3 color, - const float pixel_height, const float sigma_range) -{ - // See scanline_gaussian integral_contrib() for detailed comments! - // gaussian sample = 1/(sigma*sqrt(2*pi)) * e**(-(x**2)/(2*sigma**2)) - const float3 sigma = get_gaussian_sigma(color, sigma_range); - // Avoid repeated divides: - const float3 sigma_inv = float3(1.0)/sigma; - const float3 inner_denom_inv = 0.5 * sigma_inv * sigma_inv; - const float3 outer_denom_inv = sigma_inv/sqrt(2.0*pi); - if(beam_antialias_level > 0.5) - { - // Sample 1/3 pixel away in each direction as well: - const float3 sample_offset = float3(pixel_height/3.0); - const float3 dist2 = dist + sample_offset; - const float3 dist3 = abs(dist - sample_offset); - // Average three pure Gaussian samples: - const float3 scale = color/3.0 * outer_denom_inv; - const float3 weight1 = exp(-(dist*dist)*inner_denom_inv); - const float3 weight2 = exp(-(dist2*dist2)*inner_denom_inv); - const float3 weight3 = exp(-(dist3*dist3)*inner_denom_inv); - return scale * (weight1 + weight2 + weight3); - } - else - { - return color*exp(-(dist*dist)*inner_denom_inv)*outer_denom_inv; - } -} - -float3 scanline_generalized_gaussian_sampled_contrib(const float3 dist, - const float3 color, const float pixel_height, const float sigma_range, - const float shape_range) -{ - // See scanline_generalized_gaussian_integral_contrib() for details! - // generalized sample = - // beta/(2*alpha*gamma(1/beta)) * e**(-(|x|/alpha)**beta) - const float3 alpha = sqrt(2.0) * get_gaussian_sigma(color, sigma_range); - const float3 beta = get_generalized_gaussian_beta(color, shape_range); - // Avoid repeated divides: - const float3 alpha_inv = float3(1.0)/alpha; - const float3 beta_inv = float3(1.0)/beta; - const float3 scale = color * beta * 0.5 * alpha_inv / - gamma_impl(beta_inv, beta); - if(beam_antialias_level > 0.5) - { - // Sample 1/3 pixel closer to and farther from the scanline too. - const float3 sample_offset = float3(pixel_height/3.0); - const float3 dist2 = dist + sample_offset; - const float3 dist3 = abs(dist - sample_offset); - // Average three generalized Gaussian samples: - const float3 weight1 = exp(-pow(abs(dist*alpha_inv), beta)); - const float3 weight2 = exp(-pow(abs(dist2*alpha_inv), beta)); - const float3 weight3 = exp(-pow(abs(dist3*alpha_inv), beta)); - return scale/3.0 * (weight1 + weight2 + weight3); - } - else - { - return scale * exp(-pow(abs(dist*alpha_inv), beta)); - } -} - -inline float3 scanline_contrib(float3 dist, float3 color, - float pixel_height, const float sigma_range, const float shape_range) -{ - // Requires: 1.) Requirements of scanline_gaussian_integral_contrib() - // must be met. - // 2.) Requirements of get_gaussian_sigma() must be met. - // 3.) Requirements of get_generalized_gaussian_beta() must be - // met. - // Returns: Return a scanline's light output over a given pixel, using - // a generalized or pure Gaussian distribution and sampling or - // integrals as desired by user codepath choices. - if(beam_generalized_gaussian) - { - if(beam_antialias_level > 1.5) - { - return scanline_generalized_gaussian_integral_contrib( - dist, color, pixel_height, sigma_range, shape_range); - } - else - { - return scanline_generalized_gaussian_sampled_contrib( - dist, color, pixel_height, sigma_range, shape_range); - } - } - else - { - if(beam_antialias_level > 1.5) - { - return scanline_gaussian_integral_contrib( - dist, color, pixel_height, sigma_range); - } - else - { - return scanline_gaussian_sampled_contrib( - dist, color, pixel_height, sigma_range); - } - } -} - -inline float3 get_raw_interpolated_color(const float3 color0, - const float3 color1, const float3 color2, const float3 color3, - const float4 weights) -{ - // Use max to avoid bizarre artifacts from negative colors: - return max(mul(weights, float4x3(color0, color1, color2, color3)), 0.0); -} - -float3 get_interpolated_linear_color(const float3 color0, const float3 color1, - const float3 color2, const float3 color3, const float4 weights) -{ - // Requires: 1.) Requirements of include/gamma-management.h must be met: - // intermediate_gamma must be globally defined, and input - // colors are interpreted as linear RGB unless you #define - // GAMMA_ENCODE_EVERY_FBO (in which case they are - // interpreted as gamma-encoded with intermediate_gamma). - // 2.) color0-3 are colors sampled from a texture with tex2D(). - // They are interpreted as defined in requirement 1. - // 3.) weights contains weights for each color, summing to 1.0. - // 4.) beam_horiz_linear_rgb_weight must be defined as a global - // float in [0.0, 1.0] describing how much blending should - // be done in linear RGB (rest is gamma-corrected RGB). - // 5.) RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE must be #defined - // if beam_horiz_linear_rgb_weight is anything other than a - // static constant, or we may try branching at runtime - // without dynamic branches allowed (slow). - // Returns: Return an interpolated color lookup between the four input - // colors based on the weights in weights. The final color will - // be a linear RGB value, but the blending will be done as - // indicated above. - const float intermediate_gamma = get_intermediate_gamma(); - // Branch if beam_horiz_linear_rgb_weight is static (for free) or if the - // profile allows dynamic branches (faster than computing extra pows): - #ifndef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE - #define SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT - #else - #ifdef DRIVERS_ALLOW_DYNAMIC_BRANCHES - #define SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT - #endif - #endif - #ifdef SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT - // beam_horiz_linear_rgb_weight is static, so we can branch: - #ifdef GAMMA_ENCODE_EVERY_FBO - const float3 gamma_mixed_color = pow(get_raw_interpolated_color( - color0, color1, color2, color3, weights), intermediate_gamma); - if(beam_horiz_linear_rgb_weight > 0.0) - { - const float3 linear_mixed_color = get_raw_interpolated_color( - pow(color0, intermediate_gamma), - pow(color1, intermediate_gamma), - pow(color2, intermediate_gamma), - pow(color3, intermediate_gamma), - weights); - return lerp(gamma_mixed_color, linear_mixed_color, - beam_horiz_linear_rgb_weight); - } - else - { - return gamma_mixed_color; - } - #else - const float3 linear_mixed_color = get_raw_interpolated_color( - color0, color1, color2, color3, weights); - if(beam_horiz_linear_rgb_weight < 1.0) - { - const float3 gamma_mixed_color = get_raw_interpolated_color( - pow(color0, 1.0/intermediate_gamma), - pow(color1, 1.0/intermediate_gamma), - pow(color2, 1.0/intermediate_gamma), - pow(color3, 1.0/intermediate_gamma), - weights); - return lerp(gamma_mixed_color, linear_mixed_color, - beam_horiz_linear_rgb_weight); - } - else - { - return linear_mixed_color; - } - #endif // GAMMA_ENCODE_EVERY_FBO - #else - #ifdef GAMMA_ENCODE_EVERY_FBO - // Inputs: color0-3 are colors in gamma-encoded RGB. - const float3 gamma_mixed_color = pow(get_raw_interpolated_color( - color0, color1, color2, color3, weights), intermediate_gamma); - const float3 linear_mixed_color = get_raw_interpolated_color( - pow(color0, intermediate_gamma), - pow(color1, intermediate_gamma), - pow(color2, intermediate_gamma), - pow(color3, intermediate_gamma), - weights); - return lerp(gamma_mixed_color, linear_mixed_color, - beam_horiz_linear_rgb_weight); - #else - // Inputs: color0-3 are colors in linear RGB. - const float3 linear_mixed_color = get_raw_interpolated_color( - color0, color1, color2, color3, weights); - const float3 gamma_mixed_color = get_raw_interpolated_color( - pow(color0, 1.0/intermediate_gamma), - pow(color1, 1.0/intermediate_gamma), - pow(color2, 1.0/intermediate_gamma), - pow(color3, 1.0/intermediate_gamma), - weights); - return lerp(gamma_mixed_color, linear_mixed_color, - beam_horiz_linear_rgb_weight); - #endif // GAMMA_ENCODE_EVERY_FBO - #endif // SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT -} - -float3 get_scanline_color(const sampler2D texture, const float2 scanline_uv, - const float2 uv_step_x, const float4 weights) -{ - // Requires: 1.) scanline_uv must be vertically snapped to the caller's - // desired line or scanline and horizontally snapped to the - // texel just left of the output pixel (color1) - // 2.) uv_step_x must contain the horizontal uv distance - // between texels. - // 3.) weights must contain interpolation filter weights for - // color0, color1, color2, and color3, where color1 is just - // left of the output pixel. - // Returns: Return a horizontally interpolated texture lookup using 2-4 - // nearby texels, according to weights and the conventions of - // get_interpolated_linear_color(). - // We can ignore the outside texture lookups for Quilez resampling. - const float3 color1 = tex2D(texture, scanline_uv).rgb; - const float3 color2 = tex2D(texture, scanline_uv + uv_step_x).rgb; - float3 color0 = float3(0.0); - float3 color3 = float3(0.0); - if(beam_horiz_filter > 0.5) - { - color0 = tex2D(texture, scanline_uv - uv_step_x).rgb; - color3 = tex2D(texture, scanline_uv + 2.0 * uv_step_x).rgb; - } - // Sample the texture as-is, whether it's linear or gamma-encoded: - // get_interpolated_linear_color() will handle the difference. - return get_interpolated_linear_color(color0, color1, color2, color3, weights); -} - -float3 sample_single_scanline_horizontal(const sampler2D texture, - const float2 tex_uv, const float2 texture_size, - const float2 texture_size_inv) -{ - // TODO: Add function requirements. - // Snap to the previous texel and get sample dists from 2/4 nearby texels: - const float2 curr_texel = tex_uv * texture_size; - // Use under_half to fix a rounding bug right around exact texel locations. - const float2 prev_texel = - floor(curr_texel - float2(under_half)) + float2(0.5); - const float2 prev_texel_hor = float2(prev_texel.x, curr_texel.y); - const float2 prev_texel_hor_uv = prev_texel_hor * texture_size_inv; - const float prev_dist = curr_texel.x - prev_texel_hor.x; - const float4 sample_dists = float4(1.0 + prev_dist, prev_dist, - 1.0 - prev_dist, 2.0 - prev_dist); - // Get Quilez, Lanczos2, or Gaussian resize weights for 2/4 nearby texels: - float4 weights; - if(beam_horiz_filter < 0.5) - { - // Quilez: - const float x = sample_dists.y; - const float w2 = x*x*x*(x*(x*6.0 - 15.0) + 10.0); - weights = float4(0.0, 1.0 - w2, w2, 0.0); - } - else if(beam_horiz_filter < 1.5) - { - // Gaussian: - float inner_denom_inv = 1.0/(2.0*beam_horiz_sigma*beam_horiz_sigma); - weights = exp(-(sample_dists*sample_dists)*inner_denom_inv); - } - else - { - // Lanczos2: - const float4 pi_dists = FIX_ZERO(sample_dists * pi); - weights = 2.0 * sin(pi_dists) * sin(pi_dists * 0.5) / - (pi_dists * pi_dists); - } - // Ensure the weight sum == 1.0: - const float4 final_weights = weights/dot(weights, float4(1.0)); - // Get the interpolated horizontal scanline color: - const float2 uv_step_x = float2(texture_size_inv.x, 0.0); - return get_scanline_color( - texture, prev_texel_hor_uv, uv_step_x, final_weights); -} - -float3 sample_rgb_scanline_horizontal(const sampler2D texture, - const float2 tex_uv, const float2 texture_size, - const float2 texture_size_inv) -{ - // TODO: Add function requirements. - // Rely on a helper to make convergence easier. - if(beam_misconvergence) - { - const float3 convergence_offsets_rgb = - get_convergence_offsets_x_vector(); - const float3 offset_u_rgb = - convergence_offsets_rgb * texture_size_inv.xxx; - const float2 scanline_uv_r = tex_uv - float2(offset_u_rgb.r, 0.0); - const float2 scanline_uv_g = tex_uv - float2(offset_u_rgb.g, 0.0); - const float2 scanline_uv_b = tex_uv - float2(offset_u_rgb.b, 0.0); - const float3 sample_r = sample_single_scanline_horizontal( - texture, scanline_uv_r, texture_size, texture_size_inv); - const float3 sample_g = sample_single_scanline_horizontal( - texture, scanline_uv_g, texture_size, texture_size_inv); - const float3 sample_b = sample_single_scanline_horizontal( - texture, scanline_uv_b, texture_size, texture_size_inv); - return float3(sample_r.r, sample_g.g, sample_b.b); - } - else - { - return sample_single_scanline_horizontal(texture, tex_uv, texture_size, - texture_size_inv); - } -} - -float2 get_last_scanline_uv(const float2 tex_uv, const float2 texture_size, - const float2 texture_size_inv, const float2 il_step_multiple, - const float frame_count, out float dist) -{ - // Compute texture coords for the last/upper scanline, accounting for - // interlacing: With interlacing, only consider even/odd scanlines every - // other frame. Top-field first (TFF) order puts even scanlines on even - // frames, and BFF order puts them on odd frames. Texels are centered at: - // frac(tex_uv * texture_size) == x.5 - // Caution: If these coordinates ever seem incorrect, first make sure it's - // not because anisotropic filtering is blurring across field boundaries. - // Note: TFF/BFF won't matter for sources that double-weave or similar. - const float field_offset = floor(il_step_multiple.y * 0.75) * - fmod(frame_count + float(interlace_bff), 2.0); - const float2 curr_texel = tex_uv * texture_size; - // Use under_half to fix a rounding bug right around exact texel locations. - const float2 prev_texel_num = floor(curr_texel - float2(under_half)); - const float wrong_field = fmod( - prev_texel_num.y + field_offset, il_step_multiple.y); - const float2 scanline_texel_num = prev_texel_num - float2(0.0, wrong_field); - // Snap to the center of the previous scanline in the current field: - const float2 scanline_texel = scanline_texel_num + float2(0.5); - const float2 scanline_uv = scanline_texel * texture_size_inv; - // Save the sample's distance from the scanline, in units of scanlines: - dist = (curr_texel.y - scanline_texel.y)/il_step_multiple.y; - return scanline_uv; -} -*/ -bool is_interlaced(float num_lines) -{ - // Detect interlacing based on the number of lines in the source. - if(interlace_detect) - { - // NTSC: 525 lines, 262.5/field; 486 active (2 half-lines), 243/field - // NTSC Emulators: Typically 224 or 240 lines - // PAL: 625 lines, 312.5/field; 576 active (typical), 288/field - // PAL Emulators: ? - // ATSC: 720p, 1080i, 1080p - // Where do we place our cutoffs? Assumptions: - // 1.) We only need to care about active lines. - // 2.) Anything > 288 and <= 576 lines is probably interlaced. - // 3.) Anything > 576 lines is probably not interlaced... - // 4.) ...except 1080 lines, which is a crapshoot (user decision). - // 5.) Just in case the main program uses calculated video sizes, - // we should nudge the float thresholds a bit. - bool sd_interlace; - if (num_lines > 288.5 && num_lines < 576.5) - {sd_interlace = true;} - else - {sd_interlace = false;} - bool hd_interlace; - if (num_lines > 1079.5 && num_lines < 1080.5) - {hd_interlace = false;} - else - {hd_interlace = sd_interlace || hd_interlace;} - } - else - { - return false; - } -} - - -#endif // SCANLINE_FUNCTIONS_H - diff --git a/crt/shaders/crt-royale/src/scanline-functions.h b/crt/shaders/crt-royale/src/scanline-functions.h index 296f201..cb47c9f 100644 --- a/crt/shaders/crt-royale/src/scanline-functions.h +++ b/crt/shaders/crt-royale/src/scanline-functions.h @@ -22,10 +22,10 @@ ////////////////////////////////// INCLUDES ////////////////////////////////// -//#include "../user-settings.h" -//#include "derived-settings-and-constants.h" -//#include "../../../../include/special-functions.h" -//#include "../../../../include/gamma-management.h" +#include "../user-settings.h" +#include "derived-settings-and-constants.h" +#include "../../../../include/special-functions.h" +#include "../../../../include/gamma-management.h" ///////////////////////////// SCANLINE FUNCTIONS ///////////////////////////// diff --git a/crt/shaders/crt-royale/src/special-functions-old.h b/crt/shaders/crt-royale/src/special-functions-old.h deleted file mode 100644 index 839267a..0000000 --- a/crt/shaders/crt-royale/src/special-functions-old.h +++ /dev/null @@ -1,498 +0,0 @@ -#ifndef SPECIAL_FUNCTIONS_H -#define SPECIAL_FUNCTIONS_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file implements the following mathematical special functions: -// 1.) erf() = 2/sqrt(pi) * indefinite_integral(e**(-x**2)) -// 2.) gamma(s), a real-numbered extension of the integer factorial function -// It also implements normalized_ligamma(s, z), a normalized lower incomplete -// gamma function for s < 0.5 only. Both gamma() and normalized_ligamma() can -// be called with an _impl suffix to use an implementation version with a few -// extra precomputed parameters (which may be useful for the caller to reuse). -// See below for details. -// -// Design Rationale: -// Pretty much every line of code in this file is duplicated four times for -// different input types (vec4/vec3/vec2/float). This is unfortunate, -// but Cg doesn't allow function templates. Macros would be far less verbose, -// but they would make the code harder to document and read. I don't expect -// these functions will require a whole lot of maintenance changes unless -// someone ever has need for more robust incomplete gamma functions, so code -// duplication seems to be the lesser evil in this case. - - -/////////////////////////// GAUSSIAN ERROR FUNCTION ////////////////////////// - -vec4 erf6(vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Return an Abramowitz/Stegun approximation of erf(), where: - // erf(x) = 2/sqrt(pi) * integral(e**(-x**2)) - // This approximation has a max absolute error of 2.5*10**-5 - // with solid numerical robustness and efficiency. See: - // https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions - const vec4 one = vec4(1.0); - const vec4 sign_x = sign(x); - const vec4 t = one/(one + 0.47047*abs(x)); - const vec4 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec3 erf6(const vec3 x) -{ - // vec3 version: - const vec3 one = vec3(1.0); - const vec3 sign_x = sign(x); - const vec3 t = one/(one + 0.47047*abs(x)); - const vec3 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec2 erf6(const vec2 x) -{ - // vec2 version: - const vec2 one = vec2(1.0); - const vec2 sign_x = sign(x); - const vec2 t = one/(one + 0.47047*abs(x)); - const vec2 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -float erf6(const float x) -{ - // Float version: - const float sign_x = sign(x); - const float t = 1.0/(1.0 + 0.47047*abs(x)); - const float result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec4 erft(const vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Approximate erf() with the hyperbolic tangent. The error is - // visually noticeable, but it's blazing fast and perceptually - // close...at least on ATI hardware. See: - // http://www.maplesoft.com/applications/view.aspx?SID=5525&view=html - // Warning: Only use this if your hardware drivers correctly implement - // tanh(): My nVidia 8800GTS returns garbage output. - return tanh(1.202760580 * x); -} - -vec3 erft(const vec3 x) -{ - // vec3 version: - return tanh(1.202760580 * x); -} - -vec2 erft(const vec2 x) -{ - // vec2 version: - return tanh(1.202760580 * x); -} - -float erft(const float x) -{ - // Float version: - return tanh(1.202760580 * x); -} - -vec4 erf(const vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Some approximation of erf(x), depending on user settings. - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -vec3 erf(const vec3 x) -{ - // vec3 version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -vec2 erf(const vec2 x) -{ - // vec2 version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -float erf(const float x) -{ - // Float version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - - -/////////////////////////// COMPLETE GAMMA FUNCTION ////////////////////////// - -vec4 gamma_impl(const vec4 s, const vec4 s_inv) -{ - // Requires: 1.) s is the standard parameter to the gamma function, and - // it should lie in the [0, 36] range. - // 2.) s_inv = 1.0/s. This implementation function requires - // the caller to precompute this value, giving users the - // opportunity to reuse it. - // Returns: Return approximate gamma function (real-numbered factorial) - // output using the Lanczos approximation with two coefficients - // calculated using Paul Godfrey's method here: - // http://my.fit.edu/~gabdo/gamma.txt - // An optimal g value for s in [0, 36] is ~1.12906830989, with - // a maximum relative error of 0.000463 for 2**16 equally - // evals. We could use three coeffs (0.0000346 error) without - // hurting latency, but this allows more parallelism with - // outside instructions. - const vec4 g = vec4(1.12906830989); - const vec4 c0 = vec4(0.8109119309638332633713423362694399653724431); - const vec4 c1 = vec4(0.4808354605142681877121661197951496120000040); - const vec4 e = vec4(2.71828182845904523536028747135266249775724709); - const vec4 sph = s + vec4(0.5); - const vec4 lanczos_sum = c0 + c1/(s + vec4(1.0)); - const vec4 base = (sph + g)/e; // or (s + g + vec4(0.5))/e - // gamma(s + 1) = base**sph * lanczos_sum; divide by s for gamma(s). - // This has less error for small s's than (s -= 1.0) at the beginning. - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec3 gamma_impl(const vec3 s, const vec3 s_inv) -{ - // vec3 version: - const vec3 g = vec3(1.12906830989); - const vec3 c0 = vec3(0.8109119309638332633713423362694399653724431); - const vec3 c1 = vec3(0.4808354605142681877121661197951496120000040); - const vec3 e = vec3(2.71828182845904523536028747135266249775724709); - const vec3 sph = s + vec3(0.5); - const vec3 lanczos_sum = c0 + c1/(s + vec3(1.0)); - const vec3 base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec2 gamma_impl(const vec2 s, const vec2 s_inv) -{ - // vec2 version: - const vec2 g = vec2(1.12906830989); - const vec2 c0 = vec2(0.8109119309638332633713423362694399653724431); - const vec2 c1 = vec2(0.4808354605142681877121661197951496120000040); - const vec2 e = vec2(2.71828182845904523536028747135266249775724709); - const vec2 sph = s + vec2(0.5); - const vec2 lanczos_sum = c0 + c1/(s + vec2(1.0)); - const vec2 base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -float gamma_impl(const float s, const float s_inv) -{ - // Float version: - const float g = 1.12906830989; - const float c0 = 0.8109119309638332633713423362694399653724431; - const float c1 = 0.4808354605142681877121661197951496120000040; - const float e = 2.71828182845904523536028747135266249775724709; - const float sph = s + 0.5; - const float lanczos_sum = c0 + c1/(s + 1.0); - const float base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec4 gamma(const vec4 s) -{ - // Requires: s is the standard parameter to the gamma function, and it - // should lie in the [0, 36] range. - // Returns: Return approximate gamma function output with a maximum - // relative error of 0.000463. See gamma_impl for details. - return gamma_impl(s, vec4(1.0)/s); -} - -vec3 gamma(const vec3 s) -{ - // vec3 version: - return gamma_impl(s, vec3(1.0)/s); -} - -vec2 gamma(const vec2 s) -{ - // vec2 version: - return gamma_impl(s, vec2(1.0)/s); -} - -float gamma(const float s) -{ - // Float version: - return gamma_impl(s, 1.0/s); -} - - -//////////////// INCOMPLETE GAMMA FUNCTIONS (RESTRICTED INPUT) /////////////// - -// Lower incomplete gamma function for small s and z (implementation): -vec4 ligamma_small_z_impl(const vec4 s, const vec4 z, const vec4 s_inv) -{ - // Requires: 1.) s < ~0.5 - // 2.) z <= ~0.775075 - // 3.) s_inv = 1.0/s (precomputed for outside reuse) - // Returns: A series representation for the lower incomplete gamma - // function for small s and small z (4 terms). - // The actual "rolled up" summation looks like: - // last_sign = 1.0; last_pow = 1.0; last_factorial = 1.0; - // sum = last_sign * last_pow / ((s + k) * last_factorial) - // for(int i = 0; i < 4; ++i) - // { - // last_sign *= -1.0; last_pow *= z; last_factorial *= i; - // sum += last_sign * last_pow / ((s + k) * last_factorial); - // } - // Unrolled, constant-unfolded and arranged for madds and parallelism: - const vec4 scale = pow(z, s); - vec4 sum = s_inv; // Summation iteration 0 result - // Summation iterations 1, 2, and 3: - const vec4 z_sq = z*z; - const vec4 denom1 = s + vec4(1.0); - const vec4 denom2 = 2.0*s + vec4(4.0); - const vec4 denom3 = 6.0*s + vec4(18.0); - //vec4 denom4 = 24.0*s + vec4(96.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - //sum += z_sq * z_sq / denom4; - // Scale and return: - return scale * sum; -} - -vec3 ligamma_small_z_impl(const vec3 s, const vec3 z, const vec3 s_inv) -{ - // vec3 version: - const vec3 scale = pow(z, s); - vec3 sum = s_inv; - const vec3 z_sq = z*z; - const vec3 denom1 = s + vec3(1.0); - const vec3 denom2 = 2.0*s + vec3(4.0); - const vec3 denom3 = 6.0*s + vec3(18.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -vec2 ligamma_small_z_impl(const vec2 s, const vec2 z, const vec2 s_inv) -{ - // vec2 version: - const vec2 scale = pow(z, s); - vec2 sum = s_inv; - const vec2 z_sq = z*z; - const vec2 denom1 = s + vec2(1.0); - const vec2 denom2 = 2.0*s + vec2(4.0); - const vec2 denom3 = 6.0*s + vec2(18.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -float ligamma_small_z_impl(const float s, const float z, const float s_inv) -{ - // Float version: - const float scale = pow(z, s); - float sum = s_inv; - const float z_sq = z*z; - const float denom1 = s + 1.0; - const float denom2 = 2.0*s + 4.0; - const float denom3 = 6.0*s + 18.0; - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -// Upper incomplete gamma function for small s and large z (implementation): -vec4 uigamma_large_z_impl(const vec4 s, const vec4 z) -{ - // Requires: 1.) s < ~0.5 - // 2.) z > ~0.775075 - // Returns: Gauss's continued fraction representation for the upper - // incomplete gamma function (4 terms). - // The "rolled up" continued fraction looks like this. The denominator - // is truncated, and it's calculated "from the bottom up:" - // denom = vec4('inf'); - // vec4 one = vec4(1.0); - // for(int i = 4; i > 0; --i) - // { - // denom = ((i * 2.0) - one) + z - s + (i * (s - i))/denom; - // } - // Unrolled and constant-unfolded for madds and parallelism: - const vec4 numerator = pow(z, s) * exp(-z); - vec4 denom = vec4(7.0) + z - s; - denom = vec4(5.0) + z - s + (3.0*s - vec4(9.0))/denom; - denom = vec4(3.0) + z - s + (2.0*s - vec4(4.0))/denom; - denom = vec4(1.0) + z - s + (s - vec4(1.0))/denom; - return numerator / denom; -} - -vec3 uigamma_large_z_impl(const vec3 s, const vec3 z) -{ - // vec3 version: - const vec3 numerator = pow(z, s) * exp(-z); - vec3 denom = vec3(7.0) + z - s; - denom = vec3(5.0) + z - s + (3.0*s - vec3(9.0))/denom; - denom = vec3(3.0) + z - s + (2.0*s - vec3(4.0))/denom; - denom = vec3(1.0) + z - s + (s - vec3(1.0))/denom; - return numerator / denom; -} - -vec2 uigamma_large_z_impl(const vec2 s, const vec2 z) -{ - // vec2 version: - const vec2 numerator = pow(z, s) * exp(-z); - vec2 denom = vec2(7.0) + z - s; - denom = vec2(5.0) + z - s + (3.0*s - vec2(9.0))/denom; - denom = vec2(3.0) + z - s + (2.0*s - vec2(4.0))/denom; - denom = vec2(1.0) + z - s + (s - vec2(1.0))/denom; - return numerator / denom; -} - -float uigamma_large_z_impl(const float s, const float z) -{ - // Float version: - const float numerator = pow(z, s) * exp(-z); - float denom = 7.0 + z - s; - denom = 5.0 + z - s + (3.0*s - 9.0)/denom; - denom = 3.0 + z - s + (2.0*s - 4.0)/denom; - denom = 1.0 + z - s + (s - 1.0)/denom; - return numerator / denom; -} - -// Normalized lower incomplete gamma function for small s (implementation): -vec4 normalized_ligamma_impl(const vec4 s, const vec4 z, - const vec4 s_inv, const vec4 gamma_s_inv) -{ - // Requires: 1.) s < ~0.5 - // 2.) s_inv = 1/s (precomputed for outside reuse) - // 3.) gamma_s_inv = 1/gamma(s) (precomputed for outside reuse) - // Returns: Approximate the normalized lower incomplete gamma function - // for s < 0.5. Since we only care about s < 0.5, we only need - // to evaluate two branches (not four) based on z. Each branch - // uses four terms, with a max relative error of ~0.00182. The - // branch threshold and specifics were adapted for fewer terms - // from Gil/Segura/Temme's paper here: - // http://oai.cwi.nl/oai/asset/20433/20433B.pdf - // Evaluate both branches: Real branches test slower even when available. - const vec4 thresh = vec4(0.775075); - const bool4 z_is_large = z > thresh; - const vec4 large_z = vec4(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec4 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - // Combine the results from both branches: - return large_z * vec4(z_is_large) + small_z * vec4(!z_is_large); -} - -vec3 normalized_ligamma_impl(const vec3 s, const vec3 z, - const vec3 s_inv, const vec3 gamma_s_inv) -{ - // vec3 version: - const vec3 thresh = vec3(0.775075); - const bool3 z_is_large = z > thresh; - const vec3 large_z = vec3(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec3 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * vec3(z_is_large) + small_z * vec3(!z_is_large); -} - -vec2 normalized_ligamma_impl(const vec2 s, const vec2 z, - const vec2 s_inv, const vec2 gamma_s_inv) -{ - // vec2 version: - const vec2 thresh = vec2(0.775075); - const bool2 z_is_large = z > thresh; - const vec2 large_z = vec2(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec2 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * vec2(z_is_large) + small_z * vec2(!z_is_large); -} - -float normalized_ligamma_impl(const float s, const float z, - const float s_inv, const float gamma_s_inv) -{ - // Float version: - const float thresh = 0.775075; - const bool z_is_large = z > thresh; - const float large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv; - const float small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * float(z_is_large) + small_z * float(!z_is_large); -} - -// Normalized lower incomplete gamma function for small s: -vec4 normalized_ligamma(const vec4 s, const vec4 z) -{ - // Requires: s < ~0.5 - // Returns: Approximate the normalized lower incomplete gamma function - // for s < 0.5. See normalized_ligamma_impl() for details. - const vec4 s_inv = vec4(1.0)/s; - const vec4 gamma_s_inv = vec4(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -vec3 normalized_ligamma(const vec3 s, const vec3 z) -{ - // vec3 version: - const vec3 s_inv = vec3(1.0)/s; - const vec3 gamma_s_inv = vec3(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -vec2 normalized_ligamma(const vec2 s, const vec2 z) -{ - // vec2 version: - const vec2 s_inv = vec2(1.0)/s; - const vec2 gamma_s_inv = vec2(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -float normalized_ligamma(const float s, const float z) -{ - // Float version: - const float s_inv = 1.0/s; - const float gamma_s_inv = 1.0/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - - -#endif // SPECIAL_FUNCTIONS_H - - diff --git a/crt/shaders/crt-royale/src/special-functions.h b/crt/shaders/crt-royale/src/special-functions.h deleted file mode 100644 index 2a06390..0000000 --- a/crt/shaders/crt-royale/src/special-functions.h +++ /dev/null @@ -1,498 +0,0 @@ -#ifndef SPECIAL_FUNCTIONS_H -#define SPECIAL_FUNCTIONS_H - - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file implements the following mathematical special functions: -// 1.) erf() = 2/sqrt(pi) * indefinite_integral(e**(-x**2)) -// 2.) gamma(s), a real-numbered extension of the integer factorial function -// It also implements normalized_ligamma(s, z), a normalized lower incomplete -// gamma function for s < 0.5 only. Both gamma() and normalized_ligamma() can -// be called with an _impl suffix to use an implementation version with a few -// extra precomputed parameters (which may be useful for the caller to reuse). -// See below for details. -// -// Design Rationale: -// Pretty much every line of code in this file is duplicated four times for -// different input types (vec4/vec3/vec2/float). This is unfortunate, -// but Cg doesn't allow function templates. Macros would be far less verbose, -// but they would make the code harder to document and read. I don't expect -// these functions will require a whole lot of maintenance changes unless -// someone ever has need for more robust incomplete gamma functions, so code -// duplication seems to be the lesser evil in this case. - - -/////////////////////////// GAUSSIAN ERROR FUNCTION ////////////////////////// - -vec4 erf6(vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Return an Abramowitz/Stegun approximation of erf(), where: - // erf(x) = 2/sqrt(pi) * integral(e**(-x**2)) - // This approximation has a max absolute error of 2.5*10**-5 - // with solid numerical robustness and efficiency. See: - // https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions - const vec4 one = vec4(1.0); - const vec4 sign_x = sign(x); - const vec4 t = one/(one + 0.47047*abs(x)); - const vec4 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec3 erf6(const vec3 x) -{ - // vec3 version: - const vec3 one = vec3(1.0); - const vec3 sign_x = sign(x); - const vec3 t = one/(one + 0.47047*abs(x)); - const vec3 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec2 erf6(const vec2 x) -{ - // vec2 version: - const vec2 one = vec2(1.0); - const vec2 sign_x = sign(x); - const vec2 t = one/(one + 0.47047*abs(x)); - const vec2 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -float erf6(const float x) -{ - // Float version: - const float sign_x = sign(x); - const float t = 1.0/(1.0 + 0.47047*abs(x)); - const float result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec4 erft(const vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Approximate erf() with the hyperbolic tangent. The error is - // visually noticeable, but it's blazing fast and perceptually - // close...at least on ATI hardware. See: - // http://www.maplesoft.com/applications/view.aspx?SID=5525&view=html - // Warning: Only use this if your hardware drivers correctly implement - // tanh(): My nVidia 8800GTS returns garbage output. - return tanh(1.202760580 * x); -} - -vec3 erft(const vec3 x) -{ - // vec3 version: - return tanh(1.202760580 * x); -} - -vec2 erft(const vec2 x) -{ - // vec2 version: - return tanh(1.202760580 * x); -} - -float erft(const float x) -{ - // Float version: - return tanh(1.202760580 * x); -} - -vec4 erf(const vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Some approximation of erf(x), depending on user settings. - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -vec3 erf(const vec3 x) -{ - // vec3 version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -vec2 erf(const vec2 x) -{ - // vec2 version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -float erf(const float x) -{ - // Float version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -/////////////////////////// COMPLETE GAMMA FUNCTION ////////////////////////// - -vec4 gamma_impl(const vec4 s, const vec4 s_inv) -{ - // Requires: 1.) s is the standard parameter to the gamma function, and - // it should lie in the [0, 36] range. - // 2.) s_inv = 1.0/s. This implementation function requires - // the caller to precompute this value, giving users the - // opportunity to reuse it. - // Returns: Return approximate gamma function (real-numbered factorial) - // output using the Lanczos approximation with two coefficients - // calculated using Paul Godfrey's method here: - // http://my.fit.edu/~gabdo/gamma.txt - // An optimal g value for s in [0, 36] is ~1.12906830989, with - // a maximum relative error of 0.000463 for 2**16 equally - // evals. We could use three coeffs (0.0000346 error) without - // hurting latency, but this allows more parallelism with - // outside instructions. - const vec4 g = vec4(1.12906830989); - const vec4 c0 = vec4(0.8109119309638332633713423362694399653724431); - const vec4 c1 = vec4(0.4808354605142681877121661197951496120000040); - const vec4 e = vec4(2.71828182845904523536028747135266249775724709); - const vec4 sph = s + vec4(0.5); - const vec4 lanczos_sum = c0 + c1/(s + vec4(1.0)); - const vec4 base = (sph + g)/e; // or (s + g + vec4(0.5))/e - // gamma(s + 1) = base**sph * lanczos_sum; divide by s for gamma(s). - // This has less error for small s's than (s -= 1.0) at the beginning. - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec3 gamma_impl(const vec3 s, const vec3 s_inv) -{ - // vec3 version: - const vec3 g = vec3(1.12906830989); - const vec3 c0 = vec3(0.8109119309638332633713423362694399653724431); - const vec3 c1 = vec3(0.4808354605142681877121661197951496120000040); - const vec3 e = vec3(2.71828182845904523536028747135266249775724709); - const vec3 sph = s + vec3(0.5); - const vec3 lanczos_sum = c0 + c1/(s + vec3(1.0)); - const vec3 base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec2 gamma_impl(const vec2 s, const vec2 s_inv) -{ - // vec2 version: - const vec2 g = vec2(1.12906830989); - const vec2 c0 = vec2(0.8109119309638332633713423362694399653724431); - const vec2 c1 = vec2(0.4808354605142681877121661197951496120000040); - const vec2 e = vec2(2.71828182845904523536028747135266249775724709); - const vec2 sph = s + vec2(0.5); - const vec2 lanczos_sum = c0 + c1/(s + vec2(1.0)); - const vec2 base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -float gamma_impl(const float s, const float s_inv) -{ - // Float version: - const float g = 1.12906830989; - const float c0 = 0.8109119309638332633713423362694399653724431; - const float c1 = 0.4808354605142681877121661197951496120000040; - const float e = 2.71828182845904523536028747135266249775724709; - const float sph = s + 0.5; - const float lanczos_sum = c0 + c1/(s + 1.0); - const float base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec4 gamma(const vec4 s) -{ - // Requires: s is the standard parameter to the gamma function, and it - // should lie in the [0, 36] range. - // Returns: Return approximate gamma function output with a maximum - // relative error of 0.000463. See gamma_impl for details. - return gamma_impl(s, vec4(1.0)/s); -} - -vec3 gamma(const vec3 s) -{ - // vec3 version: - return gamma_impl(s, vec3(1.0)/s); -} - -vec2 gamma(const vec2 s) -{ - // vec2 version: - return gamma_impl(s, vec2(1.0)/s); -} - -float gamma(const float s) -{ - // Float version: - return gamma_impl(s, 1.0/s); -} - -//////////////// INCOMPLETE GAMMA FUNCTIONS (RESTRICTED INPUT) /////////////// - -// Lower incomplete gamma function for small s and z (implementation): -vec4 ligamma_small_z_impl(const vec4 s, const vec4 z, const vec4 s_inv) -{ - // Requires: 1.) s < ~0.5 - // 2.) z <= ~0.775075 - // 3.) s_inv = 1.0/s (precomputed for outside reuse) - // Returns: A series representation for the lower incomplete gamma - // function for small s and small z (4 terms). - // The actual "rolled up" summation looks like: - // last_sign = 1.0; last_pow = 1.0; last_factorial = 1.0; - // sum = last_sign * last_pow / ((s + k) * last_factorial) - // for(int i = 0; i < 4; ++i) - // { - // last_sign *= -1.0; last_pow *= z; last_factorial *= i; - // sum += last_sign * last_pow / ((s + k) * last_factorial); - // } - // Unrolled, constant-unfolded and arranged for madds and parallelism: - const vec4 scale = pow(z, s); - vec4 sum = s_inv; // Summation iteration 0 result - // Summation iterations 1, 2, and 3: - const vec4 z_sq = z*z; - const vec4 denom1 = s + vec4(1.0); - const vec4 denom2 = 2.0*s + vec4(4.0); - const vec4 denom3 = 6.0*s + vec4(18.0); - //vec4 denom4 = 24.0*s + vec4(96.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - //sum += z_sq * z_sq / denom4; - // Scale and return: - return scale * sum; -} - -vec3 ligamma_small_z_impl(const vec3 s, const vec3 z, const vec3 s_inv) -{ - // vec3 version: - const vec3 scale = pow(z, s); - vec3 sum = s_inv; - const vec3 z_sq = z*z; - const vec3 denom1 = s + vec3(1.0); - const vec3 denom2 = 2.0*s + vec3(4.0); - const vec3 denom3 = 6.0*s + vec3(18.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -vec2 ligamma_small_z_impl(const vec2 s, const vec2 z, const vec2 s_inv) -{ - // vec2 version: - const vec2 scale = pow(z, s); - vec2 sum = s_inv; - const vec2 z_sq = z*z; - const vec2 denom1 = s + vec2(1.0); - const vec2 denom2 = 2.0*s + vec2(4.0); - const vec2 denom3 = 6.0*s + vec2(18.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -float ligamma_small_z_impl(const float s, const float z, const float s_inv) -{ - // Float version: - const float scale = pow(z, s); - float sum = s_inv; - const float z_sq = z*z; - const float denom1 = s + 1.0; - const float denom2 = 2.0*s + 4.0; - const float denom3 = 6.0*s + 18.0; - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -// Upper incomplete gamma function for small s and large z (implementation): -vec4 uigamma_large_z_impl(const vec4 s, const vec4 z) -{ - // Requires: 1.) s < ~0.5 - // 2.) z > ~0.775075 - // Returns: Gauss's continued fraction representation for the upper - // incomplete gamma function (4 terms). - // The "rolled up" continued fraction looks like this. The denominator - // is truncated, and it's calculated "from the bottom up:" - // denom = vec4('inf'); - // vec4 one = vec4(1.0); - // for(int i = 4; i > 0; --i) - // { - // denom = ((i * 2.0) - one) + z - s + (i * (s - i))/denom; - // } - // Unrolled and constant-unfolded for madds and parallelism: - const vec4 numerator = pow(z, s) * exp(-z); - vec4 denom = vec4(7.0) + z - s; - denom = vec4(5.0) + z - s + (3.0*s - vec4(9.0))/denom; - denom = vec4(3.0) + z - s + (2.0*s - vec4(4.0))/denom; - denom = vec4(1.0) + z - s + (s - vec4(1.0))/denom; - return numerator / denom; -} - -vec3 uigamma_large_z_impl(const vec3 s, const vec3 z) -{ - // vec3 version: - const vec3 numerator = pow(z, s) * exp(-z); - vec3 denom = vec3(7.0) + z - s; - denom = vec3(5.0) + z - s + (3.0*s - vec3(9.0))/denom; - denom = vec3(3.0) + z - s + (2.0*s - vec3(4.0))/denom; - denom = vec3(1.0) + z - s + (s - vec3(1.0))/denom; - return numerator / denom; -} - -vec2 uigamma_large_z_impl(const vec2 s, const vec2 z) -{ - // vec2 version: - const vec2 numerator = pow(z, s) * exp(-z); - vec2 denom = vec2(7.0) + z - s; - denom = vec2(5.0) + z - s + (3.0*s - vec2(9.0))/denom; - denom = vec2(3.0) + z - s + (2.0*s - vec2(4.0))/denom; - denom = vec2(1.0) + z - s + (s - vec2(1.0))/denom; - return numerator / denom; -} - -float uigamma_large_z_impl(const float s, const float z) -{ - // Float version: - const float numerator = pow(z, s) * exp(-z); - float denom = 7.0 + z - s; - denom = 5.0 + z - s + (3.0*s - 9.0)/denom; - denom = 3.0 + z - s + (2.0*s - 4.0)/denom; - denom = 1.0 + z - s + (s - 1.0)/denom; - return numerator / denom; -} - -// Normalized lower incomplete gamma function for small s (implementation): -vec4 normalized_ligamma_impl(const vec4 s, const vec4 z, - const vec4 s_inv, const vec4 gamma_s_inv) -{ - // Requires: 1.) s < ~0.5 - // 2.) s_inv = 1/s (precomputed for outside reuse) - // 3.) gamma_s_inv = 1/gamma(s) (precomputed for outside reuse) - // Returns: Approximate the normalized lower incomplete gamma function - // for s < 0.5. Since we only care about s < 0.5, we only need - // to evaluate two branches (not four) based on z. Each branch - // uses four terms, with a max relative error of ~0.00182. The - // branch threshold and specifics were adapted for fewer terms - // from Gil/Segura/Temme's paper here: - // http://oai.cwi.nl/oai/asset/20433/20433B.pdf - // Evaluate both branches: Real branches test slower even when available. - const vec4 thresh = vec4(0.775075); - bvec4 z_is_large = greaterThan(z , thresh); - vec4 z_size_check = vec4(z_is_large.x ? 1.0 : 0.0, z_is_large.y ? 1.0 : 0.0, z_is_large.z ? 1.0 : 0.0, z_is_large.w ? 1.0 : 0.0); - const vec4 large_z = vec4(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec4 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - // Combine the results from both branches: - return large_z * vec4(z_size_check) + small_z * vec4(z_size_check); -} - -vec3 normalized_ligamma_impl(const vec3 s, const vec3 z, - const vec3 s_inv, const vec3 gamma_s_inv) -{ - // vec3 version: - const vec3 thresh = vec3(0.775075); - bvec3 z_is_large = greaterThan(z , thresh); - vec3 z_size_check = vec3(z_is_large.x ? 1.0 : 0.0, z_is_large.y ? 1.0 : 0.0, z_is_large.z ? 1.0 : 0.0); - const vec3 large_z = vec3(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec3 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * vec3(z_size_check) + small_z * vec3(z_size_check); -} - -vec2 normalized_ligamma_impl(const vec2 s, const vec2 z, - const vec2 s_inv, const vec2 gamma_s_inv) -{ - // vec2 version: - const vec2 thresh = vec2(0.775075); - bvec2 z_is_large = greaterThan(z , thresh); - vec2 z_size_check = vec2(z_is_large.x ? 1.0 : 0.0, z_is_large.y ? 1.0 : 0.0); - const vec2 large_z = vec2(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec2 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * vec2(z_size_check) + small_z * vec2(z_size_check); -} - -float normalized_ligamma_impl(const float s, const float z, - const float s_inv, const float gamma_s_inv) -{ - // Float version: - const float thresh = 0.775075; - float z_size_check = 0.0; - if (z > thresh) z_size_check = 1.0; - const float large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv; - const float small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * float(z_size_check) + small_z * float(z_size_check); -} - -// Normalized lower incomplete gamma function for small s: -vec4 normalized_ligamma(const vec4 s, const vec4 z) -{ - // Requires: s < ~0.5 - // Returns: Approximate the normalized lower incomplete gamma function - // for s < 0.5. See normalized_ligamma_impl() for details. - const vec4 s_inv = vec4(1.0)/s; - const vec4 gamma_s_inv = vec4(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -vec3 normalized_ligamma(const vec3 s, const vec3 z) -{ - // vec3 version: - const vec3 s_inv = vec3(1.0)/s; - const vec3 gamma_s_inv = vec3(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -vec2 normalized_ligamma(const vec2 s, const vec2 z) -{ - // vec2 version: - const vec2 s_inv = vec2(1.0)/s; - const vec2 gamma_s_inv = vec2(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -float normalized_ligamma(const float s, const float z) -{ - // Float version: - const float s_inv = 1.0/s; - const float gamma_s_inv = 1.0/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -#endif // SPECIAL_FUNCTIONS_H \ No newline at end of file diff --git a/crt/shaders/crt-royale/src/tex2Dantialias-old.h b/crt/shaders/crt-royale/src/tex2Dantialias-old.h deleted file mode 100644 index 0a5f834..0000000 --- a/crt/shaders/crt-royale/src/tex2Dantialias-old.h +++ /dev/null @@ -1,1393 +0,0 @@ -#ifndef TEX2DANTIALIAS_H -#define TEX2DANTIALIAS_H - -///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// - -// crt-royale: A full-featured CRT shader, with cheese. -// Copyright (C) 2014 TroggleMonkey -// -// This program is free software; you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation; either version 2 of the License, or any later version. -// -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. -// -// You should have received a copy of the GNU General Public License along with -// this program; if not, write to the Free Software Foundation, Inc., 59 Temple -// Place, Suite 330, Boston, MA 02111-1307 USA - - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file provides antialiased and subpixel-aware tex2D lookups. -// Requires: All functions share these requirements: -// 1.) All requirements of gamma-management.h must be satisfied! -// 2.) pixel_to_tex_uv must be a 2x2 matrix that transforms pixe- -// space offsets to texture uv offsets. You can get this with: -// const vec2 duv_dx = ddx(tex_uv); -// const vec2 duv_dy = ddy(tex_uv); -// const vec2x2 pixel_to_tex_uv = vec2x2( -// duv_dx.x, duv_dy.x, -// duv_dx.y, duv_dy.y); -// This is left to the user in case the current Cg profile -// doesn't support ddx()/ddy(). Ideally, the user could find -// calculate a distorted tangent-space mapping analytically. -// If not, a simple flat mapping can be obtained with: -// const vec2 xy_to_uv_scale = IN.output_size * -// IN.video_size/IN.texture_size; -// const vec2x2 pixel_to_tex_uv = vec2x2( -// xy_to_uv_scale.x, 0.0, -// 0.0, xy_to_uv_scale.y); -// Optional: To set basic AA settings, #define ANTIALIAS_OVERRIDE_BASICS and: -// 1.) Set an antialiasing level: -// static const float aa_level = {0 (none), -// 1 (sample subpixels), 4, 5, 6, 7, 8, 12, 16, 20, 24} -// 2.) Set a filter type: -// static const float aa_filter = { -// 0 (Box, Separable), 1 (Box, Cylindrical), -// 2 (Tent, Separable), 3 (Tent, Cylindrical) -// 4 (Gaussian, Separable), 5 (Gaussian, Cylindrical) -// 6 (Cubic, Separable), 7 (Cubic, Cylindrical) -// 8 (Lanczos Sinc, Separable), -// 9 (Lanczos Jinc, Cylindrical)} -// If the input is unknown, a separable box filter is used. -// Note: Lanczos Jinc is terrible for sparse sampling, and -// using aa_axis_importance (see below) defeats the purpose. -// 3.) Mirror the sample pattern on odd frames? -// static const bool aa_temporal = {true, false] -// This helps rotational invariance but can look "fluttery." -// The user may #define ANTIALIAS_OVERRIDE_PARAMETERS to override -// (all of) the following default parameters with static or uniform -// constants (or an accessor function for subpixel offsets): -// 1.) Cubic parameters: -// static const float aa_cubic_c = 0.5; -// See http://www.imagemagick.org/Usage/filter/#mitchell -// 2.) Gaussian parameters: -// static const float aa_gauss_sigma = -// 0.5/aa_pixel_diameter; -// 3.) Set subpixel offsets. This requires an accessor function -// for compatibility with scalar runtime shader params. Return -// a vec2 pixel offset in [-0.5, 0.5] for the red subpixel: -// vec2 get_aa_subpixel_r_offset() -// The user may also #define ANTIALIAS_OVERRIDE_STATIC_CONSTANTS to -// override (all of) the following default static values. However, -// the file's structure requires them to be declared static const: -// 1.) static const float aa_lanczos_lobes = 3.0; -// 2.) static const float aa_gauss_support = 1.0/aa_pixel_diameter; -// Note the default tent/Gaussian support radii may appear -// arbitrary, but extensive testing found them nearly optimal -// for tough cases like strong distortion at low AA levels. -// (The Gaussian default is only best for practical gauss_sigma -// values; much larger gauss_sigmas ironically prefer slightly -// smaller support given sparse sampling, and vice versa.) -// 3.) static const float aa_tent_support = 1.0 / aa_pixel_diameter; -// 4.) static const vec2 aa_xy_axis_importance: -// The sparse N-queens sampling grid interacts poorly with -// negative-lobed 2D filters. However, if aliasing is much -// stronger in one direction (e.g. horizontally with a phosphor -// mask), it can be useful to downplay sample offsets along the -// other axis. The support radius in each direction scales with -// aa_xy_axis_importance down to a minimum of 0.5 (box support), -// after which point only the offsets used for calculating -// weights continue to scale downward. This works as follows: -// If aa_xy_axis_importance = vec2(1.0, 1.0/support_radius), -// the vertical support radius will drop to 1.0, and we'll just -// filter vertical offsets with the first filter lobe, while -// horizontal offsets go through the full multi-lobe filter. -// If aa_xy_axis_importance = vec2(1.0, 0.0), the vertical -// support radius will drop to box support, and the vertical -// offsets will be ignored entirely (essentially giving us a -// box filter vertically). The former is potentially smoother -// (but less predictable) and the default behavior of Lanczos -// jinc, whereas the latter is sharper and the default behavior -// of cubics and Lanczos sinc. -// 5.) static const float aa_pixel_diameter: You can expand the -// pixel diameter to e.g. sqrt(2.0), which may be a better -// support range for cylindrical filters (they don't -// currently discard out-of-circle samples though). -// Finally, there are two miscellaneous options: -// 1.) If you want to antialias a manually tiled texture, you can -// #define ANTIALIAS_DISABLE_ANISOTROPIC to use tex2Dlod() to -// fix incompatibilities with anisotropic filtering. This is -// slower, and the Cg profile must support tex2Dlod(). -// 2.) If aa_cubic_c is a runtime uniform, you can #define -// RUNTIME_ANTIALIAS_WEIGHTS to evaluate cubic weights once per -// fragment instead of at the usage site (which is used by -// default, because it enables static evaluation). -// Description: -// Each antialiased lookup follows these steps: -// 1.) Define a sample pattern of pixel offsets in the range of [-0.5, 0.5] -// pixels, spanning the diameter of a rectangular box filter. -// 2.) Scale these offsets by the support diameter of the user's chosen filter. -// 3.) Using these pixel offsets from the pixel center, compute the offsets to -// predefined subpixel locations. -// 4.) Compute filter weights based on subpixel offsets. -// Much of that can often be done at compile-time. At runtime: -// 1.) Project pixel-space offsets into uv-space with a matrix multiplication -// to get the uv offsets for each sample. Rectangular pixels have a -// diameter of 1.0. Circular pixels are not currently supported, but they -// might be better with a diameter of sqrt(2.0) to ensure there are no gaps -// between them. -// 2.) Load, weight, and sum samples. -// We use a sparse bilinear sampling grid, so there are two major implications: -// 1.) We can directly project the pixel-space support box into uv-space even -// if we're upsizing. This wouldn't be the case for nearest neighbor, -// where we'd have to expand the uv-space diameter to at least the support -// size to ensure sufficient filter support. In our case, this allows us -// to treat upsizing the same as downsizing and use static weighting. :) -// 2.) For decent results, negative-lobed filters must be computed based on -// separable weights, not radial distances, because the sparse sampling -// makes no guarantees about radial distributions. Even then, it's much -// better to set aa_xy_axis_importance to e.g. vec2(1.0, 0.0) to use e.g. -// Lanczos2 horizontally and a box filter vertically. This is mainly due -// to the sparse N-queens sampling and a statistically enormous positive or -// negative covariance between horizontal and vertical weights. -// -// Design Decision Comments: -// "aa_temporal" mirrors the sample pattern on odd frames along the axis that -// keeps subpixel weights constant. This helps with rotational invariance, but -// it can cause distracting fluctuations, and horizontal and vertical edges -// will look the same. Using a different pattern on a shifted grid would -// exploit temporal AA better, but it would require a dynamic branch or a lot -// of conditional moves, so it's prohibitively slow for the minor benefit. - - -///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// - -#ifndef ANTIALIAS_OVERRIDE_BASICS - // The following settings must be static constants: - const float aa_level = 12.0; - const float aa_filter = 0.0; - const bool aa_temporal = false; -#endif - -#ifndef ANTIALIAS_OVERRIDE_STATIC_CONSTANTS - // Users may override these parameters, but the file structure requires - // them to be static constants; see the descriptions above. - const float aa_pixel_diameter = 1.0; - const float aa_lanczos_lobes = 3.0; - const float aa_gauss_support = 1.0 / aa_pixel_diameter; - const float aa_tent_support = 1.0 / aa_pixel_diameter; - - // If we're using a negative-lobed filter, default to using it horizontally - // only, and use only the first lobe vertically or a box filter, over a - // correspondingly smaller range. This compensates for the sparse sampling - // grid's typically large positive/negative x/y covariance. - const vec2 aa_xy_axis_importance = - aa_filter < 5.5 ? vec2(1.0) : // Box, tent, Gaussian - aa_filter < 8.5 ? vec2(1.0, 0.0) : // Cubic and Lanczos sinc - aa_filter < 9.5 ? vec2(1.0, 1.0/aa_lanczos_lobes) : // Lanczos jinc - vec2(1.0); // Default to box -#endif - -#ifndef ANTIALIAS_OVERRIDE_PARAMETERS - // Users may override these values with their own uniform or static consts. - // Cubics: See http://www.imagemagick.org/Usage/filter/#mitchell - // 1.) "Keys cubics" with B = 1 - 2C are considered the highest quality. - // 2.) C = 0.5 (default) is Catmull-Rom; higher C's apply sharpening. - // 3.) C = 1.0/3.0 is the Mitchell-Netravali filter. - // 4.) C = 0.0 is a soft spline filter. - const float aa_cubic_c = 0.5; - const float aa_gauss_sigma = 0.5 / aa_pixel_diameter; - // Users may override the subpixel offset accessor function with their own. - // A function is used for compatibility with scalar runtime shader params. - vec2 get_aa_subpixel_r_offset() - { - return vec2(0.0, 0.0); - } -#endif - - -////////////////////////////////// INCLUDES ////////////////////////////////// - -#include "../../../../include/gamma-management.h" - - -////////////////////////////////// CONSTANTS ///////////////////////////////// - -const float aa_box_support = 0.5; -const float aa_cubic_support = 2.0; - - -//////////////////////////// GLOBAL NON-CONSTANTS //////////////////////////// - -// We'll want to define these only once per fragment at most. -#ifdef RUNTIME_ANTIALIAS_WEIGHTS - uniform float aa_cubic_b; - uniform float cubic_branch1_x3_coeff; - uniform float cubic_branch1_x2_coeff; - uniform float cubic_branch1_x0_coeff; - uniform float cubic_branch2_x3_coeff; - uniform float cubic_branch2_x2_coeff; - uniform float cubic_branch2_x1_coeff; - uniform float cubic_branch2_x0_coeff; -#endif - - -/////////////////////////////////// HELPERS ////////////////////////////////// - -void assign_aa_cubic_constants() -{ - // Compute cubic coefficients on demand at runtime, and save them to global - // uniforms. The B parameter is computed from C, because "Keys cubics" - // with B = 1 - 2C are considered the highest quality. - #ifdef RUNTIME_ANTIALIAS_WEIGHTS - if(aa_filter > 5.5 && aa_filter < 7.5) - { - aa_cubic_b = 1.0 - 2.0*aa_cubic_c; - cubic_branch1_x3_coeff = 12.0 - 9.0*aa_cubic_b - 6.0*aa_cubic_c; - cubic_branch1_x2_coeff = -18.0 + 12.0*aa_cubic_b + 6.0*aa_cubic_c; - cubic_branch1_x0_coeff = 6.0 - 2.0 * aa_cubic_b; - cubic_branch2_x3_coeff = -aa_cubic_b - 6.0 * aa_cubic_c; - cubic_branch2_x2_coeff = 6.0*aa_cubic_b + 30.0*aa_cubic_c; - cubic_branch2_x1_coeff = -12.0*aa_cubic_b - 48.0*aa_cubic_c; - cubic_branch2_x0_coeff = 8.0*aa_cubic_b + 24.0*aa_cubic_c; - } - #endif -} - -vec4 get_subpixel_support_diam_and_final_axis_importance() -{ - // Statically select the base support radius: - const float base_support_radius = - aa_filter < 1.5 ? aa_box_support : - aa_filter < 3.5 ? aa_tent_support : - aa_filter < 5.5 ? aa_gauss_support : - aa_filter < 7.5 ? aa_cubic_support : - aa_filter < 9.5 ? aa_lanczos_lobes : - aa_box_support; // Default to box - // Expand the filter support for subpixel filtering. - const vec2 subpixel_support_radius_raw = - vec2(base_support_radius) + abs(get_aa_subpixel_r_offset()); - if(aa_filter < 1.5) - { - // Ignore aa_xy_axis_importance for box filtering. - const vec2 subpixel_support_diam = - 2.0 * subpixel_support_radius_raw; - const vec2 final_axis_importance = vec2(1.0); - return vec4(subpixel_support_diam, final_axis_importance); - } - else - { - // Scale the support window by aa_xy_axis_importance, but don't narrow - // it further than box support. This allows decent vertical AA without - // messing up horizontal weights or using something silly like Lanczos4 - // horizontally with a huge vertical average over an 8-pixel radius. - const vec2 subpixel_support_radius = max(vec2(aa_box_support), - subpixel_support_radius_raw * aa_xy_axis_importance); - // Adjust aa_xy_axis_importance to compensate for what's already done: - const vec2 final_axis_importance = aa_xy_axis_importance * - subpixel_support_radius_raw/subpixel_support_radius; - const vec2 subpixel_support_diam = 2.0 * subpixel_support_radius; - return vec4(subpixel_support_diam, final_axis_importance); - } -} - - -/////////////////////////// FILTER WEIGHT FUNCTIONS ////////////////////////// - -float eval_box_filter(const float dist) -{ - return float(abs(dist) <= aa_box_support); -} - -float eval_separable_box_filter(const vec2 offset) -{ - return float(all(abs(offset) <= vec2(aa_box_support))); -} - -float eval_tent_filter(const float dist) -{ - return clamp((aa_tent_support - dist)/ - aa_tent_support, 0.0, 1.0); -} - -float eval_gaussian_filter(const float dist) -{ - return exp(-(dist*dist) / (2.0*aa_gauss_sigma*aa_gauss_sigma)); -} - -float eval_cubic_filter(const float dist) -{ - // Compute coefficients like assign_aa_cubic_constants(), but statically. - #ifndef RUNTIME_ANTIALIAS_WEIGHTS - // When runtime weights are used, these values are instead written to - // global uniforms at the beginning of each tex2Daa* call. - const float aa_cubic_b = 1.0 - 2.0*aa_cubic_c; - const float cubic_branch1_x3_coeff = 12.0 - 9.0*aa_cubic_b - 6.0*aa_cubic_c; - const float cubic_branch1_x2_coeff = -18.0 + 12.0*aa_cubic_b + 6.0*aa_cubic_c; - const float cubic_branch1_x0_coeff = 6.0 - 2.0 * aa_cubic_b; - const float cubic_branch2_x3_coeff = -aa_cubic_b - 6.0 * aa_cubic_c; - const float cubic_branch2_x2_coeff = 6.0*aa_cubic_b + 30.0*aa_cubic_c; - const float cubic_branch2_x1_coeff = -12.0*aa_cubic_b - 48.0*aa_cubic_c; - const float cubic_branch2_x0_coeff = 8.0*aa_cubic_b + 24.0*aa_cubic_c; - #endif - const float abs_dist = abs(dist); - // Compute the cubic based on the Horner's method formula in: - // http://www.cs.utexas.edu/users/fussell/courses/cs384g/lectures/mitchell/Mitchell.pdf - return (abs_dist < 1.0 ? - (cubic_branch1_x3_coeff*abs_dist + - cubic_branch1_x2_coeff)*abs_dist*abs_dist + - cubic_branch1_x0_coeff : - abs_dist < 2.0 ? - ((cubic_branch2_x3_coeff*abs_dist + - cubic_branch2_x2_coeff)*abs_dist + - cubic_branch2_x1_coeff)*abs_dist + cubic_branch2_x0_coeff : - 0.0)/6.0; -} - -float eval_separable_cubic_filter(const vec2 offset) -{ - // This is faster than using a specific vec2 version: - return eval_cubic_filter(offset.x) * - eval_cubic_filter(offset.y); -} - -vec2 eval_sinc_filter(const vec2 offset) -{ - // It's faster to let the caller handle the zero case, or at least it - // was when I used macros and the shader preset took a full minute to load. - const vec2 pi_offset = pi * offset; - return sin(pi_offset)/pi_offset; -} - -float eval_separable_lanczos_sinc_filter(const vec2 offset_unsafe) -{ - // Note: For sparse sampling, you really need to pick an axis to use - // Lanczos along (e.g. set aa_xy_axis_importance = vec2(1.0, 0.0)). - const vec2 offset = FIX_ZERO(offset_unsafe); - const vec2 xy_weights = eval_sinc_filter(offset) * - eval_sinc_filter(offset/aa_lanczos_lobes); - return xy_weights.x * xy_weights.y; -} - -float eval_jinc_filter_unorm(const float x) -{ - // This is a Jinc approximation for x in [0, 45). We'll use x in range - // [0, 4*pi) or so. There are faster/closer approximations based on - // piecewise cubics from [0, 45) and asymptotic approximations beyond that, - // but this has a maximum absolute error < 1/512, and it's simpler/faster - // for shaders...not that it's all that useful for sparse sampling anyway. - const float point3845_x = 0.38448566093564*x; - const float exp_term = exp(-(point3845_x*point3845_x)); - const float point8154_plus_x = 0.815362332840791 + x; - const float cos_term = cos(point8154_plus_x); - return ( - 0.0264727330997042*min(x, 6.83134964622778) + - 0.680823557250528*exp_term + - -0.0597255978950933*min(7.41043194481873, x)*cos_term / - (point8154_plus_x + 0.0646074538634482*(x*x) + - cos(x)*max(exp_term, cos(x) + cos_term)) - - 0.180837503591406); -} - -float eval_jinc_filter(const float dist) -{ - return eval_jinc_filter_unorm(pi * dist); -} - -float eval_lanczos_jinc_filter(const float dist) -{ - return eval_jinc_filter(dist) * eval_jinc_filter(dist/aa_lanczos_lobes); -} - - -vec3 eval_unorm_rgb_weights(const vec2 offset, - const vec2 final_axis_importance) -{ - // Requires: 1.) final_axis_impportance must be computed according to - // get_subpixel_support_diam_and_final_axis_importance(). - // 2.) aa_filter must be a global constant. - // 3.) offset must be an xy pixel offset in the range: - // ([-subpixel_support_diameter.x/2, - // subpixel_support_diameter.x/2], - // [-subpixel_support_diameter.y/2, - // subpixel_support_diameter.y/2]) - // Returns: Sample weights at R/G/B destination subpixels for the - // given xy pixel offset. - const vec2 offset_g = offset * final_axis_importance; - const vec2 aa_r_offset = get_aa_subpixel_r_offset(); - const vec2 offset_r = offset_g - aa_r_offset * final_axis_importance; - const vec2 offset_b = offset_g + aa_r_offset * final_axis_importance; - // Statically select a filter: - if(aa_filter < 0.5) - { - return vec3(eval_separable_box_filter(offset_r), - eval_separable_box_filter(offset_g), - eval_separable_box_filter(offset_b)); - } - else if(aa_filter < 1.5) - { - return vec3(eval_box_filter(length(offset_r)), - eval_box_filter(length(offset_g)), - eval_box_filter(length(offset_b))); - } - else if(aa_filter < 2.5) - { - return vec3( - eval_tent_filter(offset_r.x) * eval_tent_filter(offset_r.y), - eval_tent_filter(offset_g.x) * eval_tent_filter(offset_g.y), - eval_tent_filter(offset_b.x) * eval_tent_filter(offset_b.y)); - } - else if(aa_filter < 3.5) - { - return vec3(eval_tent_filter(length(offset_r)), - eval_tent_filter(length(offset_g)), - eval_tent_filter(length(offset_b))); - } - else if(aa_filter < 4.5) - { - return vec3( - eval_gaussian_filter(offset_r.x) * eval_gaussian_filter(offset_r.y), - eval_gaussian_filter(offset_g.x) * eval_gaussian_filter(offset_g.y), - eval_gaussian_filter(offset_b.x) * eval_gaussian_filter(offset_b.y)); - } - else if(aa_filter < 5.5) - { - return vec3(eval_gaussian_filter(length(offset_r)), - eval_gaussian_filter(length(offset_g)), - eval_gaussian_filter(length(offset_b))); - } - else if(aa_filter < 6.5) - { - return vec3( - eval_cubic_filter(offset_r.x) * eval_cubic_filter(offset_r.y), - eval_cubic_filter(offset_g.x) * eval_cubic_filter(offset_g.y), - eval_cubic_filter(offset_b.x) * eval_cubic_filter(offset_b.y)); - } - else if(aa_filter < 7.5) - { - return vec3(eval_cubic_filter(length(offset_r)), - eval_cubic_filter(length(offset_g)), - eval_cubic_filter(length(offset_b))); - } - else if(aa_filter < 8.5) - { - return vec3(eval_separable_lanczos_sinc_filter(offset_r), - eval_separable_lanczos_sinc_filter(offset_g), - eval_separable_lanczos_sinc_filter(offset_b)); - } - else if(aa_filter < 9.5) - { - return vec3(eval_lanczos_jinc_filter(length(offset_r)), - eval_lanczos_jinc_filter(length(offset_g)), - eval_lanczos_jinc_filter(length(offset_b))); - } - else - { - // Default to a box, because Lanczos Jinc is so bad. ;) - return vec3(eval_separable_box_filter(offset_r), - eval_separable_box_filter(offset_g), - eval_separable_box_filter(offset_b)); - } -} - - -////////////////////////////// HELPER FUNCTIONS ////////////////////////////// - -vec4 tex2Daa_tiled_linearize(const sampler2D samp, const vec2 s) -{ - // If we're manually tiling a texture, anisotropic filtering can get - // confused. This is one workaround: - #ifdef ANTIALIAS_DISABLE_ANISOTROPIC - // TODO: Use tex2Dlod_linearize with a calculated mip level. - return tex2Dlod_linearize(samp, vec4(s, 0.0, 0.0)); - #else - return tex2D_linearize(samp, s); - #endif -} - -vec2 get_frame_sign(const float frame) -{ - if(aa_temporal) - { - // Mirror the sampling pattern for odd frames in a direction that - // lets us keep the same subpixel sample weights: - const float frame_odd = float(fmod(frame, 2.0) > 0.5); - const vec2 aa_r_offset = get_aa_subpixel_r_offset(); - const vec2 mirror = -vec2(abs(aa_r_offset) < vec2(FIX_ZERO(0.0))); - return mirror; - } - else - { - return vec2(1.0); - } -} - - -///////////////////////// ANTIALIASED TEXTURE LOOKUPS //////////////////////// - -vec3 tex2Daa_subpixel_weights_only(const sampler2D texture, - const vec2 tex_uv, const vec2x2 pixel_to_tex_uv) -{ - // This function is unlike the others: Just perform a single independent - // lookup for each subpixel. It may be very aliased. - const vec2 aa_r_offset = get_aa_subpixel_r_offset(); - const vec2 aa_r_offset_uv_offset = mul(pixel_to_tex_uv, aa_r_offset); - const float color_g = tex2D_linearize(texture, tex_uv).g; - const float color_r = tex2D_linearize(texture, tex_uv + aa_r_offset_uv_offset).r; - const float color_b = tex2D_linearize(texture, tex_uv - aa_r_offset_uv_offset).b; - return vec3(color_r, color_g, color_b); -} - -// The tex2Daa* functions compile very slowly due to all the macros and -// compile-time math, so only include the ones we'll actually use! -vec3 tex2Daa4x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use an RGMS4 pattern (4-queens): - // . . Q . : off =(-1.5, -1.5)/4 + (2.0, 0.0)/4 - // Q . . . : off =(-1.5, -1.5)/4 + (0.0, 1.0)/4 - // . . . Q : off =(-1.5, -1.5)/4 + (3.0, 2.0)/4 - // . Q . . : off =(-1.5, -1.5)/4 + (1.0, 3.0)/4 - // Static screenspace sample offsets (compute some implicitly): - const float grid_size = 4.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(2.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(0.0, 1.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = w1.bgr; - const vec3 w3 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * (w0 * sample0 + w1 * sample1 + - w2 * sample2 + w3 * sample3); -} - -vec3 tex2Daa5x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 5-queens pattern: - // . Q . . . : off =(-2.0, -2.0)/5 + (1.0, 0.0)/5 - // . . . . Q : off =(-2.0, -2.0)/5 + (4.0, 1.0)/5 - // . . Q . . : off =(-2.0, -2.0)/5 + (2.0, 2.0)/5 - // Q . . . . : off =(-2.0, -2.0)/5 + (0.0, 3.0)/5 - // . . . Q . : off =(-2.0, -2.0)/5 + (3.0, 4.0)/5 - // Static screenspace sample offsets (compute some implicitly): - const float grid_size = 5.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(1.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(4.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(2.0, 2.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = w1.bgr; - const vec3 w4 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 w_sum_inv = vec3(1.0)/(w0 + w1 + w2 + w3 + w4); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * (w0 * sample0 + w1 * sample1 + - w2 * sample2 + w3 * sample3 + w4 * sample4); -} - -vec3 tex2Daa6x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 6-queens pattern with a stronger horizontal - // than vertical slant: - // . . . . Q . : off =(-2.5, -2.5)/6 + (4.0, 0.0)/6 - // . . Q . . . : off =(-2.5, -2.5)/6 + (2.0, 1.0)/6 - // Q . . . . . : off =(-2.5, -2.5)/6 + (0.0, 2.0)/6 - // . . . . . Q : off =(-2.5, -2.5)/6 + (5.0, 3.0)/6 - // . . . Q . . : off =(-2.5, -2.5)/6 + (3.0, 4.0)/6 - // . Q . . . . : off =(-2.5, -2.5)/6 + (1.0, 5.0)/6 - // Static screenspace sample offsets (compute some implicitly): - const float grid_size = 6.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(4.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(2.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(0.0, 2.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = w2.bgr; - const vec3 w4 = w1.bgr; - const vec3 w5 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * (w0 * sample0 + w1 * sample1 + w2 * sample2 + - w3 * sample3 + w4 * sample4 + w5 * sample5); -} - -vec3 tex2Daa7x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 7-queens pattern with a queen in the center: - // . Q . . . . . : off =(-3.0, -3.0)/7 + (1.0, 0.0)/7 - // . . . . Q . . : off =(-3.0, -3.0)/7 + (4.0, 1.0)/7 - // Q . . . . . . : off =(-3.0, -3.0)/7 + (0.0, 2.0)/7 - // . . . Q . . . : off =(-3.0, -3.0)/7 + (3.0, 3.0)/7 - // . . . . . . Q : off =(-3.0, -3.0)/7 + (6.0, 4.0)/7 - // . . Q . . . . : off =(-3.0, -3.0)/7 + (2.0, 5.0)/7 - // . . . . . Q . : off =(-3.0, -3.0)/7 + (5.0, 6.0)/7 - const float grid_size = 7.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(1.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(4.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(0.0, 2.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(3.0, 3.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = w2.bgr; - const vec3 w5 = w1.bgr; - const vec3 w6 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2; - const vec3 w_sum = half_sum + half_sum.bgr + w3; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6); -} - -vec3 tex2Daa8x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 8-queens pattern. - // . . Q . . . . . : off =(-3.5, -3.5)/8 + (2.0, 0.0)/8 - // . . . . Q . . . : off =(-3.5, -3.5)/8 + (4.0, 1.0)/8 - // . Q . . . . . . : off =(-3.5, -3.5)/8 + (1.0, 2.0)/8 - // . . . . . . . Q : off =(-3.5, -3.5)/8 + (7.0, 3.0)/8 - // Q . . . . . . . : off =(-3.5, -3.5)/8 + (0.0, 4.0)/8 - // . . . . . . Q . : off =(-3.5, -3.5)/8 + (6.0, 5.0)/8 - // . . . Q . . . . : off =(-3.5, -3.5)/8 + (3.0, 6.0)/8 - // . . . . . Q . . : off =(-3.5, -3.5)/8 + (5.0, 7.0)/8 - const float grid_size = 8.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(2.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(4.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(1.0, 2.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(7.0, 3.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = w3.bgr; - const vec3 w5 = w2.bgr; - const vec3 w6 = w1.bgr; - const vec3 w7 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2 + w3; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, and mirror on odd frames if directed: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - const vec2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset3).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset3).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample7 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7); -} - -vec3 tex2Daa12x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 12-superqueens pattern where no 3 points are - // exactly collinear. - // . . . Q . . . . . . . . : off =(-5.5, -5.5)/12 + (3.0, 0.0)/12 - // . . . . . . . . . Q . . : off =(-5.5, -5.5)/12 + (9.0, 1.0)/12 - // . . . . . . Q . . . . . : off =(-5.5, -5.5)/12 + (6.0, 2.0)/12 - // . Q . . . . . . . . . . : off =(-5.5, -5.5)/12 + (1.0, 3.0)/12 - // . . . . . . . . . . . Q : off =(-5.5, -5.5)/12 + (11.0, 4.0)/12 - // . . . . Q . . . . . . . : off =(-5.5, -5.5)/12 + (4.0, 5.0)/12 - // . . . . . . . Q . . . . : off =(-5.5, -5.5)/12 + (7.0, 6.0)/12 - // Q . . . . . . . . . . . : off =(-5.5, -5.5)/12 + (0.0, 7.0)/12 - // . . . . . . . . . . Q . : off =(-5.5, -5.5)/12 + (10.0, 8.0)/12 - // . . . . . Q . . . . . . : off =(-5.5, -5.5)/12 + (5.0, 9.0)/12 - // . . Q . . . . . . . . . : off =(-5.5, -5.5)/12 + (2.0, 10.0)/12 - // . . . . . . . . Q . . . : off =(-5.5, -5.5)/12 + (8.0, 11.0)/12 - const float grid_size = 12.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(3.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(9.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(6.0, 2.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(1.0, 3.0) * xy_step; - const vec2 xy_offset4 = xy_start_offset + vec2(11.0, 4.0) * xy_step; - const vec2 xy_offset5 = xy_start_offset + vec2(4.0, 5.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); - const vec3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); - const vec3 w6 = w5.bgr; - const vec3 w7 = w4.bgr; - const vec3 w8 = w3.bgr; - const vec3 w9 = w2.bgr; - const vec3 w10 = w1.bgr; - const vec3 w11 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2 + w3 + w4 + w5; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/w_sum; - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - const vec2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); - const vec2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); - const vec2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset3).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset4).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset5).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset5).rgb; - const vec3 sample7 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset4).rgb; - const vec3 sample8 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset3).rgb; - const vec3 sample9 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample10 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample11 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + - w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11); -} - -vec3 tex2Daa16x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 16-superqueens pattern where no 3 points are - // exactly collinear. - // . . Q . . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (2.0, 0.0)/16 - // . . . . . . . . . Q . . . . . . : off =(-7.5, -7.5)/16 + (9.0, 1.0)/16 - // . . . . . . . . . . . . Q . . . : off =(-7.5, -7.5)/16 + (12.0, 2.0)/16 - // . . . . Q . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (4.0, 3.0)/16 - // . . . . . . . . Q . . . . . . . : off =(-7.5, -7.5)/16 + (8.0, 4.0)/16 - // . . . . . . . . . . . . . . Q . : off =(-7.5, -7.5)/16 + (14.0, 5.0)/16 - // Q . . . . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (0.0, 6.0)/16 - // . . . . . . . . . . Q . . . . . : off =(-7.5, -7.5)/16 + (10.0, 7.0)/16 - // . . . . . Q . . . . . . . . . . : off =(-7.5, -7.5)/16 + (5.0, 8.0)/16 - // . . . . . . . . . . . . . . . Q : off =(-7.5, -7.5)/16 + (15.0, 9.0)/16 - // . Q . . . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (1.0, 10.0)/16 - // . . . . . . . Q . . . . . . . . : off =(-7.5, -7.5)/16 + (7.0, 11.0)/16 - // . . . . . . . . . . . Q . . . . : off =(-7.5, -7.5)/16 + (11.0, 12.0)/16 - // . . . Q . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (3.0, 13.0)/16 - // . . . . . . Q . . . . . . . . . : off =(-7.5, -7.5)/16 + (6.0, 14.0)/16 - // . . . . . . . . . . . . . Q . . : off =(-7.5, -7.5)/16 + (13.0, 15.0)/16 - const float grid_size = 16.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(2.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(9.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(12.0, 2.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(4.0, 3.0) * xy_step; - const vec2 xy_offset4 = xy_start_offset + vec2(8.0, 4.0) * xy_step; - const vec2 xy_offset5 = xy_start_offset + vec2(14.0, 5.0) * xy_step; - const vec2 xy_offset6 = xy_start_offset + vec2(0.0, 6.0) * xy_step; - const vec2 xy_offset7 = xy_start_offset + vec2(10.0, 7.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); - const vec3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); - const vec3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); - const vec3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); - const vec3 w8 = w7.bgr; - const vec3 w9 = w6.bgr; - const vec3 w10 = w5.bgr; - const vec3 w11 = w4.bgr; - const vec3 w12 = w3.bgr; - const vec3 w13 = w2.bgr; - const vec3 w14 = w1.bgr; - const vec3 w15 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - const vec2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); - const vec2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); - const vec2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); - const vec2 uv_offset6 = mul(true_pixel_to_tex_uv, xy_offset6 * frame_sign); - const vec2 uv_offset7 = mul(true_pixel_to_tex_uv, xy_offset7 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset3).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset4).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset5).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset6).rgb; - const vec3 sample7 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset7).rgb; - const vec3 sample8 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset7).rgb; - const vec3 sample9 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset6).rgb; - const vec3 sample10 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset5).rgb; - const vec3 sample11 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset4).rgb; - const vec3 sample12 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset3).rgb; - const vec3 sample13 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample14 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample15 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + - w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + - w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15); -} - -vec3 tex2Daa20x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 20-superqueens pattern where no 3 points are - // exactly collinear and superqueens have a squared attack radius of 13. - // . . . . . . . Q . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (7.0, 0.0)/20 - // . . . . . . . . . . . . . . . . Q . . . : off =(-9.5, -9.5)/20 + (16.0, 1.0)/20 - // . . . . . . . . . . . Q . . . . . . . . : off =(-9.5, -9.5)/20 + (11.0, 2.0)/20 - // . Q . . . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (1.0, 3.0)/20 - // . . . . . Q . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (5.0, 4.0)/20 - // . . . . . . . . . . . . . . . Q . . . . : off =(-9.5, -9.5)/20 + (15.0, 5.0)/20 - // . . . . . . . . . . Q . . . . . . . . . : off =(-9.5, -9.5)/20 + (10.0, 6.0)/20 - // . . . . . . . . . . . . . . . . . . . Q : off =(-9.5, -9.5)/20 + (19.0, 7.0)/20 - // . . Q . . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (2.0, 8.0)/20 - // . . . . . . Q . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (6.0, 9.0)/20 - // . . . . . . . . . . . . . Q . . . . . . : off =(-9.5, -9.5)/20 + (13.0, 10.0)/20 - // . . . . . . . . . . . . . . . . . Q . . : off =(-9.5, -9.5)/20 + (17.0, 11.0)/20 - // Q . . . . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (0.0, 12.0)/20 - // . . . . . . . . . Q . . . . . . . . . . : off =(-9.5, -9.5)/20 + (9.0, 13.0)/20 - // . . . . Q . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (4.0, 14.0)/20 - // . . . . . . . . . . . . . . Q . . . . . : off =(-9.5, -9.5)/20 + (14.0, 15.0)/20 - // . . . . . . . . . . . . . . . . . . Q . : off =(-9.5, -9.5)/20 + (18.0, 16.0)/20 - // . . . . . . . . Q . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (8.0, 17.0)/20 - // . . . Q . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (3.0, 18.0)/20 - // . . . . . . . . . . . . Q . . . . . . . : off =(-9.5, -9.5)/20 + (12.0, 19.0)/20 - const float grid_size = 20.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(7.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(16.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(11.0, 2.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(1.0, 3.0) * xy_step; - const vec2 xy_offset4 = xy_start_offset + vec2(5.0, 4.0) * xy_step; - const vec2 xy_offset5 = xy_start_offset + vec2(15.0, 5.0) * xy_step; - const vec2 xy_offset6 = xy_start_offset + vec2(10.0, 6.0) * xy_step; - const vec2 xy_offset7 = xy_start_offset + vec2(19.0, 7.0) * xy_step; - const vec2 xy_offset8 = xy_start_offset + vec2(2.0, 8.0) * xy_step; - const vec2 xy_offset9 = xy_start_offset + vec2(6.0, 9.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); - const vec3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); - const vec3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); - const vec3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); - const vec3 w8 = eval_unorm_rgb_weights(xy_offset8, final_axis_importance); - const vec3 w9 = eval_unorm_rgb_weights(xy_offset9, final_axis_importance); - const vec3 w10 = w9.bgr; - const vec3 w11 = w8.bgr; - const vec3 w12 = w7.bgr; - const vec3 w13 = w6.bgr; - const vec3 w14 = w5.bgr; - const vec3 w15 = w4.bgr; - const vec3 w16 = w3.bgr; - const vec3 w17 = w2.bgr; - const vec3 w18 = w1.bgr; - const vec3 w19 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - const vec2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); - const vec2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); - const vec2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); - const vec2 uv_offset6 = mul(true_pixel_to_tex_uv, xy_offset6 * frame_sign); - const vec2 uv_offset7 = mul(true_pixel_to_tex_uv, xy_offset7 * frame_sign); - const vec2 uv_offset8 = mul(true_pixel_to_tex_uv, xy_offset8 * frame_sign); - const vec2 uv_offset9 = mul(true_pixel_to_tex_uv, xy_offset9 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset3).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset4).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset5).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset6).rgb; - const vec3 sample7 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset7).rgb; - const vec3 sample8 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset8).rgb; - const vec3 sample9 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset9).rgb; - const vec3 sample10 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset9).rgb; - const vec3 sample11 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset8).rgb; - const vec3 sample12 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset7).rgb; - const vec3 sample13 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset6).rgb; - const vec3 sample14 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset5).rgb; - const vec3 sample15 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset4).rgb; - const vec3 sample16 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset3).rgb; - const vec3 sample17 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample18 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample19 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + - w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + - w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15 + - w16 * sample16 + w17 * sample17 + w18 * sample18 + w19 * sample19); -} - -vec3 tex2Daa24x(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Use a diagonally symmetric 24-superqueens pattern where no 3 points are - // exactly collinear and superqueens have a squared attack radius of 13. - // . . . . . . Q . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (6.0, 0.0)/24 - // . . . . . . . . . . . . . . . . Q . . . . . . . : off =(-11.5, -11.5)/24 + (16.0, 1.0)/24 - // . . . . . . . . . . Q . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (10.0, 2.0)/24 - // . . . . . . . . . . . . . . . . . . . . . Q . . : off =(-11.5, -11.5)/24 + (21.0, 3.0)/24 - // . . . . . Q . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (5.0, 4.0)/24 - // . . . . . . . . . . . . . . . Q . . . . . . . . : off =(-11.5, -11.5)/24 + (15.0, 5.0)/24 - // . Q . . . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (1.0, 6.0)/24 - // . . . . . . . . . . . Q . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (11.0, 7.0)/24 - // . . . . . . . . . . . . . . . . . . . Q . . . . : off =(-11.5, -11.5)/24 + (19.0, 8.0)/24 - // . . . . . . . . . . . . . . . . . . . . . . . Q : off =(-11.5, -11.5)/24 + (23.0, 9.0)/24 - // . . . Q . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (3.0, 10.0)/24 - // . . . . . . . . . . . . . . Q . . . . . . . . . : off =(-11.5, -11.5)/24 + (14.0, 11.0)/24 - // . . . . . . . . . Q . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (9.0, 12.0)/24 - // . . . . . . . . . . . . . . . . . . . . Q . . . : off =(-11.5, -11.5)/24 + (20.0, 13.0)/24 - // Q . . . . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (0.0, 14.0)/24 - // . . . . Q . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (4.0, 15.0)/24 - // . . . . . . . . . . . . Q . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (12.0, 16.0)/24 - // . . . . . . . . . . . . . . . . . . . . . . Q . : off =(-11.5, -11.5)/24 + (22.0, 17.0)/24 - // . . . . . . . . Q . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (8.0, 18.0)/24 - // . . . . . . . . . . . . . . . . . . Q . . . . . : off =(-11.5, -11.5)/24 + (18.0, 19.0)/24 - // . . Q . . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (2.0, 20.0)/24 - // . . . . . . . . . . . . . Q . . . . . . . . . . : off =(-11.5, -11.5)/24 + (13.0, 21.0)/24 - // . . . . . . . Q . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (7.0, 22.0)/24 - // . . . . . . . . . . . . . . . . . Q . . . . . . : off =(-11.5, -11.5)/24 + (17.0, 23.0)/24 - const float grid_size = 24.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample. Exploit diagonal symmetry: - const vec2 xy_offset0 = xy_start_offset + vec2(6.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(16.0, 1.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(10.0, 2.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(21.0, 3.0) * xy_step; - const vec2 xy_offset4 = xy_start_offset + vec2(5.0, 4.0) * xy_step; - const vec2 xy_offset5 = xy_start_offset + vec2(15.0, 5.0) * xy_step; - const vec2 xy_offset6 = xy_start_offset + vec2(1.0, 6.0) * xy_step; - const vec2 xy_offset7 = xy_start_offset + vec2(11.0, 7.0) * xy_step; - const vec2 xy_offset8 = xy_start_offset + vec2(19.0, 8.0) * xy_step; - const vec2 xy_offset9 = xy_start_offset + vec2(23.0, 9.0) * xy_step; - const vec2 xy_offset10 = xy_start_offset + vec2(3.0, 10.0) * xy_step; - const vec2 xy_offset11 = xy_start_offset + vec2(14.0, 11.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); - const vec3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); - const vec3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); - const vec3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); - const vec3 w8 = eval_unorm_rgb_weights(xy_offset8, final_axis_importance); - const vec3 w9 = eval_unorm_rgb_weights(xy_offset9, final_axis_importance); - const vec3 w10 = eval_unorm_rgb_weights(xy_offset10, final_axis_importance); - const vec3 w11 = eval_unorm_rgb_weights(xy_offset11, final_axis_importance); - const vec3 w12 = w11.bgr; - const vec3 w13 = w10.bgr; - const vec3 w14 = w9.bgr; - const vec3 w15 = w8.bgr; - const vec3 w16 = w7.bgr; - const vec3 w17 = w6.bgr; - const vec3 w18 = w5.bgr; - const vec3 w19 = w4.bgr; - const vec3 w20 = w3.bgr; - const vec3 w21 = w2.bgr; - const vec3 w22 = w1.bgr; - const vec3 w23 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2 + w3 + w4 + - w5 + w6 + w7 + w8 + w9 + w10 + w11; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, mirror on odd frames if directed, and exploit - // diagonal symmetry: - const vec2 frame_sign = get_frame_sign(frame); - const vec2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); - const vec2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); - const vec2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); - const vec2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); - const vec2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); - const vec2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); - const vec2 uv_offset6 = mul(true_pixel_to_tex_uv, xy_offset6 * frame_sign); - const vec2 uv_offset7 = mul(true_pixel_to_tex_uv, xy_offset7 * frame_sign); - const vec2 uv_offset8 = mul(true_pixel_to_tex_uv, xy_offset8 * frame_sign); - const vec2 uv_offset9 = mul(true_pixel_to_tex_uv, xy_offset9 * frame_sign); - const vec2 uv_offset10 = mul(true_pixel_to_tex_uv, xy_offset10 * frame_sign); - const vec2 uv_offset11 = mul(true_pixel_to_tex_uv, xy_offset11 * frame_sign); - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset0).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset1).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset2).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset3).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset4).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset5).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset6).rgb; - const vec3 sample7 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset7).rgb; - const vec3 sample8 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset8).rgb; - const vec3 sample9 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset9).rgb; - const vec3 sample10 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset10).rgb; - const vec3 sample11 = tex2Daa_tiled_linearize(texture, tex_uv + uv_offset11).rgb; - const vec3 sample12 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset11).rgb; - const vec3 sample13 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset10).rgb; - const vec3 sample14 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset9).rgb; - const vec3 sample15 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset8).rgb; - const vec3 sample16 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset7).rgb; - const vec3 sample17 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset6).rgb; - const vec3 sample18 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset5).rgb; - const vec3 sample19 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset4).rgb; - const vec3 sample20 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset3).rgb; - const vec3 sample21 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset2).rgb; - const vec3 sample22 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset1).rgb; - const vec3 sample23 = tex2Daa_tiled_linearize(texture, tex_uv - uv_offset0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + - w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + - w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15 + - w16 * sample16 + w17 * sample17 + w18 * sample18 + w19 * sample19 + - w20 * sample20 + w21 * sample21 + w22 * sample22 + w23 * sample23); -} - -vec3 tex2Daa_debug_16x_regular(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Sample on a regular 4x4 grid. This is mainly for testing. - const float grid_size = 4.0; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const vec2 xy_step = vec2(1.0)/grid_size * subpixel_support_diameter; - const vec2 xy_start_offset = vec2(0.5 - grid_size*0.5) * xy_step; - // Get the xy offset of each sample: - const vec2 xy_offset0 = xy_start_offset + vec2(0.0, 0.0) * xy_step; - const vec2 xy_offset1 = xy_start_offset + vec2(1.0, 0.0) * xy_step; - const vec2 xy_offset2 = xy_start_offset + vec2(2.0, 0.0) * xy_step; - const vec2 xy_offset3 = xy_start_offset + vec2(3.0, 0.0) * xy_step; - const vec2 xy_offset4 = xy_start_offset + vec2(0.0, 1.0) * xy_step; - const vec2 xy_offset5 = xy_start_offset + vec2(1.0, 1.0) * xy_step; - const vec2 xy_offset6 = xy_start_offset + vec2(2.0, 1.0) * xy_step; - const vec2 xy_offset7 = xy_start_offset + vec2(3.0, 1.0) * xy_step; - // Compute subpixel weights, and exploit diagonal symmetry for speed. - // (We can't exploit vertical or horizontal symmetry due to uncertain - // subpixel offsets. We could fix that by rotating xy offsets with the - // subpixel structure, but...no.) - const vec3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); - const vec3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); - const vec3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); - const vec3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); - const vec3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); - const vec3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); - const vec3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); - const vec3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); - const vec3 w8 = w7.bgr; - const vec3 w9 = w6.bgr; - const vec3 w10 = w5.bgr; - const vec3 w11 = w4.bgr; - const vec3 w12 = w3.bgr; - const vec3 w13 = w2.bgr; - const vec3 w14 = w1.bgr; - const vec3 w15 = w0.bgr; - // Get the weight sum to normalize the total to 1.0 later: - const vec3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7; - const vec3 w_sum = half_sum + half_sum.bgr; - const vec3 w_sum_inv = vec3(1.0)/(w_sum); - // Scale the pixel-space to texture offset matrix by the pixel diameter. - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - // Get uv sample offsets, taking advantage of row alignment: - const vec2 uv_step_x = mul(true_pixel_to_tex_uv, vec2(xy_step.x, 0.0)); - const vec2 uv_step_y = mul(true_pixel_to_tex_uv, vec2(0.0, xy_step.y)); - const vec2 uv_offset0 = -1.5 * (uv_step_x + uv_step_y); - const vec2 sample0_uv = tex_uv + uv_offset0; - const vec2 sample4_uv = sample0_uv + uv_step_y; - const vec2 sample8_uv = sample0_uv + uv_step_y * 2.0; - const vec2 sample12_uv = sample0_uv + uv_step_y * 3.0; - // Load samples, linearizing if necessary, etc.: - const vec3 sample0 = tex2Daa_tiled_linearize(texture, sample0_uv).rgb; - const vec3 sample1 = tex2Daa_tiled_linearize(texture, sample0_uv + uv_step_x).rgb; - const vec3 sample2 = tex2Daa_tiled_linearize(texture, sample0_uv + uv_step_x * 2.0).rgb; - const vec3 sample3 = tex2Daa_tiled_linearize(texture, sample0_uv + uv_step_x * 3.0).rgb; - const vec3 sample4 = tex2Daa_tiled_linearize(texture, sample4_uv).rgb; - const vec3 sample5 = tex2Daa_tiled_linearize(texture, sample4_uv + uv_step_x).rgb; - const vec3 sample6 = tex2Daa_tiled_linearize(texture, sample4_uv + uv_step_x * 2.0).rgb; - const vec3 sample7 = tex2Daa_tiled_linearize(texture, sample4_uv + uv_step_x * 3.0).rgb; - const vec3 sample8 = tex2Daa_tiled_linearize(texture, sample8_uv).rgb; - const vec3 sample9 = tex2Daa_tiled_linearize(texture, sample8_uv + uv_step_x).rgb; - const vec3 sample10 = tex2Daa_tiled_linearize(texture, sample8_uv + uv_step_x * 2.0).rgb; - const vec3 sample11 = tex2Daa_tiled_linearize(texture, sample8_uv + uv_step_x * 3.0).rgb; - const vec3 sample12 = tex2Daa_tiled_linearize(texture, sample12_uv).rgb; - const vec3 sample13 = tex2Daa_tiled_linearize(texture, sample12_uv + uv_step_x).rgb; - const vec3 sample14 = tex2Daa_tiled_linearize(texture, sample12_uv + uv_step_x * 2.0).rgb; - const vec3 sample15 = tex2Daa_tiled_linearize(texture, sample12_uv + uv_step_x * 3.0).rgb; - // Sum weighted samples (weight sum must equal 1.0 for each channel): - return w_sum_inv * ( - w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + - w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + - w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + - w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15); -} - -vec3 tex2Daa_debug_dynamic(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // This function is for testing only: Use an NxN grid with dynamic weights. - const int grid_size = 8; - assign_aa_cubic_constants(); - const vec4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); - const vec2 subpixel_support_diameter = ssd_fai.xy; - const vec2 final_axis_importance = ssd_fai.zw; - const float grid_radius_in_samples = (float(grid_size) - 1.0)/2.0; - const vec2 filter_space_offset_step = - subpixel_support_diameter/vec2(grid_size); - const vec2 sample0_filter_space_offset = - -grid_radius_in_samples * filter_space_offset_step; - // Compute xy sample offsets and subpixel weights: - vec3 weights[grid_size * grid_size]; - vec3 weight_sum = 0.0; - for(int i = 0; i < grid_size; ++i) - { - for(int j = 0; j < grid_size; ++j) - { - // Weights based on xy distances: - const vec2 offset = sample0_filter_space_offset + - vec2(j, i) * filter_space_offset_step; - const vec3 weight = eval_unorm_rgb_weights(offset, final_axis_importance); - weights[i*grid_size + j] = weight; - weight_sum += weight; - } - } - // Get uv offset vectors along x and y directions: - const vec2x2 true_pixel_to_tex_uv = - vec2x2(vec4(pixel_to_tex_uv * aa_pixel_diameter)); - const vec2 uv_offset_step_x = mul(true_pixel_to_tex_uv, - vec2(filter_space_offset_step.x, 0.0)); - const vec2 uv_offset_step_y = mul(true_pixel_to_tex_uv, - vec2(0.0, filter_space_offset_step.y)); - // Get a starting sample location: - const vec2 sample0_uv_offset = -grid_radius_in_samples * - (uv_offset_step_x + uv_offset_step_y); - const vec2 sample0_uv = tex_uv + sample0_uv_offset; - // Load, weight, and sum [linearized] samples: - vec3 sum = 0.0; - const vec3 weight_sum_inv = vec3(1.0)/weight_sum; - for(int i = 0; i < grid_size; ++i) - { - const vec2 row_i_first_sample_uv = - sample0_uv + i * uv_offset_step_y; - for(int j = 0; j < grid_size; ++j) - { - const vec2 sample_uv = - row_i_first_sample_uv + j * uv_offset_step_x; - sum += weights[i*grid_size + j] * - tex2Daa_tiled_linearize(texture, sample_uv).rgb; - } - } - return sum * weight_sum_inv; -} - - -/////////////////////// ANTIALIASING CODEPATH SELECTION ////////////////////// - -vec3 tex2Daa(const sampler2D texture, const vec2 tex_uv, - const vec2x2 pixel_to_tex_uv, const float frame) -{ - // Statically switch between antialiasing modes/levels: - return aa_level < 0.5 ? tex2D_linearize(texture, tex_uv).rgb : - aa_level < 3.5 ? tex2Daa_subpixel_weights_only( - texture, tex_uv, pixel_to_tex_uv) : - aa_level < 4.5 ? tex2Daa4x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 5.5 ? tex2Daa5x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 6.5 ? tex2Daa6x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 7.5 ? tex2Daa7x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 11.5 ? tex2Daa8x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 15.5 ? tex2Daa12x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 19.5 ? tex2Daa16x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 23.5 ? tex2Daa20x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 253.5 ? tex2Daa24x(texture, tex_uv, pixel_to_tex_uv, frame) : - aa_level < 254.5 ? tex2Daa_debug_16x_regular( - texture, tex_uv, pixel_to_tex_uv, frame) : - tex2Daa_debug_dynamic(texture, tex_uv, pixel_to_tex_uv, frame); -} - - -#endif // TEX2DANTIALIAS_H - diff --git a/crt/shaders/crt-royale/user-settings.h b/crt/shaders/crt-royale/user-settings.h index b631311..d6bd75f 100644 --- a/crt/shaders/crt-royale/user-settings.h +++ b/crt/shaders/crt-royale/user-settings.h @@ -74,7 +74,7 @@ // Enable runtime shader parameters in the Retroarch (etc.) GUI? They override // many of the options in this file and allow real-time tuning, but many of // them are slower. Disabling them and using this text file will boost FPS. -#define RUNTIME_SHADER_PARAMS_ENABLE +//#define RUNTIME_SHADER_PARAMS_ENABLE // Specify the phosphor bloom sigma at runtime? This option is 10% slower, but // it's the only way to do a wide-enough full bloom with a runtime dot pitch. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA diff --git a/include/blur-functions-old.h b/include/blur-functions-old.h deleted file mode 100644 index 05da1c7..0000000 --- a/include/blur-functions-old.h +++ /dev/null @@ -1,1916 +0,0 @@ -#ifndef BLUR_FUNCTIONS_H -#define BLUR_FUNCTIONS_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file provides reusable one-pass and separable (two-pass) blurs. -// Requires: All blurs share these requirements (dxdy requirement is split): -// 1.) All requirements of gamma-management.h must be satisfied! -// 2.) filter_linearN must == "true" in your .cgp preset unless -// you're using tex2DblurNresize at 1x scale. -// 3.) mipmap_inputN must == "true" in your .cgp preset if -// IN.output_size < IN.video_size. -// 4.) IN.output_size == IN.video_size / pow(2, M), where M is some -// positive integer. tex2Dblur*resize can resize arbitrarily -// (and the blur will be done after resizing), but arbitrary -// resizes "fail" with other blurs due to the way they mix -// static weights with bilinear sample exploitation. -// 5.) In general, dxdy should contain the uv pixel spacing: -// dxdy = (IN.video_size/IN.output_size)/IN.texture_size -// 6.) For separable blurs (tex2DblurNresize and tex2DblurNfast), -// zero out the dxdy component in the unblurred dimension: -// dxdy = vec2(dxdy.x, 0.0) or vec2(0.0, dxdy.y) -// Many blurs share these requirements: -// 1.) One-pass blurs require scale_xN == scale_yN or scales > 1.0, -// or they will blur more in the lower-scaled dimension. -// 2.) One-pass shared sample blurs require ddx(), ddy(), and -// tex2Dlod() to be supported by the current Cg profile, and -// the drivers must support high-quality derivatives. -// 3.) One-pass shared sample blurs require: -// tex_uv.w == log2(IN.video_size/IN.output_size).y; -// Non-wrapper blurs share this requirement: -// 1.) sigma is the intended standard deviation of the blur -// Wrapper blurs share this requirement, which is automatically -// met (unless OVERRIDE_BLUR_STD_DEVS is #defined; see below): -// 1.) blurN_std_dev must be global static const float values -// specifying standard deviations for Nx blurs in units -// of destination pixels -// Optional: 1.) The including file (or an earlier included file) may -// optionally #define USE_BINOMIAL_BLUR_STD_DEVS to replace -// default standard deviations with those matching a binomial -// distribution. (See below for details/properties.) -// 2.) The including file (or an earlier included file) may -// optionally #define OVERRIDE_BLUR_STD_DEVS and override: -// static const float blur3_std_dev -// static const float blur4_std_dev -// static const float blur5_std_dev -// static const float blur6_std_dev -// static const float blur7_std_dev -// static const float blur8_std_dev -// static const float blur9_std_dev -// static const float blur10_std_dev -// static const float blur11_std_dev -// static const float blur12_std_dev -// static const float blur17_std_dev -// static const float blur25_std_dev -// static const float blur31_std_dev -// static const float blur43_std_dev -// 3.) The including file (or an earlier included file) may -// optionally #define OVERRIDE_ERROR_BLURRING and override: -// static const float error_blurring -// This tuning value helps mitigate weighting errors from one- -// pass shared-sample blurs sharing bilinear samples between -// fragments. Values closer to 0.0 have "correct" blurriness -// but allow more artifacts, and values closer to 1.0 blur away -// artifacts by sampling closer to halfway between texels. -// UPDATE 6/21/14: The above static constants may now be overridden -// by non-static uniform constants. This permits exposing blur -// standard deviations as runtime GUI shader parameters. However, -// using them keeps weights from being statically computed, and the -// speed hit depends on the blur: On my machine, uniforms kill over -// 53% of the framerate with tex2Dblur12x12shared, but they only -// drop the framerate by about 18% with tex2Dblur11fast. -// Quality and Performance Comparisons: -// For the purposes of the following discussion, "no sRGB" means -// GAMMA_ENCODE_EVERY_FBO is #defined, and "sRGB" means it isn't. -// 1.) tex2DblurNfast is always faster than tex2DblurNresize. -// 2.) tex2DblurNresize functions are the only ones that can arbitrarily resize -// well, because they're the only ones that don't exploit bilinear samples. -// This also means they're the only functions which can be truly gamma- -// correct without linear (or sRGB FBO) input, but only at 1x scale. -// 3.) One-pass shared sample blurs only have a speed advantage without sRGB. -// They also have some inaccuracies due to their shared-[bilinear-]sample -// design, which grow increasingly bothersome for smaller blurs and higher- -// frequency source images (relative to their resolution). I had high -// hopes for them, but their most realistic use case is limited to quickly -// reblurring an already blurred input at full resolution. Otherwise: -// a.) If you're blurring a low-resolution source, you want a better blur. -// b.) If you're blurring a lower mipmap, you want a better blur. -// c.) If you're blurring a high-resolution, high-frequency source, you -// want a better blur. -// 4.) The one-pass blurs without shared samples grow slower for larger blurs, -// but they're competitive with separable blurs at 5x5 and smaller, and -// even tex2Dblur7x7 isn't bad if you're wanting to conserve passes. -// Here are some framerates from a GeForce 8800GTS. The first pass resizes to -// viewport size (4x in this test) and linearizes for sRGB codepaths, and the -// remaining passes perform 6 full blurs. Mipmapped tests are performed at the -// same scale, so they just measure the cost of mipmapping each FBO (only every -// other FBO is mipmapped for separable blurs, to mimic realistic usage). -// Mipmap Neither sRGB+Mipmap sRGB Function -// 76.0 92.3 131.3 193.7 tex2Dblur3fast -// 63.2 74.4 122.4 175.5 tex2Dblur3resize -// 93.7 121.2 159.3 263.2 tex2Dblur3x3 -// 59.7 68.7 115.4 162.1 tex2Dblur3x3resize -// 63.2 74.4 122.4 175.5 tex2Dblur5fast -// 49.3 54.8 100.0 132.7 tex2Dblur5resize -// 59.7 68.7 115.4 162.1 tex2Dblur5x5 -// 64.9 77.2 99.1 137.2 tex2Dblur6x6shared -// 55.8 63.7 110.4 151.8 tex2Dblur7fast -// 39.8 43.9 83.9 105.8 tex2Dblur7resize -// 40.0 44.2 83.2 104.9 tex2Dblur7x7 -// 56.4 65.5 71.9 87.9 tex2Dblur8x8shared -// 49.3 55.1 99.9 132.5 tex2Dblur9fast -// 33.3 36.2 72.4 88.0 tex2Dblur9resize -// 27.8 29.7 61.3 72.2 tex2Dblur9x9 -// 37.2 41.1 52.6 60.2 tex2Dblur10x10shared -// 44.4 49.5 91.3 117.8 tex2Dblur11fast -// 28.8 30.8 63.6 75.4 tex2Dblur11resize -// 33.6 36.5 40.9 45.5 tex2Dblur12x12shared -// TODO: Fill in benchmarks for new untested blurs. -// tex2Dblur17fast -// tex2Dblur25fast -// tex2Dblur31fast -// tex2Dblur43fast -// tex2Dblur3x3resize - - -///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// - -// Set static standard deviations, but allow users to override them with their -// own constants (even non-static uniforms if they're okay with the speed hit): -#ifndef OVERRIDE_BLUR_STD_DEVS - // blurN_std_dev values are specified in terms of dxdy strides. - #ifdef USE_BINOMIAL_BLUR_STD_DEVS - // By request, we can define standard deviations corresponding to a - // binomial distribution with p = 0.5 (related to Pascal's triangle). - // This distribution works such that blurring multiple times should - // have the same result as a single larger blur. These values are - // larger than default for blurs up to 6x and smaller thereafter. - const float blur3_std_dev = 0.84931640625; - const float blur4_std_dev = 0.84931640625; - const float blur5_std_dev = 1.0595703125; - const float blur6_std_dev = 1.06591796875; - const float blur7_std_dev = 1.17041015625; - const float blur8_std_dev = 1.1720703125; - const float blur9_std_dev = 1.2259765625; - const float blur10_std_dev = 1.21982421875; - const float blur11_std_dev = 1.25361328125; - const float blur12_std_dev = 1.2423828125; - const float blur17_std_dev = 1.27783203125; - const float blur25_std_dev = 1.2810546875; - const float blur31_std_dev = 1.28125; - const float blur43_std_dev = 1.28125; - #else - // The defaults are the largest values that keep the largest unused - // blur term on each side <= 1.0/256.0. (We could get away with more - // or be more conservative, but this compromise is pretty reasonable.) - const float blur3_std_dev = 0.62666015625; - const float blur4_std_dev = 0.66171875; - const float blur5_std_dev = 0.9845703125; - const float blur6_std_dev = 1.02626953125; - const float blur7_std_dev = 1.36103515625; - const float blur8_std_dev = 1.4080078125; - const float blur9_std_dev = 1.7533203125; - const float blur10_std_dev = 1.80478515625; - const float blur11_std_dev = 2.15986328125; - const float blur12_std_dev = 2.215234375; - const float blur17_std_dev = 3.45535583496; - const float blur25_std_dev = 5.3409576416; - const float blur31_std_dev = 6.86488037109; - const float blur43_std_dev = 10.1852050781; - #endif // USE_BINOMIAL_BLUR_STD_DEVS -#endif // OVERRIDE_BLUR_STD_DEVS - -#ifndef OVERRIDE_ERROR_BLURRING - // error_blurring should be in [0.0, 1.0]. Higher values reduce ringing - // in shared-sample blurs but increase blurring and feature shifting. - const float error_blurring = 0.5; -#endif - - -////////////////////////////////// INCLUDES ////////////////////////////////// - -// gamma-management.h relies on pass-specific settings to guide its behavior: -// FIRST_PASS, LAST_PASS, GAMMA_ENCODE_EVERY_FBO, etc. See it for details. -//#include "gamma-management.h" -#include "quad-pixel-communication.h" -#include "special-functions.h" - - -/////////////////////////////////// HELPERS ////////////////////////////////// - -vec4 uv2_to_uv4(vec2 tex_uv) -{ - // Make a vec2 uv offset safe for adding to vec4 tex2Dlod coords: - return vec4(tex_uv, 0.0, 0.0); -} - -// Make a length squared helper macro (for usage with static constants): -#define LENGTH_SQ(vec) (dot(vec, vec)) - -float get_fast_gaussian_weight_sum_inv(const float sigma) -{ - // We can use the Gaussian integral to calculate the asymptotic weight for - // the center pixel. Since the unnormalized center pixel weight is 1.0, - // the normalized weight is the same as the weight sum inverse. Given a - // large enough blur (9+), the asymptotic weight sum is close and faster: - // center_weight = 0.5 * - // (erf(0.5/(sigma*sqrt(2.0))) - erf(-0.5/(sigma*sqrt(2.0)))) - // erf(-x) == -erf(x), so we get 0.5 * (2.0 * erf(blah blah)): - // However, we can get even faster results with curve-fitting. These are - // also closer than the asymptotic results, because they were constructed - // from 64 blurs sizes from [3, 131) and 255 equally-spaced sigmas from - // (0, blurN_std_dev), so the results for smaller sigmas are biased toward - // smaller blurs. The max error is 0.0031793913. - // Relative FPS: 134.3 with erf, 135.8 with curve-fitting. - //static const float temp = 0.5/sqrt(2.0); - //return erf(temp/sigma); - return min(exp(exp(0.348348412457428/ - (sigma - 0.0860587260734721))), 0.399334576340352/sigma); -} - - -//////////////////// ARBITRARILY RESIZABLE SEPARABLE BLURS /////////////////// - -vec3 tex2Dblur11resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 11x Gaussian blurred texture lookup using a 11-tap blur. - // It may be mipmapped depending on settings and dxdy. - // Calculate Gaussian blur kernel weights and a normalization factor for - // distances of 0-4, ignoring constant factors (since we're normalizing). - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float weight_sum_inv = 1.0 / - (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5)); - // Statically normalize weights, sum weighted samples, and return. Blurs are - // currently optimized for dynamic weights. - vec3 sum = vec3(0.0); - sum += w5 * tex2D_linearize(texture, tex_uv - 5.0 * dxdy).rgb; - sum += w4 * tex2D_linearize(texture, tex_uv - 4.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv - 3.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv + 3.0 * dxdy).rgb; - sum += w4 * tex2D_linearize(texture, tex_uv + 4.0 * dxdy).rgb; - sum += w5 * tex2D_linearize(texture, tex_uv + 5.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur9resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 9x Gaussian blurred texture lookup using a 9-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4)); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w4 * tex2D_linearize(texture, tex_uv - 4.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv - 3.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv + 3.0 * dxdy).rgb; - sum += w4 * tex2D_linearize(texture, tex_uv + 4.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur7resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 7x Gaussian blurred texture lookup using a 7-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3)); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w3 * tex2D_linearize(texture, tex_uv - 3.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - sum += w3 * tex2D_linearize(texture, tex_uv + 3.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur5resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 5x Gaussian blurred texture lookup using a 5-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2)); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w2 * tex2D_linearize(texture, tex_uv - 2.0 * dxdy).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - sum += w2 * tex2D_linearize(texture, tex_uv + 2.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 1D 3x Gaussian blurred texture lookup using a 3-tap blur. - // It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * w1); - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w1 * tex2D_linearize(texture, tex_uv - 1.0 * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1 * tex2D_linearize(texture, tex_uv + 1.0 * dxdy).rgb; - return sum * weight_sum_inv; -} - - -/////////////////////////// FAST SEPARABLE BLURS /////////////////////////// - -vec3 tex2Dblur11fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: 1.) Global requirements must be met (see file description). - // 2.) filter_linearN must = "true" in your .cgp file. - // 3.) For gamma-correct bilinear filtering, global - // gamma_aware_bilinear == true (from gamma-management.h) - // Returns: A 1D 11x Gaussian blurred texture lookup using 6 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float weight_sum_inv = 1.0 / - (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5)); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w01 = w0 * 0.5 + w1; - const float w23 = w2 + w3; - const float w45 = w4 + w5; - const float w01_ratio = w1/w01; - const float w23_ratio = w3/w23; - const float w45_ratio = w5/w45; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w45 * tex2D_linearize(texture, tex_uv - (4.0 + w45_ratio) * dxdy).rgb; - sum += w23 * tex2D_linearize(texture, tex_uv - (2.0 + w23_ratio) * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv - w01_ratio * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv + w01_ratio * dxdy).rgb; - sum += w23 * tex2D_linearize(texture, tex_uv + (2.0 + w23_ratio) * dxdy).rgb; - sum += w45 * tex2D_linearize(texture, tex_uv + (4.0 + w45_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur9fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 9x Gaussian blurred texture lookup using 1 nearest - // neighbor and 4 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4)); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w12 = w1 + w2; - const float w34 = w3 + w4; - const float w12_ratio = w2/w12; - const float w34_ratio = w4/w34; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w34 * tex2D_linearize(texture, tex_uv - (3.0 + w34_ratio) * dxdy).rgb; - sum += w12 * tex2D_linearize(texture, tex_uv - (1.0 + w12_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w12 * tex2D_linearize(texture, tex_uv + (1.0 + w12_ratio) * dxdy).rgb; - sum += w34 * tex2D_linearize(texture, tex_uv + (3.0 + w34_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur7fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 7x Gaussian blurred texture lookup using 4 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3)); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w01 = w0 * 0.5 + w1; - const float w23 = w2 + w3; - const float w01_ratio = w1/w01; - const float w23_ratio = w3/w23; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w23 * tex2D_linearize(texture, tex_uv - (2.0 + w23_ratio) * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv - w01_ratio * dxdy).rgb; - sum += w01 * tex2D_linearize(texture, tex_uv + w01_ratio * dxdy).rgb; - sum += w23 * tex2D_linearize(texture, tex_uv + (2.0 + w23_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur5fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 5x Gaussian blurred texture lookup using 1 nearest - // neighbor and 2 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2)); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w12 = w1 + w2; - const float w12_ratio = w2/w12; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w12 * tex2D_linearize(texture, tex_uv - (1.0 + w12_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w12 * tex2D_linearize(texture, tex_uv + (1.0 + w12_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur3fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 3x Gaussian blurred texture lookup using 2 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float weight_sum_inv = 1.0 / (w0 + 2.0 * w1); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w01 = w0 * 0.5 + w1; - const float w01_ratio = w1/w01; - // Weights for all samples are the same, so just average them: - return 0.5 * ( - tex2D_linearize(texture, tex_uv - w01_ratio * dxdy).rgb + - tex2D_linearize(texture, tex_uv + w01_ratio * dxdy).rgb); -} - - -//////////////////////////// HUGE SEPARABLE BLURS //////////////////////////// - -// Huge separable blurs come only in "fast" versions. -vec3 tex2Dblur43fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 43x Gaussian blurred texture lookup using 22 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - const float w13 = exp(-169.0 * denom_inv); - const float w14 = exp(-196.0 * denom_inv); - const float w15 = exp(-225.0 * denom_inv); - const float w16 = exp(-256.0 * denom_inv); - const float w17 = exp(-289.0 * denom_inv); - const float w18 = exp(-324.0 * denom_inv); - const float w19 = exp(-361.0 * denom_inv); - const float w20 = exp(-400.0 * denom_inv); - const float w21 = exp(-441.0 * denom_inv); - //const float weight_sum_inv = 1.0 / - // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + - // w12 + w13 + w14 + w15 + w16 + w17 + w18 + w19 + w20 + w21)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w0_1 = w0 * 0.5 + w1; - const float w2_3 = w2 + w3; - const float w4_5 = w4 + w5; - const float w6_7 = w6 + w7; - const float w8_9 = w8 + w9; - const float w10_11 = w10 + w11; - const float w12_13 = w12 + w13; - const float w14_15 = w14 + w15; - const float w16_17 = w16 + w17; - const float w18_19 = w18 + w19; - const float w20_21 = w20 + w21; - const float w0_1_ratio = w1/w0_1; - const float w2_3_ratio = w3/w2_3; - const float w4_5_ratio = w5/w4_5; - const float w6_7_ratio = w7/w6_7; - const float w8_9_ratio = w9/w8_9; - const float w10_11_ratio = w11/w10_11; - const float w12_13_ratio = w13/w12_13; - const float w14_15_ratio = w15/w14_15; - const float w16_17_ratio = w17/w16_17; - const float w18_19_ratio = w19/w18_19; - const float w20_21_ratio = w21/w20_21; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w20_21 * tex2D_linearize(texture, tex_uv - (20.0 + w20_21_ratio) * dxdy).rgb; - sum += w18_19 * tex2D_linearize(texture, tex_uv - (18.0 + w18_19_ratio) * dxdy).rgb; - sum += w16_17 * tex2D_linearize(texture, tex_uv - (16.0 + w16_17_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(texture, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv - w0_1_ratio * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv + w0_1_ratio * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(texture, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w16_17 * tex2D_linearize(texture, tex_uv + (16.0 + w16_17_ratio) * dxdy).rgb; - sum += w18_19 * tex2D_linearize(texture, tex_uv + (18.0 + w18_19_ratio) * dxdy).rgb; - sum += w20_21 * tex2D_linearize(texture, tex_uv + (20.0 + w20_21_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur31fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 31x Gaussian blurred texture lookup using 16 linear - // taps. It may be mipmapped depending on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - const float w13 = exp(-169.0 * denom_inv); - const float w14 = exp(-196.0 * denom_inv); - const float w15 = exp(-225.0 * denom_inv); - //const float weight_sum_inv = 1.0 / - // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + - // w9 + w10 + w11 + w12 + w13 + w14 + w15)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - // The center texel (with weight w0) is used twice, so halve its weight. - const float w0_1 = w0 * 0.5 + w1; - const float w2_3 = w2 + w3; - const float w4_5 = w4 + w5; - const float w6_7 = w6 + w7; - const float w8_9 = w8 + w9; - const float w10_11 = w10 + w11; - const float w12_13 = w12 + w13; - const float w14_15 = w14 + w15; - const float w0_1_ratio = w1/w0_1; - const float w2_3_ratio = w3/w2_3; - const float w4_5_ratio = w5/w4_5; - const float w6_7_ratio = w7/w6_7; - const float w8_9_ratio = w9/w8_9; - const float w10_11_ratio = w11/w10_11; - const float w12_13_ratio = w13/w12_13; - const float w14_15_ratio = w15/w14_15; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w14_15 * tex2D_linearize(texture, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv - w0_1_ratio * dxdy).rgb; - sum += w0_1 * tex2D_linearize(texture, tex_uv + w0_1_ratio * dxdy).rgb; - sum += w2_3 * tex2D_linearize(texture, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; - sum += w4_5 * tex2D_linearize(texture, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; - sum += w6_7 * tex2D_linearize(texture, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; - sum += w8_9 * tex2D_linearize(texture, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; - sum += w10_11 * tex2D_linearize(texture, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; - sum += w12_13 * tex2D_linearize(texture, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; - sum += w14_15 * tex2D_linearize(texture, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur25fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 25x Gaussian blurred texture lookup using 1 nearest - // neighbor and 12 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - const float w9 = exp(-81.0 * denom_inv); - const float w10 = exp(-100.0 * denom_inv); - const float w11 = exp(-121.0 * denom_inv); - const float w12 = exp(-144.0 * denom_inv); - //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( - // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + w12)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w1_2 = w1 + w2; - const float w3_4 = w3 + w4; - const float w5_6 = w5 + w6; - const float w7_8 = w7 + w8; - const float w9_10 = w9 + w10; - const float w11_12 = w11 + w12; - const float w1_2_ratio = w2/w1_2; - const float w3_4_ratio = w4/w3_4; - const float w5_6_ratio = w6/w5_6; - const float w7_8_ratio = w8/w7_8; - const float w9_10_ratio = w10/w9_10; - const float w11_12_ratio = w12/w11_12; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w11_12 * tex2D_linearize(texture, tex_uv - (11.0 + w11_12_ratio) * dxdy).rgb; - sum += w9_10 * tex2D_linearize(texture, tex_uv - (9.0 + w9_10_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(texture, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(texture, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w9_10 * tex2D_linearize(texture, tex_uv + (9.0 + w9_10_ratio) * dxdy).rgb; - sum += w11_12 * tex2D_linearize(texture, tex_uv + (11.0 + w11_12_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - -vec3 tex2Dblur17fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Same as tex2Dblur11() - // Returns: A 1D 17x Gaussian blurred texture lookup using 1 nearest - // neighbor and 8 linear taps. It may be mipmapped depending - // on settings and dxdy. - // First get the texel weights and normalization factor as above. - const float denom_inv = 0.5/(sigma*sigma); - const float w0 = 1.0; - const float w1 = exp(-1.0 * denom_inv); - const float w2 = exp(-4.0 * denom_inv); - const float w3 = exp(-9.0 * denom_inv); - const float w4 = exp(-16.0 * denom_inv); - const float w5 = exp(-25.0 * denom_inv); - const float w6 = exp(-36.0 * denom_inv); - const float w7 = exp(-49.0 * denom_inv); - const float w8 = exp(-64.0 * denom_inv); - //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( - // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8)); - const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); - // Calculate combined weights and linear sample ratios between texel pairs. - const float w1_2 = w1 + w2; - const float w3_4 = w3 + w4; - const float w5_6 = w5 + w6; - const float w7_8 = w7 + w8; - const float w1_2_ratio = w2/w1_2; - const float w3_4_ratio = w4/w3_4; - const float w5_6_ratio = w6/w5_6; - const float w7_8_ratio = w8/w7_8; - // Statically normalize weights, sum weighted samples, and return: - vec3 sum = vec3(0.0); - sum += w7_8 * tex2D_linearize(texture, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w0 * tex2D_linearize(texture, tex_uv).rgb; - sum += w1_2 * tex2D_linearize(texture, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; - sum += w3_4 * tex2D_linearize(texture, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; - sum += w5_6 * tex2D_linearize(texture, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; - sum += w7_8 * tex2D_linearize(texture, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; - return sum * weight_sum_inv; -} - - -//////////////////// ARBITRARILY RESIZABLE ONE-PASS BLURS //////////////////// - -vec3 tex2Dblur3x3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Requires: Global requirements must be met (see file description). - // Returns: A 3x3 Gaussian blurred mipmapped texture lookup of the - // resized input. - // Description: - // This is the only arbitrarily resizable one-pass blur; tex2Dblur5x5resize - // would perform like tex2Dblur9x9, MUCH slower than tex2Dblur5resize. - const float denom_inv = 0.5/(sigma*sigma); - // Load each sample. We need all 3x3 samples. Quad-pixel communication - // won't help either: This should perform like tex2Dblur5x5, but sharing a - // 4x4 sample field would perform more like tex2Dblur8x8shared (worse). - const vec2 sample4_uv = tex_uv; - const vec2 dx = vec2(dxdy.x, 0.0); - const vec2 dy = vec2(0.0, dxdy.y); - const vec2 sample1_uv = sample4_uv - dy; - const vec2 sample7_uv = sample4_uv + dy; - const vec3 sample0 = tex2D_linearize(texture, sample1_uv - dx).rgb; - const vec3 sample1 = tex2D_linearize(texture, sample1_uv).rgb; - const vec3 sample2 = tex2D_linearize(texture, sample1_uv + dx).rgb; - const vec3 sample3 = tex2D_linearize(texture, sample4_uv - dx).rgb; - const vec3 sample4 = tex2D_linearize(texture, sample4_uv).rgb; - const vec3 sample5 = tex2D_linearize(texture, sample4_uv + dx).rgb; - const vec3 sample6 = tex2D_linearize(texture, sample7_uv - dx).rgb; - const vec3 sample7 = tex2D_linearize(texture, sample7_uv).rgb; - const vec3 sample8 = tex2D_linearize(texture, sample7_uv + dx).rgb; - // Statically compute Gaussian sample weights: - const float w4 = 1.0; - const float w1_3_5_7 = exp(-LENGTH_SQ(vec2(1.0, 0.0)) * denom_inv); - const float w0_2_6_8 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float weight_sum_inv = 1.0/(w4 + 4.0 * (w1_3_5_7 + w0_2_6_8)); - // Weight and sum the samples: - const vec3 sum = w4 * sample4 + - w1_3_5_7 * (sample1 + sample3 + sample5 + sample7) + - w0_2_6_8 * (sample0 + sample2 + sample6 + sample8); - return sum * weight_sum_inv; -} - - -//////////////////////////// FASTER ONE-PASS BLURS /////////////////////////// - -vec3 tex2Dblur9x9(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 9x9 blur with 5x5 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 9x9 Gaussian blurred mipmapped texture lookup composed of - // 5x5 carefully selected bilinear samples. - // Description: - // Perform a 1-pass 9x9 blur with 5x5 bilinear samples. Adjust the - // bilinear sample location to reflect the true Gaussian weights for each - // underlying texel. The following diagram illustrates the relative - // locations of bilinear samples. Each sample with the same number has the - // same weight (notice the symmetry). The letters a, b, c, d distinguish - // quadrants, and the letters U, D, L, R, C (up, down, left, right, center) - // distinguish 1D directions along the line containing the pixel center: - // 6a 5a 2U 5b 6b - // 4a 3a 1U 3b 4b - // 2L 1L 0C 1R 2R - // 4c 3c 1D 3d 4d - // 6c 5c 2D 5d 6d - // The following diagram illustrates the underlying equally spaced texels, - // named after the sample that accesses them and subnamed by their location - // within their 2x2, 2x1, 1x2, or 1x1 texel block: - // 6a4 6a3 5a4 5a3 2U2 5b3 5b4 6b3 6b4 - // 6a2 6a1 5a2 5a1 2U1 5b1 5b2 6b1 6b2 - // 4a4 4a3 3a4 3a3 1U2 3b3 3b4 4b3 4b4 - // 4a2 4a1 3a2 3a1 1U1 3b1 3b2 4b1 4b2 - // 2L2 2L1 1L2 1L1 0C1 1R1 1R2 2R1 2R2 - // 4c2 4c1 3c2 3c1 1D1 3d1 3d2 4d1 4d2 - // 4c4 4c3 3c4 3c3 1D2 3d3 3d4 4d3 4d4 - // 6c2 6c1 5c2 5c1 2D1 5d1 5d2 6d1 6d2 - // 6c4 6c3 5c4 5c3 2D2 5d3 5d4 6d3 6d4 - // Note there is only one C texel and only two texels for each U, D, L, or - // R sample. The center sample is effectively a nearest neighbor sample, - // and the U/D/L/R samples use 1D linear filtering. All other texels are - // read with bilinear samples somewhere within their 2x2 texel blocks. - - // COMPUTE TEXTURE COORDS: - // Statically compute sampling offsets within each 2x2 texel block, based - // on 1D sampling ratios between texels [1, 2] and [3, 4] texels away from - // the center, and reuse them independently for both dimensions. Compute - // these offsets based on the relative 1D Gaussian weights of the texels - // in question. (w1off means "Gaussian weight for the texel 1.0 texels - // away from the pixel center," etc.). - const float denom_inv = 0.5/(sigma*sigma); - const float w1off = exp(-1.0 * denom_inv); - const float w2off = exp(-4.0 * denom_inv); - const float w3off = exp(-9.0 * denom_inv); - const float w4off = exp(-16.0 * denom_inv); - const float texel1to2ratio = w2off/(w1off + w2off); - const float texel3to4ratio = w4off/(w3off + w4off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including x-axis-aligned: - const vec2 sample1R_texel_offset = vec2(1.0, 0.0) + vec2(texel1to2ratio, 0.0); - const vec2 sample2R_texel_offset = vec2(3.0, 0.0) + vec2(texel3to4ratio, 0.0); - const vec2 sample3d_texel_offset = vec2(1.0, 1.0) + vec2(texel1to2ratio, texel1to2ratio); - const vec2 sample4d_texel_offset = vec2(3.0, 1.0) + vec2(texel3to4ratio, texel1to2ratio); - const vec2 sample5d_texel_offset = vec2(1.0, 3.0) + vec2(texel1to2ratio, texel3to4ratio); - const vec2 sample6d_texel_offset = vec2(3.0, 3.0) + vec2(texel3to4ratio, texel3to4ratio); - - // CALCULATE KERNEL WEIGHTS FOR ALL SAMPLES: - // Statically compute Gaussian texel weights for the bottom-right quadrant. - // Read underscores as "and." - const float w1R1 = w1off; - const float w1R2 = w2off; - const float w2R1 = w3off; - const float w2R2 = w4off; - const float w3d1 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float w3d2_3d3 = exp(-LENGTH_SQ(vec2(2.0, 1.0)) * denom_inv); - const float w3d4 = exp(-LENGTH_SQ(vec2(2.0, 2.0)) * denom_inv); - const float w4d1_5d1 = exp(-LENGTH_SQ(vec2(3.0, 1.0)) * denom_inv); - const float w4d2_5d3 = exp(-LENGTH_SQ(vec2(4.0, 1.0)) * denom_inv); - const float w4d3_5d2 = exp(-LENGTH_SQ(vec2(3.0, 2.0)) * denom_inv); - const float w4d4_5d4 = exp(-LENGTH_SQ(vec2(4.0, 2.0)) * denom_inv); - const float w6d1 = exp(-LENGTH_SQ(vec2(3.0, 3.0)) * denom_inv); - const float w6d2_6d3 = exp(-LENGTH_SQ(vec2(4.0, 3.0)) * denom_inv); - const float w6d4 = exp(-LENGTH_SQ(vec2(4.0, 4.0)) * denom_inv); - // Statically add texel weights in each sample to get sample weights: - const float w0 = 1.0; - const float w1 = w1R1 + w1R2; - const float w2 = w2R1 + w2R2; - const float w3 = w3d1 + 2.0 * w3d2_3d3 + w3d4; - const float w4 = w4d1_5d1 + w4d2_5d3 + w4d3_5d2 + w4d4_5d4; - const float w5 = w4; - const float w6 = w6d1 + 2.0 * w6d2_6d3 + w6d4; - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = - 1.0/(w0 + 4.0 * (w1 + w2 + w3 + w4 + w5 + w6)); - - // LOAD TEXTURE SAMPLES: - // Load all 25 samples (1 nearest, 8 linear, 16 bilinear) using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - // Sampling order doesn't seem to affect performance, so just be clear: - const vec3 sample0C = tex2D_linearize(texture, tex_uv).rgb; - const vec3 sample1R = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset).rgb; - const vec3 sample1D = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample1L = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset).rgb; - const vec3 sample1U = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample2R = tex2D_linearize(texture, tex_uv + dxdy * sample2R_texel_offset).rgb; - const vec3 sample2D = tex2D_linearize(texture, tex_uv + dxdy * sample2R_texel_offset.yx).rgb; - const vec3 sample2L = tex2D_linearize(texture, tex_uv - dxdy * sample2R_texel_offset).rgb; - const vec3 sample2U = tex2D_linearize(texture, tex_uv - dxdy * sample2R_texel_offset.yx).rgb; - const vec3 sample3d = tex2D_linearize(texture, tex_uv + dxdy * sample3d_texel_offset).rgb; - const vec3 sample3c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample3d_texel_offset).rgb; - const vec3 sample3b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample3d_texel_offset).rgb; - const vec3 sample3a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample3d_texel_offset).rgb; - const vec3 sample4d = tex2D_linearize(texture, tex_uv + dxdy * sample4d_texel_offset).rgb; - const vec3 sample4c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample4d_texel_offset).rgb; - const vec3 sample4b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample4d_texel_offset).rgb; - const vec3 sample4a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample4d_texel_offset).rgb; - const vec3 sample5d = tex2D_linearize(texture, tex_uv + dxdy * sample5d_texel_offset).rgb; - const vec3 sample5c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample5d_texel_offset).rgb; - const vec3 sample5b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample5d_texel_offset).rgb; - const vec3 sample5a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample5d_texel_offset).rgb; - const vec3 sample6d = tex2D_linearize(texture, tex_uv + dxdy * sample6d_texel_offset).rgb; - const vec3 sample6c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample6d_texel_offset).rgb; - const vec3 sample6b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample6d_texel_offset).rgb; - const vec3 sample6a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample6d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Statically normalize weights (so total = 1.0), and sum weighted samples. - vec3 sum = w0 * sample0C; - sum += w1 * (sample1R + sample1D + sample1L + sample1U); - sum += w2 * (sample2R + sample2D + sample2L + sample2U); - sum += w3 * (sample3d + sample3c + sample3b + sample3a); - sum += w4 * (sample4d + sample4c + sample4b + sample4a); - sum += w5 * (sample5d + sample5c + sample5b + sample5a); - sum += w6 * (sample6d + sample6c + sample6b + sample6a); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur7x7(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 7x7 blur with 5x5 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 7x7 Gaussian blurred mipmapped texture lookup composed of - // 4x4 carefully selected bilinear samples. - // Description: - // First see the descriptions for tex2Dblur9x9() and tex2Dblur7(). This - // blur mixes concepts from both. The sample layout is as follows: - // 4a 3a 3b 4b - // 2a 1a 1b 2b - // 2c 1c 1d 2d - // 4c 3c 3d 4d - // The texel layout is as follows. Note that samples 3a/3b, 1a/1b, 1c/1d, - // and 3c/3d share a vertical column of texels, and samples 2a/2c, 1a/1c, - // 1b/1d, and 2b/2d share a horizontal row of texels (all sample1's share - // the center texel): - // 4a4 4a3 3a4 3ab3 3b4 4b3 4b4 - // 4a2 4a1 3a2 3ab1 3b2 4b1 4b2 - // 2a4 2a3 1a4 1ab3 1b4 2b3 2b4 - // 2ac2 2ac1 1ac2 1* 1bd2 2bd1 2bd2 - // 2c4 2c3 1c4 1cd3 1d4 2d3 2d4 - // 4c2 4c1 3c2 3cd1 3d2 4d1 4d2 - // 4c4 4c3 3c4 3cd3 3d4 4d3 4d4 - - // COMPUTE TEXTURE COORDS: - // Statically compute bilinear sampling offsets (details in tex2Dblur9x9). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w1off = exp(-1.0 * denom_inv); - const float w2off = exp(-4.0 * denom_inv); - const float w3off = exp(-9.0 * denom_inv); - const float texel0to1ratio = w1off/(w0off * 0.5 + w1off); - const float texel2to3ratio = w3off/(w2off + w3off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including axis-aligned: - const vec2 sample1d_texel_offset = vec2(texel0to1ratio, texel0to1ratio); - const vec2 sample2d_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample3d_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample4d_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - - // CALCULATE KERNEL WEIGHTS FOR ALL SAMPLES: - // Statically compute Gaussian texel weights for the bottom-right quadrant. - // Read underscores as "and." - const float w1abcd = 1.0; - const float w1bd2_1cd3 = exp(-LENGTH_SQ(vec2(1.0, 0.0)) * denom_inv); - const float w2bd1_3cd1 = exp(-LENGTH_SQ(vec2(2.0, 0.0)) * denom_inv); - const float w2bd2_3cd2 = exp(-LENGTH_SQ(vec2(3.0, 0.0)) * denom_inv); - const float w1d4 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float w2d3_3d2 = exp(-LENGTH_SQ(vec2(2.0, 1.0)) * denom_inv); - const float w2d4_3d4 = exp(-LENGTH_SQ(vec2(3.0, 1.0)) * denom_inv); - const float w4d1 = exp(-LENGTH_SQ(vec2(2.0, 2.0)) * denom_inv); - const float w4d2_4d3 = exp(-LENGTH_SQ(vec2(3.0, 2.0)) * denom_inv); - const float w4d4 = exp(-LENGTH_SQ(vec2(3.0, 3.0)) * denom_inv); - // Statically add texel weights in each sample to get sample weights. - // Split weights for shared texels between samples sharing them: - const float w1 = w1abcd * 0.25 + w1bd2_1cd3 + w1d4; - const float w2_3 = (w2bd1_3cd1 + w2bd2_3cd2) * 0.5 + w2d3_3d2 + w2d4_3d4; - const float w4 = w4d1 + 2.0 * w4d2_4d3 + w4d4; - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = - 1.0/(4.0 * (w1 + 2.0 * w2_3 + w4)); - - // LOAD TEXTURE SAMPLES: - // Load all 16 samples using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - const vec3 sample1a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample1d_texel_offset).rgb; - const vec3 sample2a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample2d_texel_offset).rgb; - const vec3 sample3a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample3d_texel_offset).rgb; - const vec3 sample4a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample4d_texel_offset).rgb; - const vec3 sample1b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample1d_texel_offset).rgb; - const vec3 sample2b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample2d_texel_offset).rgb; - const vec3 sample3b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample3d_texel_offset).rgb; - const vec3 sample4b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample4d_texel_offset).rgb; - const vec3 sample1c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample1d_texel_offset).rgb; - const vec3 sample2c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample2d_texel_offset).rgb; - const vec3 sample3c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample3d_texel_offset).rgb; - const vec3 sample4c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample4d_texel_offset).rgb; - const vec3 sample1d = tex2D_linearize(texture, tex_uv + dxdy * sample1d_texel_offset).rgb; - const vec3 sample2d = tex2D_linearize(texture, tex_uv + dxdy * sample2d_texel_offset).rgb; - const vec3 sample3d = tex2D_linearize(texture, tex_uv + dxdy * sample3d_texel_offset).rgb; - const vec3 sample4d = tex2D_linearize(texture, tex_uv + dxdy * sample4d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Statically normalize weights (so total = 1.0), and sum weighted samples. - vec3 sum = vec3(0.0); - sum += w1 * (sample1a + sample1b + sample1c + sample1d); - sum += w2_3 * (sample2a + sample2b + sample2c + sample2d); - sum += w2_3 * (sample3a + sample3b + sample3c + sample3d); - sum += w4 * (sample4a + sample4b + sample4c + sample4d); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur5x5(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 5x5 blur with 3x3 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 5x5 Gaussian blurred mipmapped texture lookup composed of - // 3x3 carefully selected bilinear samples. - // Description: - // First see the description for tex2Dblur9x9(). This blur uses the same - // concept and sample/texel locations except on a smaller scale. Samples: - // 2a 1U 2b - // 1L 0C 1R - // 2c 1D 2d - // Texels: - // 2a4 2a3 1U2 2b3 2b4 - // 2a2 2a1 1U1 2b1 2b2 - // 1L2 1L1 0C1 1R1 1R2 - // 2c2 2c1 1D1 2d1 2d2 - // 2c4 2c3 1D2 2d3 2d4 - - // COMPUTE TEXTURE COORDS: - // Statically compute bilinear sampling offsets (details in tex2Dblur9x9). - const float denom_inv = 0.5/(sigma*sigma); - const float w1off = exp(-1.0 * denom_inv); - const float w2off = exp(-4.0 * denom_inv); - const float texel1to2ratio = w2off/(w1off + w2off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including x-axis-aligned: - const vec2 sample1R_texel_offset = vec2(1.0, 0.0) + vec2(texel1to2ratio, 0.0); - const vec2 sample2d_texel_offset = vec2(1.0, 1.0) + vec2(texel1to2ratio, texel1to2ratio); - - // CALCULATE KERNEL WEIGHTS FOR ALL SAMPLES: - // Statically compute Gaussian texel weights for the bottom-right quadrant. - // Read underscores as "and." - const float w1R1 = w1off; - const float w1R2 = w2off; - const float w2d1 = exp(-LENGTH_SQ(vec2(1.0, 1.0)) * denom_inv); - const float w2d2_3 = exp(-LENGTH_SQ(vec2(2.0, 1.0)) * denom_inv); - const float w2d4 = exp(-LENGTH_SQ(vec2(2.0, 2.0)) * denom_inv); - // Statically add texel weights in each sample to get sample weights: - const float w0 = 1.0; - const float w1 = w1R1 + w1R2; - const float w2 = w2d1 + 2.0 * w2d2_3 + w2d4; - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = 1.0/(w0 + 4.0 * (w1 + w2)); - - // LOAD TEXTURE SAMPLES: - // Load all 9 samples (1 nearest, 4 linear, 4 bilinear) using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - const vec3 sample0C = tex2D_linearize(texture, tex_uv).rgb; - const vec3 sample1R = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset).rgb; - const vec3 sample1D = tex2D_linearize(texture, tex_uv + dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample1L = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset).rgb; - const vec3 sample1U = tex2D_linearize(texture, tex_uv - dxdy * sample1R_texel_offset.yx).rgb; - const vec3 sample2d = tex2D_linearize(texture, tex_uv + dxdy * sample2d_texel_offset).rgb; - const vec3 sample2c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample2d_texel_offset).rgb; - const vec3 sample2b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample2d_texel_offset).rgb; - const vec3 sample2a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample2d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Statically normalize weights (so total = 1.0), and sum weighted samples. - vec3 sum = w0 * sample0C; - sum += w1 * (sample1R + sample1D + sample1L + sample1U); - sum += w2 * (sample2a + sample2b + sample2c + sample2d); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur3x3(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy, const float sigma) -{ - // Perform a 1-pass 3x3 blur with 5x5 bilinear samples. - // Requires: Same as tex2Dblur9() - // Returns: A 3x3 Gaussian blurred mipmapped texture lookup composed of - // 2x2 carefully selected bilinear samples. - // Description: - // First see the descriptions for tex2Dblur9x9() and tex2Dblur7(). This - // blur mixes concepts from both. The sample layout is as follows: - // 0a 0b - // 0c 0d - // The texel layout is as follows. Note that samples 0a/0b and 0c/0d share - // a vertical column of texels, and samples 0a/0c and 0b/0d share a - // horizontal row of texels (all samples share the center texel): - // 0a3 0ab2 0b3 - // 0ac1 0*0 0bd1 - // 0c3 0cd2 0d3 - - // COMPUTE TEXTURE COORDS: - // Statically compute bilinear sampling offsets (details in tex2Dblur9x9). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w1off = exp(-1.0 * denom_inv); - const float texel0to1ratio = w1off/(w0off * 0.5 + w1off); - // Statically compute texel offsets from the fragment center to each - // bilinear sample in the bottom-right quadrant, including axis-aligned: - const vec2 sample0d_texel_offset = vec2(texel0to1ratio, texel0to1ratio); - - // LOAD TEXTURE SAMPLES: - // Load all 4 samples using symmetry: - const vec2 mirror_x = vec2(-1.0, 1.0); - const vec2 mirror_y = vec2(1.0, -1.0); - const vec2 mirror_xy = vec2(-1.0, -1.0); - const vec2 dxdy_mirror_x = dxdy * mirror_x; - const vec2 dxdy_mirror_y = dxdy * mirror_y; - const vec2 dxdy_mirror_xy = dxdy * mirror_xy; - const vec3 sample0a = tex2D_linearize(texture, tex_uv + dxdy_mirror_xy * sample0d_texel_offset).rgb; - const vec3 sample0b = tex2D_linearize(texture, tex_uv + dxdy_mirror_y * sample0d_texel_offset).rgb; - const vec3 sample0c = tex2D_linearize(texture, tex_uv + dxdy_mirror_x * sample0d_texel_offset).rgb; - const vec3 sample0d = tex2D_linearize(texture, tex_uv + dxdy * sample0d_texel_offset).rgb; - - // SUM WEIGHTED SAMPLES: - // Weights for all samples are the same, so just average them: - return 0.25 * (sample0a + sample0b + sample0c + sample0d); -} - - -////////////////// LINEAR ONE-PASS BLURS WITH SHARED SAMPLES ///////////////// - -vec3 tex2Dblur12x12shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: 1.) Same as tex2Dblur9() - // 2.) ddx() and ddy() are present in the current Cg profile. - // 3.) The GPU driver is using fine/high-quality derivatives. - // 4.) quad_vector *correctly* describes the current fragment's - // location in its pixel quad, by the conventions noted in - // get_quad_vector[_naive]. - // 5.) tex_uv.w = log2(IN.video_size/IN.output_size).y - // 6.) tex2Dlod() is present in the current Cg profile. - // Optional: Tune artifacts vs. excessive blurriness with the global - // float error_blurring. - // Returns: A blurred texture lookup using a "virtual" 12x12 Gaussian - // blur (a 6x6 blur of carefully selected bilinear samples) - // of the given mip level. There will be subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // Perform a 1-pass blur with shared texture lookups across a pixel quad. - // We'll get neighboring samples with high-quality ddx/ddy derivatives, as - // in GPU Pro 2, Chapter VI.2, "Shader Amortization using Pixel Quad - // Message Passing" by Eric Penner. - // - // Our "virtual" 12x12 blur will be comprised of ((6 - 1)^2)/4 + 3 = 12 - // bilinear samples, where bilinear sampling positions are computed from - // the relative Gaussian weights of the 4 surrounding texels. The catch is - // that the appropriate texel weights and sample coords differ for each - // fragment, but we're reusing most of the same samples across a quad of - // destination fragments. (We do use unique coords for the four nearest - // samples at each fragment.) Mixing bilinear filtering and sample-sharing - // therefore introduces some error into the weights, and this can get nasty - // when the source image is small or high-frequency. Computing bilinear - // ratios based on weights at the sample field center results in sharpening - // and ringing artifacts, but we can move samples closer to halfway between - // texels to try blurring away the error (which can move features around by - // a texel or so). Tune this with the global float "error_blurring". - // - // The pixel quad's sample field covers 12x12 texels, accessed through 6x6 - // bilinear (2x2 texel) taps. Each fragment depends on a window of 10x10 - // texels (5x5 bilinear taps), and each fragment is responsible for loading - // a 6x6 texel quadrant as a 3x3 block of bilinear taps, plus 3 more taps - // to use unique bilinear coords for sample0* for each fragment. This - // diagram illustrates the relative locations of bilinear samples 1-9 for - // each quadrant a, b, c, d (note samples will not be equally spaced): - // 8a 7a 6a 6b 7b 8b - // 5a 4a 3a 3b 4b 5b - // 2a 1a 0a 0b 1b 2b - // 2c 1c 0c 0d 1d 2d - // 5c 4c 3c 3d 4d 5d - // 8c 7c 6c 6d 7d 8d - // The following diagram illustrates the underlying equally spaced texels, - // named after the sample that accesses them and subnamed by their location - // within their 2x2 texel block: - // 8a3 8a2 7a3 7a2 6a3 6a2 6b2 6b3 7b2 7b3 8b2 8b3 - // 8a1 8a0 7a1 7a0 6a1 6a0 6b0 6b1 7b0 7b1 8b0 8b1 - // 5a3 5a2 4a3 4a2 3a3 3a2 3b2 3b3 4b2 4b3 5b2 5b3 - // 5a1 5a0 4a1 4a0 3a1 3a0 3b0 3b1 4b0 4b1 5b0 5b1 - // 2a3 2a2 1a3 1a2 0a3 0a2 0b2 0b3 1b2 1b3 2b2 2b3 - // 2a1 2a0 1a1 1a0 0a1 0a0 0b0 0b1 1b0 1b1 2b0 2b1 - // 2c1 2c0 1c1 1c0 0c1 0c0 0d0 0d1 1d0 1d1 2d0 2d1 - // 2c3 2c2 1c3 1c2 0c3 0c2 0d2 0d3 1d2 1d3 2d2 2d3 - // 5c1 5c0 4c1 4c0 3c1 3c0 3d0 3d1 4d0 4d1 5d0 5d1 - // 5c3 5c2 4c3 4c2 3c3 3c2 3d2 3d3 4d2 4d3 5d2 5d3 - // 8c1 8c0 7c1 7c0 6c1 6c0 6d0 6d1 7d0 7d1 8d0 8d1 - // 8c3 8c2 7c3 7c2 6c3 6c2 6d2 6d3 7d2 7d3 8d2 8d3 - // With this symmetric arrangement, we don't have to know which absolute - // quadrant a sample lies in to assign kernel weights; it's enough to know - // the sample number and the relative quadrant of the sample (relative to - // the current quadrant): - // {current, adjacent x, adjacent y, diagonal} - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute sampling offsets within each 2x2 texel block, based - // on appropriate 1D Gaussian sampling ratio between texels [0, 1], [2, 3], - // and [4, 5] away from the fragment, and reuse them independently for both - // dimensions. Use the sample field center as the estimated destination, - // but nudge the result closer to halfway between texels to blur error. - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float w4_5off = exp(-(4.5*4.5) * denom_inv); - const float w5_5off = exp(-(5.5*5.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - const float texel4to5ratio = mix(w5_5off/(w4_5off + w5_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(4.0, 0.0) + vec2(texel4to5ratio, texel0to1ratio); - const vec2 sample3_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample4_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - const vec2 sample5_texel_offset = vec2(4.0, 2.0) + vec2(texel4to5ratio, texel2to3ratio); - const vec2 sample6_texel_offset = vec2(0.0, 4.0) + vec2(texel0to1ratio, texel4to5ratio); - const vec2 sample7_texel_offset = vec2(2.0, 4.0) + vec2(texel2to3ratio, texel4to5ratio); - const vec2 sample8_texel_offset = vec2(4.0, 4.0) + vec2(texel4to5ratio, texel4to5ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // based on the sum of their 4 underlying texel weights. Assume a same- - // resolution blur, so each symmetrically named sample weight will compute - // the same at every fragment in the pixel quad: We can therefore compute - // texel weights based only on the bottom-right quadrant (fragment at 0d0). - // Too avoid too much boilerplate code, use a macro to get all 4 texel - // weights for a bilinear sample based on the offset of its top-left texel: - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - const float w8diag = GET_TEXEL_QUAD_WEIGHTS(-6.0, -6.0); - const float w7diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -6.0); - const float w6diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -6.0); - const float w6adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -6.0); - const float w7adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -6.0); - const float w8adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -6.0); - const float w5diag = GET_TEXEL_QUAD_WEIGHTS(-6.0, -4.0); - const float w4diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -4.0); - const float w3diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -4.0); - const float w3adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -4.0); - const float w4adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -4.0); - const float w5adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -4.0); - const float w2diag = GET_TEXEL_QUAD_WEIGHTS(-6.0, -2.0); - const float w1diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -2.0); - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w2adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -2.0); - const float w2adjx = GET_TEXEL_QUAD_WEIGHTS(-6.0, 0.0); - const float w1adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 0.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 0.0); - const float w5adjx = GET_TEXEL_QUAD_WEIGHTS(-6.0, 2.0); - const float w4adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 2.0); - const float w3adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w4curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - const float w5curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 2.0); - const float w8adjx = GET_TEXEL_QUAD_WEIGHTS(-6.0, 4.0); - const float w7adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 4.0); - const float w6adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 4.0); - const float w6curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 4.0); - const float w7curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 4.0); - const float w8curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 4.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Statically pack weights for runtime: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - const vec4 w1 = vec4(w1curr, w1adjx, w1adjy, w1diag); - const vec4 w2 = vec4(w2curr, w2adjx, w2adjy, w2diag); - const vec4 w3 = vec4(w3curr, w3adjx, w3adjy, w3diag); - const vec4 w4 = vec4(w4curr, w4adjx, w4adjy, w4diag); - const vec4 w5 = vec4(w5curr, w5adjx, w5adjy, w5diag); - const vec4 w6 = vec4(w6curr, w6adjx, w6adjy, w6diag); - const vec4 w7 = vec4(w7curr, w7adjx, w7adjy, w7diag); - const vec4 w8 = vec4(w8curr, w8adjx, w8adjy, w8diag); - // Get the weight sum inverse (normalization factor): - const vec4 weight_sum4 = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8; - const vec2 weight_sum2 = weight_sum4.xy + weight_sum4.zw; - const float weight_sum = weight_sum2.x + weight_sum2.y; - const float weight_sum_inv = 1.0/(weight_sum); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - const vec3 sample4curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample4_texel_offset)).rgb; - const vec3 sample5curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample5_texel_offset)).rgb; - const vec3 sample6curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample6_texel_offset)).rgb; - const vec3 sample7curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample7_texel_offset)).rgb; - const vec3 sample8curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample8_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - vec3 sample3adjx, sample3adjy, sample3diag; - vec3 sample4adjx, sample4adjy, sample4diag; - vec3 sample5adjx, sample5adjy, sample5diag; - vec3 sample6adjx, sample6adjy, sample6diag; - vec3 sample7adjx, sample7adjy, sample7diag; - vec3 sample8adjx, sample8adjy, sample8diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - quad_gather(quad_vector, sample3curr, sample3adjx, sample3adjy, sample3diag); - quad_gather(quad_vector, sample4curr, sample4adjx, sample4adjy, sample4diag); - quad_gather(quad_vector, sample5curr, sample5adjx, sample5adjy, sample5diag); - quad_gather(quad_vector, sample6curr, sample6adjx, sample6adjy, sample6diag); - quad_gather(quad_vector, sample7curr, sample7adjx, sample7adjy, sample7diag); - quad_gather(quad_vector, sample8curr, sample8adjx, sample8adjy, sample8diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += (mat4x3(sample1curr, sample1adjx, sample1adjy, sample1diag) * w1); - sum += (mat4x3(sample2curr, sample2adjx, sample2adjy, sample2diag) * w2); - sum += (mat4x3(sample3curr, sample3adjx, sample3adjy, sample3diag) * w3); - sum += (mat4x3(sample4curr, sample4adjx, sample4adjy, sample4diag) * w4); - sum += (mat4x3(sample5curr, sample5adjx, sample5adjy, sample5diag) * w5); - sum += (mat4x3(sample6curr, sample6adjx, sample6adjy, sample6diag) * w6); - sum += (mat4x3(sample7curr, sample7adjx, sample7adjy, sample7diag) * w7); - sum += (mat4x3(sample8curr, sample8adjx, sample8adjy, sample8diag) * w8); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur10x10shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: Same as tex2Dblur12x12shared() - // Returns: A blurred texture lookup using a "virtual" 10x10 Gaussian - // blur (a 5x5 blur of carefully selected bilinear samples) - // of the given mip level. There will be subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // First see the description for tex2Dblur12x12shared(). This - // function shares the same concept and sample placement, but each fragment - // only uses 25 of the 36 samples taken across the pixel quad (to cover a - // 5x5 sample area, or 10x10 texel area), and it uses a lower standard - // deviation to compensate. Thanks to symmetry, the 11 omitted samples - // are always the "same:" - // 8adjx, 2adjx, 5adjx, - // 6adjy, 7adjy, 8adjy, - // 2diag, 5diag, 6diag, 7diag, 8diag - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute bilinear sampling offsets (details in tex2Dblur12x12shared). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float w4_5off = exp(-(4.5*4.5) * denom_inv); - const float w5_5off = exp(-(5.5*5.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - const float texel4to5ratio = mix(w5_5off/(w4_5off + w5_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(4.0, 0.0) + vec2(texel4to5ratio, texel0to1ratio); - const vec2 sample3_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample4_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - const vec2 sample5_texel_offset = vec2(4.0, 2.0) + vec2(texel4to5ratio, texel2to3ratio); - const vec2 sample6_texel_offset = vec2(0.0, 4.0) + vec2(texel0to1ratio, texel4to5ratio); - const vec2 sample7_texel_offset = vec2(2.0, 4.0) + vec2(texel2to3ratio, texel4to5ratio); - const vec2 sample8_texel_offset = vec2(4.0, 4.0) + vec2(texel4to5ratio, texel4to5ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // from the sum of their 4 texel weights (details in tex2Dblur12x12shared). - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - // We only need 25 of the 36 sample weights. Skip the following weights: - // 8adjx, 2adjx, 5adjx, - // 6adjy, 7adjy, 8adjy, - // 2diag, 5diag, 6diag, 7diag, 8diag - const float w4diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -4.0); - const float w3diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -4.0); - const float w3adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -4.0); - const float w4adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -4.0); - const float w5adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -4.0); - const float w1diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -2.0); - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w2adjy = GET_TEXEL_QUAD_WEIGHTS(4.0, -2.0); - const float w1adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 0.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 0.0); - const float w4adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 2.0); - const float w3adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w4curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - const float w5curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 2.0); - const float w7adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 4.0); - const float w6adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 4.0); - const float w6curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 4.0); - const float w7curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 4.0); - const float w8curr = GET_TEXEL_QUAD_WEIGHTS(4.0, 4.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = 1.0/(w0curr + w1curr + w2curr + w3curr + - w4curr + w5curr + w6curr + w7curr + w8curr + - w0adjx + w1adjx + w3adjx + w4adjx + w6adjx + w7adjx + - w0adjy + w1adjy + w2adjy + w3adjy + w4adjy + w5adjy + - w0diag + w1diag + w3diag + w4diag); - // Statically pack most weights for runtime. Note the mixed packing: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - const vec4 w1 = vec4(w1curr, w1adjx, w1adjy, w1diag); - const vec4 w3 = vec4(w3curr, w3adjx, w3adjy, w3diag); - const vec4 w4 = vec4(w4curr, w4adjx, w4adjy, w4diag); - const vec4 w2and5 = vec4(w2curr, w2adjy, w5curr, w5adjy); - const vec4 w6and7 = vec4(w6curr, w6adjx, w7curr, w7adjx); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - const vec3 sample4curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample4_texel_offset)).rgb; - const vec3 sample5curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample5_texel_offset)).rgb; - const vec3 sample6curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample6_texel_offset)).rgb; - const vec3 sample7curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample7_texel_offset)).rgb; - const vec3 sample8curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample8_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad in order of need: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - vec3 sample3adjx, sample3adjy, sample3diag; - vec3 sample4adjx, sample4adjy, sample4diag; - vec3 sample5adjx, sample5adjy, sample5diag; - vec3 sample6adjx, sample6adjy, sample6diag; - vec3 sample7adjx, sample7adjy, sample7diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - quad_gather(quad_vector, sample3curr, sample3adjx, sample3adjy, sample3diag); - quad_gather(quad_vector, sample4curr, sample4adjx, sample4adjy, sample4diag); - quad_gather(quad_vector, sample5curr, sample5adjx, sample5adjy, sample5diag); - quad_gather(quad_vector, sample6curr, sample6adjx, sample6adjy, sample6diag); - quad_gather(quad_vector, sample7curr, sample7adjx, sample7adjy, sample7diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result. First do the simple ones: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += (mat4x3(sample1curr, sample1adjx, sample1adjy, sample1diag) * w1); - sum += (mat4x3(sample3curr, sample3adjx, sample3adjy, sample3diag) * w2); - sum += (mat4x3(sample4curr, sample4adjx, sample4adjy, sample4diag) * w3); - // Now do the mixed-sample ones: - sum += (mat4x3(sample2curr, sample2adjy, sample5curr, sample5adjy) * w2and5); - sum += (mat4x3(sample6curr, sample6adjx, sample7curr, sample7adjx) * w6and7); - sum += w8curr * sample8curr; - // Normalize the sum (so the weights add to 1.0) and return: - return sum * weight_sum_inv; -} - -vec3 tex2Dblur8x8shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: Same as tex2Dblur12x12shared() - // Returns: A blurred texture lookup using a "virtual" 8x8 Gaussian - // blur (a 4x4 blur of carefully selected bilinear samples) - // of the given mip level. There will be subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // First see the description for tex2Dblur12x12shared(). This function - // shares the same concept and a similar sample placement, except each - // quadrant contains 4x4 texels and 2x2 samples instead of 6x6 and 3x3 - // respectively. There could be a total of 16 samples, 4 of which each - // fragment is responsible for, but each fragment loads 0a/0b/0c/0d with - // its own offset to reduce shared sample artifacts, bringing the sample - // count for each fragment to 7. Sample placement: - // 3a 2a 2b 3b - // 1a 0a 0b 1b - // 1c 0c 0d 1d - // 3c 2c 2d 3d - // Texel placement: - // 3a3 3a2 2a3 2a2 2b2 2b3 3b2 3b3 - // 3a1 3a0 2a1 2a0 2b0 2b1 3b0 3b1 - // 1a3 1a2 0a3 0a2 0b2 0b3 1b2 1b3 - // 1a1 1a0 0a1 0a0 0b0 0b1 1b0 1b1 - // 1c1 1c0 0c1 0c0 0d0 0d1 1d0 1d1 - // 1c3 1c2 0c3 0c2 0d2 0d3 1d2 1d3 - // 3c1 3c0 2c1 2c0 2d0 2d1 3d0 4d1 - // 3c3 3c2 2c3 2c2 2d2 2d3 3d2 4d3 - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute bilinear sampling offsets (details in tex2Dblur12x12shared). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample3_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // from the sum of their 4 texel weights (details in tex2Dblur12x12shared). - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - const float w3diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -4.0); - const float w2diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -4.0); - const float w2adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -4.0); - const float w3adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -4.0); - const float w1diag = GET_TEXEL_QUAD_WEIGHTS(-4.0, -2.0); - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w1adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 0.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w3adjx = GET_TEXEL_QUAD_WEIGHTS(-4.0, 2.0); - const float w2adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Statically pack weights for runtime: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - const vec4 w1 = vec4(w1curr, w1adjx, w1adjy, w1diag); - const vec4 w2 = vec4(w2curr, w2adjx, w2adjy, w2diag); - const vec4 w3 = vec4(w3curr, w3adjx, w3adjy, w3diag); - // Get the weight sum inverse (normalization factor): - const vec4 weight_sum4 = w0 + w1 + w2 + w3; - const vec2 weight_sum2 = weight_sum4.xy + weight_sum4.zw; - const float weight_sum = weight_sum2.x + weight_sum2.y; - const float weight_sum_inv = 1.0/(weight_sum); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - vec3 sample3adjx, sample3adjy, sample3diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - quad_gather(quad_vector, sample3curr, sample3adjx, sample3adjy, sample3diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += (mat4x3(sample1curr, sample1adjx, sample1adjy, sample1diag) * w1); - sum += (mat4x3(sample2curr, sample2adjx, sample2adjy, sample2diag) * w2); - sum += (mat4x3(sample3curr, sample3adjx, sample3adjy, sample3diag) * w3); - return sum * weight_sum_inv; -} - -vec3 tex2Dblur6x6shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector, - const float sigma) -{ - // Perform a 1-pass mipmapped blur with shared samples across a pixel quad. - // Requires: Same as tex2Dblur12x12shared() - // Returns: A blurred texture lookup using a "virtual" 6x6 Gaussian - // blur (a 3x3 blur of carefully selected bilinear samples) - // of the given mip level. There will be some inaccuracies,subtle inaccuracies, - // especially for small or high-frequency detailed sources. - // Description: - // First see the description for tex2Dblur8x8shared(). This - // function shares the same concept and sample placement, but each fragment - // only uses 9 of the 16 samples taken across the pixel quad (to cover a - // 3x3 sample area, or 6x6 texel area), and it uses a lower standard - // deviation to compensate. Thanks to symmetry, the 7 omitted samples - // are always the "same:" - // 1adjx, 3adjx - // 2adjy, 3adjy - // 1diag, 2diag, 3diag - - // COMPUTE COORDS FOR TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Statically compute bilinear sampling offsets (details in tex2Dblur12x12shared). - const float denom_inv = 0.5/(sigma*sigma); - const float w0off = 1.0; - const float w0_5off = exp(-(0.5*0.5) * denom_inv); - const float w1off = exp(-(1.0*1.0) * denom_inv); - const float w1_5off = exp(-(1.5*1.5) * denom_inv); - const float w2off = exp(-(2.0*2.0) * denom_inv); - const float w2_5off = exp(-(2.5*2.5) * denom_inv); - const float w3_5off = exp(-(3.5*3.5) * denom_inv); - const float texel0to1ratio = mix(w1_5off/(w0_5off + w1_5off), 0.5, error_blurring); - const float texel2to3ratio = mix(w3_5off/(w2_5off + w3_5off), 0.5, error_blurring); - // We don't share sample0*, so use the nearest destination fragment: - const float texel0to1ratio_nearest = w1off/(w0off + w1off); - const float texel1to2ratio_nearest = w2off/(w1off + w2off); - // Statically compute texel offsets from the bottom-right fragment to each - // bilinear sample in the bottom-right quadrant: - const vec2 sample0curr_texel_offset = vec2(0.0, 0.0) + vec2(texel0to1ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjx_texel_offset = vec2(-1.0, 0.0) + vec2(-texel1to2ratio_nearest, texel0to1ratio_nearest); - const vec2 sample0adjy_texel_offset = vec2(0.0, -1.0) + vec2(texel0to1ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample0diag_texel_offset = vec2(-1.0, -1.0) + vec2(-texel1to2ratio_nearest, -texel1to2ratio_nearest); - const vec2 sample1_texel_offset = vec2(2.0, 0.0) + vec2(texel2to3ratio, texel0to1ratio); - const vec2 sample2_texel_offset = vec2(0.0, 2.0) + vec2(texel0to1ratio, texel2to3ratio); - const vec2 sample3_texel_offset = vec2(2.0, 2.0) + vec2(texel2to3ratio, texel2to3ratio); - - // CALCULATE KERNEL WEIGHTS: - // Statically compute bilinear sample weights at each destination fragment - // from the sum of their 4 texel weights (details in tex2Dblur12x12shared). - #define GET_TEXEL_QUAD_WEIGHTS(xoff, yoff) \ - (exp(-LENGTH_SQ(vec2(xoff, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff, yoff + 1.0)) * denom_inv) + \ - exp(-LENGTH_SQ(vec2(xoff + 1.0, yoff + 1.0)) * denom_inv)) - // We only need 9 of the 16 sample weights. Skip the following weights: - // 1adjx, 3adjx - // 2adjy, 3adjy - // 1diag, 2diag, 3diag - const float w0diag = GET_TEXEL_QUAD_WEIGHTS(-2.0, -2.0); - const float w0adjy = GET_TEXEL_QUAD_WEIGHTS(0.0, -2.0); - const float w1adjy = GET_TEXEL_QUAD_WEIGHTS(2.0, -2.0); - const float w0adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 0.0); - const float w0curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 0.0); - const float w1curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 0.0); - const float w2adjx = GET_TEXEL_QUAD_WEIGHTS(-2.0, 2.0); - const float w2curr = GET_TEXEL_QUAD_WEIGHTS(0.0, 2.0); - const float w3curr = GET_TEXEL_QUAD_WEIGHTS(2.0, 2.0); - #undef GET_TEXEL_QUAD_WEIGHTS - // Get the weight sum inverse (normalization factor): - const float weight_sum_inv = 1.0/(w0curr + w1curr + w2curr + w3curr + - w0adjx + w2adjx + w0adjy + w1adjy + w0diag); - // Statically pack some weights for runtime: - const vec4 w0 = vec4(w0curr, w0adjx, w0adjy, w0diag); - - // LOAD TEXTURE SAMPLES THIS FRAGMENT IS RESPONSIBLE FOR: - // Get a uv vector from texel 0q0 of this quadrant to texel 0q3: - const vec2 dxdy_curr = dxdy * quad_vector.xy; - // Load bilinear samples for the current quadrant (for this fragment): - const vec3 sample0curr = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0curr_texel_offset).rgb; - const vec3 sample0adjx = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjx_texel_offset).rgb; - const vec3 sample0adjy = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0adjy_texel_offset).rgb; - const vec3 sample0diag = tex2D_linearize(texture, tex_uv.xy + dxdy_curr * sample0diag_texel_offset).rgb; - const vec3 sample1curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample1_texel_offset)).rgb; - const vec3 sample2curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample2_texel_offset)).rgb; - const vec3 sample3curr = tex2Dlod_linearize(texture, tex_uv + uv2_to_uv4(dxdy_curr * sample3_texel_offset)).rgb; - - // GATHER NEIGHBORING SAMPLES AND SUM WEIGHTED SAMPLES: - // Fetch the samples from other fragments in the 2x2 quad: - vec3 sample1adjx, sample1adjy, sample1diag; - vec3 sample2adjx, sample2adjy, sample2diag; - quad_gather(quad_vector, sample1curr, sample1adjx, sample1adjy, sample1diag); - quad_gather(quad_vector, sample2curr, sample2adjx, sample2adjy, sample2diag); - // Statically normalize weights (so total = 1.0), and sum weighted samples. - // Fill each row of a matrix with an rgb sample and pre-multiply by the - // weights to obtain a weighted result for sample1*, and handle the rest - // of the weights more directly/verbosely: - vec3 sum = vec3(0.0); - sum += (mat4x3(sample0curr, sample0adjx, sample0adjy, sample0diag) * w0); - sum += w1curr * sample1curr + w1adjy * sample1adjy + w2curr * sample2curr + - w2adjx * sample2adjx + w3curr * sample3curr; - return sum * weight_sum_inv; -} - - -/////////////////////// MAX OPTIMAL SIGMA BLUR WRAPPERS ////////////////////// - -// The following blurs are static wrappers around the dynamic blurs above. -// HOPEFULLY, the compiler will be smart enough to do constant-folding. - -// Resizable separable blurs: -vec3 tex2Dblur11resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur11resize(texture, tex_uv, dxdy, blur11_std_dev); -} -vec3 tex2Dblur9resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9resize(texture, tex_uv, dxdy, blur9_std_dev); -} -vec3 tex2Dblur7resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur7resize(texture, tex_uv, dxdy, blur7_std_dev); -} -vec3 tex2Dblur5resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur5resize(texture, tex_uv, dxdy, blur5_std_dev); -} -vec3 tex2Dblur3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3resize(texture, tex_uv, dxdy, blur3_std_dev); -} -// Fast separable blurs: -vec3 tex2Dblur11fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur11fast(texture, tex_uv, dxdy, blur11_std_dev); -} -vec3 tex2Dblur9fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9fast(texture, tex_uv, dxdy, blur9_std_dev); -} -vec3 tex2Dblur7fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur7fast(texture, tex_uv, dxdy, blur7_std_dev); -} -vec3 tex2Dblur5fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur5fast(texture, tex_uv, dxdy, blur5_std_dev); -} -vec3 tex2Dblur3fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3fast(texture, tex_uv, dxdy, blur3_std_dev); -} -// Huge, "fast" separable blurs: -vec3 tex2Dblur43fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur43fast(texture, tex_uv, dxdy, blur43_std_dev); -} -vec3 tex2Dblur31fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur31fast(texture, tex_uv, dxdy, blur31_std_dev); -} -vec3 tex2Dblur25fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur25fast(texture, tex_uv, dxdy, blur25_std_dev); -} -vec3 tex2Dblur17fast(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur17fast(texture, tex_uv, dxdy, blur17_std_dev); -} -// Resizable one-pass blurs: -vec3 tex2Dblur3x3resize(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3x3resize(texture, tex_uv, dxdy, blur3_std_dev); -} -// "Fast" one-pass blurs: -vec3 tex2Dblur9x9(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur9x9(texture, tex_uv, dxdy, blur9_std_dev); -} -vec3 tex2Dblur7x7(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur7x7(texture, tex_uv, dxdy, blur7_std_dev); -} -vec3 tex2Dblur5x5(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur5x5(texture, tex_uv, dxdy, blur5_std_dev); -} -vec3 tex2Dblur3x3(const sampler2D texture, const vec2 tex_uv, - const vec2 dxdy) -{ - return tex2Dblur3x3(texture, tex_uv, dxdy, blur3_std_dev); -} -// "Fast" shared-sample one-pass blurs: -vec3 tex2Dblur12x12shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur12x12shared(texture, tex_uv, dxdy, quad_vector, blur12_std_dev); -} -vec3 tex2Dblur10x10shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur10x10shared(texture, tex_uv, dxdy, quad_vector, blur10_std_dev); -} -vec3 tex2Dblur8x8shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur8x8shared(texture, tex_uv, dxdy, quad_vector, blur8_std_dev); -} -vec3 tex2Dblur6x6shared(const sampler2D texture, - const vec4 tex_uv, const vec2 dxdy, const vec4 quad_vector) -{ - return tex2Dblur6x6shared(texture, tex_uv, dxdy, quad_vector, blur6_std_dev); -} - - -#endif // BLUR_FUNCTIONS_H - diff --git a/include/blur-functions.h b/include/blur-functions.h index 25b83dc..41dfd4c 100644 --- a/include/blur-functions.h +++ b/include/blur-functions.h @@ -1,4 +1,5 @@ -#define BLUR_FUNCTIONS +#ifndef BLUR_FUNCTIONS_H +#define BLUR_FUNCTIONS_H ///////////////////////////////// MIT LICENSE //////////////////////////////// @@ -200,6 +201,14 @@ // Make a length squared helper macro (for usage with static constants): #define LENGTH_SQ(vec) (dot(vec, vec)) +////////////////////////////////// INCLUDES ////////////////////////////////// + +// gamma-management.h relies on pass-specific settings to guide its behavior: +// FIRST_PASS, LAST_PASS, GAMMA_ENCODE_EVERY_FBO, etc. See it for details. +#include "gamma-management.h" +//#include "quad-pixel-communication.h" +#include "special-functions.h" + /////////////////////////////////// HELPERS ////////////////////////////////// vec4 uv2_to_uv4(vec2 tex_uv) @@ -232,6 +241,258 @@ float get_fast_gaussian_weight_sum_inv(const float sigma) (sigma - 0.0860587260734721))), 0.399334576340352/sigma); } +vec3 tex2Dblur17fast(const sampler2D tex, const vec2 tex_uv, + const vec2 dxdy, const float sigma) +{ + // Requires: Same as tex2Dblur11() + // Returns: A 1D 17x Gaussian blurred texture lookup using 1 nearest + // neighbor and 8 linear taps. It may be mipmapped depending + // on settings and dxdy. + // First get the texel weights and normalization factor as above. + const float denom_inv = 0.5/(sigma*sigma); + const float w0 = 1.0; + const float w1 = exp(-1.0 * denom_inv); + const float w2 = exp(-4.0 * denom_inv); + const float w3 = exp(-9.0 * denom_inv); + const float w4 = exp(-16.0 * denom_inv); + const float w5 = exp(-25.0 * denom_inv); + const float w6 = exp(-36.0 * denom_inv); + const float w7 = exp(-49.0 * denom_inv); + const float w8 = exp(-64.0 * denom_inv); + //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( + // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8)); + const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); + // Calculate combined weights and linear sample ratios between texel pairs. + const float w1_2 = w1 + w2; + const float w3_4 = w3 + w4; + const float w5_6 = w5 + w6; + const float w7_8 = w7 + w8; + const float w1_2_ratio = w2/w1_2; + const float w3_4_ratio = w4/w3_4; + const float w5_6_ratio = w6/w5_6; + const float w7_8_ratio = w8/w7_8; + // Statically normalize weights, sum weighted samples, and return: + vec3 sum = vec3(0.0); + sum += w7_8 * tex2D_linearize(tex, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; + sum += w5_6 * tex2D_linearize(tex, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; + sum += w3_4 * tex2D_linearize(tex, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; + sum += w1_2 * tex2D_linearize(tex, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; + sum += w0 * tex2D_linearize(tex, tex_uv).rgb; + sum += w1_2 * tex2D_linearize(tex, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; + sum += w3_4 * tex2D_linearize(tex, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; + sum += w5_6 * tex2D_linearize(tex, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; + sum += w7_8 * tex2D_linearize(tex, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; + return sum * weight_sum_inv; +} + +vec3 tex2Dblur25fast(const sampler2D tex, const vec2 tex_uv, + const vec2 dxdy, const float sigma) +{ + // Requires: Same as tex2Dblur11() + // Returns: A 1D 25x Gaussian blurred texture lookup using 1 nearest + // neighbor and 12 linear taps. It may be mipmapped depending + // on settings and dxdy. + // First get the texel weights and normalization factor as above. + const float denom_inv = 0.5/(sigma*sigma); + const float w0 = 1.0; + const float w1 = exp(-1.0 * denom_inv); + const float w2 = exp(-4.0 * denom_inv); + const float w3 = exp(-9.0 * denom_inv); + const float w4 = exp(-16.0 * denom_inv); + const float w5 = exp(-25.0 * denom_inv); + const float w6 = exp(-36.0 * denom_inv); + const float w7 = exp(-49.0 * denom_inv); + const float w8 = exp(-64.0 * denom_inv); + const float w9 = exp(-81.0 * denom_inv); + const float w10 = exp(-100.0 * denom_inv); + const float w11 = exp(-121.0 * denom_inv); + const float w12 = exp(-144.0 * denom_inv); + //const float weight_sum_inv = 1.0 / (w0 + 2.0 * ( + // w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + w12)); + const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); + // Calculate combined weights and linear sample ratios between texel pairs. + const float w1_2 = w1 + w2; + const float w3_4 = w3 + w4; + const float w5_6 = w5 + w6; + const float w7_8 = w7 + w8; + const float w9_10 = w9 + w10; + const float w11_12 = w11 + w12; + const float w1_2_ratio = w2/w1_2; + const float w3_4_ratio = w4/w3_4; + const float w5_6_ratio = w6/w5_6; + const float w7_8_ratio = w8/w7_8; + const float w9_10_ratio = w10/w9_10; + const float w11_12_ratio = w12/w11_12; + // Statically normalize weights, sum weighted samples, and return: + vec3 sum = vec3(0.0); + sum += w11_12 * tex2D_linearize(tex, tex_uv - (11.0 + w11_12_ratio) * dxdy).rgb; + sum += w9_10 * tex2D_linearize(tex, tex_uv - (9.0 + w9_10_ratio) * dxdy).rgb; + sum += w7_8 * tex2D_linearize(tex, tex_uv - (7.0 + w7_8_ratio) * dxdy).rgb; + sum += w5_6 * tex2D_linearize(tex, tex_uv - (5.0 + w5_6_ratio) * dxdy).rgb; + sum += w3_4 * tex2D_linearize(tex, tex_uv - (3.0 + w3_4_ratio) * dxdy).rgb; + sum += w1_2 * tex2D_linearize(tex, tex_uv - (1.0 + w1_2_ratio) * dxdy).rgb; + sum += w0 * tex2D_linearize(tex, tex_uv).rgb; + sum += w1_2 * tex2D_linearize(tex, tex_uv + (1.0 + w1_2_ratio) * dxdy).rgb; + sum += w3_4 * tex2D_linearize(tex, tex_uv + (3.0 + w3_4_ratio) * dxdy).rgb; + sum += w5_6 * tex2D_linearize(tex, tex_uv + (5.0 + w5_6_ratio) * dxdy).rgb; + sum += w7_8 * tex2D_linearize(tex, tex_uv + (7.0 + w7_8_ratio) * dxdy).rgb; + sum += w9_10 * tex2D_linearize(tex, tex_uv + (9.0 + w9_10_ratio) * dxdy).rgb; + sum += w11_12 * tex2D_linearize(tex, tex_uv + (11.0 + w11_12_ratio) * dxdy).rgb; + return sum * weight_sum_inv; +} + +vec3 tex2Dblur31fast(const sampler2D tex, const vec2 tex_uv, + const vec2 dxdy, const float sigma) +{ + // Requires: Same as tex2Dblur11() + // Returns: A 1D 31x Gaussian blurred texture lookup using 16 linear + // taps. It may be mipmapped depending on settings and dxdy. + // First get the texel weights and normalization factor as above. + const float denom_inv = 0.5/(sigma*sigma); + const float w0 = 1.0; + const float w1 = exp(-1.0 * denom_inv); + const float w2 = exp(-4.0 * denom_inv); + const float w3 = exp(-9.0 * denom_inv); + const float w4 = exp(-16.0 * denom_inv); + const float w5 = exp(-25.0 * denom_inv); + const float w6 = exp(-36.0 * denom_inv); + const float w7 = exp(-49.0 * denom_inv); + const float w8 = exp(-64.0 * denom_inv); + const float w9 = exp(-81.0 * denom_inv); + const float w10 = exp(-100.0 * denom_inv); + const float w11 = exp(-121.0 * denom_inv); + const float w12 = exp(-144.0 * denom_inv); + const float w13 = exp(-169.0 * denom_inv); + const float w14 = exp(-196.0 * denom_inv); + const float w15 = exp(-225.0 * denom_inv); + //const float weight_sum_inv = 1.0 / + // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + + // w9 + w10 + w11 + w12 + w13 + w14 + w15)); + const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); + // Calculate combined weights and linear sample ratios between texel pairs. + // The center texel (with weight w0) is used twice, so halve its weight. + const float w0_1 = w0 * 0.5 + w1; + const float w2_3 = w2 + w3; + const float w4_5 = w4 + w5; + const float w6_7 = w6 + w7; + const float w8_9 = w8 + w9; + const float w10_11 = w10 + w11; + const float w12_13 = w12 + w13; + const float w14_15 = w14 + w15; + const float w0_1_ratio = w1/w0_1; + const float w2_3_ratio = w3/w2_3; + const float w4_5_ratio = w5/w4_5; + const float w6_7_ratio = w7/w6_7; + const float w8_9_ratio = w9/w8_9; + const float w10_11_ratio = w11/w10_11; + const float w12_13_ratio = w13/w12_13; + const float w14_15_ratio = w15/w14_15; + // Statically normalize weights, sum weighted samples, and return: + vec3 sum = vec3(0.0); + sum += w14_15 * tex2D_linearize(tex, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; + sum += w12_13 * tex2D_linearize(tex, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; + sum += w10_11 * tex2D_linearize(tex, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; + sum += w8_9 * tex2D_linearize(tex, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; + sum += w6_7 * tex2D_linearize(tex, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; + sum += w4_5 * tex2D_linearize(tex, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; + sum += w2_3 * tex2D_linearize(tex, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; + sum += w0_1 * tex2D_linearize(tex, tex_uv - w0_1_ratio * dxdy).rgb; + sum += w0_1 * tex2D_linearize(tex, tex_uv + w0_1_ratio * dxdy).rgb; + sum += w2_3 * tex2D_linearize(tex, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; + sum += w4_5 * tex2D_linearize(tex, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; + sum += w6_7 * tex2D_linearize(tex, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; + sum += w8_9 * tex2D_linearize(tex, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; + sum += w10_11 * tex2D_linearize(tex, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; + sum += w12_13 * tex2D_linearize(tex, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; + sum += w14_15 * tex2D_linearize(tex, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; + return sum * weight_sum_inv; +} + +vec3 tex2Dblur43fast(const sampler2D tex, const vec2 tex_uv, + const vec2 dxdy, const float sigma) +{ + // Requires: Same as tex2Dblur11() + // Returns: A 1D 43x Gaussian blurred texture lookup using 22 linear + // taps. It may be mipmapped depending on settings and dxdy. + // First get the texel weights and normalization factor as above. + const float denom_inv = 0.5/(sigma*sigma); + const float w0 = 1.0; + const float w1 = exp(-1.0 * denom_inv); + const float w2 = exp(-4.0 * denom_inv); + const float w3 = exp(-9.0 * denom_inv); + const float w4 = exp(-16.0 * denom_inv); + const float w5 = exp(-25.0 * denom_inv); + const float w6 = exp(-36.0 * denom_inv); + const float w7 = exp(-49.0 * denom_inv); + const float w8 = exp(-64.0 * denom_inv); + const float w9 = exp(-81.0 * denom_inv); + const float w10 = exp(-100.0 * denom_inv); + const float w11 = exp(-121.0 * denom_inv); + const float w12 = exp(-144.0 * denom_inv); + const float w13 = exp(-169.0 * denom_inv); + const float w14 = exp(-196.0 * denom_inv); + const float w15 = exp(-225.0 * denom_inv); + const float w16 = exp(-256.0 * denom_inv); + const float w17 = exp(-289.0 * denom_inv); + const float w18 = exp(-324.0 * denom_inv); + const float w19 = exp(-361.0 * denom_inv); + const float w20 = exp(-400.0 * denom_inv); + const float w21 = exp(-441.0 * denom_inv); + //const float weight_sum_inv = 1.0 / + // (w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + + // w12 + w13 + w14 + w15 + w16 + w17 + w18 + w19 + w20 + w21)); + const float weight_sum_inv = get_fast_gaussian_weight_sum_inv(sigma); + // Calculate combined weights and linear sample ratios between texel pairs. + // The center texel (with weight w0) is used twice, so halve its weight. + const float w0_1 = w0 * 0.5 + w1; + const float w2_3 = w2 + w3; + const float w4_5 = w4 + w5; + const float w6_7 = w6 + w7; + const float w8_9 = w8 + w9; + const float w10_11 = w10 + w11; + const float w12_13 = w12 + w13; + const float w14_15 = w14 + w15; + const float w16_17 = w16 + w17; + const float w18_19 = w18 + w19; + const float w20_21 = w20 + w21; + const float w0_1_ratio = w1/w0_1; + const float w2_3_ratio = w3/w2_3; + const float w4_5_ratio = w5/w4_5; + const float w6_7_ratio = w7/w6_7; + const float w8_9_ratio = w9/w8_9; + const float w10_11_ratio = w11/w10_11; + const float w12_13_ratio = w13/w12_13; + const float w14_15_ratio = w15/w14_15; + const float w16_17_ratio = w17/w16_17; + const float w18_19_ratio = w19/w18_19; + const float w20_21_ratio = w21/w20_21; + // Statically normalize weights, sum weighted samples, and return: + vec3 sum = vec3(0.0); + sum += w20_21 * tex2D_linearize(tex, tex_uv - (20.0 + w20_21_ratio) * dxdy).rgb; + sum += w18_19 * tex2D_linearize(tex, tex_uv - (18.0 + w18_19_ratio) * dxdy).rgb; + sum += w16_17 * tex2D_linearize(tex, tex_uv - (16.0 + w16_17_ratio) * dxdy).rgb; + sum += w14_15 * tex2D_linearize(tex, tex_uv - (14.0 + w14_15_ratio) * dxdy).rgb; + sum += w12_13 * tex2D_linearize(tex, tex_uv - (12.0 + w12_13_ratio) * dxdy).rgb; + sum += w10_11 * tex2D_linearize(tex, tex_uv - (10.0 + w10_11_ratio) * dxdy).rgb; + sum += w8_9 * tex2D_linearize(tex, tex_uv - (8.0 + w8_9_ratio) * dxdy).rgb; + sum += w6_7 * tex2D_linearize(tex, tex_uv - (6.0 + w6_7_ratio) * dxdy).rgb; + sum += w4_5 * tex2D_linearize(tex, tex_uv - (4.0 + w4_5_ratio) * dxdy).rgb; + sum += w2_3 * tex2D_linearize(tex, tex_uv - (2.0 + w2_3_ratio) * dxdy).rgb; + sum += w0_1 * tex2D_linearize(tex, tex_uv - w0_1_ratio * dxdy).rgb; + sum += w0_1 * tex2D_linearize(tex, tex_uv + w0_1_ratio * dxdy).rgb; + sum += w2_3 * tex2D_linearize(tex, tex_uv + (2.0 + w2_3_ratio) * dxdy).rgb; + sum += w4_5 * tex2D_linearize(tex, tex_uv + (4.0 + w4_5_ratio) * dxdy).rgb; + sum += w6_7 * tex2D_linearize(tex, tex_uv + (6.0 + w6_7_ratio) * dxdy).rgb; + sum += w8_9 * tex2D_linearize(tex, tex_uv + (8.0 + w8_9_ratio) * dxdy).rgb; + sum += w10_11 * tex2D_linearize(tex, tex_uv + (10.0 + w10_11_ratio) * dxdy).rgb; + sum += w12_13 * tex2D_linearize(tex, tex_uv + (12.0 + w12_13_ratio) * dxdy).rgb; + sum += w14_15 * tex2D_linearize(tex, tex_uv + (14.0 + w14_15_ratio) * dxdy).rgb; + sum += w16_17 * tex2D_linearize(tex, tex_uv + (16.0 + w16_17_ratio) * dxdy).rgb; + sum += w18_19 * tex2D_linearize(tex, tex_uv + (18.0 + w18_19_ratio) * dxdy).rgb; + sum += w20_21 * tex2D_linearize(tex, tex_uv + (20.0 + w20_21_ratio) * dxdy).rgb; + return sum * weight_sum_inv; +} + //////////////////// ARBITRARILY RESIZABLE ONE-PASS BLURS //////////////////// vec3 tex2Dblur3x3resize(const sampler2D tex, const vec2 tex_uv, @@ -278,4 +539,65 @@ vec3 tex2Dblur3x3resize(const sampler2D texture, const vec2 tex_uv, const vec2 dxdy) { return tex2Dblur3x3resize(texture, tex_uv, dxdy, blur3_std_dev); -} \ No newline at end of file +} + +vec3 tex2Dblur9fast(const sampler2D tex, const vec2 tex_uv, + const vec2 dxdy, const float sigma) +{ + // Requires: Same as tex2Dblur11() + // Returns: A 1D 9x Gaussian blurred texture lookup using 1 nearest + // neighbor and 4 linear taps. It may be mipmapped depending + // on settings and dxdy. + // First get the texel weights and normalization factor as above. + const float denom_inv = 0.5/(sigma*sigma); + const float w0 = 1.0; + const float w1 = exp(-1.0 * denom_inv); + const float w2 = exp(-4.0 * denom_inv); + const float w3 = exp(-9.0 * denom_inv); + const float w4 = exp(-16.0 * denom_inv); + const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4)); + // Calculate combined weights and linear sample ratios between texel pairs. + const float w12 = w1 + w2; + const float w34 = w3 + w4; + const float w12_ratio = w2/w12; + const float w34_ratio = w4/w34; + // Statically normalize weights, sum weighted samples, and return: + vec3 sum = vec3(0.0); + sum += w34 * tex2D_linearize(tex, tex_uv - (3.0 + w34_ratio) * dxdy).rgb; + sum += w12 * tex2D_linearize(tex, tex_uv - (1.0 + w12_ratio) * dxdy).rgb; + sum += w0 * tex2D_linearize(tex, tex_uv).rgb; + sum += w12 * tex2D_linearize(tex, tex_uv + (1.0 + w12_ratio) * dxdy).rgb; + sum += w34 * tex2D_linearize(tex, tex_uv + (3.0 + w34_ratio) * dxdy).rgb; + return sum * weight_sum_inv; +} + +vec3 tex2Dblur9fast(const sampler2D tex, const vec2 tex_uv, + const vec2 dxdy) +{ + return tex2Dblur9fast(tex, tex_uv, dxdy, blur9_std_dev); +} + +vec3 tex2Dblur17fast(const sampler2D texture, const vec2 tex_uv, + const vec2 dxdy) +{ + return tex2Dblur17fast(texture, tex_uv, dxdy, blur17_std_dev); +} + +vec3 tex2Dblur25fast(const sampler2D texture, const vec2 tex_uv, + const vec2 dxdy) +{ + return tex2Dblur25fast(texture, tex_uv, dxdy, blur25_std_dev); +} + +vec3 tex2Dblur43fast(const sampler2D texture, const vec2 tex_uv, + const vec2 dxdy) +{ + return tex2Dblur43fast(texture, tex_uv, dxdy, blur43_std_dev); +} +vec3 tex2Dblur31fast(const sampler2D texture, const vec2 tex_uv, + const vec2 dxdy) +{ + return tex2Dblur31fast(texture, tex_uv, dxdy, blur31_std_dev); +} + +#endif // BLUR_FUNCTIONS_H \ No newline at end of file diff --git a/include/gamma-management-old.h b/include/gamma-management-old.h deleted file mode 100644 index 18963c7..0000000 --- a/include/gamma-management-old.h +++ /dev/null @@ -1,547 +0,0 @@ -#ifndef GAMMA_MANAGEMENT_H -#define GAMMA_MANAGEMENT_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file provides gamma-aware tex*D*() and encode_output() functions. -// Requires: Before #include-ing this file, the including file must #define -// the following macros when applicable and follow their rules: -// 1.) #define FIRST_PASS if this is the first pass. -// 2.) #define LAST_PASS if this is the last pass. -// 3.) If sRGB is available, set srgb_framebufferN = "true" for -// every pass except the last in your .cgp preset. -// 4.) If sRGB isn't available but you want gamma-correctness with -// no banding, #define GAMMA_ENCODE_EVERY_FBO each pass. -// 5.) #define SIMULATE_CRT_ON_LCD if desired (precedence over 5-7) -// 6.) #define SIMULATE_GBA_ON_LCD if desired (precedence over 6-7) -// 7.) #define SIMULATE_LCD_ON_CRT if desired (precedence over 7) -// 8.) #define SIMULATE_GBA_ON_CRT if desired (precedence over -) -// If an option in [5, 8] is #defined in the first or last pass, it -// should be #defined for both. It shouldn't make a difference -// whether it's #defined for intermediate passes or not. -// Optional: The including file (or an earlier included file) may optionally -// #define a number of macros indicating it will override certain -// macros and associated constants are as follows: -// static constants with either static or uniform constants. The -// 1.) OVERRIDE_STANDARD_GAMMA: The user must first define: -// static const float ntsc_gamma -// static const float pal_gamma -// static const float crt_reference_gamma_high -// static const float crt_reference_gamma_low -// static const float lcd_reference_gamma -// static const float crt_office_gamma -// static const float lcd_office_gamma -// 2.) OVERRIDE_DEVICE_GAMMA: The user must first define: -// static const float crt_gamma -// static const float gba_gamma -// static const float lcd_gamma -// 3.) OVERRIDE_FINAL_GAMMA: The user must first define: -// static const float input_gamma -// static const float intermediate_gamma -// static const float output_gamma -// (intermediate_gamma is for GAMMA_ENCODE_EVERY_FBO.) -// 4.) OVERRIDE_ALPHA_ASSUMPTIONS: The user must first define: -// static const bool assume_opaque_alpha -// The gamma constant overrides must be used in every pass or none, -// and OVERRIDE_FINAL_GAMMA bypasses all of the SIMULATE* macros. -// OVERRIDE_ALPHA_ASSUMPTIONS may be set on a per-pass basis. -// Usage: After setting macros appropriately, ignore gamma correction and -// replace all tex*D*() calls with equivalent gamma-aware -// tex*D*_linearize calls, except: -// 1.) When you read an LUT, use regular tex*D or a gamma-specified -// function, depending on its gamma encoding: -// tex*D*_linearize_gamma (takes a runtime gamma parameter) -// 2.) If you must read pass0's original input in a later pass, use -// tex2D_linearize_ntsc_gamma. If you want to read pass0's -// input with gamma-corrected bilinear filtering, consider -// creating a first linearizing pass and reading from the input -// of pass1 later. -// Then, return encode_output(color) from every fragment shader. -// Finally, use the global gamma_aware_bilinear boolean if you want -// to statically branch based on whether bilinear filtering is -// gamma-correct or not (e.g. for placing Gaussian blur samples). -// -// Detailed Policy: -// tex*D*_linearize() functions enforce a consistent gamma-management policy -// based on the FIRST_PASS and GAMMA_ENCODE_EVERY_FBO settings. They assume -// their input texture has the same encoding characteristics as the input for -// the current pass (which doesn't apply to the exceptions listed above). -// Similarly, encode_output() enforces a policy based on the LAST_PASS and -// GAMMA_ENCODE_EVERY_FBO settings. Together, they result in one of the -// following two pipelines. -// Typical pipeline with intermediate sRGB framebuffers: -// linear_color = pow(pass0_encoded_color, input_gamma); -// intermediate_output = linear_color; // Automatic sRGB encoding -// linear_color = intermediate_output; // Automatic sRGB decoding -// final_output = pow(intermediate_output, 1.0/output_gamma); -// Typical pipeline without intermediate sRGB framebuffers: -// linear_color = pow(pass0_encoded_color, input_gamma); -// intermediate_output = pow(linear_color, 1.0/intermediate_gamma); -// linear_color = pow(intermediate_output, intermediate_gamma); -// final_output = pow(intermediate_output, 1.0/output_gamma); -// Using GAMMA_ENCODE_EVERY_FBO is much slower, but it's provided as a way to -// easily get gamma-correctness without banding on devices where sRGB isn't -// supported. -// -// Use This Header to Maximize Code Reuse: -// The purpose of this header is to provide a consistent interface for texture -// reads and output gamma-encoding that localizes and abstracts away all the -// annoying details. This greatly reduces the amount of code in each shader -// pass that depends on the pass number in the .cgp preset or whether sRGB -// FBO's are being used: You can trivially change the gamma behavior of your -// whole pass by commenting or uncommenting 1-3 #defines. To reuse the same -// code in your first, Nth, and last passes, you can even put it all in another -// header file and #include it from skeleton .cg files that #define the -// appropriate pass-specific settings. -// -// Rationale for Using Three Macros: -// This file uses GAMMA_ENCODE_EVERY_FBO instead of an opposite macro like -// SRGB_PIPELINE to ensure sRGB is assumed by default, which hopefully imposes -// a lower maintenance burden on each pass. At first glance it seems we could -// accomplish everything with two macros: GAMMA_CORRECT_IN / GAMMA_CORRECT_OUT. -// This works for simple use cases where input_gamma == output_gamma, but it -// breaks down for more complex scenarios like CRT simulation, where the pass -// number determines the gamma encoding of the input and output. - - -/////////////////////////////// BASE CONSTANTS /////////////////////////////// - -// Set standard gamma constants, but allow users to override them: -#ifndef OVERRIDE_STANDARD_GAMMA - // Standard encoding gammas: - const float ntsc_gamma = 2.2; // Best to use NTSC for PAL too? - const float pal_gamma = 2.8; // Never actually 2.8 in practice - // Typical device decoding gammas (only use for emulating devices): - // CRT/LCD reference gammas are higher than NTSC and Rec.709 video standard - // gammas: The standards purposely undercorrected for an analog CRT's - // assumed 2.5 reference display gamma to maintain contrast in assumed - // [dark] viewing conditions: http://www.poynton.com/PDFs/GammaFAQ.pdf - // These unstated assumptions about display gamma and perceptual rendering - // intent caused a lot of confusion, and more modern CRT's seemed to target - // NTSC 2.2 gamma with circuitry. LCD displays seem to have followed suit - // (they struggle near black with 2.5 gamma anyway), especially PC/laptop - // displays designed to view sRGB in bright environments. (Standards are - // also in flux again with BT.1886, but it's underspecified for displays.) - const float crt_reference_gamma_high = 2.5; // In (2.35, 2.55) - const float crt_reference_gamma_low = 2.35; // In (2.35, 2.55) - const float lcd_reference_gamma = 2.5; // To match CRT - const float crt_office_gamma = 2.2; // Circuitry-adjusted for NTSC - const float lcd_office_gamma = 2.2; // Approximates sRGB -#endif // OVERRIDE_STANDARD_GAMMA - -// Assuming alpha == 1.0 might make it easier for users to avoid some bugs, -// but only if they're aware of it. -#ifndef OVERRIDE_ALPHA_ASSUMPTIONS - const bool assume_opaque_alpha = false; -#endif - - -/////////////////////// DERIVED CONSTANTS AS FUNCTIONS /////////////////////// - -// gamma-management.h should be compatible with overriding gamma values with -// runtime user parameters, but we can only define other global constants in -// terms of static constants, not uniform user parameters. To get around this -// limitation, we need to define derived constants using functions. - -// Set device gamma constants, but allow users to override them: -#ifdef OVERRIDE_DEVICE_GAMMA - // The user promises to globally define the appropriate constants: - float get_crt_gamma() { return crt_gamma; } - float get_gba_gamma() { return gba_gamma; } - float get_lcd_gamma() { return lcd_gamma; } -#else - float get_crt_gamma() { return crt_reference_gamma_high; } - float get_gba_gamma() { return 3.5; } // Game Boy Advance; in (3.0, 4.0) - float get_lcd_gamma() { return lcd_office_gamma; } -#endif // OVERRIDE_DEVICE_GAMMA - -// Set decoding/encoding gammas for the first/lass passes, but allow overrides: -#ifdef OVERRIDE_FINAL_GAMMA - // The user promises to globally define the appropriate constants: - float get_intermediate_gamma() { return intermediate_gamma; } - float get_input_gamma() { return input_gamma; } - float get_output_gamma() { return output_gamma; } -#else - // If we gamma-correct every pass, always use ntsc_gamma between passes to - // ensure middle passes don't need to care if anything is being simulated: - float get_intermediate_gamma() { return ntsc_gamma; } - #ifdef SIMULATE_CRT_ON_LCD - float get_input_gamma() { return get_crt_gamma(); } - float get_output_gamma() { return get_lcd_gamma(); } - #else - #ifdef SIMULATE_GBA_ON_LCD - float get_input_gamma() { return get_gba_gamma(); } - float get_output_gamma() { return get_lcd_gamma(); } - #else - #ifdef SIMULATE_LCD_ON_CRT - float get_input_gamma() { return get_lcd_gamma(); } - float get_output_gamma() { return get_crt_gamma(); } - #else - #ifdef SIMULATE_GBA_ON_CRT - float get_input_gamma() { return get_gba_gamma(); } - float get_output_gamma() { return get_crt_gamma(); } - #else // Don't simulate anything: - float get_input_gamma() { return ntsc_gamma; } - float get_output_gamma() { return ntsc_gamma; } - #endif // SIMULATE_GBA_ON_CRT - #endif // SIMULATE_LCD_ON_CRT - #endif // SIMULATE_GBA_ON_LCD - #endif // SIMULATE_CRT_ON_LCD -#endif // OVERRIDE_FINAL_GAMMA - -// Set decoding/encoding gammas for the current pass. Use static constants for -// linearize_input and gamma_encode_output, because they aren't derived, and -// they let the compiler do dead-code elimination. -#ifndef GAMMA_ENCODE_EVERY_FBO - #ifdef FIRST_PASS - const bool linearize_input = true; - float get_pass_input_gamma() { return get_input_gamma(); } - #else - const bool linearize_input = false; - float get_pass_input_gamma() { return 1.0; } - #endif - #ifdef LAST_PASS - const bool gamma_encode_output = true; - float get_pass_output_gamma() { return get_output_gamma(); } - #else - const bool gamma_encode_output = false; - float get_pass_output_gamma() { return 1.0; } - #endif -#else - const bool linearize_input = true; - const bool gamma_encode_output = true; - #ifdef FIRST_PASS - float get_pass_input_gamma() { return get_input_gamma(); } - #else - float get_pass_input_gamma() { return get_intermediate_gamma(); } - #endif - #ifdef LAST_PASS - float get_pass_output_gamma() { return get_output_gamma(); } - #else - float get_pass_output_gamma() { return get_intermediate_gamma(); } - #endif -#endif - -// Users might want to know if bilinear filtering will be gamma-correct: -const bool gamma_aware_bilinear = !linearize_input; - - -////////////////////// COLOR ENCODING/DECODING FUNCTIONS ///////////////////// - -vec4 encode_output(const vec4 color) -{ - if(gamma_encode_output) - { - if(assume_opaque_alpha) - { - return vec4(pow(color.rgb, vec3(1.0/get_pass_output_gamma())), 1.0); - } - else - { - return vec4(pow(color.rgb, vec3(1.0/get_pass_output_gamma())), color.a); - } - } - else - { - return color; - } -} - -vec4 decode_input(const vec4 color) -{ - if(linearize_input) - { - if(assume_opaque_alpha) - { - return vec4(pow(color.rgb, vec3(get_pass_input_gamma())), 1.0); - } - else - { - return vec4(pow(color.rgb, vec3(get_pass_input_gamma())), color.a); - } - } - else - { - return color; - } -} - -vec4 decode_gamma_input(const vec4 color, const vec3 gamma) -{ - if(assume_opaque_alpha) - { - return vec4(pow(color.rgb, vec3(gamma)), 1.0); - } - else - { - return vec4(pow(color.rgb, vec3(gamma)), color.a); - } -} - - -/////////////////////////// TEXTURE LOOKUP WRAPPERS ////////////////////////// - -// "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS: -// Provide a wide array of linearizing texture lookup wrapper functions. The -// Cg shader spec Retroarch uses only allows for 2D textures, but 1D and 3D -// lookups are provided for completeness in case that changes someday. Nobody -// is likely to use the *fetch and *proj functions, but they're included just -// in case. The only tex*D texture sampling functions omitted are: -// - tex*Dcmpbias -// - tex*Dcmplod -// - tex*DARRAY* -// - tex*DMS* -// - Variants returning integers -// Standard line length restrictions are ignored below for vertical brevity. - -/* -// tex1D: -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords) -{ return decode_input(tex1D(texture, tex_coords)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords) -{ return decode_input(tex1D(texture, tex_coords)); } - -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, texel_off)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, texel_off)); } - -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords, const float dx, const float dy) -{ return decode_input(tex1D(texture, tex_coords, dx, dy)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords, const float dx, const float dy) -{ return decode_input(tex1D(texture, tex_coords, dx, dy)); } - -vec4 tex1D_linearize(const sampler1D texture, const float tex_coords, const float dx, const float dy, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, dx, dy, texel_off)); } - -vec4 tex1D_linearize(const sampler1D texture, const vec2 tex_coords, const float dx, const float dy, const int texel_off) -{ return decode_input(tex1D(texture, tex_coords, dx, dy, texel_off)); } - -// tex1Dbias: -vec4 tex1Dbias_linearize(const sampler1D texture, const vec4 tex_coords) -{ return decode_input(tex1Dbias(texture, tex_coords)); } - -vec4 tex1Dbias_linearize(const sampler1D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex1Dbias(texture, tex_coords, texel_off)); } - -// tex1Dfetch: -vec4 tex1Dfetch_linearize(const sampler1D texture, const int4 tex_coords) -{ return decode_input(tex1Dfetch(texture, tex_coords)); } - -vec4 tex1Dfetch_linearize(const sampler1D texture, const int4 tex_coords, const int texel_off) -{ return decode_input(tex1Dfetch(texture, tex_coords, texel_off)); } - -// tex1Dlod: -vec4 tex1Dlod_linearize(const sampler1D texture, const vec4 tex_coords) -{ return decode_input(tex1Dlod(texture, tex_coords)); } - -vec4 tex1Dlod_linearize(const sampler1D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex1Dlod(texture, tex_coords, texel_off)); } - -// tex1Dproj: -vec4 tex1Dproj_linearize(const sampler1D texture, const vec2 tex_coords) -{ return decode_input(tex1Dproj(texture, tex_coords)); } - -vec4 tex1Dproj_linearize(const sampler1D texture, const vec3 tex_coords) -{ return decode_input(tex1Dproj(texture, tex_coords)); } - -vec4 tex1Dproj_linearize(const sampler1D texture, const vec2 tex_coords, const int texel_off) -{ return decode_input(tex1Dproj(texture, tex_coords, texel_off)); } - -vec4 tex1Dproj_linearize(const sampler1D texture, const vec3 tex_coords, const int texel_off) -{ return decode_input(tex1Dproj(texture, tex_coords, texel_off)); } -*/ - -// tex2D: -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords) -{ return decode_input(vec4(texture(tex, tex_coords))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords) -{ return decode_input(vec4(texture(tex, tex_coords))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, texel_off))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, texel_off))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy, texel_off))); } - -vec4 tex2D_linearize(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy, const int texel_off) -{ return decode_input(vec4(texture(tex, tex_coords, dx, dy, texel_off))); } - -// tex2Dbias: -vec4 tex2Dbias_linearize(const sampler2D tex, const vec4 tex_coords) -{ return decode_input(vec4(tex2Dbias(tex, tex_coords))); } - -vec4 tex2Dbias_linearize(const sampler2D tex, const vec4 tex_coords, const int texel_off) -{ return decode_input(vec4(tex2Dbias(tex, tex_coords, texel_off))); } - -// tex2Dfetch: -vec4 tex2Dfetch_linearize(const sampler2D tex, const ivec4 tex_coords) -{ return decode_input(vec4(texture2Dfetch(tex, tex_coords))); } - -vec4 tex2Dfetch_linearize(const sampler2D tex, const ivec4 tex_coords, const int texel_off) -{ return decode_input(vec4(texture2Dfetch(tex, tex_coords, texel_off))); } - -// tex2Dlod: -vec4 tex2Dlod_linearize(const sampler2D tex, const vec4 tex_coords) -{ return decode_input(vec4(texture2Dlod(tex, tex_coords))); } - -vec4 tex2Dlod_linearize(const sampler2D tex, const vec4 tex_coords, const int texel_off) -{ return decode_input(vec4(texture2Dlod(tex, tex_coords, texel_off))); } - -// tex2Dproj: -vec4 tex2Dproj_linearize(const sampler2D tex, const vec3 tex_coords) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords))); } - -vec4 tex2Dproj_linearize(const sampler2D tex, const vec4 tex_coords) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords))); } - -vec4 tex2Dproj_linearize(const sampler2D tex, const vec3 tex_coords, const int texel_off) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords, texel_off))); } - -vec4 tex2Dproj_linearize(const sampler2D tex, const vec4 tex_coords, const int texel_off) -{ return decode_input(vec4(tex2Dproj(tex, tex_coords, texel_off))); } - -/* -// tex3D: -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords) -{ return decode_input(tex3D(texture, tex_coords)); } - -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords, const int texel_off) -{ return decode_input(tex3D(texture, tex_coords, texel_off)); } - -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords, const vec3 dx, const vec3 dy) -{ return decode_input(tex3D(texture, tex_coords, dx, dy)); } - -vec4 tex3D_linearize(const sampler3D texture, const vec3 tex_coords, const vec3 dx, const vec3 dy, const int texel_off) -{ return decode_input(tex3D(texture, tex_coords, dx, dy, texel_off)); } - -// tex3Dbias: -vec4 tex3Dbias_linearize(const sampler3D texture, const vec4 tex_coords) -{ return decode_input(tex3Dbias(texture, tex_coords)); } - -vec4 tex3Dbias_linearize(const sampler3D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex3Dbias(texture, tex_coords, texel_off)); } - -// tex3Dfetch: -vec4 tex3Dfetch_linearize(const sampler3D texture, const int4 tex_coords) -{ return decode_input(tex3Dfetch(texture, tex_coords)); } - -vec4 tex3Dfetch_linearize(const sampler3D texture, const int4 tex_coords, const int texel_off) -{ return decode_input(tex3Dfetch(texture, tex_coords, texel_off)); } - -// tex3Dlod: -vec4 tex3Dlod_linearize(const sampler3D texture, const vec4 tex_coords) -{ return decode_input(tex3Dlod(texture, tex_coords)); } - -vec4 tex3Dlod_linearize(const sampler3D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex3Dlod(texture, tex_coords, texel_off)); } - -// tex3Dproj: -vec4 tex3Dproj_linearize(const sampler3D texture, const vec4 tex_coords) -{ return decode_input(tex3Dproj(texture, tex_coords)); } - -vec4 tex3Dproj_linearize(const sampler3D texture, const vec4 tex_coords, const int texel_off) -{ return decode_input(tex3Dproj(texture, tex_coords, texel_off)); } -*/ - - -// NONSTANDARD "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS: -// This narrow selection of nonstandard tex2D* functions can be useful: - -// tex2Dlod0: Automatically fill in the tex2D LOD parameter for mip level 0. -vec4 tex2Dlod0_linearize(const sampler2D texture, const vec2 tex_coords) -{ return decode_input(vec4(texture2Dlod(texture, vec4(tex_coords, 0.0, 0.0)))); } - -vec4 tex2Dlod0_linearize(const sampler2D texture, const vec2 tex_coords, const int texel_off) -{ return decode_input(vec4(texture2Dlod(texture, vec4(tex_coords, 0.0, 0.0), texel_off))); } - - -// MANUALLY LINEARIZING TEXTURE LOOKUP FUNCTIONS: -// Provide a narrower selection of tex2D* wrapper functions that decode an -// input sample with a specified gamma value. These are useful for reading -// LUT's and for reading the input of pass0 in a later pass. - -// tex2D: -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, texel_off), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, texel_off), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec2 tex_coords, const vec2 dx, const vec2 dy, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy, texel_off), vec3(gamma))); } - -vec4 tex2D_linearize_gamma(const sampler2D tex, const vec3 tex_coords, const vec2 dx, const vec2 dy, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(texture(tex, tex_coords, dx, dy, texel_off), vec3(gamma))); } - -// tex2Dbias: -vec4 tex2Dbias_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dbias(tex, tex_coords), vec3(gamma))); } - -vec4 tex2Dbias_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dbias(tex, tex_coords, texel_off), vec3(gamma))); } - -// tex2Dfetch: -vec4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dfetch(tex, tex_coords), vec3(gamma))); } - -vec4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dfetch(tex, tex_coords, texel_off), vec3(gamma))); } - -// tex2Dlod: -vec4 tex2Dlod_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dlod(tex, tex_coords), vec3(gamma))); } - -vec4 tex2Dlod_linearize_gamma(const sampler2D tex, const vec4 tex_coords, const int texel_off, const vec3 gamma) -{ return decode_gamma_input(vec4(tex2Dlod(tex, tex_coords, texel_off), vec3(gamma))); } - - -#endif // GAMMA_MANAGEMENT_H - diff --git a/include/gamma-management.h b/include/gamma-management.h index 4236bb3..0843122 100644 --- a/include/gamma-management.h +++ b/include/gamma-management.h @@ -1,3 +1,6 @@ +#ifndef GAMMA_MANAGEMENT_H +#define GAMMA_MANAGEMENT_H + /////////////////////////////// BASE CONSTANTS /////////////////////////////// // Set standard gamma constants, but allow users to override them: @@ -157,4 +160,6 @@ vec4 encode_output(const vec4 color) //#define tex2D_linearize(C, D, E) decode_input(vec4(texture(C, D, E))) //vec4 tex2D_linearize(const sampler2D tex, const vec2 tex_coords, const int texel_off) -//{ return decode_input(vec4(texture(tex, tex_coords, texel_off))); } \ No newline at end of file +//{ return decode_input(vec4(texture(tex, tex_coords, texel_off))); } + +#endif // GAMMA_MANAGEMENT_H \ No newline at end of file diff --git a/include/special-functions-old.h b/include/special-functions-old.h deleted file mode 100644 index 839267a..0000000 --- a/include/special-functions-old.h +++ /dev/null @@ -1,498 +0,0 @@ -#ifndef SPECIAL_FUNCTIONS_H -#define SPECIAL_FUNCTIONS_H - -///////////////////////////////// MIT LICENSE //////////////////////////////// - -// Copyright (C) 2014 TroggleMonkey -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. - - -///////////////////////////////// DESCRIPTION //////////////////////////////// - -// This file implements the following mathematical special functions: -// 1.) erf() = 2/sqrt(pi) * indefinite_integral(e**(-x**2)) -// 2.) gamma(s), a real-numbered extension of the integer factorial function -// It also implements normalized_ligamma(s, z), a normalized lower incomplete -// gamma function for s < 0.5 only. Both gamma() and normalized_ligamma() can -// be called with an _impl suffix to use an implementation version with a few -// extra precomputed parameters (which may be useful for the caller to reuse). -// See below for details. -// -// Design Rationale: -// Pretty much every line of code in this file is duplicated four times for -// different input types (vec4/vec3/vec2/float). This is unfortunate, -// but Cg doesn't allow function templates. Macros would be far less verbose, -// but they would make the code harder to document and read. I don't expect -// these functions will require a whole lot of maintenance changes unless -// someone ever has need for more robust incomplete gamma functions, so code -// duplication seems to be the lesser evil in this case. - - -/////////////////////////// GAUSSIAN ERROR FUNCTION ////////////////////////// - -vec4 erf6(vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Return an Abramowitz/Stegun approximation of erf(), where: - // erf(x) = 2/sqrt(pi) * integral(e**(-x**2)) - // This approximation has a max absolute error of 2.5*10**-5 - // with solid numerical robustness and efficiency. See: - // https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions - const vec4 one = vec4(1.0); - const vec4 sign_x = sign(x); - const vec4 t = one/(one + 0.47047*abs(x)); - const vec4 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec3 erf6(const vec3 x) -{ - // vec3 version: - const vec3 one = vec3(1.0); - const vec3 sign_x = sign(x); - const vec3 t = one/(one + 0.47047*abs(x)); - const vec3 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec2 erf6(const vec2 x) -{ - // vec2 version: - const vec2 one = vec2(1.0); - const vec2 sign_x = sign(x); - const vec2 t = one/(one + 0.47047*abs(x)); - const vec2 result = one - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -float erf6(const float x) -{ - // Float version: - const float sign_x = sign(x); - const float t = 1.0/(1.0 + 0.47047*abs(x)); - const float result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))* - exp(-(x*x)); - return result * sign_x; -} - -vec4 erft(const vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Approximate erf() with the hyperbolic tangent. The error is - // visually noticeable, but it's blazing fast and perceptually - // close...at least on ATI hardware. See: - // http://www.maplesoft.com/applications/view.aspx?SID=5525&view=html - // Warning: Only use this if your hardware drivers correctly implement - // tanh(): My nVidia 8800GTS returns garbage output. - return tanh(1.202760580 * x); -} - -vec3 erft(const vec3 x) -{ - // vec3 version: - return tanh(1.202760580 * x); -} - -vec2 erft(const vec2 x) -{ - // vec2 version: - return tanh(1.202760580 * x); -} - -float erft(const float x) -{ - // Float version: - return tanh(1.202760580 * x); -} - -vec4 erf(const vec4 x) -{ - // Requires: x is the standard parameter to erf(). - // Returns: Some approximation of erf(x), depending on user settings. - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -vec3 erf(const vec3 x) -{ - // vec3 version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -vec2 erf(const vec2 x) -{ - // vec2 version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - -float erf(const float x) -{ - // Float version: - #ifdef ERF_FAST_APPROXIMATION - return erft(x); - #else - return erf6(x); - #endif -} - - -/////////////////////////// COMPLETE GAMMA FUNCTION ////////////////////////// - -vec4 gamma_impl(const vec4 s, const vec4 s_inv) -{ - // Requires: 1.) s is the standard parameter to the gamma function, and - // it should lie in the [0, 36] range. - // 2.) s_inv = 1.0/s. This implementation function requires - // the caller to precompute this value, giving users the - // opportunity to reuse it. - // Returns: Return approximate gamma function (real-numbered factorial) - // output using the Lanczos approximation with two coefficients - // calculated using Paul Godfrey's method here: - // http://my.fit.edu/~gabdo/gamma.txt - // An optimal g value for s in [0, 36] is ~1.12906830989, with - // a maximum relative error of 0.000463 for 2**16 equally - // evals. We could use three coeffs (0.0000346 error) without - // hurting latency, but this allows more parallelism with - // outside instructions. - const vec4 g = vec4(1.12906830989); - const vec4 c0 = vec4(0.8109119309638332633713423362694399653724431); - const vec4 c1 = vec4(0.4808354605142681877121661197951496120000040); - const vec4 e = vec4(2.71828182845904523536028747135266249775724709); - const vec4 sph = s + vec4(0.5); - const vec4 lanczos_sum = c0 + c1/(s + vec4(1.0)); - const vec4 base = (sph + g)/e; // or (s + g + vec4(0.5))/e - // gamma(s + 1) = base**sph * lanczos_sum; divide by s for gamma(s). - // This has less error for small s's than (s -= 1.0) at the beginning. - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec3 gamma_impl(const vec3 s, const vec3 s_inv) -{ - // vec3 version: - const vec3 g = vec3(1.12906830989); - const vec3 c0 = vec3(0.8109119309638332633713423362694399653724431); - const vec3 c1 = vec3(0.4808354605142681877121661197951496120000040); - const vec3 e = vec3(2.71828182845904523536028747135266249775724709); - const vec3 sph = s + vec3(0.5); - const vec3 lanczos_sum = c0 + c1/(s + vec3(1.0)); - const vec3 base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec2 gamma_impl(const vec2 s, const vec2 s_inv) -{ - // vec2 version: - const vec2 g = vec2(1.12906830989); - const vec2 c0 = vec2(0.8109119309638332633713423362694399653724431); - const vec2 c1 = vec2(0.4808354605142681877121661197951496120000040); - const vec2 e = vec2(2.71828182845904523536028747135266249775724709); - const vec2 sph = s + vec2(0.5); - const vec2 lanczos_sum = c0 + c1/(s + vec2(1.0)); - const vec2 base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -float gamma_impl(const float s, const float s_inv) -{ - // Float version: - const float g = 1.12906830989; - const float c0 = 0.8109119309638332633713423362694399653724431; - const float c1 = 0.4808354605142681877121661197951496120000040; - const float e = 2.71828182845904523536028747135266249775724709; - const float sph = s + 0.5; - const float lanczos_sum = c0 + c1/(s + 1.0); - const float base = (sph + g)/e; - return (pow(base, sph) * lanczos_sum) * s_inv; -} - -vec4 gamma(const vec4 s) -{ - // Requires: s is the standard parameter to the gamma function, and it - // should lie in the [0, 36] range. - // Returns: Return approximate gamma function output with a maximum - // relative error of 0.000463. See gamma_impl for details. - return gamma_impl(s, vec4(1.0)/s); -} - -vec3 gamma(const vec3 s) -{ - // vec3 version: - return gamma_impl(s, vec3(1.0)/s); -} - -vec2 gamma(const vec2 s) -{ - // vec2 version: - return gamma_impl(s, vec2(1.0)/s); -} - -float gamma(const float s) -{ - // Float version: - return gamma_impl(s, 1.0/s); -} - - -//////////////// INCOMPLETE GAMMA FUNCTIONS (RESTRICTED INPUT) /////////////// - -// Lower incomplete gamma function for small s and z (implementation): -vec4 ligamma_small_z_impl(const vec4 s, const vec4 z, const vec4 s_inv) -{ - // Requires: 1.) s < ~0.5 - // 2.) z <= ~0.775075 - // 3.) s_inv = 1.0/s (precomputed for outside reuse) - // Returns: A series representation for the lower incomplete gamma - // function for small s and small z (4 terms). - // The actual "rolled up" summation looks like: - // last_sign = 1.0; last_pow = 1.0; last_factorial = 1.0; - // sum = last_sign * last_pow / ((s + k) * last_factorial) - // for(int i = 0; i < 4; ++i) - // { - // last_sign *= -1.0; last_pow *= z; last_factorial *= i; - // sum += last_sign * last_pow / ((s + k) * last_factorial); - // } - // Unrolled, constant-unfolded and arranged for madds and parallelism: - const vec4 scale = pow(z, s); - vec4 sum = s_inv; // Summation iteration 0 result - // Summation iterations 1, 2, and 3: - const vec4 z_sq = z*z; - const vec4 denom1 = s + vec4(1.0); - const vec4 denom2 = 2.0*s + vec4(4.0); - const vec4 denom3 = 6.0*s + vec4(18.0); - //vec4 denom4 = 24.0*s + vec4(96.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - //sum += z_sq * z_sq / denom4; - // Scale and return: - return scale * sum; -} - -vec3 ligamma_small_z_impl(const vec3 s, const vec3 z, const vec3 s_inv) -{ - // vec3 version: - const vec3 scale = pow(z, s); - vec3 sum = s_inv; - const vec3 z_sq = z*z; - const vec3 denom1 = s + vec3(1.0); - const vec3 denom2 = 2.0*s + vec3(4.0); - const vec3 denom3 = 6.0*s + vec3(18.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -vec2 ligamma_small_z_impl(const vec2 s, const vec2 z, const vec2 s_inv) -{ - // vec2 version: - const vec2 scale = pow(z, s); - vec2 sum = s_inv; - const vec2 z_sq = z*z; - const vec2 denom1 = s + vec2(1.0); - const vec2 denom2 = 2.0*s + vec2(4.0); - const vec2 denom3 = 6.0*s + vec2(18.0); - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -float ligamma_small_z_impl(const float s, const float z, const float s_inv) -{ - // Float version: - const float scale = pow(z, s); - float sum = s_inv; - const float z_sq = z*z; - const float denom1 = s + 1.0; - const float denom2 = 2.0*s + 4.0; - const float denom3 = 6.0*s + 18.0; - sum -= z/denom1; - sum += z_sq/denom2; - sum -= z * z_sq/denom3; - return scale * sum; -} - -// Upper incomplete gamma function for small s and large z (implementation): -vec4 uigamma_large_z_impl(const vec4 s, const vec4 z) -{ - // Requires: 1.) s < ~0.5 - // 2.) z > ~0.775075 - // Returns: Gauss's continued fraction representation for the upper - // incomplete gamma function (4 terms). - // The "rolled up" continued fraction looks like this. The denominator - // is truncated, and it's calculated "from the bottom up:" - // denom = vec4('inf'); - // vec4 one = vec4(1.0); - // for(int i = 4; i > 0; --i) - // { - // denom = ((i * 2.0) - one) + z - s + (i * (s - i))/denom; - // } - // Unrolled and constant-unfolded for madds and parallelism: - const vec4 numerator = pow(z, s) * exp(-z); - vec4 denom = vec4(7.0) + z - s; - denom = vec4(5.0) + z - s + (3.0*s - vec4(9.0))/denom; - denom = vec4(3.0) + z - s + (2.0*s - vec4(4.0))/denom; - denom = vec4(1.0) + z - s + (s - vec4(1.0))/denom; - return numerator / denom; -} - -vec3 uigamma_large_z_impl(const vec3 s, const vec3 z) -{ - // vec3 version: - const vec3 numerator = pow(z, s) * exp(-z); - vec3 denom = vec3(7.0) + z - s; - denom = vec3(5.0) + z - s + (3.0*s - vec3(9.0))/denom; - denom = vec3(3.0) + z - s + (2.0*s - vec3(4.0))/denom; - denom = vec3(1.0) + z - s + (s - vec3(1.0))/denom; - return numerator / denom; -} - -vec2 uigamma_large_z_impl(const vec2 s, const vec2 z) -{ - // vec2 version: - const vec2 numerator = pow(z, s) * exp(-z); - vec2 denom = vec2(7.0) + z - s; - denom = vec2(5.0) + z - s + (3.0*s - vec2(9.0))/denom; - denom = vec2(3.0) + z - s + (2.0*s - vec2(4.0))/denom; - denom = vec2(1.0) + z - s + (s - vec2(1.0))/denom; - return numerator / denom; -} - -float uigamma_large_z_impl(const float s, const float z) -{ - // Float version: - const float numerator = pow(z, s) * exp(-z); - float denom = 7.0 + z - s; - denom = 5.0 + z - s + (3.0*s - 9.0)/denom; - denom = 3.0 + z - s + (2.0*s - 4.0)/denom; - denom = 1.0 + z - s + (s - 1.0)/denom; - return numerator / denom; -} - -// Normalized lower incomplete gamma function for small s (implementation): -vec4 normalized_ligamma_impl(const vec4 s, const vec4 z, - const vec4 s_inv, const vec4 gamma_s_inv) -{ - // Requires: 1.) s < ~0.5 - // 2.) s_inv = 1/s (precomputed for outside reuse) - // 3.) gamma_s_inv = 1/gamma(s) (precomputed for outside reuse) - // Returns: Approximate the normalized lower incomplete gamma function - // for s < 0.5. Since we only care about s < 0.5, we only need - // to evaluate two branches (not four) based on z. Each branch - // uses four terms, with a max relative error of ~0.00182. The - // branch threshold and specifics were adapted for fewer terms - // from Gil/Segura/Temme's paper here: - // http://oai.cwi.nl/oai/asset/20433/20433B.pdf - // Evaluate both branches: Real branches test slower even when available. - const vec4 thresh = vec4(0.775075); - const bool4 z_is_large = z > thresh; - const vec4 large_z = vec4(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec4 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - // Combine the results from both branches: - return large_z * vec4(z_is_large) + small_z * vec4(!z_is_large); -} - -vec3 normalized_ligamma_impl(const vec3 s, const vec3 z, - const vec3 s_inv, const vec3 gamma_s_inv) -{ - // vec3 version: - const vec3 thresh = vec3(0.775075); - const bool3 z_is_large = z > thresh; - const vec3 large_z = vec3(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec3 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * vec3(z_is_large) + small_z * vec3(!z_is_large); -} - -vec2 normalized_ligamma_impl(const vec2 s, const vec2 z, - const vec2 s_inv, const vec2 gamma_s_inv) -{ - // vec2 version: - const vec2 thresh = vec2(0.775075); - const bool2 z_is_large = z > thresh; - const vec2 large_z = vec2(1.0) - uigamma_large_z_impl(s, z) * gamma_s_inv; - const vec2 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * vec2(z_is_large) + small_z * vec2(!z_is_large); -} - -float normalized_ligamma_impl(const float s, const float z, - const float s_inv, const float gamma_s_inv) -{ - // Float version: - const float thresh = 0.775075; - const bool z_is_large = z > thresh; - const float large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv; - const float small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv; - return large_z * float(z_is_large) + small_z * float(!z_is_large); -} - -// Normalized lower incomplete gamma function for small s: -vec4 normalized_ligamma(const vec4 s, const vec4 z) -{ - // Requires: s < ~0.5 - // Returns: Approximate the normalized lower incomplete gamma function - // for s < 0.5. See normalized_ligamma_impl() for details. - const vec4 s_inv = vec4(1.0)/s; - const vec4 gamma_s_inv = vec4(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -vec3 normalized_ligamma(const vec3 s, const vec3 z) -{ - // vec3 version: - const vec3 s_inv = vec3(1.0)/s; - const vec3 gamma_s_inv = vec3(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -vec2 normalized_ligamma(const vec2 s, const vec2 z) -{ - // vec2 version: - const vec2 s_inv = vec2(1.0)/s; - const vec2 gamma_s_inv = vec2(1.0)/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - -float normalized_ligamma(const float s, const float z) -{ - // Float version: - const float s_inv = 1.0/s; - const float gamma_s_inv = 1.0/gamma_impl(s, s_inv); - return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} - - -#endif // SPECIAL_FUNCTIONS_H - - diff --git a/include/special-functions.h b/include/special-functions.h index 1f6d7a4..2a06390 100644 --- a/include/special-functions.h +++ b/include/special-functions.h @@ -1,3 +1,7 @@ +#ifndef SPECIAL_FUNCTIONS_H +#define SPECIAL_FUNCTIONS_H + + ///////////////////////////////// MIT LICENSE //////////////////////////////// // Copyright (C) 2014 TroggleMonkey @@ -489,4 +493,6 @@ float normalized_ligamma(const float s, const float z) const float s_inv = 1.0/s; const float gamma_s_inv = 1.0/gamma_impl(s, s_inv); return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv); -} \ No newline at end of file +} + +#endif // SPECIAL_FUNCTIONS_H \ No newline at end of file