Can't get correct sampler2D in fragment shader. #5035

Kunutza · 2025-07-09T15:20:45Z

Kunutza
Jul 9, 2025

I think something goes wrong when I do SetShaderValueTexture(blackhole_shader, iChannel0Loc, combinedRT.texture); so that I can then apply the blackhole shader on the combinedRT.texture (which renders just fine). In the fragment shader it seems like I just don't get the right sampled2D value and I just get black. I can't be sure whether the bug is in the c or the shader file.

Code:

#include <raylib.h> // https://www.raylib.com
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define GLSL_VERSION 330


int main(void) {
    const int screen_width = 800;
    const int screen_height = 800;

    InitWindow(screen_width,screen_height, "kunutza_destroyer2");


    // Planet Shader
    // RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d)
    Image planetimBlank = GenImageColor(100, 100, BLANK);
    Texture2D planet_texture = LoadTextureFromImage(planetimBlank);  // Load blank texture to fill on shader
    UnloadImage(planetimBlank);

    Shader planet_shader = LoadShader(0, TextFormat("shaders/planet.fs", GLSL_VERSION));
    
    // set the uniform for (vec2 circleCenter) in planet.fs
    float circleCenter[2] = { (float)planetimBlank.width/2,  screen_height - (float)planetimBlank.height/2 };
    int circleCenterLoc = GetShaderLocation(planet_shader, "circleCenter");
    SetShaderValue(planet_shader, circleCenterLoc, circleCenter, SHADER_UNIFORM_VEC2);
    // set the uniform for (float circleRadius) in planet.fs
    float circleRadius = 50.0;
    int circleRadiusLoc = GetShaderLocation(planet_shader, "circleRadius");
    SetShaderValue(planet_shader, circleRadiusLoc, &circleRadius, SHADER_UNIFORM_FLOAT);
    // set the uniform for (vec2 u_resolution) in planet.fs
    float iResolution[2] = { screen_width, screen_height};
    int iResolutionLoc = GetShaderLocation(planet_shader, "iResolution");
    SetShaderValue(planet_shader, iResolutionLoc, iResolution, SHADER_UNIFORM_VEC2);
    // set the uniform for θχ (float rotation) in planet.fs
    float rotation = 0.0;
    int rotationLoc = GetShaderLocation(planet_shader, "rotation");
    SetShaderValue(planet_shader, rotationLoc, &rotation, SHADER_UNIFORM_FLOAT);
    // set the uniform for (float time) in planet.fs
    srand(time(NULL));
    float ctime;
    float time_multiplier = 1.0;
    ctime = rand() % 10000;
    int timeLoc = GetShaderLocation(planet_shader, "iTime");
    SetShaderValue(planet_shader, timeLoc, &ctime, SHADER_UNIFORM_FLOAT);
    // set the uniform for (float seed) in planet.fs
    int seed = rand() % 100000 ;
    int seedLoc = GetShaderLocation(planet_shader, "seed");
    SetShaderValue(planet_shader, seedLoc, &seed, SHADER_UNIFORM_INT);


    // The skymap
    Image skymapimBlank = GenImageColor(iResolution[0], iResolution[1], BLANK);
    Texture2D skymap_texture = LoadTextureFromImage(skymapimBlank);  // Load blank texture to fill on shader
    UnloadImage(skymapimBlank);

    Shader skymap_shader = LoadShader(0, TextFormat("shaders/skymap.fs", GLSL_VERSION));
    
    // set the uniform for (vec2 iResolution) in skymap.fs
    int u_resolutionLoc = GetShaderLocation(skymap_shader, "iResolution");
    SetShaderValue(skymap_shader, u_resolutionLoc, iResolution, SHADER_UNIFORM_VEC2);
    // set the uniform for (float iTime) in skymap.fs 
    int itimeLoc = GetShaderLocation(skymap_shader, "iTime");
    SetShaderValue(skymap_shader, itimeLoc, &ctime, SHADER_UNIFORM_FLOAT);


    
    // Black hole
    //Image blackholeimBlank = GenImageColor(iResolution[0], iResolution[1], BLANK);
    //Texture2D blackhole_texture = LoadTextureFromImage(blackholeimBlank);
    //UnloadImage(blackholeimBlank);
    Shader blackhole_shader = LoadShader(0, TextFormat("shaders/black_hole.fs", GLSL_VERSION));
    // iResolution
    int blackhole_iResLoc = GetShaderLocation(blackhole_shader, "iResolution");
    SetShaderValue(blackhole_shader, blackhole_iResLoc, iResolution, SHADER_UNIFORM_VEC2);
    // iTime
    int blackhole_iTime = GetShaderLocation(blackhole_shader, "iTime");
    SetShaderValue(blackhole_shader, blackhole_iTime, &ctime, SHADER_UNIFORM_FLOAT);
    // Combined Render Texture for skymap + planet
    RenderTexture2D combinedRT = LoadRenderTexture(iResolution[0], iResolution[1]);
    // Set iChannel0 in blackhole shader
    int iChannel0Loc = GetShaderLocation(blackhole_shader, "iChannel0");
    SetShaderValueTexture(blackhole_shader, iChannel0Loc, combinedRT.texture);


    // Load texture for rendering (framebuffer), after that I will update it
    RenderTexture2D target = LoadRenderTexture(iResolution[0], iResolution[1]);

    combinedRT.texture.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8;

    float delta;
    SetTargetFPS(60);

    while (!WindowShouldClose()) {
        delta = GetFrameTime();
        if (ctime <= 0) {
            time_multiplier = -time_multiplier;
        } else if (ctime >= 100000) {
            time_multiplier = -time_multiplier;
        }
        ctime += time_multiplier * delta;
        SetShaderValue(planet_shader, timeLoc, &ctime, SHADER_UNIFORM_FLOAT);
        SetShaderValue(skymap_shader, itimeLoc, &ctime, SHADER_UNIFORM_FLOAT);
        SetShaderValue(blackhole_shader, blackhole_iTime, &ctime, SHADER_UNIFORM_FLOAT);

        // make the rotation number never gets too big
        if (rotation >= 32*PI ) {
            rotation -= 32*PI ;
        }
        rotation += 1.0 * delta;
        SetShaderValue(planet_shader, rotationLoc, &rotation, SHADER_UNIFORM_FLOAT);

        // framebuffer
        // Draw skymap + planet to combinedRT
        BeginTextureMode(combinedRT);
        ClearBackground(BLACK);

        BeginShaderMode(skymap_shader);
        DrawTexture(skymap_texture, 0, 0, WHITE);
        EndShaderMode();

        BeginShaderMode(planet_shader);
        DrawTexture(planet_texture, 0, 0, WHITE);
        EndShaderMode();
        EndTextureMode();

        SetShaderValueTexture(blackhole_shader, iChannel0Loc, combinedRT.texture);


        // Apply blackhole shader on combined result
        BeginTextureMode(target);
        ClearBackground(BLACK);

        BeginShaderMode(blackhole_shader);
        DrawTextureRec(combinedRT.texture,
                (Rectangle){ 0, 0, (float)combinedRT.texture.width, (float)-combinedRT.texture.height },
                (Vector2){ 0, 0 }, WHITE);
        EndShaderMode();
        EndTextureMode();


        BeginDrawing();
        
        ClearBackground(BLACK);

        DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height }, 
                (Vector2){ 0, 0 }, WHITE);

        EndDrawing();

    }

    // Cleanup
    UnloadTexture(planet_texture);
    UnloadTexture(skymap_texture);
    UnloadRenderTexture(combinedRT);
    UnloadRenderTexture(target);
    UnloadShader(planet_shader);
    UnloadShader(skymap_shader);
    UnloadShader(blackhole_shader);

    CloseWindow();

    exit(EXIT_SUCCESS);
}

fs code:

#version 330


// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
in vec4 fragColor;

uniform vec2      iResolution;           // viewport resolution (in pixels)
uniform float     iTime;                 // shader playback time (in seconds)
// uniform float     iTimeDelta;            // render time (in seconds)
// uniform float     iFrameRate;            // shader frame rate
// uniform int       iFrame;                // shader playback frame
// uniform float     iChannelTime[4];       // channel playback time (in seconds)
// uniform vec3      iChannelResolution[4]; // channel resolution (in pixels)
// uniform vec4      iMouse;                // mouse pixel coords. xy: current (if MLB down), zw: click
uniform sampler2D iChannel0;          // input channel. XX = 2D/Cube
// uniform vec4      iDate;                 // (year, month, day, time in seconds)
// uniform float     iSampleRate;           // sound sample rate (i.e., 44100)
                

// Output fragment color
out vec4 finalColor;

vec2 blackHoleCenter;

// Gravitational field at position pos, given a black hole
// of mass m at position center (ignoring G constant)
vec2 Fgrav(float m, vec2 center, vec2 pos)
{
	vec2 dir = center - pos;
	float distance = length(dir);
	dir /= distance;
	return dir * (m / (distance*distance));
}


void main()
{
    // void mainImage( out vec4 fragColor, in vec2 fragCoord )
    // {
    //     
    // }

    // vec4 texel = texture(texture0, fragTexCoord);   // Get texel color
    // vec2 texelScale = vec2(0.0);

    // vec4 color = mix(vec4(0.0), outlineColor, outline);
    // finalColor = mix(color, texel, texel.a);



    vec2 circleCenterCoord = vec2(0.5, 0.5);
    vec2 uv = gl_FragCoord.xy / iResolution;
    float dist = distance(uv, circleCenterCoord);

    if (dist <= 0.1)
    {
        finalColor = vec4(1.0, 0.0, 0.0, 0.5); // Red circle
    }
    else
    {
        vec4 texColor = texture(iChannel0, uv); // Use UV not fragTexCoord
        finalColor = texColor;
        finalColor.a = 1.0;
    }	

    //vec2 centerOfMass = vec2(pixelCoord.x*0.5, pixelCoord.y*0.5);
	
	//blackHoleCenter = centerOfMass;
       
	//
	//vec2 netGrav   = Fgrav(90.0, blackHoleCenter, fragTexCoord.xy);
	//
	//float netGravMag = length(netGrav);
	//
	//if(netGravMag >= 1.0)
	//{
	//    finalColor = vec4(1.0, 0.0, 0.0, 1.0);
	//}
	//else
	//{
    //    // convert coordinates
    //    //vec2 circleCenterCoord = circleCenter.xy / iResolution;
    //    //float circleWidth = circleRadius / iResolution.x; // If I get some weird with this I can make it a vec2
    //    //float dist = distance(pixelCoord, circleCenterCoord);
    //    vec2 texCoord = (fragTexCoord.xy + netGrav)/iResolution.xy;
	//    vec4 texColor = texture(iChannel0, texCoord);
	//    //texColor *= 0.05;
	//    
	//    //vec2 texCoord = (fragTexCoord.xy + netGrav*50.0)/iResolution.xy;
	//    //vec3 texColor = vec3(texCoord, 1.0);
	//    //texColor *= 0.05;
	//    
	//    vec3 fColor = texColor.rgb;
	//    
	//    //redshift
	//    //fColor.g *= 1.0 - netGravMag*netGravMag*netGravMag*0.25;
	//    //fColor.b *= 1.0 - netGravMag*0.5;
	//    
	//    //finalColor = vec4(pow(fColor, vec3(1.0/2.2)), 1.0);
    //    finalColor = vec4(fColor, 1.0);
	//}	
    
}

//https://www.shadertoy.com/view/XsfXRS

when drawing the combinedRT I get:

but when I try to draw the changes applied to target, I get:

I want to apply the shader onto the combinedRT's texture. So the correct outcome, in the current code, would be that the sky draws just fine, but where the circle (1.0, 0.0, 0.0, 0,5) appears there will be no sky behind it.

here is all the other code if you need it

planet.fs:

#version 330

// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
in vec4 fragColor;

uniform vec2 circleCenter;
uniform float circleRadius;
uniform vec2 iResolution;

uniform float rotation;
uniform float iTime;
uniform int seed; // will go instead of time in the snoise 3d

// Output fragment color
out vec4 finalColor;

//
// Description : Array and textureless GLSL 2D/3D/4D simplex 
//               noise functions.
//      Author : Ian McEwan, Ashima Arts.
//  Maintainer : stegu
//     Lastmod : 20110822 (ijm)
//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
//               Distributed under the MIT License. See LICENSE file.
//               https://github.com/ashima/webgl-noise
//               https://github.com/stegu/webgl-noise
// 

vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }

vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }

float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }

vec4 permute(vec4 x) { return mod289(((x*34.0)+10.0)*x); }

float permute(float x) { return mod289(((x*34.0)+10.0)*x); }

vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }

float taylorInvSqrt(float r) { return 1.79284291400159 - 0.85373472095314 * r; }

vec4 grad4(float j, vec4 ip)
  {
  const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0);
  vec4 p,s;

  p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0;
  p.w = 1.5 - dot(abs(p.xyz), ones.xyz);
  s = vec4(lessThan(p, vec4(0.0)));
  p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; 

  return p;
  }
						
// (sqrt(5) - 1)/4 = F4, used once below
#define F4 0.309016994374947451

float snoise4d(vec4 v)
  {
  const vec4  C = vec4( 0.138196601125011,  // (5 - sqrt(5))/20  G4
                        0.276393202250021,  // 2 * G4
                        0.414589803375032,  // 3 * G4
                       -0.447213595499958); // -1 + 4 * G4

// First corner
  vec4 i  = floor(v + dot(v, vec4(F4)) );
  vec4 x0 = v -   i + dot(i, C.xxxx);

// Other corners

// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
  vec4 i0;
  vec3 isX = step( x0.yzw, x0.xxx );
  vec3 isYZ = step( x0.zww, x0.yyz );
//  i0.x = dot( isX, vec3( 1.0 ) );
  i0.x = isX.x + isX.y + isX.z;
  i0.yzw = 1.0 - isX;
//  i0.y += dot( isYZ.xy, vec2( 1.0 ) );
  i0.y += isYZ.x + isYZ.y;
  i0.zw += 1.0 - isYZ.xy;
  i0.z += isYZ.z;
  i0.w += 1.0 - isYZ.z;

  // i0 now contains the unique values 0,1,2,3 in each channel
  vec4 i3 = clamp( i0, 0.0, 1.0 );
  vec4 i2 = clamp( i0-1.0, 0.0, 1.0 );
  vec4 i1 = clamp( i0-2.0, 0.0, 1.0 );

  //  x0 = x0 - 0.0 + 0.0 * C.xxxx
  //  x1 = x0 - i1  + 1.0 * C.xxxx
  //  x2 = x0 - i2  + 2.0 * C.xxxx
  //  x3 = x0 - i3  + 3.0 * C.xxxx
  //  x4 = x0 - 1.0 + 4.0 * C.xxxx
  vec4 x1 = x0 - i1 + C.xxxx;
  vec4 x2 = x0 - i2 + C.yyyy;
  vec4 x3 = x0 - i3 + C.zzzz;
  vec4 x4 = x0 + C.wwww;

// Permutations
  i = mod289(i); 
  float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
  vec4 j1 = permute( permute( permute( permute (
             i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))
           + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))
           + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))
           + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));

// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
  vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ;

  vec4 p0 = grad4(j0,   ip);
  vec4 p1 = grad4(j1.x, ip);
  vec4 p2 = grad4(j1.y, ip);
  vec4 p3 = grad4(j1.z, ip);
  vec4 p4 = grad4(j1.w, ip);

// Normalise gradients
  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
  p0 *= norm.x;
  p1 *= norm.y;
  p2 *= norm.z;
  p3 *= norm.w;
  p4 *= taylorInvSqrt(dot(p4,p4));

// Mix contributions from the five corners
  vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0);
  vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)            ), 0.0);
  m0 = m0 * m0;
  m1 = m1 * m1;
  return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
               + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;

  }

// Function to perform matrix multiplication
vec3 multiplyMatrix(vec3 v, mat3 m) {
    return vec3(
        dot(v, m[0]),
        dot(v, m[1]),
        dot(v, m[2])
    );
}

// Noise function with rotation
float snoise_rotated4d(vec3 v, mat3 rotationMatrix) {
    // Rotate the input vector using the transformation matrix
    vec3 rotatedV = multiplyMatrix(v, rotationMatrix);

    // Calculate simplex noise with the rotated coordinates
    return snoise4d(vec4(rotatedV, 0.3*iTime));
}


float color4d(vec3 xyz) { return snoise4d(vec4(xyz, 0.3*iTime)); }
float color_rotated4d(vec3 xyz, mat3 rotationMatrix) { return snoise_rotated4d(xyz, rotationMatrix); }

void main()
{
    // vec4 texel = texture(texture0, fragTexCoord);   // Get texel color
    // vec2 texelScale = vec2(0.0);

    // vec4 color = mix(vec4(0.0), outlineColor, outline);
    // finalColor = mix(color, texel, texel.a);

    // convert coordinates
    vec2 pixelCoord = gl_FragCoord.xy / iResolution;
    vec2 circleCenterCoord = circleCenter.xy / iResolution;
    float circleWidth = circleRadius / iResolution.x; // If I get some weird with this I can make it a vec2

    float dist = distance(pixelCoord, circleCenterCoord);
    
    if (circleWidth >= dist)
    {
        float x = (pixelCoord.x - circleCenterCoord.x) / circleWidth;
        float y = (pixelCoord.y - circleCenterCoord.y) / circleWidth;
        float z = sqrt( 1 - pow(x,2) - pow(y,2));

        finalColor = vec4(x,y,z,1.0);
        
        // vec2 p = (gl_FragCoord.xy/iResolution.y) * 2.0 - 1.0;

        // float z_squared = 1.0 - length(p.xy);
        float z_squared = z * z;
        // vec3 xyz = vec3(p, -sqrt(z_squared));
        vec3 xyz = vec3(x, y, -z);

        mat3 rotationMatrixX;
        rotationMatrixX[0] = vec3(1.0, 0.0, 0.0);
        rotationMatrixX[1] = vec3(0.0, cos(rotation/8), -sin(rotation/8));
        rotationMatrixX[2] = vec3(0.0, sin(rotation/8), cos(rotation/8));
        mat3 rotationMatrixY;
        rotationMatrixY[0] = vec3(cos(rotation), 0.0, sin(rotation));
        rotationMatrixY[1] = vec3(0.0, 1.0, 0.0);
        rotationMatrixY[2] = vec3(-sin(rotation), 0.0, cos(rotation));
        mat3 rotationMatrixZ;
        // 23.5(earth's tilt) / 90degrees * p/2 (to make rotation at 23.5)
        rotationMatrixZ[0] = vec3(cos(0.41), -sin(0.41), 0.0);
        rotationMatrixZ[1] = vec3(sin(0.41), cos(0.41), 0.0);
        rotationMatrixZ[2] = vec3(0.0, 0.0, 1.0);

        mat3 rotationMatrix = rotationMatrixZ * rotationMatrixY;

        vec3 step = vec3(1.3, 1.7, 2.1);
        // float n = color(xyz);
        // n += 0.5 * color(xyz * 2.0 - step);
        // n += 0.25 * color(xyz * 4.0 - 2.0 * step);
        // n += 0.125 * color(xyz * 8.0 - 3.0 * step);
        // n += 0.0625 * color(xyz * 16.0 - 4.0 * step);
        // n += 0.03125 * color(xyz * 32.0 - 5.0 * step);

        float n = color_rotated4d(xyz, rotationMatrix);
        n += 0.5 * color_rotated4d(xyz * 2.0 , rotationMatrix);
        n += 0.25 * color_rotated4d(xyz * 4.0 , rotationMatrix);
        n += 0.125 * color_rotated4d(xyz * 8.0 , rotationMatrix);
        n += 0.0625 * color_rotated4d(xyz * 16.0 , rotationMatrix);
        n += 0.03125 * color_rotated4d(xyz * 32.0 , rotationMatrix);

        finalColor.xyz = mix(0.0, 0.5 + 0.5 * n, smoothstep(0.0, 0.003, z_squared)) * vec3(1, 1, 1);

        if (finalColor.x < 0.5) {finalColor.xyz = vec3(0.0);}
    }
}

//https://stegu.github.io/webgl-noise/webdemo/

skymaps.fs:

#version 330

in vec2 fragTexCoord;
in vec4 fragColor;

uniform vec2 iResolution;
uniform float iTime;

out vec4 finalColor;

// 3D Gradient noise from: https://www.shadertoy.com/view/Xsl3Dl
vec3 hash( vec3 p ) // replace this by something better
{
	p = vec3( dot(p,vec3(127.1,311.7, 74.7)),
			  dot(p,vec3(269.5,183.3,246.1)),
			  dot(p,vec3(113.5,271.9,124.6)));

	return -1.0 + 2.0*fract(sin(p)*43758.5453123);
}

float Hash21(vec2 p ){
    p = fract(p*vec2(123.234, 234.34));
    p += dot(p, p+213.42);
    
    return fract(p.x*p.y);
}
float noise( in vec3 p )
{
    vec3 i = floor( p );
    vec3 f = fract( p );
	
	vec3 u = f*f*(3.0-2.0*f);

    return mix( mix( mix( dot( hash( i + vec3(0.0,0.0,0.0) ), f - vec3(0.0,0.0,0.0) ), 
                          dot( hash( i + vec3(1.0,0.0,0.0) ), f - vec3(1.0,0.0,0.0) ), u.x),
                     mix( dot( hash( i + vec3(0.0,1.0,0.0) ), f - vec3(0.0,1.0,0.0) ), 
                          dot( hash( i + vec3(1.0,1.0,0.0) ), f - vec3(1.0,1.0,0.0) ), u.x), u.y),
                mix( mix( dot( hash( i + vec3(0.0,0.0,1.0) ), f - vec3(0.0,0.0,1.0) ), 
                          dot( hash( i + vec3(1.0,0.0,1.0) ), f - vec3(1.0,0.0,1.0) ), u.x),
                     mix( dot( hash( i + vec3(0.0,1.0,1.0) ), f - vec3(0.0,1.0,1.0) ), 
                          dot( hash( i + vec3(1.0,1.0,1.0) ), f - vec3(1.0,1.0,1.0) ), u.x), u.y), u.z );
}

void main()
{
    // Normalized pixel coordinates (from 0 to 1)
    vec2 uv = gl_FragCoord.xy/iResolution.xy;
    
    // incoorperate coord if want to pixelate
    //float dx = 2.* (1.0 / iResolution.x);
    //float dy = 2.* (1.0 / iResolution.y);
    //vec2 coord = vec2(dx * floor(uv.x / dx), dy * floor(uv.y / dy));

    // Stars computation:
    vec3 stars_direction = vec3(uv * 2.f - 1.0f, 1.0f); // if you change the 2.f next to uv the size of the stars changes
	float stars_threshold = 8.0f; // modifies the number of stars that are visible
	float stars_exposure = 200.0f; // modifies the overall strength of the stars
	float stars = pow(clamp(noise(stars_direction * 200.0f), 0.0f, 1.0f), stars_threshold) * stars_exposure;
	
    float r = Hash21(vec2(stars));
    
    //stars *= mix(sin(r*6.283185), 2.4, noise(stars_direction * 100.0f + vec3(iTime/2.))); // time based flickering
    //stars *= mix(sin(r*6.283185)*2., 2.4, noise(stars_direction * 100.0f + vec3(iTime/2.))); //i think this is too much flickering
    //stars *= mix(1.-0.5*sin(r*6.283185), 2.4, noise(stars_direction * 100.0f + vec3(iTime/2.))); 

    //stars *= mix(.4, 2.4, noise(stars_direction * 100.0f + vec3(iTime/8.)));  //good THIS IS WAY BETTER IF YOU WANT TO ZOOM BECAUSE IT EFFECTS THE STARS MORE
  
    //stars *= mix(.4, 2.4, noise(stars_direction * 100.0f + vec3(iTime/2.)))/4.; // time based flickering
    //stars *= mix(0.4, 1.4, noise(stars_direction * 200.0f + vec3(iTime/4.)));
    //stars *= 1. - sin(2.*pow(sin(r*6.283185*iTime/4.), 2.));
    
    stars *= 1. - sin(2.*pow(sin(r*6.283185*iTime/4.), 2.))/2.; // IF ZOOMED STARS 0.5f YOU CCAN BARELY SEE IT
    
    // Output to screen
    finalColor = vec4(vec3(stars),1.0);

}

// https://www.shadertoy.com/view/NtsBzB

Makefile:


CC = cc -O2 -Wall -std=gnu2x

# Automatically get all .c files and convert them to .o
objects := $(patsubst %.c,%.o,$(wildcard *.c))

all: clean kunutza_destroyer

# Default target
kunutza_destroyer: $(objects)
	$(CC) $^ -o $@ -no-pie -lraylib -lm #-lbu what is that


.PHONY: clean

clean:
	# rm -f edit $(objects)
	rm -f *.o kunutza_destroyer

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

Can't get correct sampler2D in fragment shader. #5035

Uh oh!

{{title}}

Uh oh!

Replies: 0 comments

Select a reply

Uh oh!

Uh oh!

Can't get correct sampler2D in fragment shader. #5035

Uh oh!

Kunutza Jul 9, 2025

Replies: 0 comments

Kunutza
Jul 9, 2025