|
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/XsfXRSwhen 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/NtsBzBMakefile: |
Answered by
Maxaubert
Sep 28, 2026
Replies: 2 comments 1 reply
|
The texture isn't actually black, it's just never bound to Here's the mechanism in
So in your loop: SetShaderValueTexture(blackhole_shader, iChannel0Loc, combinedRT.texture); // registers texture unit 1
BeginTextureMode(target); // flush #1 -> clears the registration you just made
ClearBackground(BLACK);
BeginShaderMode(blackhole_shader); // flush #2 -> still clear
DrawTextureRec(combinedRT.texture, ...); // this draw eventually flushes with activeTextureId all zero, so unit 1 never gets bound
EndShaderMode();
EndTextureMode();By the time the batch containing your Fix: call BeginTextureMode(target);
ClearBackground(BLACK);
BeginShaderMode(blackhole_shader);
SetShaderValueTexture(blackhole_shader, iChannel0Loc, combinedRT.texture); // moved here
DrawTextureRec(combinedRT.texture,
(Rectangle){ 0, 0, (float)combinedRT.texture.width, (float)-combinedRT.texture.height },
(Vector2){ 0, 0 }, WHITE);
EndShaderMode();
EndTextureMode();This needs to be done every frame (which you're already doing), just after |
1 reply
|
Thank you so much for taking the time to answer! It is pretty cool to have someone help on this (I had pretty much given up and moved to another project). When I get some spare time I will read your answer carefully, apply your recommended changes and post the working version. |
Answer selected by
raysan5
|
It is now working as I originally intended. 
main.c: #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));
// Offset from top left corner!
Vector2 planetOffset = {400.0f, -400.0f};
// set the uniform for (vec2 circleCenter) in planet.fs
float circleCenter[2] = { (float)planetimBlank.width/2 + planetOffset.x, screen_height - (float)planetimBlank.height/2 + planetOffset.y};
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 + planetOffset.x, 0 - planetOffset.y, WHITE);
EndShaderMode();
EndTextureMode();
// Apply blackhole shader on combined result
BeginTextureMode(target);
ClearBackground(BLACK);
BeginShaderMode(blackhole_shader);
SetShaderValueTexture(blackhole_shader, iChannel0Loc, combinedRT.texture);
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);
}black_hole.fs: //https://www.shadertoy.com/view/XsfXRS
#version 330
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
// CombinedRT.texture: Rendered skymap + planet.
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)
out vec4 finalColor;
vec2 blackHoleCenters[1];
vec2 Fgrav(float m, vec2 center, vec2 pos)
{
vec2 dir = center - pos;
float distance = length(dir);
// Prevent division by zero.
distance = max(distance, 0.0001);
dir /= distance;
return dir * (m / (distance * distance));
}
void main()
{
// gl_FragCoord is in pixel coordinates, just like Shadertoy's fragCoord.
vec2 fragCoord = gl_FragCoord.xy;
vec2 centerOfMass = vec2(iResolution.x * 0.5, iResolution.y * 0.5);
// ========================================================
// BLACK HOLE 0
// ========================================================
blackHoleCenters[0] = centerOfMass;
blackHoleCenters[0].x += cos(1.0 * iTime + 3.0) * 80.0;
blackHoleCenters[0].y += sin(1.0 * iTime + 3.0) * 120.0;
// ========================================================
// TOTAL GRAVITY
// ========================================================
vec2 netGrav = Fgrav(900.0, blackHoleCenters[0], fragCoord);
float netGravMag = length(netGrav);
// ========================================================
// EVENT HORIZON
// ========================================================
if (netGravMag >= 1.0)
{
finalColor = vec4(0.0, 0.0, 0.0, 1.0);
return;
}
// ========================================================
// GRAVITATIONAL DISTORTION
// ========================================================
vec2 texCoord = (fragCoord + netGrav * 50.0) / iResolution;
// Keep UV inside the texture.
texCoord = clamp(texCoord, vec2(0.0001), vec2(0.9999));
// ========================================================
// SAMPLE SKYMAP + PLANET
// ========================================================
vec4 texColor = texture(iChannel0, texCoord);
// ========================================================
// GRAVITATIONAL REDSHIFT
// ========================================================
vec3 color = texColor.rgb;
//color.g *= 1.0 - netGravMag * netGravMag * netGravMag * 0.25;
//color.b *= 1.0 - netGravMag * 0.5;
// ========================================================
// GAMMA CORRECTION
// ========================================================
//color = pow(max(color, vec3(0.0)), vec3(1.0 / 2.2));
finalColor = vec4(color, 1.0);
}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/skymap.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 |
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
The texture isn't actually black, it's just never bound to
iChannel0for that draw call. The problem is call order: you callSetShaderValueTexturebeforeBeginTextureMode/BeginShaderMode, and both of those flush the internal render batch, which wipes out the texture-unit registration you just made.Here's the mechanism in
rlgl.h:SetShaderValueTexture→rlSetUniformSampleronly setsglUniform1i(locIndex, 1+i)and stashes the texture id inRLGL.State.activeTextureId[i]. It does not bind the texture yet:raylib/src/rlgl.h
Lines 4564 to 4589 in 6ecf21f