Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

[SFML GLSL] Fragment Shader - Okręgi

Ostatnio zmodyfikowano 2024-09-24 17:27
Autor Wiadomość
tBane
Temat założony przez niniejszego użytkownika
[SFML GLSL] Fragment Shader - Okręgi
» 2024-09-23 21:44:24
Witam.
Szukam sposobu jak wygenerować shader GLSL z powiększającym się okręgiem.

P-181625
pekfos
» 2024-09-23 22:21:11
Fragment shader określa kolor każdego piksela. Ustaw kolor jak dystans od środka jest mniejszy od promienia.
P-181626
tBane
Temat założony przez niniejszego użytkownika
» 2024-09-23 22:25:27
Ok działa :-) A jakbym chciał, by ten okrąg zanikał podczas powiększania ?


// assets/fragment_shader.frag

uniform sampler2D texture;
uniform float time;

vec4 circle(vec2 uv, vec2 pos, float rad, vec3 color) {
 
 float d = length(pos - uv) - rad*time;

  if(d > 0.0)
  d = 1.0;
 
 return vec4(color.x, color.y, color.z, 1.0 - d);
}

void main() {
 vec2 uv = gl_TexCoord[0].xy;
 vec2 center = vec2(0.5, 0.5);
 float radius = 0.025;
 
 vec4 background = vec4(0.0, 0.0, 0.0, 1.0);
 vec3 color = vec3(0.5, 0.5, 0.5);
 vec4 circle1 = circle(uv, center, radius, color);
 gl_FragColor = mix(background, circle1, circle1.a);
}
P-181627
tBane
Temat założony przez niniejszego użytkownika
» 2024-09-23 22:46:41
Potrzebuję coś takiego zrobić finalnie https://www.shadertoy.com/view/4lVXzK.
Tylko, że pozycje okręgów pobierałbym z tekstury szumu
źródło - catlikecoding.com
źródło - catlikecoding.com
P-181628
tBane
Temat założony przez niniejszego użytkownika
» 2024-09-24 15:44:31
Zrobiłem to zanikanie. Teraz potrzebuję generować jakoś te okręgi w oparciu o współrzędne generowane z szumu coś jak tutaj ale kompletnie nie rozumiem tego kodu https://www.shadertoy.com/view/lsVSDc


// assets/fragment_shader.frag

uniform sampler2D texture;
uniform float time;

void main() {
 // Odczytaj szum z tekstury
    vec3 noise = texture2D(texture, gl_TexCoord[0].xy).rgb;

    vec2 circlePos = vec2(0.5, 0.5);

    // Wyznacz współrzędną okręgu opartą o czas
    float distanceFromCenter = length(gl_TexCoord[0].xy - circlePos);
    float radius = mod(time * 0.2, 1.0); // Powiększający się promień

    // Zastosuj szum na promień, aby uzyskać zniekształcenia
    radius += noise.r * 0.1;

    // Wyznacz opadanie kolorów na krawędziach okręgu
    float circle = smoothstep(radius + 0.05, radius, distanceFromCenter);

    // Wyznacz finalny kolor (zanikanie i mieszanie kolorów)
    gl_FragColor = vec4(circle * noise, 1.0-time) * vec4(1.0, 1.0, 1.0, 1.0 - distanceFromCenter);
}

Taki właśnie efekt próbuję uzyskać https://www.shadertoy.com/view/4tBfWR. Próbowałem jakoś skopiować ten shader ale nie chce mi działać i wyrzuca błędy:

Failed to link shader:
Fragment info
-------------
(0) : error C3001: no program defined
(0) : error C3001: no program defined
(0) : error C3001: no program defined
(0) : error C3001: no program defined

C/C++
void testGLSL() {
   
// Tworzenie okna
   
sf::RenderWindow window( sf::VideoMode( 512, 512 ), "GLSL Shader Animation" );
   
   
// Wczytywanie tekstury
   
sf::Texture texture;
   
if( !texture.loadFromFile( "assets/noise.png" ) )
       
 return;
   
   
// Tworzenie sprite'a
   
sf::Sprite sprite( texture );
   
   
// Wczytywanie shadera
   
sf::Shader shader;
   
if( !shader.loadFromFile( "assets/circles_test.frag", sf::Shader::Fragment ) )
       
 return;
   
   
// Zegar do animacji
   
sf::Clock clock;
   
   
// Główna pętla
   
while( window.isOpen() )
   
{
       
sf::Event event;
       
while( window.pollEvent( event ) )
       
{
           
if( event.type == sf::Event::Closed )
               
 window.close();
           
       
}
       
       
window.clear();
       
       
shader.setUniform( "u_resolution", sf::Vector2f( window.getSize() ) );
       
       
// Pobieranie czasu i wysyłanie do shadera
       
float time = clock.getElapsedTime().asSeconds();
       
shader.setUniform( "u_time", time );
       
       
// Przypisanie tekst
        // shader.setUniform("texture", texture);
        // Rysowanie sprite'a z shaderem
       
window.draw( sprite, & shader );
       
       
window.display();
   
}
   
}


// Author: Stefan Gustavson
// Title: Worley noise 2x2x2

uniform vec2 u_resolution;
uniform float u_time;

// Cellular noise ("Worley noise") in 3D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.

// Permutation polynomial: (34x^2 + x) mod 289
vec4 permute(vec4 x) {
  return mod((34.0 * x + 1.0) * x, 289.0);
}
vec3 permute(vec3 x) {
  return mod((34.0 * x + 1.0) * x, 289.0);
}

vec2 cellular2x2x2(vec3 P) {
 #define K 0.142857142857 // 1/7
 #define Ko 0.428571428571 // 1/2-K/2
 #define K2 0.020408163265306 // 1/(7*7)
 #define Kz 0.166666666667 // 1/6
 #define Kzo 0.416666666667 // 1/2-1/6*2
 #define jitter 0.8 // smaller jitter gives less errors in F2
 vec3 Pi = mod(floor(P), 289.0);
  vec3 Pf = fract(P);
 vec4 Pfx = Pf.x + vec4(0.0, -1.0, 0.0, -1.0);
 vec4 Pfy = Pf.y + vec4(0.0, 0.0, -1.0, -1.0);
 vec4 p = permute(Pi.x + vec4(0.0, 1.0, 0.0, 1.0));
 p = permute(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0));
 vec4 p1 = permute(p + Pi.z); // z+0
 vec4 p2 = permute(p + Pi.z + vec4(1.0)); // z+1
 vec4 ox1 = fract(p1*K) - Ko;
 vec4 oy1 = mod(floor(p1*K), 7.0)*K - Ko;
 vec4 oz1 = floor(p1*K2)*Kz - Kzo; // p1 < 289 guaranteed
 vec4 ox2 = fract(p2*K) - Ko;
 vec4 oy2 = mod(floor(p2*K), 7.0)*K - Ko;
 vec4 oz2 = floor(p2*K2)*Kz - Kzo;
 vec4 dx1 = Pfx + jitter*ox1;
 vec4 dy1 = Pfy + jitter*oy1;
 vec4 dz1 = Pf.z + jitter*oz1;
 vec4 dx2 = Pfx + jitter*ox2;
 vec4 dy2 = Pfy + jitter*oy2;
 vec4 dz2 = Pf.z - 1.0 + jitter*oz2;
 vec4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0
 vec4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1

 // Sort out the two smallest distances (F1, F2)
#if 0
 // Cheat and sort out only F1
 d1 = min(d1, d2);
 d1.xy = min(d1.xy, d1.wz);
 d1.x = min(d1.x, d1.y);
 return sqrt(d1.xx);
#else
 // Do it right and sort out both F1 and F2
 vec4 d = min(d1,d2); // F1 is now in d
 d2 = max(d1,d2); // Make sure we keep all candidates for F2
 d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap smallest to d.x
 d.xz = (d.x < d.z) ? d.xz : d.zx;
 d.xw = (d.x < d.w) ? d.xw : d.wx; // F1 is now in d.x
 d.yzw = min(d.yzw, d2.yzw); // F2 now not in d2.yzw
 d.y = min(d.y, d.z); // nor in d.z
 d.y = min(d.y, d.w); // nor in d.w
 d.y = min(d.y, d2.x); // F2 is now in d.y
 return sqrt(d.xy); // F1 and F2
#endif
}

void mainImage() {
 vec2 st = (2.*gl_TexCoord[0].xy - u_resolution.xy ) / u_resolution.y;
 st *= 10.;
 vec2 F = cellular2x2x2(vec3(st,u_time));
 float n = smoothstep(0.4, 0.5, F.x);
 gl_FragColor = vec4(n, n, n, 1.0);
}
P-181630
pekfos
» 2024-09-24 16:52:18
Kod z shadertoy nie jest kompletny. Brakuje main(), co powoduje komunikat no program defined.
P-181631
tBane
Temat założony przez niniejszego użytkownika
» 2024-09-24 16:54:53
Ok. Udało się.



// Author: Stefan Gustavson
// Title: Worley noise 2x2x2

uniform vec2 u_resolution;
uniform float u_time;

// Cellular noise ("Worley noise") in 3D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.

// Permutation polynomial: (34x^2 + x) mod 289
vec4 permute(vec4 x) {
  return mod((34.0 * x + 1.0) * x, 289.0);
}
vec3 permute(vec3 x) {
  return mod((34.0 * x + 1.0) * x, 289.0);
}

vec2 cellular2x2x2(vec3 P) {
 #define K 0.142857142857 // 1/7
 #define Ko 0.428571428571 // 1/2-K/2
 #define K2 0.020408163265306 // 1/(7*7)
 #define Kz 0.166666666667 // 1/6
 #define Kzo 0.416666666667 // 1/2-1/6*2
 #define jitter 0.8 // smaller jitter gives less errors in F2
 vec3 Pi = mod(floor(P), 289.0);
  vec3 Pf = fract(P);
 vec4 Pfx = Pf.x + vec4(0.0, -1.0, 0.0, -1.0);
 vec4 Pfy = Pf.y + vec4(0.0, 0.0, -1.0, -1.0);
 vec4 p = permute(Pi.x + vec4(0.0, 1.0, 0.0, 1.0));
 p = permute(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0));
 vec4 p1 = permute(p + Pi.z); // z+0
 vec4 p2 = permute(p + Pi.z + vec4(1.0)); // z+1
 vec4 ox1 = fract(p1*K) - Ko;
 vec4 oy1 = mod(floor(p1*K), 7.0)*K - Ko;
 vec4 oz1 = floor(p1*K2)*Kz - Kzo; // p1 < 289 guaranteed
 vec4 ox2 = fract(p2*K) - Ko;
 vec4 oy2 = mod(floor(p2*K), 7.0)*K - Ko;
 vec4 oz2 = floor(p2*K2)*Kz - Kzo;
 vec4 dx1 = Pfx + jitter*ox1;
 vec4 dy1 = Pfy + jitter*oy1;
 vec4 dz1 = Pf.z + jitter*oz1;
 vec4 dx2 = Pfx + jitter*ox2;
 vec4 dy2 = Pfy + jitter*oy2;
 vec4 dz2 = Pf.z - 1.0 + jitter*oz2;
 vec4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0
 vec4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1

 // Sort out the two smallest distances (F1, F2)
#if 0
 // Cheat and sort out only F1
 d1 = min(d1, d2);
 d1.xy = min(d1.xy, d1.wz);
 d1.x = min(d1.x, d1.y);
 return sqrt(d1.xx);
#else
 // Do it right and sort out both F1 and F2
 vec4 d = min(d1,d2); // F1 is now in d
 d2 = max(d1,d2); // Make sure we keep all candidates for F2
 d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap smallest to d.x
 d.xz = (d.x < d.z) ? d.xz : d.zx;
 d.xw = (d.x < d.w) ? d.xw : d.wx; // F1 is now in d.x
 d.yzw = min(d.yzw, d2.yzw); // F2 now not in d2.yzw
 d.y = min(d.y, d.z); // nor in d.z
 d.y = min(d.y, d.w); // nor in d.w
 d.y = min(d.y, d2.x); // F2 is now in d.y
 return sqrt(d.xy); // F1 and F2
#endif
}

void main() {
 vec2 st = (2.*gl_TexCoord[0].xy*512.0 - u_resolution.xy ) / u_resolution.y;
 st *= 10.;
 vec2 F = cellular2x2x2(vec3(st,u_time));
 float n = smoothstep(0.4, 0.5, F.x);
 gl_FragColor = vec4(n, n, n, 1.0);
}
P-181632
tBane
Temat założony przez niniejszego użytkownika
» 2024-09-24 17:22:32
Jeszcze jedno pytanie z tego wątku. Jakbym chciał, by te okręgi nie były czarne tylko miały jakiś inny kolor to jak to zrobić ?


void main() {
 vec2 st = (2.*gl_TexCoord[0].xy * u_resolution.x - u_resolution.xy ) / u_resolution.y;
 st *= 10.;
 vec2 F = cellular2x2x2(vec3(st,u_time));
 float n = smoothstep(0.4, 0.5, F.x);
 vec3 background = vec3(0.26, 0.46, 0.07);
 vec3 circle_color = vec3(1.0, 0.0, 0.0);
 gl_FragColor = vec4(n*background.x, n*background.y, n*background.z, 1.0);
}
P-181633
« 1 » 2
  Strona 1 z 2 Następna strona