Move shaders from gdscript to gdshader, part2

addons/shaderV/rgba/generate_shapes/chekerboardPattern.gd

@@ -65,12 +65,9 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-float checkerb0ardPatternFunc(vec2 uv, vec2 _checker_size){
-	float fmodRes = mod(floor(_checker_size.x * uv.x) + floor(_checker_size.y * uv.y), 2.0);
-	return max(sign(fmodRes), 0.0);
-}
-"""
+	var code : String = preload("chekerboardPattern.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
@@ -79,6 +76,6 @@ func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> S
 		uv = input_vars[0]
 
 	return """%s = %s;
-%s = checkerb0ardPatternFunc(%s.xy, %s.xy) * %s;""" % [
+%s = _checkerboardPatternFunc(%s.xy, %s.xy) * %s;""" % [
 output_vars[0], input_vars[2],
 output_vars[1], uv, input_vars[1], input_vars[3]]

addons/shaderV/rgba/generate_shapes/chekerboardPattern.gdshader

@@ -0,0 +1,5 @@
+shader_type canvas_item;
+float _checkerboardPatternFunc(vec2 uv, vec2 _checker_size){
+	float fmodRes = mod(floor(_checker_size.x * uv.x) + floor(_checker_size.y * uv.y), 2.0);
+	return max(sign(fmodRes), 0.0);
+}

addons/shaderV/rgba/generate_shapes/generateCircle.gd

@@ -85,20 +85,9 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-vec4 generateCirc1eFunc(vec2 _uv_circ1e, vec2 _center_circ1e, vec2 _scale_factor_circ1e, float _innerRad_circ1e, float _outRad_circ1e, float _hard_circ1e) {
-	float _innerRadiusCheck0 = min(_innerRad_circ1e, _outRad_circ1e);
-	float _outerRadiusCheck0 = max(_innerRad_circ1e, _outRad_circ1e);
-	
-	float currentP0sitionC1rcle = length((_uv_circ1e - _center_circ1e) * _scale_factor_circ1e);
-	float maxIntencityCenterC1rcle = (_outerRadiusCheck0 + _innerRadiusCheck0) * 0.5;
-	float rd0 = _outerRadiusCheck0 - maxIntencityCenterC1rcle;
-	float circ1eDistributi0n = min(max(abs(currentP0sitionC1rcle - maxIntencityCenterC1rcle) / rd0, 0.0), 1.0);
-	vec4 _outputColor0 = vec4(1.0);
-	_outputColor0.a = 1.0 - pow(circ1eDistributi0n, _hard_circ1e);
-	return _outputColor0;
-}
-"""
+	var code : String = preload("generateCircle.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
@@ -107,5 +96,5 @@ func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> S
 		uv = input_vars[0]
 
 	return """%s = %s;
-%s = generateCirc1eFunc(%s.xy, %s.xy, %s.xy, %s, %s, %s).a * %s;""" % [output_vars[0],
+%s = _generateCircleFunc(%s.xy, %s.xy, %s.xy, %s, %s, %s).a * %s;""" % [output_vars[0],
 input_vars[6], output_vars[1], uv, input_vars[1], input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[7]]

addons/shaderV/rgba/generate_shapes/generateCircle.gdshader

@@ -0,0 +1,13 @@
+shader_type canvas_item;
+vec4 _generateCircleFunc(vec2 _uv_circle, vec2 _center_circle, vec2 _scale_factor_circle, float _innerRad_circle, float _outRad_circle, float _hard_circle) {
+	float _innerRadiusCheck0 = min(_innerRad_circle, _outRad_circle);
+	float _outerRadiusCheck0 = max(_innerRad_circle, _outRad_circle);
+
+	float currentPositionCircle = length((_uv_circle - _center_circle) * _scale_factor_circle);
+	float maxIntencityCenterCircle = (_outerRadiusCheck0 + _innerRadiusCheck0) * 0.5;
+	float rd0 = _outerRadiusCheck0 - maxIntencityCenterCircle;
+	float circleDistribution = min(max(abs(currentPositionCircle - maxIntencityCenterCircle) / rd0, 0.0), 1.0);
+	vec4 _outputColor0 = vec4(1.0);
+	_outputColor0.a = 1.0 - pow(circleDistribution, _hard_circle);
+	return _outputColor0;
+}

addons/shaderV/rgba/generate_shapes/generateCircle2.gd

@@ -85,23 +85,17 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-vec4 generateCircle2Func(vec2 _uv_gc2, vec2 _p0s_gc2, vec2 _sca1e_gc2, float _rad_gc2,
-						 float _b0rdIn_gc2, float _b0rdOut_gc2, vec4 _c0l_gc2){
-	float _dst_gc2 = length((_uv_gc2 - _p0s_gc2) * _sca1e_gc2);
-	_c0l_gc2.a *= smoothstep(_rad_gc2 - _b0rdIn_gc2, _rad_gc2, _dst_gc2) 
-				 - smoothstep(_rad_gc2, _rad_gc2 + _b0rdOut_gc2, _dst_gc2);
-	return _c0l_gc2;
-}
-"""
+	var code : String = preload("generateCircle2.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
 
 	if input_vars[0]:
 		uv = input_vars[0]
 
-	return """vec4 %s%s = generateCircle2Func(%s.xy, %s.xy, %s.xy, %s, %s, %s, vec4(%s, %s));
+	return """vec4 %s%s = _generateCircle2Func(%s.xy, %s.xy, %s.xy, %s, %s, %s, vec4(%s, %s));
 %s = %s%s.rgb;
 %s = %s%s.a;""" % [
 output_vars[0], output_vars[1], uv, input_vars[1], input_vars[2], input_vars[3],

addons/shaderV/rgba/generate_shapes/generateCircle2.gdshader

@@ -0,0 +1,8 @@
+shader_type canvas_item;
+vec4 _generateCircle2Func(vec2 _uv_gc2, vec2 _pos_gc2, vec2 _scale_gc2, float _rad_gc2,
+						 float _bordIn_gc2, float _bordOut_gc2, vec4 _col_gc2){
+	float _dst_gc2 = length((_uv_gc2 - _pos_gc2) * _scale_gc2);
+	_col_gc2.a *= smoothstep(_rad_gc2 - _bordIn_gc2, _rad_gc2, _dst_gc2) 
+				 - smoothstep(_rad_gc2, _rad_gc2 + _bordOut_gc2, _dst_gc2);
+	return _col_gc2;
+}

addons/shaderV/rgba/generate_shapes/generateRegularNgon.gd

@@ -85,17 +85,9 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-float p0lyg0nFunc(vec2 _uv_p0lyg0n, vec2 _pos_p0lyg0n, vec2 _size_p0lyg0n, float _sides_p0lyg0n, float _angle_p0lyg0n, float _smooth_p0lyg0n){
-	_uv_p0lyg0n = (_uv_p0lyg0n - _pos_p0lyg0n) / (_size_p0lyg0n * 2.0);
-	float a_p0lyg0n = atan(_uv_p0lyg0n.x, _uv_p0lyg0n.y) + _angle_p0lyg0n;
-	float r_p0lyg0n = 6.28318530718 / float(int(max(_sides_p0lyg0n, 3.0)));
-	float d_p0lyg0n = cos(floor(0.5 + a_p0lyg0n / r_p0lyg0n) * r_p0lyg0n - a_p0lyg0n) * length(_uv_p0lyg0n);
-	return (max(sign(_smooth_p0lyg0n - 0.0), 0.0) * ( 1.0 - smoothstep(0.1 - 0.0001, 0.1 + _smooth_p0lyg0n, d_p0lyg0n) ) +
-			(max(sign(-_smooth_p0lyg0n + 0.0), 0.0)) * ( 1.0 - smoothstep(0.1 + _smooth_p0lyg0n - 0.0001, 0.1, d_p0lyg0n) ) +
-			(1.0 - abs(sign(_smooth_p0lyg0n - 0.0))) * ( 1.0 - step(0.1, d_p0lyg0n)) );
-}
-"""
+	var code : String = preload("generateRegularNgon.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
@@ -104,6 +96,6 @@ func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> S
 		uv = input_vars[0]
 
 	return """%s = %s;
-%s = p0lyg0nFunc(%s.xy, %s.xy, %s.xy, %s, %s, %s) * %s;""" % [
+%s = _polygonFunc(%s.xy, %s.xy, %s.xy, %s, %s, %s) * %s;""" % [
 output_vars[0], input_vars[6],
 output_vars[1], uv, input_vars[1], input_vars[3], input_vars[2], input_vars[4], input_vars[5], input_vars[7]]

addons/shaderV/rgba/generate_shapes/generateRegularNgon.gdshader

@@ -0,0 +1,10 @@
+shader_type canvas_item;
+float _polygonFunc(vec2 _uv_polygon, vec2 _pos_polygon, vec2 _size_polygon, float _sides_polygon, float _angle_polygon, float _smooth_polygon){
+	_uv_polygon = (_uv_polygon - _pos_polygon) / (_size_polygon * 2.0);
+	float a_polygon = atan(_uv_polygon.x, _uv_polygon.y) + _angle_polygon;
+	float r_polygon = 6.28318530718 / float(int(max(_sides_polygon, 3.0)));
+	float d_polygon = cos(floor(0.5 + a_polygon / r_polygon) * r_polygon - a_polygon) * length(_uv_polygon);
+	return (max(sign(_smooth_polygon - 0.0), 0.0) * ( 1.0 - smoothstep(0.1 - 0.0001, 0.1 + _smooth_polygon, d_polygon) ) +
+			(max(sign(-_smooth_polygon + 0.0), 0.0)) * ( 1.0 - smoothstep(0.1 + _smooth_polygon - 0.0001, 0.1, d_polygon) ) +
+			(1.0 - abs(sign(_smooth_polygon - 0.0))) * ( 1.0 - step(0.1, d_polygon)) );
+}

addons/shaderV/rgba/generate_shapes/generateSpiral.gd

@@ -90,24 +90,17 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-vec4 generateSp1ralFunc(vec2 _uv_genSp1r, vec2 _p1v0t_genSp1r, float _s1ze_genSp1r, float _l1neAmnt_genSp1r,
-						float _spd_genSp1r, float _s0ft_genSp1r, float _t1me_genSp1r, vec4 _c0l_genSp1r){
-	_uv_genSp1r -= _p1v0t_genSp1r;
-	float _va1ue_genSp1r = 1.0 - sin(length(_uv_genSp1r) * _s1ze_genSp1r +
-					floor(_l1neAmnt_genSp1r) * atan(_uv_genSp1r.x, _uv_genSp1r.y) +
-					_t1me_genSp1r * _spd_genSp1r ) / _s0ft_genSp1r;
-	return vec4(_c0l_genSp1r.rgb, _c0l_genSp1r.a * _va1ue_genSp1r);
-}
-"""
+	var code : String = preload("generateSpiral.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
 
 	if input_vars[0]:
 		uv = input_vars[0]
 
-	return """vec4 %s%s = generateSp1ralFunc(%s.xy, %s.xy, %s, %s, %s, %s, %s, vec4(%s, %s));
+	return """vec4 %s%s = _generateSpiralFunc(%s.xy, %s.xy, %s, %s, %s, %s, %s, vec4(%s, %s));
 %s = %s%s.rgb;
 %s = %s%s.a;""" % [
 output_vars[0], output_vars[1], uv, input_vars[1], input_vars[2], input_vars[3], input_vars[5],

addons/shaderV/rgba/generate_shapes/generateSpiral.gdshader

@@ -0,0 +1,9 @@
+shader_type canvas_item;
+vec4 _generateSpiralFunc(vec2 _uv_genSpir, vec2 _pivot_genSpir, float _size_genSpir, float _lineAmnt_genSpir,
+						float _spd_genSpir, float _soft_genSpir, float _t1me_genSpir, vec4 _col_genSpir){
+	_uv_genSpir -= _pivot_genSpir;
+	float _va1ue_genSpir = 1.0 - sin(length(_uv_genSpir) * _size_genSpir +
+					floor(_lineAmnt_genSpir) * atan(_uv_genSpir.x, _uv_genSpir.y) +
+					_t1me_genSpir * _spd_genSpir ) / _soft_genSpir;
+	return vec4(_col_genSpir.rgb, _col_genSpir.a * _va1ue_genSpir);
+}

addons/shaderV/rgba/generate_shapes/gridShape.gd

@@ -85,22 +85,17 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-vec4 gridFunc(vec2 _grid_uv, vec2 _gridline_thickness, vec2 _gridline_smooth, vec2 _gridcell_count, vec4 _grid_col, vec4 _grid_bg_col){
-	vec2 _grid_vec = fract(_grid_uv * _gridcell_count);
-	_grid_vec = min(_grid_vec, vec2(1.0) - _grid_vec);
-	_grid_vec = smoothstep(_grid_vec - _gridline_smooth, _grid_vec + _gridline_smooth, _gridline_thickness / vec2(2.0));
-	return mix(_grid_bg_col, _grid_col, clamp(_grid_vec.x + _grid_vec.y, 0.0, 1.0));
-}
-"""
+	var code : String = preload("gridShape.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
 
 	if input_vars[0]:
 		uv = input_vars[0]
 
-	return """vec4 %s%s = gridFunc(%s.xy, %s.xy, %s.xy, %s.xy, vec4(%s, %s), vec4(%s, %s));
+	return """vec4 %s%s = _gridFunc(%s.xy, %s.xy, %s.xy, %s.xy, vec4(%s, %s), vec4(%s, %s));
 %s = %s%s.rgb;
 %s = %s%s.a;""" % [
 output_vars[0], output_vars[1], uv, input_vars[2], input_vars[3], input_vars[1],

addons/shaderV/rgba/generate_shapes/gridShape.gdshader

@@ -0,0 +1,7 @@
+shader_type canvas_item;
+vec4 _gridFunc(vec2 _grid_uv, vec2 _gridline_thickness, vec2 _gridline_smooth, vec2 _gridcell_count, vec4 _grid_col, vec4 _grid_bg_col){
+	vec2 _grid_vec = fract(_grid_uv * _gridcell_count);
+	_grid_vec = min(_grid_vec, vec2(1.0) - _grid_vec);
+	_grid_vec = smoothstep(_grid_vec - _gridline_smooth, _grid_vec + _gridline_smooth, _gridline_thickness / vec2(2.0));
+	return mix(_grid_bg_col, _grid_col, clamp(_grid_vec.x + _grid_vec.y, 0.0, 1.0));
+}

addons/shaderV/rgba/generate_shapes/scanLinesSharp.gd

@@ -80,11 +80,9 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-float scanL1nesSharpFunc(vec2 _uv_scL1Shrp, float _am0nt_scL1Shrp, float _f1ll_scL1Shrp, float _spd_scL1Shrp, float _t1me_scL1Shrp) {
-	return step(fract(_uv_scL1Shrp.y * _am0nt_scL1Shrp + _t1me_scL1Shrp * _spd_scL1Shrp), _f1ll_scL1Shrp);
-}
-"""
+	var code : String = preload("scanLinesSharp.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
@@ -93,6 +91,6 @@ func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> S
 		uv = input_vars[0]
 
 	return """%s = %s;
-%s = scanL1nesSharpFunc(%s.xy, %s, %s, %s, %s) * %s;""" % [
+%s = _scanLinesSharpFunc(%s.xy, %s, %s, %s, %s) * %s;""" % [
 output_vars[0], input_vars[5],
 output_vars[1], uv, input_vars[1], input_vars[2], input_vars[3], input_vars[4], input_vars[6]]

addons/shaderV/rgba/generate_shapes/scanLinesSharp.gdshader

@@ -0,0 +1,4 @@
+shader_type canvas_item;
+float _scanLinesSharpFunc(vec2 _uv_scLiShrp, float _amount_scLiShrp, float _fill_scLiShrp, float _spd_scLiShrp, float _time_scLiShrp) {
+	return step(fract(_uv_scLiShrp.y * _amount_scLiShrp + _time_scLiShrp * _spd_scLiShrp), _fill_scLiShrp);
+}

addons/shaderV/rgba/generate_shapes/stripesRandom.gd

@@ -70,12 +70,9 @@ func _get_output_port_type(port: int):
 			return VisualShaderNode.PORT_TYPE_SCALAR
 
 func _get_global_code(mode: int) -> String:
-	return """
-float generateRand0mStripesFunc(vec2 _uv_stripes, float _fill_stripes, float _amount_stripes){
-	_fill_stripes = min(max(_fill_stripes, 0.0), 1.0);
-	return 1.0 - step(_fill_stripes, fract(sin(dot(floor(vec2(_uv_stripes.y) * _amount_stripes), vec2(12.9898, 78.233))) * 43758.5453123));
-}
-"""
+	var code : String = preload("stripesRandom.gdshader").code
+	code = code.replace("shader_type canvas_item;\n", "")
+	return code
 
 func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String:
 	var uv = "UV"
@@ -84,5 +81,5 @@ func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> S
 		uv = input_vars[0]
 
 	return """%s = %s;
-%s = generateRand0mStripesFunc(%s.xy, %s, %s) * %s;""" % [output_vars[0], input_vars[3],
+%s = _generateRandomStripesFunc(%s.xy, %s, %s) * %s;""" % [output_vars[0], input_vars[3],
 output_vars[1], uv, input_vars[1], input_vars[2], input_vars[4]]

addons/shaderV/rgba/generate_shapes/stripesRandom.gdshader

@@ -0,0 +1,5 @@
+shader_type canvas_item;
+float _generateRandomStripesFunc(vec2 _uv_stripes, float _fill_stripes, float _amount_stripes){
+	_fill_stripes = min(max(_fill_stripes, 0.0), 1.0);
+	return 1.0 - step(_fill_stripes, fract(sin(dot(floor(vec2(_uv_stripes.y) * _amount_stripes), vec2(12.9898, 78.233))) * 43758.5453123));
+}