Создание эффекта свечения - проблемы со значениями альфа
2 ответа
Попробуйте сделать крошечный пример, где вы просто хотите усреднить ДВА пикселя. Слева (L) и справа (R). Тогда левый пиксель состоит из R (L), G (L), B (L), A (L), а правый пиксель состоит из R (R), G (R), B (R) и A (R).
Без альфы усреднение синего было бы просто:
(B(L)+B(R)) / 2
Принимая во внимание альфа, оно становится:
(B(L)*A(L)+B(R)*A(R)) / (A(L)+A(R))
Мы можем непосредственно видеть, что в случае полностью сплошные пиксели (альфа = 1), мы получаем точно такую же формулу, как указано выше:
(B(L)*1+B(R)*1) / (1+1) = (B(L)+B(R)) / 2
Кроме того, скажем, что правый пиксель полностью прозрачен, а левый сплошной, тогда цветовая составляющая правого пикселя выиграла ' Это никак не повлияет на результат, оставляя результат в точности как левый пиксель, а это именно то, что нам нужно:
(B(L)*1+B(R)*0) / (1+0) = (B(L)) / 1 = B(L)
Оба пикселя, будучи полностью прозрачными, становятся вырожденным случаем, который должен обрабатываться некоторым элегантным способом.
Теперь все, что вам нужно сделать, это расширить это за пределы двух пикселей. : -)
Я разместил этот вопрос также на en.sfml-dev.org ( здесь ) и fallahn показал мне правильный подход. Прежде чем заняться этим, вот результаты картины:
Люминесценция (порог = 0,24f): 
[1128]
] Blur (4 слоя): 
Собран: 
Уууу! Решение состоит в том, чтобы установить все прозрачные пиксели в сплошной черный цвет vec4(0.0, 0.0, 0.0, 1.0), а затем после того, как они были размыты, просто добавьте их поверх сцены:
vec4 tex_color = texture2D(texture, gl_TexCoord[0].xy);
vec4 add_color = texture2D(add_texture, gl_TexCoord[0].xy);
gl_FragColor = tex_color + add_color;
Таким образом, если add_color черный (" прозрачный "), мы добавляем tex_color + vec4(0.0, 0.0, 0.0, 1.0), что не приводит к изменениям!
Это здорово, потому что теперь вы можете полностью игнорировать альфа-канал.
Чтобы понять, почему я нахожу это таким замечательным, вы можете прочитать эту маленькую напыщенную речь здесь (не стесняйтесь ее пропустить):
Не беспокоясь об альфе, вы можете игнорировать любой sf::BlendMode, как сбивающий с толку sf::BlendMode::OneMinusSrcAlpha, который вызывал у меня головную боль в течение 2 дней. Попробуйте рассчитать любое разумное «истинное» альфа-значение, если вы знаете, что все они предварительно умножены. Конечно, вам также нужно умножить все значения rgb на альфа пикселя, чтобы обратить вспять умножение… формулы отсюда довольно быстро увеличиваются. Также вычтите 1 из альфы, потому что это OneMinusSrcAlpha ... и не забудьте проверить случаи, когда сумма всех альф (да, вам нужно сложить это) равна 0 (или в OneMinusSrcAlpha вопрос, что-то еще) потому что в противном случае вы получите деление на 0 (или в OneMinusSrcAlpha имеет значение деление на 0, когда все окружающие пиксели сплошные). Также иногда могут работать странные альфа-значения, но только для одного прохода размытия, но в моем случае у меня есть несколько проходов ... и т. Д.
Вот окончательный код:
luminescence.frag
#version 120
uniform sampler2D texture;
uniform float threshold;
void main(void){
vec3 current_color = texture2D(texture, gl_TexCoord[0].xy).rgb;
vec4 pixel = vec4(0.0, 0.0, 0.0, 1.0);
float brightness = dot(current_color.rgb, vec3(0.2126, 0.7152, 0.0722));
if (brightness >= threshold){
pixel = texture2D(texture, gl_TexCoord[0].xy);
}
gl_FragColor = pixel;
}
boxblur.frag
#version 120
uniform sampler2D texture;
uniform float texture_inverse;
uniform int blur_radius;
uniform vec2 blur_direction;
void main(void){
vec4 sum = texture2D(texture, gl_TexCoord[0].xy);
for (int i = 0; i < blur_radius; ++i){
sum += texture2D(texture, gl_TexCoord[0].xy + (i * texture_inverse) * blur_direction);
sum += texture2D(texture, gl_TexCoord[0].xy - (i * texture_inverse) * blur_direction);
}
gl_FragColor = sum / (blur_radius * 2 + 1);
}
[1148 ] multiply.frag
#version 120
uniform sampler2D texture;
uniform float multiply;
void main(void){
gl_FragColor = texture2D(texture, gl_TexCoord[0].xy) * multiply;
}
assembly.frag
#version 120
uniform sampler2D texture;
uniform sampler2D add_texture;
uniform float add_weight;
void main(void){
vec4 tex_color = texture2D(texture, gl_TexCoord[0].xy);
vec4 add_color = texture2D(add_texture, gl_TexCoord[0].xy) * add_weight;
gl_FragColor = tex_color + add_color;
}
[ 1127] main.cpp
#include <SFML/Graphics.hpp>
#include <iostream>
#include <array>
void run() {
const sf::Vector2f SIZE(1280, 720);
sf::Texture background_tex;
background_tex.loadFromFile("resources/background.jpg");
sf::Sprite background(background_tex);
sf::Shader luminescence_shader;
luminescence_shader.loadFromFile("resources/luminescence.frag", sf::Shader::Fragment);
luminescence_shader.setUniform("texture", sf::Shader::CurrentTexture);
luminescence_shader.setUniform("threshold", 0.24f);
sf::Shader blur_shader;
blur_shader.loadFromFile("resources/boxblur.frag", sf::Shader::Fragment);
blur_shader.setUniform("texture", sf::Shader::CurrentTexture);
blur_shader.setUniform("texture_inverse", 1.0f / SIZE.x);
sf::Shader assemble_shader;
assemble_shader.loadFromFile("resources/assemble.frag", sf::Shader::Fragment);
assemble_shader.setUniform("texture", sf::Shader::CurrentTexture);
sf::Shader multiply_shader;
multiply_shader.loadFromFile("resources/multiply.frag", sf::Shader::Fragment);
multiply_shader.setUniform("texture", sf::Shader::CurrentTexture);
sf::RenderStates shader_states;
//no blendmode! we make our own - assemble.frag
sf::ContextSettings context_settings;
context_settings.antialiasingLevel = 12;
//draws background
sf::RenderTexture scene_render;
scene_render.create(SIZE.x, SIZE.y, context_settings);
sf::RenderTexture luminescence_render;
luminescence_render.create(SIZE.x, SIZE.y, context_settings);
//draws luminescence and blur
sf::RenderTexture assemble_render;
assemble_render.create(SIZE.x, SIZE.y, context_settings);
//addding multiple boxblurs with different radii looks really nice! in this case 4 layers
std::array<sf::RenderTexture, 4> blur_renders;
for (int i = 0; i < blur_renders.size(); ++i) {
blur_renders[i].create(SIZE.x, SIZE.y, context_settings);
}
const int BLUR_RADIUS_VALUES[] = { 250, 180, 125, 55 };
float blur_weight = blur_renders.empty() ? 0.0 : 1.0 / blur_renders.size();
sf::RenderWindow window(sf::VideoMode(SIZE.x, SIZE.y), "glsl fun", sf::Style::Default, context_settings);
while (window.isOpen()) {
sf::Event event;
while (window.pollEvent(event)) {
if (event.type == sf::Event::Closed) {
window.close();
}
}
//first draw the scene
scene_render.clear();
scene_render.draw(background);
scene_render.display();
//apply luminescence
shader_states.shader = &luminescence_shader;
luminescence_render.clear();
luminescence_render.draw(sf::Sprite(scene_render.getTexture()), shader_states);
luminescence_render.display();
//apply two pass gaussian blur n times to simulate gaussian blur.
shader_states.shader = &blur_shader;
for (int i = 0; i < blur_renders.size(); ++i) {
blur_shader.setUniform("blur_radius", BLUR_RADIUS_VALUES[i]);
blur_renders[i].clear();
blur_renders[i].draw(sf::Sprite(luminescence_render.getTexture()));
blur_renders[i].display();
//vertical blur
blur_shader.setUniform("blur_direction", sf::Glsl::Vec2(1.0, 0.0));
blur_renders[i].draw(sf::Sprite(blur_renders[i].getTexture()), shader_states);
blur_renders[i].display();
//horizontal blur
blur_shader.setUniform("blur_direction", sf::Glsl::Vec2(0.0, 1.0));
blur_renders[i].draw(sf::Sprite(blur_renders[i].getTexture()), shader_states);
blur_renders[i].display();
}
//load blur_renders[0] into assemble_render so we can add the other blurs ontop of it
shader_states.shader = &multiply_shader;
multiply_shader.setUniform("multiply", blur_weight);
assemble_render.clear();
assemble_render.draw(sf::Sprite(blur_renders[0].getTexture()), shader_states);
assemble_render.display();
//adding the rest ontop creating a final blur
shader_states.shader = &assemble_shader;
assemble_shader.setUniform("add_weight", blur_weight);
for (int i = 1; i < blur_renders.size(); ++i) {
assemble_shader.setUniform("add_texture", blur_renders[i].getTexture());
assemble_render.draw(sf::Sprite(assemble_render.getTexture()), shader_states);
assemble_render.display();
}
//final result; scene + blur
assemble_shader.setUniform("add_weight", 1.0f);
assemble_shader.setUniform("add_texture", assemble_render.getTexture());
assemble_render.draw(sf::Sprite(scene_render.getTexture()), shader_states);
assemble_render.display();
window.clear();
window.draw(sf::Sprite(assemble_render.getTexture()));
window.display();
}
}
int main() {
try {
run();
}
catch (std::exception e) {
std::cerr << "caught exception - - - " << e.what() << '\n';
return 1;
}
return 0;
}