└── addons └── shaderV ├── shaderV_icon.png ├── examples ├── godot_logo.png └── godot_logo.png.import ├── rgba ├── hue.gdshaderinc ├── maskAlpha.gdshaderinc ├── posterize.gdshaderinc ├── inverseColor.gdshaderinc ├── blendAwithB.gdshaderinc ├── blackNwhite.gdshaderinc ├── generate_shapes │ ├── chekerboardPattern.gdshaderinc │ ├── stripesRandom.gdshaderinc │ ├── scanLinesSharp.gdshaderinc │ ├── generateCircle2.gdshaderinc │ ├── generateSpiral.gdshaderinc │ ├── gridShape.gdshaderinc │ ├── generateCircle.gdshaderinc │ ├── generateRegularNgon.gdshaderinc │ ├── chekerboardPattern.gd │ ├── stripesRandom.gd │ └── scanLinesSharp.gd ├── bloom.gdshaderinc ├── grayscale.gdshaderinc ├── tonemap.gdshaderinc ├── colorCorrectionAdjustment.gdshaderinc ├── gradient4corners.gdshaderinc ├── gradientMapping.gdshaderinc ├── BCSAdjustment.gdshaderinc ├── clamp.gdshaderinc ├── turnCGA4Palette.gdshaderinc ├── turnGBPalette.gdshaderinc ├── emboss.gdshaderinc ├── shineFX.gdshaderinc ├── blur │ ├── blurCustom.gdshaderinc │ ├── zoomBlur.gdshaderinc │ ├── blur9sample.gd │ ├── blurCustom.gd │ ├── blur9sample.gdshaderinc │ └── zoomBlur.gd ├── shiftHSV.gdshaderinc ├── noise │ ├── generic2d.gdshaderinc │ ├── worley2x2.gdshaderinc │ ├── simplex2d.gdshaderinc │ ├── fractal │ │ ├── generic2d_fractal.gdshaderinc │ │ ├── simplex2d_fractal.gdshaderinc │ │ ├── perlin2d_fractal.gdshaderinc │ │ ├── perlin2d_fractal.gd │ │ ├── simplex2d_fractal.gd │ │ ├── worley2d_fractal.gdshaderinc │ │ ├── generic2d_fractal.gd │ │ ├── perlin3d_fractal.gd │ │ ├── simplex3d_fractal.gd │ │ └── simplex3d_fractal.gdshaderinc │ ├── generic2d.gd │ ├── simplex2d.gd │ ├── worley2d.gdshaderinc │ ├── perlin2d.gdshaderinc │ ├── worley2x2x2.gdshaderinc │ ├── worley2x2.gd │ ├── perlin3d.gd │ ├── simplex3d.gd │ ├── perlin2d.gd │ ├── worley2x2x2.gd │ ├── simplex3d.gdshaderinc │ ├── simplex4d.gd │ ├── perlin4d.gd │ ├── perlinPeriodic3d.gd │ ├── worley2d.gd │ ├── worley3d.gd │ └── simplex4d.gdshaderinc ├── chromaticAberration.gdshaderinc ├── hue.gd ├── normalFromHeightmap.gdshaderinc ├── glow │ ├── innerGlow.gdshaderinc │ ├── outerGlow.gdshaderinc │ ├── innerGlowEmpty.gdshaderinc │ ├── outerGlowEmpty.gdshaderinc │ ├── glowEmpty.gdshaderinc │ ├── innerGlow.gd │ ├── outerGlow.gd │ └── innerGlowEmpty.gd ├── blackNwhite.gd ├── grayscale.gd ├── posterize.gd ├── turnCGA4Palette.gd ├── turnGBPalette.gd ├── clamp.gd ├── colorCorrectionAdjustment.gd ├── tonemap.gd ├── inverseColor.gd ├── BCSAdjustment.gd ├── tintRGBA.gd ├── bloom.gd ├── maskAlpha.gd ├── shiftHSV.gd ├── blendAwithB.gd ├── sobelEdge.gd ├── emboss.gd ├── gradientMapping.gd ├── chromaticAberration.gd └── normalFromHeightmap.gd ├── uv ├── scaleUV.gdshaderinc ├── pixelate.gdshaderinc ├── flipUV.gdshaderinc ├── tilingNoffset.gdshaderinc ├── distortionUV.gdshaderinc ├── animated │ ├── tilingNoffsetAnimated.gdshaderinc │ ├── distortionUVAnimated.gdshaderinc │ ├── swirlUV.gdshaderinc │ ├── rotateAnimated.gdshaderinc │ ├── doodleUV.gdshaderinc │ ├── tilingNoffsetAnimated.gd │ ├── swirlUV.gd │ ├── rotateAnimated.gd │ ├── doodleUV.gd │ └── distortionUVAnimated.gd ├── tileUV.gdshaderinc ├── twirl.gdshaderinc ├── rotate.gdshaderinc ├── lensDistortion.gdshaderinc ├── sphericalUV.gdshaderinc ├── transformUV.gdshaderinc ├── tilingNoffset.gd ├── pixelate.gd ├── lensDistortion.gd ├── flipUV.gd ├── twirl.gd ├── rotate.gd ├── scaleUV.gd ├── tileUV.gd ├── distortionUV.gd ├── sphericalUV.gd └── transformUV.gd ├── tools ├── vec2Compose.gdshaderinc ├── random │ ├── hash2dvector.gdshaderinc │ ├── randomFloat4D.gdshaderinc │ ├── randomGoldNoiseFloat.gdshaderinc │ ├── randomFloatImproved.gdshaderinc │ ├── hash1d.gd │ ├── hash2d.gd │ ├── hash2dvector.gd │ ├── randomFloat.gd │ ├── randomGoldNoiseFloat.gd │ ├── randomFloatImproved.gd │ └── randomFloat4D.gd ├── remap.gdshaderinc ├── transformCoordinates │ ├── cartesianToPolar.gdshaderinc │ ├── polarToCartesian.gdshaderinc │ ├── cartesianToSpherical.gdshaderinc │ ├── sphericalToCartesian.gdshaderinc │ ├── polarToCartesian.gd │ ├── sphericalToCartesian.gd │ ├── cartesianToPolar.gd │ └── cartesianToSpherical.gd ├── TimeScaled.gd ├── relay.gd ├── sinTime.gd ├── vec2Compose.gd └── remap.gd └── shaderV_icon.png.import /addons/shaderV/shaderV_icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arkology/ShaderV/HEAD/addons/shaderV/shaderV_icon.png -------------------------------------------------------------------------------- /addons/shaderV/examples/godot_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arkology/ShaderV/HEAD/addons/shaderV/examples/godot_logo.png -------------------------------------------------------------------------------- /addons/shaderV/rgba/hue.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _hueFunc(float _inp_hue){ 2 | return 3.0 * abs(1.0 - 2.0 * fract(_inp_hue + vec3(0.0, -1.0 / 3.0, 1.0 / 3.0))) - 1.0; 3 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/scaleUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _scaleUV(vec2 _scale_uv, vec2 _scale_vect, vec2 _pivot_vect) { 2 | return (_scale_uv - _pivot_vect) * _scale_vect + _pivot_vect; 3 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/maskAlpha.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _maskAlphaFunc(vec4 _col_to_mask, float _mask_alpha_to_mask){ 2 | return vec4(_col_to_mask.rgb, _col_to_mask.a * _mask_alpha_to_mask); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/posterize.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _posterizeFunc(vec3 _col_posterize, float _steps_posterize){ 2 | return floor(_col_posterize * _steps_posterize) / (_steps_posterize - 1.0); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/vec2Compose.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _vec2ComposeFunc(float _vec2_length, float _vec2_angle_radians){ 2 | return vec2(cos(_vec2_angle_radians), sin(_vec2_angle_radians)) * _vec2_length; 3 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/pixelate.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _pixelateUV(vec2 _pixelate_uv, vec2 _effect_factor_pixelate) { 2 | return round(_pixelate_uv * _effect_factor_pixelate) / (_effect_factor_pixelate - 1.0); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/hash2dvector.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _hash2v(vec2 co) { 2 | float _tmp_h = dot(co, vec2(12.9898, 78.233)); 3 | return fract(vec2(sin(_tmp_h), cos(_tmp_h)) * 43758.5453) * 2.0 - 1.0; 4 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/inverseColor.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _inverseColorFunc(vec3 _color_to_inverse, float _inverse_color_intensity){ 2 | return mix(_color_to_inverse.rgb, 1.0 - _color_to_inverse.rgb, _inverse_color_intensity); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/remap.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _remapFunc(vec3 _remap_input, vec2 _remap_from, vec2 _remap_to){ 2 | return _remap_to.x + ((_remap_input - _remap_from.x) * (_remap_to.y - _remap_to.x)) / (_remap_from.y - _remap_from.x); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/blendAwithB.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _blendAwithBFunc(vec4 _color_blendA_rgba, vec4 _color_blendB_rgba, float _fade_blend_color){ 2 | return mix(_color_blendA_rgba, _color_blendB_rgba, _color_blendB_rgba.a * _fade_blend_color); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/cartesianToPolar.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _cartesianToPolarFunc(vec2 _cartesian_vec2){ 2 | // (x, y) -> (r, theta) 3 | return vec2(length(_cartesian_vec2), atan(_cartesian_vec2.y, _cartesian_vec2.x)); 4 | } 5 | -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/polarToCartesian.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _polarToCartesianFunc(vec2 _polar_vec2){ 2 | // (r, theta) -> (x, y) 3 | return vec2(_polar_vec2.x * cos(_polar_vec2.y), 4 | _polar_vec2.x * sin(_polar_vec2.y)); 5 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/flipUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _flipUV(vec2 _flip_uv, vec2 _flip_vect) { 2 | _flip_uv.x = mix(_flip_uv.x, 1.0 - _flip_uv.x, _flip_vect.x); 3 | _flip_uv.y = mix(_flip_uv.y, 1.0 - _flip_uv.y, _flip_vect.y); 4 | return _flip_uv; 5 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/blackNwhite.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 blackNwhite(vec3 _input_rgb_color, float _threshold_color){ 2 | return vec3( ( (0.21 * _input_rgb_color.r + 0.71 * _input_rgb_color.g + 0.07 * _input_rgb_color.b) < _threshold_color) ? 0.0 : 1.0); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomFloat4D.gdshaderinc: -------------------------------------------------------------------------------- 1 | highp float _randFloat4D(vec4 input) { 2 | float f = dot(fract(input) + fract(input * 2.32184321231),vec4(129.898,782.33,944.32214932,122.2834234542)); 3 | return fract(sin(f) * 437588.5453); 4 | } 5 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/chekerboardPattern.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _checkerboardPatternFunc(vec2 uv, vec2 _checker_size){ 2 | float fmodRes = mod(floor(_checker_size.x * uv.x) + floor(_checker_size.y * uv.y), 2.0); 3 | return max(sign(fmodRes), 0.0); 4 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/bloom.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _bloomFunc(vec4 _col_bloom, float _strength_bloom){ 2 | float _gamma_bloom = 1.0 - pow(_col_bloom.r, _strength_bloom); 3 | _col_bloom.rgb += (_col_bloom.rgb * _col_bloom.a) * _strength_bloom; 4 | return _col_bloom; 5 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/grayscale.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _grayscaleFunc(vec3 _color_grayscale, float _gray_factor){ 2 | return _color_grayscale * (1.0 - _gray_factor) + (0.21 * _color_grayscale.r + 0.71 * _color_grayscale.g + 0.07 * _color_grayscale.b) * _gray_factor; 3 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/tonemap.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _tonemapFunc(vec3 _color_tonemap, float _exposure_tonemap, float _gamma_tonemap){ 2 | _color_tonemap.rgb *= pow(2.0, _exposure_tonemap); 3 | _color_tonemap.rgb = pow(_color_tonemap.rgb, vec3(_gamma_tonemap)); 4 | return _color_tonemap; 5 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/stripesRandom.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _generateRandomStripesFunc(vec2 _uv_stripes, float _fill_stripes, float _amount_stripes){ 2 | return 1.0 - step(_fill_stripes, fract(sin(dot(floor(vec2(_uv_stripes.y) * _amount_stripes), vec2(12.9898, 78.233))) * 43758.5453123)); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomGoldNoiseFloat.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _randomGoldRatioFunc(vec2 _coord_gn, vec2 _scale_gn, float _seed_gn){ 2 | float PHI = 1.6180339887; 3 | float SQ2 = 1.4142135624; 4 | return fract(tan(distance((_coord_gn + _scale_gn) * (_seed_gn + PHI), vec2(PHI, PI))) * SQ2); 5 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/tilingNoffset.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _tiling_and_offset(vec2 _tiling_and_offset_uv, vec2 _tiling_and_offset_offset_vect){ 2 | return vec2(mod(_tiling_and_offset_uv.x + _tiling_and_offset_offset_vect.x, 1.0), 3 | mod(_tiling_and_offset_uv.y + _tiling_and_offset_offset_vect.y, 1.0)); 4 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/scanLinesSharp.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _scanLinesSharpFunc(vec2 _uv_scLiShrp, float _amount_scLiShrp, float _fill_scLiShrp, float _spd_scLiShrp, float _time_scLiShrp) { 2 | return step(fract(_uv_scLiShrp.y * _amount_scLiShrp + _time_scLiShrp * _spd_scLiShrp), _fill_scLiShrp); 3 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/cartesianToSpherical.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _cartesianToSphericalFunc(vec3 _cartesian_vec3){ 2 | // (x, y, z) -> (r, theta, phi) 3 | return vec3(length(_cartesian_vec3), 4 | atan(_cartesian_vec3.y, _cartesian_vec3.x), 5 | atan(length(_cartesian_vec3.xy), _cartesian_vec3.z)); 6 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/colorCorrectionAdjustment.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _applyColorCorrectionFunc(vec3 _col_corr, sampler2D _tex_corr) { 2 | _col_corr.r = texture(_tex_corr, vec2(_col_corr.r, 0.0)).r; 3 | _col_corr.g = texture(_tex_corr, vec2(_col_corr.g, 0.0)).g; 4 | _col_corr.b = texture(_tex_corr, vec2(_col_corr.b, 0.0)).b; 5 | return _col_corr; 6 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/distortionUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _distortionUV(vec2 _distortion_uv, vec2 _distortion_vect, vec2 _distortion_wave_vect) { 2 | _distortion_uv.x += sin(_distortion_uv.y * _distortion_wave_vect.x) * _distortion_vect.x; 3 | _distortion_uv.y += sin(_distortion_uv.x * _distortion_wave_vect.y) * _distortion_vect.y; 4 | return _distortion_uv; 5 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/tilingNoffsetAnimated.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _tilingNoffsetAnimatedFunc(vec2 _tilingNoffset_uv, float _tilingNoffset_time, vec2 _tilingNoffset_offset_vect){ 2 | return vec2(mod((_tilingNoffset_uv.x + _tilingNoffset_offset_vect.x * _tilingNoffset_time), 1.0), 3 | mod((_tilingNoffset_uv.y + _tilingNoffset_offset_vect.y * _tilingNoffset_time), 1.0)); 4 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/sphericalToCartesian.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _sphericalToCartesianFunc(vec3 _spherical_vec3){ 2 | // (r, theta, phi) -> (x, y, z) 3 | return vec3(_spherical_vec3.x * sin(_spherical_vec3.z) * cos(_spherical_vec3.y), 4 | _spherical_vec3.x * sin(_spherical_vec3.z) * sin(_spherical_vec3.y), 5 | _spherical_vec3.x * cos(_spherical_vec3.z)); 6 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomFloatImproved.gdshaderinc: -------------------------------------------------------------------------------- 1 | highp float _randImproved(vec2 _co_rnd){ 2 | highp float _tmp_a_rnd = 12.9898; 3 | highp float _tmp_b_rnd = 78.233; 4 | highp float _tmp_c_rnd = 43758.5453; 5 | highp float _tmp_dt_rnd = dot(_co_rnd, vec2(_tmp_a_rnd, _tmp_b_rnd)); 6 | highp float _tmp_sn_rnd = mod(_tmp_dt_rnd, 3.14); 7 | return fract(sin(_tmp_sn_rnd) * _tmp_c_rnd); 8 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/distortionUVAnimated.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _distortionUVAnimatedFunc(vec2 _uv_dist, float _distX_dist, float _distY_dist, float _waveX_dist, float _waveY_dist, float _spd_dist, float _time_dist){ 2 | _uv_dist.x += sin(_uv_dist.y * _waveX_dist + _time_dist * _spd_dist) * _distX_dist; 3 | _uv_dist.y += sin(_uv_dist.x * _waveY_dist + _time_dist * _spd_dist) * _distY_dist; 4 | return _uv_dist; 5 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/tileUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _tileMapUV(vec2 _tile_uv, float _tile_width, float _tile_height, float _tile_number){ 2 | _tile_number = min(max(floor(_tile_number), 0.0), _tile_width * _tile_height - 1.0); 3 | vec2 tcrcp = vec2(1.0) / vec2(_tile_width, _tile_height); 4 | float ty =floor(_tile_number * tcrcp.x); 5 | float tx = _tile_number - _tile_width * ty; 6 | return (_tile_uv + vec2(tx, ty)) * tcrcp; 7 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateCircle2.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _generateCircle2Func(vec2 _uv_gc2, vec2 _pos_gc2, vec2 _scale_gc2, float _rad_gc2, 2 | float _bordIn_gc2, float _bordOut_gc2, vec4 _col_gc2){ 3 | float _dst_gc2 = length((_uv_gc2 - _pos_gc2) * _scale_gc2); 4 | _col_gc2.a *= smoothstep(_rad_gc2 - _bordIn_gc2, _rad_gc2, _dst_gc2) 5 | - smoothstep(_rad_gc2, _rad_gc2 + _bordOut_gc2, _dst_gc2); 6 | return _col_gc2; 7 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/gradient4corners.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _gradient4cornersFunc(vec2 _uv_corner, vec4 _top_left_corner, vec4 _top_right_corner, vec4 _bottom_left_corner, vec4 _bottom_right_corner){ 2 | vec4 _color_top_corner = mix(_top_left_corner, _top_right_corner, _uv_corner.x); 3 | vec4 _color_bottom_corner = mix(_bottom_left_corner, _bottom_right_corner, _uv_corner.x); 4 | return mix(_color_top_corner, _color_bottom_corner, _uv_corner.y); 5 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/gradientMapping.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _gradientMappingFunc(vec3 _col_base_gm, float _grad_offset, sampler2D _palette_gm, bool _use_col_cycle){ 2 | float avg_col = 0.2126 * _col_base_gm.r + 0.7152 * _col_base_gm.g + 0.0722 * _col_base_gm.b; 3 | if (_use_col_cycle){ 4 | return texture(_palette_gm, mod(vec2(avg_col + _grad_offset, 0), vec2(1.0))); 5 | } else{ 6 | return texture(_palette_gm, vec2(avg_col + _grad_offset, 0)); 7 | } 8 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/BCSAdjustment.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _applyBCS(vec3 _input_rgb_color, vec3 _brighntess_contrast_saturation_vec) { 2 | _input_rgb_color = mix(vec3(0.0), _input_rgb_color, _brighntess_contrast_saturation_vec.x); 3 | _input_rgb_color = mix(vec3(0.5), _input_rgb_color, _brighntess_contrast_saturation_vec.y); 4 | _input_rgb_color = mix(vec3(dot(vec3(1.0), _input_rgb_color) * 0.33333), _input_rgb_color, _brighntess_contrast_saturation_vec.z); 5 | return _input_rgb_color; 6 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/clamp.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _clampAlphaBorderFunc(float _color_alpha_clamp, vec2 _uv_clamp){ 2 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(_uv_clamp.x), 0.0)); 3 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(1.0 - _uv_clamp.x), 0.0)); 4 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(_uv_clamp.y), 0.0)); 5 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(1.0 - _uv_clamp.y), 0.0)); 6 | return _color_alpha_clamp; 7 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/swirlUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _swirlUVFunc(vec2 _swirl_uv, float _swirl_time, vec2 _swirl_pivot, float _swirl_amount){ 2 | float _swirl_rotation_index = _swirl_amount * length(_swirl_uv - _swirl_pivot) * _swirl_time; 3 | _swirl_uv -= _swirl_pivot; 4 | _swirl_uv *= mat2(vec2(cos(_swirl_rotation_index), - sin(_swirl_rotation_index)), 5 | vec2(sin(_swirl_rotation_index), cos(_swirl_rotation_index))); 6 | _swirl_uv += _swirl_pivot; 7 | return _swirl_uv; 8 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/twirl.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _twirlUVFunc(vec2 _uv_twirlUVFunc, vec2 _pivot_twirlUVFunc, float _amount_twirlUVFunc){ 2 | _uv_twirlUVFunc -= _pivot_twirlUVFunc; 3 | float _angle_twirlUVFunc = atan(_uv_twirlUVFunc.y, _uv_twirlUVFunc.x); 4 | float _radiusTemp_twirlUVFunc = length(_uv_twirlUVFunc); 5 | _angle_twirlUVFunc += _radiusTemp_twirlUVFunc * _amount_twirlUVFunc; 6 | return vec3(_radiusTemp_twirlUVFunc * vec2(cos(_angle_twirlUVFunc), sin(_angle_twirlUVFunc)) + 0.5, 0.0); 7 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/rotate.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _rotateUV(vec3 _rotate_uv, vec2 _rotate_pivot_vect, float _rotate_radians){ 2 | //_r0tation_r0tate = radians(_r0tationDeg_r0tate); 3 | vec2 _rotation_angle = vec2(cos(_rotate_radians), sin(_rotate_radians)); 4 | _rotate_uv.xy -= _rotate_pivot_vect; 5 | _rotate_uv.xy = vec2((_rotate_uv.x*_rotation_angle.x-_rotate_uv.y*_rotation_angle.y), 6 | (_rotate_uv.x*_rotation_angle.y+_rotate_uv.y*_rotation_angle.x)); 7 | _rotate_uv.xy += _rotate_pivot_vect; 8 | return _rotate_uv; 9 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateSpiral.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _generateSpiralFunc(vec2 _uv_genSpir, vec2 _pivot_genSpir, float _size_genSpir, float _lineAmnt_genSpir, 2 | float _spd_genSpir, float _soft_genSpir, float _t1me_genSpir, vec4 _col_genSpir){ 3 | _uv_genSpir -= _pivot_genSpir; 4 | float _va1ue_genSpir = 1.0 - sin(length(_uv_genSpir) * _size_genSpir + 5 | floor(_lineAmnt_genSpir) * atan(_uv_genSpir.x, _uv_genSpir.y) + 6 | _t1me_genSpir * _spd_genSpir ) / _soft_genSpir; 7 | return vec4(_col_genSpir.rgb, _col_genSpir.a * _va1ue_genSpir); 8 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/lensDistortion.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _lensDistortionUV(vec2 _lens_uv, float _lens_factor){ 2 | vec2 _pos_dist_lens = _lens_uv - 0.5; 3 | float _d1st_d1s_1en5 = length(_pos_dist_lens); 4 | if (_lens_factor > 0.0) // fisheye / barrel 5 | _lens_uv = vec2(0.5)+normalize(_pos_dist_lens)*tan(_d1st_d1s_1en5*_lens_factor)*0.70711/tan(0.70711*_lens_factor); 6 | else if (_lens_factor < 0.0) // antifisheye / pincushion 7 | _lens_uv = vec2(0.5)+normalize(_pos_dist_lens)*atan(_d1st_d1s_1en5*-_lens_factor*10.0)*0.5/atan(-_lens_factor*0.5*10.0); 8 | return _lens_uv; 9 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/gridShape.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _gridFunc(vec2 _grid_uv, vec2 _gridline_thickness, vec2 _gridline_smooth, vec2 _gridcell_count, vec4 _grid_col, vec4 _grid_bg_col){ 2 | vec2 _grid_vec = fract(_grid_uv * _gridcell_count); 3 | _grid_vec = min(_grid_vec, vec2(1.0) - _grid_vec); 4 | _grid_vec = smoothstep(_grid_vec - _gridline_smooth, _grid_vec + _gridline_smooth, _gridline_thickness / vec2(2.0)); 5 | // return mix(_grid_bg_col, _grid_col, clamp(_grid_vec.x + _grid_vec.y, 0.0, 1.0)); 6 | return mix(_grid_bg_col, _grid_col, (_grid_vec.x + _grid_vec.y)); 7 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/rotateAnimated.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _rotateUVAnimatedFunc(vec2 _uv_rotate, vec2 _pivot_rotate, float _rotation_rotate, float _rotSpeed_rotate, float _time_rotate){ 2 | _rotation_rotate += _time_rotate * _rotSpeed_rotate; 3 | //_rotation_rotate = radians(_rotationDeg_rotate); 4 | vec2 _rotAngle = vec2(cos(_rotation_rotate), sin(_rotation_rotate)); 5 | _uv_rotate -= _pivot_rotate; 6 | _uv_rotate = vec2((_uv_rotate.x*_rotAngle.x-_uv_rotate.y*_rotAngle.y),(_uv_rotate.x*_rotAngle.y+_uv_rotate.y*_rotAngle.x)); 7 | _uv_rotate += _pivot_rotate; 8 | return _uv_rotate; 9 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/sphericalUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _sphericalUV(vec2 _spherical_uv, vec2 _spherical_position_vect, vec2 _spherical_radius_vect, vec2 _spherical_spin_vect, vec2 _spherical_local_position_vect){ 2 | vec2 _temp_p = (_spherical_uv - _spherical_position_vect) * 2.0; 3 | float _temp_rad = length((_temp_p - _spherical_local_position_vect) * _spherical_radius_vect) + 0.0001; 4 | float _temp_f = (1.0 - sqrt(1.0 - _temp_rad)) / _temp_rad; 5 | return mod(vec2((_temp_p.x * 0.5 * _temp_f + _spherical_spin_vect.x) + 0.5, 6 | (_temp_p.y * 0.5 * _temp_f + _spherical_spin_vect.y) + 0.5), vec2(1.0)); 7 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/transformUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _transformUV(vec2 _uv_transform, vec2 _scale_uv_, vec2 _pivot_scale_uv_, vec2 _offset_uv_, float _rotate_uv, vec2 _pivot_rotate_uv_){ 2 | _uv_transform -= _offset_uv_; // offset 3 | _uv_transform = (_uv_transform - _pivot_scale_uv_) * _scale_uv_ + _pivot_scale_uv_; // zoom 4 | vec2 _rot_uv_angl = vec2(cos(_rotate_uv), sin(_rotate_uv)); 5 | mat2 _rot_matrix = mat2(vec2(_rot_uv_angl.x, - _rot_uv_angl.y), vec2(_rot_uv_angl.y, _rot_uv_angl.x)); 6 | _uv_transform = (_uv_transform - _pivot_rotate_uv_) * _rot_matrix + _pivot_rotate_uv_; // rotate 7 | return _uv_transform; 8 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/turnCGA4Palette.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _cg4PaletteFunc(vec3 _col_cga, float _gamma_cga){ 2 | _col_cga = pow(_col_cga, vec3(_gamma_cga)); 3 | float _gray_col_cga4 = 0.21 * _col_cga.r + 0.71 * _col_cga.g + 0.07 * _col_cga.b; 4 | vec3 _res_col_cga4 = vec3(0.0); 5 | 6 | if (_gray_col_cga4 <= 1.0/4.0) 7 | _res_col_cga4 = vec3(0.0, 0.0, 0.0); 8 | else if (_gray_col_cga4 <= 2.0/4.0) 9 | _res_col_cga4 = vec3(1.0, 0.33, 1.0); 10 | else if (_gray_col_cga4 <= 3.0/4.0) 11 | _res_col_cga4 = vec3(0.33, 1.0, 1.0); 12 | else if (_gray_col_cga4 <= 4.0/4.0) 13 | _res_col_cga4 = vec3(1.0, 1.0, 1.0); 14 | 15 | return _res_col_cga4; 16 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/turnGBPalette.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _gameboyPaletteFunc(vec3 _col_gbp0, float _gamma_gbp0){ 2 | _col_gbp0 = pow(_col_gbp0, vec3(_gamma_gbp0)); 3 | float _gray_col_gbp0 = 0.21 * _col_gbp0.r + 0.71 * _col_gbp0.g + 0.07 * _col_gbp0.b; 4 | vec3 _res_col_gbp0 = vec3(0.0); 5 | 6 | if (_gray_col_gbp0 <= 1.0/4.0) 7 | _res_col_gbp0 = vec3(0.063, 0.247, 0.063); 8 | else if (_gray_col_gbp0 <= 2.0/4.0) 9 | _res_col_gbp0 = vec3(0.188, 0.392, 0.188); 10 | else if (_gray_col_gbp0 <= 3.0/4.0) 11 | _res_col_gbp0 = vec3(0.549, 0.667, 0.078); 12 | else if (_gray_col_gbp0 <= 4.0/4.0) 13 | _res_col_gbp0 = vec3(0.612, 0.725, 0.086); 14 | 15 | return _res_col_gbp0; 16 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/emboss.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _embossFunc(sampler2D _tex_emboss, vec2 _uv_emboss, float _lod_emboss, vec2 _ofst_emboss, float _ctst_emboss){ 2 | vec4 col_emboss = vec4(0.5, 0.5, 0.5, 0.5); 3 | if (_lod_emboss < 0.0){ 4 | col_emboss -= texture(_tex_emboss, _uv_emboss - _ofst_emboss) * _ctst_emboss; 5 | col_emboss += texture(_tex_emboss, _uv_emboss + _ofst_emboss) * _ctst_emboss; 6 | }else{ 7 | col_emboss -= textureLod(_tex_emboss, _uv_emboss - _ofst_emboss, _lod_emboss) * _ctst_emboss; 8 | col_emboss += textureLod(_tex_emboss, _uv_emboss + _ofst_emboss, _lod_emboss) * _ctst_emboss; 9 | } 10 | col_emboss.rgb = vec3(0.21 * col_emboss.r + 0.71 * col_emboss.g + 0.07 * col_emboss.b); 11 | return col_emboss; 12 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/shineFX.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _shineFunc(vec4 _color_shine, vec2 _uv_shine, float _loc_shine, float _rot_shine, float _width_shine, float _soft_shine, float _bright_shine, float _gloss_shine, vec3 _shine_color_shine){ 2 | vec2 _angle_shine = vec2(cos(_rot_shine), sin(_rot_shine)); 3 | float _norm_pos_shine = dot(_uv_shine, _angle_shine); 4 | float _normal_shine = 1.0 - abs((_norm_pos_shine - _loc_shine) / _width_shine); 5 | float _shine_power_shine = smoothstep(0.0, _soft_shine * 2.0, _normal_shine); 6 | vec3 _reflect_color_shine = mix(vec3(1.0), _color_shine.rgb * 10.0, _gloss_shine); 7 | _color_shine.rgb += _color_shine.a * _shine_power_shine * _bright_shine * _reflect_color_shine * _shine_color_shine.rgb; 8 | return _color_shine; 9 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/blurCustom.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _blurWithAmountFunc(sampler2D _tex_blur_cst, vec2 _uv_blur_cst, float _l0d_blur_cst, int _amnt_blur_cst, float _0ffst_blur_cst) { 2 | vec4 _c0l_blur_cst = vec4(0, 0, 0, 0); 3 | 4 | for(int x = -_amnt_blur_cst; x <= _amnt_blur_cst; x++) { 5 | for(int y = -_amnt_blur_cst; y <= _amnt_blur_cst; y++) { 6 | vec2 _c00rd_blur_cst = _uv_blur_cst + vec2(float(x), float(y)) * _0ffst_blur_cst; 7 | if (_l0d_blur_cst < 0.0){ 8 | _c0l_blur_cst += texture(_tex_blur_cst, _c00rd_blur_cst); 9 | }else{ 10 | _c0l_blur_cst += textureLod(_tex_blur_cst, _c00rd_blur_cst, _l0d_blur_cst); 11 | } 12 | } 13 | } 14 | int _nmb_ne1ghb0urs_blur_cst = (_amnt_blur_cst * 2 + 1) * (_amnt_blur_cst * 2 + 1); 15 | _c0l_blur_cst /= float(_nmb_ne1ghb0urs_blur_cst); 16 | return _c0l_blur_cst; 17 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateCircle.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _generateCircleFunc(vec2 _uv_circle, vec2 _center_circle, vec2 _scale_factor_circle, float _innerRad_circle, float _outRad_circle, float _hard_circle) { 2 | float _innerRadiusCheck0 = min(_innerRad_circle, _outRad_circle); 3 | float _outerRadiusCheck0 = max(_innerRad_circle, _outRad_circle); 4 | 5 | float currentPositionCircle = length((_uv_circle - _center_circle) * _scale_factor_circle); 6 | float maxIntencityCenterCircle = (_outerRadiusCheck0 + _innerRadiusCheck0) * 0.5; 7 | float rd0 = _outerRadiusCheck0 - maxIntencityCenterCircle; 8 | float circleDistribution = min(max(abs(currentPositionCircle - maxIntencityCenterCircle) / rd0, 0.0), 1.0); 9 | vec4 _outputColor0 = vec4(1.0); 10 | _outputColor0.a = 1.0 - pow(circleDistribution, _hard_circle); 11 | return _outputColor0; 12 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateRegularNgon.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _polygonFunc(vec2 _uv_polygon, vec2 _pos_polygon, vec2 _size_polygon, float _sides_polygon, float _angle_polygon, float _smooth_polygon){ 2 | _uv_polygon = (_uv_polygon - _pos_polygon) / (_size_polygon * 2.0); 3 | float a_polygon = atan(_uv_polygon.x, _uv_polygon.y) + _angle_polygon; 4 | float r_polygon = 6.28318530718 / float(int(max(_sides_polygon, 3.0))); 5 | float d_polygon = cos(floor(0.5 + a_polygon / r_polygon) * r_polygon - a_polygon) * length(_uv_polygon); 6 | return (max(sign(_smooth_polygon - 0.0), 0.0) * ( 1.0 - smoothstep(0.1 - 0.0001, 0.1 + _smooth_polygon, d_polygon) ) + 7 | (max(sign(-_smooth_polygon + 0.0), 0.0)) * ( 1.0 - smoothstep(0.1 + _smooth_polygon - 0.0001, 0.1, d_polygon) ) + 8 | (1.0 - abs(sign(_smooth_polygon - 0.0))) * ( 1.0 - step(0.1, d_polygon)) ); 9 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/shiftHSV.gdshaderinc: -------------------------------------------------------------------------------- 1 | 2 | vec3 _hsvChangeHSVChangeFunc(vec3 _color_HSVChange, float _h_HSVChange, float _s_HSVChange, float _v_HSVChange){ 3 | // RGB2HSV 4 | vec3 c = _color_HSVChange; 5 | vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); 6 | vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g)); 7 | vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r)); 8 | float d = q.x - min(q.w, q.y); 9 | float e = 1.0e-10; 10 | c = vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x); 11 | 12 | c.r += _h_HSVChange; 13 | c.g *= _s_HSVChange; 14 | c.b *= _v_HSVChange; 15 | float hue = c.r + _h_HSVChange; 16 | c.x = (hue < 0.0) ? hue + 1.0 : ((hue > 1.0) ? hue - 1.0 : hue); 17 | 18 | // HSV2RGB 19 | K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 20 | vec3 p2 = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 21 | c = c.z * mix(K.xxx, clamp(p2 - K.xxx, 0.0, 1.0), c.y); 22 | 23 | return c; 24 | } 25 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/generic2d.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _hash2_generic2D(vec2 _p_hash2_generic) { 2 | return (fract(1e4 * sin(17.0 * _p_hash2_generic.x + _p_hash2_generic.y * 0.1) * 3 | (0.1 + abs(sin(_p_hash2_generic.y * 13.0 + _p_hash2_generic.x))))); 4 | } 5 | 6 | float _genericNoise2D(vec2 _x_generic2D) { 7 | vec2 _temp_i_generic2D = floor(_x_generic2D); 8 | vec2 _temp_f_generic2D = fract(_x_generic2D); 9 | 10 | float _a_g1n2 = _hash2_generic2D(_temp_i_generic2D); 11 | float _b_g1n2 = _hash2_generic2D(_temp_i_generic2D + vec2(1.0, 0.0)); 12 | float _c_g1n2 = _hash2_generic2D(_temp_i_generic2D + vec2(0.0, 1.0)); 13 | float _d_g1n2 = _hash2_generic2D(_temp_i_generic2D + vec2(1.0, 1.0)); 14 | 15 | vec2 _u_g1n2 = _temp_f_generic2D * _temp_f_generic2D * (3.0 - 2.0 * _temp_f_generic2D); 16 | return (mix(_a_g1n2, _b_g1n2, _u_g1n2.x) + (_c_g1n2 - _a_g1n2) * 17 | _u_g1n2.y * (1.0 - _u_g1n2.x) + (_d_g1n2 - _b_g1n2) * _u_g1n2.x * _u_g1n2.y); 18 | } -------------------------------------------------------------------------------- /addons/shaderV/shaderV_icon.png.import: -------------------------------------------------------------------------------- 1 | [remap] 2 | 3 | importer="texture" 4 | type="CompressedTexture2D" 5 | uid="uid://dukgbairam5vc" 6 | path="res://.godot/imported/shaderV_icon.png-5ba8dda3dde1d4196a25cb0adc8c8652.ctex" 7 | metadata={ 8 | "vram_texture": false 9 | } 10 | 11 | [deps] 12 | 13 | source_file="res://addons/shaderV/shaderV_icon.png" 14 | dest_files=["res://.godot/imported/shaderV_icon.png-5ba8dda3dde1d4196a25cb0adc8c8652.ctex"] 15 | 16 | [params] 17 | 18 | compress/mode=0 19 | compress/high_quality=true 20 | compress/lossy_quality=0.7 21 | compress/hdr_compression=1 22 | compress/normal_map=0 23 | compress/channel_pack=0 24 | mipmaps/generate=true 25 | mipmaps/limit=-1 26 | roughness/mode=0 27 | roughness/src_normal="" 28 | process/fix_alpha_border=true 29 | process/premult_alpha=false 30 | process/normal_map_invert_y=false 31 | process/hdr_as_srgb=false 32 | process/hdr_clamp_exposure=false 33 | process/size_limit=0 34 | detect_3d/compress_to=0 35 | -------------------------------------------------------------------------------- /addons/shaderV/examples/godot_logo.png.import: -------------------------------------------------------------------------------- 1 | [remap] 2 | 3 | importer="texture" 4 | type="CompressedTexture2D" 5 | uid="uid://ds4rnuhypjs8a" 6 | path="res://.godot/imported/godot_logo.png-89258be532bb292e475149e3c00d215d.ctex" 7 | metadata={ 8 | "vram_texture": false 9 | } 10 | 11 | [deps] 12 | 13 | source_file="res://addons/shaderV/examples/godot_logo.png" 14 | dest_files=["res://.godot/imported/godot_logo.png-89258be532bb292e475149e3c00d215d.ctex"] 15 | 16 | [params] 17 | 18 | compress/mode=0 19 | compress/high_quality=false 20 | compress/lossy_quality=0.7 21 | compress/hdr_compression=1 22 | compress/normal_map=0 23 | compress/channel_pack=0 24 | mipmaps/generate=true 25 | mipmaps/limit=-1 26 | roughness/mode=0 27 | roughness/src_normal="" 28 | process/fix_alpha_border=true 29 | process/premult_alpha=false 30 | process/normal_map_invert_y=false 31 | process/hdr_as_srgb=false 32 | process/hdr_clamp_exposure=false 33 | process/size_limit=0 34 | detect_3d/compress_to=0 35 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/zoomBlur.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _zoomBlurFunc(sampler2D _tex_zoom_blur, vec2 _uv_zoom_blur, int _amount_zoom_blur, vec2 _center_zoom, float _lgt_zoom_blur, float _lod_zoom_blur){ 2 | vec4 _col_zoom_blur; 3 | if (_lod_zoom_blur < 0.0){ 4 | _col_zoom_blur = texture(_tex_zoom_blur, _uv_zoom_blur); 5 | for (int i = 1; i <= _amount_zoom_blur; i++){ 6 | float _temp_d_zoom_blur = _lgt_zoom_blur * float(i); 7 | vec2 px = _uv_zoom_blur * (1.0 - _temp_d_zoom_blur) + _center_zoom * _temp_d_zoom_blur; 8 | _col_zoom_blur += texture(_tex_zoom_blur, px); 9 | } 10 | }else{ 11 | _col_zoom_blur = textureLod(_tex_zoom_blur, _uv_zoom_blur, _lod_zoom_blur); 12 | for (int i = 1; i <= _amount_zoom_blur; i++){ 13 | float _temp_d_zoom_blur = _lgt_zoom_blur * float(i); 14 | vec2 px = _uv_zoom_blur * (1.0 - _temp_d_zoom_blur) + _center_zoom * _temp_d_zoom_blur; 15 | _col_zoom_blur += textureLod(_tex_zoom_blur, px, _lod_zoom_blur); 16 | } 17 | } 18 | _col_zoom_blur = _col_zoom_blur / float(_amount_zoom_blur + 1); 19 | return _col_zoom_blur; 20 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/doodleUV.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _hash2Doodle(vec2 _p_hash_doodle) { 2 | return fract(1e4 * sin(17.0 * _p_hash_doodle.x + _p_hash_doodle.y * 0.1) * (0.1 + abs(sin(_p_hash_doodle.y * 13.0 + _p_hash_doodle.x)))); 3 | } 4 | 5 | float _noiseDoodle(vec2 _seed_noise_doodle){ 6 | vec2 i = floor(_seed_noise_doodle); 7 | vec2 f = fract(_seed_noise_doodle); 8 | float _a = _hash2Doodle(i); 9 | float _b = _hash2Doodle(i + vec2(1.0, 0.0)); 10 | float _c = _hash2Doodle(i + vec2(0.0, 1.0)); 11 | float _d = _hash2Doodle(i + vec2(1.0, 1.0)); 12 | vec2 u = f * f * (3.0 - 2.0 * f); 13 | return mix(_a, _b, u.x) + (_c - _a) * u.y * (1.0 - u.x) + (_d - _b) * u.x * u.y; 14 | } 15 | 16 | vec2 _doodleUVFunc(vec2 _doodle_uv, float _doodle_max_offset, float _doodle_time, float _doodle_frame_time, int _doodle_frame_count, float _doodle_scale){ 17 | float _timeValueDoodle = mod(floor(_doodle_time / _doodle_frame_time), float(_doodle_frame_count)) + 1.0; 18 | return _doodle_uv + vec2(_noiseDoodle((_doodle_uv + _timeValueDoodle) * _doodle_scale) * 2.0 - 1.0) * _doodle_max_offset; 19 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/hash1d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsHash 4 | 5 | func _get_name() -> String: 6 | return "HashRandom1d" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | func _get_subcategory() -> String: 12 | return "Random" 13 | 14 | func _get_description() -> String: 15 | return "Hash func with scalar input and scalar output" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 1 22 | 23 | func _get_input_port_name(port: int) -> String: 24 | return "in" 25 | 26 | func _get_input_port_type(port): 27 | return VisualShaderNode.PORT_TYPE_SCALAR 28 | 29 | func _get_output_port_count() -> int: 30 | return 1 31 | 32 | func _get_output_port_name(port: int) -> String: 33 | return "rand" 34 | 35 | func _get_output_port_type(port): 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_code(input_vars, output_vars, mode, type): 39 | return output_vars[0] + " = fract(sin(" + input_vars[0] + ") * 1e4);" 40 | 41 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2x2.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _cellular2x2NoiseFunc(vec2 P, float _jitter_w2x2) { 2 | float K = 0.142857142857; // 1/7 3 | float K2 = 0.0714285714285; // K/2 4 | 5 | vec2 Pi = floor(P) - floor(floor(P) * (1.0 / 289.0)) * 289.0; 6 | vec2 Pf = fract(P); 7 | vec4 Pfx = Pf.x + vec4(-0.5, -1.5, -0.5, -1.5); 8 | vec4 Pfy = Pf.y + vec4(-0.5, -0.5, -1.5, -1.5); 9 | vec4 p = ((34.0*(Pi.x + vec4(0.0, 1.0, 0.0, 1.0))+1.0)*(Pi.x + vec4(0.0, 1.0, 0.0, 1.0)))-floor(((34.0*(Pi.x + vec4(0.0, 1.0, 0.0, 1.0))+1.0)*(Pi.x + vec4(0.0, 1.0, 0.0, 1.0)))*(1.0/289.0))*289.0; 10 | p = ((34.0*(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0))+1.0)*(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0)))-floor(((34.0*(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0))+1.0)*(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0)))*(1.0/289.0))*289.0; 11 | vec4 ox = (p - floor(p * (1.0 / 7.0)) * 7.0)*K+K2; 12 | vec4 oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0)*K+K2; 13 | vec4 dx = Pfx + _jitter_w2x2*ox; 14 | vec4 dy = Pfy + _jitter_w2x2*oy; 15 | vec4 d = dx * dx + dy * dy; 16 | d.xy = min(d.xy, d.zw); 17 | d.x = min(d.x, d.y); 18 | return sqrt(d.x); 19 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/TimeScaled.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsTIMEscaled 4 | 5 | func _init(): 6 | set_input_port_default_value(0, 1.0) 7 | 8 | func _get_name() -> String: 9 | return "ScaledTIME" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Returns [scale] * TIME" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_SCALAR 22 | 23 | func _get_input_port_count() -> int: 24 | return 1 25 | 26 | func _get_input_port_name(port: int) -> String: 27 | return "scale" 28 | 29 | func _get_input_port_type(port): 30 | return VisualShaderNode.PORT_TYPE_SCALAR 31 | 32 | func _get_output_port_count() -> int: 33 | return 1 34 | 35 | func _get_output_port_name(port: int) -> String: 36 | return "out" 37 | 38 | func _get_output_port_type(port): 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 41 | func _get_code(input_vars, output_vars, mode, type): 42 | return "%s = %s * TIME;" % [output_vars[0], input_vars[0]] 43 | -------------------------------------------------------------------------------- /addons/shaderV/tools/relay.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRelay 4 | 5 | # Almost completely useless node xD 6 | 7 | func _get_name() -> String: 8 | return "Relay" 9 | 10 | func _get_category() -> String: 11 | return "Tools" 12 | 13 | #func _get_subcategory(): 14 | # return "" 15 | 16 | func _get_description() -> String: 17 | return "Outputs its input, may be useful for organizing node connections. Works with booleans, vectors and scalars. Also can be used as preview node" 18 | 19 | func _get_return_icon_type(): 20 | return VisualShaderNode.PORT_TYPE_MAX 21 | 22 | func _get_input_port_count() -> int: 23 | return 1 24 | 25 | func _get_input_port_name(port: int) -> String: 26 | return "i" 27 | 28 | func _get_input_port_type(port): 29 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 30 | 31 | func _get_output_port_count() -> int: 32 | return 1 33 | 34 | func _get_output_port_name(port: int) -> String: 35 | return "o" 36 | 37 | func _get_output_port_type(port): 38 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 39 | 40 | func _get_code(input_vars, output_vars, mode, type): 41 | return output_vars[0] + " = " + input_vars[0] 42 | 43 | -------------------------------------------------------------------------------- /addons/shaderV/tools/random/hash2d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsHash2D 4 | 5 | func _get_name() -> String: 6 | return "HashRandom2d" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | func _get_subcategory() -> String: 12 | return "Random" 13 | 14 | func _get_description() -> String: 15 | return "Hash func with vector input and scalar output" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 1 22 | 23 | func _get_input_port_name(port: int) -> String: 24 | return "in" 25 | 26 | func _get_input_port_type(port): 27 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 28 | 29 | func _get_output_port_count() -> int: 30 | return 1 31 | 32 | func _get_output_port_name(port ) -> String: 33 | return "rand" 34 | 35 | func _get_output_port_type(port): 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_code(input_vars, output_vars, mode, type): 39 | return output_vars[0] + " = fract(1e4 * sin(17.0 * %s.x + %s.y * 0.1) * (0.1 + abs(sin(%s.y * 13.0 + %s.x))));" % [ 40 | input_vars[0], input_vars[0], input_vars[0], input_vars[0]] 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex2d.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _permute_simplex2_noise(vec3 x) { 2 | return ((x*34.0)+1.0)*x-floor(((x*34.0)+1.0)*x*(1.0/289.0))*289.0; 3 | } 4 | 5 | float _simplex2dNoiseFunc(vec2 v) { 6 | vec4 C = vec4(0.211324865405187, 7 | 0.366025403784439, 8 | -0.577350269189626, 9 | 0.024390243902439); 10 | 11 | vec2 i = floor(v + dot(v, C.yy) ); 12 | vec2 x0 = v - i + dot(i, C.xx); 13 | 14 | vec2 i1; 15 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 16 | vec4 x12 = vec4(x0.xy, x0.xy) + C.xxzz; 17 | x12.xy -= i1; 18 | 19 | i = i - floor(i * (1.0 / 289.0)) * 289.0; 20 | vec3 p = _permute_simplex2_noise(_permute_simplex2_noise(i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0)); 21 | 22 | vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), vec3(0.0)); 23 | m = m * m; 24 | m = m * m; 25 | 26 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 27 | vec3 h = abs(x) - 0.5; 28 | vec3 ox = floor(x + 0.5); 29 | vec3 a0 = x - ox; 30 | 31 | m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h); 32 | 33 | vec3 g; 34 | g.x = a0.x * x0.x + h.x * x0.y; 35 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 36 | return (130.0 * dot(m, g) + 1.0) * 0.5; 37 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/chromaticAberration.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _chromaticAberrationFunc(sampler2D _texture_chr_aberration, vec2 _uv_chr_aberration, vec3 _values_chr_aberration){ 2 | vec4 _col_chr_aberration = vec4(0.0); 3 | if (_values_chr_aberration.z < 0.0){ 4 | _col_chr_aberration.r = texture(_texture_chr_aberration, _uv_chr_aberration + _values_chr_aberration.xy).r; 5 | _col_chr_aberration.g = texture(_texture_chr_aberration, _uv_chr_aberration).g; 6 | _col_chr_aberration.b = texture(_texture_chr_aberration, _uv_chr_aberration - _values_chr_aberration.xy).b; 7 | _col_chr_aberration.a = texture(_texture_chr_aberration, _uv_chr_aberration).a; 8 | }else{ 9 | _col_chr_aberration.r = textureLod(_texture_chr_aberration, _uv_chr_aberration + 10 | _values_chr_aberration.xy, _values_chr_aberration.z).r; 11 | _col_chr_aberration.g = textureLod(_texture_chr_aberration, _uv_chr_aberration, _values_chr_aberration.z).g; 12 | _col_chr_aberration.b = textureLod(_texture_chr_aberration, _uv_chr_aberration - 13 | _values_chr_aberration.xy, _values_chr_aberration.z).b; 14 | _col_chr_aberration.a = textureLod(_texture_chr_aberration, _uv_chr_aberration, _values_chr_aberration.z).a; 15 | } 16 | return _col_chr_aberration; 17 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/hue.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAhue 4 | 5 | func _get_name() -> String: 6 | return "Hue" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Outputs an RGB color given a HUE" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 19 | 20 | func _get_input_port_count() -> int: 21 | return 1 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "inp" 27 | 28 | func _get_input_port_type(port: int): 29 | match port: 30 | 0: 31 | return VisualShaderNode.PORT_TYPE_SCALAR 32 | 33 | func _get_output_port_count() -> int: 34 | return 1 35 | 36 | func _get_output_port_name(port: int) -> String: 37 | return "col" 38 | 39 | func _get_output_port_type(port): 40 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 41 | 42 | func _get_global_code(mode): 43 | var path = self.get_script().get_path().get_base_dir() 44 | return '#include "' + path + '/hue.gdshaderinc"' 45 | 46 | func _get_code(input_vars, output_vars, mode, type): 47 | return "%s = _hueFunc(%s);" % [output_vars[0], input_vars[0]] 48 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/normalFromHeightmap.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _normalFromHeightmapFunc(vec2 _hm_uv, sampler2D _hm_tex, vec2 _hm_size, float _norm_hm_strgth, bool _conv_hm_gray, bool _inv_x_norm, bool _inv_y_norm){ 2 | vec3 _hm_down = textureLod(_hm_tex, _hm_uv + vec2(0.0, 1.0 / _hm_size.y), 0.0).rgb; 3 | vec3 _hm_up = textureLod(_hm_tex, _hm_uv - vec2(0.0, 1.0 / _hm_size.y), 0.0).rgb; 4 | vec3 _hm_right = textureLod(_hm_tex, _hm_uv + vec2(1.0 / _hm_size.x, 0.0), 0.0).rgb; 5 | vec3 _hm_left = textureLod(_hm_tex, _hm_uv - vec2(1.0 / _hm_size.x, 0.0), 0.0).rgb; 6 | 7 | if (_conv_hm_gray) { 8 | _hm_down.r = 0.2126 * _hm_down.r + 0.7152 * _hm_down.g + 0.0722 * _hm_down.b; 9 | _hm_up.r = 0.2126 * _hm_up.r + 0.7152 * _hm_up.g + 0.0722 * _hm_up.b; 10 | _hm_right.r = 0.2126 * _hm_right.r + 0.7152 * _hm_right.g + 0.0722 * _hm_right.b; 11 | _hm_left.r = 0.2126 * _hm_left.r + 0.7152 * _hm_left.g + 0.0722 * _hm_left.b; 12 | } 13 | 14 | float dx = (1.0 - float(_inv_x_norm)) * (_hm_left.r - _hm_right.r) + 15 | (float(_inv_x_norm)) * (-_hm_left.r + _hm_right.r); 16 | float dy = (1.0 - float(_inv_y_norm)) * (_hm_up.r - _hm_down.r) + 17 | (float(_inv_y_norm)) * (-_hm_up.r + _hm_down.r); 18 | 19 | return normalize(vec3(dx, dy, 1.0 / _norm_hm_strgth)); 20 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/hash2dvector.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsHash2Dvec 4 | 5 | func _get_name() -> String: 6 | return "HashRandom2dVec" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | func _get_subcategory() -> String: 12 | return "Random" 13 | 14 | func _get_description() -> String: 15 | return "Hash func with vector input and vector output" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 19 | 20 | func _get_input_port_count() -> int: 21 | return 1 22 | 23 | func _get_input_port_name(port: int) -> String: 24 | return "in" 25 | 26 | func _get_input_port_type(port): 27 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 28 | 29 | func _get_output_port_count() -> int: 30 | return 1 31 | 32 | func _get_output_port_name(port ) -> String: 33 | return "vec" 34 | 35 | func _get_output_port_type(port): 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 38 | func _get_global_code(mode): 39 | var path = self.get_script().get_path().get_base_dir() 40 | return '#include "' + path + '/hash2dvector.gdshaderinc"' 41 | 42 | func _get_code(input_vars, output_vars, mode, type): 43 | return "%s = vec3(_hash2v(%s.xy), 0.0);" % [output_vars[0], input_vars[0]] 44 | -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomFloat.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloat 4 | 5 | func _init(): 6 | pass 7 | 8 | func _get_name() -> String: 9 | return "RandomFloat" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | func _get_subcategory() -> String: 15 | return "Random" 16 | 17 | func _get_description() -> String: 18 | return "Returns random float based on input value. UV is default input value." 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_SCALAR 22 | 23 | func _get_input_port_count() -> int: 24 | return 1 25 | 26 | func _get_input_port_name(port: int) -> String: 27 | return "in" 28 | 29 | func _get_input_port_type(port): 30 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 31 | 32 | func _get_output_port_count() -> int: 33 | return 1 34 | 35 | func _get_output_port_name(port: int) -> String: 36 | return "rand" 37 | 38 | func _get_output_port_type(port): 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 41 | func _get_code(input_vars, output_vars, mode, type): 42 | var uv = "UV" 43 | 44 | if input_vars[0]: 45 | uv = input_vars[0] 46 | 47 | return output_vars[0] + " = fract(sin(dot(%s.xy, vec2(12.9898, 78.233))) * 43758.5453123);" % uv 48 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/innerGlow.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _innerGlowFunc(sampler2D _samp_inglow, vec2 _uv_inglow, float _l0d_inglow, float _rad_inglow, float _intns_inglow, vec4 _col_inglow){ 2 | _rad_inglow = abs(_rad_inglow); 3 | 4 | vec4 _color_inglow = vec4(0.0); 5 | float _alpha_inv = 0.0; 6 | float _alpha_inglow_b1 = 0.0; 7 | int _amount_inglow = 3; 8 | 9 | if (_l0d_inglow < 0.0) 10 | _color_inglow = texture(_samp_inglow, _uv_inglow); 11 | else 12 | _color_inglow = textureLod(_samp_inglow, _uv_inglow, _l0d_inglow); 13 | 14 | _amount_inglow = int(min(_rad_inglow + 7.0, 14.0)); 15 | for(int x = - _amount_inglow; x <= _amount_inglow; x++) { 16 | for(int y = - _amount_inglow; y <= _amount_inglow; y++) { 17 | vec2 _coord_blur_cst = _uv_inglow + vec2(float(x), float(y)) * _rad_inglow * 0.01; 18 | _alpha_inglow_b1 += textureLod(_samp_inglow, _coord_blur_cst, 0.0).a; 19 | } 20 | } 21 | int _nmb_neighbours_blur_cst = (_amount_inglow * 2 + 1) * (_amount_inglow * 2 + 1); 22 | _alpha_inglow_b1 /= float(_nmb_neighbours_blur_cst); 23 | 24 | _alpha_inv = 1.0 - _alpha_inglow_b1; // inversion 25 | _alpha_inv *= _color_inglow.a; // masking 26 | 27 | if (_alpha_inv > 0.0) 28 | _alpha_inv *= (_intns_inglow + 1.0); 29 | 30 | return mix(_color_inglow, _col_inglow, _alpha_inv * _col_inglow.a); 31 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/sinTime.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsSinTIME 4 | 5 | func _init(): 6 | set_input_port_default_value(0, 1.0) 7 | set_input_port_default_value(1, 1.0) 8 | 9 | func _get_name() -> String: 10 | return "SinTIME" 11 | 12 | func _get_category() -> String: 13 | return "Tools" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Returns [amplitude] * sin([speed] * TIME)" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_SCALAR 23 | 24 | func _get_input_port_count() -> int: 25 | return 2 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "speed" 31 | 1: 32 | return "amplitude" 33 | 34 | func _get_input_port_type(port: int): 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_SCALAR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 41 | func _get_output_port_count() -> int: 42 | return 1 43 | 44 | func _get_output_port_name(port: int) -> String: 45 | return "out" 46 | 47 | func _get_output_port_type(port): 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_code(input_vars, output_vars, mode, type): 51 | return output_vars[0] + " = %s * sin(%s * TIME);" % [input_vars[1], input_vars[0]] 52 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/outerGlow.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _outerGlowFunc(sampler2D _samp_inglow, vec2 _uv_inglow, float _lod_inglow, float _rad_inglow, float _intns_inglow, vec4 _col_inglow){ 2 | _rad_inglow = abs(_rad_inglow); 3 | 4 | vec4 _color_inglow = vec4(0.0); 5 | float _alpha_inv = 0.0; 6 | float _alpha_inglow_b1 = 0.0; 7 | int _amount_inglow = 3; 8 | 9 | if (_lod_inglow < 0.0) 10 | _color_inglow = texture(_samp_inglow, _uv_inglow); 11 | else 12 | _color_inglow = textureLod(_samp_inglow, _uv_inglow, _lod_inglow); 13 | 14 | _amount_inglow = int(min(_rad_inglow + 7.0, 14.0)); 15 | for(int x = - _amount_inglow; x <= _amount_inglow; x++) { 16 | for(int y = - _amount_inglow; y <= _amount_inglow; y++) { 17 | vec2 _coord_blur_cst = _uv_inglow + vec2(float(x), float(y)) * _rad_inglow * 0.01; 18 | _alpha_inglow_b1 += textureLod(_samp_inglow, _coord_blur_cst, 0.0).a; 19 | } 20 | } 21 | int _nmb_neighbours_blur_cst = (_amount_inglow * 2 + 1) * (_amount_inglow * 2 + 1); 22 | _alpha_inglow_b1 /= float(_nmb_neighbours_blur_cst); 23 | 24 | _alpha_inv = _alpha_inglow_b1; // inversion 25 | _alpha_inv *= (1.0 - _color_inglow.a); // masking 26 | 27 | if (_alpha_inv > 0.0) 28 | _alpha_inv *= (_intns_inglow + 1.0); 29 | 30 | vec4 _glow_col_result = vec4(_col_inglow.rgb, _alpha_inv * _col_inglow.a); 31 | return mix(_glow_col_result, _color_inglow, _color_inglow.a); 32 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/innerGlowEmpty.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _innerGlowEmptyFunc(sampler2D _samp_inglowEmpt, vec2 _uv_inglowEmpt, float _lod_inglowEmpt, float _rad_inglowEmpt, float _intns_inglowEmpt, vec4 _col_inglowEmpt){ 2 | _rad_inglowEmpt = abs(_rad_inglowEmpt); 3 | 4 | vec4 _color_inglow = vec4(0.0); 5 | float _alpha_inglow_inv = 0.0; 6 | float _alpha_inglow_b1 = 0.0; 7 | int _amount_inglow = 3; 8 | 9 | if (_lod_inglowEmpt < 0.0) 10 | _color_inglow = texture(_samp_inglowEmpt, _uv_inglowEmpt); 11 | else 12 | _color_inglow = textureLod(_samp_inglowEmpt, _uv_inglowEmpt, _lod_inglowEmpt); 13 | 14 | _amount_inglow = int(min(_rad_inglowEmpt + 7.0, 14.0)); 15 | for(int x = - _amount_inglow; x <= _amount_inglow; x++) { 16 | for(int y = - _amount_inglow; y <= _amount_inglow; y++) { 17 | vec2 _coord_blur_cst = _uv_inglowEmpt + vec2(float(x), float(y)) * _rad_inglowEmpt * 0.01; 18 | _alpha_inglow_b1 += textureLod(_samp_inglowEmpt, _coord_blur_cst, 0.0).a; 19 | } 20 | } 21 | int _nmb_neighbours_blur_cst = (_amount_inglow * 2 + 1) * (_amount_inglow * 2 + 1); 22 | _alpha_inglow_b1 /= float(_nmb_neighbours_blur_cst); 23 | 24 | _alpha_inglow_inv = 1.0 - _alpha_inglow_b1; // inversion 25 | _alpha_inglow_inv *= _color_inglow.a; // masking 26 | 27 | if (_alpha_inglow_inv > 0.0) 28 | _alpha_inglow_inv *= (_intns_inglowEmpt + 1.0); 29 | 30 | return vec4(_col_inglowEmpt.rgb, _alpha_inglow_inv * _col_inglowEmpt.a); 31 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/outerGlowEmpty.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _outerGlowEmptyFunc(sampler2D _samp_inglowEmpt, vec2 _uv_inglowEmpt, float _lod_inglowEmpt, float _rad_inglowEmpt, float _intns_inglowEmpt, vec4 _col_inglowEmpt){ 2 | _rad_inglowEmpt = abs(_rad_inglowEmpt); 3 | 4 | vec4 _color_inglow = vec4(0.0); 5 | float _alpha_inglow_inv = 0.0; 6 | float _alpha_inglow_b1 = 0.0; 7 | int _amount_inglow = 3; 8 | 9 | if (_lod_inglowEmpt < 0.0) 10 | _color_inglow = texture(_samp_inglowEmpt, _uv_inglowEmpt); 11 | else 12 | _color_inglow = textureLod(_samp_inglowEmpt, _uv_inglowEmpt, _lod_inglowEmpt); 13 | 14 | _amount_inglow = int(min(_rad_inglowEmpt + 7.0, 14.0)); 15 | for(int x = - _amount_inglow; x <= _amount_inglow; x++) { 16 | for(int y = - _amount_inglow; y <= _amount_inglow; y++) { 17 | vec2 _coord_blur_cst = _uv_inglowEmpt + vec2(float(x), float(y)) * _rad_inglowEmpt * 0.01; 18 | _alpha_inglow_b1 += textureLod(_samp_inglowEmpt, _coord_blur_cst, 0.0).a; 19 | } 20 | } 21 | int _nmb_neighbours_blur_cst = (_amount_inglow * 2 + 1) * (_amount_inglow * 2 + 1); 22 | _alpha_inglow_b1 /= float(_nmb_neighbours_blur_cst); 23 | 24 | _alpha_inglow_inv = _alpha_inglow_b1; // inversion 25 | _alpha_inglow_inv *= (1.0 - _color_inglow.a); // masking 26 | 27 | if (_alpha_inglow_inv > 0.0) 28 | _alpha_inglow_inv *= (_intns_inglowEmpt + 1.0); 29 | 30 | return vec4(_col_inglowEmpt.rgb, _alpha_inglow_inv * _col_inglowEmpt.a); 31 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/polarToCartesian.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsPolarToCartesian 4 | 5 | func _init(): 6 | set_input_port_default_value(0, Vector3(1.0, 1.0, 0.0)) 7 | 8 | func _get_name() -> String: 9 | return "PolarToCartesian" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | func _get_subcategory(): 15 | return "TransformCoordinates" 16 | 17 | func _get_description() -> String: 18 | return "Polar (r, theta) -> Cartesian (x, y)" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 1 25 | 26 | func _get_input_port_name(port: int) -> String: 27 | return "polar" 28 | 29 | func _get_input_port_type(port): 30 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 31 | 32 | 33 | func _get_output_port_count() -> int: 34 | return 1 35 | 36 | func _get_output_port_name(port ) -> String: 37 | return "cartesian" 38 | 39 | func _get_output_port_type(port): 40 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 41 | 42 | func _get_global_code(mode): 43 | var path = self.get_script().get_path().get_base_dir() 44 | return '#include "' + path + '/polarToCartesian.gdshaderinc"' 45 | 46 | func _get_code(input_vars, output_vars, mode, type): 47 | return "%s = vec3(_polarToCartesianFunc(%s.xy), %s.z);" % [output_vars[0], input_vars[0], input_vars[0]] 48 | 49 | -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/sphericalToCartesian.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsSphericalToCartesian 4 | 5 | func _init(): 6 | set_input_port_default_value(0, Vector3(1.0, 1.0, 1.0)) 7 | 8 | func _get_name() -> String: 9 | return "SphericalToCartesian" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | func _get_subcategory(): 15 | return "TransformCoordinates" 16 | 17 | func _get_description() -> String: 18 | return "Spherical (r, theta, phi) -> Cartesian (x, y, z)" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 1 25 | 26 | func _get_input_port_name(port: int) -> String: 27 | return "spherical" 28 | 29 | func _get_input_port_type(port): 30 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 31 | 32 | 33 | func _get_output_port_count() -> int: 34 | return 1 35 | 36 | func _get_output_port_name(port ) -> String: 37 | return "cartesian" 38 | 39 | func _get_output_port_type(port): 40 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 41 | 42 | func _get_global_code(mode): 43 | var path = self.get_script().get_path().get_base_dir() 44 | return '#include "' + path + '/sphericalToCartesian.gdshaderinc"' 45 | 46 | func _get_code(input_vars, output_vars, mode, type): 47 | return "%s = _sphericalToCartesianFunc(%s);" % [output_vars[0], input_vars[0]] 48 | 49 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blackNwhite.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblackNwhite 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.5) 7 | 8 | func _get_name() -> String: 9 | return "BlackAndWhite" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Turns color to black and white" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 2 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "threshold" 32 | 33 | func _get_input_port_type(port: int): 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 40 | func _get_output_port_count() -> int: 41 | return 1 42 | 43 | func _get_output_port_name(port: int) -> String: 44 | return "col" 45 | 46 | func _get_output_port_type(port): 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 49 | func _get_global_code(mode): 50 | var path = self.get_script().get_path().get_base_dir() 51 | return '#include "' + path + '/blackNwhite.gdshaderinc"' 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | return "%s = blackNwhite(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 55 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/grayscale.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAgrayscale 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | 8 | func _get_name() -> String: 9 | return "GrayscalePlus" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Improved grayscale with gray factor" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 2 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "factor" 32 | 33 | func _get_input_port_type(port: int): 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 40 | func _get_output_port_count() -> int: 41 | return 1 42 | 43 | func _get_output_port_name(port: int) -> String: 44 | return "col" 45 | 46 | func _get_output_port_type(port): 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 49 | func _get_global_code(mode): 50 | var path = self.get_script().get_path().get_base_dir() 51 | return '#include "' + path + '/grayscale.gdshaderinc"' 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | return "%s = _grayscaleFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 55 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/posterize.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAposterize 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 8.0) 7 | 8 | func _get_name() -> String: 9 | return "Posterize" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Rounds values based on the value coming through [steps]" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 2 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "steps" 32 | 33 | func _get_input_port_type(port: int): 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 40 | func _get_output_port_count() -> int: 41 | return 1 42 | 43 | func _get_output_port_name(port: int) -> String: 44 | return "col" 45 | 46 | func _get_output_port_type(port): 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 49 | func _get_global_code(mode): 50 | var path = self.get_script().get_path().get_base_dir() 51 | return '#include "' + path + '/posterize.gdshaderinc"' 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | return "%s = _posterizeFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 55 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/turnCGA4Palette.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAturnCGA4Palette 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.5) 7 | 8 | func _get_name() -> String: 9 | return "TurnCGA4Palette" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Swaps color to CGA 4-color palette" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 2 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "threshold" 32 | 33 | func _get_input_port_type(port: int): 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 40 | func _get_output_port_count() -> int: 41 | return 1 42 | 43 | func _get_output_port_name(port: int) -> String: 44 | return "col" 45 | 46 | func _get_output_port_type(port): 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 49 | func _get_global_code(mode): 50 | var path = self.get_script().get_path().get_base_dir() 51 | return '#include "' + path + '/turnCGA4Palette.gdshaderinc"' 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | return "%s = _cg4PaletteFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 55 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/turnGBPalette.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAturnGameBoyPalette 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.5) 7 | 8 | func _get_name() -> String: 9 | return "TurnGameBoyPalette" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Swaps color to GameBoy palette" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 2 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "threshold" 32 | 33 | func _get_input_port_type(port: int): 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 40 | func _get_output_port_count() -> int: 41 | return 1 42 | 43 | func _get_output_port_name(port: int) -> String: 44 | return "col" 45 | 46 | func _get_output_port_type(port): 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 49 | func _get_global_code(mode): 50 | var path = self.get_script().get_path().get_base_dir() 51 | return '#include "' + path + '/turnGBPalette.gdshaderinc"' 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | return "%s = _gameboyPaletteFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 55 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/clamp.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVclampAlpha 4 | 5 | func _get_name() -> String: 6 | return "ClampAlphaBorder" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Clamp alpha to border vec4(0, 0, 1, 1)" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 2 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "alpha" 27 | 1: 28 | return "uv" 29 | 30 | func _get_input_port_type(port: int): 31 | match port: 32 | 0: 33 | return VisualShaderNode.PORT_TYPE_SCALAR 34 | 1: 35 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 36 | 37 | func _get_output_port_count() -> int: 38 | return 1 39 | 40 | func _get_output_port_name(port: int) -> String: 41 | return "alpha" 42 | 43 | func _get_output_port_type(port): 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 46 | func _get_global_code(mode): 47 | var path = self.get_script().get_path().get_base_dir() 48 | return '#include "' + path + '/clamp.gdshaderinc"' 49 | 50 | func _get_code(input_vars, output_vars, mode, type): 51 | var texture = "TEXTURE" 52 | var uv = "UV" 53 | 54 | if input_vars[1]: 55 | uv = input_vars[1] 56 | 57 | return output_vars[0] + " = _clampAlphaBorderFunc(%s, (%s).xy);" % [input_vars[0], uv] 58 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/colorCorrectionAdjustment.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcolorCorrectionAdjustment 4 | 5 | func _get_name() -> String: 6 | return "ColorCorrectionAdjustment" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Full analog of color correction adjustment of environment in Godot" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 19 | 20 | func _get_input_port_count() -> int: 21 | return 2 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "color" 27 | 1: 28 | return "corrector" 29 | 30 | func _get_input_port_type(port: int): 31 | match port: 32 | 0: 33 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 34 | 1: 35 | return VisualShaderNode.PORT_TYPE_SAMPLER 36 | 37 | func _get_output_port_count() -> int: 38 | return 1 39 | 40 | func _get_output_port_name(port: int) -> String: 41 | return "col" 42 | 43 | func _get_output_port_type(port): 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 46 | func _get_global_code(mode): 47 | var path = self.get_script().get_path().get_base_dir() 48 | return '#include "' + path + '/colorCorrectionAdjustment.gdshaderinc"' 49 | 50 | func _get_code(input_vars, output_vars, mode, type): 51 | return "%s = _applyColorCorrectionFunc(%s, %s);" % [ 52 | output_vars[0], input_vars[0], input_vars[1]] 53 | -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/cartesianToPolar.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsCartesianToPolar 4 | 5 | func _init(): 6 | set_input_port_default_value(0, Vector3(1.0, 1.0, 0.0)) 7 | 8 | func _get_name() -> String: 9 | return "CartesianToPolar" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | func _get_subcategory(): 15 | return "TransformCoordinates" 16 | 17 | func _get_description() -> String: 18 | return "Cartesian (x, y) -> Polar (r, theta). By default (x, y) is UV." 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 1 25 | 26 | func _get_input_port_name(port: int) -> String: 27 | return "cartesian" 28 | 29 | func _get_input_port_type(port): 30 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 31 | 32 | 33 | func _get_output_port_count() -> int: 34 | return 1 35 | 36 | func _get_output_port_name(port ) -> String: 37 | return "polar" 38 | 39 | func _get_output_port_type(port): 40 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 41 | 42 | func _get_global_code(mode): 43 | var path = self.get_script().get_path().get_base_dir() 44 | return '#include "' + path + '/cartesianToPolar.gdshaderinc"' 45 | 46 | func _get_code(input_vars, output_vars, mode, type): 47 | var uv = "UV" 48 | 49 | if input_vars[0]: 50 | uv = input_vars[0] 51 | 52 | return "%s = vec3(_cartesianToPolarFunc(%s.xy), %s.z);" % [output_vars[0], uv, uv] 53 | 54 | -------------------------------------------------------------------------------- /addons/shaderV/tools/transformCoordinates/cartesianToSpherical.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsCartesianToSpherical 4 | 5 | func _init(): 6 | set_input_port_default_value(0, Vector3(1.0, 1.0, 1.0)) 7 | 8 | func _get_name() -> String: 9 | return "CartesianToSpherical" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | func _get_subcategory(): 15 | return "TransformCoordinates" 16 | 17 | func _get_description() -> String: 18 | return "Cartesian (x, y, z) -> Spherical (r, theta, phi). By default (x, y, z) is UV." 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 1 25 | 26 | func _get_input_port_name(port: int) -> String: 27 | return "cartesian" 28 | 29 | func _get_input_port_type(port): 30 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 31 | 32 | 33 | func _get_output_port_count() -> int: 34 | return 1 35 | 36 | func _get_output_port_name(port ) -> String: 37 | return "spherical" 38 | 39 | func _get_output_port_type(port): 40 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 41 | 42 | func _get_global_code(mode): 43 | var path = self.get_script().get_path().get_base_dir() 44 | return '#include "' + path + '/cartesianToSpherical.gdshaderinc"' 45 | 46 | func _get_code(input_vars, output_vars, mode, type): 47 | var uv = "UV" 48 | 49 | if input_vars[0]: 50 | uv = input_vars[0] 51 | 52 | return "%s = _cartesianToSphericalFunc(%s);" % [output_vars[0], uv] 53 | 54 | -------------------------------------------------------------------------------- /addons/shaderV/tools/vec2Compose.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsvec2Compose 4 | 5 | func _init(): 6 | set_input_port_default_value(0, 1.0) 7 | set_input_port_default_value(1, 0.0) 8 | 9 | func _get_name() -> String: 10 | return "vec2Compose" 11 | 12 | func _get_category() -> String: 13 | return "Tools" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Makes 2d vector from length and angle (in radians)" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 2 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "length" 31 | 1: 32 | return "radians" 33 | 34 | func _get_input_port_type(port: int): 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_SCALAR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 41 | 42 | func _get_output_port_count() -> int: 43 | return 1 44 | 45 | func _get_output_port_name(port ) -> String: 46 | return "vec2" 47 | 48 | func _get_output_port_type(port): 49 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 50 | 51 | func _get_global_code(mode): 52 | var path = self.get_script().get_path().get_base_dir() 53 | return '#include "' + path + '/vec2Compose.gdshaderinc"' 54 | 55 | func _get_code(input_vars, output_vars, mode, type): 56 | return "%s.xy = _vec2ComposeFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 57 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/generic2d_fractal.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _hash2_gener1c2DFractal(vec2 _p_hash2_gener1c) { 2 | return (fract(1e4 * sin(17.0 * _p_hash2_gener1c.x + _p_hash2_gener1c.y * 0.1) * 3 | (0.1 + abs(sin(_p_hash2_gener1c.y * 13.0 + _p_hash2_gener1c.x))))); 4 | } 5 | float _genericNoise2DFractal(vec2 _x_gener1c2D) { 6 | vec2 _temp_i_gener1c2D = floor(_x_gener1c2D); 7 | vec2 _temp_f_gener1c2D = fract(_x_gener1c2D); 8 | 9 | float _a_g1n2 = _hash2_gener1c2DFractal(_temp_i_gener1c2D); 10 | float _b_g1n2 = _hash2_gener1c2DFractal(_temp_i_gener1c2D + vec2(1.0, 0.0)); 11 | float _c_g1n2 = _hash2_gener1c2DFractal(_temp_i_gener1c2D + vec2(0.0, 1.0)); 12 | float _d_g1n2 = _hash2_gener1c2DFractal(_temp_i_gener1c2D + vec2(1.0, 1.0)); 13 | 14 | vec2 _u_g1n2 = _temp_f_gener1c2D * _temp_f_gener1c2D * (3.0 - 2.0 * _temp_f_gener1c2D); 15 | return (mix(_a_g1n2, _b_g1n2, _u_g1n2.x) + (_c_g1n2 - _a_g1n2) * 16 | _u_g1n2.y * (1.0 - _u_g1n2.x) + (_d_g1n2 - _b_g1n2) * _u_g1n2.x * _u_g1n2.y); 17 | } 18 | float _genericNoise2DFBM(vec2 _uv_gnfbm, int _oct_gnfbm, vec2 _per_gnfbm, float _lac_gnfbm, 19 | float _persist_gnfbm, float _rot_gnfbm, float _ampl_gnfbm, vec2 _shift_gnfbm) { 20 | float _v = 0.0; 21 | float _a = _ampl_gnfbm; 22 | mat2 _r0t = mat2(vec2(cos(_rot_gnfbm), sin(_rot_gnfbm)), vec2(-sin(_rot_gnfbm), cos(_rot_gnfbm))); 23 | for (int i = 0; i < _oct_gnfbm; ++i) { 24 | _v += _a * _genericNoise2DFractal(_uv_gnfbm * _per_gnfbm); 25 | _uv_gnfbm = _r0t * _uv_gnfbm * _lac_gnfbm + _shift_gnfbm; 26 | _a *= _persist_gnfbm; 27 | } 28 | return _v; 29 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/tilingNoffset.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtilingNoffset 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0)) 7 | 8 | func _get_name() -> String: 9 | return "TilingAndOffsetUV" 10 | 11 | func _get_category() -> String: 12 | return "UV" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Tiles UV with given offset" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 2 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "uv" 30 | 1: 31 | return "offset" 32 | 33 | func _get_input_port_type(port: int): 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 39 | 40 | func _get_output_port_count() -> int: 41 | return 1 42 | 43 | func _get_output_port_name(port: int) -> String: 44 | return "uv" 45 | 46 | func _get_output_port_type(port): 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 49 | func _get_global_code(mode): 50 | var path = self.get_script().get_path().get_base_dir() 51 | return '#include "' + path + '/tilingNoffset.gdshaderinc"' 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | var uv = "UV" 55 | 56 | if input_vars[0]: 57 | uv = input_vars[0] 58 | 59 | return output_vars[0] + " = vec3(_tiling_and_offset(%s.xy, %s.xy), 0);" % [uv, input_vars[1]] 60 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/tonemap.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAtonemap 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.0) 7 | set_input_port_default_value(2, 1.0) 8 | 9 | func _get_name() -> String: 10 | return "Tonemap" 11 | 12 | func _get_category() -> String: 13 | return "RGBA" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | #func _get_description() -> String: 19 | # return "" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "color" 31 | 1: 32 | return "exposure" 33 | 2: 34 | return "gamma" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_SCALAR 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "col" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/tonemap.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | return "%s = _tonemapFunc(%s, %s, %s);" % [ 60 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 61 | -------------------------------------------------------------------------------- /addons/shaderV/uv/pixelate.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVpixelate 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(64, 64, 0)) 7 | 8 | func _get_name() -> String: 9 | return "PixelateUV" 10 | 11 | func _get_category() -> String: 12 | return "UV" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return """Pixelate UV by size factor 19 | Note: may produce artifacts if applied to texture with mipmaps enabled""" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 2 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "size" 33 | 34 | func _get_input_port_type(port: int): 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 41 | func _get_output_port_count() -> int: 42 | return 1 43 | 44 | func _get_output_port_name(port: int) -> String: 45 | return "uv" 46 | 47 | func _get_output_port_type(port): 48 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 49 | 50 | func _get_global_code(mode): 51 | var path = self.get_script().get_path().get_base_dir() 52 | return '#include "' + path + '/pixelate.gdshaderinc"' 53 | 54 | func _get_code(input_vars, output_vars, mode, type): 55 | var uv = "UV" 56 | 57 | if input_vars[0]: 58 | uv = input_vars[0] 59 | 60 | return "%s.xy = _pixelateUV(%s.xy, %s.xy);" % [output_vars[0], uv, input_vars[1]] 61 | -------------------------------------------------------------------------------- /addons/shaderV/uv/lensDistortion.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVlensDistortion 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | 8 | func _get_name() -> String: 9 | return "LensDistortionUV" 10 | 11 | func _get_category() -> String: 12 | return "UV" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return """Lens distortion effect. 19 | [factor] > 0 - fisheye / barrel; 20 | [factor] < 0 - antifisheye / pincushion""" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 2 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "factor" 34 | 35 | func _get_input_port_type(port: int): 36 | match port: 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 39 | 1: 40 | return VisualShaderNode.PORT_TYPE_SCALAR 41 | 42 | func _get_output_port_count() -> int: 43 | return 1 44 | 45 | func _get_output_port_name(port: int) -> String: 46 | return "uv" 47 | 48 | func _get_output_port_type(port): 49 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 50 | 51 | func _get_global_code(mode): 52 | var path = self.get_script().get_path().get_base_dir() 53 | return '#include "' + path + '/lensDistortion.gdshaderinc"' 54 | 55 | func _get_code(input_vars, output_vars, mode, type): 56 | var uv = "UV" 57 | 58 | if input_vars[0]: 59 | uv = input_vars[0] 60 | 61 | return "%s.xy = _lensDistortionUV(%s.xy, %s);" % [output_vars[0], uv, input_vars[1]] 62 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/glowEmpty.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _inoutGlowEmptyFunc(sampler2D _samp_inglowEmpt, vec2 _uv_inglowEmpt, float _lod_glowEmpt, float _rad_inout_Empty, 2 | float _intens_inner_glowEmpt, float _intens_outer_glowEmpt, vec4 _col_inglowEmpt){ 3 | _rad_inout_Empty = abs(_rad_inout_Empty); 4 | 5 | vec4 _color_orig_glow = vec4(0.0); 6 | float _alpha_glow_inv = 0.0; 7 | float _alpha_glow_blured = 0.0; 8 | int glow_amount = 3; 9 | 10 | if (_lod_glowEmpt < 0.0) 11 | _color_orig_glow = texture(_samp_inglowEmpt, _uv_inglowEmpt); 12 | else 13 | _color_orig_glow = textureLod(_samp_inglowEmpt, _uv_inglowEmpt, _lod_glowEmpt); 14 | 15 | glow_amount = int(min(_rad_inout_Empty + 7.0, 14.0)); 16 | for(int x = - glow_amount; x <= glow_amount; x++) { 17 | for(int y = - glow_amount; y <= glow_amount; y++) { 18 | vec2 _coord_blur_cst = _uv_inglowEmpt + vec2(float(x), float(y)) * _rad_inout_Empty * 0.01; 19 | _alpha_glow_blured += textureLod(_samp_inglowEmpt, _coord_blur_cst, 0.0).a; 20 | } 21 | } 22 | int _nmb_neighbours_blur_cst = (glow_amount * 2 + 1) * (glow_amount * 2 + 1); 23 | _alpha_glow_blured /= float(_nmb_neighbours_blur_cst); 24 | 25 | _alpha_glow_inv = _alpha_glow_blured; 26 | _alpha_glow_inv *= (1.0 - _color_orig_glow.a); 27 | 28 | float in_alpha_glow_inv = 1.0 - _alpha_glow_blured; 29 | in_alpha_glow_inv *= _color_orig_glow.a; 30 | 31 | if (_alpha_glow_inv > 0.0) 32 | _alpha_glow_inv *= (_intens_outer_glowEmpt + 1.0); 33 | 34 | if (in_alpha_glow_inv > 0.0) 35 | in_alpha_glow_inv *= (_intens_inner_glowEmpt + 1.0); 36 | 37 | return vec4(_col_inglowEmpt.rgb, (_alpha_glow_inv + in_alpha_glow_inv) * _col_inglowEmpt.a); 38 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/flipUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVflip 4 | 5 | func _init(): 6 | set_input_port_default_value(1, false) 7 | set_input_port_default_value(2, false) 8 | 9 | func _get_name() -> String: 10 | return "FlipUV" 11 | 12 | func _get_category() -> String: 13 | return "UV" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Flip UV horizontal or vertical" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "vert" 33 | 2: 34 | return "hor" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_BOOLEAN 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_BOOLEAN 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "uv" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/flipUV.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | var uv = "UV" 60 | 61 | if input_vars[0]: 62 | uv = input_vars[0] 63 | 64 | return "%s.xy = _flipUV(%s.xy, vec2(float(%s), float(%s)));" % [ 65 | output_vars[0], uv, input_vars[1], input_vars[2]] 66 | -------------------------------------------------------------------------------- /addons/shaderV/uv/twirl.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtwirl 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 8 | 9 | func _get_name() -> String: 10 | return "TwirlUV" 11 | 12 | func _get_category() -> String: 13 | return "UV" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Twirl UV by value relative to pivot point" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "value" 33 | 2: 34 | return "pivot" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "uv" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/twirl.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | var uv = "UV" 60 | 61 | if input_vars[0]: 62 | uv = input_vars[0] 63 | 64 | return output_vars[0] + " = _twirlUVFunc(%s.xy, %s.xy, %s);" % [uv, input_vars[2], input_vars[1]] 65 | -------------------------------------------------------------------------------- /addons/shaderV/uv/rotate.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVrotate 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.0) 7 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 8 | 9 | func _get_name() -> String: 10 | return "RotateUV" 11 | 12 | func _get_category() -> String: 13 | return "UV" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Rotate UV by angle in radians relative to pivot vector" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "angle" 33 | 2: 34 | return "pivot" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "uv" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/rotate.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | var uv = "UV" 60 | 61 | if input_vars[0]: 62 | uv = input_vars[0] 63 | 64 | return output_vars[0] + " = _rotateUV(%s, %s.xy, %s);" % [uv, input_vars[2], input_vars[1]] 65 | -------------------------------------------------------------------------------- /addons/shaderV/uv/scaleUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVscale 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(1, 1, 0)) 7 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 8 | 9 | func _get_name() -> String: 10 | return "ScaleUV" 11 | 12 | func _get_category() -> String: 13 | return "UV" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Scale UV relative to pivot point" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "scale" 33 | 2: 34 | return "pivot" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "uv" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/scaleUV.gdshaderinc"' 57 | 58 | 59 | func _get_code(input_vars, output_vars, mode, type): 60 | var uv = "UV" 61 | 62 | if input_vars[0]: 63 | uv = input_vars[0] 64 | 65 | return "%s.xy = _scaleUV(%s.xy, %s.xy, %s.xy);" % [ 66 | output_vars[0], uv, input_vars[1], input_vars[2]] 67 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/generic2d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseGeneric2d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | 9 | func _get_name() -> String: 10 | return "GenericNoise2D" 11 | 12 | func _get_category() -> String: 13 | return "RGBA" 14 | 15 | func _get_subcategory() -> String: 16 | return "Noise" 17 | 18 | func _get_description() -> String: 19 | return "GenericNoise using hash random function" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_SCALAR 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "offset" 33 | 2: 34 | return "scale" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_SCALAR 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "result" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_SCALAR 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/generic2d.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | var uv = "UV" 60 | 61 | if input_vars[0]: 62 | uv = input_vars[0] 63 | 64 | return "%s = _genericNoise2D((%s.xy + %s.xy) * %s);" % [ 65 | output_vars[0], uv, input_vars[1], input_vars[2]] 66 | -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomGoldNoiseFloat.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloatGoldenRation 4 | 5 | func _init(): 6 | set_input_port_default_value(0, Vector3(0, 0, 0)) 7 | set_input_port_default_value(1, Vector3(0, 0, 0)) 8 | set_input_port_default_value(2, 0.0) 9 | 10 | func _get_name() -> String: 11 | return "RandomGoldRatio" 12 | 13 | func _get_category() -> String: 14 | return "Tools" 15 | 16 | func _get_subcategory() -> String: 17 | return "Random" 18 | 19 | func _get_description() -> String: 20 | return "Random float based on golden ratio" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_SCALAR 24 | 25 | func _get_input_port_count() -> int: 26 | return 3 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "offset" 34 | 2: 35 | return "seed" 36 | 37 | func _get_input_port_type(port: int): 38 | match port: 39 | 0: 40 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 41 | 1: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 2: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 46 | func _get_output_port_count() -> int: 47 | return 1 48 | 49 | func _get_output_port_name(port) -> String: 50 | return "rand" 51 | 52 | func _get_output_port_type(port): 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_global_code(mode): 56 | var path = self.get_script().get_path().get_base_dir() 57 | return '#include "' + path + '/randomGoldNoiseFloat.gdshaderinc"' 58 | 59 | func _get_code(input_vars, output_vars, mode, type): 60 | return "%s = _randomGoldRatioFunc(%s.xy, %s.xy, %s);" % [ 61 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 62 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/inverseColor.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAinverseColor 4 | 5 | func _init(): 6 | set_input_port_default_value(2, 1.0) 7 | 8 | func _get_name() -> String: 9 | return "InverseColor" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | func _get_description() -> String: 18 | return "Inverse color basing on intensity" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 3 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "alpha" 32 | 2: 33 | return "intensity" 34 | 35 | func _get_input_port_type(port: int): 36 | match port: 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 39 | 1: 40 | return VisualShaderNode.PORT_TYPE_SCALAR 41 | 2: 42 | return VisualShaderNode.PORT_TYPE_SCALAR 43 | 44 | func _get_output_port_count() -> int: 45 | return 2 46 | 47 | func _get_output_port_name(port: int): 48 | match port: 49 | 0: 50 | return "col" 51 | 1: 52 | return "alpha" 53 | 54 | func _get_output_port_type(port: int): 55 | match port: 56 | 0: 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 1: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 61 | func _get_global_code(mode): 62 | var path = self.get_script().get_path().get_base_dir() 63 | return '#include "' + path + '/inverseColor.gdshaderinc"' 64 | 65 | func _get_code(input_vars, output_vars, mode, type): 66 | return """%s = _inverseColorFunc(%s, %s); 67 | %s = %s;""" % [output_vars[0], input_vars[0],input_vars[2], 68 | output_vars[1], input_vars[1]] 69 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex2d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseSimplex2d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | 9 | func _get_name() -> String: 10 | return "SimplexNoise2D" 11 | 12 | func _get_category() -> String: 13 | return "RGBA" 14 | 15 | func _get_subcategory() -> String: 16 | return "Noise" 17 | 18 | func _get_description() -> String: 19 | return "2d simplex noise" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_SCALAR 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "offset" 33 | 2: 34 | return "scale" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_SCALAR 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int): 49 | match port: 50 | 0: 51 | return "result" 52 | 53 | func _get_output_port_type(port: int): 54 | match port: 55 | 0: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 58 | func _get_global_code(mode): 59 | var path = self.get_script().get_path().get_base_dir() 60 | return '#include "' + path + '/simplex2d.gdshaderinc"' 61 | 62 | func _get_code(input_vars, output_vars, mode, type): 63 | var uv = "UV" 64 | 65 | if input_vars[0]: 66 | uv = input_vars[0] 67 | 68 | return "%s = _simplex2dNoiseFunc((%s.xy+%s.xy)*%s);" % [ 69 | output_vars[0], uv, input_vars[1], input_vars[2]] 70 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2d.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _cellular2dNoiseFunc(vec2 P, float _jitter_w2d) { 2 | float K = 0.142857142857; // 1/7 3 | float Ko = 0.428571428571; // 3/7 4 | 5 | vec2 Pi = floor(P) - floor(floor(P) * (1.0 / 289.0)) * 289.0; 6 | vec2 Pf = fract(P); 7 | vec3 oi = vec3(-1.0, 0.0, 1.0); 8 | vec3 of = vec3(-0.5, 0.5, 1.5); 9 | vec3 px = (34.0*(Pi.x+oi)+1.0)*(Pi.x+oi)-floor((34.0*(Pi.x+oi)+1.0)*(Pi.x+oi)*(1.0/289.0))* 289.0; 10 | vec3 p = (34.0*(px.x+Pi.y+ oi)+1.0)*(px.x+Pi.y+ oi)-floor((34.0*(px.x+Pi.y+oi)+1.0)*(px.x+Pi.y+ oi)*(1.0/289.0))*289.0; 11 | vec3 ox = fract(p*K) - Ko; 12 | vec3 oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 13 | vec3 dx = Pf.x + 0.5 + _jitter_w2d*ox; 14 | vec3 dy = Pf.y - of + _jitter_w2d*oy; 15 | vec3 d1 = dx * dx + dy * dy; 16 | p = (34.0*(px.y+Pi.y+oi)+1.0)*(px.y+Pi.y+oi)-floor((34.0*(px.y+Pi.y+oi)+1.0)*(px.y+Pi.y+oi)*(1.0/289.0))*289.0; 17 | ox = fract(p*K) - Ko; 18 | oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 19 | dx = Pf.x - 0.5 + _jitter_w2d*ox; 20 | dy = Pf.y - of + _jitter_w2d*oy; 21 | vec3 d2 = dx * dx + dy * dy; 22 | p = (34.0*(px.z+Pi.y+oi)+1.0)*(px.z+Pi.y+oi)-floor((34.0*(px.z+Pi.y+oi)+1.0)*(px.z+Pi.y+oi)*(1.0/289.0))*289.0; 23 | ox = fract(p*K) - Ko; 24 | oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 25 | dx = Pf.x - 1.5 + _jitter_w2d*ox; 26 | dy = Pf.y - of + _jitter_w2d*oy; 27 | vec3 d3 = dx * dx + dy * dy; 28 | vec3 d1a = min(d1, d2); 29 | d2 = max(d1, d2); 30 | d2 = min(d2, d3); 31 | d1 = min(d1a, d2); 32 | d2 = max(d1a, d2); 33 | d1.xy = (d1.x < d1.y) ? d1.xy : d1.yx; 34 | d1.xz = (d1.x < d1.z) ? d1.xz : d1.zx; 35 | d1.yz = min(d1.yz, d2.yz); 36 | d1.y = min(d1.y, d1.z); 37 | d1.y = min(d1.y, d2.x); 38 | return sqrt(d1.xy); 39 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/tilingNoffsetAnimated.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtilingNoffsetAnimated 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0)) 7 | set_input_port_default_value(2, 0.0) 8 | 9 | func _get_name() -> String: 10 | return "TilingAndOffsetUVAnimated" 11 | 12 | func _get_category() -> String: 13 | return "UV" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Animated UV tiling with given [offset] speed" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "offset" 33 | 2: 34 | return "time" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_SCALAR 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "uv" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_VECTOR_2D 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/tilingNoffsetAnimated.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | var uv = "UV" 60 | 61 | if input_vars[0]: 62 | uv = input_vars[0] 63 | 64 | return "%s.xy = _tilingNoffsetAnimatedFunc(%s.xy, %s, %s.xy);" % [ 65 | output_vars[0], uv, input_vars[2], input_vars[1]] 66 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/perlin2d.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _perlin2dNoiseFunc(vec2 P, vec2 _period_perl2) { 2 | vec4 Pi = floor(vec4(P, P)) + vec4(0.0, 0.0, 1.0, 1.0); 3 | vec4 Pf = fract(vec4(P, P)) - vec4(0.0, 0.0, 1.0, 1.0); 4 | 5 | if (_period_perl2.x != 0.0 && _period_perl2.y != 0.0) 6 | Pi = mod(Pi, vec4(_period_perl2, _period_perl2)); 7 | 8 | Pi = Pi - floor(Pi * (1.0 / 289.0)) * 289.0; 9 | vec4 ix = Pi.xzxz; 10 | vec4 iy = Pi.yyww; 11 | vec4 fx = Pf.xzxz; 12 | vec4 fy = Pf.yyww; 13 | 14 | vec4 i = (((((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy)*34.0)+1.0)* 15 | ((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy))- 16 | floor((((((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy)*34.0)+1.0)* 17 | ((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy))*(1.0/289.0))*289.0; 18 | 19 | vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ; 20 | vec4 gy = abs(gx) - 0.5 ; 21 | vec4 tx = floor(gx + 0.5); 22 | gx = gx - tx; 23 | 24 | vec2 g00 = vec2(gx.x,gy.x); 25 | vec2 g10 = vec2(gx.y,gy.y); 26 | vec2 g01 = vec2(gx.z,gy.z); 27 | vec2 g11 = vec2(gx.w,gy.w); 28 | 29 | vec4 norm = 1.79284291400159 - 0.85373472095314 * vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)); 30 | g00 *= norm.x; 31 | g01 *= norm.y; 32 | g10 *= norm.z; 33 | g11 *= norm.w; 34 | 35 | float n00 = dot(g00, vec2(fx.x, fy.x)); 36 | float n10 = dot(g10, vec2(fx.y, fy.y)); 37 | float n01 = dot(g01, vec2(fx.z, fy.z)); 38 | float n11 = dot(g11, vec2(fx.w, fy.w)); 39 | 40 | vec2 fade_xy = Pf.xy * Pf.xy * Pf.xy * (Pf.xy * (Pf.xy * 6.0 - 15.0) + 10.0); 41 | vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x); 42 | float n_xy = mix(n_x.x, n_x.y, fade_xy.y); 43 | return (2.3 * n_xy + 1.0) * 0.5; 44 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/BCSAdjustment.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAadjustmentBCS 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(2, 1.0) 8 | set_input_port_default_value(3, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "BCSAdjustment" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return "Full analog of BCS adjustment of environment in Godot" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "color" 32 | 1: 33 | return "brightness" 34 | 2: 35 | return "contrast" 36 | 3: 37 | return "saturation" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 1 52 | 53 | func _get_output_port_name(port: int) -> String: 54 | return "col" 55 | 56 | func _get_output_port_type(port): 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 59 | func _get_global_code(mode): 60 | var path = self.get_script().get_path().get_base_dir() 61 | return '#include "' + path + '/BCSAdjustment.gdshaderinc"' 62 | 63 | func _get_code(input_vars, output_vars, mode, type): 64 | return "%s = _applyBCS(%s, vec3(%s, %s, %s));" % [ 65 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 66 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/tintRGBA.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAtintRGBA 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(2, Vector3(1.0, 1.0, 1.0)) 8 | set_input_port_default_value(3, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "TintRGBA" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return "Tints RGBA with tint color (same as modulate property in editor)" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "col" 32 | 1: 33 | return "alpha" 34 | 2: 35 | return "colorTint" 36 | 3: 37 | return "alphaTint" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 2 52 | 53 | func _get_output_port_name(port: int): 54 | match port: 55 | 0: 56 | return "col" 57 | 1: 58 | return "alpha" 59 | 60 | func _get_output_port_type(port: int): 61 | match port: 62 | 0: 63 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 64 | 1: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 67 | func _get_code(input_vars, output_vars, mode, type): 68 | return """%s = %s * %s; 69 | %s = %s * %s;""" % [output_vars[0], input_vars[0], input_vars[2], 70 | output_vars[1], input_vars[1], input_vars[3]] 71 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2x2x2.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _cellular2x2x2NoiseFunc(vec3 P, float _jitter_w2x2x2) { 2 | float K = 0.142857142857; 3 | float Ko = 0.428571428571; 4 | float K2 = 0.020408163265306; 5 | float Kz = 0.166666666667; 6 | float Kzo = 0.416666666667; 7 | 8 | vec3 Pi = floor(P)- floor(floor(P) * (1.0 / 289.0)) * 289.0; 9 | vec3 Pf = fract(P); 10 | vec4 Pfx = Pf.x + vec4(0.0, -1.0, 0.0, -1.0); 11 | vec4 Pfy = Pf.y + vec4(0.0, 0.0, -1.0, -1.0); 12 | vec4 p = (34.0*(Pi.x+vec4(0.0,1.0,0.0,1.0))+1.0)*(Pi.x+vec4(0.0,1.0,0.0,1.0))-floor((34.0*(Pi.x+vec4(0.0,1.0,0.0,1.0))+1.0)*(Pi.x+vec4(0.0,1.0,0.0,1.0))*(1.0/289.0))*289.0; 13 | p = (34.0*(p+Pi.y+vec4(0.0,0.0,1.0,1.0))+1.0)*(p+Pi.y+vec4(0.0,0.0,1.0,1.0))-floor((34.0*(p+Pi.y+vec4(0.0,0.0,1.0,1.0))+1.0)*(p+Pi.y+vec4(0.0,0.0,1.0,1.0))*(1.0/289.0))*289.0; 14 | vec4 p1 = (34.0*(p+Pi.z)+1.0)*(p+Pi.z)-floor((34.0*(p+Pi.z)+1.0)*(p+Pi.z)*(1.0/289.0))*289.0; 15 | vec4 p2 = (34.0*(p+Pi.z+vec4(1.0))+1.0)*(p+Pi.z+vec4(1.0))-floor((34.0*(p+Pi.z+vec4(1.0))+1.0)*(p+Pi.z+vec4(1.0))*(1.0/289.0))*289.0; 16 | vec4 ox1 = fract(p1*K) - Ko; 17 | vec4 oy1 = (floor(p1*K) - floor(floor(p1*K) * (1.0 / 7.0)) * 7.0)*K - Ko; 18 | vec4 oz1 = floor(p1*K2)*Kz - Kzo; 19 | vec4 ox2 = fract(p2*K) - Ko; 20 | vec4 oy2 = (floor(p2*K) - floor(floor(p2*K) * (1.0 / 7.0)) * 7.0)*K - Ko; 21 | vec4 oz2 = floor(p2*K2)*Kz - Kzo; 22 | vec4 dx1 = Pfx + _jitter_w2x2x2*ox1; 23 | vec4 dy1 = Pfy + _jitter_w2x2x2*oy1; 24 | vec4 dz1 = Pf.z + _jitter_w2x2x2*oz1; 25 | vec4 dx2 = Pfx + _jitter_w2x2x2*ox2; 26 | vec4 dy2 = Pfy + _jitter_w2x2x2*oy2; 27 | vec4 dz2 = Pf.z - 1.0 + _jitter_w2x2x2*oz2; 28 | vec4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; 29 | vec4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; 30 | d1 = min(d1, d2); 31 | d1.xy = min(d1.xy, d1.wz); 32 | d1.x = min(d1.x, d1.y); 33 | return sqrt(d1.x); 34 | } -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomFloatImproved.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloatImproved 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0)) 8 | 9 | func _get_name() -> String: 10 | return "RandomFloatImproved" 11 | 12 | func _get_category() -> String: 13 | return "Tools" 14 | 15 | func _get_subcategory() -> String: 16 | return "Random" 17 | 18 | func _get_description() -> String: 19 | return "Improved version of classic random function. Classic random can produce artifacts. This one - doesn't." 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_SCALAR 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "scale" 33 | 2: 34 | return "offset" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 44 | 45 | func _get_output_port_count() -> int: 46 | return 1 47 | 48 | func _get_output_port_name(port: int) -> String: 49 | return "rnd" 50 | 51 | func _get_output_port_type(port): 52 | return VisualShaderNode.PORT_TYPE_SCALAR 53 | 54 | func _get_global_code(mode): 55 | var path = self.get_script().get_path().get_base_dir() 56 | return '#include "' + path + '/randomFloatImproved.gdshaderinc"' 57 | 58 | func _get_code(input_vars, output_vars, mode, type): 59 | var uv = "UV" 60 | 61 | if input_vars[0]: 62 | uv = input_vars[0] 63 | 64 | return "%s = _randImproved(%s.xy * %s + %s.xy);" % [ 65 | output_vars[0], uv, input_vars[1], input_vars[2]] 66 | -------------------------------------------------------------------------------- /addons/shaderV/tools/random/randomFloat4D.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloat4D 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | 8 | func _get_name() -> String: 9 | return "RandomFloat4D" 10 | 11 | func _get_category() -> String: 12 | return "Tools" 13 | 14 | func _get_subcategory() -> String: 15 | return "Random" 16 | 17 | func _get_description() -> String: 18 | return "Returns random float value based on 4D input vector" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_SCALAR 22 | 23 | func _get_input_port_count() -> int: 24 | return 3 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "input" 30 | 1: 31 | return "scale" 32 | 2: 33 | return "offset" 34 | 35 | func _get_input_port_type(port: int): 36 | match port: 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_VECTOR_4D 39 | 1: 40 | return VisualShaderNode.PORT_TYPE_SCALAR 41 | 2: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_4D 43 | 44 | func _get_output_port_count() -> int: 45 | return 1 46 | 47 | func _get_output_port_name(port: int) -> String: 48 | return "rnd" 49 | 50 | func _get_output_port_type(port): 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_global_code(mode): 54 | var path = self.get_script().get_path().get_base_dir() 55 | return '#include "' + path + '/randomFloat4D.gdshaderinc"' 56 | 57 | func _get_code(input_vars, output_vars, mode, type): 58 | var input = input_vars[0] 59 | var offset = input_vars[2] 60 | 61 | # See https://github.com/godotengine/godot/pull/90850 62 | if not input: 63 | input = 'vec4(0)' 64 | if not offset: 65 | offset = 'vec4(0)' 66 | 67 | return "%s = _randFloat4D(%s * %s + %s);" % [ 68 | output_vars[0], input, input_vars[1], offset] 69 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/bloom.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAbloom 4 | 5 | func _init(): 6 | set_input_port_default_value(2, 1.0) 7 | 8 | func _get_name() -> String: 9 | return "Bloom" 10 | 11 | func _get_category() -> String: 12 | return "RGBA" 13 | 14 | #func _get_subcategory(): 15 | # return "" 16 | 17 | #func _get_description() -> String: 18 | # return "" 19 | 20 | func _get_return_icon_type(): 21 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 22 | 23 | func _get_input_port_count() -> int: 24 | return 3 25 | 26 | func _get_input_port_name(port: int): 27 | match port: 28 | 0: 29 | return "color" 30 | 1: 31 | return "alpha" 32 | 2: 33 | return "strength" 34 | 35 | func _get_input_port_type(port: int): 36 | match port: 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 39 | 1: 40 | return VisualShaderNode.PORT_TYPE_SCALAR 41 | 2: 42 | return VisualShaderNode.PORT_TYPE_SCALAR 43 | 44 | func _get_output_port_count() -> int: 45 | return 2 46 | 47 | func _get_output_port_name(port: int): 48 | match port: 49 | 0: 50 | return "col" 51 | 1: 52 | return "alpha" 53 | 54 | func _get_output_port_type(port: int): 55 | match port: 56 | 0: 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 1: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 61 | func _get_global_code(mode): 62 | var path = self.get_script().get_path().get_base_dir() 63 | return '#include "' + path + '/bloom.gdshaderinc"' 64 | 65 | func _get_code(input_vars, output_vars, mode, type): 66 | return """vec4 %s%s = _bloomFunc(vec4(%s, %s), %s); 67 | %s = %s%s.rgb; 68 | %s = %s%s.a;""" % [ 69 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], 70 | output_vars[0], output_vars[0], output_vars[1], 71 | output_vars[1], output_vars[0], output_vars[1]] 72 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/swirlUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVswirl 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0.0)) 7 | set_input_port_default_value(2, 0.0) 8 | set_input_port_default_value(3, 0.0) 9 | 10 | func _get_name() -> String: 11 | return "SwirlUV" 12 | 13 | func _get_category() -> String: 14 | return "UV" 15 | 16 | func _get_subcategory() -> String: 17 | return "Animated" 18 | 19 | func _get_description() -> String: 20 | return "Swirl UV effect" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "pivot" 34 | 2: 35 | return "strength" 36 | 3: 37 | return "sin_time" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 1 52 | 53 | func _get_output_port_name(port: int) -> String: 54 | return "uv" 55 | 56 | func _get_output_port_type(port): 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 59 | func _get_global_code(mode): 60 | var path = self.get_script().get_path().get_base_dir() 61 | return '#include "' + path + '/swirlUV.gdshaderinc"' 62 | 63 | func _get_code(input_vars, output_vars, mode, type): 64 | var uv = "UV" 65 | 66 | if input_vars[0]: 67 | uv = input_vars[0] 68 | 69 | return "%s.xy = _swirlUVFunc(%s.xy, %s, %s.xy, %s);" % [ 70 | output_vars[0], uv, input_vars[3], input_vars[1], input_vars[2]] 71 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/simplex2d_fractal.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec3 _permute_simplex2_noise_fractal(vec3 x) { 2 | return ((x*34.0)+1.0)*x-floor(((x*34.0)+1.0)*x*(1.0/289.0))*289.0; 3 | } 4 | 5 | float _simplex2dNoiseFractalFunc(vec2 v) { 6 | vec4 C = vec4(0.211324865405187, 7 | 0.366025403784439, 8 | -0.577350269189626, 9 | 0.024390243902439); 10 | 11 | vec2 i = floor(v + dot(v, C.yy) ); 12 | vec2 x0 = v - i + dot(i, C.xx); 13 | 14 | vec2 i1; 15 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 16 | vec4 x12 = vec4(x0.xy, x0.xy) + C.xxzz; 17 | x12.xy -= i1; 18 | 19 | i = i - floor(i * (1.0 / 289.0)) * 289.0; 20 | vec3 p = _permute_simplex2_noise_fractal(_permute_simplex2_noise_fractal(i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0)); 21 | 22 | vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), vec3(0.0)); 23 | m = m * m; 24 | m = m * m; 25 | 26 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 27 | vec3 h = abs(x) - 0.5; 28 | vec3 ox = floor(x + 0.5); 29 | vec3 a0 = x - ox; 30 | 31 | m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h); 32 | 33 | vec3 g; 34 | g.x = a0.x * x0.x + h.x * x0.y; 35 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 36 | return 130.0 * dot(m, g); 37 | } 38 | float _simplexNoise2DFBM(vec2 _uv_sn2fbm, int _oct_sn2fbm, vec2 _per_sn2fbm, float _lac_sn2fbm, 39 | float _persist_sn2fbm, float _rot_sn2fbm, float _ampl_sn2fbm, vec2 _shift_sn2fbm) { 40 | float _v = 0.0; 41 | float _a = _ampl_sn2fbm; 42 | mat2 _r0t = mat2(vec2(cos(_rot_sn2fbm), sin(_rot_sn2fbm)), vec2(-sin(_rot_sn2fbm), cos(_rot_sn2fbm))); 43 | for (int i = 0; i < _oct_sn2fbm; ++i) { 44 | _v += _a * _simplex2dNoiseFractalFunc(_uv_sn2fbm * _per_sn2fbm); 45 | _uv_sn2fbm = _r0t * _uv_sn2fbm * _lac_sn2fbm + _shift_sn2fbm; 46 | _a *= _persist_sn2fbm; 47 | } 48 | return (min(_v, 1.0) + 1.0) * 0.5; 49 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2x2.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley2x2 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "WorleyNoise2x2" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory() -> String: 17 | return "Noise" 18 | 19 | func _get_description() -> String: 20 | return "2x2 worley noise" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_SCALAR 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "offset" 34 | 2: 35 | return "scale" 36 | 3: 37 | return "jitter" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 1 52 | 53 | func _get_output_port_name(port: int) -> String: 54 | return "F1" 55 | 56 | func _get_output_port_type(port): 57 | return VisualShaderNode.PORT_TYPE_SCALAR 58 | 59 | func _get_global_code(mode): 60 | var path = self.get_script().get_path().get_base_dir() 61 | return '#include "' + path + '/worley2x2.gdshaderinc"' 62 | 63 | func _get_code(input_vars, output_vars, mode, type): 64 | var uv = "UV" 65 | 66 | if input_vars[0]: 67 | uv = input_vars[0] 68 | 69 | return "%s = _cellular2x2NoiseFunc((%s.xy+%s.xy)*%s, min(max(%s, 0.0), 1.0));" % [ 70 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3]] 71 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/maskAlpha.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAmaskAlpha 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(2, 1.0) 8 | 9 | func _get_name() -> String: 10 | return "MaskAlpha" 11 | 12 | func _get_category() -> String: 13 | return "RGBA" 14 | 15 | #func _get_subcategory(): 16 | # return "" 17 | 18 | func _get_description() -> String: 19 | return "Color masking based on mask alpha" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 3 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "color" 31 | 1: 32 | return "alpha" 33 | 2: 34 | return "maskAlpha" 35 | 36 | func _get_input_port_type(port: int): 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_SCALAR 44 | 45 | func _get_output_port_count() -> int: 46 | return 2 47 | 48 | func _get_output_port_name(port: int): 49 | match port: 50 | 0: 51 | return "col" 52 | 1: 53 | return "alpha" 54 | 55 | func _get_output_port_type(port: int): 56 | match port: 57 | 0: 58 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 59 | 1: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 62 | func _get_global_code(mode): 63 | var path = self.get_script().get_path().get_base_dir() 64 | return '#include "' + path + '/maskAlpha.gdshaderinc"' 65 | 66 | func _get_code(input_vars, output_vars, mode, type): 67 | return """%s = _maskAlphaFunc(vec4(%s, %s), %s).rgb; 68 | %s = _maskAlphaFunc(vec4(%s, %s), %s).a;""" % [ 69 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], 70 | output_vars[1], input_vars[0], input_vars[1], input_vars[2]] 71 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/perlin3d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlin3d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 0.0) 9 | 10 | func _get_name() -> String: 11 | return "PerlinNoise3D" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory() -> String: 17 | return "Noise" 18 | 19 | func _get_description() -> String: 20 | return "Classic 3d perlin noise" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_SCALAR 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "offset" 34 | 2: 35 | return "scale" 36 | 3: 37 | return "time" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 1 52 | 53 | func _get_output_port_name(port: int): 54 | match port: 55 | 0: 56 | return "result" 57 | 58 | func _get_output_port_type(port: int): 59 | match port: 60 | 0: 61 | return VisualShaderNode.PORT_TYPE_SCALAR 62 | 63 | func _get_global_code(mode): 64 | var path = self.get_script().get_path().get_base_dir() 65 | return '#include "' + path + '/perlin3d.gdshaderinc"' 66 | 67 | func _get_code(input_vars, output_vars, mode, type): 68 | var uv = "UV" 69 | 70 | if input_vars[0]: 71 | uv = input_vars[0] 72 | 73 | return "%s = _perlin3dNoiseFunc(vec3((%s.xy+%s.xy) * %s, %s));" % [ 74 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3]] 75 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex3d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseSimplex3d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 0.0) 9 | 10 | func _get_name() -> String: 11 | return "SimplexNoise3D" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory() -> String: 17 | return "Noise" 18 | 19 | func _get_description() -> String: 20 | return "3d simplex noise" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_SCALAR 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "offset" 34 | 2: 35 | return "scale" 36 | 3: 37 | return "time" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 1 52 | 53 | func _get_output_port_name(port: int): 54 | match port: 55 | 0: 56 | return "result" 57 | 58 | func _get_output_port_type(port: int): 59 | match port: 60 | 0: 61 | return VisualShaderNode.PORT_TYPE_SCALAR 62 | 63 | func _get_global_code(mode): 64 | var path = self.get_script().get_path().get_base_dir() 65 | return '#include "' + path + '/simplex3d.gdshaderinc"' 66 | 67 | func _get_code(input_vars, output_vars, mode, type): 68 | var uv = "UV" 69 | 70 | if input_vars[0]: 71 | uv = input_vars[0] 72 | 73 | return "%s = _simplex3dNoiseFunc(vec3((%s.xy + %s.xy) * %s, %s));" % [ 74 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3]] 75 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/rotateAnimated.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVrotateAnimated 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.5) 7 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 8 | 9 | func _get_name() -> String: 10 | return "RotateUVAnimated" 11 | 12 | func _get_category() -> String: 13 | return "UV" 14 | 15 | func _get_subcategory() -> String: 16 | return "Animated" 17 | 18 | func _get_description() -> String: 19 | return "Animated UV rotation by angle in radians relative to pivot point" 20 | 21 | func _get_return_icon_type(): 22 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 23 | 24 | func _get_input_port_count() -> int: 25 | return 4 26 | 27 | func _get_input_port_name(port: int): 28 | match port: 29 | 0: 30 | return "uv" 31 | 1: 32 | return "angularSpeed" 33 | 2: 34 | return "pivot" 35 | 3: 36 | return "time" 37 | 38 | func _get_input_port_type(port: int): 39 | match port: 40 | 0: 41 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 42 | 1: 43 | return VisualShaderNode.PORT_TYPE_SCALAR 44 | 2: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 3: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 49 | 50 | func _get_output_port_count() -> int: 51 | return 1 52 | 53 | func _get_output_port_name(port: int) -> String: 54 | return "uv" 55 | 56 | func _get_output_port_type(port: int): 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 59 | func _get_global_code(mode): 60 | var path = self.get_script().get_path().get_base_dir() 61 | return '#include "' + path + '/rotateAnimated.gdshaderinc"' 62 | 63 | func _get_code(input_vars, output_vars, mode, type): 64 | var uv = "UV" 65 | 66 | if input_vars[0]: 67 | uv = input_vars[0] 68 | 69 | return output_vars[0] + " = vec3(_rotateUVAnimatedFunc(%s.xy, %s.xy, 0.0, %s, %s), 0);" % [ 70 | uv, input_vars[2], input_vars[1], input_vars[3]] 71 | -------------------------------------------------------------------------------- /addons/shaderV/uv/tileUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtile 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 2.0) 7 | set_input_port_default_value(2, 2.0) 8 | set_input_port_default_value(3, 0.0) 9 | 10 | func _get_name() -> String: 11 | return "TileUV" 12 | 13 | func _get_category() -> String: 14 | return "UV" 15 | 16 | #func _get_subcategory() -> String: 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return """Tile UV can be used to get UV position of tile within a tilemap. 21 | [uv] - uv of tileset; 22 | [Vframes] - the number of rows; 23 | [Hframes] - the number of columns; 24 | [frame] - current frame;""" 25 | 26 | func _get_return_icon_type(): 27 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 28 | 29 | func _get_input_port_count() -> int: 30 | return 4 31 | 32 | func _get_input_port_name(port: int): 33 | match port: 34 | 0: 35 | return "uv" 36 | 1: 37 | return "Vframes" 38 | 2: 39 | return "Hframes" 40 | 3: 41 | return "frame" 42 | 43 | func _get_input_port_type(port: int): 44 | match port: 45 | 0: 46 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 47 | 1: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 2: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 3: 52 | return VisualShaderNode.PORT_TYPE_SCALAR 53 | 54 | func _get_output_port_count() -> int: 55 | return 1 56 | 57 | func _get_output_port_name(port: int) -> String: 58 | return "uv" 59 | 60 | func _get_output_port_type(port): 61 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 62 | 63 | func _get_global_code(mode): 64 | var path = self.get_script().get_path().get_base_dir() 65 | return '#include "' + path + '/tileUV.gdshaderinc"' 66 | 67 | func _get_code(input_vars, output_vars, mode, type): 68 | var uv = "UV" 69 | 70 | if input_vars[0]: 71 | uv = input_vars[0] 72 | 73 | return "%s.xy = _tileMapUV(%s.xy, %s, %s, %s);" % [ 74 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3]] 75 | -------------------------------------------------------------------------------- /addons/shaderV/uv/distortionUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVdistortion 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.0) 7 | set_input_port_default_value(2, 0.0) 8 | set_input_port_default_value(3, 0.0) 9 | set_input_port_default_value(4, 0.0) 10 | 11 | func _get_name() -> String: 12 | return "DistortionUV" 13 | 14 | func _get_category() -> String: 15 | return "UV" 16 | 17 | #func _get_subcategory(): 18 | # return "" 19 | 20 | func _get_description() -> String: 21 | return "Wave-like UV distortion" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "waveX" 35 | 2: 36 | return "waveY" 37 | 3: 38 | return "distortX" 39 | 4: 40 | return "distortY" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 1 57 | 58 | func _get_output_port_name(port: int) -> String: 59 | return "uv" 60 | 61 | func _get_output_port_type(port): 62 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 63 | 64 | func _get_global_code(mode): 65 | var path = self.get_script().get_path().get_base_dir() 66 | return '#include "' + path + '/distortionUV.gdshaderinc"' 67 | 68 | func _get_code(input_vars, output_vars, mode, type): 69 | var uv = "UV" 70 | 71 | if input_vars[0]: 72 | uv = input_vars[0] 73 | 74 | return "%s.xy = _distortionUV(%s.xy, vec2(%s, %s), vec2(%s, %s));" % [ 75 | output_vars[0], uv, input_vars[3], input_vars[4], input_vars[1], input_vars[2]] 76 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/shiftHSV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAshiftHSV 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.0) 7 | set_input_port_default_value(2, 1.0) 8 | set_input_port_default_value(3, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "ShiftHSV" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return """Changes hue, saturation and value of input color. 21 | [hue] will be added to [color] hue, so [col].hue = [color].hue + [hue]. 22 | [color] saturation and value will be multiplied by [sat] and [value], so [col].saturation(OR)value = [color].saturation(OR)value +* [sat](OR)[value]""" 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 4 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "color" 34 | 1: 35 | return "hue" 36 | 2: 37 | return "sat" 38 | 3: 39 | return "value" 40 | 41 | func _get_input_port_type(port: int): 42 | match port: 43 | 0: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 1: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 2: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 3: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 52 | func _get_output_port_count() -> int: 53 | return 1 54 | 55 | func _get_output_port_name(port: int) -> String: 56 | return "col" 57 | 58 | func _get_output_port_type(port): 59 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 60 | 61 | func _get_global_code(mode): 62 | var path = self.get_script().get_path().get_base_dir() 63 | return '#include "' + path + '/shiftHSV.gdshaderinc"' 64 | 65 | func _get_code(input_vars, output_vars, mode, type): 66 | return "%s = _hsvChangeHSVChangeFunc(%s, %s, %s, %s);" % [ 67 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 68 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/perlin2d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlin2d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, Vector3(0.0, 0.0, 0.0)) 9 | 10 | func _get_name() -> String: 11 | return "PerlinNoise2D" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory() -> String: 17 | return "Noise" 18 | 19 | func _get_description() -> String: 20 | return """Classic 2d perlin noise with ability to set period. 21 | If you dont want any peroid - set it to zero""" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_SCALAR 25 | 26 | func _get_input_port_count() -> int: 27 | return 4 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "offset" 35 | 2: 36 | return "scale" 37 | 3: 38 | return "period" 39 | 40 | func _get_input_port_type(port: int): 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 50 | 51 | func _get_output_port_count() -> int: 52 | return 1 53 | 54 | func _get_output_port_name(port: int): 55 | match port: 56 | 0: 57 | return "result" 58 | 59 | func _get_output_port_type(port: int): 60 | match port: 61 | 0: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 64 | func _get_global_code(mode): 65 | var path = self.get_script().get_path().get_base_dir() 66 | return '#include "' + path + '/perlin2d.gdshaderinc"' 67 | 68 | func _get_code(input_vars, output_vars, mode, type): 69 | var uv = "UV" 70 | 71 | if input_vars[0]: 72 | uv = input_vars[0] 73 | 74 | return "%s = _perlin2dNoiseFunc((%s.xy+%s.xy)*%s, %s.xy);" % [ 75 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3]] 76 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2x2x2.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley2x2x2 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 1.0) 9 | set_input_port_default_value(4, 0.0) 10 | 11 | func _get_name() -> String: 12 | return "WorleyNoise2x2x2" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory() -> String: 18 | return "Noise" 19 | 20 | func _get_description() -> String: 21 | return "2x2x2 worley noise" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_SCALAR 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "offset" 35 | 2: 36 | return "scale" 37 | 3: 38 | return "jitter" 39 | 4: 40 | return "time" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 1 57 | 58 | func _get_output_port_name(port: int) -> String: 59 | return "F1" 60 | 61 | func _get_output_port_type(port): 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 64 | func _get_global_code(mode): 65 | var path = self.get_script().get_path().get_base_dir() 66 | return '#include "' + path + '/worley2x2x2.gdshaderinc"' 67 | 68 | func _get_code(input_vars, output_vars, mode, type): 69 | var uv = "UV" 70 | 71 | if input_vars[0]: 72 | uv = input_vars[0] 73 | 74 | return "%s = _cellular2x2x2NoiseFunc(vec3((%s.xy + %s.xy) * %s, %s), min(max(%s, 0.0), 1.0));" % [ 75 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[4], input_vars[3]] 76 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex3d.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _permute_simplex3_noise(vec4 x) { 2 | return ((x * 34.0) + 1.0) * x - floor(((x * 34.0) + 1.0) * x * (1.0 / 289.0)) * 289.0; 3 | } 4 | float _simplex3dNoiseFunc(vec3 v) { 5 | vec2 C = vec2(1.0/6.0, 1.0/3.0) ; 6 | vec4 D = vec4(0.0, 0.5, 1.0, 2.0); 7 | 8 | vec3 i = floor(v + dot(v, vec3(C.y))); 9 | vec3 x0 = v - i + dot(i, vec3(C.x)) ; 10 | 11 | vec3 g = step(x0.yzx, x0.xyz); 12 | vec3 l = 1.0 - g; 13 | vec3 i1 = min( g.xyz, l.zxy ); 14 | vec3 i2 = max( g.xyz, l.zxy ); 15 | 16 | vec3 x1 = x0 - i1 + vec3(C.x); 17 | vec3 x2 = x0 - i2 + vec3(C.y); 18 | vec3 x3 = x0 - D.yyy; 19 | 20 | i = i - floor(i * (1.0 / 289.0)) * 289.0; 21 | vec4 p = _permute_simplex3_noise(_permute_simplex3_noise(_permute_simplex3_noise( 22 | i.z + vec4(0.0, i1.z, i2.z, 1.0)) 23 | + i.y + vec4(0.0, i1.y, i2.y, 1.0)) 24 | + i.x + vec4(0.0, i1.x, i2.x, 1.0)); 25 | 26 | float n_ = 0.142857142857; 27 | vec3 ns = n_ * D.wyz - D.xzx; 28 | 29 | vec4 j = p - 49.0 * floor(p * ns.z * ns.z); 30 | 31 | vec4 x_ = floor(j * ns.z); 32 | vec4 y_ = floor(j - 7.0 * x_ ); 33 | 34 | vec4 x = x_ *ns.x + vec4(ns.y); 35 | vec4 y = y_ *ns.x + vec4(ns.y); 36 | vec4 h = 1.0 - abs(x) - abs(y); 37 | 38 | vec4 b0 = vec4( x.xy, y.xy ); 39 | vec4 b1 = vec4( x.zw, y.zw ); 40 | 41 | vec4 s0 = floor(b0)*2.0 + 1.0; 42 | vec4 s1 = floor(b1)*2.0 + 1.0; 43 | vec4 sh = -step(h, vec4(0.0)); 44 | 45 | vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ; 46 | vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ; 47 | 48 | vec3 p0 = vec3(a0.xy,h.x); 49 | vec3 p1 = vec3(a0.zw,h.y); 50 | vec3 p2 = vec3(a1.xy,h.z); 51 | vec3 p3 = vec3(a1.zw,h.w); 52 | 53 | vec4 norm = 2.79284291400159 - 0.85373472095314 * vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)); 54 | p0 *= norm.x; 55 | p1 *= norm.y; 56 | p2 *= norm.z; 57 | p3 *= norm.w; 58 | 59 | vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), vec4(0.0)); 60 | m = m * m; 61 | return (22.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3) ) ) + 1.0) * 0.5; 62 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex4d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseSimplex4d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 1.0) 9 | set_input_port_default_value(4, 0.0) 10 | 11 | func _get_name() -> String: 12 | return "SimplexNoise4D" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory() -> String: 18 | return "Noise" 19 | 20 | func _get_description() -> String: 21 | return "4d simplex noise" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_SCALAR 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "offset" 35 | 2: 36 | return "scale" 37 | 3: 38 | return "z" 39 | 4: 40 | return "time" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 1 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "result" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 68 | func _get_global_code(mode): 69 | var path = self.get_script().get_path().get_base_dir() 70 | return '#include "' + path + '/simplex4d.gdshaderinc"' 71 | 72 | func _get_code(input_vars, output_vars, mode, type): 73 | var uv = "UV" 74 | 75 | if input_vars[0]: 76 | uv = input_vars[0] 77 | 78 | return "%s = _simplex4dNoiseFunc(vec4((%s.xy + %s.xy) * %s, %s, %s));" % [ 79 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], input_vars[4]] 80 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/perlin4d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlin4d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 1.0) 9 | set_input_port_default_value(4, 0.0) 10 | 11 | func _get_name() -> String: 12 | return "PerlinNoise4D" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory() -> String: 18 | return "Noise" 19 | 20 | func _get_description() -> String: 21 | return "Classic 4d perlin noise" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_SCALAR 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "offset" 35 | 2: 36 | return "scale" 37 | 3: 38 | return "z" 39 | 4: 40 | return "time" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 1 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "result" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 68 | func _get_global_code(mode): 69 | var path = self.get_script().get_path().get_base_dir() 70 | return '#include "' + path + '/perlin4d.gdshaderinc"' 71 | 72 | func _get_code(input_vars, output_vars, mode, type): 73 | var uv = "UV" 74 | 75 | if input_vars[0]: 76 | uv = input_vars[0] 77 | 78 | return "%s = _perlin4dNoiseFunc(vec4((%s.xy + %s.xy) * %s, %s, %s));" % [ 79 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], input_vars[4]] 80 | -------------------------------------------------------------------------------- /addons/shaderV/tools/remap.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRemap 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.0) 7 | set_input_port_default_value(2, 1.0) 8 | set_input_port_default_value(3, -1.0) 9 | set_input_port_default_value(4, 1.0) 10 | 11 | func _get_name() -> String: 12 | return "Remap" 13 | 14 | func _get_category() -> String: 15 | return "Tools" 16 | 17 | #func _get_subcategory(): 18 | # return "" 19 | 20 | func _get_description() -> String: 21 | return "Remaps input value from ( [inMin], [inMax] ) range to ( [outMin], [outMax] ). UV is default input value." 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "input" 33 | 1: 34 | return "inMin" 35 | 2: 36 | return "inMin" 37 | 3: 38 | return "outMin" 39 | 4: 40 | return "outMax" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | 56 | func _get_output_port_count() -> int: 57 | return 1 58 | 59 | func _get_output_port_name(port ) -> String: 60 | return "out" 61 | 62 | func _get_output_port_type(port): 63 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 64 | 65 | func _get_global_code(mode): 66 | var path = self.get_script().get_path().get_base_dir() 67 | return '#include "' + path + '/remap.gdshaderinc"' 68 | 69 | func _get_code(input_vars, output_vars, mode, type): 70 | var uv = "UV" 71 | 72 | if input_vars[0]: 73 | uv = input_vars[0] 74 | 75 | return output_vars[0] + " = _remapFunc(%s, vec2(%s, %s), vec2(%s, %s));" % [ 76 | uv, input_vars[1], input_vars[2], input_vars[3], input_vars[4]] 77 | 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/chekerboardPattern.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateCheckerboard 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(8.0, 8.0, 0.0)) 7 | set_input_port_default_value(2, Vector3(1.0, 1.0, 1.0)) 8 | set_input_port_default_value(3, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "CheckerboardShape" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory(): 17 | return "Shapes" 18 | 19 | func _get_description() -> String: 20 | return "Creates checkerboard pattern" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "amount" 34 | 2: 35 | return "color" 36 | 3: 37 | return "alpha" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 2 52 | 53 | func _get_output_port_name(port: int): 54 | match port: 55 | 0: 56 | return "col" 57 | 1: 58 | return "alpha" 59 | 60 | func _get_output_port_type(port: int): 61 | match port: 62 | 0: 63 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 64 | 1: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 67 | func _get_global_code(mode): 68 | var path = self.get_script().get_path().get_base_dir() 69 | return '#include "' + path + '/chekerboardPattern.gdshaderinc"' 70 | 71 | func _get_code(input_vars, output_vars, mode, type): 72 | var uv = "UV" 73 | 74 | if input_vars[0]: 75 | uv = input_vars[0] 76 | 77 | return """%s = %s; 78 | %s = _checkerboardPatternFunc(%s.xy, %s.xy) * %s;""" % [ 79 | output_vars[0], input_vars[2], 80 | output_vars[1], uv, input_vars[1], input_vars[3]] 81 | -------------------------------------------------------------------------------- /addons/shaderV/uv/sphericalUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVspherical 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(1.0, 1.0, 0.0)) 7 | set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0)) 8 | set_input_port_default_value(3, Vector3(0.5, 0.5, 0.0)) 9 | set_input_port_default_value(4, Vector3(0.0, 0.0, 0.0)) 10 | 11 | func _get_name() -> String: 12 | return "SphericalUV" 13 | 14 | func _get_category() -> String: 15 | return "UV" 16 | 17 | #func _get_subcategory() -> String: 18 | # return "" 19 | 20 | func _get_description() -> String: 21 | return "Makes UV look like a sphere. Can be used to make 2d planets" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "radius" 35 | 2: 36 | return "spin" 37 | 3: 38 | return "position" 39 | 4: 40 | return "local position" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 54 | 55 | func _get_output_port_count() -> int: 56 | return 1 57 | 58 | func _get_output_port_name(port: int) -> String: 59 | return "uv" 60 | 61 | func _get_output_port_type(port): 62 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 63 | 64 | func _get_global_code(mode): 65 | var path = self.get_script().get_path().get_base_dir() 66 | return '#include "' + path + '/sphericalUV.gdshaderinc"' 67 | 68 | func _get_code(input_vars, output_vars, mode, type): 69 | var uv = "UV" 70 | 71 | if input_vars[0]: 72 | uv = input_vars[0] 73 | 74 | return "%s.xy = _sphericalUV(%s.xy, %s.xy, %s.xy, %s.xy, %s.xy);" % [ 75 | output_vars[0], uv, input_vars[3], input_vars[1], input_vars[2], input_vars[4]] 76 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/doodleUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVdoodle 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.5) 7 | set_input_port_default_value(2, 4) 8 | set_input_port_default_value(3, 0.7) 9 | set_input_port_default_value(4, 0.065) 10 | set_input_port_default_value(5, 0.0) 11 | 12 | func _get_name() -> String: 13 | return "DoodleUV" 14 | 15 | func _get_category() -> String: 16 | return "UV" 17 | 18 | func _get_subcategory() -> String: 19 | return "Animated" 20 | 21 | func _get_description() -> String: 22 | return "Doodle UV effect" 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 6 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "uv" 34 | 1: 35 | return "frameTime" 36 | 2: 37 | return "frameCount" 38 | 3: 39 | return "lacunarity" 40 | 4: 41 | return "maxOffset" 42 | 5: 43 | return "time" 44 | 45 | func _get_input_port_type(port: int): 46 | match port: 47 | 0: 48 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 49 | 1: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 2: 52 | return VisualShaderNode.PORT_TYPE_SCALAR 53 | 3: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 4: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 5: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 60 | func _get_output_port_count() -> int: 61 | return 1 62 | 63 | func _get_output_port_name(port: int) -> String: 64 | return "uv" 65 | 66 | func _get_output_port_type(port): 67 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 68 | 69 | func _get_global_code(mode): 70 | var path = self.get_script().get_path().get_base_dir() 71 | return '#include "' + path + '/doodleUV.gdshaderinc"' 72 | 73 | func _get_code(input_vars, output_vars, mode, type): 74 | var uv = "UV" 75 | 76 | if input_vars[0]: 77 | uv = input_vars[0] 78 | 79 | return "%s.xy = _doodleUVFunc(%s.xy, %s, %s, %s, int(%s), %s);" % [ 80 | output_vars[0], uv, input_vars[4], input_vars[5], input_vars[1], input_vars[2], input_vars[3]] 81 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/perlinPeriodic3d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlinPeriodic3d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, Vector3(0.0, 0.0, 0.0)) 9 | set_input_port_default_value(4, 0.0) 10 | 11 | func _get_name() -> String: 12 | return "PerlinPeriodicNoise3D" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory() -> String: 18 | return "Noise" 19 | 20 | func _get_description() -> String: 21 | return "Classic 3d perlin noise with ability to set period" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_SCALAR 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "offset" 35 | 2: 36 | return "scale" 37 | 3: 38 | return "period" 39 | 4: 40 | return "time" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 1 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "result" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 68 | func _get_global_code(mode): 69 | var path = self.get_script().get_path().get_base_dir() 70 | return '#include "' + path + '/perlinPeriodic3d.gdshaderinc"' 71 | 72 | func _get_code(input_vars, output_vars, mode, type): 73 | var uv = "UV" 74 | 75 | if input_vars[0]: 76 | uv = input_vars[0] 77 | 78 | return "%s = _perlin3dPeriodicNoiseFunc(vec3((%s.xy + %s.xy) * %s, %s), %s);" % [ 79 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[4], input_vars[3]] 80 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley2d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "WorleyNoise2D" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory() -> String: 17 | return "Noise" 18 | 19 | func _get_description() -> String: 20 | return "2d worley noise" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "uv" 32 | 1: 33 | return "offset" 34 | 2: 35 | return "scale" 36 | 3: 37 | return "jitter" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 2 52 | 53 | func _get_output_port_name(port: int): 54 | match port: 55 | 0: 56 | return "F1" 57 | 1: 58 | return "F2" 59 | 60 | func _get_output_port_type(port: int): 61 | match port: 62 | 0: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 1: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 67 | func _get_global_code(mode): 68 | var path = self.get_script().get_path().get_base_dir() 69 | return '#include "' + path + '/worley2d.gdshaderinc"' 70 | 71 | func _get_code(input_vars, output_vars, mode, type): 72 | var uv = "UV" 73 | 74 | if input_vars[0]: 75 | uv = input_vars[0] 76 | 77 | return """vec2 %s%s = _cellular2dNoiseFunc((%s.xy+%s.xy)*%s, min(max(%s, 0.0), 1.0)); 78 | %s = %s%s.x; 79 | %s = %s%s.y;""" % [ 80 | output_vars[0], output_vars[1], uv, input_vars[1], input_vars[2], input_vars[3], 81 | output_vars[0], output_vars[0], output_vars[1], 82 | output_vars[1], output_vars[0], output_vars[1]] 83 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blendAwithB.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblend 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(3, 1.0) 8 | set_input_port_default_value(4, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "BlendAwithB" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return "Blends colors basing on fade" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 5 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "colorDown" 32 | 1: 33 | return "alphaDown" 34 | 2: 35 | return "colorUp" 36 | 3: 37 | return "alphaUp" 38 | 4: 39 | return "fade" 40 | 41 | func _get_input_port_type(port: int): 42 | match port: 43 | 0: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 1: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 2: 48 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 49 | 3: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 4: 52 | return VisualShaderNode.PORT_TYPE_SCALAR 53 | 54 | func _get_output_port_count() -> int: 55 | return 2 56 | 57 | func _get_output_port_name(port: int): 58 | match port: 59 | 0: 60 | return "col" 61 | 1: 62 | return "alpha" 63 | 64 | func _get_output_port_type(port: int): 65 | match port: 66 | 0: 67 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 68 | 1: 69 | return VisualShaderNode.PORT_TYPE_SCALAR 70 | 71 | func _get_global_code(mode): 72 | var path = self.get_script().get_path().get_base_dir() 73 | return '#include "' + path + '/blendAwithB.gdshaderinc"' 74 | 75 | func _get_code(input_vars, output_vars, mode, type): 76 | return """vec4 %s%s = _blendAwithBFunc(vec4(%s, %s), vec4(%s, %s), %s); 77 | %s = %s%s.rgb; 78 | %s = %s%s.a;""" % [ 79 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], 80 | output_vars[0], output_vars[0], output_vars[1], 81 | output_vars[1], output_vars[0], output_vars[1]] 82 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/stripesRandom.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateStripesRandom 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.5) 7 | set_input_port_default_value(2, 20.0) 8 | set_input_port_default_value(3, Vector3(1.0, 1.0, 1.0)) 9 | set_input_port_default_value(4, 1.0) 10 | 11 | func _get_name() -> String: 12 | return "RandomStripesShape" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory(): 18 | return "Shapes" 19 | 20 | func _get_description() -> String: 21 | return "Random horizontal lines creation" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "fill" 35 | 2: 36 | return "amount" 37 | 3: 38 | return "color" 39 | 4: 40 | return "alpha" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 2 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "col" 62 | 1: 63 | return "alpha" 64 | 65 | func _get_output_port_type(port: int): 66 | match port: 67 | 0: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 1: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 72 | func _get_global_code(mode): 73 | var path = self.get_script().get_path().get_base_dir() 74 | return '#include "' + path + '/stripesRandom.gdshaderinc"' 75 | 76 | func _get_code(input_vars, output_vars, mode, type): 77 | var uv = "UV" 78 | 79 | if input_vars[0]: 80 | uv = input_vars[0] 81 | 82 | return """%s = %s; 83 | %s = _generateRandomStripesFunc(%s.xy, %s, %s) * float(%s);""" % [output_vars[0], input_vars[3], 84 | output_vars[1], uv, input_vars[1], input_vars[2], input_vars[4]] 85 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/blur9sample.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblur9sample 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 0.5) 8 | 9 | func _get_name() -> String: 10 | return "BlurBasic" 11 | 12 | func _get_category() -> String: 13 | return "RGBA" 14 | 15 | func _get_subcategory(): 16 | return "Blur" 17 | 18 | func _get_description() -> String: 19 | return """Basic 8-directional blur with 9 samples 20 | Note: negative lod => detect lod automatically""" 21 | 22 | func _get_return_icon_type(): 23 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 24 | 25 | func _get_input_port_count() -> int: 26 | return 4 27 | 28 | func _get_input_port_name(port: int): 29 | match port: 30 | 0: 31 | return "sampler2D" 32 | 1: 33 | return "uv" 34 | 2: 35 | return "lod" 36 | 3: 37 | return "radius" 38 | 39 | func _get_input_port_type(port: int): 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_SAMPLER 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 50 | func _get_output_port_count() -> int: 51 | return 2 52 | 53 | func _get_output_port_name(port: int): 54 | match port: 55 | 0: 56 | return "col" 57 | 1: 58 | return "alpha" 59 | 60 | func _get_output_port_type(port: int): 61 | match port: 62 | 0: 63 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 64 | 1: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 67 | func _get_global_code(mode): 68 | var path = self.get_script().get_path().get_base_dir() 69 | return '#include "' + path + '/blur9sample.gdshaderinc"' 70 | 71 | func _get_code(input_vars, output_vars, mode, type): 72 | var texture = "TEXTURE" 73 | var uv = "UV" 74 | 75 | if input_vars[0]: 76 | texture = input_vars[0] 77 | if input_vars[1]: 78 | uv = input_vars[1] 79 | 80 | return """vec4 %s%s = _blur9sampleFunc(%s, %s.xy, %s, %s); 81 | %s = %s%s.rgb; 82 | %s = %s%s.a;""" % [ 83 | output_vars[0], output_vars[1], texture, uv, input_vars[2], input_vars[3], 84 | output_vars[0], output_vars[0], output_vars[1], 85 | output_vars[1], output_vars[0], output_vars[1]] 86 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/perlin2d_fractal.gdshaderinc: -------------------------------------------------------------------------------- 1 | float _perlin2dNoiseFuncFractal(vec2 P) { 2 | vec4 Pi = floor(vec4(P, P)) + vec4(0.0, 0.0, 1.0, 1.0); 3 | vec4 Pf = fract(vec4(P, P)) - vec4(0.0, 0.0, 1.0, 1.0); 4 | 5 | Pi = Pi - floor(Pi * (1.0 / 289.0)) * 289.0; 6 | vec4 ix = Pi.xzxz; 7 | vec4 iy = Pi.yyww; 8 | vec4 fx = Pf.xzxz; 9 | vec4 fy = Pf.yyww; 10 | 11 | vec4 i = (((((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy)*34.0)+1.0)* 12 | ((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy))- 13 | floor((((((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy)*34.0)+1.0)* 14 | ((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy))*(1.0/289.0))*289.0; 15 | 16 | vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ; 17 | vec4 gy = abs(gx) - 0.5 ; 18 | vec4 tx = floor(gx + 0.5); 19 | gx = gx - tx; 20 | 21 | vec2 g00 = vec2(gx.x,gy.x); 22 | vec2 g10 = vec2(gx.y,gy.y); 23 | vec2 g01 = vec2(gx.z,gy.z); 24 | vec2 g11 = vec2(gx.w,gy.w); 25 | 26 | vec4 norm = 1.79284291400159 - 0.85373472095314 * vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)); 27 | g00 *= norm.x; 28 | g01 *= norm.y; 29 | g10 *= norm.z; 30 | g11 *= norm.w; 31 | 32 | float n00 = dot(g00, vec2(fx.x, fy.x)); 33 | float n10 = dot(g10, vec2(fx.y, fy.y)); 34 | float n01 = dot(g01, vec2(fx.z, fy.z)); 35 | float n11 = dot(g11, vec2(fx.w, fy.w)); 36 | 37 | vec2 fade_xy = Pf.xy * Pf.xy * Pf.xy * (Pf.xy * (Pf.xy * 6.0 - 15.0) + 10.0); 38 | vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x); 39 | float n_xy = mix(n_x.x, n_x.y, fade_xy.y); 40 | return 2.3 * n_xy; 41 | } 42 | float _perlinNoise2DFBM(vec2 _uv_pn2fbm, int _oct_pn2fbm, vec2 _per_pn2fbm, float _lac_pn2fbm, 43 | float _persist_pn2fbm, float _rot_pn2fbm, float _ampl_pn2fbm, vec2 _shift_pn2fbm) { 44 | float _v = 0.0; 45 | float _a = _ampl_pn2fbm; 46 | mat2 _r0t = mat2(vec2(cos(_rot_pn2fbm), sin(_rot_pn2fbm)), vec2(-sin(_rot_pn2fbm), cos(_rot_pn2fbm))); 47 | for (int i = 0; i < _oct_pn2fbm; ++i) { 48 | _v += _a * _perlin2dNoiseFuncFractal(_uv_pn2fbm * _per_pn2fbm); 49 | _uv_pn2fbm = _r0t * _uv_pn2fbm * _lac_pn2fbm + _shift_pn2fbm; 50 | _a *= _persist_pn2fbm; 51 | } 52 | return (min(_v, 1.0) + 1.0) * 0.5; 53 | } -------------------------------------------------------------------------------- /addons/shaderV/uv/transformUV.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtransform 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, Vector3(1, 1, 0)) 8 | set_input_port_default_value(3, Vector3(0.5, 0.5, 0)) 9 | set_input_port_default_value(4, 0.0) 10 | set_input_port_default_value(5, Vector3(0.5, 0.5, 0)) 11 | 12 | func _get_name() -> String: 13 | return "TransformUV" 14 | 15 | func _get_category() -> String: 16 | return "UV" 17 | 18 | #func _get_subcategory(): 19 | # return "" 20 | 21 | func _get_description() -> String: 22 | return "Performs offset, scale and rotation of UV with custom pivots. Rotation is set in radians." 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 6 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "uv" 34 | 1: 35 | return "offset" 36 | 2: 37 | return "scale" 38 | 3: 39 | return "scalePivot" 40 | 4: 41 | return "rotation" 42 | 5: 43 | return "rotationPivot" 44 | 45 | func _get_input_port_type(port: int): 46 | match port: 47 | 0: 48 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 49 | 1: 50 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 51 | 2: 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 3: 54 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 55 | 4: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 5: 58 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 59 | 60 | func _get_output_port_count() -> int: 61 | return 1 62 | 63 | func _get_output_port_name(port: int) -> String: 64 | return "uv" 65 | 66 | func _get_output_port_type(port): 67 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 68 | 69 | func _get_global_code(mode): 70 | var path = self.get_script().get_path().get_base_dir() 71 | return '#include "' + path + '/transformUV.gdshaderinc"' 72 | 73 | func _get_code(input_vars, output_vars, mode, type): 74 | var uv = "UV" 75 | 76 | if input_vars[0]: 77 | uv = input_vars[0] 78 | 79 | return "%s.xy = _transformUV(%s.xy, %s.xy, %s.xy, %s.xy, %s, %s.xy);" % [ 80 | output_vars[0], uv, input_vars[2], input_vars[3], input_vars[1], input_vars[4], input_vars[5]] 81 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/sobelEdge.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAsobelEdge 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 0.001) 8 | set_input_port_default_value(4, false) 9 | set_input_port_default_value(5, false) 10 | 11 | func _get_name() -> String: 12 | return "SobelEdge" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | #func _get_subcategory(): 18 | # return "" 19 | 20 | func _get_description() -> String: 21 | return """Sobel edge filter. Returns detected edges as scalar. 22 | 'scharr' controls if Scharr or Sobel operator is used. 23 | Note: negative lod => detect lod automatically""" 24 | 25 | func _get_return_icon_type(): 26 | return VisualShaderNode.PORT_TYPE_SCALAR 27 | 28 | func _get_input_port_count() -> int: 29 | return 6 30 | 31 | func _get_input_port_name(port: int): 32 | match port: 33 | 0: 34 | return "sampler2D" 35 | 1: 36 | return "uv" 37 | 2: 38 | return "lod" 39 | 3: 40 | return "offset" 41 | 4: 42 | return "preconvertToGray" 43 | 5: 44 | return "scharr" 45 | 46 | func _get_input_port_type(port: int): 47 | match port: 48 | 0: 49 | return VisualShaderNode.PORT_TYPE_SAMPLER 50 | 1: 51 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 52 | 2: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 3: 55 | return VisualShaderNode.PORT_TYPE_SCALAR 56 | 4: 57 | return VisualShaderNode.PORT_TYPE_BOOLEAN 58 | 5: 59 | return VisualShaderNode.PORT_TYPE_BOOLEAN 60 | 61 | func _get_output_port_count() -> int: 62 | return 1 63 | 64 | func _get_output_port_name(port: int) -> String: 65 | return "edges" 66 | 67 | func _get_output_port_type(port): 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 70 | func _get_global_code(mode): 71 | var path = self.get_script().get_path().get_base_dir() 72 | return '#include "' + path + '/sobelEdge.gdshaderinc"' 73 | 74 | func _get_code(input_vars, output_vars, mode, type): 75 | var texture = "TEXTURE" 76 | var uv = "UV" 77 | 78 | if input_vars[0]: 79 | texture = input_vars[0] 80 | if input_vars[1]: 81 | uv = input_vars[1] 82 | 83 | return "%s = _sobelEdgeFunc(%s, %s.xy, %s, %s, %s, %s);" % [ 84 | output_vars[0], texture, uv, input_vars[2], input_vars[3], input_vars[4], input_vars[5]] 85 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley3d.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley3d 4 | 5 | func _init(): 6 | set_input_port_default_value(1, Vector3(0, 0, 0)) 7 | set_input_port_default_value(2, 5.0) 8 | set_input_port_default_value(3, 1.0) 9 | set_input_port_default_value(4, 0.0) 10 | 11 | func _get_name() -> String: 12 | return "WorleyNoise3D" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory() -> String: 18 | return "Noise" 19 | 20 | func _get_description() -> String: 21 | return "3d worley noise" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "uv" 33 | 1: 34 | return "offset" 35 | 2: 36 | return "scale" 37 | 3: 38 | return "jitter" 39 | 4: 40 | return "time" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 2 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "F1" 62 | 1: 63 | return "F2" 64 | 65 | func _get_output_port_type(port: int): 66 | match port: 67 | 0: 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 1: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 72 | func _get_global_code(mode): 73 | var path = self.get_script().get_path().get_base_dir() 74 | return '#include "' + path + '/worley3d.gdshaderinc"' 75 | 76 | func _get_code(input_vars, output_vars, mode, type): 77 | var uv = "UV" 78 | 79 | if input_vars[0]: 80 | uv = input_vars[0] 81 | 82 | return """vec2 %s%s = _cellular3dNoiseFunc(vec3((%s.xy+%s.xy)*%s, %s), min(max(%s, 0.0), 1.0)); 83 | %s = %s%s.x; 84 | %s = %s%s.y;""" % [ 85 | output_vars[0], output_vars[1], uv, input_vars[1], input_vars[2], input_vars[4], input_vars[3], 86 | output_vars[0], output_vars[0], output_vars[1], 87 | output_vars[1], output_vars[0], output_vars[1]] 88 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/distortionUVAnimated.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVdistortionAnimated 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 0.0) 7 | set_input_port_default_value(2, 0.0) 8 | set_input_port_default_value(3, 0.0) 9 | set_input_port_default_value(4, 0.0) 10 | set_input_port_default_value(5, 1.0) 11 | set_input_port_default_value(6, 0.0) 12 | 13 | func _get_name() -> String: 14 | return "DistortionUVAnimated" 15 | 16 | func _get_category() -> String: 17 | return "UV" 18 | 19 | func _get_subcategory() -> String: 20 | return "Animated" 21 | 22 | func _get_description() -> String: 23 | return "Animated wave-like UV distortion" 24 | 25 | func _get_return_icon_type(): 26 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 27 | 28 | func _get_input_port_count() -> int: 29 | return 7 30 | 31 | func _get_input_port_name(port: int): 32 | match port: 33 | 0: 34 | return "uv" 35 | 1: 36 | return "waveX" 37 | 2: 38 | return "waveY" 39 | 3: 40 | return "distortX" 41 | 4: 42 | return "distortY" 43 | 5: 44 | return "speed" 45 | 6: 46 | return "time" 47 | 48 | func _get_input_port_type(port: int): 49 | match port: 50 | 0: 51 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 52 | 1: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 2: 55 | return VisualShaderNode.PORT_TYPE_SCALAR 56 | 3: 57 | return VisualShaderNode.PORT_TYPE_SCALAR 58 | 4: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 5: 61 | return VisualShaderNode.PORT_TYPE_SCALAR 62 | 6: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 65 | func _get_output_port_count() -> int: 66 | return 1 67 | 68 | func _get_output_port_name(port: int) -> String: 69 | return "uv" 70 | 71 | func _get_output_port_type(port): 72 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 73 | 74 | func _get_global_code(mode): 75 | var path = self.get_script().get_path().get_base_dir() 76 | return '#include "' + path + '/distortionUVAnimated.gdshaderinc"' 77 | 78 | func _get_code(input_vars, output_vars, mode, type): 79 | var uv = "UV" 80 | 81 | if input_vars[0]: 82 | uv = input_vars[0] 83 | 84 | return "%s.xy = _distortionUVAnimatedFunc(%s.xy, %s, %s, %s, %s, %s, %s);" % [ 85 | output_vars[0], uv, input_vars[3], input_vars[4], input_vars[1], input_vars[2], input_vars[5], input_vars[6]] 86 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/emboss.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAemboss 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 0.005) 8 | set_input_port_default_value(4, 1.0) 9 | 10 | func _get_name() -> String: 11 | return "Emboss" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return """Emboss filter. 21 | Note: negative lod => detect lod automatically""" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "sampler2D" 33 | 1: 34 | return "uv" 35 | 2: 36 | return "lod" 37 | 3: 38 | return "offset" 39 | 4: 40 | return "contrast" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_SAMPLER 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 2 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "col" 62 | 1: 63 | return "alpha" 64 | 65 | func _get_output_port_type(port: int): 66 | match port: 67 | 0: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 1: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 72 | func _get_global_code(mode): 73 | var path = self.get_script().get_path().get_base_dir() 74 | return '#include "' + path + '/emboss.gdshaderinc"' 75 | 76 | func _get_code(input_vars, output_vars, mode, type): 77 | var texture = "TEXTURE" 78 | var uv = "UV" 79 | 80 | if input_vars[0]: 81 | texture = input_vars[0] 82 | if input_vars[1]: 83 | uv = input_vars[1] 84 | 85 | return """vec4 %s%s = _embossFunc(%s, %s.xy, %s, vec2(%s), %s); 86 | %s = %s%s.rgb; 87 | %s = %s%s.a;""" % [ 88 | output_vars[0], output_vars[1], texture, uv, input_vars[2], input_vars[3], input_vars[4], 89 | output_vars[0], output_vars[0], output_vars[1], 90 | output_vars[1], output_vars[0], output_vars[1]] 91 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/gradientMapping.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAgradientMapping 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 1.0) 7 | set_input_port_default_value(2, 0.0) 8 | set_input_port_default_value(3, false) 9 | 10 | func _get_name() -> String: 11 | return "GradientMapping" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return """Remaps colors based on average color value using [gradient]. 21 | [gradientOffset] allows to do color cycling if set TIME to [gradientOffset] and 'true' to [cycleColor]""" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "color" 33 | 1: 34 | return "alpha" 35 | 2: 36 | return "gradientOffset" 37 | 3: 38 | return "cycleColor" 39 | 4: 40 | return "gradient" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_BOOLEAN 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SAMPLER 54 | 55 | func _get_output_port_count() -> int: 56 | return 2 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "col" 62 | 1: 63 | return "alpha" 64 | 65 | func _get_output_port_type(port: int): 66 | match port: 67 | 0: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 1: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 72 | func _get_global_code(mode): 73 | var path = self.get_script().get_path().get_base_dir() 74 | return '#include "' + path + '/gradientMapping.gdshaderinc"' 75 | 76 | func _get_code(input_vars, output_vars, mode, type): 77 | return """vec4 %s%s = _gradientMappingFunc(%s, %s, %s, %s); 78 | %s = %s%s.rgb; 79 | %s = %s%s.a * %s;""" % [ 80 | output_vars[0], output_vars[1], input_vars[0], input_vars[2], input_vars[4], input_vars[3], 81 | output_vars[0], output_vars[0], output_vars[1], 82 | output_vars[1], output_vars[0], output_vars[1], input_vars[1]] 83 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/blurCustom.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblurCustom 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 5) 8 | set_input_port_default_value(4, 0.001) 9 | 10 | func _get_name() -> String: 11 | return "BlurCustom" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | func _get_subcategory(): 17 | return "Blur" 18 | 19 | func _get_description() -> String: 20 | return """Custom 8-directional blur with ([amount]*2+1)^2 samples 21 | Note: negative lod => detect lod automatically""" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "sampler2D" 33 | 1: 34 | return "uv" 35 | 2: 36 | return "lod" 37 | 3: 38 | return "amount" 39 | 4: 40 | return "offset" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_SAMPLER 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 2 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "col" 62 | 1: 63 | return "alpha" 64 | 65 | func _get_output_port_type(port: int): 66 | match port: 67 | 0: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 1: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 72 | func _get_global_code(mode): 73 | var path = self.get_script().get_path().get_base_dir() 74 | return '#include "' + path + '/blurCustom.gdshaderinc"' 75 | 76 | func _get_code(input_vars, output_vars, mode, type): 77 | var texture = "TEXTURE" 78 | var uv = "UV" 79 | 80 | if input_vars[0]: 81 | texture = input_vars[0] 82 | if input_vars[1]: 83 | uv = input_vars[1] 84 | 85 | return """vec4 %s%s = _blurWithAmountFunc(%s, %s.xy, %s, int(%s), %s); 86 | %s = %s%s.rgb; 87 | %s = %s%s.a;""" % [ 88 | output_vars[0], output_vars[1], texture, uv, input_vars[2], input_vars[3], input_vars[4], 89 | output_vars[0], output_vars[0], output_vars[1], 90 | output_vars[1], output_vars[0], output_vars[1]] 91 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/blur9sample.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _blur9sampleFunc(sampler2D _blur9sample_sample, vec2 _blur9sample_uv, float _blur9sample_lod, float _blur9sample_radius){ 2 | vec4 _c01r_b1ur = vec4(0.0); 3 | if (_blur9sample_lod < 0.0){ 4 | _c01r_b1ur = texture(_blur9sample_sample, _blur9sample_uv); 5 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(0, - _blur9sample_radius) * 0.01); 6 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(0, _blur9sample_radius) * 0.01); 7 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(- _blur9sample_radius, 0) * 0.01); 8 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(_blur9sample_radius, 0) * 0.01); 9 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(- _blur9sample_radius, - _blur9sample_radius) * 0.01); 10 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(- _blur9sample_radius, _blur9sample_radius) * 0.01); 11 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(_blur9sample_radius, _blur9sample_radius) * 0.01); 12 | _c01r_b1ur += texture(_blur9sample_sample, _blur9sample_uv + vec2(_blur9sample_radius, -_blur9sample_radius) * 0.01); 13 | }else{ 14 | _c01r_b1ur = textureLod(_blur9sample_sample, _blur9sample_uv, _blur9sample_lod); 15 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(0, - _blur9sample_radius) * 0.01, _blur9sample_lod); 16 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(0, _blur9sample_radius) * 0.01, _blur9sample_lod); 17 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(- _blur9sample_radius, 0) * 0.01, _blur9sample_lod); 18 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(_blur9sample_radius, 0) * 0.01, _blur9sample_lod); 19 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(- _blur9sample_radius, - _blur9sample_radius) * 0.01, _blur9sample_lod); 20 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(- _blur9sample_radius, _blur9sample_radius) * 0.01, _blur9sample_lod); 21 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(_blur9sample_radius, _blur9sample_radius) * 0.01, _blur9sample_lod); 22 | _c01r_b1ur += textureLod(_blur9sample_sample, _blur9sample_uv + vec2(_blur9sample_radius, -_blur9sample_radius) * 0.01, _blur9sample_lod); 23 | } 24 | _c01r_b1ur /= 9.0; 25 | return _c01r_b1ur; 26 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/chromaticAberration.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAchromaticAberration 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 0.05) 8 | set_input_port_default_value(4, 0.0) 9 | 10 | func _get_name() -> String: 11 | return "ChromaticAberration" 12 | 13 | func _get_category() -> String: 14 | return "RGBA" 15 | 16 | #func _get_subcategory(): 17 | # return "" 18 | 19 | func _get_description() -> String: 20 | return """Basic Chromatic Aberration with red and blue channels offset 21 | Note: negative lod => detect lod automatically""" 22 | 23 | func _get_return_icon_type(): 24 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 25 | 26 | func _get_input_port_count() -> int: 27 | return 5 28 | 29 | func _get_input_port_name(port: int): 30 | match port: 31 | 0: 32 | return "sampler2D" 33 | 1: 34 | return "uv" 35 | 2: 36 | return "lod" 37 | 3: 38 | return "amountX" 39 | 4: 40 | return "amountY" 41 | 42 | func _get_input_port_type(port: int): 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_SAMPLER 46 | 1: 47 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 48 | 2: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 3: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 4: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 55 | func _get_output_port_count() -> int: 56 | return 2 57 | 58 | func _get_output_port_name(port: int): 59 | match port: 60 | 0: 61 | return "col" 62 | 1: 63 | return "alpha" 64 | 65 | func _get_output_port_type(port: int): 66 | match port: 67 | 0: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 1: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 72 | func _get_global_code(mode): 73 | var path = self.get_script().get_path().get_base_dir() 74 | return '#include "' + path + '/chromaticAberration.gdshaderinc"' 75 | 76 | func _get_code(input_vars, output_vars, mode, type): 77 | var texture = "TEXTURE" 78 | var uv = "UV" 79 | 80 | if input_vars[0]: 81 | texture = input_vars[0] 82 | if input_vars[1]: 83 | uv = input_vars[1] 84 | 85 | return """vec4 %s%s = _chromaticAberrationFunc(%s, %s.xy, vec3(%s, %s, %s)); 86 | %s = %s%s.rgb; 87 | %s = %s%s.a;""" % [ 88 | output_vars[0], output_vars[1], texture, uv, input_vars[3], input_vars[4], input_vars[2], 89 | output_vars[0], output_vars[0], output_vars[1], 90 | output_vars[1], output_vars[0], output_vars[1]] 91 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/scanLinesSharp.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAscanLinesSharp 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 21.0) 7 | set_input_port_default_value(2, 0.5) 8 | set_input_port_default_value(3, 1.0) 9 | set_input_port_default_value(4, 0.0) 10 | set_input_port_default_value(5, Vector3(1.0, 1.0, 1.0)) 11 | set_input_port_default_value(6, 1.0) 12 | 13 | func _get_name() -> String: 14 | return "ScanLinesSharpShape" 15 | 16 | func _get_category() -> String: 17 | return "RGBA" 18 | 19 | func _get_subcategory(): 20 | return "Shapes" 21 | 22 | func _get_description() -> String: 23 | return "Sharp moving scanlines" 24 | 25 | func _get_return_icon_type(): 26 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 27 | 28 | func _get_input_port_count() -> int: 29 | return 7 30 | 31 | func _get_input_port_name(port: int): 32 | match port: 33 | 0: 34 | return "uv" 35 | 1: 36 | return "amount" 37 | 2: 38 | return "fill" 39 | 3: 40 | return "speed" 41 | 4: 42 | return "time" 43 | 5: 44 | return "color" 45 | 6: 46 | return "alpha" 47 | 48 | func _get_input_port_type(port: int): 49 | match port: 50 | 0: 51 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 52 | 1: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 2: 55 | return VisualShaderNode.PORT_TYPE_SCALAR 56 | 3: 57 | return VisualShaderNode.PORT_TYPE_SCALAR 58 | 4: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 5: 61 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 62 | 6: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 65 | func _get_output_port_count() -> int: 66 | return 2 67 | 68 | func _get_output_port_name(port: int): 69 | match port: 70 | 0: 71 | return "col" 72 | 1: 73 | return "alpha" 74 | 75 | func _get_output_port_type(port: int): 76 | match port: 77 | 0: 78 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 79 | 1: 80 | return VisualShaderNode.PORT_TYPE_SCALAR 81 | 82 | func _get_global_code(mode): 83 | var path = self.get_script().get_path().get_base_dir() 84 | return '#include "' + path + '/scanLinesSharp.gdshaderinc"' 85 | 86 | func _get_code(input_vars, output_vars, mode, type): 87 | var uv = "UV" 88 | 89 | if input_vars[0]: 90 | uv = input_vars[0] 91 | 92 | return """%s = %s; 93 | %s = _scanLinesSharpFunc(%s.xy, %s, %s, %s, %s) * float(%s);""" % [ 94 | output_vars[0], input_vars[5], 95 | output_vars[1], uv, input_vars[1], input_vars[2], input_vars[3], input_vars[4], input_vars[6]] 96 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/perlin2d_fractal.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlin2dFractal 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 6) 7 | set_input_port_default_value(2, Vector3(2, 2, 0)) 8 | set_input_port_default_value(3, 2.0) 9 | set_input_port_default_value(4, 0.8) 10 | set_input_port_default_value(5, 0.5) 11 | set_input_port_default_value(6, 0.6) 12 | set_input_port_default_value(7, Vector3(0.5, 0.5, 0)) 13 | 14 | func _get_name() -> String: 15 | return "FractalPerlinNoise2D" 16 | 17 | func _get_category() -> String: 18 | return "RGBA" 19 | 20 | func _get_subcategory() -> String: 21 | return "NoiseFractal" 22 | 23 | func _get_description() -> String: 24 | return "Fractal 2D Perlin Noise" 25 | 26 | func _get_return_icon_type(): 27 | return VisualShaderNode.PORT_TYPE_SCALAR 28 | 29 | func _get_input_port_count() -> int: 30 | return 8 31 | 32 | func _get_input_port_name(port: int): 33 | match port: 34 | 0: 35 | return "uv" 36 | 1: 37 | return "octaves" 38 | 2: 39 | return "period" 40 | 3: 41 | return "lacunarity" 42 | 4: 43 | return "persistence" 44 | 5: 45 | return "angle" 46 | 6: 47 | return "amplitude" 48 | 7: 49 | return "shift" 50 | 51 | func _get_input_port_type(port: int): 52 | match port: 53 | 0: 54 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 55 | 1: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 2: 58 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 59 | 3: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 4: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 5: 64 | return VisualShaderNode.PORT_TYPE_SCALAR 65 | 6: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 7: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 70 | func _get_output_port_count() -> int: 71 | return 1 72 | 73 | func _get_output_port_name(port: int) -> String: 74 | return "result" 75 | 76 | func _get_output_port_type(port): 77 | return VisualShaderNode.PORT_TYPE_SCALAR 78 | 79 | func _get_global_code(mode): 80 | var path = self.get_script().get_path().get_base_dir() 81 | return '#include "' + path + '/perlin2d_fractal.gdshaderinc"' 82 | 83 | func _get_code(input_vars, output_vars, mode, type): 84 | var uv = "UV" 85 | 86 | if input_vars[0]: 87 | uv = input_vars[0] 88 | 89 | return "%s = _perlinNoise2DFBM(%s.xy, int(%s), %s.xy, %s, %s, %s, %s, %s.xy);" % [ 90 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], 91 | input_vars[4], input_vars[5], input_vars[6], input_vars[7]] 92 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/simplex2d_fractal.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseSimplex2dFractal 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 6) 7 | set_input_port_default_value(2, Vector3(2, 2, 0)) 8 | set_input_port_default_value(3, 2.0) 9 | set_input_port_default_value(4, 0.8) 10 | set_input_port_default_value(5, 0.5) 11 | set_input_port_default_value(6, 0.5) 12 | set_input_port_default_value(7, Vector3(0.5, 0.5, 0)) 13 | 14 | func _get_name() -> String: 15 | return "FractalSimplexNoise2D" 16 | 17 | func _get_category() -> String: 18 | return "RGBA" 19 | 20 | func _get_subcategory() -> String: 21 | return "NoiseFractal" 22 | 23 | func _get_description() -> String: 24 | return "Fractal 2D Simplex Noise" 25 | 26 | func _get_return_icon_type(): 27 | return VisualShaderNode.PORT_TYPE_SCALAR 28 | 29 | func _get_input_port_count() -> int: 30 | return 8 31 | 32 | func _get_input_port_name(port: int): 33 | match port: 34 | 0: 35 | return "uv" 36 | 1: 37 | return "octaves" 38 | 2: 39 | return "period" 40 | 3: 41 | return "lacunarity" 42 | 4: 43 | return "persistence" 44 | 5: 45 | return "angle" 46 | 6: 47 | return "amplitude" 48 | 7: 49 | return "shift" 50 | 51 | func _get_input_port_type(port: int): 52 | match port: 53 | 0: 54 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 55 | 1: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 2: 58 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 59 | 3: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 4: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 5: 64 | return VisualShaderNode.PORT_TYPE_SCALAR 65 | 6: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 7: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 70 | func _get_output_port_count() -> int: 71 | return 1 72 | 73 | func _get_output_port_name(port: int) -> String: 74 | return "result" 75 | 76 | func _get_output_port_type(port): 77 | return VisualShaderNode.PORT_TYPE_SCALAR 78 | 79 | func _get_global_code(mode): 80 | var path = self.get_script().get_path().get_base_dir() 81 | return '#include "' + path + '/simplex2d_fractal.gdshaderinc"' 82 | 83 | func _get_code(input_vars, output_vars, mode, type): 84 | var uv = "UV" 85 | 86 | if input_vars[0]: 87 | uv = input_vars[0] 88 | 89 | return "%s = _simplexNoise2DFBM(%s.xy, int(%s), %s.xy, %s, %s, %s, %s, %s.xy);" % [ 90 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], 91 | input_vars[4], input_vars[5], input_vars[6], input_vars[7]] 92 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/worley2d_fractal.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec2 _cellular2dNoiseFractalFunc(vec2 P, float _jitter_w2d) { 2 | float K = 0.142857142857; // 1/7 3 | float Ko = 0.428571428571; // 3/7 4 | 5 | vec2 Pi = floor(P) - floor(floor(P) * (1.0 / 289.0)) * 289.0; 6 | vec2 Pf = fract(P); 7 | vec3 oi = vec3(-1.0, 0.0, 1.0); 8 | vec3 of = vec3(-0.5, 0.5, 1.5); 9 | vec3 px = (34.0*(Pi.x+oi)+1.0)*(Pi.x+oi)-floor((34.0*(Pi.x+oi)+1.0)*(Pi.x+oi)*(1.0/289.0))* 289.0; 10 | vec3 p = (34.0*(px.x+Pi.y+ oi)+1.0)*(px.x+Pi.y+ oi)-floor((34.0*(px.x+Pi.y+oi)+1.0)*(px.x+Pi.y+ oi)*(1.0/289.0))*289.0; 11 | vec3 ox = fract(p*K) - Ko; 12 | vec3 oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 13 | vec3 dx = Pf.x + 0.5 + _jitter_w2d*ox; 14 | vec3 dy = Pf.y - of + _jitter_w2d*oy; 15 | vec3 d1 = dx * dx + dy * dy; 16 | p = (34.0*(px.y+Pi.y+oi)+1.0)*(px.y+Pi.y+oi)-floor((34.0*(px.y+Pi.y+oi)+1.0)*(px.y+Pi.y+oi)*(1.0/289.0))*289.0; 17 | ox = fract(p*K) - Ko; 18 | oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 19 | dx = Pf.x - 0.5 + _jitter_w2d*ox; 20 | dy = Pf.y - of + _jitter_w2d*oy; 21 | vec3 d2 = dx * dx + dy * dy; 22 | p = (34.0*(px.z+Pi.y+oi)+1.0)*(px.z+Pi.y+oi)-floor((34.0*(px.z+Pi.y+oi)+1.0)*(px.z+Pi.y+oi)*(1.0/289.0))*289.0; 23 | ox = fract(p*K) - Ko; 24 | oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 25 | dx = Pf.x - 1.5 + _jitter_w2d*ox; 26 | dy = Pf.y - of + _jitter_w2d*oy; 27 | vec3 d3 = dx * dx + dy * dy; 28 | vec3 d1a = min(d1, d2); 29 | d2 = max(d1, d2); 30 | d2 = min(d2, d3); 31 | d1 = min(d1a, d2); 32 | d2 = max(d1a, d2); 33 | d1.xy = (d1.x < d1.y) ? d1.xy : d1.yx; 34 | d1.xz = (d1.x < d1.z) ? d1.xz : d1.zx; 35 | d1.yz = min(d1.yz, d2.yz); 36 | d1.y = min(d1.y, d1.z); 37 | d1.y = min(d1.y, d2.x); 38 | return sqrt(d1.xy); 39 | } 40 | float _cellularNoise2DFBM(vec2 _uv_cnfbm, int _oct_cnfbm, vec2 _per_cnfbm, float _lac_cnfbm, float _persist_cnfbm, 41 | float _rot_cnfbm, float _ampl_cnfbm, vec2 _shift_cnfbm, float _jitter_cnfbm, bool _use_F2_cnfbm) { 42 | float _v = 0.0; 43 | float _a = _ampl_cnfbm; 44 | mat2 _r0t = mat2(vec2(cos(_rot_cnfbm), sin(_rot_cnfbm)), vec2(-sin(_rot_cnfbm), cos(_rot_cnfbm))); 45 | for (int i = 0; i < _oct_cnfbm; ++i) { 46 | vec2 _cell_noiseF12 = _cellular2dNoiseFractalFunc(_uv_cnfbm * _per_cnfbm, _jitter_cnfbm); 47 | if (_use_F2_cnfbm) { 48 | _v += _a * _cell_noiseF12.y; 49 | } else { 50 | _v += _a * _cell_noiseF12.x; 51 | } 52 | _uv_cnfbm = _r0t * _uv_cnfbm * _lac_cnfbm + _shift_cnfbm; 53 | _a *= _persist_cnfbm; 54 | } 55 | return _v; 56 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/zoomBlur.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAzoomBlur 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, Vector3(0.5, 0.5, 0.0)) 8 | set_input_port_default_value(4, 20) 9 | set_input_port_default_value(5, 0.005) 10 | 11 | func _get_name() -> String: 12 | return "ZoomBlur" 13 | 14 | func _get_category() -> String: 15 | return "RGBA" 16 | 17 | func _get_subcategory(): 18 | return "Blur" 19 | 20 | func _get_description() -> String: 21 | return """Zoom blur using [amount] samples 22 | Note: negative lod => detect lod automatically""" 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 6 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "sampler2D" 34 | 1: 35 | return "uv" 36 | 2: 37 | return "lod" 38 | 3: 39 | return "pivot" 40 | 4: 41 | return "amount" 42 | 5: 43 | return "length" 44 | 45 | func _get_input_port_type(port: int): 46 | match port: 47 | 0: 48 | return VisualShaderNode.PORT_TYPE_SAMPLER 49 | 1: 50 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 51 | 2: 52 | return VisualShaderNode.PORT_TYPE_SCALAR 53 | 3: 54 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 55 | 4: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 5: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 60 | func _get_output_port_count() -> int: 61 | return 2 62 | 63 | func _get_output_port_name(port: int): 64 | match port: 65 | 0: 66 | return "col" 67 | 1: 68 | return "alpha" 69 | 70 | func _get_output_port_type(port: int): 71 | match port: 72 | 0: 73 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 74 | 1: 75 | return VisualShaderNode.PORT_TYPE_SCALAR 76 | 77 | func _get_global_code(mode): 78 | var path = self.get_script().get_path().get_base_dir() 79 | return '#include "' + path + '/zoomBlur.gdshaderinc"' 80 | 81 | func _get_code(input_vars, output_vars, mode, type): 82 | var texture = "TEXTURE" 83 | var uv = "UV" 84 | 85 | if input_vars[0]: 86 | texture = input_vars[0] 87 | if input_vars[1]: 88 | uv = input_vars[1] 89 | 90 | return """vec4 %s%s = _zoomBlurFunc(%s, %s.xy, int(%s), %s.xy, %s, %s); 91 | %s = %s%s.rgb; 92 | %s = %s%s.a;""" % [ 93 | output_vars[0], output_vars[1], texture, uv, input_vars[4], input_vars[3], input_vars[5], input_vars[2], 94 | output_vars[0], output_vars[0], output_vars[1], 95 | output_vars[1], output_vars[0], output_vars[1]] 96 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/generic2d_fractal.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseGeneric2dFractal 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 6) 7 | set_input_port_default_value(2, Vector3(2, 2, 0)) 8 | set_input_port_default_value(3, 2.0) 9 | set_input_port_default_value(4, 0.8) 10 | set_input_port_default_value(5, 0.5) 11 | set_input_port_default_value(6, 0.3) 12 | set_input_port_default_value(7, Vector3(0.5, 0.5, 0)) 13 | 14 | func _get_name() -> String: 15 | return "FractalGenericNoise2D" 16 | 17 | func _get_category() -> String: 18 | return "RGBA" 19 | 20 | func _get_subcategory() -> String: 21 | return "NoiseFractal" 22 | 23 | func _get_description() -> String: 24 | return "Fractal GenericNoise using hash random function" 25 | 26 | func _get_return_icon_type(): 27 | return VisualShaderNode.PORT_TYPE_SCALAR 28 | 29 | func _get_input_port_count() -> int: 30 | return 8 31 | 32 | func _get_input_port_name(port: int): 33 | match port: 34 | 0: 35 | return "uv" 36 | 1: 37 | return "octaves" 38 | 2: 39 | return "period" 40 | 3: 41 | return "lacunarity" 42 | 4: 43 | return "persistence" 44 | 5: 45 | return "angle" 46 | 6: 47 | return "amplitude" 48 | 7: 49 | return "shift" 50 | 51 | func _get_input_port_type(port: int): 52 | match port: 53 | 0: 54 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 55 | 1: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 2: 58 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 59 | 3: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 4: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 5: 64 | return VisualShaderNode.PORT_TYPE_SCALAR 65 | 6: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 7: 68 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 69 | 70 | func _get_output_port_count() -> int: 71 | return 1 72 | 73 | func _get_output_port_name(port: int) -> String: 74 | return "result" 75 | 76 | func _get_output_port_type(port): 77 | return VisualShaderNode.PORT_TYPE_SCALAR 78 | 79 | func _get_global_code(mode): 80 | var path = self.get_script().get_path().get_base_dir() 81 | return '#include "' + path + '/generic2d_fractal.gdshaderinc"' 82 | 83 | func _get_code(input_vars, output_vars, mode, type): 84 | var uv = "UV" 85 | 86 | if input_vars[0]: 87 | uv = input_vars[0] 88 | 89 | return "%s = _genericNoise2DFBM(%s.xy, int(%s), %s.xy, %s, %s, %s, %s, %s.xy);" % [ 90 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], 91 | input_vars[4], input_vars[5], input_vars[6], input_vars[7]] 92 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/perlin3d_fractal.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlin3dFractal 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 6) 7 | set_input_port_default_value(2, Vector3(2, 2, 0)) 8 | set_input_port_default_value(3, 2.0) 9 | set_input_port_default_value(4, 0.8) 10 | set_input_port_default_value(5, 0.5) 11 | set_input_port_default_value(6, 0.6) 12 | set_input_port_default_value(7, Vector3(0.5, 0.5, 0)) 13 | set_input_port_default_value(8, 0.0) 14 | 15 | func _get_name() -> String: 16 | return "FractalPerlinNoise3D" 17 | 18 | func _get_category() -> String: 19 | return "RGBA" 20 | 21 | func _get_subcategory() -> String: 22 | return "NoiseFractal" 23 | 24 | func _get_description() -> String: 25 | return "Fractal 3D Perlin Noise" 26 | 27 | func _get_return_icon_type(): 28 | return VisualShaderNode.PORT_TYPE_SCALAR 29 | 30 | func _get_input_port_count() -> int: 31 | return 9 32 | 33 | func _get_input_port_name(port: int): 34 | match port: 35 | 0: 36 | return "uv" 37 | 1: 38 | return "octaves" 39 | 2: 40 | return "period" 41 | 3: 42 | return "lacunarity" 43 | 4: 44 | return "persistence" 45 | 5: 46 | return "angle" 47 | 6: 48 | return "amplitude" 49 | 7: 50 | return "shift" 51 | 8: 52 | return "time" 53 | 54 | func _get_input_port_type(port: int): 55 | match port: 56 | 0: 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 1: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 2: 61 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 62 | 3: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 4: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 5: 67 | return VisualShaderNode.PORT_TYPE_SCALAR 68 | 6: 69 | return VisualShaderNode.PORT_TYPE_SCALAR 70 | 7: 71 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 72 | 8: 73 | return VisualShaderNode.PORT_TYPE_SCALAR 74 | 75 | func _get_output_port_count() -> int: 76 | return 1 77 | 78 | func _get_output_port_name(port: int) -> String: 79 | return "result" 80 | 81 | func _get_output_port_type(port): 82 | return VisualShaderNode.PORT_TYPE_SCALAR 83 | 84 | func _get_global_code(mode): 85 | var path = self.get_script().get_path().get_base_dir() 86 | return '#include "' + path + '/perlin3d_fractal.gdshaderinc"' 87 | 88 | func _get_code(input_vars, output_vars, mode, type): 89 | var uv = "UV" 90 | 91 | if input_vars[0]: 92 | uv = input_vars[0] 93 | 94 | return "%s = _perlinNoise3DFBM(%s.xy, int(%s), %s.xy, %s, %s, %s, %s, %s.xy, %s);" % [ 95 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], 96 | input_vars[4], input_vars[5], input_vars[6], input_vars[7], input_vars[8]] 97 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/simplex3d_fractal.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseSimplex3dFractal 4 | 5 | func _init(): 6 | set_input_port_default_value(1, 6) 7 | set_input_port_default_value(2, Vector3(2, 2, 0)) 8 | set_input_port_default_value(3, 2.0) 9 | set_input_port_default_value(4, 0.8) 10 | set_input_port_default_value(5, 0.5) 11 | set_input_port_default_value(6, 0.6) 12 | set_input_port_default_value(7, Vector3(0.5, 0.5, 0)) 13 | set_input_port_default_value(8, 0.0) 14 | 15 | func _get_name() -> String: 16 | return "FractalSimplexNoise3D" 17 | 18 | func _get_category() -> String: 19 | return "RGBA" 20 | 21 | func _get_subcategory() -> String: 22 | return "NoiseFractal" 23 | 24 | func _get_description() -> String: 25 | return "Fractal 3D Simplex Noise" 26 | 27 | func _get_return_icon_type(): 28 | return VisualShaderNode.PORT_TYPE_SCALAR 29 | 30 | func _get_input_port_count() -> int: 31 | return 9 32 | 33 | func _get_input_port_name(port: int): 34 | match port: 35 | 0: 36 | return "uv" 37 | 1: 38 | return "octaves" 39 | 2: 40 | return "period" 41 | 3: 42 | return "lacunarity" 43 | 4: 44 | return "persistence" 45 | 5: 46 | return "angle" 47 | 6: 48 | return "amplitude" 49 | 7: 50 | return "shift" 51 | 8: 52 | return "time" 53 | 54 | func _get_input_port_type(port: int): 55 | match port: 56 | 0: 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 1: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 2: 61 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 62 | 3: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 4: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 5: 67 | return VisualShaderNode.PORT_TYPE_SCALAR 68 | 6: 69 | return VisualShaderNode.PORT_TYPE_SCALAR 70 | 7: 71 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 72 | 8: 73 | return VisualShaderNode.PORT_TYPE_SCALAR 74 | 75 | func _get_output_port_count() -> int: 76 | return 1 77 | 78 | func _get_output_port_name(port: int) -> String: 79 | return "result" 80 | 81 | func _get_output_port_type(port): 82 | return VisualShaderNode.PORT_TYPE_SCALAR 83 | 84 | func _get_global_code(mode): 85 | var path = self.get_script().get_path().get_base_dir() 86 | return '#include "' + path + '/simplex3d_fractal.gdshaderinc"' 87 | 88 | func _get_code(input_vars, output_vars, mode, type): 89 | var uv = "UV" 90 | 91 | if input_vars[0]: 92 | uv = input_vars[0] 93 | 94 | return "%s = _simplexNoise3DFBM(%s.xy, int(%s), %s.xy, %s, %s, %s, %s, %s.xy, %s);" % [ 95 | output_vars[0], uv, input_vars[1], input_vars[2], input_vars[3], 96 | input_vars[4], input_vars[5], input_vars[6], input_vars[7], input_vars[8]] 97 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/fractal/simplex3d_fractal.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _permute_simplex3_noise_fractal(vec4 x) { 2 | return ((x * 34.0) + 1.0) * x - floor(((x * 34.0) + 1.0) * x * (1.0 / 289.0)) * 289.0; 3 | } 4 | float _simplex3dNoiseFractalFunc(vec3 v) { 5 | vec2 C = vec2(1.0/6.0, 1.0/3.0) ; 6 | vec4 D = vec4(0.0, 0.5, 1.0, 2.0); 7 | 8 | vec3 i = floor(v + dot(v, vec3(C.y))); 9 | vec3 x0 = v - i + dot(i, vec3(C.x)) ; 10 | 11 | vec3 g = step(x0.yzx, x0.xyz); 12 | vec3 l = 1.0 - g; 13 | vec3 i1 = min( g.xyz, l.zxy ); 14 | vec3 i2 = max( g.xyz, l.zxy ); 15 | 16 | vec3 x1 = x0 - i1 + vec3(C.x); 17 | vec3 x2 = x0 - i2 + vec3(C.y); 18 | vec3 x3 = x0 - D.yyy; 19 | 20 | i = i - floor(i * (1.0 / 289.0)) * 289.0; 21 | vec4 p = _permute_simplex3_noise_fractal(_permute_simplex3_noise_fractal(_permute_simplex3_noise_fractal( 22 | i.z + vec4(0.0, i1.z, i2.z, 1.0)) 23 | + i.y + vec4(0.0, i1.y, i2.y, 1.0)) 24 | + i.x + vec4(0.0, i1.x, i2.x, 1.0)); 25 | 26 | float n_ = 0.142857142857; 27 | vec3 ns = n_ * D.wyz - D.xzx; 28 | 29 | vec4 j = p - 49.0 * floor(p * ns.z * ns.z); 30 | 31 | vec4 x_ = floor(j * ns.z); 32 | vec4 y_ = floor(j - 7.0 * x_ ); 33 | 34 | vec4 x = x_ *ns.x + vec4(ns.y); 35 | vec4 y = y_ *ns.x + vec4(ns.y); 36 | vec4 h = 1.0 - abs(x) - abs(y); 37 | 38 | vec4 b0 = vec4( x.xy, y.xy ); 39 | vec4 b1 = vec4( x.zw, y.zw ); 40 | 41 | vec4 s0 = floor(b0)*2.0 + 1.0; 42 | vec4 s1 = floor(b1)*2.0 + 1.0; 43 | vec4 sh = -step(h, vec4(0.0)); 44 | 45 | vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ; 46 | vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ; 47 | 48 | vec3 p0 = vec3(a0.xy,h.x); 49 | vec3 p1 = vec3(a0.zw,h.y); 50 | vec3 p2 = vec3(a1.xy,h.z); 51 | vec3 p3 = vec3(a1.zw,h.w); 52 | 53 | vec4 norm = 2.79284291400159 - 0.85373472095314 * vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)); 54 | p0 *= norm.x; 55 | p1 *= norm.y; 56 | p2 *= norm.z; 57 | p3 *= norm.w; 58 | 59 | vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), vec4(0.0)); 60 | m = m * m; 61 | return 22.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3) ) ); 62 | } 63 | float _simplexNoise3DFBM(vec2 _uv_sn3fbm, int _oct_sn3fbm, vec2 _per_sn3fbm, float _lac_sn3fbm, 64 | float _persist_sn3fbm, float _rot_sn3fbm, float _ampl_sn3fbm, vec2 _shift_sn3fbm, float _time_sn3fbm) { 65 | float _v = 0.0; 66 | float _a = _ampl_sn3fbm; 67 | mat2 _r0t = mat2(vec2(cos(_rot_sn3fbm), sin(_rot_sn3fbm)), vec2(-sin(_rot_sn3fbm), cos(_rot_sn3fbm))); 68 | for (int i = 0; i < _oct_sn3fbm; ++i) { 69 | _v += _a * _simplex3dNoiseFractalFunc(vec3(_uv_sn3fbm * _per_sn3fbm, _time_sn3fbm)); 70 | _uv_sn3fbm = _r0t * _uv_sn3fbm * _lac_sn3fbm + _shift_sn3fbm; 71 | _a *= _persist_sn3fbm; 72 | } 73 | return (min(_v, 1.0) + 1.0) * 0.5; 74 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex4d.gdshaderinc: -------------------------------------------------------------------------------- 1 | vec4 _permute_4_s4_noise(vec4 x) { 2 | return ((x * 34.0) + 1.0) * x - floor(((x * 34.0) + 1.0) * x * (1.0 / 289.0)) * 289.0; 3 | } 4 | float _permute_s4_noise(float x) { 5 | return ((x * 34.0) + 1.0) * x - floor(((x * 34.0) + 1.0) * x * (1.0 / 289.0)) * 289.0; 6 | } 7 | vec4 _grad4_s4_noise(float j, vec4 ip) { 8 | vec4 ones = vec4(1.0, 1.0, 1.0, -1.0); 9 | vec4 p, s; 10 | p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0; 11 | p.w = 1.5 - dot(abs(p.xyz), ones.xyz); 12 | s = vec4(lessThan(p, vec4(0.0))); 13 | p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; 14 | return p; 15 | } 16 | float _simplex4dNoiseFunc(vec4 v) { 17 | vec4 C = vec4( 0.138196601125011, 18 | 0.276393202250021, 19 | 0.414589803375032, 20 | -0.447213595499958); 21 | 22 | vec4 i = floor(v + dot(v, vec4(0.309016994374947451)) ); 23 | vec4 x0 = v - i + dot(i, C.xxxx); 24 | 25 | vec4 i0; 26 | vec3 isX = step( x0.yzw, x0.xxx ); 27 | vec3 isYZ = step( x0.zww, x0.yyz ); 28 | i0.x = isX.x + isX.y + isX.z; 29 | i0.yzw = 1.0 - isX; 30 | i0.y += isYZ.x + isYZ.y; 31 | i0.zw += 1.0 - isYZ.xy; 32 | i0.z += isYZ.z; 33 | i0.w += 1.0 - isYZ.z; 34 | 35 | vec4 i3 = clamp( i0, 0.0, 1.0 ); 36 | vec4 i2 = clamp( i0-1.0, 0.0, 1.0 ); 37 | vec4 i1 = clamp( i0-2.0, 0.0, 1.0 ); 38 | 39 | vec4 x1 = x0 - i1 + C.xxxx; 40 | vec4 x2 = x0 - i2 + C.yyyy; 41 | vec4 x3 = x0 - i3 + C.zzzz; 42 | vec4 x4 = x0 + C.wwww; 43 | 44 | i = i - floor(i * (1.0 / 289.0)) * 289.0; 45 | float j0 = _permute_s4_noise( _permute_s4_noise( _permute_s4_noise( _permute_s4_noise(i.w) + i.z) + i.y) + i.x); 46 | vec4 j1 = _permute_4_s4_noise( _permute_4_s4_noise( _permute_4_s4_noise( _permute_4_s4_noise ( 47 | i.w + vec4(i1.w, i2.w, i3.w, 1.0 )) 48 | + i.z + vec4(i1.z, i2.z, i3.z, 1.0 )) 49 | + i.y + vec4(i1.y, i2.y, i3.y, 1.0 )) 50 | + i.x + vec4(i1.x, i2.x, i3.x, 1.0 )); 51 | 52 | vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ; 53 | 54 | vec4 p0 = _grad4_s4_noise(j0, ip); 55 | vec4 p1 = _grad4_s4_noise(j1.x, ip); 56 | vec4 p2 = _grad4_s4_noise(j1.y, ip); 57 | vec4 p3 = _grad4_s4_noise(j1.z, ip); 58 | vec4 p4 = _grad4_s4_noise(j1.w, ip); 59 | 60 | vec4 norm = 2.79284291400159 - 1.85373472095314 * vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)); 61 | p0 *= norm.x; 62 | p1 *= norm.y; 63 | p2 *= norm.z; 64 | p3 *= norm.w; 65 | p4 *= 2.79284291400159 - 1.85373472095314 * dot(p4,p4); 66 | 67 | vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), vec3(0.0)); 68 | vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)), vec2(0.0)); 69 | m0 = m0 * m0; 70 | m1 = m1 * m1; 71 | return (33.0 *(dot(m0*m0, vec3(dot(p0, x0), dot(p1, x1), dot(p2, x2))) 72 | + dot(m1*m1, vec2(dot(p3, x3), dot(p4, x4)))) + 1.0) * 0.5; 73 | } -------------------------------------------------------------------------------- /addons/shaderV/rgba/normalFromHeightmap.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAnormalFromHeightmap 4 | 5 | func _init(): 6 | set_input_port_default_value(2, Vector3(64, 64, 0)) 7 | set_input_port_default_value(3, 10.0) 8 | set_input_port_default_value(4, false) 9 | set_input_port_default_value(5, false) 10 | set_input_port_default_value(6, false) 11 | 12 | func _get_name() -> String: 13 | return "NormalFromHeightmap" 14 | 15 | func _get_category() -> String: 16 | return "RGBA" 17 | 18 | #func _get_subcategory(): 19 | # return "" 20 | 21 | func _get_description() -> String: 22 | return """Create normal map from heightmap texture. You should provide actual size of heightmap (in pixels). 23 | It always uses 0 lod of heightmap texture to create normalmap. 24 | It's possible to invert X and Y of normalmap if needed. 25 | If you provide texture with different colors (not actual heightmap) to 'heightmapSampler', you can set 'preconvertToGray' to 'true'.""" 26 | 27 | func _get_return_icon_type(): 28 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 29 | 30 | func _get_input_port_count() -> int: 31 | return 7 32 | 33 | func _get_input_port_name(port: int): 34 | match port: 35 | 0: 36 | return "heightmapSampler" 37 | 1: 38 | return "uv" 39 | 2: 40 | return "heightmapSize" 41 | 3: 42 | return "strength" 43 | 4: 44 | return "preconvertToGray" 45 | 5: 46 | return "invertX" 47 | 6: 48 | return "invertY" 49 | 50 | func _get_input_port_type(port: int): 51 | match port: 52 | 0: 53 | return VisualShaderNode.PORT_TYPE_SAMPLER 54 | 1: 55 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 56 | 2: 57 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 58 | 3: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 4: 61 | return VisualShaderNode.PORT_TYPE_BOOLEAN 62 | 5: 63 | return VisualShaderNode.PORT_TYPE_BOOLEAN 64 | 6: 65 | return VisualShaderNode.PORT_TYPE_BOOLEAN 66 | 67 | func _get_output_port_count() -> int: 68 | return 1 69 | 70 | func _get_output_port_name(port: int) -> String: 71 | return "normal" 72 | 73 | func _get_output_port_type(port): 74 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 75 | 76 | func _get_global_code(mode): 77 | var path = self.get_script().get_path().get_base_dir() 78 | return '#include "' + path + '/normalFromHeightmap.gdshaderinc"' 79 | 80 | func _get_code(input_vars, output_vars, mode, type): 81 | var texture = "TEXTURE" 82 | var uv = "UV" 83 | 84 | if input_vars[0]: 85 | texture = input_vars[0] 86 | if input_vars[1]: 87 | uv = input_vars[1] 88 | 89 | return "%s = _normalFromHeightmapFunc(%s.xy, %s, %s.xy, %s, %s, %s, %s);" % [ 90 | output_vars[0], uv, texture, input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[6]] 91 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/innerGlow.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAinnerGlow 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 1.0) 8 | set_input_port_default_value(4, 1.0) 9 | set_input_port_default_value(5, Vector3(1.0, 1.0, 1.0)) 10 | set_input_port_default_value(6, 1.0) 11 | 12 | func _get_name() -> String: 13 | return "InnerGlow" 14 | 15 | func _get_category() -> String: 16 | return "RGBA" 17 | 18 | func _get_subcategory(): 19 | return "Glow" 20 | 21 | func _get_description() -> String: 22 | return "Adds inner glow to color. Color should have alpha < 1.0 to find contours" 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 7 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "sampler2D" 34 | 1: 35 | return "uv" 36 | 2: 37 | return "lod" 38 | 3: 39 | return "size" 40 | 4: 41 | return "intensity" 42 | 5: 43 | return "color" 44 | 6: 45 | return "alpha" 46 | 47 | func _get_input_port_type(port: int): 48 | match port: 49 | 0: 50 | return VisualShaderNode.PORT_TYPE_SAMPLER 51 | 1: 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 2: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 3: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 4: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 5: 60 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 61 | 6: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 64 | func _get_output_port_count() -> int: 65 | return 2 66 | 67 | func _get_output_port_name(port: int): 68 | match port: 69 | 0: 70 | return "col" 71 | 1: 72 | return "alpha" 73 | 74 | func _get_output_port_type(port: int): 75 | match port: 76 | 0: 77 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 78 | 1: 79 | return VisualShaderNode.PORT_TYPE_SCALAR 80 | 81 | func _get_global_code(mode): 82 | var path = self.get_script().get_path().get_base_dir() 83 | return '#include "' + path + '/innerGlow.gdshaderinc"' 84 | 85 | func _get_code(input_vars, output_vars, mode, type): 86 | var texture = "TEXTURE" 87 | var uv = "UV" 88 | 89 | if input_vars[0]: 90 | texture = input_vars[0] 91 | if input_vars[1]: 92 | uv = input_vars[1] 93 | 94 | return """vec4 %s%s = _innerGlowFunc(%s, %s.xy, %s, %s, %s, vec4(%s, %s)); 95 | %s = %s%s.rgb; 96 | %s = %s%s.a;""" % [ 97 | output_vars[0], output_vars[1], texture, uv, input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[6], 98 | output_vars[0], output_vars[0], output_vars[1], 99 | output_vars[1], output_vars[0], output_vars[1]] 100 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/outerGlow.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAouterGlow 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 1.0) 8 | set_input_port_default_value(4, 1.0) 9 | set_input_port_default_value(5, Vector3(1.0, 1.0, 1.0)) 10 | set_input_port_default_value(6, 1.0) 11 | 12 | func _get_name() -> String: 13 | return "OuterGlow" 14 | 15 | func _get_category() -> String: 16 | return "RGBA" 17 | 18 | func _get_subcategory(): 19 | return "Glow" 20 | 21 | func _get_description() -> String: 22 | return "Adds outer glow to color. Color should have alpha < 1.0 to find contours" 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 7 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "sampler2D" 34 | 1: 35 | return "uv" 36 | 2: 37 | return "lod" 38 | 3: 39 | return "size" 40 | 4: 41 | return "intensity" 42 | 5: 43 | return "color" 44 | 6: 45 | return "alpha" 46 | 47 | func _get_input_port_type(port: int): 48 | match port: 49 | 0: 50 | return VisualShaderNode.PORT_TYPE_SAMPLER 51 | 1: 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 2: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 3: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 4: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 5: 60 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 61 | 6: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 64 | func _get_output_port_count() -> int: 65 | return 2 66 | 67 | func _get_output_port_name(port: int): 68 | match port: 69 | 0: 70 | return "col" 71 | 1: 72 | return "alpha" 73 | 74 | func _get_output_port_type(port: int): 75 | match port: 76 | 0: 77 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 78 | 1: 79 | return VisualShaderNode.PORT_TYPE_SCALAR 80 | 81 | func _get_global_code(mode): 82 | var path = self.get_script().get_path().get_base_dir() 83 | return '#include "' + path + '/outerGlow.gdshaderinc"' 84 | 85 | func _get_code(input_vars, output_vars, mode, type): 86 | var texture = "TEXTURE" 87 | var uv = "UV" 88 | 89 | if input_vars[0]: 90 | texture = input_vars[0] 91 | if input_vars[1]: 92 | uv = input_vars[1] 93 | 94 | return """vec4 %s%s = _outerGlowFunc(%s, %s.xy, %s, %s, %s, vec4(%s, %s)); 95 | %s = %s%s.rgb; 96 | %s = %s%s.a;""" % [ 97 | output_vars[0], output_vars[1], texture, uv, input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[6], 98 | output_vars[0], output_vars[0], output_vars[1], 99 | output_vars[1], output_vars[0], output_vars[1]] 100 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/glow/innerGlowEmpty.gd: -------------------------------------------------------------------------------- 1 | @tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAinnerGlowEmpty 4 | 5 | func _init(): 6 | set_input_port_default_value(2, -1.0) 7 | set_input_port_default_value(3, 1.0) 8 | set_input_port_default_value(4, 1.0) 9 | set_input_port_default_value(5, Vector3(1.0, 1.0, 1.0)) 10 | set_input_port_default_value(6, 1.0) 11 | 12 | func _get_name() -> String: 13 | return "InnerGlowEmpty" 14 | 15 | func _get_category() -> String: 16 | return "RGBA" 17 | 18 | func _get_subcategory(): 19 | return "Glow" 20 | 21 | func _get_description() -> String: 22 | return "Same as InnerGlow but without original texture (only contours)" 23 | 24 | func _get_return_icon_type(): 25 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 26 | 27 | func _get_input_port_count() -> int: 28 | return 7 29 | 30 | func _get_input_port_name(port: int): 31 | match port: 32 | 0: 33 | return "sampler2D" 34 | 1: 35 | return "uv" 36 | 2: 37 | return "lod" 38 | 3: 39 | return "size" 40 | 4: 41 | return "intensity" 42 | 5: 43 | return "color" 44 | 6: 45 | return "alpha" 46 | 47 | func _get_input_port_type(port: int): 48 | match port: 49 | 0: 50 | return VisualShaderNode.PORT_TYPE_SAMPLER 51 | 1: 52 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 53 | 2: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 3: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 4: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 5: 60 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 61 | 6: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 64 | func _get_output_port_count() -> int: 65 | return 2 66 | 67 | func _get_output_port_name(port: int): 68 | match port: 69 | 0: 70 | return "col" 71 | 1: 72 | return "alpha" 73 | 74 | func _get_output_port_type(port: int): 75 | match port: 76 | 0: 77 | return VisualShaderNode.PORT_TYPE_VECTOR_3D 78 | 1: 79 | return VisualShaderNode.PORT_TYPE_SCALAR 80 | 81 | func _get_global_code(mode): 82 | var path = self.get_script().get_path().get_base_dir() 83 | return '#include "' + path + '/innerGlowEmpty.gdshaderinc"' 84 | 85 | func _get_code(input_vars, output_vars, mode, type): 86 | var texture = "TEXTURE" 87 | var uv = "UV" 88 | 89 | if input_vars[0]: 90 | texture = input_vars[0] 91 | if input_vars[1]: 92 | uv = input_vars[1] 93 | 94 | return """vec4 %s%s = _innerGlowEmptyFunc(%s, %s.xy, %s, %s, %s, vec4(%s, %s)); 95 | %s = %s%s.rgb; 96 | %s = %s%s.a;""" % [ 97 | output_vars[0], output_vars[1], texture, uv, input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[6], 98 | output_vars[0], output_vars[0], output_vars[1], 99 | output_vars[1], output_vars[0], output_vars[1]] 100 | --------------------------------------------------------------------------------