#### Howdy, Stranger!

We are about to switch to a new forum software. Until then we have removed the registration on this forum.

# Nebula Shader from Examples (What causes the 'zoom')

edited December 2016

I was toying around with the nebula shader example and specifically the nebula.glsl file.

The code is essentially made up of a nebula portion and stars portion. I have questions on the nebula portion and so have commented out the stars portion.

I'm only looking at just one of the nebula that is created (there are actually two in the original example). I stopped the rotation and have been adjusting some of the parameters. I'm trying to find out what is it that seems to be making the nebula zoom in and out. I don't want it to do that. However, I am having trouble pinpointing what is it that is making this zoom effect. Any help would be appreciated.

``````//Utility functions

return vec3(1.0,1.0,1.0);//t*t*t*(t*(t*6.0-15.0)+10.0);
}

vec2 rotate(vec2 point, float rads) {
return point * mat2(cs, -sn, sn, cs);
}

vec4 randomizer4(const vec4 x)
{
vec4 z = mod(x, vec4(5612.0));
z = mod(z, vec4(3.1415927 * 2.0));
return(fract(cos(z) * vec4(56812.5453)));
}

// Fast computed noise
// http://www.gamedev.net/topic/502913-fast-computed-noise/

const float A = 1.0;
const float B = 57.0;
const float C = 113.0;
const vec3 ABC = vec3(A, B, C);
const vec4 A3 = vec4(0, B, C, C+B);
const vec4 A4 = vec4(A, A+B, C+A, C+A+B);

float cnoise4(const in vec3 xx)
{
vec3 x = mod(xx + 32768.0, 65536.0);
vec3 ix =   floor(x);
vec3 fx = fract(x); // returns fractional part of x.
//vec3 wx = vec3(0,0,0);
//vec3 wx = vec3(0.0,-1.,1.0);
//vec3 wx = fx; wx.y=0;

vec3 wx = fx*fx*(3.0-2.0*fx);
//vec3 wx = fx*fx*fx;
//wx.x=0.0;
float nn = dot(ix, ABC);

vec4 N1 = nn + A3;
vec4 N2 =  nn + A4;
vec4 R1 = randomizer4(N1);
vec4 R2 = randomizer4(N2);
vec4 R = mix(R1, R2, wx.x);
float re = mix(mix(R.x, R.y, wx.y), mix(R.z, R.w, wx.y), wx.z);

return 1.0 - 2.0 * re;
}
float surface3 ( vec3 coord, float frequency ) {

float n = 0.0;

n += 1.0    * abs( cnoise4( coord * frequency ) );
n += 0.5    * abs( cnoise4( coord * frequency * 2.0 ) );
n += 0.25   * abs( cnoise4( coord * frequency * 4.0 ) );
n += 0.125  * abs( cnoise4( coord * frequency * 8.0 ) );
n += 0.0625 * abs( cnoise4( coord * frequency * 16.0 ) );

return n;
}

void main( void ) {
vec2 position = gl_FragCoord.xy / resolution.xy;
//position += rotate(position, rads); // rotates everything slowly.

//float n = surface3(vec3(position*sin(time*0.1), time * 0.05)*mat3(1,0,0,0,.8,.6,0,-.6,.8),2.0); //.9  //layer one
//float n = surface3(vec3(position*sin(time*0.1), time * 0.05) ,2.0); //.9  //layer one

float n2 = surface3(vec3(position*cos(time*0.1), time * 0.04)*mat3(1,0,0,0,.8,.6,0,-.6,.8),6.0); // .8 // layer two
//vec2 test = position*cos(time*0.1);
//float n2 = surface3(vec3(test, time * 0.04) ,6.0); // .8 // layer two
//float n2 = surface3(vec3(position*cos(time*0.1), 0) ,6); // .8 // layer two . z not affected

//float n2 = test.x;

//float lum = length(n);
float lum2 =  length(n2); //length of a scalar float is abs value.

//vec3 tc = pow(vec3(1.0-lum),vec3(sin(position.x)+cos(time)+4.0,8.0+sin(time)+4.0,8.0)); // layer one
vec3 tc2 = pow(vec3(1.1-lum2),vec3(5.0,position.y+cos(time)+7.0,sin(position.x)+sin(time)+2.0)); // layer 2
//vec3 tc2 = pow(vec3(1.1-lum2,1.1-lum2,1.1-lum2),vec3(5.0,position.y+cos(time)+7.0,sin(position.x)+sin(time)+2.0)); // layer 2
//vec3 tc2 = pow(vec3(1.1-lum2,1.1-lum2,1.1-lum2),vec3(5.0,7, 2.0)); // layer 2

vec3 curr_color = /*(tc*0.8) */+ (tc2*0.5);
//curr_color.z=0;
curr_color =vec3(lum2, lum2, lum2); //makes black n white
///////////////////////////////////////////////end nebula...//////////////////////////////
//Let's draw some stars

float scale = sin(0.3 * time) + 20.0;
vec2 position2 = (((gl_FragCoord.xy / resolution) - 0.5) * scale);
//vec3 color = vec3(100.0); // not used
float z = 0.0;
vec2 centered_coord = position2;// - vec2(sin(time*0.1),sin(time*0.1)); //what does this do?
//vec2 centered_coord = position2 - vec2(sin(time*0.4),sin(time*0.4));  // it makes you move along x y plane back n forth.

for (float i=1.0; i<=100.0; i++)
{
//vec2 star_pos = vec2(sin(i) * 250.0, sin(i*i*i) * 250.0);
vec2 star_pos = vec2(sin(i) * 1000.0, sin(i*i*i) * 1000.0);

//vec2 star_pos = vec2(sin(i) * 250.0, sin(i*i*i) * 1000.0);
//vec2 star_pos = vec2( sin(i)*250.0, i  );
//float z = mod(i*i - 50.0*time, 256.0); // x *time is speed.
//float z = mod(i - 50.0*time, 256.0); // i is ?? but if not there..it will  .
//float z = mod(i*i*i*i*i - 10.0*time, 256.0); // i is ?? but if not there..it will  .
//float z = mod(i- 10.0*time, 1024.0); // i is ?? but if not there..it will  .
float z = mod(i*i- 10.0*time, 256.0); // lava lamp also happens here..

float fade = (256.0 - z) /256.0;
//float fade = (1024.0 - z) /256.0; // cool effect almost lava lamp
vec2 blob_coord = star_pos / z;
}

//curr_color = vec3(0,0,0);// only does stars
//curr_color += gradient; // if comment out, only does nebula

gl_FragColor = vec4(curr_color, 1.0); // might be alpha
//gl_FragColor = vec4(gradient, 1.0); // does not work
}
``````

also providing the pde code

``````/**
* Nebula.
*
* From CoffeeBreakStudios.com (CBS)
* Ported from the webGL version in GLSL Sandbox:
* http://glsl.heroku.com/e#3265.2
*/

void setup() {
fullScreen( P2D);
//size(500,500, P2D);
noStroke();

nebula.set("resolution", float(width), float(height));
}

void draw() {
nebula.set("time", millis() / 500.0);
// This kind of raymarching effects are entirely implemented in the
// fragment shader, they only need a quad covering the entire view
// area so every pixel is pushed through the shader.
rect(0, 0, width, height);

text("fr: " + frameRate, width/2, 10);
}
``````
Tagged:

`float n2 = surface3(vec3(position*cos(0), time * 0.04)*mat3(1,0,0,0,.8,.6,0,-.6,.8),6.0); // .8 // layer two`