├── .import ├── .gdignore ├── ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.etc2.stex ├── ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.md5 ├── ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.s3tc.stex ├── ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.etc2.stex ├── ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.md5 ├── ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.s3tc.stex ├── ORANGE_BRICK_DISP.png-72e0f5dfa82c68dfc272559680fb4cf6.md5 ├── ORANGE_BRICK_DISP.png-72e0f5dfa82c68dfc272559680fb4cf6.stex ├── ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.etc2.stex ├── ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.md5 ├── ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.s3tc.stex ├── ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.etc2.stex ├── ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.md5 ├── ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.s3tc.stex ├── icon - Copy (2).png-a24309cb85b9401a65ab766593c53f71.md5 ├── icon - Copy.png-e6587c0e73d2763f12eb06840ccf4d68.md5 ├── icon.png-487276ed1e3a0c39cad0279d744ee560.etc2.stex ├── icon.png-487276ed1e3a0c39cad0279d744ee560.md5 ├── icon.png-487276ed1e3a0c39cad0279d744ee560.s3tc.stex ├── icon.png-487276ed1e3a0c39cad0279d744ee560.stex ├── icon2.png-2294dfe885793d4711fc20bee13a3760.md5 ├── icon2.png-2294dfe885793d4711fc20bee13a3760.stex ├── round256x256.PNG-3f1a0f3eaed5ade1fedb4691f9178b00.md5 ├── round256x256.PNG-3f1a0f3eaed5ade1fedb4691f9178b00.stex ├── round256x2562(2)_n.PNG-5ef8b5f82d72de57bfb2506e9db60b73.md5 ├── round256x2562.PNG-655467fe84091635a0e9c5dac849e46d.md5 ├── round256x2562.PNG-655467fe84091635a0e9c5dac849e46d.stex ├── round256x2562_n.PNG-366651df1ed0f65527bf1a411afa286c.md5 ├── round256x2562_n2.PNG-e9005db117405a34de72c7fd321959cc.md5 ├── round256x2562_n2_invertedY.PNG-afb2f30dd8794cde16a4af12e902dc9e.md5 ├── round256x2562_n2_invertedY.PNG-afb2f30dd8794cde16a4af12e902dc9e.stex ├── round256x2562_n3.png-fbaa4dfdf7110a52a82c9a777c20a7bb.md5 ├── round256x2562_n3_invertedY.png-746e1e43aa57244cf1cbd903a4562ca9.md5 ├── round256x2562_n4.png-a20ebc5e31f7e9588f1dae23d948ccfe.md5 ├── round256x256w.PNG-e3cee93710c4b2e23cae958eeea16669.md5 ├── round256x256w.PNG-e3cee93710c4b2e23cae958eeea16669.stex ├── round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.etc2.stex ├── round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.md5 ├── round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.s3tc.stex ├── water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.etc2.stex ├── water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.md5 ├── water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.s3tc.stex ├── water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.etc2.stex ├── water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.md5 ├── water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.s3tc.stex ├── water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.etc2.stex ├── water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.md5 └── water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.s3tc.stex ├── LICENSE ├── Shaders ├── 2DTopDownTerrain │ ├── 2dTopDownTerrain.tscn │ ├── 2dTopDownTerrain_material.tres │ └── 2dTopDownTerrain_shader.tres ├── FrostedGlass │ ├── FrostedGlass.material │ ├── FrostedGlass.shader │ └── FrostedGlass.tscn ├── Voronoi-Worley │ ├── Voronoi.shader │ ├── Voronoi.tres │ └── Voronoi.tscn ├── Water_Kmitt91 │ ├── stone_mat.material │ └── water_t.tscn └── planetshader │ ├── planetshader.gd │ ├── planetshader.tscn │ ├── planetshader_material.tres │ ├── planetshader_shader.tres │ ├── planetshader_shadercode.tres │ ├── round256x256.PNG │ ├── round256x256.PNG.import │ ├── round256x2562.PNG │ ├── round256x2562.PNG.import │ ├── round256x2562_n2_invertedY.PNG │ ├── round256x2562_n2_invertedY.PNG.import │ ├── round256x256w.PNG │ ├── round256x256w.PNG.import │ ├── round64x64.PNG │ └── round64x64.PNG.import ├── Visual Shaders ├── 2D_Dissolve │ ├── 2D_Dissolve.material │ ├── 2D_Dissolve.tres │ └── 2D_Dissolve.tscn ├── CurvedWorld(WIP) │ ├── CurvedWorld.gd │ ├── CurvedWorld.material │ ├── CurvedWorld.tscn │ ├── CurvedWorld_shader.res │ └── MeshInstance.gd ├── Fresnel Effect │ ├── Fresnel.material │ ├── Fresnel.tscn │ ├── HDR2.tres │ ├── fresnel_visualshader.tres │ └── rotate.gd ├── NoiseTexture │ ├── noisetexture.tres │ └── noisetexture.tscn ├── TextureGlow │ ├── HDR.tres │ ├── MeshInstance.gd │ ├── TextureGlow.material │ ├── TextureGlow.tres │ ├── TextureGlow.tscn │ ├── new_noisetexture.tres │ └── textures │ │ ├── ORANGE_BRICK_AO.png │ │ ├── ORANGE_BRICK_AO.png.import │ │ ├── ORANGE_BRICK_DIFF.png │ │ ├── ORANGE_BRICK_DIFF.png.import │ │ ├── ORANGE_BRICK_DISP.png │ │ ├── ORANGE_BRICK_DISP.png.import │ │ ├── ORANGE_BRICK_NORM.png │ │ ├── ORANGE_BRICK_NORM.png.import │ │ ├── ORANGE_BRICK_SPEC.png │ │ └── ORANGE_BRICK_SPEC.png.import ├── Water │ ├── plane.tscn │ ├── plane_mesh.tres │ ├── water.tscn │ ├── water_material.tres │ ├── water_normal.jpg │ ├── water_normal.jpg.import │ ├── water_normal_n.jpg │ ├── water_normal_n.jpg.import │ ├── water_normal_p.jpg │ ├── water_normal_p.jpg.import │ └── water_shader.tres └── Zoom │ ├── ZoomShader.tres │ └── ZoomShader.tscn ├── addons └── shaderV │ ├── rgba │ ├── BCSAdjustment.gd │ ├── blackNwhite.gd │ ├── blendAwithB.gd │ ├── bloom.gd │ ├── blur │ │ ├── blur9sample.gd │ │ ├── blurCustom.gd │ │ └── zoomBlur.gd │ ├── chromaticAberration.gd │ ├── clamp.gd │ ├── colorCorrectionAdjustment.gd │ ├── emboss.gd │ ├── generate_shapes │ │ ├── generateCircle.gd │ │ ├── generateCircle2.gd │ │ ├── generateRect.gd │ │ ├── generateRegularNgon.gd │ │ ├── generateSpiral.gd │ │ ├── scanLinesSharp.gd │ │ └── stripesRandom.gd │ ├── gradient4corners.gd │ ├── gradientMapping.gd │ ├── grayscale.gd │ ├── hue.gd │ ├── innerGlow.gd │ ├── innerGlowEmpty.gd │ ├── inverseColor.gd │ ├── maskAlpha.gd │ ├── noise │ │ ├── generic2d.gd │ │ ├── perlin2d.gd │ │ ├── perlin3d.gd │ │ ├── perlin4d.gd │ │ ├── perlinPeriodic3d.gd │ │ ├── simplex2d.gd │ │ ├── simplex3d.gd │ │ ├── simplex4d.gd │ │ ├── worley2d.gd │ │ ├── worley2x2.gd │ │ ├── worley2x2x2.gd │ │ └── worley3d.gd │ ├── posterize.gd │ ├── shiftHSV.gd │ ├── shineFX.gd │ ├── tintRGBA.gd │ ├── tonemap.gd │ ├── turnCGA4Palette.gd │ └── turnGBPalette.gd │ ├── tools │ ├── hash1d.gd │ ├── hash2d.gd │ ├── hash2dvector.gd │ ├── randomFloat.gd │ ├── randomFloatInput.gd │ ├── randomFloat_I.gd │ ├── randomGoldNoiseFloat.gd │ ├── relay.gd │ ├── remap.gd │ └── sinTime.gd │ └── uv │ ├── animated │ ├── distortionUVAnimated.gd │ ├── doodleUV.gd │ ├── rotateAnimated.gd │ ├── swirlUV.gd │ └── tilingNoffsetAnimated.gd │ ├── distortionUV.gd │ ├── flipUV.gd │ ├── lensDistortion.gd │ ├── pixelate.gd │ ├── rotate.gd │ ├── sphericalUV.gd │ ├── tileUV.gd │ ├── tilingNoffset.gd │ ├── twirl.gd │ └── zoomUV.gd ├── default_env.tres ├── icon.png ├── icon.png.import ├── icon2.png ├── icon2.png.import └── project.godot /.import/.gdignore: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.etc2.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.md5: -------------------------------------------------------------------------------- 1 | source_md5="e405bfb0ba24cc59f01c20b0d175cf1a" 2 | dest_md5="4872e1bf98cc553ec299d518ee09fc48" 3 | 4 | -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_AO.png-a3b42a368764b5a6cd6622229d2cec29.s3tc.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.etc2.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.md5: -------------------------------------------------------------------------------- 1 | source_md5="c4c2d34d80c98d88f1f0c19333108ed0" 2 | dest_md5="8496cfe636f6a81ee8a6bf2528652d72" 3 | 4 | -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_DIFF.png-290579554e1446c4fc738af303a0a10c.s3tc.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_DISP.png-72e0f5dfa82c68dfc272559680fb4cf6.md5: -------------------------------------------------------------------------------- 1 | source_md5="f371ae70a86942dd30c7b73daee2bb97" 2 | dest_md5="fa4ac8898115dbecaf239f37e19fdc4f" 3 | 4 | -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_DISP.png-72e0f5dfa82c68dfc272559680fb4cf6.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_DISP.png-72e0f5dfa82c68dfc272559680fb4cf6.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.etc2.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.md5: -------------------------------------------------------------------------------- 1 | source_md5="d386b85fe56a3adb0b0d52cc8b5b0107" 2 | dest_md5="af029587c5bcb318bf7641c4bab063a7" 3 | 4 | -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_NORM.png-ed9db9fb0a061b957636be9b87c39d1d.s3tc.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.etc2.stex -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.md5: -------------------------------------------------------------------------------- 1 | source_md5="53b6877f56f3f5f43081fc9dd63db2ee" 2 | dest_md5="b28b6e0fc68b93b2c6095932031fb48d" 3 | 4 | -------------------------------------------------------------------------------- /.import/ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/ORANGE_BRICK_SPEC.png-74164b5824853f966d4fd8e1b7e57e3d.s3tc.stex -------------------------------------------------------------------------------- /.import/icon - Copy (2).png-a24309cb85b9401a65ab766593c53f71.md5: -------------------------------------------------------------------------------- 1 | source_md5="efdcfa697c53274d500e5fbf84bb450f" 2 | dest_md5="feba81553edaf571b1f4048dcd7ebbb0" 3 | 4 | -------------------------------------------------------------------------------- /.import/icon - Copy.png-e6587c0e73d2763f12eb06840ccf4d68.md5: -------------------------------------------------------------------------------- 1 | source_md5="8dd9ff1eebf38898a54579d8c01b0a88" 2 | dest_md5="64b0613b3173e1e1c96dd18b6569e62d" 3 | 4 | -------------------------------------------------------------------------------- /.import/icon.png-487276ed1e3a0c39cad0279d744ee560.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/icon.png-487276ed1e3a0c39cad0279d744ee560.etc2.stex -------------------------------------------------------------------------------- /.import/icon.png-487276ed1e3a0c39cad0279d744ee560.md5: -------------------------------------------------------------------------------- 1 | source_md5="0167658bc4406f0d0fe437e0197c415a" 2 | dest_md5="3016389a90bd9cc0fb8c640bf5dc530e" 3 | 4 | -------------------------------------------------------------------------------- /.import/icon.png-487276ed1e3a0c39cad0279d744ee560.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/icon.png-487276ed1e3a0c39cad0279d744ee560.s3tc.stex -------------------------------------------------------------------------------- /.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex -------------------------------------------------------------------------------- /.import/icon2.png-2294dfe885793d4711fc20bee13a3760.md5: -------------------------------------------------------------------------------- 1 | source_md5="bd7006aea8a99615610bc7b59c79fe16" 2 | dest_md5="9cef47e05eb76e050ddf5d3f8571c030" 3 | 4 | -------------------------------------------------------------------------------- /.import/icon2.png-2294dfe885793d4711fc20bee13a3760.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/icon2.png-2294dfe885793d4711fc20bee13a3760.stex -------------------------------------------------------------------------------- /.import/round256x256.PNG-3f1a0f3eaed5ade1fedb4691f9178b00.md5: -------------------------------------------------------------------------------- 1 | source_md5="308a7f67c5af70f8503a40db0634a7b4" 2 | dest_md5="80610cb5397a1d7b3475a07e1d17a81f" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x256.PNG-3f1a0f3eaed5ade1fedb4691f9178b00.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/round256x256.PNG-3f1a0f3eaed5ade1fedb4691f9178b00.stex -------------------------------------------------------------------------------- /.import/round256x2562(2)_n.PNG-5ef8b5f82d72de57bfb2506e9db60b73.md5: -------------------------------------------------------------------------------- 1 | source_md5="94d8872fb4d44346ab946db609c3e9cf" 2 | dest_md5="28519c8735a192aed9c7aa8abe3e147e" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562.PNG-655467fe84091635a0e9c5dac849e46d.md5: -------------------------------------------------------------------------------- 1 | source_md5="dd4ea0affbd4753db77f6b97f83e37ca" 2 | dest_md5="6f8b1e7864ac237417af6bcab06261dc" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562.PNG-655467fe84091635a0e9c5dac849e46d.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/round256x2562.PNG-655467fe84091635a0e9c5dac849e46d.stex -------------------------------------------------------------------------------- /.import/round256x2562_n.PNG-366651df1ed0f65527bf1a411afa286c.md5: -------------------------------------------------------------------------------- 1 | source_md5="e98cafec275b0d5e0c618346dac15f0a" 2 | dest_md5="13515505acbc5dd48196dadabddd5e28" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562_n2.PNG-e9005db117405a34de72c7fd321959cc.md5: -------------------------------------------------------------------------------- 1 | source_md5="f9fcfaf7535236930e26131b8a6c5dcb" 2 | dest_md5="1c791c8269a7c2aff1bda5c23d301022" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562_n2_invertedY.PNG-afb2f30dd8794cde16a4af12e902dc9e.md5: -------------------------------------------------------------------------------- 1 | source_md5="fbe77a11d76dc31ed90a1dc455219e60" 2 | dest_md5="69ff04b7505ffef128f0a33385cb7a2c" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562_n2_invertedY.PNG-afb2f30dd8794cde16a4af12e902dc9e.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/round256x2562_n2_invertedY.PNG-afb2f30dd8794cde16a4af12e902dc9e.stex -------------------------------------------------------------------------------- /.import/round256x2562_n3.png-fbaa4dfdf7110a52a82c9a777c20a7bb.md5: -------------------------------------------------------------------------------- 1 | source_md5="ee002939f57d0e94bacab1a062d73e29" 2 | dest_md5="262bf898ad48661dfb1e749d7d784278" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562_n3_invertedY.png-746e1e43aa57244cf1cbd903a4562ca9.md5: -------------------------------------------------------------------------------- 1 | source_md5="5dcf8481f4e3b253f554eaf87f84d611" 2 | dest_md5="4fbbb28688d2753055864552268c4d49" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x2562_n4.png-a20ebc5e31f7e9588f1dae23d948ccfe.md5: -------------------------------------------------------------------------------- 1 | source_md5="96126d82164432f363a2682bf2afae26" 2 | dest_md5="8d585f11f88cbf25bb3ca21ec9bb930d" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x256w.PNG-e3cee93710c4b2e23cae958eeea16669.md5: -------------------------------------------------------------------------------- 1 | source_md5="0c5fa860d02d9478ee44f95c754ca3d1" 2 | dest_md5="47856fbe3bc7ef645fc816f3c6c6212d" 3 | 4 | -------------------------------------------------------------------------------- /.import/round256x256w.PNG-e3cee93710c4b2e23cae958eeea16669.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/round256x256w.PNG-e3cee93710c4b2e23cae958eeea16669.stex -------------------------------------------------------------------------------- /.import/round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.etc2.stex -------------------------------------------------------------------------------- /.import/round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.md5: -------------------------------------------------------------------------------- 1 | source_md5="0409c80ca7bb1b4e16479afb4af63e86" 2 | dest_md5="9e66844fc03f3596ed89da92cdc15d1e" 3 | 4 | -------------------------------------------------------------------------------- /.import/round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/round64x64.PNG-3fdcae263a9af1b0901104e5d991fb05.s3tc.stex -------------------------------------------------------------------------------- /.import/water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.etc2.stex -------------------------------------------------------------------------------- /.import/water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.md5: -------------------------------------------------------------------------------- 1 | source_md5="570b0a8211397505c28881225a5a6cc0" 2 | dest_md5="a9641fd5726db97766cdd9ccad013dfe" 3 | 4 | -------------------------------------------------------------------------------- /.import/water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/water_normal.jpg-c73dae6346245cf4f302ca7eb6a4e0a7.s3tc.stex -------------------------------------------------------------------------------- /.import/water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.etc2.stex -------------------------------------------------------------------------------- /.import/water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.md5: -------------------------------------------------------------------------------- 1 | source_md5="7d0111da0910cae93942c5bf9b2d9337" 2 | dest_md5="322e6444b4f91bf98252fdb50ac5a0f1" 3 | 4 | -------------------------------------------------------------------------------- /.import/water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/water_normal_n.jpg-b5d1158fe71bfd5269167d121f0f1ac3.s3tc.stex -------------------------------------------------------------------------------- /.import/water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.etc2.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.etc2.stex -------------------------------------------------------------------------------- /.import/water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.md5: -------------------------------------------------------------------------------- 1 | source_md5="57f2c53fd554e6f943f74d6435da874a" 2 | dest_md5="59ea6669f4d836c26727e243fdb35dec" 3 | 4 | -------------------------------------------------------------------------------- /.import/water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.s3tc.stex: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/.import/water_normal_p.jpg-5ed7a74e91be1ae47ff57e0196bd8ce7.s3tc.stex -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019-2022 Christoffer Sundbom https://github.com/Norrox/ 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Shaders/2DTopDownTerrain/2dTopDownTerrain.tscn: -------------------------------------------------------------------------------- 1 | [gd_scene load_steps=3 format=2] 2 | 3 | [ext_resource path="res://icon.png" type="Texture" id=1] 4 | [ext_resource path="res://Shaders/2DTopDownTerrain/2dTopDownTerrain_material.tres" type="Material" id=2] 5 | 6 | 7 | [node name="Node2D" type="Node2D"] 8 | 9 | [node name="Sprite" type="Sprite" parent="."] 10 | material = ExtResource( 2 ) 11 | position = Vector2( 512, 299.5 ) 12 | scale = Vector2( 15.9375, 9.39063 ) 13 | texture = ExtResource( 1 ) 14 | -------------------------------------------------------------------------------- /Shaders/2DTopDownTerrain/2dTopDownTerrain_material.tres: -------------------------------------------------------------------------------- 1 | [gd_resource type="ShaderMaterial" load_steps=2 format=2] 2 | 3 | [ext_resource path="res://Shaders/2DTopDownTerrain/2dTopDownTerrain_shader.tres" type="Shader" id=1] 4 | 5 | [resource] 6 | shader = ExtResource( 1 ) 7 | shader_param/heighest_landmass = 1.75 8 | shader_param/lowest_landmass = 0.0 9 | shader_param/landmass = 1.25 10 | shader_param/density = 50.42 11 | shader_param/seed = 1337.0 12 | shader_param/iResolution = Vector2( 64, 64 ) 13 | shader_param/uni_radius = 100.0 14 | shader_param/color_1 = Color( 0, 0.388235, 0.627451, 1 ) 15 | shader_param/color_2 = Color( 0, 0.588235, 1, 1 ) 16 | shader_param/color_3 = Color( 1, 0.980392, 0.533333, 1 ) 17 | shader_param/color_4 = Color( 0.105882, 0.611765, 0, 1 ) 18 | shader_param/color_5 = Color( 0, 0.490196, 0.0313726, 1 ) 19 | shader_param/color_6 = Color( 0, 0.34902, 0.0705882, 1 ) 20 | shader_param/color_7 = Color( 0.458824, 0.458824, 0.458824, 1 ) 21 | shader_param/color_8 = Color( 0.623529, 0.623529, 0.623529, 1 ) 22 | shader_param/color_9 = Color( 0.815686, 0.815686, 0.815686, 1 ) 23 | shader_param/color_10 = Color( 1, 1, 1, 1 ) 24 | -------------------------------------------------------------------------------- /Shaders/2DTopDownTerrain/2dTopDownTerrain_shader.tres: -------------------------------------------------------------------------------- 1 | [gd_resource type="Shader" format=2] 2 | 3 | [resource] 4 | code = "shader_type canvas_item; 5 | 6 | uniform float heighest_landmass = 1.0; 7 | uniform float lowest_landmass = 0.0; 8 | uniform float landmass = 1.0; 9 | uniform float density = 5.0; 10 | uniform float seed = 1337.0; 11 | uniform vec2 iResolution = vec2(64,64); 12 | uniform float uni_radius = 100.0f; 13 | uniform vec4 color_1 : hint_color = vec4(0.77,0.90,0.98,1.0); 14 | uniform vec4 color_2 : hint_color = vec4(0.82,0.92,0.99,1.0); 15 | uniform vec4 color_3 : hint_color = vec4(0.91,0.97,0.99,1.0); 16 | uniform vec4 color_4 : hint_color = vec4(0.62,0.75,0.59,1.0); 17 | uniform vec4 color_5 : hint_color = vec4(0.86,0.90,0.68,1.0); 18 | uniform vec4 color_6 : hint_color = vec4(0.99,0.99,0.63,1.0); 19 | uniform vec4 color_7 : hint_color = vec4(0.99,0.83,0.59,1.0); 20 | uniform vec4 color_8 : hint_color = vec4(0.98,0.71,0.49,1.0); 21 | uniform vec4 color_9 : hint_color = vec4(0.98,0.57,0.47,1.0); 22 | uniform vec4 color_10 : hint_color = vec4(0.79,0.48,0.43,1.0); 23 | 24 | float noise (vec3 n) 25 | { 26 | return fract(sin(dot(n, vec3(95.43583, 93.323197, 94.993431))) * 65536.32); 27 | } 28 | 29 | float perlin_a (vec3 n) 30 | { 31 | vec3 base = floor(n * 64.0) * 0.015625; 32 | vec3 dd = vec3(0.015625, 0.0, 0.0); 33 | float a = noise(base); 34 | float b = noise(base + dd.xyy); 35 | float c = noise(base + dd.yxy); 36 | float d = noise(base + dd.xxy); 37 | vec3 p = (n - base) * 64.0; 38 | float t = mix(a, b, p.x); 39 | float tt = mix(c, d, p.x); 40 | return mix(t, tt, p.y); 41 | } 42 | 43 | float perlin_b (vec3 n) 44 | { 45 | vec3 base = vec3(n.x, n.y, floor(n.z * 64.0) * 0.015625); 46 | vec3 dd = vec3(0.015625, 0.0, 0.0); 47 | vec3 p = (n - base) * 64.0; 48 | float front = perlin_a(base + dd.yyy); 49 | float back = perlin_a(base + dd.yyx); 50 | return mix(front, back, p.z); 51 | } 52 | 53 | float fbm(vec3 n) 54 | { 55 | float total = 0.0; 56 | float m1 = 1.0; 57 | float m2 = 0.1; 58 | for (int i = 0; i < 5; i++) 59 | { 60 | total += perlin_b(n * m1) * m2; 61 | m2 *= 2.0; 62 | m1 *= 0.5; 63 | } 64 | return total; 65 | } 66 | 67 | vec3 heightmap (vec3 n) 68 | { 69 | return vec3(fbm((5.0 * n) + fbm((5.0 * n) * 3.0 - 1000.0) * 0.05),0,0); 70 | } 71 | 72 | vec4 PixelShaderFunction(vec2 coords) 73 | { 74 | float dx = coords.x - 0.5f; 75 | float dy = coords.y - 0.5f; 76 | if(dx * dx + dy * dy <= 0.25f) 77 | return vec4(1.0, 0.0, 0.0, 1.0); 78 | else 79 | return vec4(0.0, 0.0, 0.0, 0.0); 80 | } 81 | 82 | void fragment() 83 | { 84 | vec2 position = UV; 85 | float pi = 3.14; 86 | float distance_to_center = distance(position, vec2(0.5,0.5)); 87 | 88 | //vec2 uv = (2.0*FRAGCOORD.xy - iResolution.xy)/iResolution.y; 89 | //float t = floor(TIME*0.9); 90 | float _color = clamp(vec4(vec3((heightmap(vec3(UV.xy*density,seed)*0.02)-landmass)),1.0).r,lowest_landmass,heighest_landmass); 91 | 92 | if (distance_to_center String: 6 | return "BCSAdjustment" 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 BCS adjustment of environment in Godot" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 4 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "color" 27 | 1: 28 | return "brightness" 29 | 2: 30 | return "contrast" 31 | 3: 32 | return "saturation" 33 | 34 | func _get_input_port_type(port: int): 35 | set_input_port_default_value(1, 1.0) 36 | set_input_port_default_value(2, 1.0) 37 | set_input_port_default_value(3, 1.0) 38 | match port: 39 | 0: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 1: 42 | return VisualShaderNode.PORT_TYPE_SCALAR 43 | 2: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 3: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 48 | func _get_output_port_count() -> int: 49 | return 1 50 | 51 | func _get_output_port_name(port: int) -> String: 52 | return "col" 53 | 54 | func _get_output_port_type(port: int) -> int: 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 57 | func _get_global_code(mode: int) -> String: 58 | return """ 59 | vec3 applyBCSFunc(vec3 _c0l_BCS, vec3 _bcs_vec) { 60 | _c0l_BCS = mix(vec3(0.0), _c0l_BCS, _bcs_vec.x); 61 | _c0l_BCS = mix(vec3(0.5), _c0l_BCS, _bcs_vec.y); 62 | _c0l_BCS = mix(vec3(dot(vec3(1.0), _c0l_BCS) * 0.33333), _c0l_BCS, _bcs_vec.z); 63 | return _c0l_BCS; 64 | } 65 | """ 66 | 67 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 68 | return "%s = applyBCSFunc(%s, vec3(%s, %s, %s));" % [ 69 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 70 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blackNwhite.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblackNwhite 4 | 5 | func _get_name() -> String: 6 | return "BlackAndWhite" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | #func _get_description() -> String: 15 | # return "" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "threshold" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, 0.5) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 1: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "col" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec3 blackNwh1teFunc(vec3 _c0l_bNw, float _thresh0ld_bNw){ 50 | return vec3( ( (0.21 * _c0l_bNw.r + 0.71 * _c0l_bNw.g + 0.07 * _c0l_bNw.b) < _thresh0ld_bNw) ? 0.0 : 1.0); 51 | } 52 | """ 53 | 54 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 55 | return "%s = blackNwh1teFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 56 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blendAwithB.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblend 4 | 5 | func _get_name() -> String: 6 | return "BlendAwithB" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Blends colors basing on fade" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "colorDown" 27 | 1: 28 | return "alphaDown" 29 | 2: 30 | return "colorUp" 31 | 3: 32 | return "alphaUp" 33 | 4: 34 | return "fade" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, 1.0) 38 | set_input_port_default_value(3, 1.0) 39 | set_input_port_default_value(4, 1.0) 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_VECTOR 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_VECTOR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 4: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 52 | func _get_output_port_count() -> int: 53 | return 2 54 | 55 | func _get_output_port_name(port: int): 56 | match port: 57 | 0: 58 | return "col" 59 | 1: 60 | return "alpha" 61 | 62 | func _get_output_port_type(port: int): 63 | match port: 64 | 0: 65 | return VisualShaderNode.PORT_TYPE_VECTOR 66 | 1: 67 | return VisualShaderNode.PORT_TYPE_SCALAR 68 | 69 | func _get_global_code(mode: int) -> String: 70 | return """ 71 | vec4 blendAwithBFunc(vec4 _c0l0r_blendA_rgba, vec4 _c0l0r_blendB_rgba, float _fade_blend_c0l0r){ 72 | return mix(_c0l0r_blendA_rgba, _c0l0r_blendB_rgba, _c0l0r_blendB_rgba.a * _fade_blend_c0l0r); 73 | } 74 | """ 75 | 76 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 77 | return """vec4 %s%s = blendAwithBFunc(vec4(%s, %s), vec4(%s, %s), %s); 78 | %s = %s%s.rgb; 79 | %s = %s%s.a;""" % [ 80 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], 81 | output_vars[0], output_vars[0], output_vars[1], 82 | output_vars[1], output_vars[0], output_vars[1]] 83 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/bloom.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAbloom 4 | 5 | func _get_name() -> String: 6 | return "Bloom" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | #func _get_description() -> String: 15 | # return "" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "color" 27 | 1: 28 | return "alpha" 29 | 2: 30 | return "strength" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(2, 1.0) 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 2: 40 | return VisualShaderNode.PORT_TYPE_SCALAR 41 | 42 | func _get_output_port_count() -> int: 43 | return 2 44 | 45 | func _get_output_port_name(port: int): 46 | match port: 47 | 0: 48 | return "col" 49 | 1: 50 | return "alpha" 51 | 52 | func _get_output_port_type(port: int): 53 | match port: 54 | 0: 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 1: 57 | return VisualShaderNode.PORT_TYPE_SCALAR 58 | 59 | func _get_global_code(mode: int) -> String: 60 | return """ 61 | vec4 bl00mFunc(vec4 _c0l_bl00m, float _strength_bl00m){ 62 | float _gamma_bl00m = 1.0 - pow(_c0l_bl00m.r, _strength_bl00m); 63 | _c0l_bl00m.rgb += (_c0l_bl00m.rgb * _c0l_bl00m.a) * min(max(_strength_bl00m, 0.0), 1.0); 64 | return _c0l_bl00m; 65 | } 66 | """ 67 | 68 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 69 | return """vec4 %s%s = bl00mFunc(vec4(%s, %s), %s); 70 | %s = %s%s.rgb; 71 | %s = %s%s.a""" % [ 72 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], 73 | output_vars[0], output_vars[0], output_vars[1], 74 | output_vars[1], output_vars[0], output_vars[1]] 75 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/blurCustom.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAblurCustom 4 | 5 | func _get_name() -> String: 6 | return "BlurCustom" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return """Custom 8-directional blur with ([amount]*2+1)^2 samples 16 | Note: negative lod => detect lod automatically""" 17 | 18 | func _get_return_icon_type() -> int: 19 | return VisualShaderNode.PORT_TYPE_VECTOR 20 | 21 | func _get_input_port_count() -> int: 22 | return 5 23 | 24 | func _get_input_port_name(port: int): 25 | match port: 26 | 0: 27 | return "sampler2D" 28 | 1: 29 | return "uv" 30 | 2: 31 | return "lod" 32 | 3: 33 | return "amount" 34 | 4: 35 | return "offset" 36 | 37 | func _get_input_port_type(port: int): 38 | set_input_port_default_value(2, -1.0) 39 | set_input_port_default_value(3, 5) 40 | set_input_port_default_value(4, 0.001) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_SAMPLER 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_output_port_count() -> int: 54 | return 2 55 | 56 | func _get_output_port_name(port: int): 57 | match port: 58 | 0: 59 | return "col" 60 | 1: 61 | return "alpha" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_VECTOR 67 | 1: 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 70 | func _get_global_code(mode: int) -> String: 71 | return """ 72 | vec4 blurWithAmountFunc(sampler2D _tex_b1r_cst, vec2 _uv_b1r_cst, float _l0d_b1r_cst, int _amnt_b1r_cst, float _0ffst_b1r_cst) { 73 | vec4 _c0l_b1r_cst = vec4(0, 0, 0, 0); 74 | _amnt_b1r_cst = int(max(min(float(_amnt_b1r_cst), 20.0), 0.0)); // have to do this int() float() shit because of gles2 75 | // max _amnt_b1r_cst is 20 for not to kill PC 76 | for(int x = -_amnt_b1r_cst; x <= _amnt_b1r_cst; x++) { 77 | for(int y = -_amnt_b1r_cst; y <= _amnt_b1r_cst; y++) { 78 | vec2 _c00rd_b1r_cst = _uv_b1r_cst + vec2(float(x), float(y)) * _0ffst_b1r_cst; 79 | if (_l0d_b1r_cst < 0.0){ 80 | _c0l_b1r_cst += texture(_tex_b1r_cst, _c00rd_b1r_cst); 81 | }else{ 82 | _c0l_b1r_cst += textureLod(_tex_b1r_cst, _c00rd_b1r_cst, _l0d_b1r_cst); 83 | } 84 | } 85 | } 86 | int _nmb_ne1ghb0urs_b1r_cst = (_amnt_b1r_cst * 2 + 1) * (_amnt_b1r_cst * 2 + 1); 87 | _c0l_b1r_cst /= float(_nmb_ne1ghb0urs_b1r_cst); 88 | return _c0l_b1r_cst; 89 | } 90 | """ 91 | 92 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 93 | return """vec4 %s%s = blurWithAmountFunc(%s, %s.xy, %s, int(%s), %s); 94 | %s = %s%s.rgb; 95 | %s = %s%s.a;""" % [ 96 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], 97 | output_vars[0], output_vars[0], output_vars[1], 98 | output_vars[1], output_vars[0], output_vars[1]] 99 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/blur/zoomBlur.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAzoomBlur 4 | 5 | func _get_name() -> String: 6 | return "ZoomBlur" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return """Zoom blur using [amount] samples 16 | Note: negative lod => detect lod automatically""" 17 | 18 | func _get_return_icon_type() -> int: 19 | return VisualShaderNode.PORT_TYPE_VECTOR 20 | 21 | func _get_input_port_count() -> int: 22 | return 6 23 | 24 | func _get_input_port_name(port: int): 25 | match port: 26 | 0: 27 | return "sampler2D" 28 | 1: 29 | return "uv" 30 | 2: 31 | return "lod" 32 | 3: 33 | return "pivot" 34 | 4: 35 | return "amount" 36 | 5: 37 | return "length" 38 | 39 | func _get_input_port_type(port: int): 40 | set_input_port_default_value(2, -1.0) 41 | set_input_port_default_value(3, Vector3(0.5, 0.5, 0.0)) 42 | set_input_port_default_value(4, 20.0) 43 | set_input_port_default_value(5, 0.005) 44 | match port: 45 | 0: 46 | return VisualShaderNode.PORT_TYPE_SAMPLER 47 | 1: 48 | return VisualShaderNode.PORT_TYPE_VECTOR 49 | 2: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 3: 52 | return VisualShaderNode.PORT_TYPE_VECTOR 53 | 4: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 5: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 58 | func _get_output_port_count() -> int: 59 | return 2 60 | 61 | func _get_output_port_name(port: int): 62 | match port: 63 | 0: 64 | return "col" 65 | 1: 66 | return "alpha" 67 | 68 | func _get_output_port_type(port: int): 69 | match port: 70 | 0: 71 | return VisualShaderNode.PORT_TYPE_VECTOR 72 | 1: 73 | return VisualShaderNode.PORT_TYPE_SCALAR 74 | 75 | func _get_global_code(mode: int) -> String: 76 | return """ 77 | vec4 zoomBlurFunc(sampler2D _tex_z00m_blur, vec2 _uv_z00m_blur, int _amount_z00m_blur, vec2 _center_zoom, float _lgt_z00m_blur, float _lod_z00m_blur){ 78 | vec4 _col_z00m_blur; 79 | if (_lod_z00m_blur < 0.0){ 80 | _col_z00m_blur = texture(_tex_z00m_blur, _uv_z00m_blur); 81 | for (int i = 1; i <= _amount_z00m_blur; i++){ 82 | float _temp_d_z00m_blur = _lgt_z00m_blur * float(i); 83 | vec2 px = _uv_z00m_blur * (1.0 - _temp_d_z00m_blur) + _center_zoom * _temp_d_z00m_blur; 84 | _col_z00m_blur += texture(_tex_z00m_blur, px); 85 | } 86 | }else{ 87 | _col_z00m_blur = textureLod(_tex_z00m_blur, _uv_z00m_blur, _lod_z00m_blur); 88 | for (int i = 1; i <= _amount_z00m_blur; i++){ 89 | float _temp_d_z00m_blur = _lgt_z00m_blur * float(i); 90 | vec2 px = _uv_z00m_blur * (1.0 - _temp_d_z00m_blur) + _center_zoom * _temp_d_z00m_blur; 91 | _col_z00m_blur += textureLod(_tex_z00m_blur, px, _lod_z00m_blur); 92 | } 93 | } 94 | _col_z00m_blur = _col_z00m_blur / float(_amount_z00m_blur + 1); 95 | return _col_z00m_blur; 96 | } 97 | """ 98 | 99 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 100 | return """vec4 %s%s = zoomBlurFunc(%s, %s.xy, int(%s), %s.xy, %s, %s); 101 | %s = %s%s.rgb; 102 | %s = %s%s.a;""" % [ 103 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[4], input_vars[3], input_vars[5], input_vars[2], 104 | output_vars[0], output_vars[0], output_vars[1], 105 | output_vars[1], output_vars[0], output_vars[1]] 106 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/chromaticAberration.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAchromaticAberration 4 | 5 | func _get_name() -> String: 6 | return "ChromaticAberration" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return """Basic Chromatic Aberration with red and blue channels offset 16 | Note: negative lod => detect lod automatically""" 17 | 18 | func _get_return_icon_type() -> int: 19 | return VisualShaderNode.PORT_TYPE_VECTOR 20 | 21 | func _get_input_port_count() -> int: 22 | return 5 23 | 24 | func _get_input_port_name(port: int): 25 | match port: 26 | 0: 27 | return "sampler2D" 28 | 1: 29 | return "uv" 30 | 2: 31 | return "lod" 32 | 3: 33 | return "amountX" 34 | 4: 35 | return "amountY" 36 | 37 | func _get_input_port_type(port: int): 38 | set_input_port_default_value(2, -1.0) 39 | set_input_port_default_value(3, 0.05) 40 | set_input_port_default_value(4, 0.0) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_SAMPLER 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_output_port_count() -> int: 54 | return 2 55 | 56 | func _get_output_port_name(port: int): 57 | match port: 58 | 0: 59 | return "col" 60 | 1: 61 | return "alpha" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_VECTOR 67 | 1: 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 70 | func _get_global_code(mode: int) -> String: 71 | return """ 72 | vec4 chr0maticAberrati0nFunc(sampler2D _texture_chr_aberrat1on, vec2 _uv_chr_aberrat1on, vec3 _values_chr_aberrat1on){ 73 | vec4 _c0l_chr_aberrat1on = vec4(0.0); 74 | if (_values_chr_aberrat1on.z < 0.0){ 75 | _c0l_chr_aberrat1on.r = texture(_texture_chr_aberrat1on, _uv_chr_aberrat1on + _values_chr_aberrat1on.xy).r; 76 | _c0l_chr_aberrat1on.g = texture(_texture_chr_aberrat1on, _uv_chr_aberrat1on).g; 77 | _c0l_chr_aberrat1on.b = texture(_texture_chr_aberrat1on, _uv_chr_aberrat1on - _values_chr_aberrat1on.xy).b; 78 | _c0l_chr_aberrat1on.a = texture(_texture_chr_aberrat1on, _uv_chr_aberrat1on).a; 79 | }else{ 80 | _c0l_chr_aberrat1on.r = textureLod(_texture_chr_aberrat1on, _uv_chr_aberrat1on + 81 | _values_chr_aberrat1on.xy, _values_chr_aberrat1on.z).r; 82 | _c0l_chr_aberrat1on.g = textureLod(_texture_chr_aberrat1on, _uv_chr_aberrat1on, _values_chr_aberrat1on.z).g; 83 | _c0l_chr_aberrat1on.b = textureLod(_texture_chr_aberrat1on, _uv_chr_aberrat1on - 84 | _values_chr_aberrat1on.xy, _values_chr_aberrat1on.z).b; 85 | _c0l_chr_aberrat1on.a = textureLod(_texture_chr_aberrat1on, _uv_chr_aberrat1on, _values_chr_aberrat1on.z).a; 86 | } 87 | return _c0l_chr_aberrat1on; 88 | } 89 | """ 90 | 91 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 92 | return """vec4 %s%s = chr0maticAberrati0nFunc(%s, %s.xy, vec3(%s, %s, %s)); 93 | %s = %s%s.rgb; 94 | %s = %s%s.a;""" % [ 95 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[3], input_vars[4], input_vars[2], 96 | output_vars[0], output_vars[0], output_vars[1], 97 | output_vars[1], output_vars[0], output_vars[1]] 98 | -------------------------------------------------------------------------------- /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() -> int: 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 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: int) -> int: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 46 | func _get_global_code(mode: int) -> String: 47 | return """ 48 | float clampAlphaBorderFunc(float _color_alpha_clamp, vec2 _uv_clamp){ 49 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(_uv_clamp.x), 0.0)); 50 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(1.0 - _uv_clamp.x), 0.0)); 51 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(_uv_clamp.y), 0.0)); 52 | _color_alpha_clamp = mix(0.0, _color_alpha_clamp, max(sign(1.0 - _uv_clamp.y), 0.0)); 53 | return _color_alpha_clamp; 54 | } 55 | """ 56 | 57 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 58 | return output_vars[0] + " = clampAlphaBorderFunc(%s, (%s).xy);" % [input_vars[0], input_vars[1]] 59 | -------------------------------------------------------------------------------- /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() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 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: int) -> int: 44 | return VisualShaderNode.PORT_TYPE_VECTOR 45 | 46 | func _get_global_code(mode: int) -> String: 47 | return """ 48 | vec3 applyC0l0rC0rrecti0nFunc(vec3 _c0l_c0rr, sampler2D _tex_c0rr) { 49 | _c0l_c0rr.r = texture(_tex_c0rr, vec2(_c0l_c0rr.r, 0.0)).r; 50 | _c0l_c0rr.g = texture(_tex_c0rr, vec2(_c0l_c0rr.g, 0.0)).g; 51 | _c0l_c0rr.b = texture(_tex_c0rr, vec2(_c0l_c0rr.b, 0.0)).b; 52 | return _c0l_c0rr; 53 | } 54 | """ 55 | 56 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 57 | return "%s = applyC0l0rC0rrecti0nFunc(%s, %s);" % [ 58 | output_vars[0], input_vars[0], input_vars[1]] 59 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/emboss.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAemboss 4 | 5 | func _get_name() -> String: 6 | return "Emboss" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Emboss filter" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "sampler2D" 27 | 1: 28 | return "uv" 29 | 2: 30 | return "lod" 31 | 3: 32 | return "offset" 33 | 4: 34 | return "contrast" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(2, -1.0) 38 | set_input_port_default_value(3, 0.005) 39 | set_input_port_default_value(4, 1.0) 40 | match port: 41 | 0: 42 | return VisualShaderNode.PORT_TYPE_SAMPLER 43 | 1: 44 | return VisualShaderNode.PORT_TYPE_VECTOR 45 | 2: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 3: 48 | return VisualShaderNode.PORT_TYPE_SCALAR 49 | 4: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 52 | func _get_output_port_count() -> int: 53 | return 2 54 | 55 | func _get_output_port_name(port: int): 56 | match port: 57 | 0: 58 | return "col" 59 | 1: 60 | return "alpha" 61 | 62 | func _get_output_port_type(port: int): 63 | match port: 64 | 0: 65 | return VisualShaderNode.PORT_TYPE_VECTOR 66 | 1: 67 | return VisualShaderNode.PORT_TYPE_SCALAR 68 | 69 | func _get_global_code(mode: int) -> String: 70 | return """ 71 | vec4 emb0ssFunc(sampler2D _tex_emb0ss, vec2 _uv_emb0ss, float _lod_emb0ss, vec2 _ofst_emb0ss, float _ctst_emb0ss){ 72 | vec4 col_emb0ss = vec4(0.5, 0.5, 0.5, 0.5); 73 | if (_lod_emb0ss < 0.0){ 74 | col_emb0ss -= texture(_tex_emb0ss, _uv_emb0ss - _ofst_emb0ss) * _ctst_emb0ss; 75 | col_emb0ss += texture(_tex_emb0ss, _uv_emb0ss + _ofst_emb0ss) * _ctst_emb0ss; 76 | }else{ 77 | col_emb0ss -= textureLod(_tex_emb0ss, _uv_emb0ss - _ofst_emb0ss, _lod_emb0ss) * _ctst_emb0ss; 78 | col_emb0ss += textureLod(_tex_emb0ss, _uv_emb0ss + _ofst_emb0ss, _lod_emb0ss) * _ctst_emb0ss; 79 | } 80 | col_emb0ss.rgb = vec3(0.21 * col_emb0ss.r + 0.71 * col_emb0ss.g + 0.07 * col_emb0ss.b); 81 | return col_emb0ss; 82 | } 83 | """ 84 | 85 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 86 | return """vec4 %s%s = emb0ssFunc(%s, %s.xy, %s, vec2(%s), %s); 87 | %s = %s%s.rgb; 88 | %s = %s%s.a;""" % [ 89 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], 90 | output_vars[0], output_vars[0], output_vars[1], 91 | output_vars[1], output_vars[0], output_vars[1]] 92 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateCircle.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateCircle 4 | 5 | func _get_name() -> String: 6 | return "CircleCreate" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Circle creation with adjusted position, scale, inner/outer radius, hardness and color" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 8 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "pos" 29 | 2: 30 | return "scale" 31 | 3: 32 | return "inRadius" 33 | 4: 34 | return "outRadius" 35 | 5: 36 | return "hardness" 37 | 6: 38 | return "color" 39 | 7: 40 | return "alpha" 41 | 42 | func _get_input_port_type(port: int): 43 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0)) 44 | set_input_port_default_value(2, Vector3(1.0, 1.0, 0.0)) 45 | set_input_port_default_value(3, -0.5) 46 | set_input_port_default_value(4, 0.5) 47 | set_input_port_default_value(5, 1.0) 48 | set_input_port_default_value(6, Vector3(1.0, 1.0, 1.0)) 49 | set_input_port_default_value(7, 1.0) 50 | match port: 51 | 0: 52 | return VisualShaderNode.PORT_TYPE_VECTOR 53 | 1: 54 | return VisualShaderNode.PORT_TYPE_VECTOR 55 | 2: 56 | return VisualShaderNode.PORT_TYPE_VECTOR 57 | 3: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 4: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 5: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 6: 64 | return VisualShaderNode.PORT_TYPE_VECTOR 65 | 7: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 68 | func _get_output_port_count() -> int: 69 | return 2 70 | 71 | func _get_output_port_name(port: int): 72 | match port: 73 | 0: 74 | return "col" 75 | 1: 76 | return "alpha" 77 | 78 | func _get_output_port_type(port: int): 79 | match port: 80 | 0: 81 | return VisualShaderNode.PORT_TYPE_VECTOR 82 | 1: 83 | return VisualShaderNode.PORT_TYPE_SCALAR 84 | 85 | func _get_global_code(mode: int) -> String: 86 | return """ 87 | vec4 generateCirc1eFunc(vec2 _uv_circ1e, vec2 _center_circ1e, vec2 _scale_factor_circ1e, float _innerRad_circ1e, float _outRad_circ1e, float _hard_circ1e) { 88 | float _innerRadiusCheck0 = min(_innerRad_circ1e, _outRad_circ1e); 89 | float _outerRadiusCheck0 = max(_innerRad_circ1e, _outRad_circ1e); 90 | 91 | float currentP0sitionC1rcle = length((_uv_circ1e - _center_circ1e) * _scale_factor_circ1e); 92 | float maxIntencityCenterC1rcle = (_outerRadiusCheck0 + _innerRadiusCheck0) * 0.5; 93 | float rd0 = _outerRadiusCheck0 - maxIntencityCenterC1rcle; 94 | float circ1eDistributi0n = min(max(abs(currentP0sitionC1rcle - maxIntencityCenterC1rcle) / rd0, 0.0), 1.0); 95 | vec4 _outputColor0 = vec4(1.0); 96 | _outputColor0.a = 1.0 - pow(circ1eDistributi0n, _hard_circ1e); 97 | return _outputColor0; 98 | } 99 | """ 100 | 101 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 102 | return """%s = %s; 103 | %s = generateCirc1eFunc(%s.xy, %s.xy, %s.xy, %s, %s, %s).a * %s;""" % [output_vars[0], 104 | input_vars[6], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[7]] 105 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateCircle2.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateCircle2 4 | 5 | func _get_name() -> String: 6 | return "CircleCreate2" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Circle creation with adjusted position, scale, radius inner/outer width, and color" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 8 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "pos" 29 | 2: 30 | return "scale" 31 | 3: 32 | return "radius" 33 | 4: 34 | return "inWidth" 35 | 5: 36 | return "outWidth" 37 | 6: 38 | return "color" 39 | 7: 40 | return "alpha" 41 | 42 | func _get_input_port_type(port: int): 43 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0)) 44 | set_input_port_default_value(2, Vector3(1.0, 1.0, 0.0)) 45 | set_input_port_default_value(3, 0.0) 46 | set_input_port_default_value(4, 0.5) 47 | set_input_port_default_value(5, 0.5) 48 | set_input_port_default_value(6, Vector3(1.0, 1.0, 1.0)) 49 | set_input_port_default_value(7, 1.0) 50 | match port: 51 | 0: 52 | return VisualShaderNode.PORT_TYPE_VECTOR 53 | 1: 54 | return VisualShaderNode.PORT_TYPE_VECTOR 55 | 2: 56 | return VisualShaderNode.PORT_TYPE_VECTOR 57 | 3: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 4: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 5: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 6: 64 | return VisualShaderNode.PORT_TYPE_VECTOR 65 | 7: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 68 | func _get_output_port_count() -> int: 69 | return 2 70 | 71 | func _get_output_port_name(port: int): 72 | match port: 73 | 0: 74 | return "col" 75 | 1: 76 | return "alpha" 77 | 78 | func _get_output_port_type(port: int): 79 | match port: 80 | 0: 81 | return VisualShaderNode.PORT_TYPE_VECTOR 82 | 1: 83 | return VisualShaderNode.PORT_TYPE_SCALAR 84 | 85 | func _get_global_code(mode: int) -> String: 86 | return """ 87 | vec4 generateCircle2Func(vec2 _uv_gc2, vec2 _p0s_gc2, vec2 _sca1e_gc2, float _rad_gc2, 88 | float _b0rdIn_gc2, float _b0rdOut_gc2, vec4 _c0l_gc2){ 89 | float _dst_gc2 = length((_uv_gc2 - _p0s_gc2) * _sca1e_gc2); 90 | _c0l_gc2.a *= smoothstep(_rad_gc2 - _b0rdIn_gc2, _rad_gc2, _dst_gc2) 91 | - smoothstep(_rad_gc2, _rad_gc2 + _b0rdOut_gc2, _dst_gc2); 92 | return _c0l_gc2; 93 | } 94 | """ 95 | 96 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 97 | return """vec4 %s%s = generateCircle2Func(%s.xy, %s.xy, %s.xy, %s, %s, %s, vec4(%s, %s)); 98 | %s = %s%s.rgb; 99 | %s = %s%s.a;""" % [ 100 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], 101 | input_vars[4], input_vars[5], input_vars[6], input_vars[7], 102 | output_vars[0], output_vars[0], output_vars[1], 103 | output_vars[1], output_vars[0], output_vars[1]] 104 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateRect.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateRect 4 | 5 | func _get_name() -> String: 6 | return "RectCreate" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Rectangle creation" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "pos" 29 | 2: 30 | return "scale" 31 | 3: 32 | return "color" 33 | 4: 34 | return "alpha" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0)) 38 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0.0)) 39 | set_input_port_default_value(3, Vector3(1.0, 1.0, 1.0)) 40 | set_input_port_default_value(4, 1.0) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_VECTOR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_VECTOR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_output_port_count() -> int: 54 | return 2 55 | 56 | func _get_output_port_name(port: int): 57 | match port: 58 | 0: 59 | return "col" 60 | 1: 61 | return "alpha" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_VECTOR 67 | 1: 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 70 | func _get_global_code(mode: int) -> String: 71 | return """ 72 | float rectCreati0nFunc(vec2 _uv_rect_generate, vec2 _pos_rect_generate, vec2 _size_rect_generate){ 73 | vec2 sw_rect_gen = _pos_rect_generate - _size_rect_generate / 2.0; 74 | vec2 ne_rect_gen = _pos_rect_generate + _size_rect_generate / 2.0; 75 | vec2 _pct_temp_var = step(sw_rect_gen, _uv_rect_generate); 76 | _pct_temp_var -= step(ne_rect_gen, _uv_rect_generate); 77 | return _pct_temp_var.x * _pct_temp_var.y; 78 | } 79 | """ 80 | 81 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 82 | return """%s = %s; 83 | %s = rectCreati0nFunc(%s.xy, %s.xy, %s.xy) * %s;""" % [ 84 | output_vars[0],input_vars[3], 85 | output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[4]] 86 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateRegularNgon.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateRegularPolygon 4 | 5 | func _get_name() -> String: 6 | return "RegularPolygon" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Regular N-gon with 3+ sides" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 8 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "pos" 29 | 2: 30 | return "sides" 31 | 3: 32 | return "size" 33 | 4: 34 | return "angle" 35 | 5: 36 | return "smooth" 37 | 6: 38 | return "color" 39 | 7: 40 | return "alpha" 41 | 42 | func _get_input_port_type(port: int): 43 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0)) 44 | set_input_port_default_value(2, 3) 45 | set_input_port_default_value(3, Vector3(1.0, 1.0, 0.0)) 46 | set_input_port_default_value(4, 0.0) 47 | set_input_port_default_value(5, 0.0) 48 | set_input_port_default_value(6, Vector3(1.0, 1.0, 1.0)) 49 | set_input_port_default_value(7, 1.0) 50 | match port: 51 | 0: 52 | return VisualShaderNode.PORT_TYPE_VECTOR 53 | 1: 54 | return VisualShaderNode.PORT_TYPE_VECTOR 55 | 2: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 3: 58 | return VisualShaderNode.PORT_TYPE_VECTOR 59 | 4: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 5: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 6: 64 | return VisualShaderNode.PORT_TYPE_VECTOR 65 | 7: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 68 | func _get_output_port_count() -> int: 69 | return 2 70 | 71 | func _get_output_port_name(port: int): 72 | match port: 73 | 0: 74 | return "col" 75 | 1: 76 | return "alpha" 77 | 78 | func _get_output_port_type(port: int): 79 | match port: 80 | 0: 81 | return VisualShaderNode.PORT_TYPE_VECTOR 82 | 1: 83 | return VisualShaderNode.PORT_TYPE_SCALAR 84 | 85 | func _get_global_code(mode: int) -> String: 86 | return """ 87 | float p0lyg0nFunc(vec2 _uv_p0lyg0n, vec2 _pos_p0lyg0n, vec2 _size_p0lyg0n, float _sides_p0lyg0n, float _angle_p0lyg0n, float _smooth_p0lyg0n){ 88 | _uv_p0lyg0n = (_uv_p0lyg0n - _pos_p0lyg0n) / (_size_p0lyg0n * 2.0); 89 | float a_p0lyg0n = atan(_uv_p0lyg0n.x, _uv_p0lyg0n.y) + _angle_p0lyg0n; 90 | float r_p0lyg0n = 6.28318530718 / float(int(max(_sides_p0lyg0n, 3.0))); 91 | float d_p0lyg0n = cos(floor(0.5 + a_p0lyg0n / r_p0lyg0n) * r_p0lyg0n - a_p0lyg0n) * length(_uv_p0lyg0n); 92 | return (max(sign(_smooth_p0lyg0n - 0.0), 0.0) * ( 1.0 - smoothstep(0.1 - 0.0001, 0.1 + _smooth_p0lyg0n, d_p0lyg0n) ) + 93 | (max(sign(-_smooth_p0lyg0n + 0.0), 0.0)) * ( 1.0 - smoothstep(0.1 + _smooth_p0lyg0n - 0.0001, 0.1, d_p0lyg0n) ) + 94 | (1.0 - abs(sign(_smooth_p0lyg0n - 0.0))) * ( 1.0 - step(0.1, d_p0lyg0n)) ); 95 | } 96 | """ 97 | 98 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 99 | return """%s = %s; 100 | %s = p0lyg0nFunc(%s.xy, %s.xy, %s.xy, %s, %s, %s) * %s;""" % [ 101 | output_vars[0], input_vars[6], 102 | output_vars[1], input_vars[0], input_vars[1], input_vars[3], input_vars[2], input_vars[4], input_vars[5], input_vars[7]] 103 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/generateSpiral.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateSpiral 4 | 5 | func _get_name() -> String: 6 | return "SpiralCreate" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Spiral creation with adjusted position, size, linesAmount, softness, speed and color" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 9 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "pivot" 29 | 2: 30 | return "size" 31 | 3: 32 | return "linesAmount" 33 | 4: 34 | return "softness" 35 | 5: 36 | return "speed" 37 | 6: 38 | return "time" 39 | 7: 40 | return "color" 41 | 8: 42 | return "alpha" 43 | 44 | func _get_input_port_type(port: int): 45 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0)) 46 | set_input_port_default_value(2, 70.0) 47 | set_input_port_default_value(3, 1.0) 48 | set_input_port_default_value(4, 1.0) 49 | set_input_port_default_value(5, 0.0) 50 | set_input_port_default_value(6, 0.0) 51 | set_input_port_default_value(7, Vector3(1.0, 1.0, 1.0)) 52 | set_input_port_default_value(8, 1.0) 53 | match port: 54 | 0: 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 1: 57 | return VisualShaderNode.PORT_TYPE_VECTOR 58 | 2: 59 | return VisualShaderNode.PORT_TYPE_VECTOR 60 | 3: 61 | return VisualShaderNode.PORT_TYPE_SCALAR 62 | 4: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 5: 65 | return VisualShaderNode.PORT_TYPE_SCALAR 66 | 6: 67 | return VisualShaderNode.PORT_TYPE_SCALAR 68 | 7: 69 | return VisualShaderNode.PORT_TYPE_VECTOR 70 | 8: 71 | return VisualShaderNode.PORT_TYPE_SCALAR 72 | 73 | func _get_output_port_count() -> int: 74 | return 2 75 | 76 | func _get_output_port_name(port: int): 77 | match port: 78 | 0: 79 | return "col" 80 | 1: 81 | return "alpha" 82 | 83 | func _get_output_port_type(port: int): 84 | match port: 85 | 0: 86 | return VisualShaderNode.PORT_TYPE_VECTOR 87 | 1: 88 | return VisualShaderNode.PORT_TYPE_SCALAR 89 | 90 | func _get_global_code(mode: int) -> String: 91 | return """ 92 | vec4 generateSp1ralFunc(vec2 _uv_genSp1r, vec2 _p1v0t_genSp1r, float _s1ze_genSp1r, float _l1neAmnt_genSp1r, 93 | float _spd_genSp1r, float _s0ft_genSp1r, float _t1me_genSp1r, vec4 _c0l_genSp1r){ 94 | _uv_genSp1r -= _p1v0t_genSp1r; 95 | float _va1ue_genSp1r = 1.0 - sin(length(_uv_genSp1r) * _s1ze_genSp1r + 96 | floor(_l1neAmnt_genSp1r) * atan(_uv_genSp1r.x, _uv_genSp1r.y) + 97 | _t1me_genSp1r * _spd_genSp1r ) / _s0ft_genSp1r; 98 | return _c0l_genSp1r * _va1ue_genSp1r; 99 | } 100 | """ 101 | 102 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 103 | return """vec4 %s%s = generateSp1ralFunc(%s.xy, %s.xy, %s, %s, %s, %s, %s, vec4(%s, %s)); 104 | %s = %s%s.rgb; 105 | %s = %s%s.a;""" % [ 106 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[5], 107 | input_vars[4], input_vars[6], input_vars[7], input_vars[8], 108 | output_vars[0], output_vars[0], output_vars[1], 109 | output_vars[1], output_vars[0], output_vars[1]] 110 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/scanLinesSharp.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAscanLinesSharp 4 | 5 | func _get_name() -> String: 6 | return "ScanLinesSharp" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Sharp moving scanlines" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 7 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "amount" 29 | 2: 30 | return "fill" 31 | 3: 32 | return "speed" 33 | 4: 34 | return "time" 35 | 5: 36 | return "color" 37 | 6: 38 | return "alpha" 39 | 40 | func _get_input_port_type(port: int): 41 | set_input_port_default_value(1, 21) 42 | set_input_port_default_value(2, 0.5) 43 | set_input_port_default_value(3, 1) 44 | set_input_port_default_value(4, 0) 45 | set_input_port_default_value(5, Vector3(0.0, 0.0, 0.0)) 46 | set_input_port_default_value(6, 1) 47 | match port: 48 | 0: 49 | return VisualShaderNode.PORT_TYPE_VECTOR 50 | 1: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 2: 53 | return VisualShaderNode.PORT_TYPE_SCALAR 54 | 3: 55 | return VisualShaderNode.PORT_TYPE_SCALAR 56 | 4: 57 | return VisualShaderNode.PORT_TYPE_SCALAR 58 | 5: 59 | return VisualShaderNode.PORT_TYPE_VECTOR 60 | 6: 61 | return VisualShaderNode.PORT_TYPE_SCALAR 62 | 63 | func _get_output_port_count() -> int: 64 | return 2 65 | 66 | func _get_output_port_name(port: int): 67 | match port: 68 | 0: 69 | return "col" 70 | 1: 71 | return "alpha" 72 | 73 | func _get_output_port_type(port: int): 74 | match port: 75 | 0: 76 | return VisualShaderNode.PORT_TYPE_VECTOR 77 | 1: 78 | return VisualShaderNode.PORT_TYPE_SCALAR 79 | 80 | func _get_global_code(mode: int) -> String: 81 | return """ 82 | float scanL1nesSharpFunc(vec2 _uv_scL1Shrp, float _am0nt_scL1Shrp, float _f1ll_scL1Shrp, float _spd_scL1Shrp, float _t1me_scL1Shrp) { 83 | return step(fract(_uv_scL1Shrp.y * _am0nt_scL1Shrp + _t1me_scL1Shrp * _spd_scL1Shrp), _f1ll_scL1Shrp); 84 | } 85 | """ 86 | 87 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 88 | return """%s = %s; 89 | %s = scanL1nesSharpFunc(%s.xy, %s, %s, %s, %s) * %s;""" % [ 90 | output_vars[0], input_vars[5], 91 | output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], input_vars[6]] 92 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/generate_shapes/stripesRandom.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAcreateStripesRandom 4 | 5 | func _get_name() -> String: 6 | return "RandomStripes" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Random horizontal lines creation" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "fill" 29 | 2: 30 | return "amount" 31 | 3: 32 | return "color" 33 | 4: 34 | return "alpha" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, 0.5) 38 | set_input_port_default_value(2, 20.0) 39 | set_input_port_default_value(3, Vector3(1.0, 1.0, 1.0)) 40 | set_input_port_default_value(4, 1) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_SCALAR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_VECTOR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_output_port_count() -> int: 54 | return 2 55 | 56 | func _get_output_port_name(port: int): 57 | match port: 58 | 0: 59 | return "col" 60 | 1: 61 | return "alpha" 62 | 63 | func _get_output_port_type(port: int): 64 | match port: 65 | 0: 66 | return VisualShaderNode.PORT_TYPE_VECTOR 67 | 1: 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 70 | func _get_global_code(mode: int) -> String: 71 | return """ 72 | float generateRand0mStripesFunc(vec2 _uv_stripes, float _fill_stripes, float _amount_stripes){ 73 | _fill_stripes = min(max(_fill_stripes, 0.0), 1.0); 74 | return 1.0 - step(_fill_stripes, fract(sin(dot(floor(vec2(_uv_stripes.y) * _amount_stripes), vec2(12.9898, 78.233))) * 43758.5453123)); 75 | } 76 | """ 77 | 78 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 79 | return """%s = %s; 80 | %s = generateRand0mStripesFunc(%s.xy, %s, %s) * %s;""" % [output_vars[0], input_vars[3], 81 | output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[4]] 82 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/gradient4corners.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAgradient4corners 4 | 5 | func _get_name() -> String: 6 | return "Gradient4Corners" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Generates gradient based on corners colors" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 9 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "colorTopLeft" 29 | 2: 30 | return "alphaTopLeft" 31 | 3: 32 | return "colorTopRight" 33 | 4: 34 | return "alphaTopRight" 35 | 5: 36 | return "colorBottomLeft" 37 | 6: 38 | return "alphaBottomLeft" 39 | 7: 40 | return "colorBottomRight" 41 | 8: 42 | return "alphaBottomRight" 43 | 44 | func _get_input_port_type(port: int): 45 | set_input_port_default_value(1, Vector3(1.0, 1.0, 1.0)) 46 | set_input_port_default_value(2, 1.0) 47 | set_input_port_default_value(3, Vector3(1.0, 1.0, 1.0)) 48 | set_input_port_default_value(4, 1.0) 49 | set_input_port_default_value(5, Vector3(1.0, 1.0, 1.0)) 50 | set_input_port_default_value(6, 1.0) 51 | set_input_port_default_value(7, Vector3(1.0, 1.0, 1.0)) 52 | set_input_port_default_value(8, 1.0) 53 | match port: 54 | 0: 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 1: 57 | return VisualShaderNode.PORT_TYPE_VECTOR 58 | 2: 59 | return VisualShaderNode.PORT_TYPE_SCALAR 60 | 3: 61 | return VisualShaderNode.PORT_TYPE_VECTOR 62 | 4: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 5: 65 | return VisualShaderNode.PORT_TYPE_VECTOR 66 | 6: 67 | return VisualShaderNode.PORT_TYPE_SCALAR 68 | 7: 69 | return VisualShaderNode.PORT_TYPE_VECTOR 70 | 8: 71 | return VisualShaderNode.PORT_TYPE_SCALAR 72 | 73 | func _get_output_port_count() -> int: 74 | return 2 75 | 76 | func _get_output_port_name(port: int): 77 | match port: 78 | 0: 79 | return "col" 80 | 1: 81 | return "alpha" 82 | 83 | func _get_output_port_type(port: int): 84 | match port: 85 | 0: 86 | return VisualShaderNode.PORT_TYPE_VECTOR 87 | 1: 88 | return VisualShaderNode.PORT_TYPE_SCALAR 89 | 90 | func _get_global_code(mode: int) -> String: 91 | return """ 92 | vec4 gradient4cornersFunc(vec2 _uv_c0rner, vec4 _top_left_c0rner, vec4 _top_right_c0rner, vec4 _bottom_left_c0rner, vec4 _bottom_right_c0rner){ 93 | vec4 _c0l0r_t0p_c0rner = mix(_top_left_c0rner, _top_right_c0rner, _uv_c0rner.x); 94 | vec4 _c0l0r_b0tt0m_c0rner = mix(_bottom_left_c0rner, _bottom_right_c0rner, _uv_c0rner.x); 95 | return mix(_c0l0r_t0p_c0rner, _c0l0r_b0tt0m_c0rner, _uv_c0rner.y); 96 | } 97 | """ 98 | 99 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 100 | return """vec4 %s%s = gradient4cornersFunc(%s.xy, vec4(%s, %s), vec4(%s, %s), vec4(%s, %s), vec4(%s, %s)); 101 | %s = %s%s.rgb; 102 | %s = %s%s.a;""" % [ 103 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], 104 | input_vars[4], input_vars[5], input_vars[6], input_vars[7], input_vars[8], 105 | output_vars[0], output_vars[0], output_vars[1], 106 | output_vars[1], output_vars[0], output_vars[1]] 107 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/gradientMapping.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAgradientMapping 4 | 5 | func _get_name() -> String: 6 | return "GradientMapping" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Remaps colors based on average color value using [gradientMap] gradient" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "gradientMap" 29 | 30 | func _get_input_port_type(port: int): 31 | match port: 32 | 0: 33 | return VisualShaderNode.PORT_TYPE_VECTOR 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: int) -> int: 44 | return VisualShaderNode.PORT_TYPE_VECTOR 45 | 46 | func _get_global_code(mode: int) -> String: 47 | return """ 48 | vec3 gradientMappingFunc(vec3 _c0l_base_gm, sampler2D _palette_gm){ 49 | float avg_c0l = 0.2126 * _c0l_base_gm.r + 0.7152 * _c0l_base_gm.g + 0.0722 * _c0l_base_gm.b; 50 | return texture(_palette_gm, vec2(avg_c0l, 0)).rgb; 51 | } 52 | """ 53 | 54 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 55 | return "%s = gradientMappingFunc(%s, %s);" % [ 56 | output_vars[0], input_vars[0], input_vars[1]] 57 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/grayscale.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAgrayscale 4 | 5 | func _get_name() -> String: 6 | return "GrayscalePlus" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Improved grayscale with gray factor" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "factor" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, 1.0) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 1: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "col" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec3 grayscaleFunc(vec3 _c0l0r_grayscale, float _gray_fact0r){ 50 | _gray_fact0r = min(max(_gray_fact0r, 0.0), 1.0); 51 | return _c0l0r_grayscale * (1.0 - _gray_fact0r) + (0.21 * _c0l0r_grayscale.r + 0.71 * _c0l0r_grayscale.g + 0.07 * _c0l0r_grayscale.b) * _gray_fact0r; 52 | } 53 | """ 54 | 55 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 56 | return "%s = grayscaleFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 57 | -------------------------------------------------------------------------------- /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() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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: int) -> int: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 42 | func _get_global_code(mode: int) -> String: 43 | return """ 44 | vec3 hueFunc(float _1np_hue){ 45 | return min(max(3.0 * abs(1.0 - 2.0 * fract(_1np_hue + vec3(0.0, -1.0 / 3.0, 1.0 / 3.0))) - 1.0 , 0.0), 1.0); 46 | } 47 | """ 48 | 49 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 50 | return "%s = hueFunc(%s);" % [output_vars[0], input_vars[0]] 51 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/innerGlow.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAinnerGlow 4 | 5 | func _get_name() -> String: 6 | return "InnerGlow" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | #func _get_description() -> String: 15 | # return "" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 7 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "sampler2D" 27 | 1: 28 | return "uv" 29 | 2: 30 | return "lod" 31 | 3: 32 | return "size" 33 | 4: 34 | return "intensity" 35 | 5: 36 | return "color" 37 | 6: 38 | return "alpha" 39 | 40 | func _get_input_port_type(port: int): 41 | set_input_port_default_value(2, -1.0) 42 | set_input_port_default_value(3, 1.0) 43 | set_input_port_default_value(4, 1.0) 44 | set_input_port_default_value(5, Vector3(1.0, 1.0, 1.0)) 45 | set_input_port_default_value(6, 1.0) 46 | match port: 47 | 0: 48 | return VisualShaderNode.PORT_TYPE_SAMPLER 49 | 1: 50 | return VisualShaderNode.PORT_TYPE_VECTOR 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_VECTOR 59 | 6: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 62 | func _get_output_port_count() -> int: 63 | return 2 64 | 65 | func _get_output_port_name(port: int): 66 | match port: 67 | 0: 68 | return "col" 69 | 1: 70 | return "alpha" 71 | 72 | func _get_output_port_type(port: int): 73 | match port: 74 | 0: 75 | return VisualShaderNode.PORT_TYPE_VECTOR 76 | 1: 77 | return VisualShaderNode.PORT_TYPE_SCALAR 78 | 79 | func _get_global_code(mode: int) -> String: 80 | return """ 81 | vec4 innerGl0wFunc(sampler2D _samp_1ngl0w, vec2 _uv_1ngl0w, float _l0d_1ngl0w, float _rad_1ngl0w, float _1ntns_1ngl0w, vec4 _c0l_1ngl0w){ 82 | _rad_1ngl0w = abs(_rad_1ngl0w); 83 | 84 | vec4 _c01r_1ngl0w = vec4(0.0); 85 | float _a1pha_1nv = 0.0; 86 | float _a1pha_1ngl0w_b1 = 0.0; 87 | int _am0nt_1ngl0w = 3; 88 | 89 | if (_l0d_1ngl0w < 0.0) 90 | _c01r_1ngl0w = texture(_samp_1ngl0w, _uv_1ngl0w); 91 | else 92 | _c01r_1ngl0w = textureLod(_samp_1ngl0w, _uv_1ngl0w, _l0d_1ngl0w); 93 | 94 | _am0nt_1ngl0w = int(min(_rad_1ngl0w + 7.0, 14.0)); 95 | for(int x = - _am0nt_1ngl0w; x <= _am0nt_1ngl0w; x++) { 96 | for(int y = - _am0nt_1ngl0w; y <= _am0nt_1ngl0w; y++) { 97 | vec2 _c00rd_b1r_cst = _uv_1ngl0w + vec2(float(x), float(y)) * _rad_1ngl0w * 0.01; 98 | _a1pha_1ngl0w_b1 += textureLod(_samp_1ngl0w, _c00rd_b1r_cst, 0.0).a; 99 | } 100 | } 101 | int _nmb_ne1ghb0urs_b1r_cst = (_am0nt_1ngl0w * 2 + 1) * (_am0nt_1ngl0w * 2 + 1); 102 | _a1pha_1ngl0w_b1 /= float(_nmb_ne1ghb0urs_b1r_cst); 103 | 104 | _a1pha_1nv = 1.0 - _a1pha_1ngl0w_b1; // inversion 105 | _a1pha_1nv *= _c01r_1ngl0w.a; // masking 106 | 107 | if (_a1pha_1nv > 0.0) 108 | _a1pha_1nv *= (_1ntns_1ngl0w + 1.0); 109 | 110 | return mix(_c01r_1ngl0w, _c0l_1ngl0w, _a1pha_1nv * _c0l_1ngl0w.a); 111 | } 112 | """ 113 | 114 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 115 | return """vec4 %s%s = innerGl0wFunc(%s, %s.xy, %s, %s, %s, vec4(%s, %s)); 116 | %s = %s%s.rgb; 117 | %s = %s%s.a;""" % [ 118 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4], input_vars[5], input_vars[6], 119 | output_vars[0], output_vars[0], output_vars[1], 120 | output_vars[1], output_vars[0], output_vars[1]] 121 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/inverseColor.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAinverseColor 4 | 5 | func _get_name() -> String: 6 | return "InverseColor" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Inverse color basing on intensity" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "color" 27 | 1: 28 | return "alpha" 29 | 2: 30 | return "intensity" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(2, 1.0) 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_SCALAR 39 | 2: 40 | return VisualShaderNode.PORT_TYPE_SCALAR 41 | 42 | func _get_output_port_count() -> int: 43 | return 2 44 | 45 | func _get_output_port_name(port: int): 46 | match port: 47 | 0: 48 | return "col" 49 | 1: 50 | return "alpha" 51 | 52 | func _get_output_port_type(port: int): 53 | match port: 54 | 0: 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 1: 57 | return VisualShaderNode.PORT_TYPE_SCALAR 58 | 59 | func _get_global_code(mode: int) -> String: 60 | return """ 61 | vec3 inverseC0l0rFunc(vec3 _c0l0r_to_inverse, float _inverse_c0l0r_intensity){ 62 | return mix(_c0l0r_to_inverse.rgb, 1.0 - _c0l0r_to_inverse.rgb, _inverse_c0l0r_intensity); 63 | } 64 | """ 65 | 66 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 67 | return """%s = inverseC0l0rFunc(%s, %s); 68 | %s = %s;""" % [output_vars[0], input_vars[0],input_vars[2], 69 | output_vars[1], input_vars[1]] 70 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/maskAlpha.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAmaskAlpha 4 | 5 | func _get_name() -> String: 6 | return "MaskAlpha" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Color masking based on mask alpha" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "color" 27 | 1: 28 | return "alpha" 29 | 2: 30 | return "maskAlpha" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 1) 34 | set_input_port_default_value(2, 1) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 43 | func _get_output_port_count() -> int: 44 | return 2 45 | 46 | func _get_output_port_name(port: int): 47 | match port: 48 | 0: 49 | return "col" 50 | 1: 51 | return "alpha" 52 | 53 | func _get_output_port_type(port: int): 54 | match port: 55 | 0: 56 | return VisualShaderNode.PORT_TYPE_VECTOR 57 | 1: 58 | return VisualShaderNode.PORT_TYPE_SCALAR 59 | 60 | func _get_global_code(mode: int) -> String: 61 | return """ 62 | vec4 maskAlphaFunc(vec4 _col_to_mask_with_alpha, float _mask_alpha_to_mask_using_alpha){ 63 | return _col_to_mask_with_alpha * _mask_alpha_to_mask_using_alpha; 64 | } 65 | """ 66 | 67 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 68 | return """%s = maskAlphaFunc(vec4(%s, %s), %s).rgb; 69 | %s = maskAlphaFunc(vec4(%s, %s), %s).a;""" % [ 70 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], 71 | output_vars[1], input_vars[0], input_vars[1], input_vars[2]] 72 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/generic2d.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseGeneric2d 4 | 5 | func _get_name() -> String: 6 | return "GenericNoise2D" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | func _get_subcategory() -> String: 12 | return "Noise" 13 | 14 | func _get_description() -> String: 15 | return "GenericNoise using hash random function" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "scale" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, Vector3(0, 0, 0)) 34 | set_input_port_default_value(2, 5) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_VECTOR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "result" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 52 | func _get_global_code(mode: int) -> String: 53 | return """ 54 | float hash2_gener1c2D(vec2 _p_hash2_gener1c) { 55 | return (fract(1e4 * sin(17.0 * _p_hash2_gener1c.x + _p_hash2_gener1c.y * 0.1) * 56 | (0.1 + abs(sin(_p_hash2_gener1c.y * 13.0 + _p_hash2_gener1c.x))))); 57 | } 58 | 59 | float genericNoise2D(vec2 _x_gener1c2D) { 60 | vec2 _temp_i_gener1c2D = floor(_x_gener1c2D); 61 | vec2 _temp_f_gener1c2D = fract(_x_gener1c2D); 62 | 63 | float _a_g1n2 = hash2_gener1c2D(_temp_i_gener1c2D); 64 | float _b_g1n2 = hash2_gener1c2D(_temp_i_gener1c2D + vec2(1.0, 0.0)); 65 | float _c_g1n2 = hash2_gener1c2D(_temp_i_gener1c2D + vec2(0.0, 1.0)); 66 | float _d_g1n2 = hash2_gener1c2D(_temp_i_gener1c2D + vec2(1.0, 1.0)); 67 | 68 | vec2 _u_g1n2 = _temp_f_gener1c2D * _temp_f_gener1c2D * (3.0 - 2.0 * _temp_f_gener1c2D); 69 | return (mix(_a_g1n2, _b_g1n2, _u_g1n2.x) + (_c_g1n2 - _a_g1n2) * 70 | _u_g1n2.y * (1.0 - _u_g1n2.x) + (_d_g1n2 - _b_g1n2) * _u_g1n2.x * _u_g1n2.y); 71 | } 72 | """ 73 | 74 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 75 | return "%s = genericNoise2D((%s.xy + %s.xy) * %s);" % [ 76 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 77 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/perlin2d.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoisePerlin2d 4 | 5 | func _get_name() -> String: 6 | return "Perlin2D" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | func _get_subcategory() -> String: 12 | return "Noise" 13 | 14 | func _get_description() -> String: 15 | return """Classic 2d perlin noise with ability to set period. 16 | If you dont want any peroid - set it to zero""" 17 | 18 | func _get_return_icon_type() -> int: 19 | return VisualShaderNode.PORT_TYPE_VECTOR 20 | 21 | func _get_input_port_count() -> int: 22 | return 4 23 | 24 | func _get_input_port_name(port: int): 25 | match port: 26 | 0: 27 | return "uv" 28 | 1: 29 | return "offset" 30 | 2: 31 | return "scale" 32 | 3: 33 | return "period" 34 | 35 | func _get_input_port_type(port: int): 36 | set_input_port_default_value(1, Vector3(0, 0, 0)) 37 | set_input_port_default_value(2, 5) 38 | set_input_port_default_value(3, Vector3(0.0, 0.0, 0.0)) 39 | match port: 40 | 0: 41 | return VisualShaderNode.PORT_TYPE_VECTOR 42 | 1: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 2: 45 | return VisualShaderNode.PORT_TYPE_SCALAR 46 | 3: 47 | return VisualShaderNode.PORT_TYPE_VECTOR 48 | 49 | func _get_output_port_count() -> int: 50 | return 1 51 | 52 | func _get_output_port_name(port: int): 53 | match port: 54 | 0: 55 | return "result" 56 | 57 | func _get_output_port_type(port: int): 58 | match port: 59 | 0: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 62 | func _get_global_code(mode: int) -> String: 63 | return """ 64 | float perlin2dN0iseFunc(vec2 P, vec2 _per10d_perl2) { 65 | vec4 Pi = floor(vec4(P, P)) + vec4(0.0, 0.0, 1.0, 1.0); 66 | vec4 Pf = fract(vec4(P, P)) - vec4(0.0, 0.0, 1.0, 1.0); 67 | 68 | if (_per10d_perl2.x != 0.0 && _per10d_perl2.y != 0.0) 69 | Pi = mod(Pi, vec4(_per10d_perl2, _per10d_perl2)); 70 | 71 | Pi = Pi - floor(Pi * (1.0 / 289.0)) * 289.0; 72 | vec4 ix = Pi.xzxz; 73 | vec4 iy = Pi.yyww; 74 | vec4 fx = Pf.xzxz; 75 | vec4 fy = Pf.yyww; 76 | 77 | 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)* 78 | ((((ix*34.0)+1.0)*ix)-floor((((ix*34.0)+1.0)*ix)*(1.0/289.0))*289.0 + iy))- 79 | 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)* 80 | ((((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; 81 | 82 | vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ; 83 | vec4 gy = abs(gx) - 0.5 ; 84 | vec4 tx = floor(gx + 0.5); 85 | gx = gx - tx; 86 | 87 | vec2 g00 = vec2(gx.x,gy.x); 88 | vec2 g10 = vec2(gx.y,gy.y); 89 | vec2 g01 = vec2(gx.z,gy.z); 90 | vec2 g11 = vec2(gx.w,gy.w); 91 | 92 | vec4 norm = 1.79284291400159 - 0.85373472095314 * vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)); 93 | g00 *= norm.x; 94 | g01 *= norm.y; 95 | g10 *= norm.z; 96 | g11 *= norm.w; 97 | 98 | float n00 = dot(g00, vec2(fx.x, fy.x)); 99 | float n10 = dot(g10, vec2(fx.y, fy.y)); 100 | float n01 = dot(g01, vec2(fx.z, fy.z)); 101 | float n11 = dot(g11, vec2(fx.w, fy.w)); 102 | 103 | vec2 fade_xy = Pf.xy * Pf.xy * Pf.xy * (Pf.xy * (Pf.xy * 6.0 - 15.0) + 10.0); 104 | vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x); 105 | float n_xy = mix(n_x.x, n_x.y, fade_xy.y); 106 | return 2.3 * n_xy; 107 | } 108 | """ 109 | 110 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 111 | return "%s = perlin2dN0iseFunc((%s.xy+%s.xy)*%s, %s.xy);" % [ 112 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 113 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/simplex2d.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseSimplex2d 4 | 5 | func _get_name() -> String: 6 | return "Simplex2D" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | func _get_subcategory() -> String: 12 | return "Noise" 13 | 14 | func _get_description() -> String: 15 | return "2d simplex noise" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "scale" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, Vector3(0, 0, 0)) 34 | set_input_port_default_value(2, 5) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_VECTOR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int): 47 | match port: 48 | 0: 49 | return "result" 50 | 51 | func _get_output_port_type(port: int): 52 | match port: 53 | 0: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 56 | func _get_global_code(mode: int) -> String: 57 | return """ 58 | vec3 _permute_simplex2_n0ise(vec3 x) { 59 | return ((x*34.0)+1.0)*x-floor(((x*34.0)+1.0)*x*(1.0/289.0))*289.0; 60 | } 61 | 62 | float simplex2dN0iseFunc(vec2 v) { 63 | vec4 C = vec4(0.211324865405187, 64 | 0.366025403784439, 65 | -0.577350269189626, 66 | 0.024390243902439); 67 | 68 | vec2 i = floor(v + dot(v, C.yy) ); 69 | vec2 x0 = v - i + dot(i, C.xx); 70 | 71 | vec2 i1; 72 | i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); 73 | vec4 x12 = vec4(x0.xy, x0.xy) + C.xxzz; 74 | x12.xy -= i1; 75 | 76 | i = i - floor(i * (1.0 / 289.0)) * 289.0; 77 | vec3 p = _permute_simplex2_n0ise(_permute_simplex2_n0ise(i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0)); 78 | 79 | vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), vec3(0.0)); 80 | m = m * m; 81 | m = m * m; 82 | 83 | vec3 x = 2.0 * fract(p * C.www) - 1.0; 84 | vec3 h = abs(x) - 0.5; 85 | vec3 ox = floor(x + 0.5); 86 | vec3 a0 = x - ox; 87 | 88 | m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h); 89 | 90 | vec3 g; 91 | g.x = a0.x * x0.x + h.x * x0.y; 92 | g.yz = a0.yz * x12.xz + h.yz * x12.yw; 93 | return 130.0 * dot(m, g); 94 | } 95 | """ 96 | 97 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 98 | return "%s = simplex2dN0iseFunc((%s.xy+%s.xy)*%s);" % [ 99 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 100 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2d.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley2d 4 | 5 | func _get_name() -> String: 6 | return "Worley2D" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | func _get_subcategory() -> String: 12 | return "Noise" 13 | 14 | func _get_description() -> String: 15 | return "2d worley noise" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 4 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "scale" 31 | 3: 32 | return "jitter" 33 | 34 | func _get_input_port_type(port: int): 35 | set_input_port_default_value(1, Vector3(0, 0, 0)) 36 | set_input_port_default_value(2, 5) 37 | set_input_port_default_value(3, 1) 38 | match port: 39 | 0: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 1: 42 | return VisualShaderNode.PORT_TYPE_VECTOR 43 | 2: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 3: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 48 | func _get_output_port_count() -> int: 49 | return 2 50 | 51 | func _get_output_port_name(port: int): 52 | match port: 53 | 0: 54 | return "F1" 55 | 1: 56 | return "F2" 57 | 58 | func _get_output_port_type(port: int): 59 | match port: 60 | 0: 61 | return VisualShaderNode.PORT_TYPE_SCALAR 62 | 1: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 65 | func _get_global_code(mode: int) -> String: 66 | return """ 67 | vec2 cellular2dNoiseFunc(vec2 P, float _jitter_w2d) { 68 | float K = 0.142857142857; // 1/7 69 | float Ko = 0.428571428571; // 3/7 70 | 71 | vec2 Pi = floor(P) - floor(floor(P) * (1.0 / 289.0)) * 289.0; 72 | vec2 Pf = fract(P); 73 | vec3 oi = vec3(-1.0, 0.0, 1.0); 74 | vec3 of = vec3(-0.5, 0.5, 1.5); 75 | 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; 76 | 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; 77 | vec3 ox = fract(p*K) - Ko; 78 | vec3 oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 79 | vec3 dx = Pf.x + 0.5 + _jitter_w2d*ox; 80 | vec3 dy = Pf.y - of + _jitter_w2d*oy; 81 | vec3 d1 = dx * dx + dy * dy; 82 | 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; 83 | ox = fract(p*K) - Ko; 84 | oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 85 | dx = Pf.x - 0.5 + _jitter_w2d*ox; 86 | dy = Pf.y - of + _jitter_w2d*oy; 87 | vec3 d2 = dx * dx + dy * dy; 88 | 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; 89 | ox = fract(p*K) - Ko; 90 | oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0) * K - Ko; 91 | dx = Pf.x - 1.5 + _jitter_w2d*ox; 92 | dy = Pf.y - of + _jitter_w2d*oy; 93 | vec3 d3 = dx * dx + dy * dy; 94 | vec3 d1a = min(d1, d2); 95 | d2 = max(d1, d2); 96 | d2 = min(d2, d3); 97 | d1 = min(d1a, d2); 98 | d2 = max(d1a, d2); 99 | d1.xy = (d1.x < d1.y) ? d1.xy : d1.yx; 100 | d1.xz = (d1.x < d1.z) ? d1.xz : d1.zx; 101 | d1.yz = min(d1.yz, d2.yz); 102 | d1.y = min(d1.y, d1.z); 103 | d1.y = min(d1.y, d2.x); 104 | return sqrt(d1.xy); 105 | } 106 | """ 107 | 108 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 109 | return """vec2 %s%s = cellular2dNoiseFunc((%s.xy+%s.xy)*%s, min(max(%s, 0.0), 1.0)); 110 | %s = %s%s.x; 111 | %s = %s%s.y;""" % [ 112 | output_vars[0], output_vars[1], input_vars[0], input_vars[1], input_vars[2], input_vars[3], 113 | output_vars[0], output_vars[0], output_vars[1], 114 | output_vars[1], output_vars[0], output_vars[1]] 115 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2x2.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley2x2 4 | 5 | func _get_name() -> String: 6 | return "Worley2x2" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | func _get_subcategory() -> String: 12 | return "Noise" 13 | 14 | func _get_description() -> String: 15 | return "2x2 worley noise" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 4 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "scale" 31 | 3: 32 | return "jitter" 33 | 34 | func _get_input_port_type(port: int): 35 | set_input_port_default_value(1, Vector3(0, 0, 0)) 36 | set_input_port_default_value(2, 5) 37 | set_input_port_default_value(3, 1) 38 | match port: 39 | 0: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 1: 42 | return VisualShaderNode.PORT_TYPE_VECTOR 43 | 2: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 3: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 48 | func _get_output_port_count() -> int: 49 | return 1 50 | 51 | func _get_output_port_name(port: int) -> String: 52 | return "F1" 53 | 54 | func _get_output_port_type(port: int) -> int: 55 | return VisualShaderNode.PORT_TYPE_SCALAR 56 | 57 | func _get_global_code(mode: int) -> String: 58 | return """ 59 | float cellular2x2NoiseFunc(vec2 P, float _jitter_w2x2) { 60 | float K = 0.142857142857; // 1/7 61 | float K2 = 0.0714285714285; // K/2 62 | 63 | vec2 Pi = floor(P) - floor(floor(P) * (1.0 / 289.0)) * 289.0; 64 | vec2 Pf = fract(P); 65 | vec4 Pfx = Pf.x + vec4(-0.5, -1.5, -0.5, -1.5); 66 | vec4 Pfy = Pf.y + vec4(-0.5, -0.5, -1.5, -1.5); 67 | 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; 68 | 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; 69 | vec4 ox = (p - floor(p * (1.0 / 7.0)) * 7.0)*K+K2; 70 | vec4 oy = (floor(p*K) - floor(floor(p*K) * (1.0 / 7.0)) * 7.0)*K+K2; 71 | vec4 dx = Pfx + _jitter_w2x2*ox; 72 | vec4 dy = Pfy + _jitter_w2x2*oy; 73 | vec4 d = dx * dx + dy * dy; 74 | d.xy = min(d.xy, d.zw); 75 | d.x = min(d.x, d.y); 76 | return sqrt(d.x); 77 | } 78 | """ 79 | 80 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 81 | return "%s = cellular2x2NoiseFunc((%s.xy+%s.xy)*%s, min(max(%s, 0.0), 1.0));" % [ 82 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 83 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/noise/worley2x2x2.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeNoiseWorley2x2x2 4 | 5 | func _get_name() -> String: 6 | return "Worley2x2x2" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | func _get_subcategory() -> String: 12 | return "Noise" 13 | 14 | func _get_description() -> String: 15 | return "2x2x2 worley noise" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "scale" 31 | 3: 32 | return "jitter" 33 | 4: 34 | return "time" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, Vector3(0, 0, 0)) 38 | set_input_port_default_value(2, 5) 39 | set_input_port_default_value(3, 1) 40 | set_input_port_default_value(4, 0) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_output_port_count() -> int: 54 | return 1 55 | 56 | func _get_output_port_name(port: int) -> String: 57 | return "F1" 58 | 59 | func _get_output_port_type(port: int) -> int: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 62 | func _get_global_code(mode: int) -> String: 63 | return """ 64 | float cellular2x2x2NoiseFunc(vec3 P, float _jitter_w2x2x2) { 65 | float K = 0.142857142857; 66 | float Ko = 0.428571428571; 67 | float K2 = 0.020408163265306; 68 | float Kz = 0.166666666667; 69 | float Kzo = 0.416666666667; 70 | 71 | vec3 Pi = floor(P)- floor(floor(P) * (1.0 / 289.0)) * 289.0; 72 | vec3 Pf = fract(P); 73 | vec4 Pfx = Pf.x + vec4(0.0, -1.0, 0.0, -1.0); 74 | vec4 Pfy = Pf.y + vec4(0.0, 0.0, -1.0, -1.0); 75 | 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; 76 | 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; 77 | 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; 78 | 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; 79 | vec4 ox1 = fract(p1*K) - Ko; 80 | vec4 oy1 = (floor(p1*K) - floor(floor(p1*K) * (1.0 / 7.0)) * 7.0)*K - Ko; 81 | vec4 oz1 = floor(p1*K2)*Kz - Kzo; 82 | vec4 ox2 = fract(p2*K) - Ko; 83 | vec4 oy2 = (floor(p2*K) - floor(floor(p2*K) * (1.0 / 7.0)) * 7.0)*K - Ko; 84 | vec4 oz2 = floor(p2*K2)*Kz - Kzo; 85 | vec4 dx1 = Pfx + _jitter_w2x2x2*ox1; 86 | vec4 dy1 = Pfy + _jitter_w2x2x2*oy1; 87 | vec4 dz1 = Pf.z + _jitter_w2x2x2*oz1; 88 | vec4 dx2 = Pfx + _jitter_w2x2x2*ox2; 89 | vec4 dy2 = Pfy + _jitter_w2x2x2*oy2; 90 | vec4 dz2 = Pf.z - 1.0 + _jitter_w2x2x2*oz2; 91 | vec4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; 92 | vec4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; 93 | d1 = min(d1, d2); 94 | d1.xy = min(d1.xy, d1.wz); 95 | d1.x = min(d1.x, d1.y); 96 | return sqrt(d1.x); 97 | } 98 | """ 99 | 100 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 101 | return "%s = cellular2x2x2NoiseFunc(vec3((%s.xy + %s.xy) * %s, %s), min(max(%s, 0.0), 1.0));" % [ 102 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[4], input_vars[3]] 103 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/posterize.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAposterize 4 | 5 | func _get_name() -> String: 6 | return "Posterize" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Rounds values based on the value coming through [steps]" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "steps" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, 8.0) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 1: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "col" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec3 p0ster1zeFunc(vec3 _col_p0sr1ze, float _steps_p0sterize){ 50 | return floor(_col_p0sr1ze * _steps_p0sterize) / (_steps_p0sterize - 1.0); 51 | } 52 | """ 53 | 54 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 55 | return "%s = p0ster1zeFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 56 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/shiftHSV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAshiftHSV 4 | 5 | func _get_name() -> String: 6 | return "ShiftHSV" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return """Changes hue, saturation and value of input color. 16 | Input values recommendations: 17 | [hue]: min=0.0, max=1.0; 18 | [saturation]: min=0.0; 19 | [value]: min=0.0; 20 | """ 21 | 22 | func _get_return_icon_type() -> int: 23 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "hue" 34 | 2: 35 | return "sat" 36 | 3: 37 | return "value" 38 | 39 | func _get_input_port_type(port: int): 40 | set_input_port_default_value(1, 1.0) 41 | set_input_port_default_value(2, 1.0) 42 | set_input_port_default_value(3, 1.0) 43 | match port: 44 | 0: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 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 | 53 | func _get_output_port_count() -> int: 54 | return 1 55 | 56 | func _get_output_port_name(port: int) -> String: 57 | return "col" 58 | 59 | func _get_output_port_type(port: int) -> int: 60 | return VisualShaderNode.PORT_TYPE_VECTOR 61 | 62 | func _get_global_code(mode: int) -> String: 63 | return """ 64 | vec3 hsv2rgbHSVChan9eFunc(vec3 _hsv_c0l0r_HSVChan9e){ 65 | vec4 _K_hsv2rgbHSVChan9e = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 66 | vec3 _p_hsv2rgbHSVChan9e = abs(fract(_hsv_c0l0r_HSVChan9e.xxx + _K_hsv2rgbHSVChan9e.xyz) * 6.0 - _K_hsv2rgbHSVChan9e.www); 67 | return vec3(_hsv_c0l0r_HSVChan9e.z * mix(_K_hsv2rgbHSVChan9e.xxx, 68 | clamp(_p_hsv2rgbHSVChan9e - _K_hsv2rgbHSVChan9e.xxx, 0.0, 1.0), 69 | _hsv_c0l0r_HSVChan9e.y)); 70 | } 71 | 72 | vec3 rgb2hvsHSVChan9eFunc(vec3 _rgb_c0l0r_HSVChan9e){ 73 | vec4 _K_rgb2hvsHSVChan9e = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); 74 | vec4 _p_rgb2hvsHSVChan9e = mix( vec4(_rgb_c0l0r_HSVChan9e.bg, _K_rgb2hvsHSVChan9e.wz), 75 | vec4(_rgb_c0l0r_HSVChan9e.gb, _K_rgb2hvsHSVChan9e.xy), 76 | step(_rgb_c0l0r_HSVChan9e.b, _rgb_c0l0r_HSVChan9e.g)); 77 | vec4 _q_rgb2hvsHSVChan9e = mix( vec4(_p_rgb2hvsHSVChan9e.xyw, _rgb_c0l0r_HSVChan9e.r), 78 | vec4(_rgb_c0l0r_HSVChan9e.r, _p_rgb2hvsHSVChan9e.yzx), 79 | step(_p_rgb2hvsHSVChan9e.x, _rgb_c0l0r_HSVChan9e.r)); 80 | float _d_rgb2hvsHSVChan9e = _q_rgb2hvsHSVChan9e.x - min(_q_rgb2hvsHSVChan9e.w, _q_rgb2hvsHSVChan9e.y); 81 | return vec3(vec3(abs(_q_rgb2hvsHSVChan9e.z + (_q_rgb2hvsHSVChan9e.w - _q_rgb2hvsHSVChan9e.y) / (6.0 * _d_rgb2hvsHSVChan9e + 1.0e-10)), 82 | _d_rgb2hvsHSVChan9e / (_q_rgb2hvsHSVChan9e.x + 1.0e-10), 83 | _q_rgb2hvsHSVChan9e.x)); 84 | } 85 | 86 | vec3 hsvChangeHSVChan9eFunc(vec3 _c0l0r_HSVChan9e, float _h_HSVChan9e, float _s_HSVChan9e, float _v_HSVChan9e){ 87 | _c0l0r_HSVChan9e = rgb2hvsHSVChan9eFunc(_c0l0r_HSVChan9e); 88 | _c0l0r_HSVChan9e.r *= _h_HSVChan9e; 89 | _c0l0r_HSVChan9e.g *= _s_HSVChan9e; 90 | _c0l0r_HSVChan9e.b *= _v_HSVChan9e; 91 | return hsv2rgbHSVChan9eFunc(_c0l0r_HSVChan9e); 92 | } 93 | """ 94 | 95 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 96 | return "%s = hsvChangeHSVChan9eFunc(%s, %s, %s, %s);" % [ 97 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 98 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/shineFX.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAshineFX 4 | 5 | func _get_name() -> String: 6 | return "ShineFX" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Adds shine effect in form of line" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 10 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "color" 29 | 2: 30 | return "alpha" 31 | 3: 32 | return "location" 33 | 4: 34 | return "angle(radians)" 35 | 5: 36 | return "width" 37 | 6: 38 | return "soft" 39 | 7: 40 | return "bright" 41 | 8: 42 | return "gloss" 43 | 9: 44 | return "shineColor" 45 | 46 | func _get_input_port_type(port: int): 47 | set_input_port_default_value(3, 0.0) 48 | set_input_port_default_value(4, 0.0) 49 | set_input_port_default_value(5, 0.0) 50 | set_input_port_default_value(6, 0.0) 51 | set_input_port_default_value(7, 0.0) 52 | set_input_port_default_value(8, 0.0) 53 | set_input_port_default_value(9, Vector3(1.0, 1.0, 1.0)) 54 | match port: 55 | 0: 56 | return VisualShaderNode.PORT_TYPE_VECTOR 57 | 1: 58 | return VisualShaderNode.PORT_TYPE_VECTOR 59 | 2: 60 | return VisualShaderNode.PORT_TYPE_SCALAR 61 | 3: 62 | return VisualShaderNode.PORT_TYPE_SCALAR 63 | 4: 64 | return VisualShaderNode.PORT_TYPE_SCALAR 65 | 5: 66 | return VisualShaderNode.PORT_TYPE_SCALAR 67 | 6: 68 | return VisualShaderNode.PORT_TYPE_SCALAR 69 | 7: 70 | return VisualShaderNode.PORT_TYPE_SCALAR 71 | 8: 72 | return VisualShaderNode.PORT_TYPE_SCALAR 73 | 9: 74 | return VisualShaderNode.PORT_TYPE_VECTOR 75 | 76 | func _get_output_port_count() -> int: 77 | return 2 78 | 79 | func _get_output_port_name(port: int): 80 | match port: 81 | 0: 82 | return "col" 83 | 1: 84 | return "alpha" 85 | 86 | func _get_output_port_type(port: int): 87 | match port: 88 | 0: 89 | return VisualShaderNode.PORT_TYPE_VECTOR 90 | 1: 91 | return VisualShaderNode.PORT_TYPE_SCALAR 92 | 93 | func _get_global_code(mode: int) -> String: 94 | return """ 95 | vec4 shineFunc(vec4 _color_sh1ne, vec2 _uv_sh1ne, float _loc_sh1ne, float _rot_sh1ne, float _width_sh1ne, float _soft_sh1ne, float _bright_sh1ne, float _gloss_sh1ne, vec3 _shine_color_sh1ne){ 96 | vec2 _angle_sh1ne = vec2(cos(_rot_sh1ne), sin(_rot_sh1ne)); 97 | float _norm_pos_sh1ne = dot(_uv_sh1ne, _angle_sh1ne); 98 | float _normal_sh1ne = 1.0 - min(max(abs((_norm_pos_sh1ne - _loc_sh1ne) / _width_sh1ne), 0.0), 1.0); 99 | float _shine_power_sh1ne = smoothstep(0.0, _soft_sh1ne * 2.0, _normal_sh1ne); 100 | vec3 _reflect_color_sh1ne = mix(vec3(1.0), _color_sh1ne.rgb * 10.0, _gloss_sh1ne); 101 | _color_sh1ne.rgb += _color_sh1ne.a * _shine_power_sh1ne * _bright_sh1ne * _reflect_color_sh1ne * _shine_color_sh1ne.rgb; 102 | return min(max(_color_sh1ne, vec4(0.0)), vec4(1.0)); 103 | } 104 | """ 105 | 106 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 107 | return """%s = %s; 108 | %s = shineFunc(vec4(%s, %s), %s.xy, %s, %s, %s, %s, %s, %s, %s).rgb;""" % [ 109 | output_vars[1], input_vars[2], 110 | output_vars[0], input_vars[1], input_vars[2], input_vars[0], input_vars[3], input_vars[4], 111 | input_vars[5], input_vars[6], input_vars[7], input_vars[8], input_vars[9]] 112 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/tintRGBA.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAtintRGBA 4 | 5 | func _get_name() -> String: 6 | return "TintRGBA" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Tints RGBA with tint color (same as modulate property in editor)" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 4 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "col" 27 | 1: 28 | return "alpha" 29 | 2: 30 | return "colorTint" 31 | 3: 32 | return "alphaTint" 33 | 34 | func _get_input_port_type(port: int): 35 | set_input_port_default_value(1, 1.0) 36 | set_input_port_default_value(2, Vector3(1.0, 1.0, 0.0)) 37 | set_input_port_default_value(3, 1) 38 | match port: 39 | 0: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 1: 42 | return VisualShaderNode.PORT_TYPE_SCALAR 43 | 2: 44 | return VisualShaderNode.PORT_TYPE_VECTOR 45 | 3: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 48 | func _get_output_port_count() -> int: 49 | return 2 50 | 51 | func _get_output_port_name(port: int): 52 | match port: 53 | 0: 54 | return "col" 55 | 1: 56 | return "alpha" 57 | 58 | func _get_output_port_type(port: int): 59 | match port: 60 | 0: 61 | return VisualShaderNode.PORT_TYPE_VECTOR 62 | 1: 63 | return VisualShaderNode.PORT_TYPE_SCALAR 64 | 65 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 66 | return """%s = %s * %s; 67 | %s = %s * %s;""" % [output_vars[0], input_vars[0], input_vars[2], 68 | output_vars[1], input_vars[1], input_vars[3]] 69 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/tonemap.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAtonemap 4 | 5 | func _get_name() -> String: 6 | return "Tonemap" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | #func _get_description() -> String: 15 | # return "" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "color" 27 | 1: 28 | return "exposure" 29 | 2: 30 | return "gamma" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 0.0) 34 | set_input_port_default_value(2, 1.0) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "col" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_VECTOR 51 | 52 | func _get_global_code(mode: int) -> String: 53 | return """ 54 | vec3 t0nemapFunc(vec3 _c0l0r_t0nemap, float _exposure_t0nemap, float _gamma_t0nemap){ 55 | _c0l0r_t0nemap.rgb *= pow(2.0, _exposure_t0nemap); 56 | _c0l0r_t0nemap.rgb = pow(_c0l0r_t0nemap.rgb, vec3(_gamma_t0nemap)); 57 | return _c0l0r_t0nemap; 58 | } 59 | """ 60 | 61 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 62 | return "%s = t0nemapFunc(%s, %s, %s);" % [ 63 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 64 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/turnCGA4Palette.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAturnCGA4Palette 4 | 5 | func _get_name() -> String: 6 | return "TurnCGA4Palette" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Swaps color to CGA 4-color palette" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "threshold" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, 1.5) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "col" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec3 cg4Pa1etteFunc(vec3 _c0l_cga, float _g4mm4_cga){ 50 | _c0l_cga = pow(_c0l_cga, vec3(_g4mm4_cga)); 51 | float _gr4y_c0l_cga4 = 0.21 * _c0l_cga.r + 0.71 * _c0l_cga.g + 0.07 * _c0l_cga.b; 52 | vec3 _re5_c0l_cga4 = vec3(0.0); 53 | 54 | vec3 _CGAPa1[4] = vec3[4] ( vec3(0.0, 0.0, 0.0), 55 | vec3(1.0, 0.33, 1.0), 56 | vec3(0.33, 1.0, 1.0), 57 | vec3(1.0, 1.0, 1.0)); 58 | 59 | if (_gr4y_c0l_cga4 <= 1.0/4.0) 60 | _re5_c0l_cga4 = _CGAPa1[0]; 61 | else if (_gr4y_c0l_cga4 <= 2.0/4.0) 62 | _re5_c0l_cga4 = _CGAPa1[1]; 63 | else if (_gr4y_c0l_cga4 <= 3.0/4.0) 64 | _re5_c0l_cga4 = _CGAPa1[2]; 65 | else if (_gr4y_c0l_cga4 <= 4.0/4.0) 66 | _re5_c0l_cga4 = _CGAPa1[3]; 67 | 68 | return _re5_c0l_cga4; 69 | } 70 | """ 71 | 72 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 73 | return "%s = cg4Pa1etteFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 74 | -------------------------------------------------------------------------------- /addons/shaderV/rgba/turnGBPalette.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeRGBAturnGameBoyPalette 4 | 5 | func _get_name() -> String: 6 | return "TurnGameBoyPalette" 7 | 8 | func _get_category() -> String: 9 | return "RGBA" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Swaps color to GameBoy palette" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "threshold" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, 1.5) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "col" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec3 g4meb0yPa1etteFunc(vec3 _c0l_g4b0, float _g4mm4_g4b0){ 50 | _c0l_g4b0 = pow(_c0l_g4b0, vec3(_g4mm4_g4b0)); 51 | float _gr4y_c0l_g4b0 = 0.21 * _c0l_g4b0.r + 0.71 * _c0l_g4b0.g + 0.07 * _c0l_g4b0.b; 52 | vec3 _re5_c0l_g4b0 = vec3(0.0); 53 | 54 | vec3 _Gameb0yPa1[4] = vec3[4] ( vec3(0.612, 0.725, 0.086), 55 | vec3(0.549, 0.667, 0.078), 56 | vec3(0.188, 0.392, 0.188), 57 | vec3(0.063, 0.247, 0.063)); 58 | 59 | if (_gr4y_c0l_g4b0 <= 1.0/4.0) 60 | _re5_c0l_g4b0 = _Gameb0yPa1[3]; 61 | else if (_gr4y_c0l_g4b0 <= 2.0/4.0) 62 | _re5_c0l_g4b0 = _Gameb0yPa1[2]; 63 | else if (_gr4y_c0l_g4b0 <= 3.0/4.0) 64 | _re5_c0l_g4b0 = _Gameb0yPa1[1]; 65 | else if (_gr4y_c0l_g4b0 <= 4.0/4.0) 66 | _re5_c0l_g4b0 = _Gameb0yPa1[0]; 67 | 68 | return _re5_c0l_g4b0; 69 | } 70 | """ 71 | 72 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 73 | return "%s = g4meb0yPa1etteFunc(%s, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 74 | -------------------------------------------------------------------------------- /addons/shaderV/tools/hash1d.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsHash 4 | 5 | func _get_name() -> String: 6 | return "Hash1d" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Hash func with scalar input and scalar output" 16 | 17 | func _get_return_icon_type() -> int: 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: int) -> int: 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: int) -> int: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_code(input_vars : Array, output_vars: Array, mode: int, type: int) -> String: 39 | return output_vars[0] + " = fract(sin(" + input_vars[0] + ") * 1e4);" 40 | 41 | -------------------------------------------------------------------------------- /addons/shaderV/tools/hash2d.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsHash2D 4 | 5 | func _get_name() -> String: 6 | return "Hash2d" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Hash func with vector input and scalar output" 16 | 17 | func _get_return_icon_type() -> int: 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: int) -> int: 27 | return VisualShaderNode.PORT_TYPE_VECTOR 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) -> int: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 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/tools/hash2dvector.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsHash2Dvec 4 | 5 | func _get_name() -> String: 6 | return "Hash2dVec" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Hash func with vector input and vector output" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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: int) -> int: 27 | return VisualShaderNode.PORT_TYPE_VECTOR 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) -> int: 36 | return VisualShaderNode.PORT_TYPE_VECTOR 37 | 38 | func _get_global_code(mode: int) -> String: 39 | return """ 40 | vec2 hash2v(vec2 co) { 41 | float _tmp_h = dot(co, vec2(12.9898, 78.233)); 42 | return fract(vec2(sin(_tmp_h), cos(_tmp_h)) * 43758.5453) * 2.0 - 1.0; 43 | } 44 | """ 45 | 46 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 47 | return "%s.xy = hash2v(%s.xy);" % [output_vars[0], input_vars[0]] 48 | 49 | 50 | 51 | 52 | -------------------------------------------------------------------------------- /addons/shaderV/tools/randomFloat.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloat 4 | 5 | func _get_name() -> String: 6 | return "RandomFloat" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Returns random float based on UV" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 0 22 | 23 | func _get_output_port_count() -> int: 24 | return 1 25 | 26 | func _get_output_port_name(port: int) -> String: 27 | return "random" 28 | 29 | func _get_output_port_type(port: int) -> int: 30 | return VisualShaderNode.PORT_TYPE_SCALAR 31 | 32 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 33 | return output_vars[0] + " = fract(sin(dot(UV, vec2(12.9898, 78.233))) * 43758.5453123);" 34 | -------------------------------------------------------------------------------- /addons/shaderV/tools/randomFloatInput.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloatInput 4 | 5 | func _get_name() -> String: 6 | return "RandomFloatInput" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Returns random float based on input value" 16 | 17 | func _get_return_icon_type() -> int: 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: int) -> int: 27 | set_input_port_default_value(0, Vector3(0, 0, 0)) 28 | return VisualShaderNode.PORT_TYPE_VECTOR 29 | 30 | func _get_output_port_count() -> int: 31 | return 1 32 | 33 | func _get_output_port_name(port: int) -> String: 34 | return "rand" 35 | 36 | func _get_output_port_type(port: int) -> int: 37 | return VisualShaderNode.PORT_TYPE_SCALAR 38 | 39 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 40 | return output_vars[0] + " = fract(sin(dot(%s.xy, vec2(12.9898, 78.233))) * 43758.5453123);" % input_vars[0] 41 | -------------------------------------------------------------------------------- /addons/shaderV/tools/randomFloat_I.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloat_I 4 | 5 | func _get_name() -> String: 6 | return "RandomFloat_I" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Improved version of classic random function. Classic random can produce artifacts. This one - doesn't." 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "scale" 29 | 2: 30 | return "offset" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 1.0) 34 | set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0)) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_VECTOR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "rnd" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_SCALAR 51 | 52 | func _get_global_code(mode: int) -> String: 53 | return """ 54 | highp float randImpr0vedFunc(vec2 _c0_rnd){ 55 | highp float _tmp_a_rnd = 12.9898; 56 | highp float _tmp_b_rnd = 78.233; 57 | highp float _tmp_c_rnd = 43758.5453; 58 | highp float _tmp_dt_rnd = dot(_c0_rnd, vec2(_tmp_a_rnd, _tmp_b_rnd)); 59 | highp float _tmp_sn_rnd = mod(_tmp_dt_rnd, 3.14); 60 | return fract(sin(_tmp_sn_rnd) * _tmp_c_rnd); 61 | } 62 | """ 63 | 64 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 65 | return "%s = randImpr0vedFunc(%s.xy * %s + %s.xy);" % [ 66 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 67 | -------------------------------------------------------------------------------- /addons/shaderV/tools/randomGoldNoiseFloat.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRandomFloatGoldenRation 4 | 5 | func _get_name(): 6 | return "RandomGoldRatio" 7 | 8 | func _get_category(): 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description(): 15 | return "Random float based on golden ratio" 16 | 17 | func _get_return_icon_type(): 18 | return VisualShaderNode.PORT_TYPE_SCALAR 19 | 20 | func _get_input_port_count(): 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "seed" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(0, Vector3(0, 0, 0)) 34 | set_input_port_default_value(1, Vector3(0, 0, 0)) 35 | set_input_port_default_value(2, 0.0) 36 | match port: 37 | 0: 38 | return VisualShaderNode.PORT_TYPE_VECTOR 39 | 1: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 2: 42 | return VisualShaderNode.PORT_TYPE_SCALAR 43 | 44 | func _get_output_port_count(): 45 | return 1 46 | 47 | func _get_output_port_name(port): 48 | return "rand" 49 | 50 | func _get_output_port_type(port): 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_code(input_vars, output_vars, mode, type): 54 | return """float PHI_goldenRati0 = 1.61803398874989484820459 * 00000.1; // Golden Ratio 55 | float PI_goldenRati0 = 3.14159265358979323846264 * 00000.1; // PI 56 | float SQ2_goldenRati0 = 1.41421356237309504880169 * 10000.0; // Square Root of Two 57 | %s = fract(tan(distance((%s.xy+%s.xy)*(%s+PHI_goldenRati0), vec2(PHI_goldenRati0, PI_goldenRati0)))*SQ2_goldenRati0);""" %[ 58 | output_vars[0], input_vars[0], input_vars[1], input_vars[2]] 59 | -------------------------------------------------------------------------------- /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() -> int: 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: int) -> int: 29 | return VisualShaderNode.PORT_TYPE_VECTOR 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: int) -> int: 38 | return VisualShaderNode.PORT_TYPE_VECTOR 39 | 40 | func _get_code(input_vars : Array, output_vars: Array, mode: int, type: int) -> String: 41 | return output_vars[0] + " = " + input_vars[0] 42 | 43 | -------------------------------------------------------------------------------- /addons/shaderV/tools/remap.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsRemap 4 | 5 | func _get_name() -> String: 6 | return "Remap" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Remaps input value from ( [inMin], [inMax] ) range to ( [outMin], [outMax] )" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "input" 27 | 1: 28 | return "inMin" 29 | 2: 30 | return "inMin" 31 | 3: 32 | return "outMin" 33 | 4: 34 | return "outMax" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, 0.0) 38 | set_input_port_default_value(2, 1.0) 39 | set_input_port_default_value(3, -1.0) 40 | set_input_port_default_value(4, 1.0) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_SCALAR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | 54 | func _get_output_port_count() -> int: 55 | return 1 56 | 57 | func _get_output_port_name(port ) -> String: 58 | return "out" 59 | 60 | func _get_output_port_type(port) -> int: 61 | return VisualShaderNode.PORT_TYPE_VECTOR 62 | 63 | func _get_global_code(mode: int) -> String: 64 | return """ 65 | vec3 remapFunc(vec3 _inpt_r4p, vec2 _fr0m_r4p, vec2 _t0_r4p){ 66 | return _t0_r4p.x + ((_inpt_r4p - _fr0m_r4p.x) * (_t0_r4p.y - _t0_r4p.x)) / (_fr0m_r4p.y - _fr0m_r4p.x); 67 | } 68 | """ 69 | 70 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 71 | return output_vars[0] + " = remapFunc(%s, vec2(%s, %s), vec2(%s, %s));" % [ 72 | input_vars[0], input_vars[1], input_vars[2], input_vars[3], input_vars[4]] 73 | 74 | 75 | 76 | 77 | -------------------------------------------------------------------------------- /addons/shaderV/tools/sinTime.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderToolsSinTIME 4 | 5 | func _get_name() -> String: 6 | return "SinTIME" 7 | 8 | func _get_category() -> String: 9 | return "Tools" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Returns sin([spd] * TIME)" 16 | 17 | func _get_return_icon_type() -> int: 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 "spd" 25 | 26 | func _get_input_port_type(port: int) -> int: 27 | set_input_port_default_value(0, 1.0) 28 | return VisualShaderNode.PORT_TYPE_SCALAR 29 | 30 | func _get_output_port_count() -> int: 31 | return 1 32 | 33 | func _get_output_port_name(port: int) -> String: 34 | return "out" 35 | 36 | func _get_output_port_type(port: int) -> int: 37 | return VisualShaderNode.PORT_TYPE_SCALAR 38 | 39 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 40 | return output_vars[0] + " = sin(%s * TIME);" % input_vars[0] 41 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/distortionUVAnimated.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVdistortionAnimated 4 | 5 | func _get_name() -> String: 6 | return "DistortionUVAnimated" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | func _get_subcategory() -> String: 12 | return "Animated" 13 | 14 | func _get_description() -> String: 15 | return "Animated wave-like UV distortion" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 6 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "waveX" 29 | 2: 30 | return "waveY" 31 | 3: 32 | return "distortX" 33 | 4: 34 | return "distortY" 35 | 5: 36 | return "speed" 37 | 38 | func _get_input_port_type(port: int): 39 | set_input_port_default_value(1, 0) 40 | set_input_port_default_value(2, 0) 41 | set_input_port_default_value(3, 0) 42 | set_input_port_default_value(4, 0) 43 | set_input_port_default_value(5, 0) 44 | match port: 45 | 0: 46 | return VisualShaderNode.PORT_TYPE_VECTOR 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 | 4: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 5: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 58 | func _get_output_port_count() -> int: 59 | return 1 60 | 61 | func _get_output_port_name(port: int) -> String: 62 | return "uv" 63 | 64 | func _get_output_port_type(port: int) -> int: 65 | return VisualShaderNode.PORT_TYPE_VECTOR 66 | 67 | func _get_global_code(mode: int) -> String: 68 | return """ 69 | vec2 d1stort1onUVAnimatedFunc(vec2 _uv_d1st, float _d1stX_d1st, float _d1stY_d1st, float _waveX_d1st, float _waveY_d1st, float _spd_d1st, float _t1me_d1st){ 70 | _uv_d1st.x += sin(_uv_d1st.y * _waveX_d1st + _t1me_d1st * _spd_d1st) * _d1stX_d1st; 71 | _uv_d1st.y += sin(_uv_d1st.x * _waveY_d1st + _t1me_d1st * _spd_d1st) * _d1stY_d1st; 72 | return _uv_d1st; 73 | } 74 | """ 75 | 76 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 77 | return "%s.xy = d1stort1onUVAnimatedFunc(%s.xy, %s, %s, %s, %s, %s, TIME);" % [ 78 | output_vars[0], input_vars[0], input_vars[3], input_vars[4], input_vars[1], input_vars[2], input_vars[5]] 79 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/doodleUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVdoodle 4 | 5 | func _get_name() -> String: 6 | return "DoodleFX" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | func _get_subcategory() -> String: 12 | return "Animated" 13 | 14 | func _get_description() -> String: 15 | return "Doodle UV effect" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 6 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "frameTime" 29 | 2: 30 | return "frameCount" 31 | 3: 32 | return "scale" 33 | 4: 34 | return "maxOffset" 35 | 5: 36 | return "time" 37 | 38 | func _get_input_port_type(port: int): 39 | set_input_port_default_value(1, 0.5) 40 | set_input_port_default_value(2, 4.0) 41 | set_input_port_default_value(3, 0.7) 42 | set_input_port_default_value(4, 0.065) 43 | set_input_port_default_value(5, 0) 44 | match port: 45 | 0: 46 | return VisualShaderNode.PORT_TYPE_VECTOR 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 | 4: 54 | return VisualShaderNode.PORT_TYPE_SCALAR 55 | 5: 56 | return VisualShaderNode.PORT_TYPE_SCALAR 57 | 58 | func _get_output_port_count() -> int: 59 | return 1 60 | 61 | func _get_output_port_name(port: int) -> String: 62 | return "uv" 63 | 64 | func _get_output_port_type(port: int) -> int: 65 | return VisualShaderNode.PORT_TYPE_VECTOR 66 | 67 | func _get_global_code(mode: int) -> String: 68 | return """ 69 | float hash2D00dle(vec2 _p_hash_d00dle) { 70 | return fract(1e4 * sin(17.0 * _p_hash_d00dle.x + _p_hash_d00dle.y * 0.1) * (0.1 + abs(sin(_p_hash_d00dle.y * 13.0 + _p_hash_d00dle.x)))); 71 | } 72 | 73 | float noiseD00dle(vec2 _seed_noise_d00dle){ 74 | vec2 i = floor(_seed_noise_d00dle); 75 | vec2 f = fract(_seed_noise_d00dle); 76 | float _a = hash2D00dle(i); 77 | float _b = hash2D00dle(i + vec2(1.0, 0.0)); 78 | float _c = hash2D00dle(i + vec2(0.0, 1.0)); 79 | float _d = hash2D00dle(i + vec2(1.0, 1.0)); 80 | vec2 u = f * f * (3.0 - 2.0 * f); 81 | return mix(_a, _b, u.x) + (_c - _a) * u.y * (1.0 - u.x) + (_d - _b) * u.x * u.y; 82 | } 83 | 84 | vec2 d00dleUVFunc(vec2 _uv_d00dle, float _max_offset_d00dle, float _time_d00dle, float _frame_time_d00dle, int _frame_count_d00dle, float _scale_d00dle){ 85 | float timeValueD00dle = mod(floor(_time_d00dle / _frame_time_d00dle), float(_frame_count_d00dle)) + 1.0; 86 | return _uv_d00dle + vec2(noiseD00dle((_uv_d00dle + timeValueD00dle) * _scale_d00dle) * 2.0 - 1.0) * _max_offset_d00dle; 87 | } 88 | """ 89 | 90 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 91 | return "%s.xy = d00dleUVFunc(%s.xy, %s, %s, %s, int(%s), %s);" % [ 92 | output_vars[0], input_vars[0], input_vars[4], input_vars[5], input_vars[1], input_vars[2], input_vars[3]] 93 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/rotateAnimated.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVrotateAnimated 4 | 5 | func _get_name() -> String: 6 | return "RotateUVAnim" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | func _get_subcategory() -> String: 12 | return "Animated" 13 | 14 | func _get_description() -> String: 15 | return "Animated UV rotation by angle in radians relative to pivot point" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 4 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "angularSpeed" 29 | 2: 30 | return "pivot" 31 | 3: 32 | return "time" 33 | 34 | func _get_input_port_type(port: int): 35 | set_input_port_default_value(1, 0.5) 36 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 37 | match port: 38 | 0: 39 | return VisualShaderNode.PORT_TYPE_VECTOR 40 | 1: 41 | return VisualShaderNode.PORT_TYPE_SCALAR 42 | 2: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 3: 45 | return VisualShaderNode.PORT_TYPE_SCALAR 46 | 47 | 48 | func _get_output_port_count() -> int: 49 | return 1 50 | 51 | func _get_output_port_name(port: int) -> String: 52 | return "uv" 53 | 54 | func _get_output_port_type(port: int): 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 57 | func _get_global_code(mode: int) -> String: 58 | return """ 59 | vec2 r0tateUVAnimatedFunc(vec2 _uv_r0tate, vec2 _pivot_r0tate, float _r0tation_r0tate, float _r0tSpeed_r0tate, float _t1me_r0tate){ 60 | _r0tation_r0tate += _t1me_r0tate * _r0tSpeed_r0tate; 61 | //_r0tation_r0tate = radians(_r0tationDeg_r0tate); 62 | vec2 _r0tAngle = vec2(cos(_r0tation_r0tate), sin(_r0tation_r0tate)); 63 | _uv_r0tate -= _pivot_r0tate; 64 | _uv_r0tate = vec2((_uv_r0tate.x*_r0tAngle.x-_uv_r0tate.y*_r0tAngle.y),(_uv_r0tate.x*_r0tAngle.y+_uv_r0tate.y*_r0tAngle.x)); 65 | _uv_r0tate += _pivot_r0tate; 66 | return _uv_r0tate; 67 | } 68 | """ 69 | 70 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 71 | return output_vars[0] + " = vec3(r0tateUVAnimatedFunc(%s.xy, %s.xy, 0.0, %s, %s), 0);" % [ 72 | input_vars[0], input_vars[2], input_vars[1], input_vars[3]] 73 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/swirlUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVswirl 4 | 5 | func _get_name() -> String: 6 | return "SwirlUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | func _get_subcategory() -> String: 12 | return "Animated" 13 | 14 | func _get_description() -> String: 15 | return "Swirl UV effect" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 4 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "pivot" 29 | 2: 30 | return "strength" 31 | 3: 32 | return "time" 33 | 34 | func _get_input_port_type(port: int): 35 | set_input_port_default_value(1, Vector3(0.5, 0.5, 0.0)) 36 | set_input_port_default_value(2, 0.0) 37 | set_input_port_default_value(3, 0.0) 38 | match port: 39 | 0: 40 | return VisualShaderNode.PORT_TYPE_VECTOR 41 | 1: 42 | return VisualShaderNode.PORT_TYPE_SCALAR 43 | 2: 44 | return VisualShaderNode.PORT_TYPE_SCALAR 45 | 3: 46 | return VisualShaderNode.PORT_TYPE_SCALAR 47 | 48 | func _get_output_port_count() -> int: 49 | return 1 50 | 51 | func _get_output_port_name(port: int) -> String: 52 | return "uv" 53 | 54 | func _get_output_port_type(port: int) -> int: 55 | return VisualShaderNode.PORT_TYPE_VECTOR 56 | 57 | func _get_global_code(mode: int) -> String: 58 | return """ 59 | vec2 swirlUVFunc(vec2 _uv_sw1rl, float _t1me_sw1rl, vec2 _p1vot_sw1rl, float _amount_sw1rl){ 60 | float _rotation_index_sw1rl = _amount_sw1rl * length(_uv_sw1rl - _p1vot_sw1rl) * _t1me_sw1rl; 61 | _uv_sw1rl -= _p1vot_sw1rl; 62 | _uv_sw1rl *= mat2(vec2(cos(_rotation_index_sw1rl), - sin(_rotation_index_sw1rl)), 63 | vec2(sin(_rotation_index_sw1rl), cos(_rotation_index_sw1rl))); 64 | _uv_sw1rl += _p1vot_sw1rl; 65 | return _uv_sw1rl; 66 | } 67 | """ 68 | 69 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 70 | return "%s.xy = swirlUVFunc(%s.xy, %s, %s.xy, %s);" % [ 71 | output_vars[0], input_vars[0], input_vars[3], input_vars[1], input_vars[2]] 72 | -------------------------------------------------------------------------------- /addons/shaderV/uv/animated/tilingNoffsetAnimated.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtilingNoffsetAnimated 4 | 5 | func _get_name() -> String: 6 | return "TilingAndOffsetAnimated" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Animated UV tiling with given [offset] speed" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "offset" 29 | 2: 30 | return "time" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0)) 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR 37 | 1: 38 | return VisualShaderNode.PORT_TYPE_VECTOR 39 | 2: 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: int) -> int: 49 | return VisualShaderNode.PORT_TYPE_VECTOR 50 | 51 | func _get_global_code(mode: int) -> String: 52 | return """ 53 | vec2 tilingNoffsetAnimatedFunc(vec2 _uv_tN0A, float _t1me_tN0A, vec2 _offset_tN0A){ 54 | return vec2(mod((_uv_tN0A.x + _offset_tN0A.x * _t1me_tN0A), 1.0), mod((_uv_tN0A.y + _offset_tN0A.y * _t1me_tN0A), 1.0)); 55 | } 56 | """ 57 | 58 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 59 | return "%s.xy = %s.xy + tilingNoffsetAnimatedFunc(%s.xy, %s, %s.xy);" % [ 60 | output_vars[0], output_vars[0], input_vars[0], input_vars[2], input_vars[1]] 61 | -------------------------------------------------------------------------------- /addons/shaderV/uv/distortionUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVdistortion 4 | 5 | func _get_name() -> String: 6 | return "DistortionUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Wave-like UV distortion" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "waveX" 29 | 2: 30 | return "waveY" 31 | 3: 32 | return "distortX" 33 | 4: 34 | return "distortY" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, 0) 38 | set_input_port_default_value(2, 0) 39 | set_input_port_default_value(3, 0) 40 | set_input_port_default_value(4, 0) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_SCALAR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_SCALAR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_SCALAR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_SCALAR 52 | 53 | func _get_output_port_count() -> int: 54 | return 1 55 | 56 | func _get_output_port_name(port: int) -> String: 57 | return "uv" 58 | 59 | func _get_output_port_type(port: int) -> int: 60 | return VisualShaderNode.PORT_TYPE_VECTOR 61 | 62 | func _get_global_code(mode: int) -> String: 63 | return """ 64 | vec2 d1stort1onUVFunc(vec2 _uv_d1st, float _d1stX_d1st, float _d1stY_d1st, float _waveX_d1st, float _waveY_d1st){ 65 | _uv_d1st.x += sin(_uv_d1st.y * _waveX_d1st) * _d1stX_d1st; 66 | _uv_d1st.y += sin(_uv_d1st.x * _waveY_d1st) * _d1stY_d1st; 67 | return _uv_d1st; 68 | } 69 | """ 70 | 71 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 72 | return "%s.xy = d1stort1onUVFunc(%s.xy, %s, %s, %s, %s);" % [ 73 | output_vars[0], input_vars[0], input_vars[3], input_vars[4], input_vars[1], input_vars[2]] 74 | -------------------------------------------------------------------------------- /addons/shaderV/uv/flipUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVflip 4 | 5 | func _get_name() -> String: 6 | return "FlipUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Flip UV horizontal or vertical" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "vert" 29 | 2: 30 | return "hor" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, false) 34 | set_input_port_default_value(2, false) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_BOOLEAN 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_BOOLEAN 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "uv" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_VECTOR 51 | 52 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 53 | return output_vars[0] + " = vec3(mix(%s.x, 1.0 - %s.x, float(%s)), mix(%s.y, 1.0 - %s.y, float(%s)), 0);" % [ 54 | input_vars[0], input_vars[0], input_vars[1], input_vars[0], input_vars[0], input_vars[2]] 55 | -------------------------------------------------------------------------------- /addons/shaderV/uv/lensDistortion.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVlensDistortion 4 | 5 | func _get_name() -> String: 6 | return "LensDistortion" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return """Lens distortion effect. 16 | [factor] > 0 - fisheye / barrel; 17 | [factor] < 0 - antifisheye / pincushion""" 18 | 19 | func _get_return_icon_type() -> int: 20 | return VisualShaderNode.PORT_TYPE_VECTOR 21 | 22 | func _get_input_port_count() -> int: 23 | return 2 24 | 25 | func _get_input_port_name(port: int): 26 | match port: 27 | 0: 28 | return "uv" 29 | 1: 30 | return "factor" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 1.0) 34 | match port: 35 | 0: 36 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "uv" 45 | 46 | func _get_output_port_type(port: int) -> int: 47 | return VisualShaderNode.PORT_TYPE_VECTOR 48 | 49 | func _get_global_code(mode: int) -> String: 50 | return """ 51 | vec2 lensD1st0rti0nFunc(vec2 _uv_d1s_1en5, float _fctr_d1s_1en5){ 52 | vec2 _p0s_d1s_1en5 = _uv_d1s_1en5 - 0.5; 53 | float _d1st_d1s_1en5 = length(_p0s_d1s_1en5); 54 | if (_fctr_d1s_1en5 > 0.0) // fisheye / barrel 55 | _uv_d1s_1en5 = vec2(0.5)+normalize(_p0s_d1s_1en5)*tan(_d1st_d1s_1en5*_fctr_d1s_1en5)*0.70711/tan(0.70711*_fctr_d1s_1en5); 56 | else if (_fctr_d1s_1en5 < 0.0) // antifisheye / pincushion 57 | _uv_d1s_1en5 = vec2(0.5)+normalize(_p0s_d1s_1en5)*atan(_d1st_d1s_1en5*-_fctr_d1s_1en5*10.0)*0.5/atan(-_fctr_d1s_1en5*0.5*10.0); 58 | return _uv_d1s_1en5; 59 | } 60 | """ 61 | 62 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 63 | return "%s.xy = lensD1st0rti0nFunc(%s.xy, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 64 | -------------------------------------------------------------------------------- /addons/shaderV/uv/pixelate.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVpixelate 4 | 5 | func _get_name() -> String: 6 | return "PixelateUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Pixelate UV by effect factor" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "uv" 27 | 1: 28 | return "factor" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, 1.0) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 1: 36 | return VisualShaderNode.PORT_TYPE_SCALAR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "uv" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec2 pixelateFunc(vec2 _uv_p1xelate, float _effect_factor_p1xelate){ 50 | return round(_uv_p1xelate / max(_effect_factor_p1xelate * 0.01, 0.001)) * max(_effect_factor_p1xelate * 0.01, 0.001); 51 | } 52 | """ 53 | 54 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 55 | return "%s.xy = pixelateFunc(%s.xy, %s);" % [output_vars[0], input_vars[0], input_vars[1]] 56 | -------------------------------------------------------------------------------- /addons/shaderV/uv/rotate.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVrotate 4 | 5 | func _get_name() -> String: 6 | return "RotateUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Rotate UV by angle in radians relative to pivot vector" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "angle" 29 | 2: 30 | return "pivot" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 0.0) 34 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_VECTOR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "uv" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_VECTOR 51 | 52 | func _get_global_code(mode: int) -> String: 53 | return """ 54 | vec3 r0tateUVFunc(vec3 _uv_r0tate, vec2 _pivot_r0tate, float _r0tation_r0tate){ 55 | //_r0tation_r0tate = radians(_r0tationDeg_r0tate); 56 | vec2 _r0tAngle = vec2(cos(_r0tation_r0tate), sin(_r0tation_r0tate)); 57 | _uv_r0tate.xy -= _pivot_r0tate; 58 | _uv_r0tate.xy = vec2((_uv_r0tate.x*_r0tAngle.x-_uv_r0tate.y*_r0tAngle.y),(_uv_r0tate.x*_r0tAngle.y+_uv_r0tate.y*_r0tAngle.x)); 59 | _uv_r0tate.xy += _pivot_r0tate; 60 | return _uv_r0tate; 61 | } 62 | """ 63 | 64 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 65 | return output_vars[0] + " = r0tateUVFunc(%s, %s.xy, %s);" % [input_vars[0], input_vars[2], input_vars[1]] 66 | -------------------------------------------------------------------------------- /addons/shaderV/uv/sphericalUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVspherical 4 | 5 | func _get_name() -> String: 6 | return "SphericalUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory() -> String: 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Makes UV look like a sphere. Can be used to make 2d planets" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 5 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "radius" 29 | 2: 30 | return "spin" 31 | 3: 32 | return "position" 33 | 4: 34 | return "local position" 35 | 36 | func _get_input_port_type(port: int): 37 | set_input_port_default_value(1, Vector3(1.0, 1.0, 0.0)) 38 | set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0)) 39 | set_input_port_default_value(3, Vector3(0.5, 0.5, 0.0)) 40 | set_input_port_default_value(4, Vector3(0.0, 0.0, 0.0)) 41 | match port: 42 | 0: 43 | return VisualShaderNode.PORT_TYPE_VECTOR 44 | 1: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 2: 47 | return VisualShaderNode.PORT_TYPE_VECTOR 48 | 3: 49 | return VisualShaderNode.PORT_TYPE_VECTOR 50 | 4: 51 | return VisualShaderNode.PORT_TYPE_VECTOR 52 | 53 | func _get_output_port_count() -> int: 54 | return 1 55 | 56 | func _get_output_port_name(port: int) -> String: 57 | return "uv" 58 | 59 | func _get_output_port_type(port: int) -> int: 60 | return VisualShaderNode.PORT_TYPE_VECTOR 61 | 62 | func _get_global_code(mode: int) -> String: 63 | return """ 64 | vec2 sphericalFunc(vec2 _uv_shprc1, vec2 _p0s_shprc1, vec2 _rad_shprc1, vec2 _sp1n_shprc1, vec2 _l0c_p0s_shprc1){ 65 | vec2 _temp_p = (_uv_shprc1 - _p0s_shprc1) * 2.0; 66 | float _temp_rad = length((_temp_p - _l0c_p0s_shprc1) * _rad_shprc1) + 0.0001; 67 | float _temp_f = (1.0 - sqrt(1.0 - _temp_rad)) / _temp_rad; 68 | return mod(vec2((_temp_p.x * 0.5 * _temp_f + _sp1n_shprc1.x) + 0.5, 69 | (_temp_p.y * 0.5 * _temp_f + _sp1n_shprc1.y) + 0.5), vec2(1.0)); 70 | } 71 | """ 72 | 73 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 74 | return "%s.xy = sphericalFunc(%s.xy, %s.xy, %s.xy, %s.xy, %s.xy);" % [ 75 | output_vars[0], input_vars[0], input_vars[3], input_vars[1], input_vars[2], input_vars[4]] 76 | -------------------------------------------------------------------------------- /addons/shaderV/uv/tileUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtile 4 | 5 | func _get_name() -> String: 6 | return "TileUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory() -> String: 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return """Tile UV can be used to get UV position of tile within a tilemap. 16 | [uv] - uv of tileset; 17 | [Vframes] - the number of rows; 18 | [Hframes] - the number of columns; 19 | [frame] - current frame;""" 20 | 21 | func _get_return_icon_type() -> int: 22 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "Vframes" 33 | 2: 34 | return "Hframes" 35 | 3: 36 | return "frame" 37 | 38 | func _get_input_port_type(port: int): 39 | set_input_port_default_value(1, 2.0) 40 | set_input_port_default_value(2, 2.0) 41 | set_input_port_default_value(3, 0.0) 42 | match port: 43 | 0: 44 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "uv" 57 | 58 | func _get_output_port_type(port: int) -> int: 59 | return VisualShaderNode.PORT_TYPE_VECTOR 60 | 61 | func _get_global_code(mode: int) -> String: 62 | return """ 63 | vec2 t1leMapUV(vec2 _uv_t1le_t1mp, float _w1dth_t1mp, float _he1ght_t1mp, float _t1le_nmbr_t1mp){ 64 | _t1le_nmbr_t1mp = min(max(floor(_t1le_nmbr_t1mp), 0.0), _w1dth_t1mp * _he1ght_t1mp - 1.0); 65 | vec2 tcrcp = vec2(1.0) / vec2(_w1dth_t1mp, _he1ght_t1mp); 66 | float ty =floor(_t1le_nmbr_t1mp * tcrcp.x); 67 | float tx = _t1le_nmbr_t1mp - _w1dth_t1mp * ty; 68 | return (_uv_t1le_t1mp + vec2(tx, ty)) * tcrcp; 69 | } 70 | """ 71 | 72 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 73 | return "%s.xy = t1leMapUV(%s.xy, %s, %s, %s);" % [ 74 | output_vars[0], input_vars[0], input_vars[1], input_vars[2], input_vars[3]] 75 | -------------------------------------------------------------------------------- /addons/shaderV/uv/tilingNoffset.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtilingNoffset 4 | 5 | func _get_name() -> String: 6 | return "TilingAndOffset" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Tiles UV with given offset" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 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 "uv" 27 | 1: 28 | return "offset" 29 | 30 | func _get_input_port_type(port: int): 31 | set_input_port_default_value(1, Vector3(0.0, 0.0, 0.0)) 32 | match port: 33 | 0: 34 | return VisualShaderNode.PORT_TYPE_VECTOR 35 | 1: 36 | return VisualShaderNode.PORT_TYPE_VECTOR 37 | 38 | func _get_output_port_count() -> int: 39 | return 1 40 | 41 | func _get_output_port_name(port: int) -> String: 42 | return "uv" 43 | 44 | func _get_output_port_type(port: int) -> int: 45 | return VisualShaderNode.PORT_TYPE_VECTOR 46 | 47 | func _get_global_code(mode: int) -> String: 48 | return """ 49 | vec2 ti1ingN0ffsetFunc(vec2 _uv_tN0, vec2 _offset_tN0){ 50 | return vec2(mod(_uv_tN0.x + _offset_tN0.x, 1.0), mod(_uv_tN0.y + _offset_tN0.y, 1.0)); 51 | } 52 | """ 53 | 54 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 55 | return output_vars[0] + " = vec3(ti1ingN0ffsetFunc(%s.xy, %s.xy), 0);" % [input_vars[0], input_vars[1]] 56 | -------------------------------------------------------------------------------- /addons/shaderV/uv/twirl.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVtwirl 4 | 5 | func _get_name() -> String: 6 | return "TwirlUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Twirl UV by value relative to pivot point" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "value" 29 | 2: 30 | return "pivot" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 1.0) 34 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_VECTOR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "uv" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_VECTOR 51 | 52 | func _get_global_code(mode: int) -> String: 53 | return """ 54 | vec3 twirlUVFunc(vec2 _uv_twirlUVFunc, vec2 _pivot_twirlUVFunc, float _amount_twirlUVFunc){ 55 | _uv_twirlUVFunc -= _pivot_twirlUVFunc; 56 | float _angle_twirlUVFunc = atan(_uv_twirlUVFunc.y, _uv_twirlUVFunc.x); 57 | float _radiusTemp_twirlUVFunc = length(_uv_twirlUVFunc); 58 | _angle_twirlUVFunc += _radiusTemp_twirlUVFunc * _amount_twirlUVFunc; 59 | return vec3(_radiusTemp_twirlUVFunc * vec2(cos(_angle_twirlUVFunc), sin(_angle_twirlUVFunc)) + 0.5, 0.0); 60 | } 61 | """ 62 | 63 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 64 | return output_vars[0] + " = twirlUVFunc(%s.xy, %s.xy, %s);" % [input_vars[0], input_vars[2], input_vars[1]] 65 | -------------------------------------------------------------------------------- /addons/shaderV/uv/zoomUV.gd: -------------------------------------------------------------------------------- 1 | tool 2 | extends VisualShaderNodeCustom 3 | class_name VisualShaderNodeUVzoom 4 | 5 | func _get_name() -> String: 6 | return "ZoomUV" 7 | 8 | func _get_category() -> String: 9 | return "UV" 10 | 11 | #func _get_subcategory(): 12 | # return "" 13 | 14 | func _get_description() -> String: 15 | return "Zoom UV relative to pivot point" 16 | 17 | func _get_return_icon_type() -> int: 18 | return VisualShaderNode.PORT_TYPE_VECTOR 19 | 20 | func _get_input_port_count() -> int: 21 | return 3 22 | 23 | func _get_input_port_name(port: int): 24 | match port: 25 | 0: 26 | return "uv" 27 | 1: 28 | return "factor" 29 | 2: 30 | return "pivot" 31 | 32 | func _get_input_port_type(port: int): 33 | set_input_port_default_value(1, 1.0) 34 | set_input_port_default_value(2, Vector3(0.5, 0.5, 0)) 35 | match port: 36 | 0: 37 | return VisualShaderNode.PORT_TYPE_VECTOR 38 | 1: 39 | return VisualShaderNode.PORT_TYPE_SCALAR 40 | 2: 41 | return VisualShaderNode.PORT_TYPE_VECTOR 42 | 43 | func _get_output_port_count() -> int: 44 | return 1 45 | 46 | func _get_output_port_name(port: int) -> String: 47 | return "uv" 48 | 49 | func _get_output_port_type(port: int) -> int: 50 | return VisualShaderNode.PORT_TYPE_VECTOR 51 | 52 | func _get_code(input_vars: Array, output_vars: Array, mode: int, type: int) -> String: 53 | return output_vars[0] + " = (%s - %s) * %s + %s;" % [input_vars[0], input_vars[2], input_vars[1], input_vars[2]] 54 | -------------------------------------------------------------------------------- /default_env.tres: -------------------------------------------------------------------------------- 1 | [gd_resource type="Environment" load_steps=2 format=2] 2 | 3 | [sub_resource type="ProceduralSky" id=1] 4 | 5 | [resource] 6 | background_mode = 2 7 | background_sky = SubResource( 1 ) 8 | -------------------------------------------------------------------------------- /icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/icon.png -------------------------------------------------------------------------------- /icon.png.import: -------------------------------------------------------------------------------- 1 | [remap] 2 | 3 | importer="texture" 4 | type="StreamTexture" 5 | path.s3tc="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.s3tc.stex" 6 | path.etc2="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.etc2.stex" 7 | metadata={ 8 | "imported_formats": [ "s3tc", "etc2" ], 9 | "vram_texture": true 10 | } 11 | 12 | [deps] 13 | 14 | source_file="res://icon.png" 15 | dest_files=[ "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.s3tc.stex", "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.etc2.stex" ] 16 | 17 | [params] 18 | 19 | compress/mode=2 20 | compress/lossy_quality=0.7 21 | compress/hdr_mode=0 22 | compress/bptc_ldr=0 23 | compress/normal_map=0 24 | flags/repeat=true 25 | flags/filter=true 26 | flags/mipmaps=true 27 | flags/anisotropic=false 28 | flags/srgb=2 29 | process/fix_alpha_border=true 30 | process/premult_alpha=false 31 | process/HDR_as_SRGB=false 32 | process/invert_color=false 33 | stream=false 34 | size_limit=0 35 | detect_3d=false 36 | svg/scale=1.0 37 | -------------------------------------------------------------------------------- /icon2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Norrox/GodotShaders/822f3e082c3b8766dc20b1a82c3dab2aa2d63b71/icon2.png -------------------------------------------------------------------------------- /icon2.png.import: -------------------------------------------------------------------------------- 1 | [remap] 2 | 3 | importer="texture" 4 | type="StreamTexture" 5 | path="res://.import/icon2.png-2294dfe885793d4711fc20bee13a3760.stex" 6 | metadata={ 7 | "vram_texture": false 8 | } 9 | 10 | [deps] 11 | 12 | source_file="res://icon2.png" 13 | dest_files=[ "res://.import/icon2.png-2294dfe885793d4711fc20bee13a3760.stex" ] 14 | 15 | [params] 16 | 17 | compress/mode=0 18 | compress/lossy_quality=0.7 19 | compress/hdr_mode=0 20 | compress/bptc_ldr=0 21 | compress/normal_map=0 22 | flags/repeat=0 23 | flags/filter=true 24 | flags/mipmaps=false 25 | flags/anisotropic=false 26 | flags/srgb=2 27 | process/fix_alpha_border=true 28 | process/premult_alpha=false 29 | process/HDR_as_SRGB=false 30 | process/invert_color=false 31 | stream=false 32 | size_limit=0 33 | detect_3d=true 34 | svg/scale=1.0 35 | --------------------------------------------------------------------------------