...
2019-04-11T13:18:37 [INFO] Vertex shader added successfully
2019-04-11T13:18:37 [WARNING] QOpenGLShader::compile(Fragment): 0:1(10): error: GLSL 1.50 is not supported. Supported versions are: 1.10, 1.20, and 1.00 ES

2019-04-11T13:18:37 [WARNING] *** Problematic Fragment shader source code ***
#version 150
#define lowp
#define mediump
#define highp
#line 1
uniform sampler2D tex0;
in vec2 vTexCoord;
out vec4 FragColor;

uniform float colors; // 12.0
uniform float sat_levels; // 4.0
uniform float bri_levels; // 4.0
uniform float edge_thres; // 0.2;
uniform float edge_thres2; // 5.0;

vec3 RGBtoHSV( float r, float g, float b) 
{
	 float minv, maxv, delta;
	 vec3 res;

	 minv = min(min(r, g), b);
	 maxv = max(max(r, g), b);
	 res.z = maxv;            // v
	 
	 delta = maxv - minv;

	 if( maxv != 0.0 )
			res.y = delta / maxv;      // s
	 else {
			// r = g = b = 0      // s = 0, v is undefined
			res.y = 0.0;
			res.x = -1.0;
			return res;
	 }

	 if( r == maxv )
			res.x = ( g - b ) / delta;      // between yellow & magenta
	 else if( g == maxv )
			res.x = 2.0 + ( b - r ) / delta;   // between cyan & yellow
	 else
			res.x = 4.0 + ( r - g ) / delta;   // between magenta & cyan

	 res.x = res.x * 60.0;            // degrees
	 if( res.x < 0.0 )
			res.x = res.x + 360.0;
			
	 return res;
}

vec3 HSVtoRGB(float h, float s, float v ) 
{
	 int i;
	 float f, p, q, t;
	 vec3 res;

	 if( s == 0.0 ) 
	 {
			// achromatic (grey)
			res.x = v;
			res.y = v;
			res.z = v;
			return res;
	 }

	 h /= 60.0;         // sector 0 to 5
	 i = int(floor( h ));
	 f = h - float(i);         // factorial part of h
	 p = v * ( 1.0 - s );
	 q = v * ( 1.0 - s * f );
	 t = v * ( 1.0 - s * ( 1.0 - f ) );

	 switch(i) 
	 {
			case 0:
				 res.x = v;
				 res.y = t;
				 res.z = p;
				 break;
			case 1:
				 res.x = q;
				 res.y = v;
				 res.z = p;
				 break;
			case 2:
				 res.x = p;
				 res.y = v;
				 res.z = t;
				 break;
			case 3:
				 res.x = p;
				 res.y = q;
				 res.z = v;
				 break;
			case 4:
				 res.x = t;
				 res.y = p;
				 res.z = v;
				 break;
			default:      // case 5:
				 res.x = v;
				 res.y = p;
				 res.z = q;
				 break;
	 }
	 return res;
}

// averaged pixel intensity from 3 color channels
float avg_intensity(vec4 pix) 
{
 return (pix.r + pix.g + pix.b)/3.;
}

vec4 get_pixel(vec2 coords, float dx, float dy) 
{
 return texture(tex0,coords + vec2(dx, dy));
}

// returns pixel color
float IsEdge(in vec2 coords)
{
	float dxtex = 1.0 /float(textureSize(tex0,0)) ;
	float dytex = 1.0 /float(textureSize(tex0,0));
	float pix[9];
	int k = -1;
	float delta;

	// read neighboring pixel intensities
	for (int i=-1; i<2; i++) {
	 for(int j=-1; j<2; j++) {
		k++;
		pix[k] = avg_intensity(get_pixel(coords,float(i)*dxtex,
													float(j)*dytex));
	 }
	}

	// average color differences around neighboring pixels
	delta = (abs(pix[1]-pix[7])+
					abs(pix[5]-pix[3]) +
					abs(pix[0]-pix[8])+
					abs(pix[2]-pix[6])
					 )/4.;

	//return clamp(5.5*delta,0.0,1.0);
	return clamp(edge_thres2*delta,0.0,1.0);
}

void main() {
	vec2 uv = vTexCoord.xy;
	vec4 tc = vec4(1.0, 0.0, 0.0, 1.0);
	vec3 colorOrg = texture(tex0, uv).rgb;
	vec3 vHSV =  RGBtoHSV(colorOrg.r,colorOrg.g,colorOrg.b);

	// hue limiting	
	if (colors == 0.0) {
		vHSV.y = 0.0;
	} else {
		float hue_divider = (360.0/colors);
		vHSV.x = round(vHSV.x/hue_divider)*hue_divider;

		float sat_divider = 100.0/sat_levels;
		vHSV.y = round((vHSV.y*100.0)/sat_divider)*sat_divider/100.0;
	}

	float bri_divider = 100.0/bri_levels;
	vHSV.z = round((vHSV.z*100.0)/bri_divider)*bri_divider/100.0;

	float edg = IsEdge(uv);
	vec3 vRGB = (edg >= (1.0-((edge_thres-1.0)*0.01)))? vec3(0.0,0.0,0.0):HSVtoRGB(vHSV.x,vHSV.y,vHSV.z);
	tc = vec4(vRGB.x,vRGB.y,vRGB.z, 1);
	FragColor = tc;
}
***
2019-04-11T13:18:37 [WARNING] Fragment shader could not be added

vec4 process(vec4 color) {
    return changesTo(color);
}

void main(void) {
    gl_FragColor = changesTo(color);
}

...
2019-04-11T13:25:09 [INFO] Vertex shader added successfully
2019-04-11T13:25:09 [WARNING] QOpenGLShader::compile(Fragment): 0:38(22): error: could not implicitly convert operands to arithmetic operator
0:38(18): error: no matching function for call to `min(error, float)'; candidates are:
0:38(18): error:    float min(float, float)
0:38(18): error:    vec2 min(vec2, float)
0:38(18): error:    vec3 min(vec3, float)
0:38(18): error:    vec4 min(vec4, float)
0:38(18): error:    vec2 min(vec2, vec2)
0:38(18): error:    vec3 min(vec3, vec3)
0:38(18): error:    vec4 min(vec4, vec4)
0:38(18): error:    int min(int, int)
0:38(18): error:    ivec2 min(ivec2, int)
0:38(18): error:    ivec3 min(ivec3, int)
0:38(18): error:    ivec4 min(ivec4, int)
0:38(18): error:    ivec2 min(ivec2, ivec2)
0:38(18): error:    ivec3 min(ivec3, ivec3)
0:38(18): error:    ivec4 min(ivec4, ivec4)
0:38(14): error: cannot construct `int' from a non-numeric data type
0:44(23): warning: `kSize' used uninitialized
0:46(9): warning: `kSize' used uninitialized
0:46(27): warning: `kSize' used uninitialized
0:54(14): warning: `kSize' used uninitialized
0:54(26): warning: `kSize' used uninitialized
0:56(14): warning: `kSize' used uninitialized
0:56(26): warning: `kSize' used uninitialized
0:59(52): warning: `kSize' used uninitialized
0:59(68): warning: `kSize' used uninitialized

2019-04-11T13:25:09 [WARNING] *** Problematic Fragment shader source code ***
#define lowp
#define mediump
#define highp
#line 1
/***

    Port of https://www.shadertoy.com/view/4dfGDH
    Adapted by CGVIRUS for the Olive-Editor Community

***/


uniform sampler2D tex;
varying vec2 vTexCoord;
uniform vec2 resolution;
const vec2 renderScale = vec2(1.,1.);

//Effects Parameter
uniform float sigma_s;
uniform float sigma_r;

#define MSIZE 30

float normpdf(in float x, in float sigma)
{
	return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;
}

float normpdf3(in vec3 v, in float sigma)
{
	return 0.39894*exp(-0.5*dot(v,v)/(sigma*sigma))/sigma;
}


void main()
{
	vec2 uv = gl_FragCoord.xy / resolution.xy;
	vec3 c = texture2D(tex, uv).rgb;
	{
		//declare stuff
		int kSize = int(min((MSIZE-1)/2., 1.5*(sigma_s*0.5)*renderScale.x));
		float kernel[MSIZE];
		vec3 final_colour = vec3(0.0);
		
		//create the 1-D kernel
		float Z = 0.0;
		for (int j = 0; j <= kSize; ++j)
		{
			kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j), (sigma_s*0.5)*renderScale.x);
		}
		
		
		vec3 cc;
		float factor;
		float bZ = 1.0/normpdf(0.0, (sigma_r*.001));
		//read out the texels
		for (int i=-kSize; i <= kSize; ++i)
		{
			for (int j=-kSize; j <= kSize; ++j)
			{
				cc = texture2D(tex, uv + (vec2(float(i),float(j))) / resolution.xy).rgb;
				factor = normpdf3(cc-c, (sigma_r*.001))*bZ*kernel[kSize+j]*kernel[kSize+i];
				Z += factor;
				final_colour += factor*cc;

			}
		}
		
		
		gl_FragColor = vec4(final_colour/Z, texture2D( tex, uv ).a);
	}
}

***
2019-04-11T13:25:09 [WARNING] Fragment shader could not be added

...
2019-04-11T10:12:06 [INFO] Vertex shader added successfully
2019-04-11T10:12:06 [WARNING] QOpenGLShader::compile(Fragment): 0:43(13): error: no matching function for call to `texture2DLod(sampler2D, vec2, float)'; candidates are:
0:43(13): error: type mismatch

2019-04-11T10:12:06 [WARNING] *** Problematic Fragment shader source code ***
#define lowp
#define mediump
#define highp
#line 1
/***
    
    Bokeh disc. Fixed for Scaling and Noise, Optimized for MIPMAP
    
    Port of https://www.shadertoy.com/view/4d2Xzw by David Hoskins.
    Adaption and Implementation by CGVIRUS for Olive-Editor Community
        
    License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
    
***/


uniform sampler2D tex;
varying vec2 uTexCoord;
uniform vec2 resolution;

#define USE_MIPMAP
#define GOLDEN_ANGLE 2.39996323


uniform float Samples;
uniform float Amount;
uniform float Exposure;

mat2 rot = mat2(cos(GOLDEN_ANGLE), sin(GOLDEN_ANGLE), -sin(GOLDEN_ANGLE), cos(GOLDEN_ANGLE));

vec3 Bokeh(sampler2D tex, vec2 uv, float radius, float amount)
{
    vec2 rscale = vec2(1.0,1.0);
    vec3 acc = vec3(0.0);
    vec3 div = vec3(0.0);
    vec2 pixel = (1.0 / resolution.xy)*rscale;
    float r = 1.0;
    vec2 vangle = vec2(0.0,radius); 
    amount += radius*5000.0;
    
    for (int j = 0; j < int(Samples); j++)
    {  
        r += 1. / r;
        vangle = rot * vangle;
        vec2 tuv = (uv + pixel * (r-1.) * vangle);
        vec3 col = texture2DLod(tex, tuv, radius*.8).xyz;
        col *= Exposure; 
        vec3 bokeh = pow(col, vec3(9.0)) * amount+.4;
        acc += col * bokeh;
        div += bokeh;
    }
    return acc / div;
}

void main()
{
    
    vec2 uv = gl_FragCoord.xy / resolution.xy;
    float a = 40.0;
    // uv *= vec2(1.0, 1.0);
    gl_FragColor = vec4(Bokeh(tex, uv, Amount, a),texture2D( tex, uv ).a);
    
    
}
***
2019-04-11T10:12:06 [WARNING] Fragment shader could not be added