Waterly.cpp (FFGL 2.1)

Waterly.cpp

#include "Waterly.h"
using namespace ffglex;
using namespace ffglqs;

static CFFGLPluginInfo PluginInfo(
	PluginFactory< Waterly >,// Create method
	"SH01",                  // Plugin unique ID of maximum length 4.
	"Waterly",               // Plugin name
	2,                       // API major version number
	1,                       // API minor version number
	1,                       // Plugin major version number
	0,                       // Plugin minor version number
	FF_EFFECT,               // Plugin type
	"",                      // Plugin description
	""                       // About
);

static const std::string fragmentShaderCode = R"(
#define PI 3.14159265358979

float SCALE = 1.0;
float style = 0.0;
float input_scale = 1.0;
vec2 direction = vec2(0.0);
vec2 position = vec2(0.0);

mat3 m = mat3( 0.00,  0.80,  0.60,
              -0.80,  0.36, -0.48,
              -0.60, -0.48,  0.64 );

float hash( float n )
{
    return fract(sin(n)*43758.5453);
}

float noise( in vec3 x )
{
    vec3 p = floor(x);
    vec3 f = fract(x);

    f = f*f*(3.0-2.0*f);

    float n = p.x + p.y*57.0 + 113.0*p.z;

    float res = mix(mix(mix( hash(n+  0.0), hash(n+  1.0),f.x),
                        mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y),
                    mix(mix( hash(n+113.0), hash(n+114.0),f.x),
                        mix( hash(n+170.0), hash(n+171.0),f.x),f.y),f.z);
    return res;
}

float fbm( vec3 p )
{
    float f;
    f  = 0.5000*noise( p ); p = m*p*2.02;
    f += 0.2500*noise( p ); p = m*p*2.03;
    f += 0.1250*noise( p ); p = m*p*2.01;
    f += 0.0625*noise( p );
    return f;
}
// --- End of: Created by inigo quilez --------------------
float mynoise ( vec3 p)
{
    return mix(noise(p*scale)*intensity, .5+.5*noise(p*scale)*intensity, style);
}
float myfbm( vec3 p )
{
    float f;
    f  = 0.5000*mynoise( p ); p = m*p*2.02;
    f += 0.2500*mynoise( p ); p = m*p*2.03;
    f += 0.1250*mynoise( p ); p = m*p*2.01;
    f += 0.0625*mynoise( p ); p = m*p*2.05;
    f += 0.0625/2.*mynoise( p ); p = m*p*2.02;
    f += 0.0625/4.*mynoise( p );
    return f;
}
float myfbm2( vec3 p )
{
    float f;
    f  = 1. - 0.5000*mynoise( p ); p = m*p*2.02;
    f *= 1. - 0.2500*mynoise( p ); p = m*p*2.03;
    f *= 1. - 0.1250*mynoise( p ); p = m*p*2.01;
    f *= 1. - 0.0625*mynoise( p ); p = m*p*2.05;
    f *= 1. - 0.0625/2.*mynoise( p ); p = m*p*2.02;
    f *= 1. - 0.0625/4.*mynoise( p );
    return f;
}

mat2 rotate2d(float _angle){
    return mat2(cos(_angle),-sin(_angle),
    sin(_angle),cos(_angle));
}

void main()
{
    vec2 fragCoord = gl_FragCoord.xy;
	vec2 _uv = i_uv;
    _uv.xy += direction.xy;

    //_uv = rotate2d(1*-PI) * _uv;

	vec3 v;
	vec3 p = 4.*vec3(_uv,0.)+(time)*(.1,.7,1.2)*rate;
	float x;
	if (mode == 0.0) {
		x = myfbm(p);
	} else if (mode == 1.0) {
		x = myfbm2(p);
	}

	//v = vec3(x);
	v = (.5+.5*sin(x*vec3(30.,20.,10.)*SCALE))/SCALE;
	float g = 1.;
	//g = pow(length(v),1.);
	//g =  .5*noise(8.*m*m*m*p)+.5; g = 2.*pow(g,3.);
	v *= g;

    vec3 Ti = texture(inputTexture, mod(.02*v.xy+position.xy+_uv.xy, 1.0)).rgb;
    vec3 T=Ti;
    //T = Ti+(1.-Ti)*Tf;
	vec3 T1,T2;
	T1 = vec3(0.,0.,0.); T1 *= .5*(T+1.);
	T2 = vec3(1.,1.,1.); //T2 = 1.2*Ti*vec3(1.,.8,.6)-.2;
	v = mix(T1,T2,T);
	fragColor = vec4(v, 1.0);
}
)";

Waterly::Waterly()
{
	// Input properties
	SetMinInputs( 1 );
	SetMaxInputs( 1 );

	SetFragmentShader( fragmentShaderCode );
	AddParam( ParamRange::Create( "rate", 0, { -1, 1 } ) );
	AddParam( Param::Create( "intensity" ) );
	AddParam( ParamRange::Create( "scale", 1.0, { 1, 3 } ) );
	AddParam( ParamOption::Create( "mode", { { "1" }, { "2" } } ) );
}
Waterly::~Waterly()
{
}