Войти
ПрограммированиеФорумГрафика

Помогите найти алгоритмы полноэкранного сглаживания (постэффект, glsl)

Страницы: 1 2 3 4 5 6 7 Следующая »
#0
9:17, 13 июля 2018

В общем, пилю свой игровой движок, сейчас использую msaa сглаживание и отложенный рендер, что ведет к проблемам с производительностью.  Так же приходиться поддерживать рендер с msaa и без, решил таки отказаться от msaa.
И встал вопрос о том, какие алгоритмы выбрать для сглаживания. 

Проблема в том, что нагуглить удалось только названия либо ссылки на готовые реализации (тут проблема в том что я хочу разобраться в вопросе).
Помогите найти сами алгоритмы (с описанием что, как и почему). Хотелось бы FXAA, SMAA и TXAA. Или другие варианты, хочется иметь несколько алгоритмов от быстрых до качественных.


#1
9:37, 13 июля 2018

FXAA

#2
10:00, 13 июля 2018

Самое простое - предварительный рендер в текстуру большего разрешения, потом в бэкбуфер с Linear фильтрацией.

#3
12:10, 13 июля 2018

Только сегодня пост видел: https://twitter.com/erkaman2/status/1017496058308497408?s=21

#4
13:01, 13 июля 2018

FXAA не нужен, вот есть более качественные варианты SMAA и MLAA:
iryoku.com
https://github.com/iryoku/smaa

#5
19:43, 13 июля 2018

Daniil Petrov
> А вот TXAA уже однозначно только на картах от Nvidia работает :)
Не неси ерунды. Ни FXAA, ни TXAA не юзают хардварных фич только какого либо конкретного вендора. Поэтому работают на любом железе. На любом, где есть возможность читать из текстуры.
То, что ты не можешь разобраться в шейдере, и взять только часть, которая реализует сам алгоритм не значит, что этого не может никто.

#6
(Правка: 19:52) 19:50, 13 июля 2018

Какие зависимости господа от FXAA? Шейдер сглаживание на том же ShaderToy есть. Вот код даже прикреплю

// Created by Reinder Nijhoff 2016
// @reindernijhoff
//
// https://www.shadertoy.com/view/ls3GWS
//
// car model is made by Eiffie
// shader 'Shiny Toy': https://www.shadertoy.com/view/ldsGWB
//
// demonstrating post process FXAA applied to my shader 'Tokyo': 
// https://www.shadertoy.com/view/Xtf3zn
//
// FXAA code from: http://www.geeks3d.com/20110405/fxaa-fast-approximate-anti-aliasing-demo-glsl-opengl-test-radeon-geforce/3/
//

#define FXAA_SPAN_MAX 8.0
#define FXAA_REDUCE_MUL   (1.0/FXAA_SPAN_MAX)
#define FXAA_REDUCE_MIN   (1.0/128.0)
#define FXAA_SUBPIX_SHIFT (1.0/4.0)

vec3 FxaaPixelShader( vec4 uv, sampler2D tex, vec2 rcpFrame) {
    
    vec3 rgbNW = textureLod(tex, uv.zw, 0.0).xyz;
    vec3 rgbNE = textureLod(tex, uv.zw + vec2(1,0)*rcpFrame.xy, 0.0).xyz;
    vec3 rgbSW = textureLod(tex, uv.zw + vec2(0,1)*rcpFrame.xy, 0.0).xyz;
    vec3 rgbSE = textureLod(tex, uv.zw + vec2(1,1)*rcpFrame.xy, 0.0).xyz;
    vec3 rgbM  = textureLod(tex, uv.xy, 0.0).xyz;

    vec3 luma = vec3(0.299, 0.587, 0.114);
    float lumaNW = dot(rgbNW, luma);
    float lumaNE = dot(rgbNE, luma);
    float lumaSW = dot(rgbSW, luma);
    float lumaSE = dot(rgbSE, luma);
    float lumaM  = dot(rgbM,  luma);

    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));

    vec2 dir;
    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));

    float dirReduce = max(
        (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),
        FXAA_REDUCE_MIN);
    float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
    
    dir = min(vec2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),
          max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
          dir * rcpDirMin)) * rcpFrame.xy;

    vec3 rgbA = (1.0/2.0) * (
        textureLod(tex, uv.xy + dir * (1.0/3.0 - 0.5), 0.0).xyz +
        textureLod(tex, uv.xy + dir * (2.0/3.0 - 0.5), 0.0).xyz);
    vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
        textureLod(tex, uv.xy + dir * (0.0/3.0 - 0.5), 0.0).xyz +
        textureLod(tex, uv.xy + dir * (3.0/3.0 - 0.5), 0.0).xyz);
    
    float lumaB = dot(rgbB, luma);

    if((lumaB < lumaMin) || (lumaB > lumaMax)) return rgbA;
    
    return rgbB; 
}


void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 rcpFrame = 1./iResolution.xy;
    vec2 uv2 = fragCoord.xy / iResolution.xy;
        
    float splitCoord = (iMouse.x == 0.0) ? iResolution.x/2. + iResolution.x*cos(iTime*.5) : iMouse.x;
    
    vec3 col;
    
    if( uv2.x < splitCoord/iResolution.x ) {
       vec4 uv = vec4( uv2, uv2 - (rcpFrame * (0.5 + FXAA_SUBPIX_SHIFT)));
      col = FxaaPixelShader( uv, iChannel0, 1./iResolution.xy );
    } else {
      col = texture( iChannel0, uv2 ).xyz;
    }
    
    if (abs(fragCoord.x - splitCoord) < 1.0) {
    col.x = 1.0;
  }
    
    fragColor = vec4( col, 1. );
}

#7
21:05, 13 июля 2018

vindast
> 1) luma непонятная константа
https://en.wikipedia.org/wiki/Grayscale#Luma_coding_in_video_systems
> как и FXAA_SPAN_MAX.
Максимальное расстояние, на котором брать семплы для смешивания

> 2) смысловая нагрузка dirReduce не понятна.
Уменьшить шаг в зависимости от luma соседей

> 3) почему используется textureLod если лод всегда 0?
Странный вопрос. textureLod для этого и используется, чтобы указать номер Lod-а, и чтобы не было выборки по mip-ам если они есть.

#8
(Правка: 1:50) 1:49, 14 июля 2018

Daniil Petrov
> а где тогда найти исходники TXAA?
Исходники не знаю где. Можешь погуглить пейперы и презентации, чтобы понять принцип. Вот например: https://de45xmedrsdbp.cloudfront.net/Resources/files/TemporalAA_s… -59732822.pdf
Возможно в UE4 есть реализация, не смотрел еще.
У меня есть недоделанный TXAA, как доделаю - выложу в открытый доступ (но не знаю когда).
Но если ты даже FXAA не смог выковырять из исходников, то с TXAA я думаю у тебя нет шансов, ибо там вообще все на пайплайне завязано, всякие матрицы проекции, велосити и акум буфера.

#9
4:32, 14 июля 2018

prowkan
> Не путайте, пожалуйста, TXAA и TAA.
А в чем разница?

#10
4:46, 14 июля 2018

prowkan
> Разница в том, что TXAA работает только на NVIDIA (за исключением Dishonored 2,
> но мне почему-то кажется, что там просто TAA так обозвали)
Ну мне тоже кажется, что они просто ТАА обозвали так. Тогда и разницы нет, ведь так?

#11
(Правка: 5:07) 5:06, 14 июля 2018

Daniil Petrov
> Разница есть :)
Технически разница какая? Ну то есть я могу сказать, вот сортировка пузырьком.

BubleSort:

for (i = 0; i < n-1; i++)      
  for (j = 0; j < n-i-1; j++) 
    if (data[j] > data[j+1]) swap(&data[j], &data[j+1]);

А потом я беру этот баблсорт, чуть меняю и называю по другому:
BubleXSort:

for (int i=n-2; i >= 0; i--)
  for (int j = i; j < n; j++)
    if (data[j] > data[j+1]) swap(&data[j], &data[j+1]);

И... этот тот же баблсорт, потому что идея, положенная в баблсорт сохранилась.

Так какая идеологическая разнца между TXAA и TAA? Ведь ты утверждаешь, что разница есть.

#12
(Правка: 6:06) 6:06, 14 июля 2018

Daniil Petrov
Привел в качестве пруфов какой то маркетинговый буллшит.
Суть TAA - каждый кадр смещаем чуть чуть в постпроективном пространстве, чтобы эмулировать семплы как в MSAA. Все это аккумулируем в одну картинку и получаем сглаживание. Но так как картинка динамическая и постоянно меняется - нам надо уметь находить те же пиксели с предыдущего кадра. Для этого строят велосити буфер (или буфер скоростей). Данные о скоростях получают из репроекции и фреймов анимации. Вот и все сглаживание.

#13
8:02, 14 июля 2018

Daniil Petrov
> А можешь привести разницу между скоростью и качеством TAA <> MSAA?
Не могу. Потому что алгоритмы сильно разные, и на разных данных можно получить разные результаты.
Для TAA надо писать в velocity текстуру. Надо делать рендерпасс в аккум буфер, резолвить этот аккум буфер (обычно совмещают с постпроцессом). TAA достаточно сложно реализуется, потому как требует возни с velocity буфером (а это встраивание кучи кода по всему рендеру), есть не тривиальные трюки по борьбе с flickering-ом.
Для MSAA ничего вообще не надо делать, все за тебя сделает железка, и практически единственный минус это то, что растет нагрузка на шину.

Могу сказать, что правильно реализованный TAA смотрится значительно лучше чем MSAA. Особенно хорошо это видно на какой-нибудь растительности при статичной камере.
Ну и вердикт у меня примерно такой, TAA на данный момент один из самых годных алгоритмов антиалязинга по качеству и перфомансу, но с самой сложной реализацией.

#14
8:18, 14 июля 2018

Daniil Petrov
> а на FXAA есть смысл заморачиваться или соотношение скорость / качество по
> сравнению с MSAA того не стоит?
Мне FXAA по качеству совсем не нравится. Это наверное худший алгоритм антиалязинга из тех, которые мне известны. Подкупает только его скорость. В общем это такой AA для бедных.

Старый добый MSAA рулит там, где его можно применить (а его к сожалению не везде можно применить)

Страницы: 1 2 3 4 5 6 7 Следующая »
ПрограммированиеФорумГрафика

Тема закрыта.