aceslowman

I am having trouble writing a shader that involves rapid alternating values. I am working on a 'shake' effect, for which I am moving back and forth between two positions, and with this being glsl, I have to rely on some sort of external data to actually generate that alternation.

My thought is that I could count the frames coming from jit.gl.render, and use a modulus to check if it's odd or even. The problem is that it's predictably inconsistent with some videos, more consistent with others.

What strategies might some of you suggest for getting something like this to work in glsl?

<jittershader name="shake">
    <description>
    Shake
    </description>
    <param name="amplitude" type="float" default="0.1" />
    <param name="time" type="float" default="0.0" />    
    <param name="preview" type="bool" default="0.0" />
    <language name="glsl" version="2.1">
        <bind param="amplitude" program="fp" />
        <bind param="preview" program="fp" />
        <bind param="time" program="fp" />        

        <program name="vp" type="vertex" source="sh.passthrudim.vp.glsl" />
        <program name="fp" type="fragment">
<![CDATA[
uniform sampler2DRect tex0;
varying vec2 texcoord0;
varying vec2 texdim0;

uniform bool preview;
uniform float amplitude;
uniform float time;

float rand(vec2 co)
{
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

void main()
{
    vec2 uv = texcoord0/texdim0;

    //vec2 shake = vec2(rand(vec2(time)));    //maybe not random... maybe do odd or even on modulus?
    vec2 shake = vec2((mod(time,2.)*2.)-1.,0.);
    
    
    uv += shake * vec2(amplitude);

    vec4 color = texture2DRect(tex0, uv*texdim0);

    if(texcoord0.x < (texdim0.x/2.) && preview){
        vec2 pos = texcoord0;
        pos.x += texdim0.x/2.;
        gl_FragColor = texture2DRect(tex0, pos);
    }else{
        gl_FragColor = color;
    }
}

]]>
        </program>
    </language>
</jittershader>


I am having trouble writing a shader that involves rapid alternating values. I am working on a 'shake' effect, for which I am moving back and forth between two positions, and with this being glsl, I have to rely on some sort of external data to actually generate that alternation. 

My thought is that I could count the frames coming from jit.gl.render, and use a modulus to check if it's odd or even. The problem is that it's predictably inconsistent with some videos, more consistent with others. 

<jittershader name="shake">
	<description>
	Shake
	</description>
	<param name="amplitude" type="float" default="0.1" />
	<param name="time" type="float" default="0.0" />	
	<param name="preview" type="bool" default="0.0" />
	<language name="glsl" version="2.1">
		<bind param="amplitude" program="fp" />
		<bind param="preview" program="fp" />
		<bind param="time" program="fp" />		

		<program name="vp" type="vertex" source="sh.passthrudim.vp.glsl" />
		<program name="fp" type="fragment">
<![CDATA[
uniform sampler2DRect tex0;
varying vec2 texcoord0;
varying vec2 texdim0;

uniform bool preview;
uniform float amplitude;
uniform float time;

float rand(vec2 co)
{
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

void main()
{
	vec2 uv = texcoord0/texdim0;

	//vec2 shake = vec2(rand(vec2(time)));	//maybe not random... maybe do odd or even on modulus?
	vec2 shake = vec2((mod(time,2.)*2.)-1.,0.);
	
	
	uv += shake * vec2(amplitude);

	vec4 color = texture2DRect(tex0, uv*texdim0);

	if(texcoord0.x < (texdim0.x/2.) && preview){
		vec2 pos = texcoord0;
		pos.x += texdim0.x/2.;
		gl_FragColor = texture2DRect(tex0, pos);
	}else{
		gl_FragColor = color;
	}
}

]]>
		</program>
	</language>
</jittershader>


I am having trouble writing a shader that involves rapid alternating values. I am working on a 'shake' effect, for which I am moving back an

sending-a-steady-consistent-framecount-to-a-shader

Your rand function if fed system time will create very rapid changes. 

vec2 shake = vec2(rand(vec2(time*0.0000001)));

Apply a different mutliplier and you control the speed
You can also make the time value an int
vec2 shake = vec2(rand(vec2(floor(time*0.1))));
Now you get steady timed jumps.



Why use modulo ?
Your rand function if fed system time will create very rapid changes. 
Just do this to slow it down
 

i strongly rec you check out the jit.mo package for this, specifically jit.time or jit.time.perlin.

also, you don't bang jit.world with a metro, simply enable rendering with a toggle.

Sending a steady, consistent, alternating values to a shader