40 | // License: MIT
41 | vec4 transition(vec2 p) {
42 | float x = progress;
43 | x=smoothstep(.0,1.0,(x*2.0+p.x-1.0));
44 | return mix(getFromColor((p-.5)*(1.-x)+.5), getToColor((p-.5)*x+.5), x);
45 | }
46 |
47 |
48 |
49 | void main() {
50 | gl_FragColor = transition(isf_FragNormCoord.xy);
51 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Deinterlace.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Utility"
4 | ],
5 | "CREDIT": "by zoidberg",
6 | "INPUTS": [
7 | {
8 | "NAME": "inputImage",
9 | "TYPE": "image"
10 | }
11 | ],
12 | "ISFVSN": "2"
13 | }
14 | */
15 |
16 | const vec2 pointOffset = vec2(0.0, 1.0);
17 |
18 | void main() {
19 | vec4 outColor;
20 | // "upper" (a.k.a. "the top row")
21 | if (fract((gl_FragCoord.y+0.5)/2.0) == 0.0) {
22 | //gl_FragColor = vec4(1,0,0,1);
23 | outColor = (IMG_PIXEL(inputImage, gl_FragCoord.xy) + IMG_PIXEL(inputImage, gl_FragCoord.xy - pointOffset))/2.0;
24 | gl_FragColor = outColor;
25 | }
26 | // "lower" (a.k.a. "the bottom row")
27 | else {
28 | //gl_FragColor = vec4(0,1,0,1);
29 | outColor = (IMG_PIXEL(inputImage, gl_FragCoord.xy) + IMG_PIXEL(inputImage, gl_FragCoord.xy + pointOffset))/2.0;
30 | gl_FragColor = outColor;
31 | }
32 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Dot Screen.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Dreamy.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "ISFVSN" : "2",
4 | "INPUTS" : [
5 | {
6 | "TYPE" : "image",
7 | "NAME" : "startImage"
8 | },
9 | {
10 | "NAME" : "endImage",
11 | "TYPE" : "image"
12 | },
13 | {
14 | "TYPE" : "float",
15 | "NAME" : "progress",
16 | "MIN" : 0,
17 | "MAX" : 1,
18 | "DEFAULT" : 0
19 | }
20 | ],
21 | "CATEGORIES" : [
22 | "Distortion"
23 | ],
24 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Dreamy.glsl",
25 | "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: mikolalysenko
41 | // License: MIT
42 |
43 | vec2 offset(float progress, float x, float theta) {
44 | float phase = progress*progress + progress + theta;
45 | float shifty = 0.03*progress*cos(10.0*(progress+x));
46 | return vec2(0, shifty);
47 | }
48 | vec4 transition(vec2 p) {
49 | return mix(getFromColor(p + offset(progress, p.x, 0.0)), getToColor(p + offset(1.0-progress, p.x, 3.14)), progress);
50 | }
51 |
52 |
53 |
54 | void main() {
55 | gl_FragColor = transition(isf_FragNormCoord.xy);
56 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Edge Distort.vs:
--------------------------------------------------------------------------------
1 | varying vec2 left_coord;
2 | varying vec2 right_coord;
3 | varying vec2 above_coord;
4 | varying vec2 below_coord;
5 |
6 | varying vec2 lefta_coord;
7 | varying vec2 righta_coord;
8 | varying vec2 leftb_coord;
9 | varying vec2 rightb_coord;
10 |
11 |
12 | void main()
13 | {
14 | isf_vertShaderInit();
15 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
16 | vec2 d = 1.0/RENDERSIZE;
17 |
18 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
19 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
20 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
21 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
22 |
23 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
24 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
25 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
26 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
27 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Edge Trace.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = spread/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Edges.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Emboss.vs:
--------------------------------------------------------------------------------
1 | varying vec2 left_coord;
2 | varying vec2 right_coord;
3 | varying vec2 above_coord;
4 | varying vec2 below_coord;
5 |
6 | varying vec2 lefta_coord;
7 | varying vec2 rightb_coord;
8 |
9 |
10 | void main()
11 | {
12 | isf_vertShaderInit();
13 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
14 | vec2 d = 1.0/RENDERSIZE;
15 |
16 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
17 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
18 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
19 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
20 |
21 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
22 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
23 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Exposure Adjust.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by carter rosenberg",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Color Adjustment"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "inputEV",
14 | "TYPE": "float",
15 | "MIN": -10.0,
16 | "MAX": 10.0,
17 | "DEFAULT": 0.5
18 | }
19 | ]
20 | }*/
21 |
22 |
23 |
24 | void main() {
25 | // based on
26 | // https://developer.apple.com/library/mac/documentation/graphicsimaging/reference/CoreImageFilterReference/Reference/reference.html#//apple_ref/doc/filter/ci/CIExposureAdjust
27 | vec4 tmpColorA = IMG_THIS_PIXEL(inputImage);
28 | tmpColorA.rgb = tmpColorA.rgb * pow(2.0, inputEV);
29 | gl_FragColor = tmpColorA;
30 | }
31 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Fade.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "INPUTS" : [
4 | {
5 | "TYPE" : "image",
6 | "NAME" : "startImage"
7 | },
8 | {
9 | "NAME" : "endImage",
10 | "TYPE" : "image"
11 | },
12 | {
13 | "MAX" : 1,
14 | "TYPE" : "float",
15 | "MIN" : 0,
16 | "NAME" : "progress",
17 | "DEFAULT" : 0
18 | }
19 | ],
20 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/fade.glsl",
21 | "DESCRIPTION": "",
22 | "CATEGORIES" : [
23 | "Dissolve"
24 | ],
25 | "ISFVSN" : "2"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // author: gre
41 | // license: MIT
42 |
43 | vec4 transition (vec2 uv) {
44 | return mix(
45 | getFromColor(uv),
46 | getToColor(uv),
47 | progress
48 | );
49 | }
50 |
51 |
52 |
53 | void main() {
54 | gl_FragColor = transition(isf_FragNormCoord.xy);
55 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/False Color.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by zoidberg",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Color Effect"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "brightColor",
14 | "TYPE": "color",
15 | "DEFAULT": [
16 | 1.0,
17 | 0.9,
18 | 0.8,
19 | 1.0
20 | ]
21 | },
22 | {
23 | "NAME": "darkColor",
24 | "TYPE": "color",
25 | "DEFAULT": [
26 | 0.3,
27 | 0.0,
28 | 0.0,
29 | 1.0
30 | ]
31 | }
32 | ]
33 | }*/
34 |
35 | //const vec4 lumcoeff = vec4(0.299, 0.587, 0.114, 0.0);
36 | const vec4 lumcoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
37 |
38 | void main() {
39 | vec4 srcPixel = IMG_THIS_PIXEL(inputImage);
40 | float luminance = dot(srcPixel,lumcoeff);
41 | gl_FragColor = mix(vec4(darkColor.rgb, srcPixel.a), vec4(brightColor.rgb, srcPixel.a), luminance);
42 | }
43 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/FastMosh.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Flip H.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by VIDVOX",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Geometry Adjustment"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | }
12 | ]
13 | }*/
14 |
15 | void main() {
16 | vec2 normSrcCoord;
17 |
18 | normSrcCoord.x = isf_FragNormCoord[0];
19 | normSrcCoord.y = isf_FragNormCoord[1];
20 |
21 | normSrcCoord.x = (1.0-normSrcCoord.x);
22 |
23 | gl_FragColor = IMG_NORM_PIXEL(inputImage, normSrcCoord);
24 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Flip V.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by VIDVOX",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Geometry Adjustment"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | }
12 | ]
13 | }*/
14 |
15 | void main() {
16 | vec2 normSrcCoord;
17 |
18 | normSrcCoord.x = isf_FragNormCoord[0];
19 | normSrcCoord.y = isf_FragNormCoord[1];
20 |
21 | normSrcCoord.y = (1.0-normSrcCoord.y);
22 |
23 | gl_FragColor = IMG_NORM_PIXEL(inputImage, normSrcCoord);
24 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Freeze Frame.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "DESCRIPTION": "Holds the output on the captured freeze frame",
3 | "CREDIT": "by VIDVOX",
4 | "ISFVSN": "2",
5 | "CATEGORIES": [
6 | "Utility"
7 | ],
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "NAME": "freeze",
15 | "TYPE": "bool",
16 | "DEFAULT": 0.0
17 | }
18 | ],
19 | "PASSES": [
20 | {
21 | "TARGET":"freezeBuffer",
22 | "PERSISTENT": true
23 | }
24 | ]
25 |
26 | }*/
27 |
28 | // Essentially the same as a feedback buffer where you can only set it to a mix of 1.0
29 |
30 | void main()
31 | {
32 | if (freeze) {
33 | gl_FragColor = IMG_THIS_PIXEL(freezeBuffer);
34 | }
35 | else {
36 | gl_FragColor = IMG_THIS_PIXEL(inputImage);
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Gamma Correction.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by zoidberg",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Color Adjustment", "Utility"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "gamma",
14 | "TYPE": "float",
15 | "MIN": 0.0,
16 | "MAX": 1.0,
17 | "DEFAULT": 0.5
18 | }
19 | ]
20 | }*/
21 |
22 |
23 |
24 | void main() {
25 | // the input gamma range is 0.0-1.0 (normalized). the actual gamma range i want to use is 0.0 - 5.0.
26 | // however, actual gamma 0.0-1.0 is just as interesting as actual gamma 1.0-5.0, so we scale the normalized input to match...
27 | float realGamma = (gamma<=0.5) ? (gamma * 2.0) : (((gamma-0.5) * 2.0 * 4.0) + 1.0);
28 | vec4 tmpColorA = IMG_THIS_PIXEL(inputImage);
29 | vec4 tmpColorB;
30 | tmpColorB.rgb = pow(tmpColorA.rgb, vec3(1.0/realGamma));
31 | tmpColorB.a = tmpColorA.a;
32 | gl_FragColor = tmpColorB;
33 | }
34 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Glow.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 texOffsets[3];
3 | #else
4 | out vec2 texOffsets[3];
5 | #endif
6 |
7 | const float radius = 10.0;
8 |
9 | void main(void) {
10 | // load the main shader stuff
11 | isf_vertShaderInit();
12 |
13 | if (PASSINDEX==0 || PASSINDEX==2 || PASSINDEX==4 || PASSINDEX==6 || PASSINDEX==8) {
14 | float pixelWidth = 1.0/RENDERSIZE[0]*radius;
15 | if (PASSINDEX >= 2)
16 | pixelWidth *= .7;
17 | else if (PASSINDEX >= 6)
18 | pixelWidth *= 1.0;
19 | texOffsets[0] = isf_FragNormCoord;
20 | texOffsets[1] = clamp(vec2(isf_FragNormCoord[0]-pixelWidth, isf_FragNormCoord[1]),0.0,1.0);
21 | texOffsets[2] = clamp(vec2(isf_FragNormCoord[0]+pixelWidth, isf_FragNormCoord[1]),0.0,1.0);
22 | }
23 | else if (PASSINDEX==1 || PASSINDEX==3 || PASSINDEX==5 || PASSINDEX==7 || PASSINDEX==9) {
24 | float pixelHeight = 1.0/RENDERSIZE[1]*radius;
25 | if (PASSINDEX >= 3)
26 | pixelHeight *= .7;
27 | else if (PASSINDEX >= 6)
28 | pixelHeight *= 1.0;
29 | texOffsets[0] = isf_FragNormCoord;
30 | texOffsets[1] = clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-pixelHeight),0.0,1.0);
31 | texOffsets[2] = clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+pixelHeight),0.0,1.0);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/HSVtoRGB.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color Effect",
4 | "Utility"
5 | ],
6 | "CREDIT": "by zoidberg",
7 | "DESCRIPTION": "swizzles RGBA to BGRA and vice versa",
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | }
13 | ],
14 | "ISFVSN": "2"
15 | }
16 | */
17 |
18 |
19 |
20 |
21 | vec3 rgb2hsv(vec3 c) {
22 | vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
23 | //vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
24 | //vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
25 | vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
26 | vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
27 |
28 | float d = q.x - min(q.w, q.y);
29 | float e = 1.0e-10;
30 | return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
31 | }
32 |
33 | vec3 hsv2rgb(vec3 c) {
34 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
35 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
36 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
37 | }
38 |
39 |
40 |
41 |
42 | void main()
43 | {
44 | vec4 inColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
45 | gl_FragColor = vec4(hsv2rgb(inColor.rgb), inColor.a);
46 | }
47 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Heart Transition.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Wipe",
4 | "Retro"
5 | ],
6 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/heart.glsl",
7 | "DESCRIPTION": "",
8 | "INPUTS": [
9 | {
10 | "NAME": "startImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "NAME": "endImage",
15 | "TYPE": "image"
16 | },
17 | {
18 | "DEFAULT": 0,
19 | "MAX": 1,
20 | "MIN": 0,
21 | "NAME": "progress",
22 | "TYPE": "float"
23 | }
24 | ],
25 | "ISFVSN": "2"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: gre
41 | // License: MIT
42 |
43 | float inHeart (vec2 p, vec2 center, float size) {
44 | if (size==0.0) return 0.0;
45 | vec2 o = (p-center)/(1.6*size);
46 | float a = o.x*o.x+o.y*o.y-0.3;
47 | return step(a*a*a, o.x*o.x*o.y*o.y*o.y);
48 | }
49 | vec4 transition (vec2 uv) {
50 | return mix(
51 | getFromColor(uv),
52 | getToColor(uv),
53 | inHeart(uv, vec2(0.5, 0.4), progress)
54 | );
55 | }
56 |
57 |
58 |
59 | void main() {
60 | gl_FragColor = transition(isf_FragNormCoord.xy);
61 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Heart.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by VIDVOX",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Geometry"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "size",
10 | "LABEL": "Size",
11 | "TYPE": "float",
12 | "MIN": 0.0,
13 | "MAX": 1.0,
14 | "DEFAULT": 0.25
15 | },
16 | {
17 | "NAME": "color",
18 | "LABEL": "Fill Color",
19 | "TYPE": "color",
20 | "DEFAULT": [
21 | 1.0,
22 | 0.0,
23 | 0.0,
24 | 1.0
25 | ]
26 | }
27 | ]
28 | }*/
29 |
30 |
31 | // Adapted from https://glsl.io/transition/d71472a550601b96d69d
32 |
33 |
34 | bool inHeart (vec2 p, vec2 center, float size) {
35 | if (size == 0.0) return false;
36 | vec2 o = (p-center)/(1.6*size);
37 | return pow(o.x*o.x+o.y*o.y-0.3, 3.0) < o.x*o.x*pow(o.y, 3.0);
38 | }
39 |
40 | void main() {
41 | vec2 p = isf_FragNormCoord;
42 | float m = inHeart(p, vec2(0.5, 0.4), size) ? 1.0 : 0.0;
43 | gl_FragColor = mix(vec4(0.0), color, m);
44 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Histogram Viewer.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES" : [
3 | "Histogram", "Utility"
4 | ],
5 | "DESCRIPTION": "Draws an RGB histogram from a provided histogram image",
6 | "CREDIT": "by VIDVOX",
7 | "ISFVSN": "2",
8 | "INPUTS": [
9 | {
10 | "NAME": "histogramImage",
11 | "TYPE": "image"
12 | }
13 | ]
14 | }*/
15 |
16 |
17 | void main() {
18 | vec4 outColor = vec4(0., 0., 0., 0.);
19 | vec4 histoVals = IMG_NORM_PIXEL(histogramImage, vec2(isf_FragNormCoord.x, 0.5));
20 | if (histoVals.r >= isf_FragNormCoord.y) {
21 | outColor.r = 1.0;
22 | outColor.a = 1.0;
23 | }
24 | if (histoVals.g >= isf_FragNormCoord.y) {
25 | outColor.g = 1.0;
26 | outColor.a = 1.0;
27 | }
28 | if (histoVals.b >= isf_FragNormCoord.y) {
29 | outColor.b = 1.0;
30 | outColor.a = 1.0;
31 | }
32 |
33 | gl_FragColor = outColor;
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Hue-Saturation.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "DESCRIPTION" : "Hue\/Saturation adjustment",
4 | "ISFVSN" : "2",
5 | "INPUTS" : [
6 | {
7 | "NAME" : "inputImage",
8 | "TYPE" : "image"
9 | },
10 | {
11 | "NAME" : "hue",
12 | "TYPE" : "float",
13 | "MAX" : 1,
14 | "DEFAULT" : 0,
15 | "MIN" : -1,
16 | "LABEL" : "Hue"
17 | },
18 | {
19 | "NAME" : "saturation",
20 | "TYPE" : "float",
21 | "MAX" : 1,
22 | "DEFAULT" : 0,
23 | "LABEL" : "Saturation",
24 | "MIN" : -1
25 | }
26 | ],
27 | "CREDIT" : "2xAA"
28 | }
29 | */
30 |
31 | void main() {
32 | vec4 color = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord.xy);
33 |
34 | /* hue adjustment */
35 | float angle = hue * 3.14159265;
36 | float s = sin(angle), c = cos(angle);
37 | vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
38 | float len = length(color.rgb);
39 | color.rgb = vec3(
40 | dot(color.rgb, weights.xyz),
41 | dot(color.rgb, weights.zxy),
42 | dot(color.rgb, weights.yzx)
43 | );
44 |
45 | /* saturation adjustment */
46 | float average = (color.r + color.g + color.b) / 3.0;
47 | if (saturation > 0.0) {
48 | color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - saturation));
49 | } else {
50 | color.rgb += (average - color.rgb) * (-saturation);
51 | }
52 |
53 | gl_FragColor = color;
54 | }
55 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Interlace Mirror.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Glitch",
4 | "Retro"
5 | ],
6 | "CREDIT": "by Carter Rosenberg",
7 | "DESCRIPTION": "",
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "DEFAULT": 1,
15 | "LABEL": "Horizontal",
16 | "NAME": "horizontal",
17 | "TYPE": "bool"
18 | },
19 | {
20 | "DEFAULT": 0,
21 | "LABEL": "Vertical",
22 | "NAME": "vertical",
23 | "TYPE": "bool"
24 | }
25 | ],
26 | "ISFVSN": "2"
27 | }
28 | */
29 |
30 | void main()
31 | {
32 | vec2 pixelCoord = isf_FragNormCoord * RENDERSIZE;
33 | vec2 loc = pixelCoord;
34 | if (vertical) {
35 | if (mod(pixelCoord.x,2.0)>1.0) {
36 | loc.y = RENDERSIZE.y - pixelCoord.y;
37 | }
38 | }
39 | if (horizontal) {
40 | if (mod(pixelCoord.y,2.0)>1.0) {
41 | loc.x = RENDERSIZE.x - pixelCoord.x;
42 | }
43 | }
44 | gl_FragColor = IMG_PIXEL(inputImage,loc);
45 | }
46 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Kaleidoscope.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "effect"
5 | ],
6 | "DESCRIPTION" : "Kaleidoscope",
7 | "ISFVSN" : "2",
8 | "INPUTS" : [
9 | {
10 | "NAME" : "inputImage",
11 | "TYPE" : "image"
12 | },
13 | {
14 | "NAME" : "sides",
15 | "TYPE" : "float",
16 | "MAX" : 60,
17 | "DEFAULT" : 5,
18 | "MIN" : 2
19 | }
20 | ],
21 | "CREDIT" : "2xAA"
22 | }
23 | */
24 |
25 | void main() {
26 |
27 | vec2 uv = gl_FragCoord.xy/RENDERSIZE.xy;
28 |
29 | // normalize to the center
30 | uv = uv - 0.5;
31 |
32 | // cartesian to polar coordinates
33 | float r = length(uv);
34 | float a = atan(uv.y, uv.x);
35 |
36 | // kaleidoscope
37 | //float sides = 5.;
38 | float tau = 2. * 3.1416;
39 | a = mod(a, tau/sides);
40 | a = abs(a - tau/sides/2.);
41 |
42 | // polar to cartesian coordinates
43 | uv = r * vec2(cos(a), sin(a));
44 |
45 | // recenter
46 | uv = uv + 0.5;
47 |
48 | vec4 c = IMG_NORM_PIXEL(inputImage, uv);
49 | gl_FragColor = c;
50 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Layer Position.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "DESCRIPTION": "",
3 | "CREDIT": "",
4 | "ISFVSN": "2",
5 | "CATEGORIES": [
6 | "Geometry Adjustment", "Utility"
7 | ],
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "NAME": "offset",
15 | "TYPE": "point2D",
16 | "DEFAULT": [
17 | 0.5,
18 | 0.5
19 | ],
20 | "MIN": [
21 | 0.0,
22 | 0.0
23 | ],
24 | "MAX": [
25 | 1.0,
26 | 1.0
27 | ]
28 | },
29 | {
30 | "NAME": "repeatImage",
31 | "TYPE": "bool",
32 | "DEFAULT": 0.0
33 | }
34 | ]
35 |
36 | }*/
37 |
38 | void main() {
39 | vec4 outputColor = vec4(0.0);
40 | vec2 newLoc = offset;
41 | vec2 topSize = RENDERSIZE;
42 |
43 | newLoc = offset * RENDERSIZE;
44 | newLoc.x = topSize.x - newLoc.x;
45 | newLoc.y = topSize.y - newLoc.y;
46 | newLoc = (gl_FragCoord.xy + 2.0*newLoc) - topSize;
47 |
48 | if (repeatImage) {
49 | newLoc = mod(newLoc, RENDERSIZE);
50 | }
51 |
52 | if ((newLoc.x >= 0.0)&&(newLoc.x < RENDERSIZE.x)&&(newLoc.y >= 0.0)&&(newLoc.y <= RENDERSIZE.y)) {
53 | outputColor = IMG_PIXEL(inputImage, newLoc);
54 | }
55 |
56 | gl_FragColor = outputColor;
57 | }
58 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Lens Flare.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Life.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]) * RENDERSIZE;
28 |
29 | left_coord = vec2(texc.xy + vec2(-1.0 , 0));
30 | right_coord = vec2(texc.xy + vec2(1.0 , 0));
31 | above_coord = vec2(texc.xy + vec2(0,1.0));
32 | below_coord = vec2(texc.xy + vec2(0,-1.0));
33 |
34 | lefta_coord = vec2(texc.xy + vec2(-1.0 , 1.0));
35 | righta_coord = vec2(texc.xy + vec2(1.0 , 1.0));
36 | leftb_coord = vec2(texc.xy + vec2(-1.0 , -1.0));
37 | rightb_coord = vec2(texc.xy + vec2(1.0 , -1.0));
38 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Line Screen.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Luma Transition.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "ISFVSN" : "2",
4 | "CATEGORIES" : [
5 | "Dissolve"
6 | ],
7 | "INPUTS" : [
8 | {
9 | "TYPE" : "image",
10 | "NAME" : "startImage"
11 | },
12 | {
13 | "NAME" : "endImage",
14 | "TYPE" : "image"
15 | },
16 | {
17 | "TYPE" : "float",
18 | "MIN" : 0,
19 | "DEFAULT" : 0,
20 | "NAME" : "progress",
21 | "MAX" : 1
22 | },
23 | {
24 | "NAME" : "luma",
25 | "TYPE" : "image"
26 | }
27 | ],
28 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/luma.glsl",
29 | "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/"
30 | }
31 | */
32 |
33 |
34 |
35 | vec4 getFromColor(vec2 inUV) {
36 | return IMG_NORM_PIXEL(startImage, inUV);
37 | }
38 | vec4 getToColor(vec2 inUV) {
39 | return IMG_NORM_PIXEL(endImage, inUV);
40 | }
41 |
42 |
43 |
44 | // Author: gre
45 | // License: MIT
46 |
47 |
48 | vec4 transition(vec2 uv) {
49 | return mix(
50 | getToColor(uv),
51 | getFromColor(uv),
52 | step(progress, IMG_NORM_PIXEL(luma, uv).r-0.001)
53 | );
54 | }
55 |
56 |
57 |
58 | void main() {
59 | gl_FragColor = transition(isf_FragNormCoord.xy);
60 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Maximum Component.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by zoidberg",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Color Effect", "Utility"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | }
12 | ]
13 | }*/
14 |
15 | void main() {
16 | vec4 srcPixel = IMG_THIS_PIXEL(inputImage);
17 | float maxComponent = max(srcPixel.r, max(srcPixel.g, srcPixel.b));
18 | gl_FragColor = vec4(maxComponent, maxComponent, maxComponent, srcPixel.a);
19 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Minimum Component.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color Effect",
4 | "Utility"
5 | ],
6 | "CREDIT": "by zoidberg",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | }
12 | ],
13 | "ISFVSN": "2"
14 | }
15 | */
16 |
17 | void main() {
18 | vec4 srcPixel = IMG_THIS_PIXEL(inputImage);
19 | float minComponent = min(srcPixel.r, min(srcPixel.g, srcPixel.b));
20 | gl_FragColor = vec4(minComponent, minComponent, minComponent, srcPixel.a);
21 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Mirror Edge.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by VIDVOX",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Tile Effect"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "angle",
14 | "LABEL": "Angle",
15 | "TYPE": "float",
16 | "MIN": 0.0,
17 | "MAX": 1.0,
18 | "DEFAULT": 0.0
19 | },
20 | {
21 | "NAME": "shift",
22 | "LABEL": "Shift",
23 | "TYPE": "point2D",
24 | "DEFAULT": [
25 | 0.0,
26 | 0.5
27 | ]
28 | }
29 | ]
30 | }*/
31 |
32 |
33 | varying vec2 translated_coord;
34 |
35 |
36 | void main() {
37 | vec2 loc = translated_coord;
38 | vec2 modifiedCenter = shift / RENDERSIZE;
39 |
40 | loc = mod(loc + modifiedCenter, 1.0);
41 |
42 | // mirror the image so it's repeated 4 times at different reflections
43 | loc = 2.0 * abs(loc - 0.5);
44 |
45 | gl_FragColor = IMG_NORM_PIXEL(inputImage, loc);
46 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Mirror Edge.vs:
--------------------------------------------------------------------------------
1 | varying vec2 translated_coord;
2 |
3 | const float pi = 3.14159265359;
4 |
5 | void main() {
6 | isf_vertShaderInit();
7 |
8 | vec2 loc = RENDERSIZE * vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
9 |
10 | float r = distance(RENDERSIZE/2.0, loc);
11 | float a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
12 |
13 | loc.x = r * cos(a + 2.0 * pi * angle) + 0.5;
14 | loc.y = r * sin(a + 2.0 * pi * angle) + 0.5;
15 |
16 | translated_coord = loc / RENDERSIZE + vec2(0.5);
17 |
18 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Mirror.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by VIDVOX",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Geometry Adjustment"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "horizontal",
14 | "TYPE": "bool",
15 | "DEFAULT": 1.0
16 | },
17 | {
18 | "NAME": "vertical",
19 | "TYPE": "bool",
20 | "DEFAULT": 0.0
21 | }
22 | ]
23 | }*/
24 |
25 | void main() {
26 | // isf_FragNormCoord[0] and isf_FragNormCoord[1] are my normalized x/y coordinates
27 | // if we're not doing a flip in either direction we can just pass thru
28 | vec2 normSrcCoord;
29 |
30 | normSrcCoord.x = isf_FragNormCoord[0];
31 | normSrcCoord.y = isf_FragNormCoord[1];
32 |
33 | if ((normSrcCoord.x > 0.5)&&(horizontal)) {
34 | normSrcCoord.x = (1.0-normSrcCoord.x);
35 | }
36 | if ((normSrcCoord.y > 0.5)&&(vertical)) {
37 | normSrcCoord.y = (1.0-normSrcCoord.y);
38 | }
39 |
40 | gl_FragColor = IMG_NORM_PIXEL(inputImage, normSrcCoord);
41 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Multiply Blend.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "ISFVSN" : "2",
4 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/multiply_blend.glsl",
5 | "DESCRIPTION": "",
6 | "CATEGORIES" : [
7 | "Dissolve"
8 | ],
9 | "INPUTS" : [
10 | {
11 | "NAME" : "startImage",
12 | "TYPE" : "image"
13 | },
14 | {
15 | "NAME" : "endImage",
16 | "TYPE" : "image"
17 | },
18 | {
19 | "MAX" : 1,
20 | "DEFAULT" : 0,
21 | "MIN" : 0,
22 | "TYPE" : "float",
23 | "NAME" : "progress"
24 | }
25 | ]
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: Fernando Kuteken
41 | // License: MIT
42 |
43 | vec4 blend(vec4 a, vec4 b) {
44 | return a * b;
45 | }
46 |
47 | vec4 transition (vec2 uv) {
48 |
49 | vec4 blended = blend(getFromColor(uv), getToColor(uv));
50 |
51 | if (progress < 0.5)
52 | return mix(getFromColor(uv), blended, 2.0 * progress);
53 | else
54 | return mix(blended, getToColor(uv), 2.0 * progress - 1.0);
55 | }
56 |
57 |
58 |
59 |
60 | void main() {
61 | gl_FragColor = transition(isf_FragNormCoord.xy);
62 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Neon.vs:
--------------------------------------------------------------------------------
1 | varying vec2 left_coord;
2 | varying vec2 right_coord;
3 | varying vec2 above_coord;
4 | varying vec2 below_coord;
5 |
6 | varying vec2 lefta_coord;
7 | varying vec2 righta_coord;
8 | varying vec2 leftb_coord;
9 | varying vec2 rightb_coord;
10 |
11 |
12 | void main()
13 | {
14 | isf_vertShaderInit();
15 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
16 | vec2 d = 1.0/RENDERSIZE;
17 |
18 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
19 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
20 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
21 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
22 |
23 | d = 1.0/RENDERSIZE;
24 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
25 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
26 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
27 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
28 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Optical Flow Distort.vs:
--------------------------------------------------------------------------------
1 | varying vec2 left_coord;
2 | varying vec2 right_coord;
3 | varying vec2 above_coord;
4 | varying vec2 below_coord;
5 |
6 | varying vec2 lefta_coord;
7 | varying vec2 righta_coord;
8 | varying vec2 leftb_coord;
9 | varying vec2 rightb_coord;
10 |
11 |
12 | void main()
13 | {
14 | isf_vertShaderInit();
15 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
16 | vec2 d = 4.0/RENDERSIZE;
17 |
18 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
19 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
20 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
21 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
22 |
23 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
24 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
25 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
26 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
27 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Pinch.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "effect"
5 | ],
6 | "DESCRIPTION" : "Pinch",
7 | "ISFVSN" : "2",
8 | "INPUTS" : [
9 | {
10 | "NAME" : "inputImage",
11 | "TYPE" : "image"
12 | },
13 | {
14 | "NAME" : "center",
15 | "TYPE" : "point2D",
16 | "DEFAULT": [0.5,0.5],
17 | "MIN": [0,0],
18 | "MAX": [1,1]
19 | },
20 | {
21 | "NAME" : "amount",
22 | "TYPE" : "float",
23 | "MAX" : 4.0,
24 | "DEFAULT" : 2.0,
25 | "MIN" : 0
26 | }
27 | ],
28 | "CREDIT" : "2xAA"
29 | }
30 | */
31 |
32 | precision mediump float;
33 |
34 | void main() {
35 |
36 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy;
37 |
38 | // normalize to the center
39 | uv = uv - center;
40 |
41 | // cartesian to polar coordinates
42 | float r = length(uv);
43 | float a = atan(uv.y, uv.x);
44 |
45 | // distort
46 | r = sqrt(r/amount); // pinch
47 |
48 | // polar to cartesian coordinates
49 | uv = r * vec2(cos(a), sin(a));
50 |
51 | uv = uv + center;
52 |
53 | vec4 c = IMG_NORM_PIXEL(inputImage, uv);
54 | gl_FragColor = c;
55 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Posterize.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Retro",
4 | "Stylize",
5 | "Color Effect"
6 | ],
7 | "CREDIT": "VIDVOX",
8 | "DESCRIPTION": "Posterizes an image",
9 | "INPUTS": [
10 | {
11 | "NAME": "inputImage",
12 | "TYPE": "image"
13 | },
14 | {
15 | "DEFAULT": 1.25,
16 | "LABEL": "Gamma",
17 | "MAX": 2,
18 | "MIN": 0.5,
19 | "NAME": "gamma",
20 | "TYPE": "float"
21 | },
22 | {
23 | "DEFAULT": 6,
24 | "LABEL": "Quality",
25 | "MAX": 32,
26 | "MIN": 3,
27 | "NAME": "numColors",
28 | "TYPE": "float"
29 | }
30 | ],
31 | "ISFVSN": "2"
32 | }
33 | */
34 |
35 | void main() {
36 |
37 | vec4 c = IMG_THIS_PIXEL(inputImage);
38 |
39 | c.rgb = pow(c.rgb, vec3(gamma, gamma, gamma));
40 | c.rgb = c.rgb * numColors;
41 | c.rgb = floor(c.rgb);
42 | c.rgb = c.rgb / numColors;
43 | c.rgb = pow(c.rgb, vec3(1.0/gamma));
44 |
45 | gl_FragColor = c;
46 | }
47 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/RGB EQ.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by VIDVOX",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Color Adjustment"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "red",
14 | "TYPE": "float",
15 | "MIN": 0.0,
16 | "MAX": 2.0,
17 | "DEFAULT": 1.0
18 | },
19 | {
20 | "NAME": "green",
21 | "TYPE": "float",
22 | "MIN": 0.0,
23 | "MAX": 2.0,
24 | "DEFAULT": 1.0
25 | },
26 | {
27 | "NAME": "blue",
28 | "TYPE": "float",
29 | "MIN": 0.0,
30 | "MAX": 2.0,
31 | "DEFAULT": 1.0
32 | },
33 | {
34 | "NAME": "gain",
35 | "TYPE": "float",
36 | "MIN": -1.0,
37 | "MAX": 1.0,
38 | "DEFAULT": 0.0
39 | }
40 | ]
41 | }*/
42 |
43 |
44 |
45 |
46 | void main() {
47 | vec4 pixel = IMG_THIS_PIXEL(inputImage);
48 | float brightness = (pixel.r * red + pixel.g * green + pixel.b * blue) / 3.0;
49 |
50 | pixel.r = pixel.r * red;
51 | pixel.g = pixel.g * green;
52 | pixel.b = pixel.b * blue;
53 |
54 | if (gain >= 0.0) {
55 | pixel.a = (brightness >= gain) ? pixel.a : 0.0;
56 | }
57 | else {
58 | pixel.a = (brightness <= 1.0-abs(gain)) ? pixel.a : 0.0;
59 | }
60 | gl_FragColor = pixel;
61 | }
62 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/RGB Invert.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color Effect",
4 | "Utility"
5 | ],
6 | "CREDIT": "by VIDVOX",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "DEFAULT": 1,
14 | "NAME": "r",
15 | "TYPE": "bool"
16 | },
17 | {
18 | "DEFAULT": 1,
19 | "NAME": "g",
20 | "TYPE": "bool"
21 | },
22 | {
23 | "DEFAULT": 1,
24 | "NAME": "b",
25 | "TYPE": "bool"
26 | },
27 | {
28 | "DEFAULT": 0,
29 | "NAME": "a",
30 | "TYPE": "bool"
31 | }
32 | ],
33 | "ISFVSN": "2"
34 | }
35 | */
36 |
37 | void main() {
38 | vec4 srcPixel = IMG_THIS_PIXEL(inputImage);
39 | if (r)
40 | srcPixel.r = 1.0-srcPixel.r;
41 | if (g)
42 | srcPixel.g = 1.0-srcPixel.g;
43 | if (b)
44 | srcPixel.b = 1.0-srcPixel.b;
45 | if (a)
46 | srcPixel.a = 1.0-srcPixel.a;
47 | gl_FragColor = srcPixel;
48 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/RGB Trails 3.0.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by zoidberg",
3 | "ISFVSN": "2",
4 | "DESCRIPTION": "a persistent buffer is used to maintain an image which is constantly updated. Similar to VVMotionBlur, but each channel has its own weight",
5 | "CATEGORIES": [
6 | "Color Effect"
7 | ],
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "NAME": "rWeight",
15 | "TYPE": "float"
16 | },
17 | {
18 | "NAME": "gWeight",
19 | "TYPE": "float"
20 | },
21 | {
22 | "NAME": "bWeight",
23 | "TYPE": "float"
24 | },
25 | {
26 | "NAME": "aWeight",
27 | "TYPE": "float",
28 | "DEFAULT": 0.0
29 | }
30 | ],
31 | "PASSES": [
32 | {
33 | "TARGET":"accum",
34 | "PERSISTENT": true,
35 | "FLOAT": true
36 | },
37 | {
38 |
39 | }
40 | ]
41 |
42 | }*/
43 |
44 | void main()
45 | {
46 | if (PASSINDEX==0) {
47 | vec4 freshPixel = IMG_THIS_PIXEL(inputImage);
48 | vec4 stalePixel = IMG_THIS_PIXEL(accum);
49 | gl_FragColor = vec4(mix(freshPixel.r,stalePixel.r,rWeight), mix(freshPixel.g,stalePixel.g,gWeight), mix(freshPixel.b,stalePixel.b,bWeight), mix(freshPixel.a,stalePixel.a,aWeight));
50 | }
51 | else
52 | gl_FragColor = IMG_THIS_PIXEL(accum);
53 | }
54 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/RGBtoHSV.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color Effect",
4 | "Utility"
5 | ],
6 | "CREDIT": "by zoidberg",
7 | "DESCRIPTION": "swizzles RGBA to BGRA and vice versa",
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | }
13 | ],
14 | "ISFVSN": "2"
15 | }
16 | */
17 |
18 |
19 |
20 |
21 | vec3 rgb2hsv(vec3 c) {
22 | vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
23 | //vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
24 | //vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
25 | vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
26 | vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
27 |
28 | float d = q.x - min(q.w, q.y);
29 | float e = 1.0e-10;
30 | return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
31 | }
32 |
33 | vec3 hsv2rgb(vec3 c) {
34 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
35 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
36 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
37 | }
38 |
39 |
40 |
41 |
42 | void main()
43 | {
44 | vec4 inColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
45 | gl_FragColor = vec4(rgb2hsv(inColor.rgb), inColor.a);
46 | }
47 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Rotate.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Geometry Adjustment",
4 | "Utility"
5 | ],
6 | "CREDIT": "by VIDVOX",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "DEFAULT": 0,
14 | "MAX": 1,
15 | "MIN": 0,
16 | "NAME": "angle",
17 | "TYPE": "float"
18 | }
19 | ],
20 | "ISFVSN": "2"
21 | }
22 | */
23 |
24 | #if __VERSION__ <= 120
25 | varying vec2 translated_coord;
26 | #else
27 | in vec2 translated_coord;
28 | #endif
29 |
30 | void main() {
31 | vec2 loc = translated_coord;
32 | // if out of range draw black
33 | if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0)) {
34 | gl_FragColor = vec4(0.0);
35 | }
36 | else {
37 | gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Rotate.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 translated_coord;
3 | #else
4 | out vec2 translated_coord;
5 | #endif
6 |
7 | const float pi = 3.14159265359;
8 |
9 | void main() {
10 | isf_vertShaderInit();
11 |
12 | vec2 loc = RENDERSIZE * vec2(vv_FragNormCoord[0],vv_FragNormCoord[1]);
13 | float r = distance(RENDERSIZE/2.0, loc);
14 | float a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
15 |
16 | loc.x = r * cos(a + 2.0 * pi * angle) + 0.5;
17 | loc.y = r * sin(a + 2.0 * pi * angle) + 0.5;
18 |
19 | translated_coord = loc / RENDERSIZE + vec2(0.5);
20 |
21 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Saturation Bleed.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Sepia Tone.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color Effect",
4 | "Retro"
5 | ],
6 | "CREDIT": "by VIDVOX",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "DEFAULT": 0.8,
14 | "MAX": 1.2,
15 | "MIN": 0.8,
16 | "NAME": "contrast",
17 | "TYPE": "float"
18 | }
19 | ],
20 | "ISFVSN": "2"
21 | }
22 | */
23 |
24 |
25 | // Adapted from https://www.omniref.com/ruby/gems/essytas/0.0.1/files/lib/glsl/sepia.frag
26 |
27 | void main() {
28 |
29 | vec4 rawColor = IMG_THIS_PIXEL(inputImage);
30 | vec4 color = rawColor;
31 | vec4 sepia1 = vec4( 0.2, 0.05, 0.0, 1.0 );
32 | vec4 sepia2 = vec4( 1.0, 0.9, 0.5, 1.0 );
33 | float sepiaMix = dot(vec3(0.3, 0.59, 0.11), color.rgb);
34 | color = mix(color, vec4(sepiaMix), 0.5);
35 | vec4 sepia = mix(sepia1, sepia2, sepiaMix);
36 | sepia = vec4( min( vec3( 1.0 ), sepia.rgb ), color.a );
37 |
38 | float bright = 0.05;
39 | sepia = sepia + vec4(bright, bright, bright, 0.0);
40 | sepia.rgb = ((vec3(2.0) * (sepia.rgb - vec3(0.5))) * vec3(contrast) / vec3(2.0)) + vec3(0.5);
41 | sepia.a = rawColor.a;
42 | gl_FragColor = sepia;
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Set Alpha.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color Adjustment",
4 | "Utility"
5 | ],
6 | "CREDIT": "VIDVOX",
7 | "DESCRIPTION": "Sets the alpha channel of the image",
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "DEFAULT": 0.5,
15 | "LABEL": "New Alpha",
16 | "MAX": 1,
17 | "MIN": 0,
18 | "NAME": "newAlpha",
19 | "TYPE": "float"
20 | }
21 | ],
22 | "ISFVSN": "2"
23 | }
24 | */
25 |
26 | void main() {
27 | vec4 inputPixelColor = IMG_THIS_NORM_PIXEL(inputImage);
28 |
29 | inputPixelColor.a = newAlpha;
30 |
31 | gl_FragColor = inputPixelColor;
32 | }
33 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Shake.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Noise",
4 | "Geometry Adjustment"
5 | ],
6 | "CREDIT": "by VIDVOX",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "DEFAULT": 0,
14 | "MAX": 2,
15 | "MIN": 0,
16 | "NAME": "magnitude",
17 | "TYPE": "float"
18 | },
19 | {
20 | "DEFAULT": 1,
21 | "MAX": 10,
22 | "MIN": 0,
23 | "NAME": "intensity",
24 | "TYPE": "float"
25 | }
26 | ],
27 | "ISFVSN": "2"
28 | }
29 | */
30 |
31 |
32 | const float pi = 3.14159265359;
33 |
34 |
35 | float rand(vec2 co) {
36 | return fract(sin(dot(co.xy, vec2(12.9898,78.233))) * 43758.5453);
37 | }
38 |
39 | void main(void) {
40 | float offset = 0.1 * magnitude;
41 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy;
42 | float rotation = intensity * 2.0 * pi * rand(vec2(magnitude, TIME));
43 | float yOffset = offset * sin(TIME * 1.0 * cos(TIME * intensity) + rotation) * rand(vec2(magnitude, TIME));
44 | float xOffset = offset * cos(TIME * 1.0 * cos(TIME * intensity) + rotation) * rand(vec2(1.0-magnitude, TIME));;
45 |
46 | float zoom = 1.0 + offset;
47 |
48 | uv = (uv - 0.5) / zoom + 0.5;
49 |
50 | uv.y += yOffset;
51 | uv.x += xOffset;
52 |
53 | gl_FragColor = IMG_NORM_PIXEL(inputImage, uv);
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Sharpen Luminance.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Sharpen RGB.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Show Alpha.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Utility"
4 | ],
5 | "CREDIT": "VIDVOX",
6 | "DESCRIPTION": "Maps the alpha to grayscale",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | }
12 | ],
13 | "ISFVSN": "2"
14 | }
15 | */
16 |
17 | void main() {
18 | vec4 inputPixelColor = IMG_THIS_PIXEL(inputImage);
19 | inputPixelColor.rgb = vec3(inputPixelColor.a);
20 | inputPixelColor.a = 1.0;
21 | gl_FragColor = inputPixelColor;
22 | }
23 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Side Scroller And Flip.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "BrianChasalow",
3 | "ISFVSN": "2",
4 | "CATEGORIES": [
5 | "Geometry Adjustment"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "slide",
14 | "TYPE": "float",
15 | "MIN": 0.0,
16 | "MAX": 2.0,
17 | "DEFAULT": 0.0
18 | },
19 | {
20 | "NAME": "shift",
21 | "TYPE": "float",
22 | "MIN": 0.0,
23 | "MAX": 2.0,
24 | "DEFAULT": 0.0
25 | },
26 | {
27 | "NAME": "mirrorHorizontal",
28 | "TYPE": "bool",
29 | "MIN": false,
30 | "MAX": true,
31 | "DEFAULT": true
32 | },
33 | {
34 | "NAME": "mirrorVertical",
35 | "TYPE": "bool",
36 | "MIN": false,
37 | "MAX": true,
38 | "DEFAULT": true
39 | }
40 |
41 | ]
42 | }*/
43 |
44 | void main(void)
45 | {
46 | vec2 retard = isf_FragNormCoord;
47 | retard.x += slide;
48 | retard.y += shift;
49 | vec2 moddedRetard = mod(retard,1.0);
50 |
51 | if(mirrorHorizontal && retard.x >= 1.0 && retard.x <= 2.0)
52 | moddedRetard = vec2(1.0-moddedRetard.x, moddedRetard.y);
53 | if(mirrorVertical && retard.y >= 1.0 && retard.y <= 2.0)
54 | moddedRetard = vec2(moddedRetard.x, 1.0-moddedRetard.y);
55 |
56 | vec4 pixel = IMG_NORM_PIXEL(inputImage, moddedRetard);
57 | gl_FragColor = pixel;
58 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Sketch.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Slice.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "effect"
5 | ],
6 | "DESCRIPTION" : "Slice",
7 | "ISFVSN" : "2",
8 | "INPUTS" : [
9 | {
10 | "NAME" : "inputImage",
11 | "TYPE" : "image"
12 | },
13 | {
14 | "NAME" : "slices",
15 | "TYPE" : "float",
16 | "MAX" : 200,
17 | "DEFAULT" : 10,
18 | "MIN" : 1
19 | },
20 | {
21 | "NAME" : "offset",
22 | "TYPE" : "float",
23 | "MAX" : 0.5,
24 | "DEFAULT" : 0.03,
25 | "MIN" : 0
26 | },
27 | {
28 | "NAME" : "timeMultiplier",
29 | "TYPE" : "float",
30 | "MAX" : 3.0,
31 | "DEFAULT" : 1.0,
32 | "MIN" : 0.0
33 | }
34 | ],
35 | "CREDIT" : "https://getmosh.io/"
36 | }
37 | */
38 |
39 | precision mediump float;
40 |
41 | varying vec2 vUv;
42 |
43 | float rand(vec2 co){
44 | return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
45 | }
46 |
47 | void main() {
48 | vec2 p = gl_FragCoord.xy / RENDERSIZE.xy;
49 | float yInt = floor(p.y * slices) / slices;
50 | float rnd = rand(vec2(yInt, yInt));
51 | p.x += sin((TIME * timeMultiplier) * rnd / 5.0) * offset - offset / 2.0;
52 | p.x = fract(p.x);
53 | gl_FragColor = texture2D(inputImage, p);
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Smudged Lens.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Soft Blur.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Solid Color.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Color",
4 | "Utility"
5 | ],
6 | "CREDIT": "by Carter Rosenberg",
7 | "DESCRIPTION": "demonstrates the use of color-type image inputs",
8 | "INPUTS": [
9 | {
10 | "DEFAULT": [
11 | 1,
12 | 0,
13 | 0,
14 | 1
15 | ],
16 | "NAME": "Color",
17 | "TYPE": "color"
18 | }
19 | ],
20 | "ISFVSN": "2"
21 | }
22 | */
23 |
24 | void main()
25 | {
26 | gl_FragColor = Color;
27 | }
28 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Sorting Smear.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 | #else
7 | out vec2 left_coord;
8 | out vec2 right_coord;
9 | out vec2 above_coord;
10 | out vec2 below_coord;
11 | #endif
12 |
13 |
14 | void main()
15 | {
16 | isf_vertShaderInit();
17 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
18 | vec2 d = 1.0/RENDERSIZE;
19 |
20 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
21 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
22 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
23 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
24 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Unsharp Mask.vs:
--------------------------------------------------------------------------------
1 | #if __VERSION__ <= 120
2 | varying vec2 left_coord;
3 | varying vec2 right_coord;
4 | varying vec2 above_coord;
5 | varying vec2 below_coord;
6 |
7 | varying vec2 lefta_coord;
8 | varying vec2 righta_coord;
9 | varying vec2 leftb_coord;
10 | varying vec2 rightb_coord;
11 | #else
12 | out vec2 left_coord;
13 | out vec2 right_coord;
14 | out vec2 above_coord;
15 | out vec2 below_coord;
16 |
17 | out vec2 lefta_coord;
18 | out vec2 righta_coord;
19 | out vec2 leftb_coord;
20 | out vec2 rightb_coord;
21 | #endif
22 |
23 |
24 | void main()
25 | {
26 | isf_vertShaderInit();
27 | vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
28 | vec2 d = 1.0/RENDERSIZE;
29 |
30 | left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
31 | right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
32 | above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
33 | below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
34 |
35 | lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
36 | righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
37 | leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
38 | rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
39 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/VVMotionBlur 3.0.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "DESCRIPTION": "this is basically identical to the demonstration of a persistent buffer",
3 | "CREDIT": "by zoidberg",
4 | "ISFVSN": "2",
5 | "CATEGORIES": [
6 | "Blur"
7 | ],
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "NAME": "blurAmount",
15 | "TYPE": "float",
16 | "DEFAULT": 0.0
17 | }
18 | ],
19 | "PASSES": [
20 | {
21 | "TARGET":"bufferVariableNameA",
22 | "PERSISTENT": true,
23 | "FLOAT": true
24 | },
25 | {
26 |
27 | }
28 | ]
29 |
30 | }*/
31 |
32 | void main()
33 | {
34 | vec4 freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
35 | vec4 stalePixel = IMG_PIXEL(bufferVariableNameA,gl_FragCoord.xy);
36 | gl_FragColor = mix(freshPixel,stalePixel,blurAmount);
37 | }
38 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Vertex Manipulator.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Geometry Adjustment"
4 | ],
5 | "CREDIT": "VIDVOX",
6 | "DESCRIPTION": "Moves the vertex points to the specified locations without correction",
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "DEFAULT": [
14 | 0,
15 | 1
16 | ],
17 | "LABEL": "Top Left",
18 | "NAME": "topleft",
19 | "TYPE": "point2D"
20 | },
21 | {
22 | "DEFAULT": [
23 | 0,
24 | 0
25 | ],
26 | "LABEL": "Bottom Left",
27 | "NAME": "bottomleft",
28 | "TYPE": "point2D"
29 | },
30 | {
31 | "DEFAULT": [
32 | 1,
33 | 1
34 | ],
35 | "LABEL": "Top Right",
36 | "NAME": "topright",
37 | "TYPE": "point2D"
38 | },
39 | {
40 | "DEFAULT": [
41 | 1,
42 | 0
43 | ],
44 | "LABEL": "Bottom Right",
45 | "NAME": "bottomright",
46 | "TYPE": "point2D"
47 | }
48 | ],
49 | "ISFVSN": "2"
50 | }
51 | */
52 |
53 |
54 | void main()
55 | {
56 | vec4 test = IMG_THIS_PIXEL(inputImage);
57 | gl_FragColor = test;
58 | }
59 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Vertex Manipulator.vs:
--------------------------------------------------------------------------------
1 |
2 |
3 | void main()
4 | {
5 | isf_vertShaderInit();
6 |
7 | vec4 position = gl_Position;
8 | vec4 coord;
9 | if ((position.x<0.0)&&(position.y<0.0)) {
10 | coord.xy = bottomleft / RENDERSIZE;
11 | coord.x = coord.x * 2.0;
12 | coord.y = coord.y * 2.0;
13 | }
14 | else if ((position.x>0.0)&&(position.y<0.0)) {
15 | coord.xy = bottomright / RENDERSIZE;
16 | coord.x = (1.0-coord.x) * -2.0;
17 | coord.y = coord.y * 2.0;
18 | }
19 | else if (position.x<0.0) {
20 | coord.xy = topleft / RENDERSIZE;
21 | coord.x = coord.x * 2.0;
22 | coord.y = (1.0-coord.y) * -2.0;
23 | }
24 | else {
25 | coord.xy = topright / RENDERSIZE;
26 | coord.x = (1.0-coord.x) * -2.0;
27 | coord.y = (1.0-coord.y) * -2.0;
28 | }
29 | gl_Position.xy = position.xy + coord.xy;
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Vertical Tearing.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "Glitch"
5 | ],
6 | "DESCRIPTION" : "This introduces a vertical tearing effect similar to when GL VBL sync is off.",
7 | "ISFVSN" : "2",
8 | "INPUTS" : [
9 | {
10 | "NAME" : "inputImage",
11 | "TYPE" : "image"
12 | },
13 | {
14 | "NAME" : "tearPosition",
15 | "TYPE" : "float",
16 | "MAX" : 1,
17 | "DEFAULT" : 0.5,
18 | "MIN" : 0
19 | }
20 | ],
21 | "PASSES" : [
22 | {
23 | "TARGET" : "oldImage"
24 | },
25 | {
26 | "TARGET" : "newImage",
27 | "PERSISTENT" : true
28 | },
29 | {
30 |
31 | }
32 | ],
33 | "CREDIT" : "by VIDVOX"
34 | }
35 | */
36 |
37 | void main()
38 | {
39 | // write the previous buffer into here
40 | if (PASSINDEX == 0) {
41 | gl_FragColor = IMG_NORM_PIXEL(newImage,isf_FragNormCoord.xy);
42 | }
43 | else if (PASSINDEX == 1) {
44 | gl_FragColor = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord.xy);
45 | }
46 | else if (PASSINDEX == 2) {
47 | vec4 freshPixel = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord.xy);
48 | vec4 stalePixel = IMG_NORM_PIXEL(oldImage,isf_FragNormCoord.xy);
49 | gl_FragColor = (isf_FragNormCoord.y > tearPosition) ? freshPixel : stalePixel;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Vignette.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "DESCRIPTION" : "A simple Vignette",
4 | "ISFVSN" : "2",
5 | "INPUTS" : [
6 | {
7 | "NAME" : "inputImage",
8 | "TYPE" : "image"
9 | },
10 | {
11 | "NAME" : "intensity",
12 | "TYPE" : "float",
13 | "MAX" : 100,
14 | "DEFAULT" : 15,
15 | "MIN" : 1,
16 | "LABEL" : "Intensity"
17 | },
18 | {
19 | "NAME" : "extension",
20 | "TYPE" : "float",
21 | "MAX" : 2.5,
22 | "DEFAULT" : 0.25,
23 | "MIN" : 0.05,
24 | "LABEL" : "Extension"
25 | }
26 | ],
27 | "CREDIT" : "2xAA"
28 | }
29 | */
30 |
31 | void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
32 | vec2 uv = fragCoord.xy / RENDERSIZE.xy;
33 | uv *= 1.0 - uv.yx; //vec2(1.0)- uv.yx; -> 1.-u.yx; Thanks FabriceNeyret !
34 | float vig = uv.x * uv.y * intensity; // multiply with sth for intensity
35 | vig = pow(vig, extension); // change pow for modifying the extend of the vignette
36 | fragColor = vec4(IMG_NORM_PIXEL(inputImage, isf_FragNormCoord).rgb * (clamp(vig, 0., 1.)), 1.0);
37 | }
38 |
39 | void main(void) {
40 | mainImage(gl_FragColor, gl_FragCoord.xy);
41 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/White Point Adjust.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by zoidberg",
3 | "ISFVSN": "2",
4 | "DESCRIPTION": "Modifies the white point by multiplying the src pixel by the color value",
5 | "CATEGORIES": [
6 | "Color Adjustment"
7 | ],
8 | "INPUTS": [
9 | {
10 | "NAME": "inputImage",
11 | "TYPE": "image"
12 | },
13 | {
14 | "NAME": "newWhite",
15 | "TYPE": "color",
16 | "DEFAULT": [
17 | 1.0,
18 | 1.0,
19 | 1.0,
20 | 1.0
21 | ]
22 | }
23 | ]
24 | }*/
25 |
26 |
27 |
28 | void main() {
29 | vec4 tmpColorA = IMG_THIS_PIXEL(inputImage);
30 | gl_FragColor = tmpColorA * newWhite;
31 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Window Blinds.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "Dissolve"
5 | ],
6 | "INPUTS" : [
7 | {
8 | "TYPE" : "image",
9 | "NAME" : "startImage"
10 | },
11 | {
12 | "NAME" : "endImage",
13 | "TYPE" : "image"
14 | },
15 | {
16 | "NAME" : "progress",
17 | "MIN" : 0,
18 | "TYPE" : "float",
19 | "MAX" : 1,
20 | "DEFAULT" : 0
21 | }
22 | ],
23 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/windowblinds.glsl",
24 | "DESCRIPTION": "",
25 | "ISFVSN" : "2"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: Fabien Benetou
41 | // License: MIT
42 |
43 | vec4 transition (vec2 uv) {
44 | float t = progress;
45 |
46 | if (mod(floor(uv.y*100.*progress),2.)==0.)
47 | t*=2.-.5;
48 |
49 | return mix(
50 | getFromColor(uv),
51 | getToColor(uv),
52 | mix(t, progress, smoothstep(0.8, 1.0, progress))
53 | );
54 | }
55 |
56 |
57 |
58 | void main() {
59 | gl_FragColor = transition(isf_FragNormCoord.xy);
60 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Wipe Down.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "ISFVSN" : "2",
4 | "INPUTS" : [
5 | {
6 | "TYPE" : "image",
7 | "NAME" : "startImage"
8 | },
9 | {
10 | "TYPE" : "image",
11 | "NAME" : "endImage"
12 | },
13 | {
14 | "TYPE" : "float",
15 | "NAME" : "progress",
16 | "MIN" : 0,
17 | "MAX" : 1,
18 | "DEFAULT" : 0
19 | }
20 | ],
21 | "CATEGORIES" : [
22 | "Wipe"
23 | ],
24 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeDown.glsl",
25 | "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: Jake Nelson
41 | // License: MIT
42 |
43 | vec4 transition(vec2 uv) {
44 | vec2 p=uv.xy/vec2(1.0).xy;
45 | vec4 a=getFromColor(p);
46 | vec4 b=getToColor(p);
47 | return mix(a, b, step(1.0-p.y,progress));
48 | }
49 |
50 |
51 |
52 | void main() {
53 | gl_FragColor = transition(isf_FragNormCoord.xy);
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Wipe Left.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "INPUTS" : [
4 | {
5 | "TYPE" : "image",
6 | "NAME" : "startImage"
7 | },
8 | {
9 | "TYPE" : "image",
10 | "NAME" : "endImage"
11 | },
12 | {
13 | "TYPE" : "float",
14 | "MAX" : 1,
15 | "NAME" : "progress",
16 | "MIN" : 0,
17 | "DEFAULT" : 0
18 | }
19 | ],
20 | "CATEGORIES" : [
21 | "Wipe"
22 | ],
23 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeLeft.glsl",
24 | "DESCRIPTION": "",
25 | "ISFVSN" : "2"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: Jake Nelson
41 | // License: MIT
42 |
43 | vec4 transition(vec2 uv) {
44 | vec2 p=uv.xy/vec2(1.0).xy;
45 | vec4 a=getFromColor(p);
46 | vec4 b=getToColor(p);
47 | return mix(a, b, step(1.0-p.x,progress));
48 | }
49 |
50 |
51 |
52 | void main() {
53 | gl_FragColor = transition(isf_FragNormCoord.xy);
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Wipe Right.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "INPUTS" : [
4 | {
5 | "TYPE" : "image",
6 | "NAME" : "startImage"
7 | },
8 | {
9 | "TYPE" : "image",
10 | "NAME" : "endImage"
11 | },
12 | {
13 | "TYPE" : "float",
14 | "MAX" : 1,
15 | "NAME" : "progress",
16 | "MIN" : 0,
17 | "DEFAULT" : 0
18 | }
19 | ],
20 | "CATEGORIES" : [
21 | "Wipe"
22 | ],
23 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeRight.glsl",
24 | "DESCRIPTION": "",
25 | "ISFVSN" : "2"
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: Jake Nelson
41 | // License: MIT
42 |
43 | vec4 transition(vec2 uv) {
44 | vec2 p=uv.xy/vec2(1.0).xy;
45 | vec4 a=getFromColor(p);
46 | vec4 b=getToColor(p);
47 | return mix(a, b, step(0.0+p.x,progress));
48 | }
49 |
50 |
51 |
52 | void main() {
53 | gl_FragColor = transition(isf_FragNormCoord.xy);
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Wipe Up.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "Wipe"
5 | ],
6 | "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeUp.glsl",
7 | "DESCRIPTION": "",
8 | "ISFVSN" : "2",
9 | "INPUTS" : [
10 | {
11 | "TYPE" : "image",
12 | "NAME" : "startImage"
13 | },
14 | {
15 | "NAME" : "endImage",
16 | "TYPE" : "image"
17 | },
18 | {
19 | "MIN" : 0,
20 | "TYPE" : "float",
21 | "NAME" : "progress",
22 | "MAX" : 1,
23 | "DEFAULT" : 0
24 | }
25 | ]
26 | }
27 | */
28 |
29 |
30 |
31 | vec4 getFromColor(vec2 inUV) {
32 | return IMG_NORM_PIXEL(startImage, inUV);
33 | }
34 | vec4 getToColor(vec2 inUV) {
35 | return IMG_NORM_PIXEL(endImage, inUV);
36 | }
37 |
38 |
39 |
40 | // Author: Jake Nelson
41 | // License: MIT
42 |
43 | vec4 transition(vec2 uv) {
44 | vec2 p=uv.xy/vec2(1.0).xy;
45 | vec4 a=getFromColor(p);
46 | vec4 b=getToColor(p);
47 | return mix(a, b, step(0.0+p.y,progress));
48 | }
49 |
50 |
51 |
52 | void main() {
53 | gl_FragColor = transition(isf_FragNormCoord.xy);
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/Zoom.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Geometry Adjustment"
4 | ],
5 | "CREDIT": "by VIDVOX",
6 | "INPUTS": [
7 | {
8 | "NAME": "inputImage",
9 | "TYPE": "image"
10 | },
11 | {
12 | "DEFAULT": 1,
13 | "MAX": 10,
14 | "MIN": 0.01,
15 | "NAME": "level",
16 | "TYPE": "float"
17 | },
18 | {
19 | "DEFAULT": [
20 | 0,
21 | 0
22 | ],
23 | "MAX": [
24 | 1,
25 | 1
26 | ],
27 | "MIN": [
28 | 0,
29 | 0
30 | ],
31 | "NAME": "center",
32 | "TYPE": "point2D"
33 | }
34 | ],
35 | "ISFVSN": "2"
36 | }
37 | */
38 |
39 | void main() {
40 | vec2 loc;
41 | vec2 modifiedCenter;
42 |
43 | loc = isf_FragNormCoord;
44 | modifiedCenter = center;
45 | loc.x = (loc.x - modifiedCenter.x)*(1.0/level) + modifiedCenter.x;
46 | loc.y = (loc.y - modifiedCenter.y)*(1.0/level) + modifiedCenter.y;
47 | if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0)) {
48 | gl_FragColor = vec4(0.0);
49 | }
50 | else {
51 | gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/block-color.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "color"
5 | ],
6 | "DESCRIPTION" : "Solid color block",
7 | "ISFVSN" : "2",
8 | "INPUTS" : [
9 | {
10 | "NAME" : "r",
11 | "TYPE" : "float",
12 | "MAX" : 1,
13 | "DEFAULT" : 0,
14 | "MIN" : 0,
15 | "LABEL" : "Red"
16 | },
17 | {
18 | "NAME" : "g",
19 | "TYPE" : "float",
20 | "MAX" : 1,
21 | "DEFAULT" : 0,
22 | "LABEL" : "Green",
23 | "MIN" : 0
24 | },
25 | {
26 | "NAME" : "b",
27 | "TYPE" : "float",
28 | "MAX" : 1,
29 | "DEFAULT" : 0,
30 | "LABEL" : "Blue",
31 | "MIN" : 0
32 | },
33 | {
34 | "NAME" : "a",
35 | "TYPE" : "float",
36 | "MAX" : 1,
37 | "DEFAULT" : 0,
38 | "LABEL" : "Alpha",
39 | "MIN" : 0
40 | }
41 | ],
42 | "VSN" : "1.0",
43 | "CREDIT" : "2xAA"
44 | }
45 | */
46 |
47 | void main() {
48 | gl_FragColor = vec4(r, g, b, a);
49 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/feedback.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "DESCRIPTION": "RGB GLitchMod",
3 | "CREDIT": "by dantheman",
4 | "CATEGORIES": [
5 | "Distortion Effect"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME": "offset",
14 | "TYPE": "float",
15 | "MIN":0.0,
16 | "MAX":0.5,
17 | "DEFAULT": 0.25
18 | },
19 | {
20 | "NAME": "offset_right",
21 | "TYPE": "float",
22 | "MIN":0.0,
23 | "MAX":0.1,
24 | "DEFAULT": 0
25 | },
26 | {
27 | "NAME": "mix_var",
28 | "TYPE":"float",
29 | "MIN":0.0,
30 | "MAX":1.0,
31 | "DEFAULT": 1.0
32 | }
33 | ],
34 | "PERSISTENT_BUFFERS": [
35 | "one"
36 | ],
37 | "PASSES": [
38 | {
39 | "TARGET":"one",
40 | "WIDTH": "$WIDTH",
41 | "HEIGHT": "$HEIGHT",
42 | "DESCRIPTION": "buffer"
43 | }
44 | ]
45 |
46 | }*/
47 |
48 |
49 | void main() {
50 |
51 | vec2 pos = isf_FragNormCoord;
52 | vec4 old = IMG_NORM_PIXEL(one, pos);
53 | vec4 new = IMG_NORM_PIXEL(inputImage, pos);
54 |
55 | gl_FragColor = (new + old * mix_var * 10.0) / (1.0 + mix_var * 10.0);
56 | }
57 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/film-grain.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "XXX"
5 | ],
6 | "DESCRIPTION" : "",
7 | "INPUTS" : [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | },
12 | {
13 | "NAME" : "strength",
14 | "TYPE" : "float",
15 | "DEFAULT" : 16.0,
16 | "MIN": 0.0,
17 | "MAX": 50.0,
18 | "LABEL" : "Strength"
19 | },
20 | {
21 | "NAME": "secondaryOperation",
22 | "TYPE": "long",
23 | "VALUES": [
24 | 0,
25 | 1
26 | ],
27 | "LABELS": [
28 | "One",
29 | "Two"
30 | ],
31 | "DEFAULT": 0
32 | }
33 | ],
34 | "CREDIT" : ""
35 | }
36 | */
37 |
38 | void main() {
39 | vec2 uv = gl_FragCoord.xy;
40 | vec4 color = IMG_THIS_PIXEL(inputImage);
41 |
42 | float x = (uv.x + 4.0) * (uv.y + 4.0) * TIME;
43 | vec4 grain = vec4(mod((mod(x, 13.0) + 1.0) * (mod(x, 123.0) + 1.0), 0.01)-0.005) * strength;
44 |
45 | // if(abs(uv.x - 0.5) < 0.002)
46 | // color = vec4(0.0);
47 |
48 | if(secondaryOperation == 0) {
49 | grain = 1.0 - grain;
50 | gl_FragColor = color * grain;
51 | } else {
52 | gl_FragColor = color + grain;
53 | }
54 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/plasma.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "XXX"
5 | ],
6 | "DESCRIPTION" : "",
7 | "INPUTS" : [
8 | {
9 | "NAME" : "timeScale",
10 | "TYPE" : "float",
11 | "DEFAULT" : 0.18,
12 | "MIN": 0.001,
13 | "MAX": 2.0,
14 | "LABEL" : "Time Scale"
15 | },
16 | {
17 | "NAME": "uScale",
18 | "TYPE": "point2D",
19 | "LABEL" : "Scale",
20 | "DEFAULT": [
21 | 10.5,
22 | 10.5
23 | ],
24 | "MAX": 50.0,
25 | "MIN": 0.001
26 | }
27 | ],
28 | "CREDIT" : ""
29 | }
30 | */
31 |
32 | const float PI = 3.1415926535897932384626433832795;
33 |
34 | void main() {
35 | float time = TIME / timeScale;
36 | vec2 scale = vec2(RENDERSIZE.x / uScale.x, RENDERSIZE.y / uScale.y);
37 | float v = 0.0;
38 | vec2 c = isf_FragNormCoord * scale - scale/2.0;
39 | v += sin((c.x+time));
40 | v += sin((c.y+time)/2.0);
41 | v += sin((c.x+c.y+time)/2.0);
42 | c += scale/2.0 * vec2(sin(time/3.0), cos(time/2.0));
43 | v += sin(sqrt(c.x*c.x+c.y*c.y+1.0)+time);
44 | v = v/2.0;
45 | vec3 col = vec3(1, sin(PI*v), cos(PI*v));
46 | gl_FragColor = vec4(col*.5 + .5, 1);
47 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/rgbglitchmod.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "DESCRIPTION": "RGB GLitchMod",
3 | "CREDIT": "by dantheman",
4 | "CATEGORIES": [
5 | "Distortion Effect"
6 | ],
7 | "INPUTS": [
8 | {
9 | "NAME": "inputImage",
10 | "TYPE": "image"
11 | }
12 | ],
13 | "PERSISTENT_BUFFERS": [
14 | "one"
15 | ],
16 | "PASSES": [
17 | {
18 | "TARGET":"one",
19 | "WIDTH": "$WIDTH",
20 | "HEIGHT": "$HEIGHT",
21 | "DESCRIPTION": "buffer"
22 | }
23 | ]
24 |
25 | }*/
26 |
27 |
28 |
29 | void main()
30 | {
31 | vec2 uv = isf_FragNormCoord.xy;
32 | vec2 texCoord = uv;
33 | // if this is the first pass, i'm going to read the position from the "lastPosition" image, and write a new position based on this and the hold variables
34 |
35 | vec4 srcPixel = IMG_NORM_PIXEL(inputImage,texCoord);
36 | vec4 newPixel = IMG_NORM_PIXEL(one, texCoord);
37 | srcPixel = mod((srcPixel+newPixel), vec4(1.0));
38 | srcPixel *= 0.50;
39 |
40 | // i'm only using the X, which is the last render time we reset
41 | gl_FragColor = vec4(srcPixel.rgb, 1.0);
42 | }
43 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/scale.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "transform"
5 | ],
6 | "DESCRIPTION" : "Scale",
7 | "ISFVSN" : "2",
8 | "INPUTS" : [
9 | {
10 | "NAME" : "inputImage",
11 | "TYPE" : "image"
12 | },
13 | {
14 | "NAME" : "scale",
15 | "TYPE" : "float",
16 | "MAX" : 2.0,
17 | "DEFAULT" : 0.0,
18 | "MIN" : -2.0
19 | }
20 | ],
21 | "CREDIT" : "2xAA"
22 | }
23 | */
24 |
25 | void main() {
26 | vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy;
27 |
28 | uv -= 0.5;
29 |
30 | uv.x = uv.x / (1.0 + scale);
31 | uv.y = uv.y / (1.0 + scale);
32 |
33 | uv += 0.5;
34 |
35 | gl_FragColor = IMG_NORM_PIXEL(inputImage, uv);
36 | }
37 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/st_lsfGDH.fs:
--------------------------------------------------------------------------------
1 | /*
2 | {
3 | "CATEGORIES" : [
4 | "zoomer"
5 | ],
6 | "DESCRIPTION" : "simple rotozoomer",
7 | "INPUTS" : [
8 | {
9 | "NAME" : "inputImage",
10 | "TYPE" : "image"
11 | }
12 | ],
13 | "ISFVSN" : "2",
14 | "CREDIT" : "triggerHLM "
15 | }
16 | */
17 |
18 | float pi = 3.14159265;
19 |
20 | vec4 mainImage( vec2 fragCoord ) {
21 | float time= TIME * 0.2;
22 |
23 | vec2 position = vec2(640.0/2.0+640.0/2.0*sin(time*2.0), 360.0/2.0+360.0/2.0*cos(time*3.0));
24 | vec2 position2 = vec2(640.0/2.0+640.0/2.0*sin((time+2000.0)*2.0), 360.0/2.0+360.0/2.0*cos((time+2000.0)*3.0));
25 |
26 |
27 | vec2 offset = vec2(640.0/2.0, 360.0/2.0) ;
28 | vec2 offset2 = vec2(6.0*sin(time*1.1), 3.0*cos(time*1.1));
29 |
30 | vec2 oldPos = (fragCoord.xy);
31 |
32 | float angle = time*2.0;
33 |
34 | vec2 newPos = vec2(oldPos.x *cos(angle) - oldPos.y *sin(angle),
35 | oldPos.y *cos(angle) + oldPos.x *sin(angle));
36 |
37 |
38 | newPos = (newPos)*(0.0044+0.004*sin(time*3.0))-offset2;
39 | vec2 temp = newPos;
40 | newPos.x = temp.x + 0.4*sin(temp.y*2.0+time*8.0);
41 | newPos.y = (-temp.y + 0.4*sin(temp.x*2.0+time*8.0));
42 | vec4 final = IMG_NORM_PIXEL(inputImage, newPos);
43 | return final;
44 | }
45 |
46 | void main(void) {
47 | gl_FragColor = mainImage(gl_FragCoord.xy);
48 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/tapestryfract.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CREDIT": "by echophons",
3 | "DESCRIPTION": "",
4 | "CATEGORIES": [ "generator"
5 | ],
6 | "INPUTS": [
7 | {
8 | "NAME": "h",
9 | "TYPE": "float",
10 | "DEFAULT": 0.5,
11 | "MIN": 0.0,
12 | "MAX": 1.0
13 | },
14 | {
15 | "NAME": "j",
16 | "TYPE": "float",
17 | "DEFAULT": 0.5,
18 | "MIN": 0.0,
19 | "MAX": 1.0
20 | }
21 | ]
22 | }*/
23 |
24 | // edit of http://glslsandbox.com/e#18752.0
25 | uniform vec2 mouse;
26 |
27 | vec3 iResolution = vec3(RENDERSIZE, 1.0);
28 | float iGlobalTime = TIME;
29 |
30 | float gTime = iGlobalTime*0.5;
31 |
32 | void main( void )
33 | {
34 | float f = 3.0;
35 | float g = 3.0;
36 | vec2 res = iResolution.xy;
37 | vec2 mou = mouse.xy;
38 |
39 | //if (mouse.x < 0.5)
40 | //{
41 | mou.x = sin(gTime * .3)*sin(gTime * .17) * 1. + sin(gTime * .3);
42 | mou.y = (1.0-cos(gTime * .632))*sin(gTime * .131)*1.0+cos(gTime * .3);
43 | mou = (mou+1.0) * res;
44 | //}
45 | vec2 z = ((-res+2.0 * gl_FragCoord.xy) / res.y);
46 | vec2 p = ((-res+2.0+mou) / res.y) * j;
47 | for( int i = 0; i < 25; i++)
48 | {
49 | float d = dot(z,z);
50 | z = (vec2( z.x, -z.y ) / d) + p * h;
51 | z.x = 1.0-abs(z.x);
52 | f = max( f-d, (dot(z-p,z-p) ));
53 | g = min( g*d, sin(dot(z+p,z+p))+1.0);
54 | }
55 | f = abs(-log(f) / 3.5);
56 | g = abs(-log(g) / 8.0);
57 | gl_FragColor = vec4(min(vec3(g, g*f, f), 1.0),1.0);
58 | }
59 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002 Dilate.vs:
--------------------------------------------------------------------------------
1 |
2 | #if __VERSION__ <= 120
3 | varying vec2 texcoord0;
4 | varying vec2 texcoord1;
5 | varying vec2 texcoord2;
6 | varying vec2 texcoord3;
7 | varying vec2 texcoord4;
8 | varying vec2 texcoord5;
9 | varying vec2 texcoord6;
10 | varying vec2 texcoord7;
11 | #else
12 | out vec2 texcoord0;
13 | out vec2 texcoord1;
14 | out vec2 texcoord2;
15 | out vec2 texcoord3;
16 | out vec2 texcoord4;
17 | out vec2 texcoord5;
18 | out vec2 texcoord6;
19 | out vec2 texcoord7;
20 | #endif
21 |
22 | void main()
23 | {
24 | isf_vertShaderInit();
25 | // perform standard transform on vertex
26 | //gl_Position = ftransform();
27 |
28 | // transform texcoord
29 | vec2 texcoord = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
30 |
31 | // get sample positions
32 | texcoord0 = texcoord + vec2(-amount, -amount);
33 | texcoord1 = texcoord + vec2( 0, -amount);
34 | texcoord2 = texcoord + vec2( amount, -amount);
35 | texcoord3 = texcoord + vec2(-amount, 0);
36 | texcoord4 = texcoord + vec2( amount, 0);
37 | texcoord5 = texcoord + vec2(-amount, amount);
38 | texcoord6 = texcoord + vec2( 0, amount);
39 | texcoord7 = texcoord + vec2( amount, amount);
40 | }
41 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002 Erode.vs:
--------------------------------------------------------------------------------
1 |
2 | #if __VERSION__ <= 120
3 | varying vec2 texcoord0;
4 | varying vec2 texcoord1;
5 | varying vec2 texcoord2;
6 | varying vec2 texcoord3;
7 | varying vec2 texcoord4;
8 | varying vec2 texcoord5;
9 | varying vec2 texcoord6;
10 | varying vec2 texcoord7;
11 | #else
12 | out vec2 texcoord0;
13 | out vec2 texcoord1;
14 | out vec2 texcoord2;
15 | out vec2 texcoord3;
16 | out vec2 texcoord4;
17 | out vec2 texcoord5;
18 | out vec2 texcoord6;
19 | out vec2 texcoord7;
20 | #endif
21 |
22 | void main()
23 | {
24 | isf_vertShaderInit();
25 | // perform standard transform on vertex
26 | //gl_Position = ftransform();
27 |
28 | // transform texcoord
29 | vec2 texcoord = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
30 |
31 | // get sample positions
32 | texcoord0 = texcoord + vec2(-amount, -amount);
33 | texcoord1 = texcoord + vec2( 0, -amount);
34 | texcoord2 = texcoord + vec2( amount, -amount);
35 | texcoord3 = texcoord + vec2(-amount, 0);
36 | texcoord4 = texcoord + vec2( amount, 0);
37 | texcoord5 = texcoord + vec2(-amount, amount);
38 | texcoord6 = texcoord + vec2( 0, amount);
39 | texcoord7 = texcoord + vec2( amount, amount);
40 | }
41 |
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002 Light Leak.vs:
--------------------------------------------------------------------------------
1 |
2 | #if __VERSION__ <= 120
3 | varying mat2 rotmat;
4 | #else
5 | out mat2 rotmat;
6 | #endif
7 |
8 | void main()
9 | {
10 | isf_vertShaderInit();
11 |
12 | // setup basic rotation matrix here
13 | float theta = radians(angle);
14 |
15 | // dont need to compute this more than once..
16 | float c = cos(theta);
17 | float s = sin(theta);
18 |
19 | // rotation matrix
20 | rotmat = mat2(c,s,-s,c);
21 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002-CRT-Displacement.fs:
--------------------------------------------------------------------------------
1 | /*{
2 | "CATEGORIES": [
3 | "Distortion Effect",
4 | "Retro",
5 | "v002"
6 | ],
7 | "CREDIT": "by vade",
8 | "DESCRIPTION": "CRT Displacement, emulating the look of curved CRT Displays",
9 | "INPUTS": [
10 | {
11 | "NAME": "inputImage",
12 | "TYPE": "image"
13 | },
14 | {
15 | "DEFAULT": 0.5,
16 | "MAX": 1,
17 | "MIN": 0,
18 | "NAME": "Amount",
19 | "TYPE": "float"
20 | }
21 | ],
22 | "ISFVSN": "2"
23 | }
24 | */
25 |
26 | void main (void)
27 | {
28 | vec2 t1, t2;
29 | vec2 ctr = RENDERSIZE / 2.0;
30 |
31 | t1 = gl_FragCoord.xy;
32 |
33 | float a = -0.0;
34 | float b = -.1 * Amount;
35 | float c = -.0;
36 | float d = 1.0 - 1.1 * ( a + b + c );
37 | float r1, r2;
38 | float unit = length(ctr) / 2.0;
39 |
40 | r1 = distance( t1, ctr )/unit;
41 | r2 = r1 *( r1*( r1 * (a*r1 + b) + c) + d );
42 | float sc = step( 0.0 , r1) * ( r1/(r2 + .000001)) + (1.0 - step( 0.0 , r1));
43 |
44 | t2 = ctr + ( t1 - ctr) * sc;
45 |
46 | gl_FragColor = IMG_PIXEL(inputImage, t2);
47 |
48 | if ((t2.x < 0.0)
49 | ||(t2.y < 0.0)
50 | ||(t2.x > RENDERSIZE.x)
51 | ||(t2.y > RENDERSIZE.y))
52 | {
53 | gl_FragColor = vec4(0.0);
54 | }
55 | }
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002-CRT-Mask-RGB-Shadow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/application/sample-modules/isf/v002-CRT-Mask-RGB-Shadow.png
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002-CRT-Mask-RGB-Staggered.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/application/sample-modules/isf/v002-CRT-Mask-RGB-Staggered.png
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002-CRT-Mask-RGB-Straight.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/application/sample-modules/isf/v002-CRT-Mask-RGB-Straight.png
--------------------------------------------------------------------------------
/src/application/sample-modules/isf/v002-CRT-Mask-Scanline-Staggered.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/application/sample-modules/isf/v002-CRT-Mask-Scanline-Staggered.png
--------------------------------------------------------------------------------
/src/application/setup-beat-detektor.js:
--------------------------------------------------------------------------------
1 | import BeatDetektor from "../../lib/BeatDetektor";
2 |
3 | export default function() {
4 | const beatDetektor = new BeatDetektor(85, 169);
5 | const beatDetektorKick = new BeatDetektor.modules.vis.BassKick();
6 |
7 | this.updateBeatDetektor = (delta, features) => {
8 | if (!features) {
9 | return;
10 | }
11 |
12 | beatDetektor.process(delta / 1000.0, features.complexSpectrum.real);
13 | beatDetektorKick.process(beatDetektor);
14 | const kick = beatDetektorKick.isKick();
15 | const bpm = beatDetektor.win_bpm_int_lo;
16 |
17 | this.store.commit("beats/SET_KICK", { kick });
18 | if (this.store.state.beats.bpm !== bpm) {
19 | this.store.dispatch("beats/setBpm", { bpm, source: "beatdetektor" });
20 | }
21 | };
22 | }
23 |
--------------------------------------------------------------------------------
/src/application/setup-grandiose.js:
--------------------------------------------------------------------------------
1 | /* globals __dirname */
2 |
3 | import store from "./worker/store/index";
4 |
5 | let grandiose = undefined;
6 |
7 | export default function setupGrandiose() {
8 | if (grandiose === undefined) {
9 | /* eslint-disable */
10 | __dirname = `${__dirname}/node_modules/grandiose`;
11 | __dirname = __dirname.replace("app.asar", "app.asar.unpacked");
12 | /* eslint-enable */
13 |
14 | try {
15 | grandiose = require("grandiose");
16 | } catch (error) {
17 | if (error.message.includes("libndi.so")) {
18 | store.dispatch("errors/createMessage", {
19 | message:
20 | "libndi is not installed, please see \"Ubuntu/Debian\" in the modV README."
21 | });
22 | } else {
23 | console.error(error);
24 | }
25 | }
26 |
27 | // eslint-disable-next-line
28 | __dirname = __dirname.replace("/node_modules/grandiose", "");
29 | }
30 |
31 | // Make sure to set grandiose to undefined as it will be an empty object otherwise
32 | if (!grandiose.isSupportedCPU) {
33 | grandiose = undefined;
34 | }
35 |
36 | return grandiose;
37 | }
38 |
--------------------------------------------------------------------------------
/src/application/setup-tweens.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/application/setup-tweens.js
--------------------------------------------------------------------------------
/src/application/use.js:
--------------------------------------------------------------------------------
1 | import installPlugin from "./install-plugin";
2 |
3 | export default function use(type, extension) {
4 | switch (type) {
5 | case "plugin": {
6 | installPlugin(extension);
7 | break;
8 | }
9 |
10 | case "control": {
11 | this.store.dispatch("controls/addControl", extension);
12 | break;
13 | }
14 |
15 | // case 'renderer': {
16 | // store.commit('renderers/addRenderer', extension)
17 | // break
18 | // }
19 |
20 | default: {
21 | installPlugin(type || extension);
22 | break;
23 | }
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/src/application/utils/apply-expression.js:
--------------------------------------------------------------------------------
1 | import get from "lodash.get";
2 | import store from "../worker/store";
3 |
4 | export function applyExpression({ value, inputId }) {
5 | const expressionAssignment = store.getters["expressions/getByInputId"](
6 | inputId
7 | );
8 |
9 | const input = store.state.inputs.inputs[inputId];
10 |
11 | let dataOut = value;
12 |
13 | if (expressionAssignment) {
14 | const scope = {
15 | value: dataOut,
16 | time: Date.now(),
17 | inputValue: get(store.state, input.getLocation)
18 | };
19 |
20 | dataOut = expressionAssignment.func.evaluate(scope);
21 | }
22 |
23 | return dataOut;
24 | }
25 |
--------------------------------------------------------------------------------
/src/application/utils/conform-file-path.js:
--------------------------------------------------------------------------------
1 | import path from "path";
2 |
3 | export const conformFilePath = (filePath = "") =>
4 | filePath
5 | .split(process.platform === "win32" ? path.posix.sep : path.win32.sep)
6 | .join(path.sep);
7 |
--------------------------------------------------------------------------------
/src/application/utils/get-next-name.js:
--------------------------------------------------------------------------------
1 | function nameTemplate(name, count) {
2 | if (count < 1) {
3 | return name;
4 | }
5 |
6 | return `${name} (${count})`;
7 | }
8 |
9 | export default function findBestName(nameIn, names) {
10 | return new Promise(resolve => {
11 | if (names.indexOf(nameIn) < 0) {
12 | resolve(nameIn);
13 | }
14 |
15 | const nameRe = new RegExp(`\\b^${nameIn}\\s\\((\\d+?)\\)$`, "g");
16 |
17 | let count = 1;
18 | let newName = nameTemplate(nameIn, count);
19 |
20 | const filteredNames = names.filter(arrName => arrName.match(nameRe));
21 |
22 | while (filteredNames.indexOf(newName) > -1) {
23 | count += 1;
24 | newName = nameTemplate(nameIn, count);
25 | }
26 |
27 | resolve(newName);
28 | });
29 | }
30 |
--------------------------------------------------------------------------------
/src/application/utils/lerp.js:
--------------------------------------------------------------------------------
1 | export default function lerp(start, end, amt) {
2 | return (1 - amt) * start + amt * end;
3 | }
4 |
--------------------------------------------------------------------------------
/src/application/utils/map.js:
--------------------------------------------------------------------------------
1 | export default function map(value, low1, high1, low2, high2) {
2 | // eslint-disable-next-line
3 | return low2 + (high2 - low2) * (value - low1) / (high1 - low1);
4 | }
5 |
--------------------------------------------------------------------------------
/src/application/worker/audio-features.js:
--------------------------------------------------------------------------------
1 | import lerp from "../utils/lerp";
2 |
3 | const MAX_SMOOTHING = 1;
4 | const SMOOTHING_STEP = 0.001;
5 |
6 | let features = {};
7 | const smoothedFeatures = {};
8 |
9 | function getFeatures() {
10 | return features;
11 | }
12 |
13 | function getFeature(key) {
14 | return features[key];
15 | }
16 |
17 | function setFeatures(newFeatures) {
18 | features = newFeatures;
19 | }
20 |
21 | function addSmoothingId(id) {
22 | smoothedFeatures[id] = 0;
23 | }
24 |
25 | function removeSmoothingId(id) {
26 | delete smoothedFeatures[id];
27 | }
28 |
29 | function getSmoothedFeature(feature, id, smoothingValue) {
30 | smoothedFeatures[id] = lerp(
31 | smoothedFeatures[id] || 0,
32 | features[feature],
33 | smoothingValue
34 | );
35 |
36 | return smoothedFeatures[id];
37 | }
38 |
39 | export {
40 | getFeature,
41 | getFeatures,
42 | setFeatures,
43 | addSmoothingId,
44 | removeSmoothingId,
45 | getSmoothedFeature,
46 | MAX_SMOOTHING,
47 | SMOOTHING_STEP
48 | };
49 |
--------------------------------------------------------------------------------
/src/application/worker/frame-counter.js:
--------------------------------------------------------------------------------
1 | /*
2 | * In relation to: https://github.com/vcync/modv-3/issues/129
3 | *
4 | * The frame-counter will not overflow in a normal session of modV.
5 | *
6 | * We can determine the maximum safe integer in JavaScript with `Number.MAX_SAFE_INTEGER`.
7 | * In V8 at the time of writing this is 9007199254740991.
8 | *
9 | * That's nine quadrillion, seven trillion, one hundred and ninety-nine billion,
10 | * two hundred and fifty-four million, seven hundred and forty thousand and nine hundred
11 | * and ninety-one.
12 | *
13 | * We use the following formula to calculate when, in days, this will reach the max safe int:
14 | * max_int / (frames_per_second * (seconds_in_a_minute * minutes_in_an_hour) / hours_in_a_day)
15 | *
16 | * At an average screen refresh of 60fps:
17 | * Number.MAX_SAFE_INTEGER / (60 * (60 * 60) / 24)
18 | * = 1000799917193.4435
19 | *
20 | * In years, this is:
21 | * 1000799917193.4435 / 365
22 | * = 2741917581.3519
23 | *
24 | * Of course this doesn't account for leap years, but we're pretty safe.
25 | * Unless you have a time-machine and somewhere safe to hide a computer running modV…
26 | */
27 |
28 | let _frames = 0;
29 |
30 | function tick() {
31 | return _frames++;
32 | }
33 |
34 | function frames() {
35 | return _frames;
36 | }
37 |
38 | export { tick, frames };
39 |
--------------------------------------------------------------------------------
/src/application/worker/store/index.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Vuex from "vuex";
3 | import createPersistedState from "vuex-persistedstate";
4 |
5 | const requireModule = require.context("./modules/", false, /\.js$/);
6 | const modules = {};
7 |
8 | const moduleKeys = requireModule.keys();
9 | for (let i = 0, len = moduleKeys.length; i < len; i++) {
10 | const moduleName = moduleKeys[i];
11 |
12 | modules[moduleName.replace(/(\.\/|\.js)/g, "")] = requireModule(
13 | moduleName
14 | ).default;
15 | }
16 |
17 | Vue.use(Vuex);
18 |
19 | const plugins = [];
20 |
21 | // createPersistedState doesn't work in the worker store, so don't run it there.
22 | // That's okay as the worker doesn't need to know about mediaStream.
23 | // If we want other persisted items that the worker needs to know about
24 | // we'll need to implement something more complex to commit via postMessage.
25 | if (self.document !== undefined) {
26 | const dataState = createPersistedState({
27 | paths: ["mediaStream"]
28 | });
29 |
30 | plugins.push(dataState);
31 | }
32 |
33 | export default new Vuex.Store({
34 | modules,
35 | plugins,
36 | strict: false
37 | });
38 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/beats.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 |
3 | const state = {
4 | bpm: 0,
5 | bpmSource: "beatdetektor",
6 | kick: false,
7 | bpmSources: ["beatdetektor", "midi", "tap"]
8 | };
9 |
10 | const actions = {
11 | setBpm({ commit, state }, { bpm, source }) {
12 | if (!source) {
13 | throw new Error("Setting the BPM requires a source to be given");
14 | }
15 |
16 | if (source === state.bpmSource) {
17 | commit("SET_BPM", { bpm });
18 | }
19 | }
20 | };
21 |
22 | const mutations = {
23 | SET_BPM(state, { bpm }) {
24 | state.bpm = bpm;
25 | },
26 |
27 | SET_KICK(state, { kick }) {
28 | state.kick = kick;
29 | },
30 |
31 | ADD_BPM_SOURCE(state, { source }) {
32 | state.bpmSources.push(source);
33 | },
34 |
35 | SET_BPM_SOURCE(state, { source }) {
36 | Vue.set(state, "bpmSource", source);
37 | }
38 | };
39 |
40 | export default {
41 | namespaced: true,
42 | state,
43 | mutations,
44 | actions
45 | };
46 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/errors.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import { v4 as uuidv4 } from "uuid";
3 |
4 | const state = {
5 | messages: {}
6 | };
7 |
8 | const actions = {
9 | createMessage({ commit }, { message }) {
10 | if (!message) {
11 | throw new Error("No message given");
12 | }
13 |
14 | commit("CREATE_MESSAGE", { message, id: uuidv4() });
15 | },
16 |
17 | deleteMessage({ commit }, { id }) {
18 | commit("REMOVE_MESSAGE", { id });
19 | }
20 | };
21 |
22 | const mutations = {
23 | CREATE_MESSAGE(state, { message, id }) {
24 | Vue.set(state.messages, id, message);
25 | },
26 |
27 | REMOVE_MESSAGE(state, { id }) {
28 | Vue.delete(state.messages, id);
29 | }
30 | };
31 |
32 | export default {
33 | namespaced: true,
34 | state,
35 | mutations,
36 | actions
37 | };
38 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/fonts.js:
--------------------------------------------------------------------------------
1 | const state = {
2 | defaultFonts: ["serif", "sans-serif", "cursive", "monospace"],
3 | localFonts: []
4 | };
5 |
6 | const getters = {
7 | fonts: state => [
8 | ...state.defaultFonts,
9 | ...state.localFonts
10 | .filter(
11 | (value, index, self) =>
12 | index === self.findIndex(t => t.family === value.family)
13 | )
14 | .map(font => font.family)
15 | .sort((a, b) => a.localeCompare(b))
16 | ]
17 | };
18 |
19 | const mutations = {
20 | SET_LOCAL_FONTS(state, fonts = []) {
21 | state.localFonts = fonts;
22 | }
23 | };
24 |
25 | export default {
26 | namespaced: true,
27 | state,
28 | getters,
29 | mutations
30 | };
31 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/fps.js:
--------------------------------------------------------------------------------
1 | const state = {
2 | fps: 60
3 | };
4 |
5 | const getters = {
6 | interval: state => 1000 / state.fps
7 | };
8 |
9 | const actions = {
10 | setFPS({ commit }, { fps }) {
11 | if (!fps) {
12 | throw new Error("No FPS given");
13 | }
14 |
15 | commit("SET_FPS", { fps });
16 | }
17 | };
18 |
19 | const mutations = {
20 | SET_FPS(state, { fps }) {
21 | state.fps = fps;
22 | }
23 | };
24 |
25 | export default {
26 | namespaced: true,
27 | state,
28 | getters,
29 | mutations,
30 | actions
31 | };
32 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/images.js:
--------------------------------------------------------------------------------
1 | import streamToBlob from "stream-to-blob";
2 | import fs from "fs";
3 | import path from "path";
4 |
5 | import Vue from "vue";
6 | import { v4 as uuidv4 } from "uuid";
7 |
8 | import store from "../";
9 | import { conformFilePath } from "../../../utils/conform-file-path";
10 |
11 | const state = {};
12 |
13 | const getters = {
14 | image: state => id => state[id]
15 | };
16 |
17 | const actions = {
18 | async createImageFromPath({ commit }, { path: filePath }) {
19 | let stream;
20 | let joinedFilePath;
21 |
22 | try {
23 | joinedFilePath = path.join(
24 | store.state.media.path,
25 | conformFilePath(filePath)
26 | );
27 | } catch (e) {
28 | console.log(e);
29 | }
30 |
31 | try {
32 | stream = fs.createReadStream(joinedFilePath);
33 | } catch (error) {
34 | throw error;
35 | }
36 |
37 | if (!stream) {
38 | return {};
39 | }
40 |
41 | const blob = await streamToBlob(stream);
42 | const imageBitmap = await createImageBitmap(blob);
43 |
44 | const id = uuidv4();
45 | commit("SAVE_IMAGE", { id, imageBitmap });
46 | return { id };
47 | }
48 | };
49 |
50 | const mutations = {
51 | SAVE_IMAGE(state, { id, imageBitmap }) {
52 | Vue.set(state, id, imageBitmap);
53 | }
54 | };
55 |
56 | export default {
57 | namespaced: true,
58 | state,
59 | getters,
60 | actions,
61 | mutations
62 | };
63 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/mediaStream.js:
--------------------------------------------------------------------------------
1 | const state = {
2 | audio: [],
3 | video: [],
4 |
5 | currentAudioSource: null,
6 | currentVideoSource: null
7 | };
8 |
9 | const mutations = {
10 | ADD_AUDIO_SOURCE(state, { source }) {
11 | state.audio.push(source);
12 | },
13 |
14 | ADD_VIDEO_SOURCE(state, { source }) {
15 | state.video.push(source);
16 | },
17 |
18 | CLEAR_AUDIO_SOURCES(state) {
19 | state.audio = [];
20 | },
21 |
22 | CLEAR_VIDEO_SOURCES(state) {
23 | state.video = [];
24 | },
25 |
26 | SET_CURRENT_AUDIO_SOURCE(state, { audioId }) {
27 | state.currentAudioSource = audioId;
28 | },
29 |
30 | SET_CURRENT_VIDEO_SOURCE(state, { videoId }) {
31 | state.currentVideoSource = videoId;
32 | }
33 | };
34 |
35 | export default {
36 | namespaced: true,
37 | state,
38 | mutations
39 | };
40 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/metrics.js:
--------------------------------------------------------------------------------
1 | const state = {
2 | fps: 0
3 | };
4 |
5 | const mutations = {
6 | SET_FPS_MEASURE(state, fps) {
7 | state.fps = fps;
8 | }
9 | };
10 |
11 | export default {
12 | namespaced: true,
13 | state,
14 | mutations
15 | };
16 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/projects.js:
--------------------------------------------------------------------------------
1 | const state = {
2 | currentProject: "default"
3 | };
4 |
5 | const actions = {
6 | setCurrentProject({ commit }, projectName) {
7 | commit("SET_CURRENT_PROJECT", projectName);
8 | }
9 | };
10 |
11 | const mutations = {
12 | SET_CURRENT_PROJECT(state, currentProject) {
13 | state.currentProject = currentProject;
14 | }
15 | };
16 |
17 | export default {
18 | namespaced: true,
19 | state,
20 | actions,
21 | mutations
22 | };
23 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/renderers.js:
--------------------------------------------------------------------------------
1 | const state = {};
2 |
3 | const getters = {
4 | renderersWithTick: state => {
5 | const keys = Object.keys(state);
6 | return keys
7 | .map(key => state[key].tick && state[key])
8 | .filter(renderer => renderer);
9 | }
10 | };
11 |
12 | const mutations = {
13 | ADD_RENDERER(state, renderer) {
14 | state[renderer.name] = renderer;
15 | },
16 | REMOVE_RENDERER(state, name) {
17 | delete state[name];
18 | }
19 | };
20 |
21 | export default {
22 | namespaced: true,
23 | getters,
24 | state,
25 | mutations
26 | };
27 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/size.js:
--------------------------------------------------------------------------------
1 | import store from "../index";
2 |
3 | const state = {
4 | width: 0,
5 | height: 0,
6 | dpr: 1
7 | };
8 |
9 | const getters = {
10 | area: state => state.width * state.height
11 | };
12 |
13 | const actions = {
14 | async setSize({ commit }, { width, height, dpr }) {
15 | await store.dispatch("outputs/resize", { width, height });
16 |
17 | const modulesValues = Object.values(store.state.modules.active);
18 | const modulesLength = modulesValues.length;
19 | for (let i = 0; i < modulesLength; ++i) {
20 | const module = modulesValues[i];
21 | store.dispatch("modules/resize", { moduleId: module.$id, width, height });
22 | }
23 |
24 | const renderersValues = Object.values(store.state.renderers);
25 | const renderersLength = renderersValues.length;
26 | for (let i = 0; i < renderersLength; ++i) {
27 | const renderer = renderersValues[i];
28 | if (renderer.resize) {
29 | renderer.resize({ width, height });
30 | }
31 | }
32 |
33 | commit("SET_SIZE", { width, height, dpr });
34 | }
35 | };
36 |
37 | const mutations = {
38 | SET_SIZE(state, { width, height, dpr = 1 }) {
39 | state.width = width;
40 | state.height = height;
41 | state.dpr = dpr;
42 | }
43 | };
44 |
45 | export default {
46 | namespaced: true,
47 | state,
48 | getters,
49 | actions,
50 | mutations
51 | };
52 |
--------------------------------------------------------------------------------
/src/application/worker/store/modules/windows.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 |
3 | import { v4 as uuidv4 } from "uuid";
4 |
5 | const state = {};
6 |
7 | const actions = {
8 | createWindow({ commit }) {
9 | const win = {
10 | width: 300,
11 | height: 300,
12 | title: "modV Output",
13 | pixelRatio: 1,
14 | x: 0,
15 | y: 0,
16 | fullscreen: false,
17 | backgroundColor: "#000",
18 | outputId: ""
19 | };
20 |
21 | win.id = uuidv4();
22 | commit("ADD_WINDOW", win);
23 |
24 | return win.id;
25 | }
26 | };
27 |
28 | const mutations = {
29 | ADD_WINDOW(state, window) {
30 | Vue.set(state, window.id, window);
31 | },
32 |
33 | UPDATE_WINDOW(state, { id, key, value }) {
34 | Vue.set(state[id], key, value);
35 | }
36 |
37 | // REMOVE_WINDOW(state, id) {}
38 | };
39 |
40 | export default {
41 | namespaced: true,
42 | state,
43 | // getters,
44 | actions,
45 | mutations
46 | };
47 |
--------------------------------------------------------------------------------
/src/assets/fonts/Inter-italic.var.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/Inter-italic.var.woff2
--------------------------------------------------------------------------------
/src/assets/fonts/Inter-roman.var.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/Inter-roman.var.woff2
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-Bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-Bold.woff
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-Bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-Bold.woff2
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-BoldItalic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-BoldItalic.woff
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-BoldItalic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-BoldItalic.woff2
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-Italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-Italic.woff
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-Italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-Italic.woff2
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-Regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-Regular.woff
--------------------------------------------------------------------------------
/src/assets/fonts/iaw-mono-Regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vcync/modV/c606793d54d00f5a56e1121f3593f9585b20623f/src/assets/fonts/iaw-mono-Regular.woff2
--------------------------------------------------------------------------------
/src/assets/graphics/Arrow-vertical.svg:
--------------------------------------------------------------------------------
1 |
4 |
--------------------------------------------------------------------------------
/src/assets/graphics/Arrow.svg:
--------------------------------------------------------------------------------
1 |
4 |
--------------------------------------------------------------------------------
/src/background/background-constants.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | APP_SCHEME: "app"
3 | };
4 |
--------------------------------------------------------------------------------
/src/background/media-manager.js:
--------------------------------------------------------------------------------
1 | import MediaManager from "../media-manager";
2 | import { updateMenu } from "./menu-bar";
3 | import { setProjectNames } from "./projects";
4 |
5 | let mediaManager;
6 |
7 | export function getMediaManager() {
8 | if (!mediaManager) {
9 | mediaManager = new MediaManager({
10 | update(message) {
11 | window.webContents.send("media-manager-update", message);
12 |
13 | setProjectNames(mediaManager.$store.getters["media/projects"]);
14 | updateMenu();
15 | },
16 |
17 | pathChanged(message) {
18 | window.webContents.send("media-manager-path-changed", message);
19 | }
20 | });
21 | }
22 |
23 | return mediaManager;
24 | }
25 |
--------------------------------------------------------------------------------
/src/background/open-file.js:
--------------------------------------------------------------------------------
1 | import { app } from "electron";
2 | import { windows } from "./windows";
3 |
4 | export function openFile(filePath) {
5 | app.addRecentDocument(filePath);
6 |
7 | windows["mainWindow"].webContents.send("open-preset", filePath);
8 | }
9 |
--------------------------------------------------------------------------------
/src/background/projects.js:
--------------------------------------------------------------------------------
1 | import { windows } from "./windows";
2 |
3 | let projectNames = ["default"];
4 | let currentProject = "default";
5 |
6 | export function setCurrentProject(name) {
7 | currentProject = name;
8 | windows["mainWindow"].webContents.send("set-current-project", name);
9 | }
10 |
11 | export function setProjectNames(names = ["default"]) {
12 | projectNames = names;
13 | }
14 |
15 | export { projectNames, currentProject };
16 |
--------------------------------------------------------------------------------
/src/components/ABSwap.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
17 |
--------------------------------------------------------------------------------
/src/components/CollapsibleRow.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
45 |
46 |
60 |
--------------------------------------------------------------------------------
/src/components/Controls/CollapsibleControl.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
6 |
7 | {{ focused && focused.title }}
8 | {{ focused && focused.body }}
9 |
10 |
11 |
12 |
13 |
31 |
32 |
43 |
--------------------------------------------------------------------------------
/src/components/StatusBar/BPMDisplay.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 | {{ Math.round($modV.store.state.beats.bpm) }} BPM
4 | ({{ $modV.store.state.beats.bpmSource }})
5 |
6 |
7 |
8 |
19 |
20 |
29 |
--------------------------------------------------------------------------------
/src/components/StatusBar/FPSDisplay.vue:
--------------------------------------------------------------------------------
1 |
2 |
13 | {{ Math.round($modV.store.state.metrics.fps) }} FPS
14 |
15 |
16 |
17 |
32 |
--------------------------------------------------------------------------------
/src/components/StatusBar/SizeDisplay.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 | {{ $modV.store.state.size.width }} × {{ $modV.store.state.size.height }}
4 |
5 |
6 |
--------------------------------------------------------------------------------
/src/components/StatusBar/StatusBarItem.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
34 |
--------------------------------------------------------------------------------
/src/components/TooltipDisplay.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
17 |
--------------------------------------------------------------------------------
/src/components/dialogs/FrameRateDialog.vue:
--------------------------------------------------------------------------------
1 |
2 |
16 |
17 |
18 |
47 |
--------------------------------------------------------------------------------
/src/components/directives/ContextMenu.js:
--------------------------------------------------------------------------------
1 | import { Menu } from "@electron/remote";
2 | import Vue from "vue";
3 |
4 | function openContextMenu(e, template) {
5 | const { clientX: x, clientY: y } = e;
6 |
7 | if (template) {
8 | const menu = Menu.buildFromTemplate(template);
9 | menu.popup({ x, y });
10 | }
11 | }
12 |
13 | Vue.directive("contextMenu", {
14 | inserted(el, { value: template }) {
15 | el.addEventListener("contextmenu", async e =>
16 | openContextMenu(e, await template())
17 | );
18 | },
19 |
20 | unbind() {
21 | // el.removeEventListener("click", e => openContextMenu(e, template));
22 | }
23 | });
24 |
--------------------------------------------------------------------------------
/src/components/directives/InfoView.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 |
3 | const INFO_VIEW_ID_VAR = "$iVID";
4 |
5 | function mouseover(id, $store) {
6 | return () => {
7 | $store.dispatch("infoView/setFocused", {
8 | id
9 | });
10 | };
11 | }
12 |
13 | Vue.directive("infoView", {
14 | // When the bound element is inserted into the DOM...
15 | async inserted(el, binding, vnode) {
16 | const { value } = binding;
17 | const {
18 | context: { $store }
19 | } = vnode;
20 |
21 | const id = await $store.dispatch("infoView/addDictionaryItem", {
22 | id: value.id,
23 | title: value.title,
24 | body: value.body
25 | });
26 |
27 | vnode[INFO_VIEW_ID_VAR] = id;
28 |
29 | el.addEventListener("mouseover", mouseover(id, $store), true);
30 | },
31 |
32 | async unbind(el, binding, vnode) {
33 | const {
34 | context: { $store }
35 | } = vnode;
36 |
37 | await $store.dispatch("infoView/removeDictionaryItem", {
38 | id: vnode[INFO_VIEW_ID_VAR]
39 | });
40 | }
41 | });
42 |
--------------------------------------------------------------------------------
/src/components/directives/Search.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 |
3 | const SEARCH_ID_VAR = "$searchId";
4 |
5 | Vue.directive("searchTerms", {
6 | // When the bound element is inserted into the DOM...
7 | async inserted(el, binding, vnode) {
8 | const { value } = binding;
9 | const {
10 | context: { $store }
11 | } = vnode;
12 |
13 | const id = await $store.dispatch("search/addTerms", {
14 | ...value
15 | });
16 |
17 | vnode[SEARCH_ID_VAR] = id;
18 | el.setAttribute("data-searchId", id);
19 | },
20 |
21 | async unbind(el, binding, vnode) {
22 | const {
23 | context: { $store }
24 | } = vnode;
25 |
26 | await $store.dispatch("search/removeId", {
27 | id: vnode[SEARCH_ID_VAR]
28 | });
29 | }
30 | });
31 |
--------------------------------------------------------------------------------
/src/components/inputs/Button.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
39 |
--------------------------------------------------------------------------------
/src/components/inputs/Number.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
10 |
11 |
12 |
32 |
33 |
45 |
--------------------------------------------------------------------------------
/src/components/inputs/Select.vue:
--------------------------------------------------------------------------------
1 |
2 |
11 |
12 |
13 |
29 |
30 |
65 |
--------------------------------------------------------------------------------
/src/components/inputs/TextInput.vue:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
11 |
31 |
32 |
44 |
--------------------------------------------------------------------------------
/src/components/inputs/Textarea.vue:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
11 |
22 |
23 |
36 |
--------------------------------------------------------------------------------
/src/components/inputs/index.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Button from "./Button.vue";
3 | import Checkbox from "./Checkbox.vue";
4 | import Number from "./Number.vue";
5 | import Range from "./Range.vue";
6 | import Select from "./Select.vue";
7 | import Textarea from "./Textarea.vue";
8 | import TextInput from "./TextInput.vue";
9 |
10 | Vue.component("Button", Button);
11 | Vue.component("Checkbox", Checkbox);
12 | Vue.component("Number", Number);
13 | Vue.component("Range", Range);
14 | Vue.component("Select", Select);
15 | Vue.component("Textarea", Textarea);
16 | Vue.component("TextInput", TextInput);
17 |
--------------------------------------------------------------------------------
/src/components/mixins/has-input-link.js:
--------------------------------------------------------------------------------
1 | export default {
2 | computed: {
3 | hasLink() {
4 | return this.$modV.store.state.inputs.inputLinks[this.inputId];
5 | }
6 | }
7 | };
8 |
--------------------------------------------------------------------------------
/src/components/mixins/input-is-focused.js:
--------------------------------------------------------------------------------
1 | export default {
2 | computed: {
3 | inputIsFocused() {
4 | return this.$modV.store.state.inputs.focusedInput.id === this.inputId;
5 | }
6 | }
7 | };
8 |
--------------------------------------------------------------------------------
/src/css/iaw.css:
--------------------------------------------------------------------------------
1 | /* mono */
2 | @font-face {
3 | font-family: 'iaw-mono';
4 | font-style: normal;
5 | font-weight: 400;
6 | src: url("../assets/fonts/iaw-mono-Regular.woff2") format("woff2"),
7 | url("../assets/fonts/iaw-mono-Regular.woff") format("woff");
8 | }
9 | @font-face {
10 | font-family: 'iaw-mono';
11 | font-style: italic;
12 | font-weight: 400;
13 | src: url("../assets/fonts/iaw-mono-Italic.woff2") format("woff2"),
14 | url("../assets/fonts/iaw-mono-Italic.woff") format("woff");
15 | }
16 | @font-face {
17 | font-family: 'iaw-mono';
18 | font-style: normal;
19 | font-weight: 700;
20 | src: url("../assets/fonts/iaw-mono-Bold.woff2") format("woff2"),
21 | url("../assets/fonts/iaw-mono-Bold.woff") format("woff");
22 | }
23 | @font-face {
24 | font-family: 'iaw-mono';
25 | font-style: italic;
26 | font-weight: 700;
27 | src: url("../assets/fonts/iaw-mono-BoldItalic.woff2") format("woff2"),
28 | url("../assets/fonts/iaw-mono-BoldItalic.woff") format("woff");
29 | }
30 |
--------------------------------------------------------------------------------
/src/css/inter.css:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | Font families defined by this CSS:
4 |
5 | - "Inter" static "traditional" fonts for older web browsers
6 | - "Inter var" single-axis variable fonts for all modern browsers
7 | - "Inter var experimental" multi-axis variable fonts for modern web browsers
8 |
9 | Use like this in your CSS:
10 |
11 | :root { font-family: 'Inter', sans-serif; }
12 | @supports (font-variation-settings: normal) {
13 | :root { font-family: 'Inter var', sans-serif; }
14 | }
15 |
16 | ------------------------- static ------------------------- */
17 | /* ----------------------- variable ----------------------- */
18 |
19 | @font-face {
20 | font-family: 'Inter var';
21 | font-style: normal;
22 | font-weight: 100 900;
23 | font-display: swap;
24 | src: url('../assets/fonts/Inter-roman.var.woff2?v=3.19') format('woff2');
25 | font-named-instance: 'Regular';
26 | }
27 |
28 | @font-face {
29 | font-family: 'Inter var';
30 | font-style: italic;
31 | font-weight: 100 900;
32 | font-display: swap;
33 | src: url('../assets/fonts/Inter-italic.var.woff2?v=3.19') format('woff2');
34 | font-named-instance: 'Italic';
35 | }
36 |
--------------------------------------------------------------------------------
/src/media-manager/add-read-handler.js:
--------------------------------------------------------------------------------
1 | import { log, logError } from "./log";
2 | import store from "./store";
3 |
4 | const fs = require("fs");
5 | const path = require("path");
6 |
7 | export default async function addReadHandler({ readHandler }) {
8 | let ok = true;
9 |
10 | if (typeof readHandler.init === "function") {
11 | try {
12 | ok = await readHandler.init(
13 | {
14 | binaryPath: this.binaryPath,
15 |
16 | join: (...args) => path.join.call(args),
17 |
18 | exists: file =>
19 | new Promise((resolve, reject) => {
20 | fs.access(file, fs.constants.F_OK, err => {
21 | if (err) {
22 | resolve();
23 | } else {
24 | reject();
25 | }
26 | });
27 | })
28 | },
29 | {
30 | log
31 | }
32 | );
33 | } catch (e) {
34 | ok = false;
35 | logError(e);
36 | }
37 | }
38 |
39 | if (ok) {
40 | await store.dispatch("readHandlers/addHandler", { readHandler });
41 | log(`Added ReadHandler for ${readHandler.folder}`);
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/media-manager/add-save-handler.js:
--------------------------------------------------------------------------------
1 | import { log } from "./log";
2 | import store from "./store";
3 |
4 | export default async function addReadHandler({ saveHandler }) {
5 | await store.dispatch("saveHandlers/addHandler", { saveHandler });
6 | log(`Added SaveHandler for ${saveHandler.folder}`);
7 | }
8 |
--------------------------------------------------------------------------------
/src/media-manager/log.js:
--------------------------------------------------------------------------------
1 | /* eslint-disable no-console */
2 | const consoleLog = console.log;
3 | const consoleError = console.error;
4 |
5 | function log(...argsIn) {
6 | const delta = new Date();
7 | const args = [];
8 | args.push(`[${delta.toLocaleTimeString()}]:`);
9 |
10 | for (let i = 0; i < argsIn.length; i += 1) {
11 | args.push(argsIn[i]);
12 | }
13 | consoleLog.apply(console, args);
14 | }
15 |
16 | function logError(...argsIn) {
17 | const delta = new Date();
18 | const args = [];
19 | args.push(`[${delta.toLocaleTimeString()}]:`);
20 |
21 | for (let i = 0; i < argsIn.length; i += 1) {
22 | args.push(argsIn[i]);
23 | }
24 | consoleError.apply(console, args);
25 | }
26 |
27 | export { log, logError };
28 |
--------------------------------------------------------------------------------
/src/media-manager/media-manager-utils/stream-to-string.js:
--------------------------------------------------------------------------------
1 | // https://stackoverflow.com/a/49428486
2 | module.exports = function streamToString(stream) {
3 | const chunks = [];
4 | return new Promise((resolve, reject) => {
5 | stream.on("data", chunk => chunks.push(Buffer.from(chunk)));
6 | stream.on("error", err => reject(err));
7 | stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
8 | });
9 | };
10 |
--------------------------------------------------------------------------------
/src/media-manager/read-handlers/palette.js:
--------------------------------------------------------------------------------
1 | export default {
2 | folder: "palette",
3 | identifier: "🎨",
4 |
5 | fileTypes: ["json"],
6 |
7 | process() {
8 | return new Promise(resolve => {
9 | resolve(true);
10 | });
11 | }
12 | };
13 |
--------------------------------------------------------------------------------
/src/media-manager/read-handlers/preset.js:
--------------------------------------------------------------------------------
1 | export default {
2 | folder: "preset",
3 | identifier: "📜",
4 |
5 | fileTypes: ["json"],
6 |
7 | process() {
8 | return new Promise(resolve => {
9 | resolve(true);
10 | });
11 | }
12 | };
13 |
--------------------------------------------------------------------------------
/src/media-manager/save-handlers/preset.js:
--------------------------------------------------------------------------------
1 | export default {
2 | folder: "preset",
3 | identifier: "📜",
4 |
5 | fileTypes: ["json"],
6 |
7 | process() {
8 | return new Promise(resolve => {
9 | resolve(true);
10 | });
11 | }
12 | };
13 |
--------------------------------------------------------------------------------
/src/media-manager/store/index.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Vuex from "vuex";
3 |
4 | import readHandlers from "./modules/read-handlers";
5 | import saveHandlers from "./modules/save-handlers";
6 | import media from "./modules/media";
7 | import plugins from "./modules/plugins";
8 |
9 | Vue.use(Vuex);
10 |
11 | const modules = {
12 | readHandlers,
13 | saveHandlers,
14 | media,
15 | plugins
16 | };
17 |
18 | const store = new Vuex.Store({
19 | strict: false,
20 | modules,
21 |
22 | actions: {
23 | resetAll({ commit }) {
24 | const moduleKeys = Object.keys(modules);
25 | for (let i = 0, len = moduleKeys.length; i < len; i++) {
26 | const moduleKey = moduleKeys[i];
27 |
28 | commit(`${moduleKey}/RESET_STATE`);
29 | }
30 | }
31 | }
32 | });
33 |
34 | export default store;
35 |
--------------------------------------------------------------------------------
/src/media-manager/store/modules/plugins.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 |
3 | function initialState() {
4 | /**
5 | * Holds Plugins
6 | *
7 | * @type {Object}
8 | */
9 | return {
10 | plugins: {},
11 | pluginData: {}
12 | };
13 | }
14 |
15 | const getters = {};
16 |
17 | const actions = {
18 | addMedia({ commit }, { project, folder, item }) {
19 | return new Promise(resolve => {
20 | commit("ADD", { project, folder, item });
21 | resolve();
22 | });
23 | }
24 | };
25 |
26 | const mutations = {
27 | ADD(state, { project, folder, item }) {
28 | if (!state[project]) {
29 | Vue.set(state, project, {});
30 | }
31 |
32 | if (!state[project][folder]) {
33 | Vue.set(state[project], folder, []);
34 | }
35 |
36 | state[project][folder].push(item);
37 | },
38 |
39 | RESET_STATE(state) {
40 | const s = initialState();
41 | const stateKeys = Object.keys(s);
42 | for (let i = 0, len = stateKeys.length; i < len; i++) {
43 | const key = stateKeys[i];
44 |
45 | state[key] = s[key];
46 | }
47 | }
48 | };
49 |
50 | export default {
51 | namespaced: true,
52 | state: initialState,
53 | getters,
54 | actions,
55 | mutations
56 | };
57 |
--------------------------------------------------------------------------------
/src/menus/context/activeModuleControlContextMenu.js:
--------------------------------------------------------------------------------
1 | import modV from "../../application/index";
2 | import getPropDefault from "../../application/utils/get-prop-default";
3 |
4 | export const ActiveModuleControlContextMenu = async ({
5 | moduleId,
6 | propName,
7 | title
8 | }) => {
9 | const activeModule = modV.store.state.modules.active[moduleId];
10 | const prop = activeModule.$props[propName];
11 | const defaultPropValue = await getPropDefault(activeModule, propName, prop);
12 |
13 | if (typeof defaultPropValue === "object") {
14 | return undefined;
15 | }
16 |
17 | return [
18 | {
19 | label: title,
20 | enabled: false
21 | },
22 | {
23 | type: "separator"
24 | },
25 | {
26 | label: `Reset to "${defaultPropValue}"`,
27 | async click() {
28 | modV.store.dispatch("modules/updateProp", {
29 | moduleId,
30 | prop: propName,
31 | data: defaultPropValue
32 | });
33 | }
34 | }
35 | ];
36 | };
37 |
--------------------------------------------------------------------------------
/src/menus/context/bpmContextMenu.js:
--------------------------------------------------------------------------------
1 | import store from "../../application/worker/store";
2 |
3 | export const BPMContextMenu = () => {
4 | const currentSource = store.state.beats.bpmSource;
5 |
6 | return store.state.beats.bpmSources.map(source => ({
7 | label: source,
8 | checked: source === currentSource,
9 | type: "radio",
10 | click() {
11 | store.commit("beats/SET_BPM_SOURCE", { source });
12 | }
13 | }));
14 | };
15 |
--------------------------------------------------------------------------------
/src/menus/context/galleryItemContextMenu.js:
--------------------------------------------------------------------------------
1 | import modV from "../../application/index";
2 | import constants from "../../application/constants";
3 |
4 | export const GalleryItemContextMenu = ({ moduleName }) => [
5 | {
6 | label: moduleName,
7 | enabled: false
8 | },
9 | {
10 | type: "separator"
11 | },
12 | {
13 | label: "Add to Group",
14 | submenu: modV.store.state.groups.groups
15 | .filter(group => group.name !== constants.GALLERY_GROUP_NAME)
16 | .map(({ name: groupName, id: groupId }) => ({
17 | label: groupName,
18 | async click() {
19 | const { $id: moduleId } = await modV.store.dispatch(
20 | "modules/makeActiveModule",
21 | {
22 | moduleName
23 | }
24 | );
25 |
26 | modV.store.commit("groups/ADD_MODULE_TO_GROUP", {
27 | moduleId,
28 | groupId,
29 | position: modV.store.state.groups.groups.find(
30 | group => group.id === groupId
31 | ).modules.length
32 | });
33 | }
34 | }))
35 | }
36 | ];
37 |
--------------------------------------------------------------------------------
/src/menus/context/groupContextMenu.js:
--------------------------------------------------------------------------------
1 | import modV from "../../application/index";
2 |
3 | export const GroupContextMenu = ({ group: { name, id: groupId } }) => [
4 | {
5 | label: name,
6 | enabled: false
7 | },
8 | {
9 | type: "separator"
10 | },
11 | {
12 | label: "Delete",
13 | async click() {
14 | modV.store.dispatch("groups/removeGroup", { groupId });
15 | }
16 | }
17 | ];
18 |
--------------------------------------------------------------------------------
/src/subpages/color-picker/main.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 |
3 | import App from "./App.vue";
4 |
5 | window.Vue = new Vue({
6 | render: h => h(App)
7 | }).$mount("#app");
8 |
--------------------------------------------------------------------------------
/src/subpages/splash-screen/App.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |